slay
1.0.0
Diseño de aplicación estructurado y sólido para crear API y aplicaciones web en Node.js.
El objetivo de slay es proporcionar la cantidad mínima absoluta de coherencia en una aplicación Node.js sin imponer una enorme cantidad de convenciones a los usuarios. El objetivo de coherencia también se centra en fomentar la modularidad en el código a nivel de aplicación para una máxima reutilización. Esto se logra a través de tres características simples: diseño de la aplicación, "inicio previo" y un inicio consistente de la aplicación.
Por convención, slay busca módulos definidos por el usuario en las siguientes ubicaciones:
lib/preboots
lib/middlewares
lib/routes
Esto se hace mediante la carga del módulo estándar integrado de Node.js, lo que significa que cada uno de ellos podría ser archivos individuales con el mismo nombre en lugar de carpetas. Siéntase libre de mezclar y combinar a medida que crece la complejidad de su aplicación. p.ej:
lib/preboots/index.js
lib/middlewares.js
lib/routes/index.js
"Un prearranque es un middleware para la extensibilidad de las aplicaciones"
Es decir, en lugar de function (req, res, next) un prearranque es function (app, options, done) . Al imponer una firma de función consistente para la extensibilidad de la aplicación, todos los problemas de ordenamiento se vuelven triviales. Por ejemplo:
lib/preboots/index.js
module . exports = function ( app , options , done ) {
//
// **SCHEDULE** the attachment and initialization of
// connections to our models.
//
app . preboot ( require ( './models' ) ) ;
done ( ) ;
} ;lib/preboots/models.js
module . exports = function ( app , options , next ) {
//
// Attach all of the models for our API / microservices
// to the app itself and connect to them
// (e.g. initialize TCP sockets, etc).
//
app . models = require ( '../models' ) ;
app . models . connect ( next ) ;
} ;Si bien esto puede parecer demasiado obvio, logra varias cosas:
lib/preboots/index.js . const slay = require ( 'slay' ) ;
const app = new slay . App ( __dirname ) ;
app . start ( options , function ( err ) {
if ( err ) { throw err ; }
app . log . info ( `Listening on ${ app . config . get ( 'http' ) ` ) ;
} ) ; Llamar app.start arriba activará dos interceptores principales:
"setup" ./preboots se cargará en app.before('setup')routersapp.perform('routers') activado en app.before('setup')app.router estará disponible mediante app.after('routers') o mediante app.perform('setup')"start"lib/routes se cargará en app.before('start')lib/routes/index.js debe llamar app.perform('actions') una vez para asegurarse de que todas las rutas de app.router estén cargadas en la aplicación.lib/middlewares se cargará before('start')Para obtener más información, consulte
App.Bootstrap
La App expuesta por slay tiene todas las funciones expuestas por una app creada por express junto con:
| Método | Descripción | Heredado de |
|---|---|---|
App.bootstrap | Flujo de arranque de slay de núcleos | slay.App |
app.hookable | Define una acción enganchable | slay.App |
app.stack | Define una pila de middleware | slay.App |
app.config | Carga de configuración a través de nconf | prearranque de config |
app.log | Registrador definido a través de winston | prearranque logger |
app.routes | Enrutador express de primer nivel | prearranque routers |
app.preboot | Programar un arranque previo | broadway |
app.mixin | Agregar funcionalidad a la aplicación | broadway |
app.start | Iniciar la aplicación | broadway |
app.close | Cerrar la aplicación | broadway |
app.perform | Ejecutar un interceptor con nombre | understudy |
app.before | Ejecutar antes de un interceptor nombrado | understudy |
app.after | Ejecutar después de un interceptor con nombre | understudy |
| Nombre | Descripción | Invocado por |
|---|---|---|
setup | Configuración de arranque previa al inicio | slay |
start | Inicio de la aplicación principal | slay |
routers | Definición de rutas de app.routes | slay |
actions | Funcionalidad de la aplicación de ruta crítica | Usuario |
Una Stack es un contenedor liviano para un conjunto de middlewares before y after . Esto resulta muy útil cuando potencialmente tiene varios enrutadores en su aplicación. Una Stack se puede definir usando app.stack de la siguiente manera:
middlewares.js
module . exports = function ( app , options , next ) {
//
// An authorization middleware for different roles
// returns an HTTP middleware function when invoked.
//
var authorize = require ( './authorize' ) ;
//
// Stack middlewares can be declared and used inline
//
app . use (
app . stack ( {
name : 'admin-only' ,
before : [ authorize ( 'admin' ) ]
} ) . middleware ( function ( req , res , next ) {
// Dispatch (req, res) to a router.
} )
) ;
//
// Or extended from a previous declaration and used inline
//
app . use (
app . stacks [ 'designer-only' ]
. before ( authorize ( 'designer' ) )
. middleware ( function ( req , res , next ) {
// Dispatch (req, res) to a router.
} )
) ;
} ; Todas las instancias Stack creadas al invocar app.stack quedarán expuestas en el objeto app.stacks .
app.start([options], callback); es invocado.app.perform('setup') se ejecuta before los interceptores de "configuración" (ver: interceptores suplentes). Esto ejecuta los prearranques slay integrados que:app.config (una instancia de nconf.Provider ).app.log (una instancia de winston.Logger ).lib/preboots[.js]? ). Esto permite arranques previos arbitrarios definidos por el usuario para lograr extensibilidad de forma sincronizada o asíncrona.lib/middlewares[.js]? ).lib/routes[.js]? ).after la "configuración" . (ver: interceptores suplentes). slay no ejecuta nada de forma predeterminada aquí.app.perform('start') se ejecuta before los interceptores de "inicio" (ver: interceptores suplentes). Esto ejecuta los prearranques slay integrados que:app.perform('routers') que se ejecuta before los interceptores de "enrutadores", agrega app.routes y se ejecuta after los interceptores de "enrutadores".lib/preboots[.js]? ). programado en (2) arriba.lib/middlewares[.js]? ) programados en (2) arriba.lib/routes[.js]? ) programadas en (2) arriba.app.routes .App.prototype._listen , lo que crea cualquier servidor http y/o https .after al "inicio" . (ver: interceptores suplentes). slay no ejecuta nada de forma predeterminada aquí.callback de app.start([options], callback); es invocado. La app ahora está iniciada y lista para usar. 
npm test
MIT
