@lakutata/entrypoint 3.0.0 → 3.1.0

package/dist/esm/lib/Preflight.js

@@ -0,0 +1,10 @@
+/**
+ * The headers of the answer to a preflight of a browser: the headers the request asks for are allowed (Authorization,
+ * the headers of the application…), the headers of the adapter when it asks for none
+ * @param request
+ * @param headers the CORS headers of the adapter
+ */
+export function preflightHeaders(request, headers) {
+    const requested = request.headers['access-control-request-headers'];
+    return { ...headers, 'Access-Control-Allow-Headers': requested || headers['Access-Control-Allow-Headers'], 'Vary': 'Access-Control-Request-Headers' };
+}

package/dist/esm/lib/ReadBody.js

@@ -0,0 +1,22 @@
+/**
+ * Read the body of a request, up to a limit. Over the limit, it fails with a 413 error at once, and the rest of the body
+ * is read and dropped: the connection stays usable for the next request of the client (closing it while the client
+ * still sends would fail its request, keeping it unread would fail the next one)
+ * @param request
+ * @param limit bytes
+ */
+export function readBody(request, limit) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        const end = () => resolve(Buffer.concat(chunks).toString('utf8'));
+        const collect = (chunk) => {
+            size += chunk.length;
+            if (size <= limit)
+                return void chunks.push(chunk);
+            request.off('data', collect).off('end', end).on('data', () => undefined);
+            reject(Object.assign(new Error(`The body of the request is larger than ${limit} bytes`), { statusCode: 413 }));
+        };
+        request.on('data', collect).once('end', end).once('error', reject);
+    });
+}

package/dist/esm/lib/pattern/FlattenPattern.js

@@ -0,0 +1,55 @@
+/**
+ * The nesting levels of a subject flattened: deeper than the patterns may be (2 levels)
+ */
+const MAX_DEPTH = 3;
+/**
+ * Whether a value is a plain object, whose properties a pattern compares one by one
+ * @param value
+ */
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/**
+ * A pattern with the properties of its nested objects as keys joined by dots (`{res: {name: 'user'}}` gives
+ * `{'res.name': 'user'}`): their values are compared one by one, not as the text of their object. An empty nested
+ * object stays a value.
+ * @param pattern
+ * @param prefix
+ */
+export function flattenPattern(pattern, prefix = '') {
+    const flat = {};
+    for (const [key, value] of Object.entries(pattern)) {
+        if (isPlainObject(value) && Object.keys(value).length) {
+            Object.assign(flat, flattenPattern(value, `${prefix}${key}.`));
+        }
+        else {
+            flat[`${prefix}${key}`] = value;
+        }
+    }
+    return flat;
+}
+/**
+ * A subject matched by the flattened patterns: its own properties, with the ones of its nested objects as keys joined
+ * by dots
+ * @param subject
+ */
+export function flattenSubject(subject) {
+    if (!isPlainObject(subject))
+        return subject;
+    const flat = { ...subject };
+    const add = (object, prefix, depth) => {
+        for (const [key, value] of Object.entries(object)) {
+            if (!isPlainObject(value))
+                continue;
+            for (const [nestedKey, nestedValue] of Object.entries(value))
+                flat[`${prefix}${key}.${nestedKey}`] = nestedValue;
+            if (depth < MAX_DEPTH)
+                add(value, `${prefix}${key}.`, depth + 1);
+        }
+    };
+    add(subject, '', 1);
+    return flat;
+}

package/dist/types/Entrypoint.d.ts

