@lakutata/entrypoint 3.0.0-beta.0

package/dist/esm/lib/ActionOptions.js

@@ -0,0 +1,63 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+/**
+ * The options of a controller action, the last argument of the action decorators (`@GET`, `@CLIAction`,
+ * `@ServiceAction`, `@Schedule`…).
+ * @example
+ * ```typescript
+ * import {Controller, type HTTPContext} from 'lakutata/com/entrypoint'
+ * import {type ActionOptions} from '@lakutata/entrypoint/channel'
+ * import {GET} from 'lakutata/decorator/ctrl'
+ *
+ * //Only the requests carrying the admin token reach the action
+ * const adminOnly: ActionOptions<HTTPContext> = {
+ *     acl: true,
+ *     name: 'listUsers',
+ *     description: 'List the users',
+ *     groups: ['admin'],
+ *     rule: async (context: HTTPContext): Promise<boolean> => context.request.headers.authorization === 'Bearer admin'
+ * }
+ *
+ * class UserController extends Controller {
+ *     @GET('/users', adminOnly)
+ *     public async list(): Promise<string[]> {
+ *         return []
+ *     }
+ * }
+ * ```
+ */
+export class ActionOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ActionOptions.prototype, "acl", void 0);
+__decorate([
+    Expect(DTO.String().allow('').optional().default('')),
+    __metadata("design:type", String)
+], ActionOptions.prototype, "name", void 0);
+__decorate([
+    Expect(DTO.String().allow('').optional().default('')),
+    __metadata("design:type", String)
+], ActionOptions.prototype, "description", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.String()).optional().default([])),
+    __metadata("design:type", Array)
+], ActionOptions.prototype, "groups", void 0);
+__decorate([
+    Expect(DTO.Function().optional()),
+    __metadata("design:type", Function)
+], ActionOptions.prototype, "rule", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Function()).optional().default([])),
+    __metadata("design:type", Array)
+], ActionOptions.prototype, "middlewares", void 0);

package/dist/esm/lib/ActionResult.js

@@ -0,0 +1,24 @@
+/**
+ * The base of the results an action returns to describe its output beyond its data (a status, headers, a file, an
+ * event stream): {@link StatusResult}, {@link FileResult}, {@link EventsResult}, built with `Result`. The HTTP and CLI
+ * adapters output the results they support, and the `data` of the others; the service adapters (Socket.IO, JSON-RPC,
+ * Electron IPC, the HTTP service, gRPC, NATS) send the `data` of a `StatusResult` and answer a `FileResult` or an
+ * `EventsResult` with an error.
+ * @example
+ * ```typescript
+ * import {ActionResult} from 'lakutata/com/entrypoint'
+ *
+ * //A result carrying a page of items, an adapter of its own may output its paging
+ * export class PageResult<T> extends ActionResult {
+ *     constructor(public readonly items: T[], public readonly next?: string) {
+ *         super()
+ *     }
+ *
+ *     public get data(): T[] {
+ *         return this.items
+ *     }
+ * }
+ * ```
+ */
+export class ActionResult {
+}

package/dist/esm/lib/ApplicationOf.js

@@ -0,0 +1,11 @@
+import { Application } from '@lakutata/core';
+/**
+ * The application a module belongs to (undefined out of an application: a container of the tests)
+ * @param module
+ */
+export function applicationOf(module) {
+    let target = module;
+    while (target && !(target instanceof Application))
+        target = target.getParent?.();
+    return target;
+}

package/dist/esm/lib/Controller.js

