slay
1.0.0
Layout de aplicativo estruturado e sólido para criar APIs e aplicativos da web em Node.js.
O objetivo do slay é fornecer o mínimo absoluto de consistência em um aplicativo Node.js sem forçar uma enorme quantidade de convenções aos usuários. O objetivo de consistência também gira em torno do incentivo à modularidade no código em nível de aplicativo para máxima reutilização. Isso é realizado por meio de três recursos simples: layout do aplicativo, "pré-inicializações" e inicialização consistente do aplicativo.
Por convenção, slay procura módulos definidos pelo usuário nos seguintes locais:
lib/preboots
lib/middlewares
lib/routes
Isso é feito usando o carregamento de módulo Node.js integrado padrão, o que significa que cada um deles pode ser arquivos individuais com o mesmo nome em vez de pastas. Sinta-se à vontade para misturar e combinar conforme a complexidade do seu aplicativo aumenta. por exemplo:
lib/preboots/index.js
lib/middlewares.js
lib/routes/index.js
"Uma pré-inicialização é um middleware para extensibilidade de aplicativos"
Ou seja, em vez de function (req, res, next) uma pré-inicialização é function (app, options, done) . Ao impor uma assinatura de função consistente à extensibilidade do aplicativo, todos os problemas de ordenação exigem que se tornem triviais. Por exemplo:
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 ) ;
} ;Embora isso possa parecer muito óbvio, ele faz várias coisas:
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' ) ` ) ;
} ) ; Chamar app.start acima irá acionar dois interceptadores principais:
"setup" ./preboots será carregado em app.before('setup')routersapp.perform('routers') acionado em app.before('setup')app.router estará disponível por app.after('routers') ou por app.perform('setup')"start"lib/routes serão carregados em app.before('start')lib/routes/index.js deve chamar app.perform('actions') uma vez para garantir que todas as rotas de app.router sejam carregadas no aplicativo.lib/middlewares serão carregados before('start')Para obter mais informações, consulte
App.Bootstrap
O App exposto pelo slay possui todas as funcionalidades expostas por um app criado pelo express junto com:
| Método | Descrição | Herdado de |
|---|---|---|
App.bootstrap | Fluxo de bootstrap do Core slay | slay.App |
app.hookable | Define uma ação conectável | slay.App |
app.stack | Define uma pilha de middleware | slay.App |
app.config | Carregamento de configuração através nconf | config de pré-inicialização |
app.log | Logger definido através do winston | pré-inicialização logger |
app.routes | Roteador express de nível superior | pré-inicialização routers |
app.preboot | Agende uma pré-inicialização | broadway |
app.mixin | Adicione funcionalidade ao aplicativo | broadway |
app.start | Inicie o aplicativo | broadway |
app.close | Desligue o aplicativo | broadway |
app.perform | Execute um interceptador nomeado | understudy |
app.before | Executar antes de um interceptador nomeado | understudy |
app.after | Executar após um interceptor nomeado | understudy |
| Nome | Descrição | Invocado por |
|---|---|---|
setup | Configuração de bootstrap pré-inicializada | slay |
start | Inicialização do aplicativo principal | slay |
routers | Definição de app.routes | slay |
actions | Funcionalidade do aplicativo de caminho crítico | Usuário |
Uma Stack é um contêiner leve para um conjunto de middlewares before e after . Isso se torna muito útil quando você tem potencialmente vários roteadores em seu aplicativo. Uma Stack pode ser definida usando app.stack da seguinte forma:
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 as instâncias Stack criadas pela invocação de app.stack serão expostas no objeto app.stacks .
app.start([options], callback); é invocado.app.perform('setup') é executado before dos interceptores de "configuração" (consulte: interceptores substitutos). Isso executa as pré-inicializações slay integradas que:app.config (uma instância de nconf.Provider ).app.log (uma instância de winston.Logger ).lib/preboots[.js]? ). Isso permite pré-inicializações arbitrárias definidas pelo usuário para extensibilidade de forma sincronizada ou assíncrona.lib/middlewares[.js]? ).lib/routes[.js]? ).after "configuração" é invocado. (ver: interceptores substitutos). slay não executa nada por padrão aqui.app.perform('start') é executado before dos interceptores "start" (veja: interceptores substitutos). Isso executa as pré-inicializações slay integradas que:app.perform('routers') que é executado before dos interceptores "roteadores", adiciona app.routes e é executado after os interceptores "roteadores".lib/preboots[.js]? ). programado em (2) acima.lib/middlewares[.js]? ) agendados em (2) acima.lib/routes[.js]? ) agendadas em (2) acima.app.routes .App.prototype._listen é invocado, criando qualquer servidor http e/ou https .after "início" são invocados. (ver: interceptores substitutos). slay não executa nada por padrão aqui.callback de app.start([options], callback); é invocado. O app agora está iniciado e pronto para uso. 
npm test
MIT
