@lakutata/entrypoint 3.0.0-beta.0

package/dist/types/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/types/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/types/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/types/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/types/exceptions/InvalidActionGroupException.d.ts

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

package/dist/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/exports/CTRLDecorators.d.ts

@@ -0,0 +1,13 @@
+export { CLIAction } from '../decorators/CLIAction.js';
+export { HTTPAction } from '../decorators/HTTPAction.js';
+export { DELETE } from '../decorators/http/DELETE.js';
+export { GET } from '../decorators/http/GET.js';
+export { HEAD } from '../decorators/http/HEAD.js';
+export { OPTIONS } from '../decorators/http/OPTIONS.js';
+export { PATCH } from '../decorators/http/PATCH.js';
+export { POST } from '../decorators/http/POST.js';
+export { PUT } from '../decorators/http/PUT.js';
+export { ServiceAction } from '../decorators/ServiceAction.js';
+export { UseMiddlewares } from '../decorators/UseMiddlewares.js';
+export { Prefix } from '../decorators/Prefix.js';
+export { Schedule, type ScheduleOptions } from '../decorators/Schedule.js';

package/dist/types/exports/Channel.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The API of the packages providing a channel or an adapter
+ */
+export { defineChannel, getChannel, hasChannel, getChannelByContextType } from '../channel/Channel.js';
+export type { ChannelDefinition, ChannelKind, ChannelEntry, ChannelMatch, ChannelMatcher } from '../channel/Channel.js';
+export { isEntrypointAdapter, commandMap } from '../channel/EntrypointAdapter.js';
+export type { EntrypointAdapter, ChannelRuntime, ChannelActionInfo, DispatchOptions } from '../channel/EntrypointAdapter.js';
+export { registerControllerAction } from '../lib/ControllerEntrypoint.js';
+export type { ActionDetails, ActionInfo } from '../lib/ControllerEntrypoint.js';
+export { getActionDTOAndOptions } from '../lib/GetActionDTOAndOptions.js';
+export { ActionOptions } from '../lib/ActionOptions.js';
+export { HTTPChannel, CLIChannel, ServiceChannel, ScheduleChannel } from '../channel/BuiltinChannels.js';
+export { ServiceResponseCodec, type ServiceResponse } from '../lib/ServiceResponseCodec.js';
+export { getPrefix, setPrefix } from '../lib/Prefix.js';

package/dist/types/exports/CommanderAdapter.d.ts

@@ -0,0 +1 @@
+export { commanderCLIEntrypoint, type CommanderCLIEntrypointOptions, type CLIText, type CLITranslate } from '../adapter/commander/CommanderCLIEntrypoint.js';

package/dist/types/exports/ElectronAdapter.d.ts

@@ -0,0 +1 @@
+export { electronIPCServiceEntrypoint, ipcEventOfContext, type ElectronIPCServiceEntrypointOptions, type IPCMain, type IPCInvokeEvent, type IPCSender } from '../adapter/electron/ElectronIPCServiceEntrypoint.js';

package/dist/types/exports/Entrypoint.d.ts

@@ -0,0 +1,24 @@
+export * from '../Entrypoint.js';
+export * from '../lib/Controller.js';
+export * from '../lib/AccessControlRule.js';
+export * from '../exceptions/AccessDeniedException.js';
+export * from '../exceptions/DuplicateActionNameException.js';
+export * from '../exceptions/ControllerActionNotFoundException.js';
+export { AccessControl } from '../lib/AccessControl.js';
+export { Middleware, type ActionInvocation, type Next, type MiddlewareHandler, type MiddlewareDefinition } from '../lib/Middleware.js';
+export * from '../exceptions/InvalidMiddlewareException.js';
+export * from '../exceptions/MiddlewareNextCalledException.js';
+export { PrefixOptions } from '../lib/Prefix.js';
+export * from '../exceptions/InvalidPrefixException.js';
+export { ActionResult } from '../lib/ActionResult.js';
+export type { ActionInfo } from '../lib/ControllerEntrypoint.js';
+export type { EntrypointAdapter, ChannelRuntime, ChannelActionInfo, DispatchOptions } from '../channel/EntrypointAdapter.js';
+export * from '../exceptions/InvalidChannelException.js';
+export * from '../exceptions/InvalidEntrypointAdapterException.js';
+export { Result, StatusResult, FileResult, EventsResult, type FileResultOptions, type SendEvent, type EventsProducer } from '../lib/Result.js';
+export * from '../exceptions/RouteNotFoundException.js';
+export * from '../exceptions/EntrypointStoppedException.js';
+export * from '../exceptions/ServiceInvokeException.js';
+export { scheduleEntrypoint, type ScheduleEntrypointOptions } from '../adapter/schedule/ScheduleEntrypoint.js';
+export { httpServiceEntrypoint, httpRequestOfContext, type HTTPServiceEntrypointOptions } from '../adapter/http/HTTPServiceEntrypoint.js';
+export { Cron, parseDuration } from '../lib/schedule/Cron.js';