@@ -0,0 +1,61 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Provider, DTO } from '@lakutata/core';
+import { Scoped, Configurable } from '@lakutata/core/decorator/di';
+import { BaseContext } from '../context/BaseContext.js';
+/**
+ * The base class of the controllers: classes whose methods, decorated with the action decorators (`@GET`, `@POST`…,
+ * `@CLIAction`, `@ServiceAction`, `@Schedule`), serve the entrypoint's requests. Give the controller classes to the
+ * entrypoint's `controllers` option.
+ *
+ * A controller is scoped: each request creates its own instance in the request's container, with the request's
+ * context and abort signal, and destroys it when the request ends; its injected providers are scoped to the request
+ * too. An action method receives its input (the request's data merged with the address parameters, validated by the
+ * action's DTO, its defaults applied) and returns the result the adapter outputs; the actions declared in a parent
+ * class are served by the registered subclasses.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Controller, HTTPContext} from 'lakutata/com/entrypoint'
+ * import {CLIAction, GET, ServiceAction} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ *
+ * class FindUserDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public id: string
+ * }
+ *
+ * class UserController extends Controller {
+ *     //The same action over HTTP (GET /users/:id), the CLI (user-get --id 1) and the services ({act: 'user.get', id})
+ *     @GET('/users/:id', FindUserDTO)
+ *     @CLIAction('user-get', FindUserDTO)
+ *     @ServiceAction({act: 'user.get'}, FindUserDTO)
+ *     public async get(input: FindUserDTO): Promise<{id: string, via: string}> {
+ *         this.signal?.throwIfAborted()
+ *         const via: string = this.context instanceof HTTPContext ? this.context.request.headers['user-agent'] ?? 'http' : this.context.type
+ *         return {id: input.id, via: via}
+ *     }
+ * }
+ * ```
+ */
+let Controller = class Controller extends Provider {
+};
+__decorate([
+    Configurable(DTO.InstanceOf(BaseContext).required()),
+    __metadata("design:type", Object)
+], Controller.prototype, "context", void 0);
+__decorate([
+    Configurable(DTO.InstanceOf(AbortSignal).optional()),
+    __metadata("design:type", AbortSignal)
+], Controller.prototype, "signal", void 0);
+Controller = __decorate([
+    Scoped(true)
+], Controller);
+export { Controller };

package/dist/esm/lib/ControllerEntrypoint.js

