@lakutata/entrypoint 3.0.0-beta.0

package/dist/cjs/decorators/ServiceAction.d.ts

@@ -0,0 +1,116 @@
+import { Controller, type ControllerProperty } from '../lib/Controller.js';
+import { MethodDecorator, ActionPattern, DTO } from '@lakutata/core';
+import { ActionOptions } from '../lib/ActionOptions.js';
+import { ServiceContext } from '../context/ServiceContext.js';
+/**
+ * Expose the controller method as a service action, addressed by a pattern that the messages of the service adapters
+ * must match. Without a DTO, the input is accepted as it is.
+ * A service adapter (`socketIOServiceEntrypoint`, `jsonRPCServiceEntrypoint`, `electronIPCServiceEntrypoint`,
+ * `httpServiceEntrypoint`) receives a message, an object, and dispatches it to the action whose pattern it matches. The
+ * input is the message without the keys of the pattern; the middlewares run, the input is validated against the DTO
+ * (the defaults applied, the unknown keys removed), the access control runs when `acl` is set, then the method receives
+ * the validated input as a plain object.
+ * The value returned is sent back to the caller: `{success: true, error: null, payload}` for the Socket.IO, Electron
+ * and HTTP service adapters, the `result` of the response for JSON-RPC. An error is sent as `{success: false, error,
+ * payload: null}`, `error` holding its properties (`errno`, `errMsg`, `statusCode`, `message`…); JSON-RPC answers it as
+ * an error response. A message no pattern matches fails with `ControllerActionNotFoundException`.
+ * @param pattern The pattern of the action: an object (nested 2 levels at most) whose keys the messages must hold with
+ * the same values; a string value may be a glob (`'user.*'`, `*` any characters, `?` one). The most specific pattern
+ * matching a message wins. The controller's `@Prefix({pattern})` is merged into it.
+ * @returns The method decorator.
+ * @throws {InvalidActionPatternDepthException} When the class is declared, if the pattern is nested more than 2 levels.
+ * @example
+ * ```typescript
+ * import {Application, DTO} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ * import {socketIOServiceEntrypoint} from 'lakutata/adapter/socket.io'
+ *
+ * class TransferDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public to!: string
+ *
+ *     @Expect(DTO.Number().positive().required())
+ *     public amount!: number
+ * }
+ *
+ * class AccountController extends Controller {
+ *     //The message {resource: 'account', act: 'transfer', to: 'ada', amount: 5}: the input is {to: 'ada', amount: 5},
+ *     //the caller receives {success: true, error: null, payload: {to: 'ada', amount: 5, done: true}}; without an
+ *     //amount, {success: false, error: {errno: 'E_INVALID_VALUE', …}, payload: null}
+ *     @ServiceAction({resource: 'account', act: 'transfer'}, TransferDTO, {acl: true})
+ *     public async transfer(input: TransferDTO): Promise<{ to: string, amount: number, done: boolean }> {
+ *         return {to: input.to, amount: input.amount, done: true}
+ *     }
+ *
+ *     //Any message whose act starts with "audit.", its other keys accepted as they are
+ *     @ServiceAction({resource: 'account', act: 'audit.*'})
+ *     public async audit(input: Record<string, unknown>): Promise<void> {
+ *         console.log(input)
+ *     }
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'bank.app',
+ *     name: 'Bank',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [AccountController],
+ *             service: socketIOServiceEntrypoint({port: 3000})
+ *         })
+ *     },
+ *     bootstrap: ['entrypoint']
+ * }))
+ * ```
+ */
+export declare function ServiceAction<ClassPrototype extends Controller, Method>(pattern: ActionPattern): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as a service action addressed by a pattern, its input validated against a DTO. The input
+ * is the message without the keys of the pattern; the method receives it validated, as a plain object. The value
+ * returned is sent back as `{success: true, error: null, payload}`, an error as `{success: false, error, payload:
+ * null}` (a JSON-RPC result or error response).
+ * @param pattern The pattern of the action: an object (nested 2 levels at most) whose keys the messages must hold with
+ * the same values; a string value may be a glob (`'user.*'`, `*` any characters, `?` one). The most specific pattern
+ * matching a message wins. The controller's `@Prefix({pattern})` is merged into it.
+ * @param dtoConstructor The DTO class validating the input: the message without the keys of the pattern.
+ * @returns The method decorator.
+ * @throws {InvalidActionPatternDepthException} When the class is declared, if the pattern is nested more than 2 levels.
+ */
+export declare function ServiceAction<ClassPrototype extends Controller, Method, DTOConstructor extends typeof DTO = typeof DTO>(pattern: ActionPattern, dtoConstructor: DTOConstructor): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as a service action addressed by a pattern, with action options; the input, the message
+ * without the keys of the pattern, is accepted as it is. The value returned is sent back as `{success: true, error:
+ * null, payload}`, an error as `{success: false, error, payload: null}` (a JSON-RPC result or error response).
+ * @param pattern The pattern of the action: an object (nested 2 levels at most) whose keys the messages must hold with
+ * the same values; a string value may be a glob (`'user.*'`, `*` any characters, `?` one). The most specific pattern
+ * matching a message wins. The controller's `@Prefix({pattern})` is merged into it.
+ * @param actionOptions The action options: `acl` runs the access control rules (false by default); `name` (unique in
+ * the service 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 {InvalidActionPatternDepthException} When the class is declared, if the pattern is nested more than 2 levels.
+ * @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 ServiceAction<ClassPrototype extends Controller, Method>(pattern: ActionPattern, actionOptions: ActionOptions<ServiceContext>): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as a service action addressed by a pattern, its input validated against a DTO, with
+ * action options. The input is the message without the keys of the pattern; the method receives it validated, as a
+ * plain object. The value returned is sent back as `{success: true, error: null, payload}`, an error as `{success:
+ * false, error, payload: null}` (a JSON-RPC result or error response).
+ * @param pattern The pattern of the action: an object (nested 2 levels at most) whose keys the messages must hold with
+ * the same values; a string value may be a glob (`'user.*'`, `*` any characters, `?` one). The most specific pattern
+ * matching a message wins. The controller's `@Prefix({pattern})` is merged into it.
+ * @param dtoConstructor The DTO class validating the input: the message without the keys of the pattern.
+ * @param actionOptions The action options: `acl` runs the access control rules (false by default); `name` (unique in
+ * the service 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 {InvalidActionPatternDepthException} When the class is declared, if the pattern is nested more than 2 levels.
+ * @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 ServiceAction<ClassPrototype extends Controller, Method, DTOConstructor extends typeof DTO = typeof DTO>(pattern: ActionPattern, dtoConstructor: DTOConstructor, actionOptions: ActionOptions<ServiceContext>): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;

package/dist/cjs/decorators/ServiceAction.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceAction = ServiceAction;
+const ControllerEntrypoint_js_1 = require("../lib/ControllerEntrypoint.js");
+const GetActionDTOAndOptions_js_1 = require("../lib/GetActionDTOAndOptions.js");
+function ServiceAction(pattern, dtoConstructorOrOptions, options) {
+    return (target, propertyKey, descriptor) => {
+        const [dtoConstructor, actionOptions] = (0, GetActionDTOAndOptions_js_1.getActionDTOAndOptions)(dtoConstructorOrOptions, options);
+        (0, ControllerEntrypoint_js_1.registerServiceAction)(pattern, target, propertyKey, dtoConstructor, actionOptions);
+        return descriptor;
+    };
+}

package/dist/cjs/decorators/UseMiddlewares.d.ts

@@ -0,0 +1,52 @@
+import { MiddlewareDefinition } from '../lib/Middleware.js';
+/**
+ * Add middlewares to all the actions of a controller (on the class) or to one action (on the method). A middleware is a
+ * function `(invocation, next) => Promise<unknown>` or a class extending `Middleware`, created in the container of each
+ * request (its dependencies injected). It receives the request's context, whose data is the input before validation,
+ * and returns the result of `next()` (the rest of the pipeline), or another value without calling it, which is then
+ * answered instead of the action's result; an error it throws is answered as the action's error.
+ *
+ * The order of a request: the entrypoint's `middlewares`, the adapter's `middlewares`, the ones of the controller classes
+ * (the parent classes first), of the action options, of the action method, then the input validation, the access
+ * control and the action. Several `@UseMiddlewares` on a target run from top to bottom, the middlewares of each in their
+ * order. The middlewares of a method are taken from the nearest class declaring them for it: an overriding method
+ * replaces them.
+ * @param middlewares The middleware functions and classes, in their running order.
+ * @returns The class or method decorator.
+ * @throws {InvalidMiddlewareException} When the decorator is called, if a middleware is neither a function nor a class
+ * extending `Middleware`.
+ * @example
+ * ```typescript
+ * import {Controller, Middleware, type ActionInvocation, type Next} from 'lakutata/com/entrypoint'
+ * import {GET, UseMiddlewares} from 'lakutata/decorator/ctrl'
+ *
+ * //A middleware function: logs the duration of each action of the controller
+ * async function Timing(invocation: ActionInvocation, next: Next): Promise<unknown> {
+ *     const started: number = Date.now()
+ *     try {
+ *         return await next()
+ *     } finally {
+ *         console.log(`${invocation.action.name}: ${Date.now() - started}ms`)
+ *     }
+ * }
+ *
+ * //A middleware class: answers without running the action during a maintenance
+ * class Maintenance extends Middleware {
+ *     public async handle(invocation: ActionInvocation, next: Next): Promise<unknown> {
+ *         if (process.env.MAINTENANCE) return {maintenance: true}
+ *         return await next()
+ *     }
+ * }
+ *
+ * @UseMiddlewares(Timing)
+ * class StatusController extends Controller {
+ *     //Timing, then Maintenance, then the action
+ *     @GET('/status')
+ *     @UseMiddlewares(Maintenance)
+ *     public async status(): Promise<{ ok: boolean }> {
+ *         return {ok: true}
+ *     }
+ * }
+ * ```
+ */
+export declare function UseMiddlewares(...middlewares: MiddlewareDefinition[]): (target: object, propertyKey?: string | symbol, descriptor?: PropertyDescriptor) => void;

package/dist/cjs/decorators/UseMiddlewares.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseMiddlewares = UseMiddlewares;
+const Middleware_js_1 = require("../lib/Middleware.js");
+/**
+ * Add middlewares to all the actions of a controller (on the class) or to one action (on the method). A middleware is a
+ * function `(invocation, next) => Promise<unknown>` or a class extending `Middleware`, created in the container of each
+ * request (its dependencies injected). It receives the request's context, whose data is the input before validation,
+ * and returns the result of `next()` (the rest of the pipeline), or another value without calling it, which is then
+ * answered instead of the action's result; an error it throws is answered as the action's error.
+ *
+ * The order of a request: the entrypoint's `middlewares`, the adapter's `middlewares`, the ones of the controller classes
+ * (the parent classes first), of the action options, of the action method, then the input validation, the access
+ * control and the action. Several `@UseMiddlewares` on a target run from top to bottom, the middlewares of each in their
+ * order. The middlewares of a method are taken from the nearest class declaring them for it: an overriding method
+ * replaces them.
+ * @param middlewares The middleware functions and classes, in their running order.
+ * @returns The class or method decorator.
+ * @throws {InvalidMiddlewareException} When the decorator is called, if a middleware is neither a function nor a class
+ * extending `Middleware`.
+ * @example
+ * ```typescript
+ * import {Controller, Middleware, type ActionInvocation, type Next} from 'lakutata/com/entrypoint'
+ * import {GET, UseMiddlewares} from 'lakutata/decorator/ctrl'
+ *
+ * //A middleware function: logs the duration of each action of the controller
+ * async function Timing(invocation: ActionInvocation, next: Next): Promise<unknown> {
+ *     const started: number = Date.now()
+ *     try {
+ *         return await next()
+ *     } finally {
+ *         console.log(`${invocation.action.name}: ${Date.now() - started}ms`)
+ *     }
+ * }
+ *
+ * //A middleware class: answers without running the action during a maintenance
+ * class Maintenance extends Middleware {
+ *     public async handle(invocation: ActionInvocation, next: Next): Promise<unknown> {
+ *         if (process.env.MAINTENANCE) return {maintenance: true}
+ *         return await next()
+ *     }
+ * }
+ *
+ * @UseMiddlewares(Timing)
+ * class StatusController extends Controller {
+ *     //Timing, then Maintenance, then the action
+ *     @GET('/status')
+ *     @UseMiddlewares(Maintenance)
+ *     public async status(): Promise<{ ok: boolean }> {
+ *         return {ok: true}
+ *     }
+ * }
+ * ```
+ */
+function UseMiddlewares(...middlewares) {
+    (0, Middleware_js_1.validateMiddlewares)(middlewares);
+    return (target, propertyKey) => (0, Middleware_js_1.addMiddlewares)(target, propertyKey, middlewares);
+}

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

@@ -0,0 +1,87 @@
+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 DELETE action on a route, to delete a resource: the shorthand of
+ * `@HTTPAction(route, 'delete', …)`. 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 {DELETE} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ *
+ * class SessionIdDTO extends DTO {
+ *     @Expect(DTO.String().uuid().required())
+ *     public id!: string
+ * }
+ *
+ * class SessionController extends Controller {
+ *     //DELETE /sessions/<uuid>: answered with the status 204 (no content), an invalid id with the status 400
+ *     @DELETE('/sessions/:id', SessionIdDTO, {acl: true})
+ *     public async revoke(input: SessionIdDTO): Promise<void> {
+ *         console.log(`revoke ${input.id}`)
+ *     }
+ * }
+ * ```
+ */
+export declare function DELETE<ClassPrototype extends Controller, Method>(r: string): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP DELETE action on a route, its input validated against a DTO: the shorthand of
+ * `@HTTPAction(route, 'delete', …)`. 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 DELETE<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 DELETE action on a route, with action options: the shorthand of
+ * `@HTTPAction(route, 'delete', …)`. 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 DELETE<ClassPrototype extends Controller, Method>(r: string, actionOptions: ActionOptions<HTTPContext>): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP DELETE action on a route, its input validated against a DTO, with action
+ * options: the shorthand of `@HTTPAction(route, 'delete', …)`. 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 DELETE<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/DELETE.js

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

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

@@ -0,0 +1,89 @@
+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 GET action on a route, to read a resource: the shorthand of
+ * `@HTTPAction(route, 'get', …)`. 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 {GET} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ *
+ * class UserIdDTO extends DTO {
+ *     //A route parameter is a string: converted to a number
+ *     @Expect(DTO.Number().integer().min(1).strict(false).required())
+ *     public id!: number
+ * }
+ *
+ * class UserController extends Controller {
+ *     //GET /users/42: answered with the JSON {"id": 42, "name": "user42"}; GET /users/abc: the status 400 and
+ *     //{"errno": "E_INVALID_VALUE", "errMsg": …}
+ *     @GET('/users/:id', UserIdDTO)
+ *     public async get(input: UserIdDTO): Promise<{ id: number, name: string }> {
+ *         return {id: input.id, name: `user${input.id}`}
+ *     }
+ * }
+ * ```
+ */
+export declare function GET<ClassPrototype extends Controller, Method>(r: string): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP GET action on a route, its input validated against a DTO: the shorthand of
+ * `@HTTPAction(route, 'get', …)`. 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 GET<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 GET action on a route, with action options: the shorthand of
+ * `@HTTPAction(route, 'get', …)`. 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 GET<ClassPrototype extends Controller, Method>(r: string, actionOptions: ActionOptions<HTTPContext>): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP GET action on a route, its input validated against a DTO, with action
+ * options: the shorthand of `@HTTPAction(route, 'get', …)`. 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 GET<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/GET.js

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

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

@@ -0,0 +1,84 @@
+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 HEAD action on a route, to answer the headers of a resource without its body:
+ * the shorthand of `@HTTPAction(route, 'head', …)`. 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.
+ * With Fastify, a GET action also answers the HEAD requests of its route unless the route has a HEAD action.
+ * @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 {Controller, Result, type StatusResult} from 'lakutata/com/entrypoint'
+ * import {HEAD} from 'lakutata/decorator/ctrl'
+ *
+ * class HealthController extends Controller {
+ *     //HEAD /health: answered with the status 200 and the header X-Health, without a body
+ *     @HEAD('/health')
+ *     public async health(): Promise<StatusResult> {
+ *         return Result.status(200, undefined, {'X-Health': 'ok'})
+ *     }
+ * }
+ * ```
+ */
+export declare function HEAD<ClassPrototype extends Controller, Method>(r: string): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP HEAD action on a route, its input validated against a DTO: the shorthand of
+ * `@HTTPAction(route, 'head', …)`. 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).
+ * With Fastify, a GET action also answers the HEAD requests of its route unless the route has a HEAD action.
+ * @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 HEAD<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 HEAD action on a route, with action options: the shorthand of
+ * `@HTTPAction(route, 'head', …)`. 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).
+ * With Fastify, a GET action also answers the HEAD requests of its route unless the route has a HEAD action.
+ * @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 HEAD<ClassPrototype extends Controller, Method>(r: string, actionOptions: ActionOptions<HTTPContext>): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP HEAD action on a route, its input validated against a DTO, with action
+ * options: the shorthand of `@HTTPAction(route, 'head', …)`. 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).
+ * With Fastify, a GET action also answers the HEAD requests of its route unless the route has a HEAD action.
+ * @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 HEAD<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/HEAD.js

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

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

@@ -0,0 +1,80 @@
+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 OPTIONS action on a route, to describe the communication options of a
+ * resource: the shorthand of `@HTTPAction(route, 'options', …)`. 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 {Controller, Result, type StatusResult} from 'lakutata/com/entrypoint'
+ * import {OPTIONS} from 'lakutata/decorator/ctrl'
+ *
+ * class UploadController extends Controller {
+ *     //OPTIONS /uploads: answered with the status 204 and the header Allow
+ *     @OPTIONS('/uploads')
+ *     public async options(): Promise<StatusResult> {
+ *         return Result.status(204, undefined, {Allow: 'OPTIONS, POST'})
+ *     }
+ * }
+ * ```
+ */
+export declare function OPTIONS<ClassPrototype extends Controller, Method>(r: string): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP OPTIONS action on a route, its input validated against a DTO: the shorthand
+ * of `@HTTPAction(route, 'options', …)`. 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 OPTIONS<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 OPTIONS action on a route, with action options: the shorthand of
+ * `@HTTPAction(route, 'options', …)`. 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 OPTIONS<ClassPrototype extends Controller, Method>(r: string, actionOptions: ActionOptions<HTTPContext>): MethodDecorator<ClassPrototype, Method, ControllerProperty<ClassPrototype>>;
+/**
+ * Expose the controller method as an HTTP OPTIONS action on a route, its input validated against a DTO, with action
+ * options: the shorthand of `@HTTPAction(route, 'options', …)`. 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 OPTIONS<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/OPTIONS.js

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