Popular
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353import { MetadataArgsStorage } from "./metadata/metadata.ts";import { HTTPOptions, serve, Server } from "./deps.ts";import { getAction } from "./route/get-action.ts";import { getActionParams } from "./route/get-action-params.ts";import { StaticFilesConfig } from "./models/static-config.ts";import { ViewRenderConfig } from "./models/view-render-config.ts";import { CorsBuilder } from "./middlewares/cors-builder.ts";import { Content } from "./renderer/content.ts";import { RouteMetadata } from "./metadata/route.ts";import { registerAreas } from "./utils/register-areas.ts";import { registerControllers } from "./utils/register-controllers.ts";import { getStaticFile } from "./utils/get-static-file.ts";import { IMiddleware } from "./models/middleware-target.ts";import { TransformConfig, TransformConfigMap,} from "./models/transform-config.ts";
import { HookMetadataArgs } from "./metadata/hook.ts";import { Context } from "./models/context.ts";import { notFoundAction } from "./renderer/not-found.ts";import { AppSettings } from "./models/app-settings.ts";import { getHooksForAction } from "./route/get-hooks.ts";import { HookMethod } from "./models/hook.ts";import { HttpError } from "./http-error/HttpError.ts";import { container as defaultContainer } from "./injection/index.ts";
export type ObjectKeyAny = { [key: string]: any };
const global: ObjectKeyAny = {};
export function getMetadataArgsStorage<TState>(): MetadataArgsStorage<TState> { if (!(global as any).routingControllersMetadataArgsStorage) { (global as any).routingControllersMetadataArgsStorage = new MetadataArgsStorage(); }
return (global as any).routingControllersMetadataArgsStorage;}
export function getViewRenderConfig(): ViewRenderConfig { return (global as any).viewRenderConfig;}
// TODO(irustm): move to hooks function/** * Run hooks function and return true if response is immediately */async function resolveHooks<TState, TPayload>( context: Context<TState>, actionName: HookMethod, hooks?: HookMetadataArgs<TState, TPayload>[],): Promise<boolean> { const resolvedHooks = new Set<HookMetadataArgs<TState, TPayload>>();
if (hasHooks(hooks)) { // @ts-ignore: Object is possibly 'undefined'. for (const hook of hooks) { const action: Function | undefined = (hook as any).instance[actionName];
if (action !== undefined) { await (hook as any).instance[actionName](context, hook.payload);
if (context.response.isImmediately()) { let reverseActionName: HookMethod = actionName === "onCatchAction" ? "onCatchAction" : "onPostAction";
// run reverse resolved hooks await runHooks( context, reverseActionName, Array.from(resolvedHooks).reverse(), );
await context.request.serverRequest.respond( context.response.getMergedResult(), ); return true; } } resolvedHooks.add(hook); } }
return false;}
function hasHooks<TState = any, TPayload = any>( hooks?: HookMetadataArgs<TState, TPayload>[],): boolean { return hooks !== undefined && hooks.length > 0;}
async function runHooks<TState, TPayload>( context: Context<TState>, actionName: HookMethod, hooks: HookMetadataArgs<TState, TPayload>[],) { for (const hook of hooks) { const action: Function | undefined = (hook as any).instance[actionName];
if (action !== undefined) { await (hook as any).instance[actionName](context, hook.payload); } }}
// TODO(irustm): move to hooks functionfunction hasHooksAction<TState, TPayload>( actionName: string, hooks?: HookMetadataArgs<TState, TPayload>[],): boolean { return !!(hooks && hooks.find((hook) => (hook as any).instance[actionName] !== undefined));}
export class App<TState> { private classes: ObjectKeyAny[] = []; private readonly metadata: MetadataArgsStorage<TState>; private routes: RouteMetadata[] = [];
private staticConfig: StaticFilesConfig | undefined = undefined; private viewRenderConfig: ViewRenderConfig | undefined = undefined; private transformConfigMap?: TransformConfigMap | undefined = undefined; private globalErrorHandler?: (ctx: Context<TState>, error: Error) => void;
private server: Server | undefined = undefined;
constructor(settings: AppSettings) { this.metadata = getMetadataArgsStorage();
this.metadata.container = settings.container || defaultContainer;
registerAreas(this.metadata); registerControllers( this.metadata.controllers, this.classes, (route) => this.routes.push(route), settings.logging, );
this.useStatic(settings.staticConfig); this.useViewRender(settings.viewRenderConfig); }
async listen(address: string | HTTPOptions = ":8000"): Promise<Server> { const server: Server = serve(address); this.server = server;
console.log("Server start in", address);
for await (const req of server) { const context = new Context<TState>(req); try { // Get middlewares in request const middlewares = this.metadata.middlewares.filter((m) => m.route.test(context.request.url) );
// Resolve every pre middleware for (const middleware of middlewares) { await middleware.target.onPreRequest(context); }
if (context.response.isNotRespond()) { continue; }
if (context.response.isImmediately()) { req.respond(context.response.getRaw()); continue; }
// try getting static file if ( this.staticConfig && await getStaticFile(context, this.staticConfig) ) { req.respond(context.response.getRaw()); continue; }
const action = getAction( this.routes, context.request.method, context.request.url, );
if (action !== null) { const hooks = getHooksForAction(this.metadata.hooks, action);
// try resolve hooks if ( hasHooks(hooks) && await resolveHooks(context, "onPreAction", hooks) ) { continue; }
// Get arguments in this action const args = await getActionParams( context, action, this.transformConfigMap, );
try { // Get Action result from controller method context.response.result = await action.target[action.action]( ...args, ); } catch (error) { context.response.error = error;
// try resolve hooks if ( hasHooks(hooks) && hasHooksAction("onCatchAction", hooks) && await resolveHooks(context, "onCatchAction", hooks) ) { continue; } else { // Resolve every post middleware if error was not caught for (const middleware of middlewares) { //@ts-ignore await middleware.target.onPostRequest(context); }
if (context.response.isImmediately()) { req.respond(context.response.getMergedResult()); continue; }
throw error; } }
// try resolve hooks if ( hasHooks(hooks) && await resolveHooks(context, "onPostAction", hooks) ) { continue; } }
if (context.response.isImmediately()) { req.respond(context.response.getMergedResult()); continue; }
// Resolve every post middleware for (const middleware of middlewares) { //@ts-ignore await middleware.target.onPostRequest(context); }
if (context.response.isImmediately()) { req.respond(context.response.getMergedResult()); continue; }
if (context.response.result === undefined) { context.response.result = notFoundAction();
req.respond(context.response.getMergedResult()); continue; }
req.respond(context.response.getMergedResult()); } catch (error) { if (this.globalErrorHandler) { this.globalErrorHandler(context, error);
if (context.response.isImmediately()) { req.respond(context.response.getMergedResult()); continue; } }
if (context.response.isImmediately()) { req.respond(context.response.getMergedResult()); continue; }
if (!(error instanceof HttpError)) { console.error(error); }
req.respond(Content(error, error.httpCode || 500)); } }
return server; }
public close(): void { if (this.server) { this.server.close(); } else { console.warn("Server is not listening"); } }
public useStatic(config?: StaticFilesConfig): void { if (config && !this.staticConfig) { this.staticConfig = config; } }
public useViewRender(config?: ViewRenderConfig): void { if (config && !this.viewRenderConfig) { this.viewRenderConfig = config; (global as any).viewRenderConfig = config; } }
public useTransform(transform: TransformConfig): void { if (!this.transformConfigMap) { this.transformConfigMap = new Map(); }
this.transformConfigMap.set(transform.type, transform); }
/** * Deprecate */ public useCors(builder: CorsBuilder<TState>): void { this.metadata.middlewares.push({ type: "middleware", target: builder, route: /\//, }); }
public use(route: RegExp, middleware: IMiddleware<TState>): void { this.metadata.middlewares.push({ type: "middleware", target: middleware, route, }); }
/** * Create one global error handler */ public error( globalErrorHandler: (ctx: Context<TState>, error: Error) => void, ): void { this.globalErrorHandler = globalErrorHandler; }}