@@ -60,7 +60,7 @@ export type ServiceEntrypoint = (module: Module, handler: ServiceEntrypointHandl
 export type CLIMap = Map<string, JSONSchema>;
 /**
  * The HTTP actions given to an {@link HTTPEntrypoint}: each route (with its controller prefix) mapped to the set of
- * its HTTP methods (`GET`, `POST`…).
+ * its HTTP methods, as declared (`get`, `post`… from `@GET`, `@POST`…; `@HTTPAction` keeps the case it is given).
  */
 export type HTTPRouteMap<HTTPMethods = string> = Map<string, Set<HTTPMethods>>;
 /**
@@ -303,7 +303,8 @@ export interface EntrypointActions<T extends BaseActionInfo> {
  *                 if (cliMap.has(command)) console.log(await handler(new CLIContext({command: command, data: {}})))
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * }))
  * ```
  */
@@ -335,8 +336,9 @@ export declare const buildCLIEntrypoint: (entrypoint: CLIEntrypoint) => CLIEntry
  *             controllers: [HealthController],
  *             http: buildHTTPEntrypoint((module, routeMap, handler, registerDestroy): void => {
  *                 const server: Server = createServer(async (request, response): Promise<void> => {
+ *                     //The route map holds the routes and the methods as declared: '/health', 'get'
  *                     const route: string = (request.url ?? '/').split('?')[0]
- *                     const method: string = request.method ?? 'GET'
+ *                     const method: string = (request.method ?? 'GET').toLowerCase()
  *                     if (!routeMap.get(route)?.has(method)) {
  *                         response.writeHead(404).end()
  *                         return
@@ -353,7 +355,8 @@ export declare const buildCLIEntrypoint: (entrypoint: CLIEntrypoint) => CLIEntry
  *                 registerDestroy((): Promise<void> => new Promise((resolve): void => void server.close((): void => resolve())))
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * }))
  * ```
  */
@@ -394,7 +397,8 @@ export declare const buildHTTPEntrypoint: (entrypoint: HTTPEntrypoint) => HTTPEn
  *                 registerDestroy((): void => void bus.off('request', listener))
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * }))
  * ```
  */
@@ -444,7 +448,8 @@ export declare const buildServiceEntrypoint: (entrypoint: ServiceEntrypoint) =>
  *             http: expressHTTPEntrypoint({port: 3000}),
  *             schedule: scheduleEntrypoint()
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * }))
  * ```
  */
@@ -531,7 +536,8 @@ type StartedAdapter = {
  *                 http: expressHTTPEntrypoint({port: 3000}),
  *                 service: socketIOServiceEntrypoint({port: 3001})
  *             })
- *         }
+ *         },
+ *         bootstrap: ['entrypoint']
  *     }))
  *     .onLaunched(async (app: Application): Promise<void> => {
  *         const entrypoint: Entrypoint = await app.getObject<Entrypoint>('entrypoint')

package/dist/types/adapter/commander/CommanderCLIEntrypoint.d.ts

@@ -173,7 +173,7 @@ export type CommanderCLIEntrypointOptions = {
  *     @CLIAction('greet <name>', GreetDTO)
  *     public async greet(input: GreetDTO): Promise<string> {
  *         const text: string = `Hello, ${input.name}`
- *         return (input.loud ? text.toUpperCase() : text).repeat(input.times ?? 1)
+ *         return Array(input.times ?? 1).fill(input.loud ? text.toUpperCase() : text).join('\n')
  *     }
  * }
  *
@@ -185,7 +185,8 @@ export type CommanderCLIEntrypointOptions = {
  *             controllers: [GreetController],
  *             cli: commanderCLIEntrypoint({bin: 'tool', description: 'A greeting tool', version: '1.0.0'})
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */

package/dist/types/adapter/electron/ElectronIPCServiceEntrypoint.d.ts

@@ -187,7 +187,8 @@ export declare function ipcEventOfContext<Event extends IPCInvokeEvent = IPCInvo
  *             controllers: [EchoController],
  *             service: electronIPCServiceEntrypoint()
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  *
  * //In the preload script of a window

package/dist/types/adapter/express/ExpressHTTPEntrypoint.d.ts

@@ -20,7 +20,7 @@ export type ExpressHookContext = {
      */
     readonly server: Server;
     /**
-     * Each action route mapped to its HTTP methods, in lower case as declared (`'/users/:id'` → `{'get', 'delete'}`).
+     * Each action route mapped to its HTTP methods, as declared (`'/users/:id'` → `{'get', 'delete'}`).
      */
     readonly routes: Map<string, Set<string>>;
     /**
@@ -166,7 +166,8 @@ export type ExpressHTTPEntrypointOptions = {
  *                 fallback: staticUI('./ui/dist')
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */

package/dist/types/adapter/express/Responders.d.ts

@@ -100,7 +100,8 @@ export type JSONEnvelopeOptions = {
  *                 })
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */

package/dist/types/adapter/express/StaticUI.d.ts

@@ -76,7 +76,8 @@ export declare function assetsMaxAge(value: string | number | undefined): number
  *                 fallback: staticUI('./ui/dist', {assetsMaxAge: 86400})
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */

package/dist/types/adapter/fastify/FastifyHTTPEntrypoint.d.ts

@@ -150,7 +150,8 @@ export type FastifyHTTPEntrypointOptions = {
  *                 }
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */

package/dist/types/adapter/fastify/Responders.d.ts

@@ -99,7 +99,8 @@ export type FastifyJSONEnvelopeOptions = {
  *                 })
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */

package/dist/types/adapter/http/HTTPServiceEntrypoint.d.ts

@@ -66,8 +66,8 @@ export declare function httpRequestOfContext(context: ServiceContext): IncomingM
  * A request is a `POST` to the path whose JSON body holds the action's pattern and input (`{"cmd": "echo", "text":
  * "hi"}`). The response is always 200 with the body `{success, error, payload}` (see `ServiceResponseCodec`): `payload`
  * is the result, or `error` the whole error object when the action failed (no matching action, validation…). A body that
- * is not JSON or exceeds `limit` is answered with 400 and an error body; any other method or path with 404. The CORS
- * headers allow any origin.
+ * is not JSON is answered with 400 and an error body, a body over `limit` with 413; any other method or path with 404.
+ * The CORS headers allow any origin, and the headers a preflight asks for (`Authorization`…).
  *
  * The events pushed to the clients (`Entrypoint.notify`, `Entrypoint.broadcast`) are streamed as Server-Sent Events by
  * `GET <path>/events`: each event's name is the SSE event, its arguments the JSON array of its data. A client gives its
@@ -102,7 +102,8 @@ export declare function httpRequestOfContext(context: ServiceContext): IncomingM
  *             controllers: [EchoController],
  *             service: httpServiceEntrypoint({port: 3000, path: '/rpc'})
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  *
  * //A client: the response is {"success": true, "error": null, "payload": "hi"}

package/dist/types/adapter/http/HTTPServiceProxy.d.ts

@@ -0,0 +1,190 @@
+import { type ActionPattern, Component, type ComponentOptionsBuilder } from '@lakutata/core';
+/**
+ * The options of an {@link HTTPServiceProxy}, given to {@link buildHTTPServiceProxy}.
+ */
+export type BuildHTTPServiceProxyOptions = {
+    /**
+     * The address of the service: the URL of its `httpServiceEntrypoint`, with the adapter's `path`
+     * (`http://inventory:3000/`, `https://orders.internal/rpc`).
+     */
+    readonly url: string;
+    /**
+     * The headers sent with each call and with the event stream, such as `{Authorization: 'Bearer <token>'}`.
+     */
+    readonly headers?: Record<string, string>;
+    /**
+     * The client's id, sent as the `id` header of the calls and the `id` query parameter of the event stream: the
+     * service's `ServiceContext.clientId`, which `Entrypoint.notify()` pushes events to. Give a stable one to receive
+     * the events across restarts. At most 200 characters.
+     * @default a random UUID
+     */
+    readonly clientId?: string;
+    /**
+     * The delay, in milliseconds, before the event stream is opened again once it ended or failed (the service
+     * restarted, unreachable). A non-negative integer.
+     * @default 1000
+     */
+    readonly reconnectDelay?: number;
+};
+/**
+ * Build the component options of an {@link HTTPServiceProxy}, to register it in the `components` of an application.
+ * @param options The service's address, and the headers, client id and reconnection delay.
+ * @returns The component options.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildHTTPServiceProxy, type HTTPServiceProxy} from 'lakutata/com/entrypoint'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'shop.app',
+ *         name: 'Shop',
+ *         components: {
+ *             inventory: buildHTTPServiceProxy({url: 'http://inventory.internal:3000/'}),
+ *             //With a token, and a stable client id to receive the events of the service
+ *             orders: buildHTTPServiceProxy({
+ *                 url: 'https://orders.internal/rpc',
+ *                 headers: {Authorization: `Bearer ${process.env.ORDERS_TOKEN}`},
+ *                 clientId: 'shop-1'
+ *             })
+ *         }
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const inventory: HTTPServiceProxy = await app.getObject<HTTPServiceProxy>('inventory')
+ *         console.log(await inventory.invoke({cmd: 'stock.get', product: 'lamp'}))
+ *     })
+ * ```
+ */
+export declare const buildHTTPServiceProxy: ComponentOptionsBuilder<BuildHTTPServiceProxyOptions>;
+/**
+ * The client of a lakutata service served over HTTP by `httpServiceEntrypoint`: it invokes the service's actions by
+ * their patterns and listens to the events the service pushes to it. It is a component (a singleton), registered with
+ * {@link buildHTTPServiceProxy}; it needs no package (it uses the `fetch()` of Node.js), and its event stream is opened
+ * when the first listener is added.
+ *
+ * The failures of the remote actions are thrown as `ServiceInvokeException`, with the remote error's message and
+ * properties (`errno`, `statusCode`…) and the address as its `service`; a service that gives no response (unreachable,
+ * too slow, or an answer that is not a service response) as a `ServiceUnavailableException`.
+ * @example
+ * ```typescript
+ * import {Component} from 'lakutata'
+ * import {type HTTPServiceProxy, ServiceInvokeException, ServiceUnavailableException} from 'lakutata/com/entrypoint'
+ * import {Inject} from 'lakutata/decorator/di'
+ *
+ * class StockWatcher extends Component {
+ *     //Registered as inventory: buildHTTPServiceProxy({url: 'http://inventory.internal:3000/'})
+ *     @Inject('inventory')
+ *     protected readonly inventory: HTTPServiceProxy
+ *
+ *     protected async init(): Promise<void> {
+ *         //The events the inventory pushes with Entrypoint.notify(clientId, 'lowStock', product, quantity)
+ *         this.inventory.on('lowStock', (product: string, quantity: number): void => {
+ *             console.log(`${product}: ${quantity} left`)
+ *         })
+ *     }
+ *
+ *     public async quantity(product: string): Promise<number | undefined> {
+ *         try {
+ *             //5 seconds at most; the inventory aborts the action's signal when the call gives up
+ *             return await this.inventory.invoke({cmd: 'stock.get', product: product}, 5000)
+ *         } catch (error) {
+ *             //The action failed: its error
+ *             if (error instanceof ServiceInvokeException && error.errno === 'E_PRODUCT_NOT_FOUND') return undefined
+ *             //The inventory gave no response
+ *             if (error instanceof ServiceUnavailableException) return undefined
+ *             throw error
+ *         }
+ *     }
+ * }
+ * ```
+ */
+export declare class HTTPServiceProxy extends Component {
+    #private;
+    /**
+     * The service's address, as configured (see {@link BuildHTTPServiceProxyOptions.url}); required.
+     */
+    protected readonly url: string;
+    /**
+     * The headers sent with each call and with the event stream; none by default.
+     */
+    protected readonly headers?: Record<string, string>;
+    /**
+     * The configured client id; a random UUID is used without it (see {@link HTTPServiceProxy.id}).
+     */
+    protected readonly clientId?: string;
+    /**
+     * The delay, in milliseconds, before the event stream is opened again.
+     * @default 1000
+     */
+    protected readonly reconnectDelay: number;
+    /**
+     * Create the client id and the address of the event stream (`<url>/events?id=<id>`); nothing connects before the
+     * first call.
+     * @protected
+     */
+    protected init(): Promise<void>;
+    /**
+     * Close the event stream and remove the listeners (the calls in progress complete).
+     * @protected
+     */
+    protected destroy(): Promise<void>;
+    /**
+     * The client's id: the configured `clientId`, or a random UUID. It is sent as the `id` header of the calls, and is
+     * the `ServiceContext.clientId` of the service's actions.
+     */
+    get id(): string;
+    /**
+     * Invoke an action of the service, matched by its pattern.
+     * @param input The action's pattern and its input in one object (`{cmd: 'order.get', id: 1}`), sent as JSON: the
+     * values JSON cannot hold (functions, `undefined`, class instances) are lost or turned into plain objects.
+     * @param timeout The longest wait for the response, in milliseconds; 600000 (10 minutes) by default. The request is
+     * abandoned after it, and the service aborts the action's signal.
+     * @returns The action's result, decoded from JSON: `undefined` when the action returned nothing.
+     * @throws {ServiceInvokeException} When the action fails (no action matches the pattern, an invalid input, an error
+     * thrown, the service stopping), or the service refuses the request (another path, a body over its limit): the
+     * remote error's message and properties (`errno`…), the address as its `service`.
+     * @throws {ServiceUnavailableException} When the service gives no response: unreachable, no response within the
+     * timeout, or an answer that is not a service response. Its `cause` is the error of the request.
+     */
+    invoke<T extends Record<string, any>>(input: ActionPattern<T>, timeout?: number): Promise<any>;
+    /**
+     * Listen to an event the service pushes to this client (`Entrypoint.notify()`, `broadcast()`); the first listener
+     * opens the event stream. The listeners' errors are ignored. The `client` event, received when the stream opens,
+     * carries the client's id.
+     * @param eventName The event's name.
+     * @param listener Called with the event's arguments, decoded from JSON.
+     * @returns The proxy, to chain the calls.
+     */
+    on(eventName: string, listener: (...args: any[]) => void): this;
+    /**
+     * Listen to an event the service pushes to this client, once: the listener is removed before it is called.
+     * @param eventName The event's name.
+     * @param listener Called with the event's arguments, decoded from JSON.
+     * @returns The proxy, to chain the calls.
+     */
+    once(eventName: string, listener: (...args: any[]) => void): this;
+    /**
+     * Stop listening to an event; removing the last listener of all the events closes the event stream.
+     * @param eventName The event's name.
+     * @param listener The listener to remove; without it, all the event's listeners are removed.
+     * @returns The proxy, to chain the calls.
+     */
+    off(eventName: string, listener?: (...args: any[]) => void): this;
+    /**
+     * Add a listener, and open the event stream when it is not open.
+     * @param eventName The event's name.
+     * @param listener The listener.
+     * @param once Whether the listener is removed after its first call.
+     * @returns The proxy.
+     * @protected
+     */
+    protected add(eventName: string, listener: (...args: any[]) => void, once: boolean): this;
+    /**
+     * Read the event stream and call the listeners; the stream is opened again after `reconnectDelay` milliseconds
+     * when it ends or fails, while there are listeners. It stops once no listener is left (removed by
+     * {@link HTTPServiceProxy.off}, or the last `once()` listener called) or the proxy is destroyed.
+     * @returns A promise resolved once the reading stops.
+     * @protected
+     */
+    protected stream(): Promise<void>;
+}

