@lakutata/entrypoint 3.0.0-beta.0

package/dist/cjs/decorators/http/PATCH.d.ts

@@ -0,0 +1,90 @@
+import { Controller, type ControllerProperty } from '../../lib/Controller.js';
+import { DTO, MethodDecorator } from '@lakutata/core';
+import { ActionOptions } from '../../lib/ActionOptions.js';
+import { HTTPContext } from '../../context/HTTPContext.js';
+/**
+ * Expose the controller method as an HTTP PATCH action on a route, to update a part of a resource: the shorthand of
+ * `@HTTPAction(route, 'patch', …)`. The adapter assembles the input: by default, the query string merged with the
+ * parsed body (JSON or URL encoded), then the route parameters over them. The middlewares run, the input is validated
+ * against the DTO (the defaults applied, the unknown keys removed; without a DTO, it is accepted as it is), the access
+ * control runs when `acl` is set, then the method receives the validated input as a plain object. The query values and
+ * the route parameters are strings and the DTO schemas are strict: convert them with `.strict(false)`. The value
+ * returned is answered by the adapter's responder: as JSON by default, with the status 204 for `undefined`;
+ * `Result.status()` sets a status and headers. An error thrown is answered as `{errno, errMsg}` with the first 4xx
+ * `statusCode` along its causes (400 for an invalid input), else its own `statusCode`, else 500.
+ * @param r The route, in the syntax of the HTTP adapter (`/users/:id`); the controller's `@Prefix({route})` is
+ * prepended to it.
+ * @returns The method decorator.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Controller} from 'lakutata/com/entrypoint'
+ * import {PATCH} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ *
+ * class RenameDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public id!: string
+ *
+ *     @Expect(DTO.String().min(1).optional())
+ *     public name?: string
+ * }
+ *
+ * class ProjectController extends Controller {
+ *     //PATCH /projects/p1 with the body {"name": "Apollo"}: answered with the status 204 (no content)
+ *     @PATCH('/projects/:id', RenameDTO)
+ *     public async rename(input: RenameDTO): Promise<void> {
+ *         console.log(`rename ${input.id} to ${input.name}`)
+ *     }
+ * }
+ * ```
+ */
+export declare function PATCH<ClassPrototype extends Controller, Method>(r: string): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP PATCH action on a route, its input validated against a DTO: the shorthand of
+ * `@HTTPAction(route, 'patch', …)`. The input is the query string merged with the parsed body, then the route
+ * parameters over them (the default of the adapters); the method receives it validated, as a plain object. The value
+ * returned is answered as JSON (204 for `undefined`), an error as `{errno, errMsg}` with its status (400 for an invalid
+ * input, else 500 by default).
+ * @param r The route, in the syntax of the HTTP adapter (`/users/:id`); the controller's `@Prefix({route})` is
+ * prepended to it.
+ * @param dtoConstructor The DTO class validating the input; the query values and the route parameters are strings,
+ * convert them with `.strict(false)`.
+ * @returns The method decorator.
+ */
+export declare function PATCH<ClassPrototype extends Controller, Method, DTOConstructor extends typeof DTO = typeof DTO>(r: string, dtoConstructor: DTOConstructor): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP PATCH action on a route, with action options: the shorthand of
+ * `@HTTPAction(route, 'patch', …)`. The input is the query string merged with the parsed body, then the route
+ * parameters over them (the default of the adapters), accepted as it is. The value returned is answered as JSON (204
+ * for `undefined`), an error as `{errno, errMsg}` with its status (500 by default).
+ * @param r The route, in the syntax of the HTTP adapter (`/users/:id`); the controller's `@Prefix({route})` is
+ * prepended to it.
+ * @param actionOptions The action options: `acl` runs the access control rules (false by default); `name` (unique in the
+ * HTTP actions, `ClassName:method` by default), `description` and `groups` describe the action; `rule` is an access
+ * rule of the action; `middlewares` run before the ones `@UseMiddlewares` adds to the method.
+ * @returns The method decorator.
+ * @throws {InvalidValueException} When the class is declared, if the action options are invalid.
+ * @throws {InvalidMiddlewareException} When the class is declared, if a middleware of the options is neither a function
+ * nor a class extending `Middleware`.
+ */
+export declare function PATCH<ClassPrototype extends Controller, Method>(r: string, actionOptions: ActionOptions<HTTPContext>): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP PATCH action on a route, its input validated against a DTO, with action
+ * options: the shorthand of `@HTTPAction(route, 'patch', …)`. The input is the query string merged with the parsed
+ * body, then the route parameters over them (the default of the adapters); the method receives it validated, as a plain
+ * object. The value returned is answered as JSON (204 for `undefined`), an error as `{errno, errMsg}` with its status
+ * (400 for an invalid input, else 500 by default).
+ * @param r The route, in the syntax of the HTTP adapter (`/users/:id`); the controller's `@Prefix({route})` is
+ * prepended to it.
+ * @param dtoConstructor The DTO class validating the input; the query values and the route parameters are strings,
+ * convert them with `.strict(false)`.
+ * @param actionOptions The action options: `acl` runs the access control rules (false by default); `name` (unique in the
+ * HTTP actions, `ClassName:method` by default), `description` and `groups` describe the action; `rule` is an access
+ * rule of the action; `middlewares` run before the ones `@UseMiddlewares` adds to the method.
+ * @returns The method decorator.
+ * @throws {InvalidValueException} When the class is declared, if the action options are invalid.
+ * @throws {InvalidMiddlewareException} When the class is declared, if a middleware of the options is neither a function
+ * nor a class extending `Middleware`.
+ */
+export declare function PATCH<ClassPrototype extends Controller, Method, DTOConstructor extends typeof DTO = typeof DTO>(r: string, dtoConstructor: DTOConstructor, actionOptions: ActionOptions<HTTPContext>): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;