@@ -0,0 +1,229 @@
+import { objectConstructor, As, objectParentConstructors, objectHash, getObjectNestingDepth, UUID } from '@lakutata/utils';
+import { InvalidActionPatternDepthException } from '@lakutata/core';
+import { validateMiddlewares } from './Middleware.js';
+import { getPrefix } from './Prefix.js';
+import { getChannel } from '../channel/Channel.js';
+import { CLIChannel, HTTPChannel, ServiceChannel } from '../channel/BuiltinChannels.js';
+//The channels of the actions declared by a controller class
+const CONTROLLER_CHANNELS = Symbol('CONTROLLER.CHANNELS');
+//The actions of the controllers bound to an entrypoint, by channel
+const COMPONENT_CTRL_MAP = Symbol('COMPONENT.CTRL.MAP');
+/**
+ * The metadata key of the actions of a channel
+ * @param channel
+ */
+function channelActionsKey(channel) {
+    return `ENTRYPOINT.CHANNEL.ACTIONS.${channel}`;
+}
+/**
+ * Get action info
+ * @param controllerPrototype
+ * @param propertyKey
+ * @param actionOptions
+ * @param extra
+ */
+function getActionInfo(controllerPrototype, propertyKey, actionOptions, extra) {
+    const action = `${As(objectConstructor(controllerPrototype)).className}:${String(propertyKey)}`;
+    const id = UUID.v5(`${action}:${extra}`, UUID.NIL);
+    const name = actionOptions.name ? actionOptions.name : action;
+    const description = actionOptions.description ? actionOptions.description : '';
+    return {
+        id: id,
+        acl: !!actionOptions.acl,
+        action: action,
+        name: name,
+        description: description,
+        groups: actionOptions.groups ? actionOptions.groups : [],
+        rule: actionOptions.rule
+    };
+}
+/**
+ * Validate action pattern definition
+ * @param actionPattern
+ */
+function validateActionPatternDefinition(actionPattern) {
+    const depth = getObjectNestingDepth(actionPattern);
+    if (depth > 2)
+        throw new InvalidActionPatternDepthException('The maximum nesting depth of ActionPattern objects cannot be greater than 2 levels. The current nesting depth of the object is {0} levels', [depth]);
+    return actionPattern;
+}
+/**
+ * Get controller's internal action pattern map of a channel
+ * @param channel
+ * @param target
+ * @constructor
+ */
+function getInternalControllerActionPatternMap(channel, target) {
+    const key = channelActionsKey(channel);
+    const internalActionPatternMap = new Map();
+    //From the farthest parent: the closest declaration of an action wins
+    objectParentConstructors(target).reverse().forEach(parentConstructor => {
+        const parentActionPatternMap = Reflect.getOwnMetadata(key, parentConstructor) || new Map();
+        parentActionPatternMap.forEach((value, hash) => internalActionPatternMap.set(hash, value));
+    });
+    As(Reflect.getOwnMetadata(key, target) || new Map()).forEach((value, hash) => internalActionPatternMap.set(hash, value));
+    return internalActionPatternMap;
+}
+/**
+ * The channels of the actions of a controller, its parent classes included
+ * @param target
+ */
+export function getControllerChannels(target) {
+    const names = new Set();
+    for (const constructor of [target, ...objectParentConstructors(target)]) {
+        const own = Reflect.getOwnMetadata(CONTROLLER_CHANNELS, constructor);
+        own?.forEach((name) => names.add(name));
+    }
+    return [...names];
+}
+/**
+ * Register an action of a controller on a channel
+ * @param channel
+ * @param target
+ * @param actionPattern
+ * @param details
+ * @constructor
+ */
+export function registerChannelAction(channel, target, actionPattern, details) {
+    actionPattern = validateActionPatternDefinition(channel.validate ? channel.validate(actionPattern) : actionPattern);
+    const internalActionPatternMap = getInternalControllerActionPatternMap(channel.name, target);
+    internalActionPatternMap.set(objectHash(actionPattern), {
+        pattern: actionPattern,
+        details: { ...details, pattern: actionPattern }
+    });
+    Reflect.defineMetadata(channelActionsKey(channel.name), internalActionPatternMap, target);
+    const own = Reflect.getOwnMetadata(CONTROLLER_CHANNELS, target) || new Set();
+    Reflect.defineMetadata(CONTROLLER_CHANNELS, own.add(channel.name), target);
+}
+/**
+ * Register a controller method as an action of a channel, for the decorators of the packages providing a channel
+ * (the built-in `@HTTPAction`, `@CLIAction` and `@ServiceAction` call it). The action is served by the controller class
+ * and its subclasses registered in an entrypoint. Registering the same address again for the class replaces the
+ * previous action.
+ * @param channel The channel's definition (see {@link defineChannel}).
+ * @param controllerPrototype The prototype of the controller class (the decorator's target).
+ * @param propertyKey The name of the method running the action.
+ * @param actionPattern The action's address, checked by the channel's `validate`; at most 2 levels of nesting.
+ * @param dtoConstructor The DTO validating the action's input (`FlexibleDTO` to accept any input).
+ * @param actionOptions The action's options (name, description, groups, access control, middlewares); give them
+ * validated (as {@link getActionDTOAndOptions} returns them).
+ * @throws {InvalidActionPatternDepthException} When the address is nested more than 2 levels deep.
+ * @throws {InvalidMiddlewareException} When a middleware of the options is neither a function nor a `Middleware` subclass.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Controller, type ControllerProperty} from 'lakutata/com/entrypoint'
+ * import {getActionDTOAndOptions, getChannel, registerControllerAction, type ActionOptions} from '@lakutata/entrypoint/channel'
+ *
+ * //A decorator declaring the actions of a "queue" channel defined by its package
+ * export function OnMessage(topic: string, dtoOrOptions?: typeof DTO | ActionOptions<any>, options?: ActionOptions<any>) {
+ *     return <ClassPrototype extends Controller>(target: ClassPrototype, propertyKey: ControllerProperty<ClassPrototype>): void => {
+ *         const [dtoConstructor, actionOptions] = getActionDTOAndOptions(dtoOrOptions, options)
+ *         registerControllerAction(getChannel('queue'), target, propertyKey, {topic: topic}, dtoConstructor, actionOptions)
+ *     }
+ * }
+ * ```
+ */
+export function registerControllerAction(channel, controllerPrototype, propertyKey, actionPattern, dtoConstructor, actionOptions) {
+    const constructor = As(objectConstructor(controllerPrototype));
+    const actionInfo = getActionInfo(controllerPrototype, propertyKey, actionOptions, channel.identify(actionPattern));
+    registerChannelAction(channel, constructor, actionPattern, {
+        ...actionInfo,
+        pattern: actionPattern,
+        constructor: constructor,
+        method: propertyKey,
+        dtoConstructor: dtoConstructor,
+        jsonSchema: dtoConstructor.toJsonSchema(),
+        middlewares: validateMiddlewares(actionOptions.middlewares ?? []),
+        getActionInfo: () => actionInfo
+    });
+}
+/**
+ * Bind controller to component
+ * @param component
+ * @param controllerConstructor
+ * @constructor
+ */
+export function bindControllerToComponent(component, controllerConstructor) {
+    const totalInternalActionPatternMap = Reflect.getOwnMetadata(COMPONENT_CTRL_MAP, component) || new Map();
+    const prefix = getPrefix(controllerConstructor);
+    //The actions inherited from a parent controller are run by the registered controller
+    const bind = (channel, value) => {
+        const details = { ...value.details, constructor: controllerConstructor };
+        const prefixed = prefix && channel.prefix ? channel.prefix(prefix, value.pattern) : undefined;
+        if (prefixed === undefined)
+            return ['', { pattern: value.pattern, details: details }];
+        const pattern = validateActionPatternDefinition(channel.validate ? channel.validate(prefixed) : prefixed);
+        //A prefixed action is named after the registered controller, so the controllers sharing a parent have distinct actions
+        const action = `${controllerConstructor.className}:${String(details.method)}`;
+        details.name = details.name === details.action ? action : details.name;
+        details.action = action;
+        details.id = UUID.v5(`${action}:${channel.identify(pattern)}`, UUID.NIL);
+        details.pattern = pattern;
+        const actionInfo = { id: details.id, acl: details.acl, action: action, name: details.name, description: details.description, groups: details.groups, rule: details.rule };
+        details.getActionInfo = () => actionInfo;
+        return [objectHash(pattern), { pattern: pattern, details: details }];
+    };
+    for (const name of getControllerChannels(controllerConstructor)) {
+        const channel = getChannel(name);
+        const map = totalInternalActionPatternMap.get(name) ?? new Map();
+        getInternalControllerActionPatternMap(name, controllerConstructor).forEach((value, hash) => {
+            const [prefixedHash, bound] = bind(channel, value);
+            map.set(prefixedHash || hash, bound);
+        });
+        totalInternalActionPatternMap.set(name, map);
+    }
+    Reflect.defineMetadata(COMPONENT_CTRL_MAP, totalInternalActionPatternMap, component);
+}
+/**
+ * Get module controller action map
+ * @constructor
+ * @param component
+ */
+export function getComponentControllerActionMap(component) {
+    const totalInternalActionPatternMap = Reflect.getOwnMetadata(COMPONENT_CTRL_MAP, component) || new Map();
+    const totalActionPatternMap = new Map();
+    totalInternalActionPatternMap.forEach((map, channel) => {
+        const actions = new Map();
+        map.forEach((value) => actions.set(value.pattern, value.details));
+        totalActionPatternMap.set(channel, actions);
+    });
+    return totalActionPatternMap;
+}
+/**
+ * Register http action
+ * @param route
+ * @param methods
+ * @param controllerPrototype
+ * @param propertyKey
+ * @param dtoConstructor
+ * @param actionOptions
+ * @constructor
+ */
+export function registerHTTPAction(route, methods, controllerPrototype, propertyKey, dtoConstructor, actionOptions) {
+    methods.forEach((method) => registerControllerAction(HTTPChannel, controllerPrototype, propertyKey, { route: route, method: method }, dtoConstructor, actionOptions));
+}
+/**
+ * Register cli action
+ * @param command
+ * @param controllerPrototype
+ * @param propertyKey
+ * @param dtoConstructor
+ * @param actionOptions
+ * @constructor
+ */
+export function registerCLIAction(command, controllerPrototype, propertyKey, dtoConstructor, actionOptions) {
+    registerControllerAction(CLIChannel, controllerPrototype, propertyKey, { command: command }, dtoConstructor, actionOptions);
+}
+/**
+ * Register service action
+ * @param pattern
+ * @param controllerPrototype
+ * @param propertyKey
+ * @param dtoConstructor
+ * @param actionOptions
+ * @constructor
+ */
+export function registerServiceAction(pattern, controllerPrototype, propertyKey, dtoConstructor, actionOptions) {
+    registerControllerAction(ServiceChannel, controllerPrototype, propertyKey, pattern, dtoConstructor, actionOptions);
+}