package/dist/types/adapter/jsonrpc/JSONRPCServiceEntrypoint.d.ts

@@ -16,7 +16,9 @@ export type JSONRPCServiceEntrypointOptions = JSONRPCMappingOptions & {
     /**
      * The transport of the messages: `'http'` (a `POST` per message), `'websocket'` (a message per WebSocket text
      * frame, with the events pushed; it needs the optional package `ws`), or `'stdio'` (the process's standard input
-     * and output, for a child process, with the events pushed).
+     * and output, for a child process, with the events pushed). With `'stdio'`, the standard output belongs to the
+     * protocol: the application's logs must be written to the standard error
+     * (`{class: Logger, destinations: [process.stderr]}`), or they corrupt the messages.
      * @default 'http'
      */
     transport?: 'http' | 'websocket' | 'stdio';
@@ -95,11 +97,12 @@ export type JSONRPCServiceEntrypointOptions = JSONRPCMappingOptions & {
  * validation, otherwise `SERVER_ERROR` with the whole error object as its `data`.
  *
  * Over HTTP, a message is the body of a `POST` to the path, answered with 200 and the JSON response (204 when it held
- * only notifications); any other method or path is answered with 404, and the CORS headers allow any origin. Over
- * WebSocket and stdio, the events pushed by `Entrypoint.notify` and `Entrypoint.broadcast` are sent as notifications,
- * `{"jsonrpc": "2.0", "method": event, "params": args}`. The client id carried by `ServiceContext.clientId` is the `id`
- * header or `id` query parameter of the HTTP request or of the WebSocket connection (at most 200 characters; a random
- * one for a WebSocket connection without it), and `'stdio'` on stdio.
+ * only notifications); any other method or path is answered with 404. The CORS headers allow any origin, and the
+ * headers a preflight asks for (`Authorization`…). Over WebSocket and stdio, the events pushed by `Entrypoint.notify`
+ * and `Entrypoint.broadcast` are sent as notifications, `{"jsonrpc": "2.0", "method": event, "params": args}`. The
+ * client id carried by `ServiceContext.clientId` is the `id` header or `id` query parameter of the HTTP request or of
+ * the WebSocket connection (at most 200 characters; a random one for a WebSocket connection without it), and `'stdio'`
+ * on stdio.
  *
  * When an HTTP client disconnects before its response, the action's abort signal fires. When the entrypoint stops,
  * stdio stops reading, the new requests are answered with `STOPPING`, and once the requests in progress are answered
@@ -135,7 +138,8 @@ export type JSONRPCServiceEntrypointOptions = JSONRPCMappingOptions & {
  *                 jsonRPCServiceEntrypoint({name: 'rpc-ws', transport: 'websocket', port: 3001, path: '/rpc'})
  *             ]
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  *
  * //An HTTP client: {"jsonrpc": "2.0", "id": 1, "result": {"id": 1, "name": "Ada"}}

package/dist/types/adapter/schedule/ScheduleEntrypoint.d.ts

@@ -79,7 +79,8 @@ export type ScheduleEntrypointOptions = {
  *                 onSkip: (action, scheduledAt, reason): void => console.warn(`${action.name} skipped (${reason})`)
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */

package/dist/types/adapter/socket.io/SocketIOServiceEntrypoint.d.ts

@@ -123,7 +123,8 @@ export declare function socketOfContext(context: ServiceContext): Socket | undef
  *             controllers: [EchoController],
  *             service: socketIOServiceEntrypoint({port: 3000, options: {cors: {origin: '*'}}})
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  *
  * //A client, identified as client-1 (the events pushed by entrypoint.notify('client-1', 'progress', 50) reach it)

package/dist/types/channel/EntrypointAdapter.d.ts

@@ -72,8 +72,8 @@ export interface ChannelRuntime<Context extends BaseContext = BaseContext> {
     /**
      * Resolves once every adapter of the entrypoint started and the application launched (its objects and its
      * bootstrap are ready), for the adapters acting on their own rather than on requests (running a command,
-     * triggering the schedules). Without an application (a bare container) it never resolves unless the entrypoint's
-     * `launched()` is called.
+     * triggering the schedules). Without an application (a bare container), it resolves once the entrypoint is
+     * initialized.
      */
     readonly ready: Promise<void>;
     /**

package/dist/types/decorators/HTTPAction.d.ts

@@ -6,11 +6,11 @@ import { HTTPContext } from '../context/HTTPContext.js';
  * Expose the controller method as an HTTP action answering a route for an HTTP method, served by the HTTP adapters of
  * the entrypoint (`expressHTTPEntrypoint`, `fastifyHTTPEntrypoint`). Without a DTO, the input is accepted as it is.
  *
- * On a request, 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), the access control runs when `acl` is set, then the method receives the
- * validated input as a plain object, not a DTO instance. The query values and the route parameters are strings and the
- * DTO schemas are strict: convert them with `.strict(false)` (`DTO.Number().strict(false)`).
+ * On a request, the adapter assembles the input: by default, the query string merged with the parsed body (JSON; URL
+ * encoded with Express), then the route parameters over them. The middlewares run, the input is validated against the
+ * DTO (the defaults applied, the unknown keys removed), the access control runs when `acl` is set, then the method
+ * receives the validated input as a plain object, not a DTO instance. The query values and the route parameters are
+ * strings and the DTO schemas are strict: convert them with `.strict(false)` (`DTO.Number().strict(false)`).
  *
  * The value returned is answered by the adapter's responder: as JSON by default, with the status 204 for `undefined`;
  * return `Result.status()`, `Result.file()` or `Result.events()` for a status and headers, a file or server-sent

package/dist/types/decorators/Schedule.d.ts

@@ -61,7 +61,8 @@ export type ScheduleOptions = ({
  * @param schedule A duration text (`'30s'`, `'1h30m'`) for an interval, any other text for a cron expression
  * (`'0 *\/5 * * * *'`, `'@daily'`), or the schedule options.
  * @returns The method decorator.
- * @throws {SyntaxError} When the class is declared, if the interval or the cron expression is invalid.
+ * @throws {SyntaxError} When the class is declared, if the interval or the cron expression is invalid, or if the
+ * expression matches no date (`'0 0 30 2 *'`).
  * @throws {RangeError} When the class is declared, if the time zone is unknown.
  * @example
  * ```typescript
@@ -113,7 +114,8 @@ export declare function Schedule<ClassPrototype extends Controller, Method>(sche
  * rules (false by default); `rule` is an access rule of the action; `middlewares` run before the ones `@UseMiddlewares`
  * adds to the method.
  * @returns The method decorator.
- * @throws {SyntaxError} When the class is declared, if the interval or the cron expression is invalid.
+ * @throws {SyntaxError} When the class is declared, if the interval or the cron expression is invalid, or if the
+ * expression matches no date (`'0 0 30 2 *'`).
  * @throws {RangeError} When the class is declared, if the time zone is unknown.
  * @throws {InvalidValueException} When the class is declared, if the action options are invalid.
  */

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

@@ -15,8 +15,9 @@ import { ServiceContext } from '../context/ServiceContext.js';
  * payload: null}`, `error` holding its properties (`errno`, `errMsg`, `statusCode`, `message`…); JSON-RPC answers it as
  * an error response. A message no pattern matches fails with `ControllerActionNotFoundException`.
  * @param pattern The pattern of the action: an object (nested 2 levels at most) whose keys the messages must hold with
- * the same values; a string value may be a glob (`'user.*'`, `*` any characters, `?` one). The most specific pattern
- * matching a message wins. The controller's `@Prefix({pattern})` is merged into it.
+ * the same values, the keys of a nested object too (`{res: {name: 'user'}}` does not match `{res: {name: 'order'}}`); a
+ * string value may be a glob (`'user.*'`, `*` any characters, `?` one). The most specific pattern matching a message
+ * wins. The controller's `@Prefix({pattern})` is merged into it.
  * @returns The method decorator.
  * @throws {InvalidActionPatternDepthException} When the class is declared, if the pattern is nested more than 2 levels.
  * @example
@@ -71,8 +72,9 @@ export declare function ServiceAction<ClassPrototype extends Controller, Method>
  * returned is sent back as `{success: true, error: null, payload}`, an error as `{success: false, error, payload:
  * null}` (a JSON-RPC result or error response).
  * @param pattern The pattern of the action: an object (nested 2 levels at most) whose keys the messages must hold with
- * the same values; a string value may be a glob (`'user.*'`, `*` any characters, `?` one). The most specific pattern
- * matching a message wins. The controller's `@Prefix({pattern})` is merged into it.
+ * the same values, the keys of a nested object too (`{res: {name: 'user'}}` does not match `{res: {name: 'order'}}`); a
+ * string value may be a glob (`'user.*'`, `*` any characters, `?` one). The most specific pattern matching a message
+ * wins. The controller's `@Prefix({pattern})` is merged into it.
  * @param dtoConstructor The DTO class validating the input: the message without the keys of the pattern.
  * @returns The method decorator.
  * @throws {InvalidActionPatternDepthException} When the class is declared, if the pattern is nested more than 2 levels.
@@ -83,8 +85,9 @@ export declare function ServiceAction<ClassPrototype extends Controller, Method,
  * without the keys of the pattern, is accepted as it is. The value returned is sent back as `{success: true, error:
  * null, payload}`, an error as `{success: false, error, payload: null}` (a JSON-RPC result or error response).
  * @param pattern The pattern of the action: an object (nested 2 levels at most) whose keys the messages must hold with
- * the same values; a string value may be a glob (`'user.*'`, `*` any characters, `?` one). The most specific pattern
- * matching a message wins. The controller's `@Prefix({pattern})` is merged into it.
+ * the same values, the keys of a nested object too (`{res: {name: 'user'}}` does not match `{res: {name: 'order'}}`); a
+ * string value may be a glob (`'user.*'`, `*` any characters, `?` one). The most specific pattern matching a message
+ * wins. The controller's `@Prefix({pattern})` is merged into it.
  * @param actionOptions The action options: `acl` runs the access control rules (false by default); `name` (unique in
  * the service actions, `ClassName:method` by default), `description` and `groups` describe the action; `rule` is an
  * access rule of the action; `middlewares` run before the ones `@UseMiddlewares` adds to the method.
@@ -101,8 +104,9 @@ export declare function ServiceAction<ClassPrototype extends Controller, Method>
  * plain object. The value returned is sent back as `{success: true, error: null, payload}`, an error as `{success:
  * false, error, payload: null}` (a JSON-RPC result or error response).
  * @param pattern The pattern of the action: an object (nested 2 levels at most) whose keys the messages must hold with
- * the same values; a string value may be a glob (`'user.*'`, `*` any characters, `?` one). The most specific pattern
- * matching a message wins. The controller's `@Prefix({pattern})` is merged into it.
+ * the same values, the keys of a nested object too (`{res: {name: 'user'}}` does not match `{res: {name: 'order'}}`); a
+ * string value may be a glob (`'user.*'`, `*` any characters, `?` one). The most specific pattern matching a message
+ * wins. The controller's `@Prefix({pattern})` is merged into it.
  * @param dtoConstructor The DTO class validating the input: the message without the keys of the pattern.
  * @param actionOptions The action options: `acl` runs the access control rules (false by default); `name` (unique in
  * the service actions, `ClassName:method` by default), `description` and `groups` describe the action; `rule` is an