package/dist/cjs/decorators/http/PATCH.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PATCH = PATCH;
+const HTTPAction_js_1 = require("../HTTPAction.js");
+function PATCH(r, dtoConstructorOrOptions, options) {
+    return (0, HTTPAction_js_1.HTTPAction)(r, 'patch', dtoConstructorOrOptions, options);
+}

package/dist/cjs/decorators/http/POST.d.ts

@@ -0,0 +1,91 @@
+import { Controller, type ControllerProperty } from '../../lib/Controller.js';
+import { DTO, MethodDecorator } from '@lakutata/core';
+import { ActionOptions } from '../../lib/ActionOptions.js';
+import { HTTPContext } from '../../context/HTTPContext.js';
+/**
+ * Expose the controller method as an HTTP POST action on a route, to create a resource or run a command: the shorthand
+ * of `@HTTPAction(route, 'post', …)`. The adapter assembles the input: by default, the query string merged with the
+ * parsed body (JSON or URL encoded), then the route parameters over them. The middlewares run, the input is validated
+ * against the DTO (the defaults applied, the unknown keys removed; without a DTO, it is accepted as it is), the access
+ * control runs when `acl` is set, then the method receives the validated input as a plain object. The query values and
+ * the route parameters are strings and the DTO schemas are strict: convert them with `.strict(false)`. The value
+ * returned is answered by the adapter's responder: as JSON by default, with the status 204 for `undefined`;
+ * `Result.status()` sets a status and headers. An error thrown is answered as `{errno, errMsg}` with the first 4xx
+ * `statusCode` along its causes (400 for an invalid input), else its own `statusCode`, else 500.
+ * @param r The route, in the syntax of the HTTP adapter (`/users/:id`); the controller's `@Prefix({route})` is
+ * prepended to it.
+ * @returns The method decorator.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Controller, Result, type StatusResult} from 'lakutata/com/entrypoint'
+ * import {POST} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ *
+ * class CreateUserDTO extends DTO {
+ *     @Expect(DTO.String().email().required())
+ *     public email!: string
+ *
+ *     @Expect(DTO.String().min(1).required())
+ *     public name!: string
+ * }
+ *
+ * class UserController extends Controller {
+ *     //POST /users with the body {"email": "ada@example.com", "name": "Ada"}: answered with the status 201 and the JSON
+ *     //{"id": 1, "email": "ada@example.com", "name": "Ada"}; an invalid body with the status 400
+ *     @POST('/users', CreateUserDTO, {acl: true, name: 'Create a user'})
+ *     public async create(input: CreateUserDTO): Promise<StatusResult> {
+ *         return Result.status(201, {id: 1, email: input.email, name: input.name})
+ *     }
+ * }
+ * ```
+ */
+export declare function POST<ClassPrototype extends Controller, Method>(r: string): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP POST action on a route, its input validated against a DTO: the shorthand of
+ * `@HTTPAction(route, 'post', …)`. The input is the query string merged with the parsed body, then the route parameters
+ * over them (the default of the adapters); the method receives it validated, as a plain object. The value returned is
+ * answered as JSON (204 for `undefined`), an error as `{errno, errMsg}` with its status (400 for an invalid input, else
+ * 500 by default).
+ * @param r The route, in the syntax of the HTTP adapter (`/users/:id`); the controller's `@Prefix({route})` is
+ * prepended to it.
+ * @param dtoConstructor The DTO class validating the input; the query values and the route parameters are strings,
+ * convert them with `.strict(false)`.
+ * @returns The method decorator.
+ */
+export declare function POST<ClassPrototype extends Controller, Method, DTOConstructor extends typeof DTO = typeof DTO>(r: string, dtoConstructor: DTOConstructor): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP POST action on a route, with action options: the shorthand of
+ * `@HTTPAction(route, 'post', …)`. The input is the query string merged with the parsed body, then the route parameters
+ * over them (the default of the adapters), accepted as it is. The value returned is answered as JSON (204 for
+ * `undefined`), an error as `{errno, errMsg}` with its status (500 by default).
+ * @param r The route, in the syntax of the HTTP adapter (`/users/:id`); the controller's `@Prefix({route})` is
+ * prepended to it.
+ * @param actionOptions The action options: `acl` runs the access control rules (false by default); `name` (unique in the
+ * HTTP actions, `ClassName:method` by default), `description` and `groups` describe the action; `rule` is an access
+ * rule of the action; `middlewares` run before the ones `@UseMiddlewares` adds to the method.
+ * @returns The method decorator.
+ * @throws {InvalidValueException} When the class is declared, if the action options are invalid.
+ * @throws {InvalidMiddlewareException} When the class is declared, if a middleware of the options is neither a function
+ * nor a class extending `Middleware`.
+ */
+export declare function POST<ClassPrototype extends Controller, Method>(r: string, actionOptions: ActionOptions<HTTPContext>): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP POST action on a route, its input validated against a DTO, with action
+ * options: the shorthand of `@HTTPAction(route, 'post', …)`. The input is the query string merged with the parsed body,
+ * then the route parameters over them (the default of the adapters); the method receives it validated, as a plain
+ * object. The value returned is answered as JSON (204 for `undefined`), an error as `{errno, errMsg}` with its status
+ * (400 for an invalid input, else 500 by default).
+ * @param r The route, in the syntax of the HTTP adapter (`/users/:id`); the controller's `@Prefix({route})` is
+ * prepended to it.
+ * @param dtoConstructor The DTO class validating the input; the query values and the route parameters are strings,
+ * convert them with `.strict(false)`.
+ * @param actionOptions The action options: `acl` runs the access control rules (false by default); `name` (unique in the
+ * HTTP actions, `ClassName:method` by default), `description` and `groups` describe the action; `rule` is an access
+ * rule of the action; `middlewares` run before the ones `@UseMiddlewares` adds to the method.
+ * @returns The method decorator.
+ * @throws {InvalidValueException} When the class is declared, if the action options are invalid.
+ * @throws {InvalidMiddlewareException} When the class is declared, if a middleware of the options is neither a function
+ * nor a class extending `Middleware`.
+ */
+export declare function POST<ClassPrototype extends Controller, Method, DTOConstructor extends typeof DTO = typeof DTO>(r: string, dtoConstructor: DTOConstructor, actionOptions: ActionOptions<HTTPContext>): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;

