@lakutata/entrypoint 3.0.0-beta.0

package/dist/esm/channel/Channel.js

@@ -0,0 +1,100 @@
+import { InvalidChannelException } from '../exceptions/InvalidChannelException.js';
+const channels = new Map();
+/**
+ * Define a channel. A package providing a channel defines it when it is loaded; defining the same definition object
+ * again does nothing.
+ * @param definition The channel's definition.
+ * @returns The same definition.
+ * @throws {InvalidChannelException} When another definition already has the name.
+ * @example
+ * ```typescript
+ * import {Controller, ControllerActionNotFoundException, type BaseContext, type ControllerProperty} from 'lakutata/com/entrypoint'
+ * import {defineChannel, registerControllerAction, type ChannelEntry} from '@lakutata/entrypoint/channel'
+ * import {FlexibleDTO} from 'lakutata/dtos'
+ *
+ * //A channel of the messages of a queue, addressed by their topic
+ * export const QueueChannel = defineChannel({
+ *     name: 'queue',
+ *     kind: 'delivery',
+ *     contextType: 'QUEUE',
+ *     identify: (address): string => address.topic,
+ *     describe: (address): Record<string, unknown> => ({topic: address.topic}),
+ *     createMatcher: (entries: ChannelEntry[]) => ({
+ *         match: (context: BaseContext) => {
+ *             const entry: ChannelEntry | undefined = entries.find(candidate => candidate.details.pattern.topic === context.topic)
+ *             return entry ? {entry: entry} : undefined
+ *         }
+ *     }),
+ *     notFound: (context: BaseContext): Error => new ControllerActionNotFoundException('No action handles the topic {topic}', {topic: context.topic})
+ * })
+ *
+ * //The decorator declaring the actions of the channel
+ * export function OnMessage(topic: string) {
+ *     return <ClassPrototype extends Controller>(target: ClassPrototype, propertyKey: ControllerProperty<ClassPrototype>): void => {
+ *         registerControllerAction(QueueChannel, target, propertyKey, {topic: topic}, FlexibleDTO, {})
+ *     }
+ * }
+ * ```
+ */
+export function defineChannel(definition) {
+    const defined = channels.get(definition.name);
+    if (defined && defined !== definition)
+        throw new InvalidChannelException('The channel "{0}" is already defined', [definition.name]);
+    channels.set(definition.name, definition);
+    return definition;
+}
+/**
+ * Get a defined channel.
+ * @param name The channel's name.
+ * @returns The channel's definition.
+ * @throws {InvalidChannelException} When no channel has the name.
+ * @example
+ * ```typescript
+ * import {getChannel, type ChannelDefinition} from '@lakutata/entrypoint/channel'
+ *
+ * const http: ChannelDefinition = getChannel('http')
+ * console.log(http.kind, http.contextType) //request HTTP
+ * ```
+ */
+export function getChannel(name) {
+    const definition = channels.get(name);
+    if (!definition)
+        throw new InvalidChannelException('The channel "{0}" is not defined', [name]);
+    return definition;
+}
+/**
+ * Whether a channel is defined.
+ * @param name The channel's name.
+ * @returns `true` when a channel has the name.
+ * @example
+ * ```typescript
+ * import {hasChannel} from '@lakutata/entrypoint/channel'
+ *
+ * console.log(hasChannel('schedule')) //true
+ * console.log(hasChannel('queue')) //false until a package defines it
+ * ```
+ */
+export function hasChannel(name) {
+    return channels.has(name);
+}
+/**
+ * Find the channel whose requests have a context type.
+ * @param contextType The `type` of a request context (`HTTP`, `CLI`…).
+ * @returns The first channel defined with the context type, `undefined` when there is none.
+ * @example
+ * ```typescript
+ * import {ContextType, type BaseContext} from 'lakutata/com/entrypoint'
+ * import {getChannelByContextType} from '@lakutata/entrypoint/channel'
+ *
+ * declare const context: BaseContext
+ *
+ * console.log(getChannelByContextType(ContextType.SERVICE)?.name) //service
+ * console.log(getChannelByContextType(context.type)?.name)
+ * ```
+ */
+export function getChannelByContextType(contextType) {
+    for (const definition of channels.values())
+        if (definition.contextType === contextType)
+            return definition;
+    return undefined;
+}

