Grand-central-express NPM

DEPRECIATED

Only the following 'spin-offs' are updated:

Grand Central Junction -- a simple Rails-inspired router built on top of Express.
Grand Central Records -- a promise-based Node ORM/ActiveRecord library that can connect to MySQL, Postgres, and SQLite3. Allows chainable, raw or queueable queries.

(OLD) Grand Central Express

A modular Express framework for Node. Integrates the following libraries and features:

Grand Central Junction -- a simple Rails-inspired router built on top of Express.
Grand Central Pipeline -- an asset pipeline designed specifically for javascript concatenation and minimization.
Command-line scaffold generator --
Uses ejs view engine and LESS CSS compiling
Uses Backbone.js for front-end framework
ORM integration with either Grand Central Records, JugglingDB, or Node-ORM.

TODO

Make GCE ORM agnostic (able to use GCR, sequelize, JugglingDB)
Create 'mincer' branch to replace GCP (both?)
- https://github.com/nodeca/mincer
- https://github.com/clarkdave/connect-mincer
Testing for command-line interface
Testing for Express integration
Use glob for getting Models
When creating new app, don't overwrite package.json (extend it with required extras)
Use layouts in views/EJS rendering <%= yield %> (use mincer)
- render views partials within EJS

Documentation

Command Line

Features

Command Line

gce new APP_NAME

Generates new app scaffolding.

# Make sure you're in the project folder already
$ mkdir project
$ cd project
$ gce new project

gce server | s | start | run

Starts Express server on port 3000. Use the -p option to change ports, and the -e option to change environments.

$ gce server
Grand Central Express server listening on port 3000

gce generate controller NAME action action

Generates a controller and associated routes with provided actions.

$ gce generate controller Company about team contact
    create  controller/company.js

gce generate model NAME field:type field:type

Generates a model with provided attributes.

$ gce generate model book title:string author:string
    create  models/Book.js

gce generate scaffold NAME field:type field:type

Generates a model with provided attributes and a RESTful JSON controller. Also generates client-side Backbone model & collection. The actions currently don't include update or destroy. These are coming once the custom ORM is built.

Pass -c to avoid creating Backbone scaffold.

$ gce generate scaffold animal name:string species:string -c
    create  models/Animal.js
    create  controllers/animal.js
    update  routes

gce backbone | bb NAME field:type field:type

Generates Backbone model and collection for given name and fields.

$ gce bb scaffold animal name:string species:string
    create  client/models/Animal.js
    create  client/collections/animalList.js

gce backbone | bb view NAME

Generates Backbone view.

$ gce bb view item
    create  client/views/itemView.js

gce migrate

Not currently functional Migrates and syncs your model schemas to the database. Use the -e option to change database environments.

gce version | v | -v

Gets your version of Grand Central Express.

Features

See Grand Central Junction. Default routes file is /config/routes.js, default controllers path is /controllers.

Defined in the /models folder, with capitalized names like Person.js. The model is defined like so:

var Model = require('grand-central-express').Model;
module.exports = new Model({
    name: "Person",
    schema: {
        name: String,
        email: String,
        admin: Boolean,
        rank: Number
    }
});

Methods, validations and relationships are still in development.

The default ORM is Grand Central Records, but can be quickly changed to JugglingDB or Node-ORM using the following steps:

Change your dependency package.json from 'grand-central-records' to either 'jugglingdb' or 'orm'
In app.js, change...

Models are accessed in controllers:

exports.show = function(req, res, models) {
    var id = req.param('id');
    models.Person.find(id, function(err, person) {
        if (err) throw err;
        res.json(person);
    });
};

Database connections are defined in config/db.json. For whatever database you use, make sure to include the package (mysql, pg, sqlite3) in your dependencies.

{
    "development": {
        "adapter":  "sqlite3",
        "host":     "",
        "database": "db/development.sqlite3",
        "username": "",
        "password": ""
    }
}

The template defaults to using SQLite3 files for both development and production.

See Grand Central Pipeline.