slay
1.0.0
Disposition d'application structurée à toute épreuve pour créer des API et des applications Web dans Node.js.
L'objectif de slay est de fournir le minimum absolu de cohérence dans une application Node.js sans imposer une énorme quantité de conventions aux utilisateurs. L’objectif de cohérence consiste également à encourager la modularité du code au niveau de l’application pour une réutilisation maximale. Ceci est accompli grâce à trois fonctionnalités simples : la présentation de l'application, les "pré-démarrages" et un démarrage cohérent de l'application.
Par convention, slay recherche les modules définis par l'utilisateur aux emplacements suivants :
lib/preboots
lib/middlewares
lib/routes
Cela se fait à l'aide du chargement de module Node.js standard intégré, ce qui signifie que chacun d'entre eux peut être des fichiers individuels du même nom au lieu de dossiers. N'hésitez pas à mélanger et assortir à mesure que la complexité de votre application augmente. par exemple :
lib/preboots/index.js
lib/middlewares.js
lib/routes/index.js
"Un preboot est un middleware pour l'extensibilité des applications"
Autrement dit, au lieu de function (req, res, next) un pré-démarrage est function (app, options, done) . En appliquant une signature de fonction cohérente à l'extensibilité des applications, tous les problèmes d'ordre requis deviennent triviaux. Par exemple:
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 ) ;
} ;Même si cela peut paraître trop évident, cela a plusieurs conséquences :
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' ) ` ) ;
} ) ; L’appel de app.start ci-dessus déclenchera deux intercepteurs principaux :
"setup" ./preboots sera chargé dans app.before('setup')routersapp.perform('routers') déclenché dans app.before('setup')app.router sera disponible par app.after('routers') ou par app.perform('setup')"start"lib/routes sera chargé dans app.before('start')lib/routes/index.js doit appeler app.perform('actions') une fois pour s'assurer que toutes les routes de app.router sont chargées dans l'application.lib/middlewares sera chargé before('start')Pour plus d'informations, consultez
App.Bootstrap
L' App exposée par slay possède toutes les fonctionnalités exposées par une app créée par Express avec :
| Méthode | Description | Hérité de |
|---|---|---|
App.bootstrap | Flux d'amorçage de destruction slay noyau | slay.App |
app.hookable | Définit une action hookable | slay.App |
app.stack | Définit une pile middleware | slay.App |
app.config | Chargement de la configuration via nconf | pré-démarrage config |
app.log | Enregistreur défini via winston | pré-démarrage de logger |
app.routes | Routeur express de haut niveau | pré-démarrage routers |
app.preboot | Planifier un pré-démarrage | broadway |
app.mixin | Ajouter des fonctionnalités dans l'application | broadway |
app.start | Démarrer l'application | broadway |
app.close | Arrêtez l'application | broadway |
app.perform | Exécuter un intercepteur nommé | understudy |
app.before | Exécuter avant un intercepteur nommé | understudy |
app.after | Exécuter après un intercepteur nommé | understudy |
| Nom | Description | Invoqué par |
|---|---|---|
setup | Configuration du bootstrap avant le démarrage | slay |
start | Démarrage de l'application principale | slay |
routers | Définition de app.routes | slay |
actions | Fonctionnalité d'application du chemin critique | Utilisateur |
Une Stack est un conteneur léger pour un ensemble de middlewares before et after . Cela devient très utile lorsque vous disposez potentiellement de plusieurs routeurs dans votre application. Une Stack peut être définie à l'aide de app.stack comme suit :
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.
} )
) ;
} ; Toutes les instances Stack créées en appelant app.stack seront exposées sur l'objet app.stacks .
app.start([options], callback); est invoqué.app.perform('setup') s'exécute before les intercepteurs "setup" (voir : intercepteurs de doublure). Cela exécute les pré-démarrages slay intégrés qui :app.config (une instance de nconf.Provider ).app.log (une instance de winston.Logger ).lib/preboots[.js]? ). Cela permet des pré-démarrages arbitraires définis par l'utilisateur pour une extensibilité de manière synchronisée ou asynchrone.lib/middlewares[.js]? ).lib/routes[.js]? ).after "setup" sont invoqués. (voir : intercepteurs de doublure). slay n'exécute rien par défaut ici.app.perform('start') s'exécute before les intercepteurs "start" (voir : intercepteurs de doublure). Cela exécute les pré-démarrages slay intégrés qui :app.perform('routers') qui s'exécute before les intercepteurs "routeurs", ajoute app.routes et s'exécute after les intercepteurs "routeurs".lib/preboots[.js]? ). prévu au (2) ci-dessus.lib/middlewares[.js]? ) planifiés dans (2) ci-dessus.lib/routes[.js]? ) planifiés dans (2) ci-dessus.app.routes .App.prototype._listen est invoqué, ce qui crée des serveurs http et/ou https .after "start" sont invoqués. (voir : intercepteurs de doublure). slay n'exécute rien par défaut ici.callback de app.start([options], callback); est invoqué. L' app est maintenant démarrée et prête à être utilisée. 
npm test
MIT