package/dist/esm/channel/EntrypointAdapter.js

@@ -0,0 +1,39 @@
+/**
+ * Whether a value is an adapter: an object with a string `channel` and a `start` function.
+ * @param value The value to check.
+ * @returns `true` when the value is an adapter.
+ * @example
+ * ```typescript
+ * import {expressHTTPEntrypoint} from 'lakutata/adapter/express'
+ * import {isEntrypointAdapter} from '@lakutata/entrypoint/channel'
+ *
+ * console.log(isEntrypointAdapter(expressHTTPEntrypoint())) //true
+ * console.log(isEntrypointAdapter({channel: 'http'})) //false: no start function
+ * ```
+ */
+export function isEntrypointAdapter(value) {
+    return !!value && typeof value === 'object' && typeof value.channel === 'string' && typeof value.start === 'function';
+}
+/**
+ * Map the commands of CLI actions to the JSON schemas of their input, as a CLI adapter builds its commands from.
+ * @param actions The CLI channel's actions ({@link ChannelRuntime.actions} of a CLI adapter).
+ * @returns Each command mapped to its input's JSON schema; an action without command is mapped under `undefined`.
+ * @example
+ * ```typescript
+ * import {type CLIContext, type EntrypointAdapter} from 'lakutata/com/entrypoint'
+ * import {commandMap} from '@lakutata/entrypoint/channel'
+ *
+ * //A CLI adapter printing the commands and their options
+ * export const HelpCLIEntrypoint: EntrypointAdapter<CLIContext> = {
+ *     channel: 'cli',
+ *     start: (runtime): void => {
+ *         for (const [command, schema] of commandMap(runtime.actions)) {
+ *             console.log(command, Object.keys(schema.properties ?? {}).join(' '))
+ *         }
+ *     }
+ * }
+ * ```
+ */
+export function commandMap(actions) {
+    return new Map(actions.map((action) => [action.command, action.jsonSchema]));
+}

package/dist/esm/context/BaseContext.js

@@ -0,0 +1,87 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect, IndexSignature } from '@lakutata/core/decorator/dto';
+/**
+ * The kinds of the request contexts of the built-in channels, held by `BaseContext.type`.
+ */
+export var ContextType;
+(function (ContextType) {
+    /**
+     * A command of a CLI adapter (`CLIContext`).
+     */
+    ContextType["CLI"] = "CLI";
+    /**
+     * A request of an HTTP adapter (`HTTPContext`).
+     */
+    ContextType["HTTP"] = "HTTP";
+    /**
+     * A message of a service adapter: Socket.IO, JSON-RPC, Electron IPC, HTTP service (`ServiceContext`).
+     */
+    ContextType["SERVICE"] = "SERVICE";
+    /**
+     * A run of a scheduled action (`ScheduleContext`).
+     */
+    ContextType["SCHEDULE"] = "SCHEDULE";
+})(ContextType || (ContextType = {}));
+/**
+ * The context of a request: what an adapter knows about it, given to the controller (`this.context`), the middlewares
+ * (`invocation.context`) and the access control rules. Each channel has its subclass (`HTTPContext`, `CLIContext`,
+ * `ServiceContext`, `ScheduleContext`); test it with `instanceof` in an action serving several channels. A context is
+ * a DTO: its properties are validated when it is created and when they change; it also holds the extra properties
+ * given by its adapter (the Socket.IO socket, the JSON-RPC request), read by the adapters' helpers
+ * (`socketOfContext`…). The adapters create the contexts: an application only reads them.
+ * @example
+ * ```typescript
+ * import {Controller, CLIContext, HTTPContext, ServiceContext} from 'lakutata/com/entrypoint'
+ * import {CLIAction, GET, ServiceAction} from 'lakutata/decorator/ctrl'
+ *
+ * class VersionController extends Controller {
+ *     //One action for the three channels: the context tells them apart
+ *     @GET('/version')
+ *     @CLIAction('version')
+ *     @ServiceAction({act: 'version'})
+ *     public async version(): Promise<{ version: string, via: string }> {
+ *         let via: string = this.context.type
+ *         if (this.context instanceof HTTPContext) via = `${this.context.method.toUpperCase()} ${this.context.route}`
+ *         if (this.context instanceof CLIContext) via = `the command ${this.context.command}`
+ *         if (this.context instanceof ServiceContext) via = `the client ${this.context.clientId ?? 'unknown'}`
+ *         return {version: '1.0.0', via: via}
+ *     }
+ * }
+ * ```
+ */
+let BaseContext = class BaseContext extends DTO {
+    /**
+     * Create a context, validating its properties.
+     * @param params The properties of the context: its `type`, its `data`, and those of its channel.
+     * @throws {InvalidValueException} When a property is invalid or a required one is missing.
+     */
+    constructor(params) {
+        super(params);
+    }
+};
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], BaseContext.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.Object().pattern(DTO.String(), DTO.Any()).required()),
+    __metadata("design:type", Object)
+], BaseContext.prototype, "data", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], BaseContext.prototype, "locale", void 0);
+BaseContext = __decorate([
+    IndexSignature(DTO.Any()),
+    __metadata("design:paramtypes", [Object])
+], BaseContext);
+export { BaseContext };