package/dist/types/exports/ExpressAdapter.d.ts

@@ -0,0 +1,4 @@
+export { expressHTTPEntrypoint, type ExpressHTTPEntrypointOptions, type ExpressHookContext } from '../adapter/express/ExpressHTTPEntrypoint.js';
+export { JSONResponder, jsonEnvelope, statusOfError, describeError, type ExpressResponder, type HTTPErrorOrigin, type JSONEnvelopeOptions } from '../adapter/express/Responders.js';
+export { staticUI, type StaticUIOptions } from '../adapter/express/StaticUI.js';
+export { type ErrorDescription } from '../types/ErrorDescription.js';

package/dist/types/exports/FastifyAdapter.d.ts

@@ -0,0 +1,4 @@
+export { fastifyHTTPEntrypoint, type FastifyHTTPEntrypointOptions, type FastifyHookContext } from '../adapter/fastify/FastifyHTTPEntrypoint.js';
+export { FastifyJSONResponder, fastifyJSONEnvelope, type FastifyResponder, type FastifyJSONEnvelopeOptions } from '../adapter/fastify/Responders.js';
+export { statusOfError, describeError, type HTTPErrorOrigin } from '../lib/HTTPErrors.js';
+export { type ErrorDescription } from '../types/ErrorDescription.js';

package/dist/types/exports/JSONRPCAdapter.d.ts

@@ -0,0 +1,2 @@
+export { jsonRPCServiceEntrypoint, type JSONRPCServiceEntrypointOptions } from '../adapter/jsonrpc/JSONRPCServiceEntrypoint.js';
+export { JSONRPCErrorCode, jsonRPCRequestOfContext, type JSONRPCMappingOptions, type JSONRPCRequest, type JSONRPCRequestInfo, type JSONRPCResponse } from '../adapter/jsonrpc/JSONRPCProtocol.js';

package/dist/types/exports/SocketIOAdapter.d.ts

@@ -0,0 +1 @@
+export { socketIOServiceEntrypoint, socketOfContext, type SocketIOServiceEntrypointOptions } from '../adapter/socket.io/SocketIOServiceEntrypoint.js';

package/dist/types/lib/AccessControl.d.ts

