slay
1.0.0
Grundsolides strukturiertes Anwendungslayout zum Erstellen von APIs und Web-Apps in Node.js.
Das Ziel von slay besteht darin, das absolute Minimum an Konsistenz in einer Node.js-Anwendung bereitzustellen, ohne den Benutzern ein enormes Maß an Konventionen aufzuzwingen. Das Konsistenzziel konzentriert sich auch auf die Förderung der Modularität im Code auf Anwendungsebene für eine maximale Wiederverwendung. Dies wird durch drei einfache Funktionen erreicht: Anwendungslayout, „Preboots“ und ein konsistenter Anwendungsstart.
Konventionell sucht slay an den folgenden Orten nach benutzerdefinierten Modulen:
lib/preboots
lib/middlewares
lib/routes
Dies erfolgt mithilfe des standardmäßigen, integrierten Node.js-Modulladens, was bedeutet, dass es sich dabei jeweils um einzelne Dateien mit demselben Namen anstelle von Ordnern handeln kann. Sie können die Lösung beliebig kombinieren, wenn die Komplexität Ihrer Anwendung zunimmt. z.B:
lib/preboots/index.js
lib/middlewares.js
lib/routes/index.js
„Ein Preboot ist eine Middleware zur Anwendungserweiterbarkeit“
Das heißt, anstelle function (req, res, next) ist ein Preboot function (app, options, done) . Durch die Durchsetzung einer konsistenten Funktionssignatur zur Anwendungserweiterbarkeit werden alle Reihenfolgeprobleme trivial. Zum Beispiel:
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 ) ;
} ;Obwohl dies zu offensichtlich erscheint, bewirkt es mehrere Dinge:
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' ) ` ) ;
} ) ; Der obige Aufruf app.start löst zwei Hauptabfangjäger aus:
"setup" -Abfangjäger./preboots wird in app.before('setup') geladen.routersapp.perform('routers') ausgelöst in app.before('setup')app.router wird über app.after('routers') oder über app.perform('setup') verfügbar sein."start"lib/routes wird in app.before('start') geladenlib/routes/index.js sollte app.perform('actions') einmal aufrufen, um sicherzustellen, dass alle Routen von app.router in die App geladen werden.lib/middlewares wird before('start') geladenWeitere Informationen finden Sie unter
App.Bootstrap
Die von slay bereitgestellte App verfügt über alle Funktionen, die von einer von Express erstellten app bereitgestellt werden, sowie über:
| Verfahren | Beschreibung | Geerbt von |
|---|---|---|
App.bootstrap | Core- slay -Bootstrap-Flow | slay.App |
app.hookable | Definiert eine einhängbare Aktion | slay.App |
app.stack | Definiert einen Middleware-Stack | slay.App |
app.config | Konfiguration wird über nconf geladen | config vor dem Booten |
app.log | Logger durch winston definiert | logger -Preboot |
app.routes | express -Router der obersten Ebene | routers vor dem Booten |
app.preboot | Planen Sie einen Preboot | broadway |
app.mixin | Fügen Sie der App Funktionen hinzu | broadway |
app.start | Starten Sie die Anwendung | broadway |
app.close | Beenden Sie die Anwendung | broadway |
app.perform | Führen Sie einen benannten Abfangjäger aus | understudy |
app.before | Vor einem benannten Abfangjäger ausführen | understudy |
app.after | Nach einem benannten Abfangjäger ausführen | understudy |
| Name | Beschreibung | Aufgerufen von |
|---|---|---|
setup | Bootstrap-Setup vor dem Start | slay |
start | Start der Hauptanwendung | slay |
routers | Definition von app.routes | slay |
actions | Anwendungsfunktionalität für kritische Pfade | Benutzer |
Ein Stack ist ein leichter Container für eine Reihe von before und after -Middlewares. Dies ist sehr nützlich, wenn Ihre Anwendung möglicherweise mehrere Router enthält. Ein Stack kann mit app.stack wie folgt definiert werden:
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.
} )
) ;
} ; Alle durch den Aufruf von app.stack erstellten Stack Instanzen werden im app.stacks -Objekt verfügbar gemacht.
app.start([options], callback); aufgerufen wird.app.perform('setup') wird before „setup“ -Interceptoren ausgeführt (siehe: Understudy-Interceptors). Dadurch werden die integrierten slay Preboots ausgeführt, die:app.config (eine Instanz von nconf.Provider ).app.log (eine Instanz von winston.Logger ).lib/preboots[.js]? ). Dies ermöglicht beliebige benutzerdefinierte Preboots zur Erweiterbarkeit auf synchrone oder asynchrone Weise.lib/middlewares[.js]? ).lib/routes[.js]? ).after „setup“ werden aufgerufen. (siehe: Zweitbesetzungs-Abfangjäger). slay führt hier standardmäßig nichts aus.app.perform('start') wird before „Start“ -Interceptoren ausgeführt (siehe: Zweitstudierende Interceptoren). Dadurch werden die integrierten slay Preboots ausgeführt, die:app.perform('routers') auf, das before „routers“-Interceptoren ausgeführt wird, app.routes hinzufügt und after „routers“-Interceptoren ausgeführt wird.lib/preboots[.js]? ). in (2) oben vorgesehen.lib/middlewares[.js]? ) auf , die in (2) oben geplant sind.lib/routes[.js]? ) auf, die in (2) oben geplant sind.app.routes hinzu.App.prototype._listen wird aufgerufen, wodurch alle http und/oder https Server erstellt werden.after „Start“ werden aufgerufen. (siehe: Zweitbesetzungs-Abfangjäger). slay führt hier standardmäßig nichts aus.callback von app.start([options], callback); aufgerufen wird. Die app ist nun gestartet und einsatzbereit. 
npm test
MIT
