@lakutata/entrypoint 3.0.0-beta.0

package/dist/types/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/types/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/types/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/types/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/types/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/types/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/types/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>>;