@@ -0,0 +1,118 @@
+import { BaseObject, Exception, Container, IBaseObjectConstructor, FunctionSchema } from '@lakutata/core';
+import { BaseActionInfo, CLIActionInfo, CLIContext, ContextType, HTTPActionInfo, HTTPContext, ServiceActionInfo, ServiceContext } from '../Entrypoint.js';
+import { ActionDetails, type ActionInfo } from './ControllerEntrypoint.js';
+import { AccessControlRule, AccessControlRuleHandler } from './AccessControlRule.js';
+/**
+ * The access control of the entrypoint's actions: it checks a request to an action declared with `acl: true` against
+ * the entrypoint's rules and the action's own `rule`, or against the action's `rule` alone when `acl` is off. The
+ * entrypoint calls {@link AccessControl.run} for each request, after the input validation and before the action; a
+ * subclass of the entrypoint may replace it with a subclass (its protected `accessControl` property), for example to
+ * audit the decisions.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {AccessControl, Controller, Entrypoint} from 'lakutata/com/entrypoint'
+ * import {GET} from 'lakutata/decorator/ctrl'
+ *
+ * //Log every access decision
+ * class AuditedAccessControl extends AccessControl {
+ *     protected async match(): Promise<boolean> {
+ *         const allowed: boolean = await super.match()
+ *         console.log(`${this.target.name}: ${allowed ? 'allowed' : 'denied'}`)
+ *         return allowed
+ *     }
+ * }
+ *
+ * class AuditedEntrypoint extends Entrypoint {
+ *     protected readonly accessControl: typeof AccessControl = AuditedAccessControl
+ * }
+ *
+ * class ReportController extends Controller {
+ *     @GET('/reports', {acl: true, rule: async (): Promise<boolean> => true})
+ *     public async list(): Promise<string[]> {
+ *         return []
+ *     }
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'report.app',
+ *     name: 'Report',
+ *     components: {
+ *         entrypoint: {class: AuditedEntrypoint, controllers: [ReportController]}
+ *     }
+ * }))
+ * ```
+ */
+export declare class AccessControl extends BaseObject {
+    /**
+     * The request's container, where the rules are created.
+     * @protected
+     */
+    protected readonly runtimeContainer: Container;
+    /**
+     * The descriptions of every action of the request's channel.
+     * @protected
+     */
+    protected readonly actions: HTTPActionInfo[] | ServiceActionInfo[] | CLIActionInfo[];
+    /**
+     * The requested action: its identity and options (without the channel's fields).
+     * @protected
+     */
+    protected readonly target: ActionInfo;
+    /**
+     * The request's context.
+     * @protected
+     */
+    protected readonly context: CLIContext | HTTPContext | ServiceContext;
+    /**
+     * The action's validated input.
+     * @protected
+     */
+    protected readonly input: Record<string, any>;
+    /**
+     * Called when the rules allow the request.
+     * @protected
+     */
+    protected readonly allowCallback: () => void;
+    /**
+     * Called when a rule denies the request, with the error a rule threw (none when a rule resolved `false`).
+     * @protected
+     */
+    protected readonly denyCallback: (error?: Error | Exception) => void;
+    /**
+     * The rules to check, in order: rule classes and rule functions.
+     * @protected
+     */
+    protected readonly rules: (IBaseObjectConstructor<AccessControlRule> | AccessControlRuleHandler<any>)[];
+    /**
+     * Schema of access control rule constructors, built only when it is used
+     * @protected
+     */
+    protected get accessControlRuleConstructorDTO(): FunctionSchema<typeof AccessControlRule>;
+    /**
+     * Check the rules and call the allow or deny callback.
+     * @protected
+     */
+    protected init(): Promise<void>;
+    /**
+     * Check the rules in order: a rule class is created in the request's container and checked when it supports the
+     * request's context type, a rule function is called with the context and the input.
+     * @returns `false` as soon as a rule resolves `false`, `true` when none does (no rule included).
+     * @throws {Error} The error a rule throws (the request is then denied with it).
+     * @protected
+     */
+    protected match(): Promise<boolean>;
+    /**
+     * Check the access to an action: with `acl: true`, against the rules then the action's own `rule`; with `acl`
+     * off, against the action's `rule` alone; without either, the request is allowed without check.
+     * @param rules The entrypoint's rule classes.
+     * @param runtimeContainer The request's container, where the access control and the rules are created.
+     * @param context The request's context.
+     * @param input The action's validated input.
+     * @param details The requested action.
+     * @param getActionsCallback Returns the descriptions of the actions of a context type's channel.
+     * @returns Whether the request is allowed, and when it is not, the error to fail it with: the error a rule
+     * threw, or an `AccessDeniedException`.
+     */
+    static run(rules: IBaseObjectConstructor<AccessControlRule>[], runtimeContainer: Container, context: CLIContext | HTTPContext | ServiceContext, input: Record<string, any>, details: ActionDetails, getActionsCallback: (type: ContextType | string) => BaseActionInfo[]): Promise<[boolean, Error | Exception | undefined]>;
+}

package/dist/types/lib/AccessControlRule.d.ts