package/dist/cjs/decorators/http/POST.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const HTTPAction_js_1 = require("../HTTPAction.js");
+function POST(r, dtoConstructorOrOptions, options) {
+    return (0, HTTPAction_js_1.HTTPAction)(r, 'post', dtoConstructorOrOptions, options);
+}

package/dist/cjs/decorators/http/PUT.d.ts

@@ -0,0 +1,92 @@
+import { Controller, type ControllerProperty } from '../../lib/Controller.js';
+import { DTO, MethodDecorator } from '@lakutata/core';
+import { ActionOptions } from '../../lib/ActionOptions.js';
+import { HTTPContext } from '../../context/HTTPContext.js';
+/**
+ * Expose the controller method as an HTTP PUT action on a route, to replace a resource: the shorthand of
+ * `@HTTPAction(route, 'put', …)`. The adapter assembles the input: by default, the query string merged with the parsed
+ * body (JSON or URL encoded), then the route parameters over them. The middlewares run, the input is validated against
+ * the DTO (the defaults applied, the unknown keys removed; without a DTO, it is accepted as it is), the access control
+ * runs when `acl` is set, then the method receives the validated input as a plain object. The query values and the
+ * route parameters are strings and the DTO schemas are strict: convert them with `.strict(false)`. The value returned
+ * is answered by the adapter's responder: as JSON by default, with the status 204 for `undefined`; `Result.status()`
+ * sets a status and headers. An error thrown is answered as `{errno, errMsg}` with the first 4xx `statusCode` along its
+ * causes (400 for an invalid input), else its own `statusCode`, else 500.
+ * @param r The route, in the syntax of the HTTP adapter (`/users/:id`); the controller's `@Prefix({route})` is
+ * prepended to it.
+ * @returns The method decorator.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Controller} from 'lakutata/com/entrypoint'
+ * import {PUT} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ *
+ * class ReplaceSettingsDTO extends DTO {
+ *     //The route parameter
+ *     @Expect(DTO.String().required())
+ *     public user!: string
+ *
+ *     //The body
+ *     @Expect(DTO.String().valid('light', 'dark').required())
+ *     public theme!: string
+ * }
+ *
+ * class SettingsController extends Controller {
+ *     //PUT /settings/ada with the body {"theme": "dark"}: answered with the JSON {"user": "ada", "theme": "dark"}
+ *     @PUT('/settings/:user', ReplaceSettingsDTO)
+ *     public async replace(input: ReplaceSettingsDTO): Promise<{ user: string, theme: string }> {
+ *         return {user: input.user, theme: input.theme}
+ *     }
+ * }
+ * ```
+ */
+export declare function PUT<ClassPrototype extends Controller, Method>(r: string): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP PUT action on a route, its input validated against a DTO: the shorthand of
+ * `@HTTPAction(route, 'put', …)`. The input is the query string merged with the parsed body, then the route parameters
+ * over them (the default of the adapters); the method receives it validated, as a plain object. The value returned is
+ * answered as JSON (204 for `undefined`), an error as `{errno, errMsg}` with its status (400 for an invalid input, else
+ * 500 by default).
+ * @param r The route, in the syntax of the HTTP adapter (`/users/:id`); the controller's `@Prefix({route})` is
+ * prepended to it.
+ * @param dtoConstructor The DTO class validating the input; the query values and the route parameters are strings,
+ * convert them with `.strict(false)`.
+ * @returns The method decorator.
+ */
+export declare function PUT<ClassPrototype extends Controller, Method, DTOConstructor extends typeof DTO = typeof DTO>(r: string, dtoConstructor: DTOConstructor): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP PUT action on a route, with action options: the shorthand of
+ * `@HTTPAction(route, 'put', …)`. The input is the query string merged with the parsed body, then the route parameters
+ * over them (the default of the adapters), accepted as it is. The value returned is answered as JSON (204 for
+ * `undefined`), an error as `{errno, errMsg}` with its status (500 by default).
+ * @param r The route, in the syntax of the HTTP adapter (`/users/:id`); the controller's `@Prefix({route})` is
+ * prepended to it.
+ * @param actionOptions The action options: `acl` runs the access control rules (false by default); `name` (unique in the
+ * HTTP actions, `ClassName:method` by default), `description` and `groups` describe the action; `rule` is an access
+ * rule of the action; `middlewares` run before the ones `@UseMiddlewares` adds to the method.
+ * @returns The method decorator.
+ * @throws {InvalidValueException} When the class is declared, if the action options are invalid.
+ * @throws {InvalidMiddlewareException} When the class is declared, if a middleware of the options is neither a function
+ * nor a class extending `Middleware`.
+ */
+export declare function PUT<ClassPrototype extends Controller, Method>(r: string, actionOptions: ActionOptions<HTTPContext>): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP PUT action on a route, its input validated against a DTO, with action
+ * options: the shorthand of `@HTTPAction(route, 'put', …)`. The input is the query string merged with the parsed body,
+ * then the route parameters over them (the default of the adapters); the method receives it validated, as a plain
+ * object. The value returned is answered as JSON (204 for `undefined`), an error as `{errno, errMsg}` with its status
+ * (400 for an invalid input, else 500 by default).
+ * @param r The route, in the syntax of the HTTP adapter (`/users/:id`); the controller's `@Prefix({route})` is
+ * prepended to it.
+ * @param dtoConstructor The DTO class validating the input; the query values and the route parameters are strings,
+ * convert them with `.strict(false)`.
+ * @param actionOptions The action options: `acl` runs the access control rules (false by default); `name` (unique in the
+ * HTTP actions, `ClassName:method` by default), `description` and `groups` describe the action; `rule` is an access
+ * rule of the action; `middlewares` run before the ones `@UseMiddlewares` adds to the method.
+ * @returns The method decorator.
+ * @throws {InvalidValueException} When the class is declared, if the action options are invalid.
+ * @throws {InvalidMiddlewareException} When the class is declared, if a middleware of the options is neither a function
+ * nor a class extending `Middleware`.
+ */
+export declare function PUT<ClassPrototype extends Controller, Method, DTOConstructor extends typeof DTO = typeof DTO>(r: string, dtoConstructor: DTOConstructor, actionOptions: ActionOptions<HTTPContext>): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;

