node package manager


(DEPRECIATED) A Rails-inspired Express framework for Node


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.


  • Make GCE ORM agnostic (able to use GCR, sequelize, JugglingDB)

  • Create 'mincer' branch to replace GCP (both?)

  • 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


Command Line


Command Line

### New project

gce new APP_NAME

Generates new app scaffolding.

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

### Launch Server

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

### Generate Controller

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

### Generate Model

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

### Generate Scaffold

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

### Generate Backbone Scaffold

gce [backbone | bb] [scaffold | model] 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

### Generate Backbone View

gce [backbone | bb] view NAME

Generates Backbone view.

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

### Migrate

gce migrate

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

### Version

gce version | v | -v

Gets your version of Grand Central Express.


### Router

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

### Models

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.

### ORM/ActiveRecord

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

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

Models are accessed in controllers: = function(req, res, models) {
    var id = req.param('id');
    models.Person.find(id, function(err, person) {
        if (err) throw err;

### Database Connections

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.

### Asset Pipeline & Client-Side Compiler

See Grand Central Pipeline.