package/dist/esm/context/CLIContext.js

@@ -0,0 +1,49 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { BaseContext, ContextType } from './BaseContext.js';
+import { Expect } from '@lakutata/core/decorator/dto';
+import { DTO } from '@lakutata/core';
+/**
+ * The context of a command run by a CLI adapter (`commanderCLIEntrypoint`): `this.context` of a controller action
+ * declared with `@CLIAction`, when it runs as a command. Its `data` holds the positional arguments and the options of
+ * the command, before their validation.
+ * @example
+ * ```typescript
+ * import {Controller, CLIContext} from 'lakutata/com/entrypoint'
+ * import {CLIAction} from 'lakutata/decorator/ctrl'
+ *
+ * class CacheController extends Controller {
+ *     //"app cache clear" prints "cache clear: done"
+ *     @CLIAction('cache clear')
+ *     public async clear(): Promise<string> {
+ *         const command: string = this.context instanceof CLIContext ? this.context.command : 'unknown'
+ *         return `${command}: done`
+ *     }
+ * }
+ * ```
+ */
+export class CLIContext extends BaseContext {
+    /**
+     * Create the context of a command, validating its properties.
+     * @param params The command and its data.
+     * @throws {InvalidValueException} When a property is invalid or a required one is missing.
+     */
+    constructor(params) {
+        super(params);
+    }
+}
+__decorate([
+    Expect(DTO.String().valid(ContextType.CLI).default(ContextType.CLI)),
+    __metadata("design:type", String)
+], CLIContext.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], CLIContext.prototype, "command", void 0);

package/dist/esm/context/HTTPContext.js

@@ -0,0 +1,74 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+import { BaseContext, ContextType } from './BaseContext.js';
+import { IncomingMessage, ServerResponse } from 'node:http';
+/**
+ * The context of a request served by an HTTP adapter (`expressHTTPEntrypoint`, `fastifyHTTPEntrypoint`):
+ * `this.context` of a controller action declared with `@HTTPAction` or `@GET`…, when it runs for an HTTP request. It
+ * gives the Node.js request and response, to read or set headers; once an action has sent the response itself (its
+ * headers sent), the adapter writes neither its value nor its error.
+ * @example
+ * ```typescript
+ * import {Controller, HTTPContext} from 'lakutata/com/entrypoint'
+ * import {GET} from 'lakutata/decorator/ctrl'
+ *
+ * class AgentController extends Controller {
+ *     //GET /agent: answered with the header Cache-Control and the JSON {"agent": "curl/8.0", "route": "/agent"}
+ *     @GET('/agent')
+ *     public async agent(): Promise<{ agent: string, route: string }> {
+ *         if (!(this.context instanceof HTTPContext)) return {agent: '', route: ''}
+ *         this.context.response.setHeader('Cache-Control', 'no-store')
+ *         return {agent: this.context.request.headers['user-agent'] ?? '', route: this.context.route}
+ *     }
+ * }
+ * ```
+ */
+export class HTTPContext extends BaseContext {
+    /**
+     * Create the context of an HTTP request, validating its properties.
+     * @param params The route, the method, the request, the response and the data of the request.
+     * @throws {InvalidValueException} When a property is invalid or a required one is missing.
+     */
+    constructor(params) {
+        super(params);
+    }
+}
+__decorate([
+    Expect(DTO.String().valid(ContextType.HTTP).default(ContextType.HTTP)),
+    __metadata("design:type", String)
+], HTTPContext.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], HTTPContext.prototype, "route", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], HTTPContext.prototype, "method", void 0);
+__decorate([
+    Expect(DTO.InstanceOf(IncomingMessage)),
+    __metadata("design:type", IncomingMessage
+    /**
+     * The Node.js response (the raw reply of Fastify, the Express response).
+     */
+    )
+], HTTPContext.prototype, "request", void 0);
+__decorate([
+    Expect(DTO.InstanceOf(ServerResponse)),
+    __metadata("design:type", ServerResponse
+    /**
+     * Create the context of an HTTP request, validating its properties.
+     * @param params The route, the method, the request, the response and the data of the request.
+     * @throws {InvalidValueException} When a property is invalid or a required one is missing.
+     */
+    )
+], HTTPContext.prototype, "response", void 0);