@@ -0,0 +1,91 @@
+import { BaseObject, type ActionPattern } from '@lakutata/core';
+import { BaseContext, ContextType } from '../context/BaseContext.js';
+import { CLIActionInfo, HTTPActionInfo, ServiceActionInfo } from '../Entrypoint.js';
+import type { ActionInfo } from './ControllerEntrypoint.js';
+/**
+ * An action's own access rule (the `rule` action option): resolve `true` to allow the request, `false` to deny it with
+ * an `AccessDeniedException`; a thrown error denies it with that error.
+ * @param context The request's context.
+ * @param input The action's validated input.
+ * @returns Whether the request is allowed.
+ */
+export type AccessControlRuleHandler<T extends BaseContext<Record<string, any>>> = (context: T, input?: ActionPattern<any>) => Promise<boolean>;
+/**
+ * An access control rule, checked for the actions declared with `acl: true`: give the rule classes to the
+ * entrypoint's `rules` option. For each request to such an action, every rule supporting the request's context type
+ * is created in the request's container (its dependencies injected) and its {@link AccessControlRule.rule} called, in
+ * the order of the option; the first one resolving `false` denies the request with an `AccessDeniedException`, the
+ * first one throwing denies it with its error. A request no rule denies is allowed.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {AccessControlRule, buildEntrypoints, ContextType, Controller, type HTTPContext} from 'lakutata/com/entrypoint'
+ * import {DELETE} from 'lakutata/decorator/ctrl'
+ *
+ * //Only the requests of an administrator reach the actions of the "admin" group
+ * class AdminRule extends AccessControlRule<HTTPContext> {
+ *     public get supportContextTypes(): ContextType[] {
+ *         return [ContextType.HTTP]
+ *     }
+ *
+ *     public async rule(): Promise<boolean> {
+ *         if (!this.targetAction.groups.includes('admin')) return true
+ *         return this.context.request.headers['x-role'] === 'admin'
+ *     }
+ * }
+ *
+ * class UserController extends Controller {
+ *     @DELETE('/users/:id', {acl: true, groups: ['admin']})
+ *     public async remove(input: {id: string}): Promise<void> {
+ *     }
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'admin.app',
+ *     name: 'Admin',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [UserController],
+ *             rules: [AdminRule],
+ *             httpActionGroups: {admin: 'Administration'}
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export declare abstract class AccessControlRule<T extends BaseContext<Record<string, any>> = BaseContext<Record<string, any>>> extends BaseObject {
+    /**
+     * The request's context.
+     * @protected
+     */
+    protected readonly context: T;
+    /**
+     * The action's validated input.
+     * @protected
+     */
+    protected readonly input: ActionPattern<any>;
+    /**
+     * The descriptions of every action of the request's channel (to check the permissions an action requires against
+     * the others).
+     * @protected
+     */
+    protected readonly actions: HTTPActionInfo[] | ServiceActionInfo[] | CLIActionInfo[];
+    /**
+     * The requested action: its `id`, `name`, `description`, `groups`, `acl`, `rule` and `action`
+     * (`ControllerClass:method`). Its channel's fields (`route`, `command`, `pattern`), `controller`, `method` and
+     * `jsonSchema` are in {@link AccessControlRule.actions}, found by `id`.
+     * @protected
+     */
+    protected readonly targetAction: ActionInfo;
+    /**
+     * The context types of the requests the rule checks (`ContextType.HTTP`…, or the context type of another channel);
+     * for the other requests the rule is created but its {@link AccessControlRule.rule} is not called.
+     */
+    abstract get supportContextTypes(): ContextType[];
+    /**
+     * Check the request.
+     * @returns `true` to let the next rules check the request, `false` to deny it with an `AccessDeniedException`.
+     * @throws {Error} Any error, to deny the request with it.
+     */
+    abstract rule(): Promise<boolean>;
+}

package/dist/types/lib/ActionOptions.d.ts

@@ -0,0 +1,67 @@
+import { DTO } from '@lakutata/core';
+import type { AccessControlRuleHandler } from './AccessControlRule.js';
+import { BaseContext } from '../context/BaseContext.js';
+import type { MiddlewareDefinition } from './Middleware.js';
+/**
+ * The options of a controller action, the last argument of the action decorators (`@GET`, `@CLIAction`,
+ * `@ServiceAction`, `@Schedule`…).
+ * @example
+ * ```typescript
+ * import {Controller, type HTTPContext} from 'lakutata/com/entrypoint'
+ * import {type ActionOptions} from '@lakutata/entrypoint/channel'
+ * import {GET} from 'lakutata/decorator/ctrl'
+ *
+ * //Only the requests carrying the admin token reach the action
+ * const adminOnly: ActionOptions<HTTPContext> = {
+ *     acl: true,
+ *     name: 'listUsers',
+ *     description: 'List the users',
+ *     groups: ['admin'],
+ *     rule: async (context: HTTPContext): Promise<boolean> => context.request.headers.authorization === 'Bearer admin'
+ * }
+ *
+ * class UserController extends Controller {
+ *     @GET('/users', adminOnly)
+ *     public async list(): Promise<string[]> {
+ *         return []
+ *     }
+ * }
+ * ```
+ */
+export declare class ActionOptions<T extends BaseContext<Record<string, any>>> extends DTO {
+    /**
+     * Whether the entrypoint's access control rules are checked for the action; a request they deny fails with an
+     * `AccessDeniedException`. With no rule (or none supporting the request's context type), the access is
+     * allowed.
+     * @default false
+     */
+    acl?: boolean;
+    /**
+     * The action's name, unique within its channel among the controller methods (the addresses of one method may
+     * share it): `ControllerClass:method` when empty.
+     * @default ''
+     */
+    name?: string;
+    /**
+     * The action's description, listed with the action.
+     * @default ''
+     */
+    description?: string;
+    /**
+     * The ids of the action's groups; for HTTP, CLI and service actions each id must be a key of the entrypoint's
+     * action groups option (`httpActionGroups`…), or the entrypoint fails to initialize.
+     * @default []
+     */
+    groups?: string[];
+    /**
+     * The action's own access rule, checked after the entrypoint's rules when `acl` is on, and alone when it is off:
+     * resolving `false` denies the request (`AccessDeniedException`), throwing denies it with the thrown error.
+     */
+    rule?: AccessControlRuleHandler<T>;
+    /**
+     * The action's middlewares, run after the ones of the controller class and before the ones added to the method
+     * by `@UseMiddlewares`.
+     * @default []
+     */
+    middlewares?: MiddlewareDefinition[];
+}