package/dist/cjs/decorators/http/PUT.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUT = PUT;
+const HTTPAction_js_1 = require("../HTTPAction.js");
+function PUT(r, dtoConstructorOrOptions, options) {
+    return (0, HTTPAction_js_1.HTTPAction)(r, 'put', dtoConstructorOrOptions, options);
+}

package/dist/cjs/exceptions/AccessDeniedException.d.ts

@@ -0,0 +1,10 @@
+import { Exception } from '@lakutata/core';
+/**
+ * An access control rule denied the request: a rule of the entrypoint (`rules`) or of the action resolved `false`.
+ * Its errno is `E_ACCESS_DENY`, its HTTP status 403.
+ */
+export declare class AccessDeniedException extends Exception {
+    errno: string | number;
+    message: string;
+    readonly statusCode: number;
+}

package/dist/cjs/exceptions/AccessDeniedException.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessDeniedException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * An access control rule denied the request: a rule of the entrypoint (`rules`) or of the action resolved `false`.
+ * Its errno is `E_ACCESS_DENY`, its HTTP status 403.
+ */
+class AccessDeniedException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_ACCESS_DENY';
+        this.message = 'Access denied';
+        this.statusCode = 403;
+    }
+}
+exports.AccessDeniedException = AccessDeniedException;

