README (En Español)

RodeJS

RodeJS es un Framework orientado a paquetes para Express y Mongoose.

##Tabla de contenidos:

• Introducción
• Paquetes
• Modelos
• Modelos con Mongoose
• Controladores
• Middleware en Rutas
• APIs Restful
• Tests
• Sistemas de plantillas

Introducción

Instalar Rode y configurar su aplicación:

# npm install -g rode bower grunt-cli
$ rode generate --sessions --css stylus --ejs myapp

Instalar las dependencias:

$ npm install

Iniciar el servidor:

$ node app

El uso de rode generate es muy similar al de Express

Uso: rode generate [opciones] [dir]

Opciones:

  -h, --help          mostrar información de ayuda (en inglés)
  -V, --version       mostrar el número de versión
  -s, --sessions      añadir soporte para sesiones
  -e, --ejs           añadir soporte para ejs (por defecto se utiliza jade)
  -H, --hogan         añadir soporte para hogan.js
  -S, --soy           añadir soporte para Google Closure Templates
  -c, --css           añadir soporte para stylesheets (less|stylus) (por defecto se utiliza css plano)
  -f, --force         forzar en directorios no vacíos

Paquetes

Un paquete es una estructura dentro de su aplicación con su propio MVC.

Podes crear muy facilmente un nuevo paquete con el comando:

$ rode new:package NombreDelPaquete

Uso: rode new:package <paquete>

Opciones:

  -h, --help   mostar información de ayuda (en inglés)
  -r, --rest   configurar rest dentro del paquete
  -f, --force  forzar en paquetes ya existentes

Models

Los modelos en Rode son modulos realmente extensibles.

var rode = require('rode');

var Modelo = rode.getBaseModel();

var Persona = Modelo.extend({
  name: 'Persona',
  saludar: function () {
    console.log('Hola Modelos!');
  }
});

var Empleado = Persona.extend({
  name: 'Empleado'
});

Empleado.saludar(); // Hola Modelos!

Modelos con Mongoose

En este ejemplo vamos a definir el Modelo Persona con un Esquema:

var rode = require('rode');

var Modelo = rode.getBaseModel();

var Persona = Modelo.extend({
  name: 'Persona',
});
Persona.setSchema({
  nombre: {
    type: 'String',
    unique: true
  },
  edad: {
    type: 'Number',
    default: 0
  }
});

Ahora definimos el Modelo Empleado y su Esquema extendiendo a Persona:

var Empleado = Persona.extend({
  name: 'Empleado'
});
Empleado.setSchema({
  compania: 'String'
});

Creamos algunas personas y empleados:

var juan = new Persona.model({
  nombre: 'Juan',
  edad: 40
});
var mariano = new Empleado.model({
  nombre: 'Mariano Pardo',
  edad: '22',
  compania: 'Codexar'
});

Todavia podemos seguir usando cualquier método provisto por mongoose:

// Guardamos a Juan en Persona
juan.save(function (err) {
  // Guardamos a Mariano en Empleados
  mariano.save(function (err) {
    // Obtener todas las personas (Personas + Empleados)
    Person.getAll(function (err, personas) {
      console.log(personas);
      // Podes acceder al Modelo de Mongoose
      Persona.model.remove({});
    });
  });
});

Recomendamos tener un único archivo por cada modelo.

Controladores

Los controladores y ruteadores trabajan juntos para facilitar el ruteo de la aplicación.

Un ejemplo de controlador para un paquete llamado Principal:

var rode = require('rode');

var HolaControlador = {
  /**
   * Acción saludar
   */
  saludar: function (req, res) {
    res.render('index', {
      title: 'Hola Mundo!'
    });
  }
};

module.exports = HolaControlador;

Y las rutas para ese controlador podrían ser:

var rode = require('rode');

var ruteadorPrincipal = rode.getRouter('Principal');

/**
 * Ruta bace para el paquete (Opcional)
 */
ruteadorPrincipal.setBase('/');

/**
 * Responder a /hola con HolaControlador.saludar
 */
ruteadorPrincipal.add({
  controller: 'Hola', // Por defecto es 'Main'
  pattern: 'hola',
  action: 'saludar',
  method: 'get' // Por defecto el método es 'all' (se responde a cualquier método)
});

Middleware en Rutas

Acá hay un ejemplo de cómo definir un middleware en rutas:

var UsuarioControlador = {
  mostrarInformacionPrivada: [
    function (req, res, next) {
      // Verificar permisos
      next();
    },
    function (req, res) {
      // Mostrar Información Privada
    }
  ],
};

APIs Restful

Crear un API Restful no podría ser más facil. Crear un paquete con el comando:

$ rode new:package NombreDelPaquete --rest

O agregar la opción ruteadorProducto.setRestApi('/api/productos/'); en routes.js

Ahora deberá crear los métodos en el archivo RestController.js siguiendo unas simples convenciones de nombres:

Acá hay algunos ejemplos:

// [GET] /api/productos
get: function (req, res) { ... }

// [POST] /api/productos
post: function (req, res) { ... }

// [GET] /api/productos/patrocinados
getPatrocinados: function (req, res) { ... }

// [PUT] /api/productos/patrocinados
putPatrocinados: function (req, res) { ... }

// [POST] /api/productos/patrocinados/hoy
postPatrocinadosHoy: function (req, res) { ... }

// [GET] /api/productos/:id
getById: function (req, res) { ... }

// [POST] /api/productos/:id
postById: function (req, res) { ... }

// [DELETE] /api/productos/:id
deleteById: function (req, res) { ... }

// [GET] /api/productos/:id/comentarios
getByIdComentarios: function (req, res) { ... }

// [PUT] /api/productos/:id/comentarios/:id2
putByIdComentariosById: function (req, res) { ... }

Podes crear tantas combinaciones como necesites. Recorda que cada paquete puede tener su propio RestController.js

Tests

Podes correr todos los tests con en comando:

$ grunt test

Sistemas de plantillas

Rode soporta todos estos sistemas de plantillas:

• Jade (plantilla por defecto)
• Ejs (usando ejs-locals)
• Hogan.js
• Google Closure Templates
• Ya que usted puede seguir usando express, puede utilizar cualquier otra plantilla que express soporte