package/dist/esm/context/ScheduleContext.js

@@ -0,0 +1,61 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { BaseContext, ContextType } from './BaseContext.js';
+import { Expect } from '@lakutata/core/decorator/dto';
+import { DTO } from '@lakutata/core';
+/**
+ * The context of a run of a scheduled action (`scheduleEntrypoint`): `this.context` of a controller action declared
+ * with `@Schedule`, when the schedule runs it. Its `data` is an empty object.
+ * @example
+ * ```typescript
+ * import {Controller, ScheduleContext} from 'lakutata/com/entrypoint'
+ * import {Schedule} from 'lakutata/decorator/ctrl'
+ *
+ * class ReportController extends Controller {
+ *     //Every hour: logs "run 1 of every 1h, planned at …", then "run 2…"
+ *     @Schedule('1h')
+ *     public async hourly(): Promise<void> {
+ *         if (!(this.context instanceof ScheduleContext)) return
+ *         const delay: number = Date.now() - this.context.scheduledAt.getTime()
+ *         console.log(`run ${this.context.run} of ${this.context.schedule}, planned at ${this.context.scheduledAt.toISOString()} (${delay}ms late)`)
+ *     }
+ * }
+ * ```
+ */
+export class ScheduleContext extends BaseContext {
+    /**
+     * Create the context of a scheduled run, validating its properties.
+     * @param params The schedule, the planned time, the run number and the data of the run.
+     * @throws {InvalidValueException} When a property is invalid or a required one is missing.
+     */
+    constructor(params) {
+        super(params);
+    }
+}
+__decorate([
+    Expect(DTO.String().valid(ContextType.SCHEDULE).default(ContextType.SCHEDULE)),
+    __metadata("design:type", String)
+], ScheduleContext.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], ScheduleContext.prototype, "schedule", void 0);
+__decorate([
+    Expect(DTO.Date().required()),
+    __metadata("design:type", Date
+    /**
+     * The number of the run in this process, from 1, counting the runs started (not the skipped ones).
+     */
+    )
+], ScheduleContext.prototype, "scheduledAt", void 0);
+__decorate([
+    Expect(DTO.Number().integer().min(1).required()),
+    __metadata("design:type", Number)
+], ScheduleContext.prototype, "run", void 0);

package/dist/esm/context/ServiceContext.js

