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

• New Project
• Launch Server
• Generate Scaffold
• Generate Controller
• Generate Model
• Generate Backbone Scaffold
• Generate Backbone View
• Migrate
• Version

Features

• Router
• Models
• ORM/ActiveRecord
• Database Connections
• Client-side Compiler

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] [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

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:

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:

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.