package/dist/esm/lib/GetActionDTOAndOptions.js

@@ -0,0 +1,46 @@
+import { ActionOptions } from './ActionOptions.js';
+import { FlexibleDTO } from '@lakutata/core/dtos';
+/**
+ * Sort out the optional arguments of an action decorator (`(dto?)`, `(options?)` or `(dto, options)`): a function is
+ * the DTO, an object the options. The options are validated, their defaults applied.
+ * @param dtoConstructorOrOptions The DTO validating the action's input, or the action's options.
+ * @param options The action's options, when the first argument is the DTO.
+ * @returns The DTO (`FlexibleDTO`, accepting any input, when none is given) and the validated options.
+ * @throws {Error} When the options are invalid (the validation error of {@link ActionOptions}).
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {FlexibleDTO} from 'lakutata/dtos'
+ * import {Expect} from 'lakutata/decorator/dto'
+ * import {getActionDTOAndOptions} from '@lakutata/entrypoint/channel'
+ *
+ * class SendDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public text: string
+ * }
+ *
+ * const [dto, options] = getActionDTOAndOptions(SendDTO, {name: 'send'})
+ * console.log(dto === SendDTO, options.groups) //true []
+ * const [anyInput] = getActionDTOAndOptions({acl: true})
+ * console.log(anyInput === FlexibleDTO) //true
+ * ```
+ */
+export function getActionDTOAndOptions(dtoConstructorOrOptions, options) {
+    let dtoConstructor = FlexibleDTO;
+    let actionOptions = {};
+    if (options) {
+        //The DTO may be omitted (undefined) before the options
+        if (dtoConstructorOrOptions)
+            dtoConstructor = dtoConstructorOrOptions;
+        actionOptions = options;
+    }
+    else if (dtoConstructorOrOptions) {
+        if (dtoConstructorOrOptions.constructor.name.toUpperCase() === 'FUNCTION') {
+            dtoConstructor = dtoConstructorOrOptions;
+        }
+        else {
+            actionOptions = dtoConstructorOrOptions;
+        }
+    }
+    return [dtoConstructor, ActionOptions.validate(actionOptions)];
+}