package/dist/cjs/exceptions/ControllerActionNotFoundException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '@lakutata/core';
+/**
+ * No action matches the request: the service pattern, the command or the route of no controller action matches it.
+ * Its errno is `E_CONTROLLER_ACTION_NOT_FOUND`, its HTTP status 404.
+ */
+export declare class ControllerActionNotFoundException extends Exception {
+    errno: string | number;
+    readonly statusCode: number;
+}

package/dist/cjs/exceptions/ControllerActionNotFoundException.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllerActionNotFoundException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * No action matches the request: the service pattern, the command or the route of no controller action matches it.
+ * Its errno is `E_CONTROLLER_ACTION_NOT_FOUND`, its HTTP status 404.
+ */
+class ControllerActionNotFoundException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_CONTROLLER_ACTION_NOT_FOUND';
+        this.statusCode = 404;
+    }
+}
+exports.ControllerActionNotFoundException = ControllerActionNotFoundException;

package/dist/cjs/exceptions/DuplicateActionNameException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Two actions of a channel have the same name (`name` of their options, `Class:method` by default), when the
+ * entrypoint initializes. Its errno is `E_DUPLICATE_ACTION_NAME`.
+ */
+export declare class DuplicateActionNameException extends Exception {
+    errno: string | number;
+}

package/dist/cjs/exceptions/DuplicateActionNameException.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicateActionNameException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * Two actions of a channel have the same name (`name` of their options, `Class:method` by default), when the
+ * entrypoint initializes. Its errno is `E_DUPLICATE_ACTION_NAME`.
+ */
+class DuplicateActionNameException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_DUPLICATE_ACTION_NAME';
+    }
+}
+exports.DuplicateActionNameException = DuplicateActionNameException;