package/dist/types/lib/ActionResult.d.ts

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

package/dist/types/lib/ApplicationOf.d.ts

@@ -0,0 +1,6 @@
+import { Application } from '@lakutata/core';
+/**
+ * The application a module belongs to (undefined out of an application: a container of the tests)
+ * @param module
+ */
+export declare function applicationOf(module: unknown): Application | undefined;

package/dist/types/lib/Controller.d.ts

@@ -0,0 +1,59 @@
+import { Provider } from '@lakutata/core';
+import { CLIContext } from '../context/CLIContext.js';
+import { HTTPContext } from '../context/HTTPContext.js';
+import { ServiceContext } from '../context/ServiceContext.js';
+import { BaseContext } from '../context/BaseContext.js';
+/**
+ * The names of a controller's own members (the ones {@link Controller} does not declare): the methods an action
+ * decorator may be applied to.
+ */
+export type ControllerProperty<ClassPrototype extends Controller> = Exclude<keyof ClassPrototype, keyof Controller>;
+/**
+ * The base class of the controllers: classes whose methods, decorated with the action decorators (`@GET`, `@POST`…,
+ * `@CLIAction`, `@ServiceAction`, `@Schedule`), serve the entrypoint's requests. Give the controller classes to the
+ * entrypoint's `controllers` option.
+ *
+ * A controller is scoped: each request creates its own instance in the request's container, with the request's
+ * context and abort signal, and destroys it when the request ends; its injected providers are scoped to the request
+ * too. An action method receives its input (the request's data merged with the address parameters, validated by the
+ * action's DTO, its defaults applied) and returns the result the adapter outputs; the actions declared in a parent
+ * class are served by the registered subclasses.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Controller, HTTPContext} from 'lakutata/com/entrypoint'
+ * import {CLIAction, GET, ServiceAction} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ *
+ * class FindUserDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public id: string
+ * }
+ *
+ * class UserController extends Controller {
+ *     //The same action over HTTP (GET /users/:id), the CLI (user-get --id 1) and the services ({act: 'user.get', id})
+ *     @GET('/users/:id', FindUserDTO)
+ *     @CLIAction('user-get', FindUserDTO)
+ *     @ServiceAction({act: 'user.get'}, FindUserDTO)
+ *     public async get(input: FindUserDTO): Promise<{id: string, via: string}> {
+ *         this.signal?.throwIfAborted()
+ *         const via: string = this.context instanceof HTTPContext ? this.context.request.headers['user-agent'] ?? 'http' : this.context.type
+ *         return {id: input.id, via: via}
+ *     }
+ * }
+ * ```
+ */
+export declare class Controller extends Provider {
+    /**
+     * The request's context: an {@link HTTPContext}, {@link CLIContext}, {@link ServiceContext}, or the context of
+     * another channel (`ScheduleContext`…); check its `type` or its class to tell them apart.
+     * @protected
+     */
+    protected readonly context: CLIContext | HTTPContext | ServiceContext | BaseContext;
+    /**
+     * Aborts when the request is aborted: its client gone (the HTTP connection closed, the gRPC call cancelled), its
+     * deadline passed, or the entrypoint stopping. Long-running actions should stop then: their result is dropped.
+     * @protected
+     */
+    protected readonly signal?: AbortSignal;
+}