package/dist/esm/lib/HTTPErrors.js

@@ -0,0 +1,48 @@
+/**
+ * Find the HTTP status of an error, read from its `statusCode` or `status`: the first client error (4xx) found on the
+ * error or along its `cause` chain, else the error's own status when it is between 400 and 599, else 500. A validation
+ * failure, wrapped in an exception whose cause is the 400 validation error, thus gives 400.
+ * @param error The error, any value.
+ * @returns The HTTP status, from 400 to 599.
+ * @example
+ * ```typescript
+ * import {statusOfError} from 'lakutata/adapter/express'
+ *
+ * class NotFound extends Error {
+ *     public readonly statusCode: number = 404
+ * }
+ *
+ * console.log(statusOfError(new NotFound('No such order'))) //404
+ * console.log(statusOfError(new Error('Failed', {cause: new NotFound('No such order')}))) //404
+ * console.log(statusOfError(new Error('Boom'))) //500
+ * ```
+ */
+export function statusOfError(error) {
+    for (let current = error; current && typeof current === 'object'; current = current.cause) {
+        const status = current.statusCode ?? current.status;
+        if (typeof status === 'number' && status >= 400 && status < 500)
+            return status;
+    }
+    const status = error?.statusCode ?? error?.status;
+    return typeof status === 'number' && status >= 400 && status < 600 ? status : 500;
+}
+/**
+ * Describe an error as the JSON responders send it: its `errno` (or `code`, `E_UNKNOWN` without either) and its
+ * `errMsg` (or `message`, or the error converted to a string).
+ * @param error The error, any value.
+ * @returns The error's number and message.
+ * @example
+ * ```typescript
+ * import {describeError, type ErrorDescription} from 'lakutata/adapter/express'
+ *
+ * const description: ErrorDescription = describeError(new Error('Boom'))
+ * console.log(description) //{errno: 'E_UNKNOWN', errMsg: 'Boom'}
+ * ```
+ */
+export function describeError(error) {
+    const described = error ?? {};
+    return {
+        errno: described.errno ?? described.code ?? 'E_UNKNOWN',
+        errMsg: described.errMsg ?? described.message ?? String(error)
+    };
+}

package/dist/esm/lib/Middleware.js