@@ -0,0 +1,58 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { cloneDeep } from '@lakutata/utils';
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+import { BaseContext, ContextType } from './BaseContext.js';
+/**
+ * The context of a message received by a service adapter (`socketIOServiceEntrypoint`, `jsonRPCServiceEntrypoint`,
+ * `electronIPCServiceEntrypoint`, `httpServiceEntrypoint`): `this.context` of a controller action declared with
+ * `@ServiceAction`, when it runs for a message. Its `input` is the whole message, matched against the actions'
+ * patterns; its `data` is the message without the keys of the matched pattern. The adapters' helpers give the
+ * transport objects (`socketOfContext`, `httpRequestOfContext`, `ipcEventOfContext`, `jsonRPCRequestOfContext`).
+ * @example
+ * ```typescript
+ * import {Controller, ServiceContext} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ *
+ * class ChatController extends Controller {
+ *     //The message {act: 'join', room: 'lobby'}: answered with the payload {room: 'lobby', client: <the client id>}
+ *     @ServiceAction({act: 'join'})
+ *     public async join(input: { room: string }): Promise<{ room: string, client?: string }> {
+ *         const client: string | undefined = this.context instanceof ServiceContext ? this.context.clientId : undefined
+ *         return {room: input.room, client: client}
+ *     }
+ * }
+ * ```
+ */
+export class ServiceContext extends BaseContext {
+    /**
+     * Create the context of a service message, validating its properties; `input` is set to a copy of `data`.
+     * @param params The message (`data`), its client id, and the adapter's extra properties.
+     * @throws {InvalidValueException} When a property is invalid or a required one is missing.
+     */
+    constructor(params) {
+        //A deep copy: the pattern keys removed from the data once matched, nested ones included, stay in the input
+        params = { ...params, input: cloneDeep(params.data ?? {}) };
+        super(params);
+    }
+}
+__decorate([
+    Expect(DTO.String().valid(ContextType.SERVICE).default(ContextType.SERVICE)),
+    __metadata("design:type", String)
+], ServiceContext.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.Object().pattern(DTO.String(), DTO.Any()).required()),
+    __metadata("design:type", Object)
+], ServiceContext.prototype, "input", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ServiceContext.prototype, "clientId", void 0);

package/dist/esm/decorators/CLIAction.js

@@ -0,0 +1,10 @@
+import { registerCLIAction } from '../lib/ControllerEntrypoint.js';
+import { ActionOptions } from '../lib/ActionOptions.js';
+import { getActionDTOAndOptions } from '../lib/GetActionDTOAndOptions.js';
+export function CLIAction(command, dtoConstructorOrOptions, options) {
+    return (target, propertyKey, descriptor) => {
+        const [dtoConstructor, actionOptions] = getActionDTOAndOptions(dtoConstructorOrOptions, options);
+        registerCLIAction(command, target, propertyKey, dtoConstructor, ActionOptions.validate(actionOptions));
+        return descriptor;
+    };
+}

package/dist/esm/decorators/HTTPAction.js

@@ -0,0 +1,11 @@
+import { registerHTTPAction } from '../lib/ControllerEntrypoint.js';
+import { getActionDTOAndOptions } from '../lib/GetActionDTOAndOptions.js';
+export function HTTPAction(r, m, dtoConstructorOrOptions, options) {
+    return (target, propertyKey, descriptor) => {
+        const route = r.toString();
+        const methods = Array.isArray(m) ? m : [m];
+        const [dtoConstructor, actionOptions] = getActionDTOAndOptions(dtoConstructorOrOptions, options);
+        registerHTTPAction(route, methods, target, propertyKey, dtoConstructor, actionOptions);
+        return descriptor;
+    };
+}

package/dist/esm/decorators/Prefix.js

@@ -0,0 +1,45 @@
+import { setPrefix } from '../lib/Prefix.js';
+/**
+ * Prefix the addresses of a controller's actions, and of the controllers extending it unless they declare their own
+ * prefixes (a subclass's `@Prefix` replaces its parent's, it does not add to it):
+ * - `route` is prepended to the routes of the HTTP actions (`'/users'` and `'/:id'` give `'/users/:id'`);
+ * - `command` is prepended to the commands of the CLI actions, joined by ":" (`'user'` and `'get'` give `'user:get'`);
+ * - `pattern` is merged into the patterns of the service actions (`{resource: 'user'}` and `{act: 'get'}` give
+ *   `{resource: 'user', act: 'get'}`).
+ *
+ * A channel without its prefix keeps the addresses as declared; the scheduled actions have none. The prefixes apply when
+ * the entrypoint registers the controller, and the prefixed actions are named after the registered controller, so that
+ * the controllers sharing a parent have distinct actions. Several `@Prefix` on a class merge their options.
+ * @param options The prefixes: `route`, `command` and `pattern`, each optional; the packages of other channels add
+ * their own.
+ * @returns The class decorator.
+ * @throws {InvalidValueException} When the class is declared, if the options are invalid.
+ * @throws {InvalidPrefixException} When the entrypoint initializes, if the pattern prefix sets a key that the pattern
+ * of an action sets to another value.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Controller} from 'lakutata/com/entrypoint'
+ * import {CLIAction, GET, Prefix, ServiceAction} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ *
+ * class UserIdDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public id!: string
+ * }
+ *
+ * @Prefix({route: '/users', command: 'user', pattern: {resource: 'user'}})
+ * class UserController extends Controller {
+ *     //GET /users/:id, the command "user:get <id>" and the message {resource: 'user', act: 'get', id: …}
+ *     @GET('/:id', UserIdDTO)
+ *     @CLIAction('get <id>', UserIdDTO)
+ *     @ServiceAction({act: 'get'}, UserIdDTO)
+ *     public async get(input: UserIdDTO): Promise<{ id: string }> {
+ *         return {id: input.id}
+ *     }
+ * }
+ * ```
+ */
+export function Prefix(options) {
+    return (target) => setPrefix(target, options);
+}