package/dist/cjs/exceptions/EntrypointStoppedException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '@lakutata/core';
+/**
+ * The request arrived while the entrypoint is stopping (the application exiting): it is refused, the requests in
+ * progress being waited for. Its errno is `E_ENTRYPOINT_STOPPED`, its HTTP status 503.
+ */
+export declare class EntrypointStoppedException extends Exception {
+    errno: string | number;
+    readonly statusCode: number;
+}

package/dist/cjs/exceptions/EntrypointStoppedException.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntrypointStoppedException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * The request arrived while the entrypoint is stopping (the application exiting): it is refused, the requests in
+ * progress being waited for. Its errno is `E_ENTRYPOINT_STOPPED`, its HTTP status 503.
+ */
+class EntrypointStoppedException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_ENTRYPOINT_STOPPED';
+        this.statusCode = 503;
+    }
+}
+exports.EntrypointStoppedException = EntrypointStoppedException;

package/dist/cjs/exceptions/InvalidActionGroupException.d.ts

@@ -0,0 +1,4 @@
+import { Exception } from '@lakutata/core';
+export declare class InvalidActionGroupException extends Exception {
+    errno: string | number;
+}

package/dist/cjs/exceptions/InvalidActionGroupException.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidActionGroupException = void 0;
+const core_1 = require("@lakutata/core");
+class InvalidActionGroupException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_INVALID_ACTION_GROUP';
+    }
+}
+exports.InvalidActionGroupException = InvalidActionGroupException;

package/dist/cjs/exceptions/InvalidChannelException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from '@lakutata/core';
+/**
+ * A channel is defined twice under the same name, or a channel used is not defined. Its errno is
+ * `E_INVALID_CHANNEL`.
+ */
+export declare class InvalidChannelException extends Exception {
+    errno: string | number;
+}

package/dist/cjs/exceptions/InvalidChannelException.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidChannelException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * A channel is defined twice under the same name, or a channel used is not defined. Its errno is
+ * `E_INVALID_CHANNEL`.
+ */
+class InvalidChannelException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_INVALID_CHANNEL';
+    }
+}
+exports.InvalidChannelException = InvalidChannelException;

package/dist/cjs/exceptions/InvalidEntrypointAdapterException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '@lakutata/core';
+/**
+ * An option of the entrypoint is given an adapter of another channel, an adapter of an undefined channel, or a value
+ * which is neither an option nor an adapter, when the entrypoint initializes. Its errno is
+ * `E_INVALID_ENTRYPOINT_ADAPTER`.
+ */
+export declare class InvalidEntrypointAdapterException extends Exception {
+    errno: string | number;
+}

package/dist/cjs/exceptions/InvalidEntrypointAdapterException.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidEntrypointAdapterException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * An option of the entrypoint is given an adapter of another channel, an adapter of an undefined channel, or a value
+ * which is neither an option nor an adapter, when the entrypoint initializes. Its errno is
+ * `E_INVALID_ENTRYPOINT_ADAPTER`.
+ */
+class InvalidEntrypointAdapterException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_INVALID_ENTRYPOINT_ADAPTER';
+    }
+}
+exports.InvalidEntrypointAdapterException = InvalidEntrypointAdapterException;