@@ -0,0 +1,134 @@
+import { Provider } from '@lakutata/core';
+import { isSubclassOf } from '@lakutata/utils';
+import { InvalidMiddlewareException } from '../exceptions/InvalidMiddlewareException.js';
+import { MiddlewareNextCalledException } from '../exceptions/MiddlewareNextCalledException.js';
+/**
+ * A middleware class: it runs around the actions, created in each request's container (its dependencies are
+ * injected). Give it, or a {@link MiddlewareHandler} function, to the entrypoint's `middlewares` option (every
+ * action), an adapter's `middlewares` option (its requests), `@UseMiddlewares` (a controller class or a method) or an
+ * action's `middlewares` option. They run in that order: the entrypoint's, the adapter's, the controller parents'
+ * then the controller's, the action option's, then the method's.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller, Middleware, type ActionInvocation, type Next} from 'lakutata/com/entrypoint'
+ * import {GET, UseMiddlewares} from 'lakutata/decorator/ctrl'
+ *
+ * //Log the duration of each request
+ * class Timing extends Middleware {
+ *     public async handle(invocation: ActionInvocation, next: Next): Promise<unknown> {
+ *         const start: number = Date.now()
+ *         try {
+ *             return await next()
+ *         } finally {
+ *             console.log(`${invocation.action.name}: ${Date.now() - start}ms`)
+ *         }
+ *     }
+ * }
+ *
+ * @UseMiddlewares(async (invocation: ActionInvocation, next: Next): Promise<unknown> => {
+ *     //Short-circuit: the action does not run
+ *     if (invocation.context.data.maintenance) return {error: 'maintenance'}
+ *     return next()
+ * })
+ * class StatusController extends Controller {
+ *     @GET('/status')
+ *     public async status(): Promise<string> {
+ *         return 'ok'
+ *     }
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'status.app',
+ *     name: 'Status',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [StatusController],
+ *             middlewares: [Timing]
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export class Middleware extends Provider {
+}
+const CLASS_MIDDLEWARES = Symbol('ENTRYPOINT.CLASS.MIDDLEWARES');
+const METHOD_MIDDLEWARES = Symbol('ENTRYPOINT.METHOD.MIDDLEWARES');
+/**
+ * Whether a middleware is a middleware class
+ * @param middleware
+ */
+export function isMiddlewareClass(middleware) {
+    return isSubclassOf(middleware, Middleware);
+}
+/**
+ * Check middleware definitions: middleware classes or functions
+ * @param middlewares
+ */
+export function validateMiddlewares(middlewares) {
+    for (const middleware of middlewares) {
+        if (typeof middleware !== 'function')
+            throw new InvalidMiddlewareException('A middleware must be a function or a class extending Middleware');
+        if (!isMiddlewareClass(middleware) && /^class[\s{]/.test(Function.prototype.toString.call(middleware)))
+            throw new InvalidMiddlewareException('The middleware class "{0}" does not extend Middleware', [middleware.name]);
+    }
+    return middlewares;
+}
+/**
+ * Add middlewares to a controller class or an action method, the middlewares of each decorator run in their order,
+ * the decorators from top to bottom
+ * @param target
+ * @param propertyKey
+ * @param middlewares
+ */
+export function addMiddlewares(target, propertyKey, middlewares) {
+    const key = propertyKey === undefined ? CLASS_MIDDLEWARES : METHOD_MIDDLEWARES;
+    const existing = (propertyKey === undefined ? Reflect.getOwnMetadata(key, target) : Reflect.getOwnMetadata(key, target, propertyKey)) || [];
+    //The decorators are applied from bottom to top
+    const merged = [...validateMiddlewares(middlewares), ...existing];
+    propertyKey === undefined ? Reflect.defineMetadata(key, merged, target) : Reflect.defineMetadata(key, merged, target, propertyKey);
+}
+/**
+ * The middlewares of a controller class, the ones of its parent classes first
+ * @param controller
+ */
+export function getClassMiddlewares(controller) {
+    const chain = [];
+    for (let current = controller; current && current !== Function.prototype; current = Object.getPrototypeOf(current))
+        chain.unshift(current);
+    return chain.flatMap((constructor) => Reflect.getOwnMetadata(CLASS_MIDDLEWARES, constructor) || []);
+}
+/**
+ * The middlewares of an action method, declared on the method in the class hierarchy
+ * @param controller
+ * @param method
+ */
+export function getMethodMiddlewares(controller, method) {
+    for (let prototype = controller.prototype; prototype; prototype = Object.getPrototypeOf(prototype)) {
+        const middlewares = Reflect.getOwnMetadata(METHOD_MIDDLEWARES, prototype, method);
+        if (middlewares)
+            return middlewares;
+    }
+    return [];
+}
+/**
+ * Compose middlewares around the innermost runner
+ * @param middlewares
+ * @param innermost
+ */
+export function composeMiddlewares(middlewares, innermost) {
+    return middlewares.reduceRight((next, middleware) => {
+        const handle = isMiddlewareClass(middleware)
+            ? async (invocation, nextStep) => (await invocation.container.get(middleware)).handle(invocation, nextStep)
+            : middleware;
+        return (invocation) => {
+            let called = false;
+            return handle(invocation, () => {
+                if (called)
+                    return Promise.reject(new MiddlewareNextCalledException('next() is called more than once'));
+                called = true;
+                return next(invocation);
+            });
+        };
+    }, innermost);
+}