package/dist/esm/decorators/Schedule.js

@@ -0,0 +1,61 @@
+import { registerControllerAction } from '../lib/ControllerEntrypoint.js';
+import { getActionDTOAndOptions } from '../lib/GetActionDTOAndOptions.js';
+import { ScheduleChannel } from '../channel/BuiltinChannels.js';
+import { Cron, parseDuration } from '../lib/schedule/Cron.js';
+/**
+ * A key for each scheduled action, telling apart the actions of a same schedule
+ */
+let keys = 0;
+/**
+ * The address of a schedule
+ * @param schedule
+ */
+function ScheduleAddress(schedule) {
+    let options;
+    if (typeof schedule === 'string') {
+        //A text is an interval ("30s") when it is one, a cron expression otherwise
+        let every;
+        try {
+            every = parseDuration(schedule);
+        }
+        catch {
+            every = undefined;
+        }
+        options = every === undefined ? { cron: schedule } : { every: schedule };
+    }
+    else {
+        options = schedule;
+    }
+    const address = {};
+    if (options.every !== undefined) {
+        address.every = parseDuration(options.every);
+        address.schedule = `every ${typeof options.every === 'number' ? `${options.every}ms` : options.every}`;
+    }
+    else if (options.cron !== undefined) {
+        //The expression is checked now, not at the first run
+        new Cron(options.cron, options.timezone);
+        address.cron = options.cron;
+        address.schedule = `cron ${options.cron}`;
+        if (options.timezone)
+            address.timezone = options.timezone;
+    }
+    else {
+        throw new SyntaxError('A schedule is an interval (every) or a cron expression (cron)');
+    }
+    address.overlap = options.overlap === true;
+    address.immediate = options.immediate === true;
+    if (options.exclusive) {
+        address.exclusive = (typeof options.exclusive === 'object' ? options.exclusive.mutex : undefined) ?? 'mutex';
+        if (typeof options.exclusive === 'object' && options.exclusive.key)
+            address.exclusiveKey = options.exclusive.key;
+    }
+    address.key = `s${++keys}`;
+    return address;
+}
+export function Schedule(schedule, actionOptions) {
+    return (target, propertyKey, descriptor) => {
+        const [dtoConstructor, options] = getActionDTOAndOptions(actionOptions ?? {});
+        registerControllerAction(ScheduleChannel, target, propertyKey, ScheduleAddress(schedule), dtoConstructor, options);
+        return descriptor;
+    };
+}

package/dist/esm/decorators/ServiceAction.js

@@ -0,0 +1,9 @@
+import { registerServiceAction } from '../lib/ControllerEntrypoint.js';
+import { getActionDTOAndOptions } from '../lib/GetActionDTOAndOptions.js';
+export function ServiceAction(pattern, dtoConstructorOrOptions, options) {
+    return (target, propertyKey, descriptor) => {
+        const [dtoConstructor, actionOptions] = getActionDTOAndOptions(dtoConstructorOrOptions, options);
+        registerServiceAction(pattern, target, propertyKey, dtoConstructor, actionOptions);
+        return descriptor;
+    };
+}