package/dist/cjs/exceptions/InvalidMiddlewareException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from '@lakutata/core';
+/**
+ * A middleware is neither a function nor a class extending `Middleware`, when the entrypoint initializes. Its errno is
+ * `E_INVALID_MIDDLEWARE`.
+ */
+export declare class InvalidMiddlewareException extends Exception {
+    errno: string | number;
+}

package/dist/cjs/exceptions/InvalidMiddlewareException.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidMiddlewareException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * A middleware is neither a function nor a class extending `Middleware`, when the entrypoint initializes. Its errno is
+ * `E_INVALID_MIDDLEWARE`.
+ */
+class InvalidMiddlewareException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_INVALID_MIDDLEWARE';
+    }
+}
+exports.InvalidMiddlewareException = InvalidMiddlewareException;

package/dist/cjs/exceptions/InvalidPrefixException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from '@lakutata/core';
+/**
+ * A pattern prefix of a controller (`@Prefix`) and the pattern of one of its service actions set the same key to
+ * different values, when the entrypoint initializes. Its errno is `E_INVALID_PREFIX`.
+ */
+export declare class InvalidPrefixException extends Exception {
+    errno: string | number;
+}

package/dist/cjs/exceptions/InvalidPrefixException.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidPrefixException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * A pattern prefix of a controller (`@Prefix`) and the pattern of one of its service actions set the same key to
+ * different values, when the entrypoint initializes. Its errno is `E_INVALID_PREFIX`.
+ */
+class InvalidPrefixException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_INVALID_PREFIX';
+    }
+}
+exports.InvalidPrefixException = InvalidPrefixException;

package/dist/cjs/exceptions/MiddlewareNextCalledException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from '@lakutata/core';
+/**
+ * A middleware called `next()` more than once for a request (the request rejects with it). Its errno is
+ * `E_MIDDLEWARE_NEXT_CALLED`.
+ */
+export declare class MiddlewareNextCalledException extends Exception {
+    errno: string | number;
+}

package/dist/cjs/exceptions/MiddlewareNextCalledException.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewareNextCalledException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * A middleware called `next()` more than once for a request (the request rejects with it). Its errno is
+ * `E_MIDDLEWARE_NEXT_CALLED`.
+ */
+class MiddlewareNextCalledException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_MIDDLEWARE_NEXT_CALLED';
+    }
+}
+exports.MiddlewareNextCalledException = MiddlewareNextCalledException;

package/dist/cjs/exceptions/RouteNotFoundException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '@lakutata/core';
+/**
+ * No HTTP route matches the request (the HTTP adapters answer it). Its errno is `E_ROUTE_NOT_FOUND`, its HTTP status
+ * 404.
+ */
+export declare class RouteNotFoundException extends Exception {
+    errno: string | number;
+    readonly statusCode: number;
+}

package/dist/cjs/exceptions/RouteNotFoundException.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteNotFoundException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * No HTTP route matches the request (the HTTP adapters answer it). Its errno is `E_ROUTE_NOT_FOUND`, its HTTP status
+ * 404.
+ */
+class RouteNotFoundException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_ROUTE_NOT_FOUND';
+        this.statusCode = 404;
+    }
+}
+exports.RouteNotFoundException = RouteNotFoundException;

package/dist/cjs/exceptions/ServiceInvokeException.d.ts

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * The failure of a service invocation: the error of the remote service, with its properties (errno, errMsg, statusCode…)
+ */
+export declare class ServiceInvokeException extends Exception {
+    errno: string | number;
+    /**
+     * The id of the service invoked.
+     */
+    service?: string;
+}

package/dist/cjs/exceptions/ServiceInvokeException.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceInvokeException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * The failure of a service invocation: the error of the remote service, with its properties (errno, errMsg, statusCode…)
+ */
+class ServiceInvokeException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_SERVICE_INVOKE';
+    }
+}
+exports.ServiceInvokeException = ServiceInvokeException;