deno.land / x / opine@2.3.4 / src / application.ts
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614// deno-lint-ignore-fileimport { fromFileUrl, resolve, Server } from "../deps.ts";import { methods } from "./methods.ts";import { Router } from "./router/index.ts";import { init } from "./middleware/init.ts";import { query } from "./middleware/query.ts";import { finalHandler } from "./utils/finalHandler.ts";import { compileETag } from "./utils/compileETag.ts";import { compileQueryParser } from "./utils/compileQueryParser.ts";import { compileTrust } from "./utils/compileTrust.ts";import { merge } from "./utils/merge.ts";import { View } from "./view.ts";import { WrappedRequest } from "./request.ts";import type { Application, HTTPOptions, HTTPSOptions, IRoute, NextFunction, Opine, OpineRequest, OpineResponse, PathParams,} from "../src/types.ts";
const create = Object.create;const setPrototypeOf = Object.setPrototypeOf;const slice = Array.prototype.slice;
/** * Variable for trust proxy inheritance * @private */const trustProxyDefaultSymbol = "@@symbol:trust_proxy_default";
/** * Application prototype. * * @public */export const app: Application = {} as Application;
/** * Initialize the server. * * - setup default configuration * - setup default middleware * - setup route reflection methods * * @private */app.init = function init(): void { this.cache = {}; this.engines = {}; this.settings = {};
this.defaultConfiguration();};
/** * Initialize application configuration. * @private */app.defaultConfiguration = function defaultConfiguration(): void { this.enable("x-powered-by"); this.set("etag", "weak"); this.set("query parser", "extended"); this.set("subdomain offset", 2); this.set("trust proxy", false);
// trust proxy inherit Object.defineProperty(this.settings, trustProxyDefaultSymbol, { configurable: true, value: true, });
const self: Opine = this as Opine; this.on("mount", function onmount(parent: Opine) { // inherit trust proxy if ( self.settings[trustProxyDefaultSymbol] === true && typeof parent.settings["trust proxy fn"] === "function" ) { delete self.settings["trust proxy"]; delete self.settings["trust proxy fn"]; }
// inherit prototypes setPrototypeOf(self.request, parent.request); setPrototypeOf(self.response, parent.response); setPrototypeOf(self.engines, parent.engines); setPrototypeOf(self.settings, parent.settings); });
// setup locals this.locals = create(null);
// top-most app is mounted at / this.mountpath = "/";
// default locals this.locals.settings = this.settings;
// default configuration this.set("view", View); this.set("views", resolve("views")); this.set("jsonp callback name", "callback"); this.enable("view cache");};
/** * Lazily adds the base router if it has not yet been added. * * We cannot add the base router in the defaultConfiguration because * it reads app settings which might be set after that has run. * * @private */app.lazyrouter = function lazyrouter(): void { if (!this._router) { this._router = new Router({ caseSensitive: this.enabled("case sensitive routing"), strict: this.enabled("strict routing"), });
this._router.use(query(this.get("query parser fn"))); this._router.use(init(this as Opine)); }};
/** * Dispatch a req, res pair into the application. Starts pipeline processing. * * If no callback is provided, then default error handlers will respond * in the event of an error bubbling through the stack. * * @private */app.handle = function handle( req: OpineRequest, res: OpineResponse, next: NextFunction,): void { const router = this._router;
next = next || finalHandler(req, res);
if (!router) { return next(); }
router.handle(req, res, next);};
const isPath = (thing: unknown): thing is string | RegExp => typeof thing === "string" || thing instanceof RegExp;
/** * Proxy `Router#use()` to add middleware to the app router. * See Router#use() documentation for details. * * If the _fn_ parameter is an opine app, then it will be * mounted at the _route_ specified. * * @returns {Application} for chaining * @public */app.use = function use(...args: any[]): Application { const firstArg = args[0]; const [path, ...nonPathArgs] = (Array.isArray(firstArg) ? isPath(firstArg[0]) : isPath(firstArg)) ? args : ["/", ...args]; const fns = nonPathArgs.flat(Infinity);
if (fns.length === 0) { throw new TypeError("app.use() requires a middleware function"); }
// setup router this.lazyrouter(); const router = this._router;
fns.forEach(function (this: Application, fn: any) { // non-opine app if (!fn || !fn.handle || !fn.set) { return router.use(path, fn); }
fn.mountpath = path; fn.parent = this;
router.use( path, function mounted_app( req: OpineRequest, res: OpineResponse, next: NextFunction, ): void { const orig = req.app as Opine;
fn.handle(req, res, (err?: Error) => { setPrototypeOf(req, orig.request); setPrototypeOf(res, orig.response); next(err); }); }, );
// mounted an app fn.emit("mount", this); }, this);
return this;};
/** * Proxy to the app `Router#route()` * Returns a new `Route` instance for the _path_. * * Routes are isolated middleware stacks for specific paths. * See the Route api docs for details. * * @param {PathParams} prefix * @returns {Route} * @public */app.route = function route(prefix: PathParams): IRoute { this.lazyrouter(); return this._router.route(prefix);};
/** * Register the given template engine callback `fn` for the * provided extension `ext`. * * @param {string} ext * @param {Function} fn * @return {Application} for chaining * @public */app.engine = function engine(ext: string, fn: Function) { const extension = ext[0] !== "." ? `.${ext}` : ext; this.engines[extension] = fn;
return this;};
/** * Proxy to `Router#param()` with one added api feature. The _name_ parameter * can be an array of names. * * See the Router#param() docs for more details. * * @param {String|Array} name * @param {Function} fn * @return {app} for chaining * @public */
app.param = function param(name, fn) { this.lazyrouter(); if (Array.isArray(name)) { for (var i = 0; i < name.length; i++) { this.param(name[i], fn); } return this; } this._router.param(name, fn); return this;};
/** * Assign `setting` to `val`, or return `setting`'s value. * * app.set('foo', 'bar'); * app.set('foo'); * // => "bar" * * Mounted servers inherit their parent server's settings. * * @param {string} setting * @param {any} value * @return {Application} for chaining * @public */app.set = function set(setting: string, value?: any): Application { if (arguments.length === 1) { // app.get(setting) return this.settings[setting]; }
this.settings[setting] = value;
// trigger matched settings switch (setting) { case "etag": this.set("etag fn", compileETag(value)); break; case "query parser": this.set("query parser fn", compileQueryParser(value)); break; case "trust proxy": this.set("trust proxy fn", compileTrust(value));
// trust proxy inherit Object.defineProperty(this.settings, trustProxyDefaultSymbol, { configurable: true, value: false, });
break; }
return this;};
/** * Return the app's absolute pathname * based on the parent(s) that have * mounted it. * * For example if the application was * mounted as "/admin", which itself * was mounted as "/blog" then the * return value would be "/blog/admin". * * @return {string} * @private */app.path = function path(): string { return this.parent ? this.parent.path() + this.mountpath : "";};
/** * Check if `setting` is enabled (truthy). * * app.enabled('foo') * // => false * * app.enable('foo') * app.enabled('foo') * // => true * * @param {string} setting * @return {boolean} * @public */app.enabled = function enabled(setting: string): boolean { return Boolean(this.set(setting));};
/** * Check if `setting` is disabled. * * app.disabled('foo') * // => true * * app.enable('foo') * app.disabled('foo') * // => false * * @param {string} setting * @return {boolean} * @public */app.disabled = function disabled(setting: string): boolean { return !this.set(setting);};
/** * Enable `setting`. * * @param {string} setting * @return {Application} for chaining * @public */app.enable = function enable(setting: string): Application { return this.set(setting, true);};
/** * Disable `setting`. * * @param {string} setting * @return {Application} for chaining * @public */app.disable = function disable(setting: string): Application { return this.set(setting, false);};
/** * Delegate `.VERB(...)` calls to `router.VERB(...)`. */methods.forEach((method: string): void => { (app as any)[method] = function (path: string): Application { if (method === "get" && arguments.length === 1) { // app.get(setting) return this.set(path); }
this.lazyrouter();
const route = this._router.route(path); route[method].apply(route, slice.call(arguments, 1));
return this; };});
/** * Special-cased "all" method, applying the given route `path`, * middleware, and callback to _every_ HTTP method. * * @return {Application} for chaining * @public */app.all = function all(path: PathParams): Application { this.lazyrouter();
const route = this._router.route(path); const args = slice.call(arguments, 1);
for (let i = 0; i < methods.length; i++) { (route as any)[methods[i]].apply(route, args); }
return this;};
/** * Try rendering a view. * @private */async function tryRender(view: any, options: any, callback: Function) { try { await view.render(options, callback); } catch (err) { callback(err); }}
/** * Render the given view `name` name with `options` * and a callback accepting an error and the * rendered template string. * * Example: * * app.render('email', { name: 'Deno' }, function(err, html) { * // ... * }) * * @param {string} name * @param {Object|Function} options or callback * @param {Function} callback * @public */app.render = async function render( name: string, options: any, callback: Function = () => {},) { const cache = this.cache; const engines = this.engines; const renderOptions: any = {}; let done = callback; let view;
name = name.startsWith("file:") ? fromFileUrl(name) : name;
// support callback function as second arg if (typeof options === "function") { done = options; options = {}; }
// merge app.locals merge(renderOptions, this.locals);
// merge options._locals if (options._locals) { merge(renderOptions, options._locals); }
// merge options merge(renderOptions, options);
// set .cache unless explicitly provided if (renderOptions.cache == null) { renderOptions.cache = this.enabled("view cache"); }
// primed cache if (renderOptions.cache) { view = cache[name]; }
// view if (!view) { const View = this.get("view");
try { view = new View(name, { defaultEngine: this.get("view engine"), engines, root: this.get("views"), }); } catch (e) { return done(e); }
if (!await view.pathPromise) { const dirs = Array.isArray(view.root) && view.root.length > 1 ? `directories "${view.root.slice(0, -1).join('", "')}" or "${ view.root[view.root.length - 1] }"` : `directory "${view.root}"`;
const err = new Error( `Failed to lookup view "${name}" in views ${dirs}`, );
(err as any).view = view;
return done(err); }
// prime the cache if (renderOptions.cache) { cache[name] = view; } }
// render await tryRender(view, renderOptions, done);};
const isTlsOptions = ( options?: number | string | HTTPOptions | HTTPSOptions,): options is HTTPSOptions => options !== null && typeof options === "object" && "certFile" in options && "keyFile" in options;
/** * Listen for connections. * * @param {number|string|HTTPOptions|HTTPSOptions} options * @returns {Server} Configured Deno server * @public */app.listen = function listen( options?: number | string | HTTPOptions | HTTPSOptions, callback?: () => void,): Server { let port = 0; let hostname = "";
if (typeof options === "number") { port = options; } else if (typeof options === "string") { const addr = options.split(":"); hostname = addr[0]; port = parseInt(addr[1]); } else { hostname = options?.hostname ?? ""; port = options?.port ?? 0; }
const isTls = isTlsOptions(options);
const server = new Server({ port, hostname, handler: async (request, connInfo) => { const opineRequest = new WrappedRequest(request, connInfo); this(opineRequest);
return await opineRequest.finalResponse; }, });
const start = async () => { while (!server.closed) { try { if (isTls) { await server.listenAndServeTls(options.certFile, options.keyFile); } else { await server.listenAndServe(); } } catch (e) { // Ignore closed connections / servers if ( !(e instanceof Deno.errors.BadResource || e instanceof Deno.errors.BrokenPipe) ) { this.emit("error", e); } } } };
start();
if (callback && typeof callback === "function") { callback(); }
return server;};
opine
Version Info
a year ago
