@lakutata/entrypoint 3.0.0-beta.6 → 3.1.0

package/dist/cjs/adapter/http/HTTPServiceProxy.js

@@ -0,0 +1,371 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPServiceProxy = exports.buildHTTPServiceProxy = void 0;
+const node_crypto_1 = require("node:crypto");
+const core_1 = require("@lakutata/core");
+const di_1 = require("@lakutata/core/decorator/di");
+const ServiceResponseCodec_js_1 = require("../../lib/ServiceResponseCodec.js");
+const ServiceUnavailableException_js_1 = require("../../exceptions/ServiceUnavailableException.js");
+/**
+ * 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'}))
+ *     })
+ * ```
+ */
+const buildHTTPServiceProxy = (options) => {
+    return {
+        class: HTTPServiceProxy,
+        url: options.url,
+        headers: options.headers,
+        clientId: options.clientId,
+        reconnectDelay: options.reconnectDelay
+    };
+};
+exports.buildHTTPServiceProxy = buildHTTPServiceProxy;
+/**
+ * Whether a body is a service response
+ * @param body
+ */
+function isServiceResponse(body) {
+    return !!body && typeof body === 'object' && typeof body.success === 'boolean';
+}
+/**
+ * The reason a request failed: the network error under the "fetch failed" of fetch(), each of them when several
+ * addresses were tried (localhost: ::1, then 127.0.0.1)
+ * @param error
+ */
+function reasonOf(error) {
+    const cause = error?.cause ?? error;
+    if (cause instanceof AggregateError && cause.errors.length)
+        return cause.errors.map((each) => each?.message ?? String(each)).join(', ');
+    return cause?.message || error?.message || String(error);
+}
+/**
+ * The events of a stream of Server-Sent Events: their names and their data, the comments skipped
+ * @param stream
+ */
+async function* serverSentEvents(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let event = 'message';
+    let data = [];
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                return;
+            buffer += decoder.decode(value, { stream: true });
+            //The complete lines; the last one may be cut by the chunk
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+            for (const read of lines) {
+                const line = read.endsWith('\r') ? read.slice(0, -1) : read;
+                //A blank line ends the event
+                if (!line) {
+                    if (data.length)
+                        yield { event: event, data: data.join('\n') };
+                    event = 'message';
+                    data = [];
+                    continue;
+                }
+                if (line.startsWith(':'))
+                    continue;
+                const colon = line.indexOf(':');
+                const field = colon < 0 ? line : line.slice(0, colon);
+                const value = colon < 0 ? '' : line.slice(colon + 1).replace(/^ /, '');
+                if (field === 'event')
+                    event = value;
+                else if (field === 'data')
+                    data.push(value);
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+/**
+ * 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
+ *         }
+ *     }
+ * }
+ * ```
+ */
+class HTTPServiceProxy extends core_1.Component {
+    #id;
+    #eventsURL;
+    #listeners = new Map();
+    #events;
+    #destroyed = false;
+    /**
+     * Create the client id and the address of the event stream (`<url>/events?id=<id>`); nothing connects before the
+     * first call.
+     * @protected
+     */
+    async init() {
+        this.#id = this.clientId ?? (0, node_crypto_1.randomUUID)();
+        const events = new URL(this.url);
+        events.pathname = `${events.pathname.replace(/\/+$/, '')}/events`;
+        events.searchParams.set('id', this.#id);
+        this.#eventsURL = events.href;
+    }
+    /**
+     * Close the event stream and remove the listeners (the calls in progress complete).
+     * @protected
+     */
+    async destroy() {
+        this.#destroyed = true;
+        this.#events?.abort();
+        this.#listeners.clear();
+    }
+    /**
+     * 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() {
+        return this.#id;
+    }
+    /**
+     * 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.
+     */
+    async invoke(input, timeout = 10 * 60 * 1000) {
+        let status;
+        let text;
+        try {
+            const response = await fetch(this.url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.headers, 'id': this.#id },
+                body: JSON.stringify(input),
+                signal: AbortSignal.timeout(timeout)
+            });
+            status = response.status;
+            text = await response.text();
+        }
+        catch (error) {
+            const exception = error?.name === 'TimeoutError'
+                ? new ServiceUnavailableException_js_1.ServiceUnavailableException('The service {service} gave no response within {timeout} ms', { service: this.url, timeout: timeout })
+                : new ServiceUnavailableException_js_1.ServiceUnavailableException('The service {service} cannot be reached: {reason}', { service: this.url, reason: reasonOf(error) });
+            exception.service = this.url;
+            exception.cause = error;
+            throw exception;
+        }
+        let body;
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            //Not JSON: below
+        }
+        if (!isServiceResponse(body)) {
+            const exception = new ServiceUnavailableException_js_1.ServiceUnavailableException('The service {service} answered {status} without a service response', { service: this.url, status: status });
+            exception.service = this.url;
+            throw exception;
+        }
+        return ServiceResponseCodec_js_1.ServiceResponseCodec.decode(body, this.url);
+    }
+    /**
+     * 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, listener) {
+        return this.add(eventName, listener, false);
+    }
+    /**
+     * 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, listener) {
+        return this.add(eventName, listener, true);
+    }
+    /**
+     * 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, listener) {
+        const listeners = this.#listeners.get(eventName);
+        if (listeners && listener)
+            listeners.forEach((entry) => entry.listener === listener && listeners.delete(entry));
+        if (!listener || !listeners?.size)
+            this.#listeners.delete(eventName);
+        if (!this.#listeners.size) {
+            this.#events?.abort();
+            this.#events = undefined;
+        }
+        return 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
+     */
+    add(eventName, listener, once) {
+        if (!this.#listeners.has(eventName))
+            this.#listeners.set(eventName, new Set());
+        this.#listeners.get(eventName).add({ listener: listener, once: once });
+        if (!this.#events)
+            void this.stream();
+        return 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
+     */
+    async stream() {
+        const abort = new AbortController();
+        this.#events = abort;
+        while (!abort.signal.aborted && !this.#destroyed && this.#listeners.size) {
+            try {
+                const response = await fetch(this.#eventsURL, { headers: { ...this.headers, 'Accept': 'text/event-stream' }, signal: abort.signal });
+                if (response.ok && response.body) {
+                    for await (const { event, data } of serverSentEvents(response.body)) {
+                        const listeners = this.#listeners.get(event);
+                        if (!listeners)
+                            continue;
+                        let args;
+                        try {
+                            args = JSON.parse(data);
+                        }
+                        catch {
+                            continue;
+                        }
+                        for (const entry of [...listeners]) {
+                            if (entry.once)
+                                listeners.delete(entry);
+                            try {
+                                entry.listener(...Array.isArray(args) ? args : [args]);
+                            }
+                            catch {
+                                //The errors of the listeners are theirs
+                            }
+                        }
+                        if (!listeners.size)
+                            this.#listeners.delete(event);
+                        //The last listener gone (a once listener called): the stream is closed
+                        if (!this.#listeners.size)
+                            abort.abort();
+                    }
+                }
+                else {
+                    await response.body?.cancel();
+                }
+            }
+            catch {
+                //The service is gone: listened again after the delay
+            }
+            if (abort.signal.aborted || this.#destroyed)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, this.reconnectDelay));
+        }
+        if (this.#events === abort)
+            this.#events = undefined;
+    }
+}
+exports.HTTPServiceProxy = HTTPServiceProxy;
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().uri({ scheme: ['http', 'https'] }).required()),
+    __metadata("design:type", String)
+], HTTPServiceProxy.prototype, "url", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Object().pattern(core_1.DTO.String(), core_1.DTO.String()).optional()),
+    __metadata("design:type", Object)
+], HTTPServiceProxy.prototype, "headers", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().max(200).optional()),
+    __metadata("design:type", String)
+], HTTPServiceProxy.prototype, "clientId", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Number().integer().min(0).optional().default(1000)),
+    __metadata("design:type", Number)
+], HTTPServiceProxy.prototype, "reconnectDelay", void 0);

package/dist/cjs/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/cjs/adapter/jsonrpc/JSONRPCServiceEntrypoint.js

@@ -40,8 +40,11 @@ const BuiltinChannels_js_1 = require("../../channel/BuiltinChannels.js");
 const JSONRPCProtocol_js_1 = require("./JSONRPCProtocol.js");
 const ApplicationOf_js_1 = require("../../lib/ApplicationOf.js");
 const Connections_js_1 = require("../../lib/Connections.js");
+const ReadBody_js_1 = require("../../lib/ReadBody.js");
+const Preflight_js_1 = require("../../lib/Preflight.js");
 /**
- * The headers of the responses of HTTP: the tools of the browsers may call the adapter
+ * The headers of the responses of HTTP: the tools of the browsers may call the adapter; a preflight is allowed the
+ * headers it asks for
  */
 const CORS_HEADERS = {
     'Access-Control-Allow-Origin': '*',
@@ -58,22 +61,6 @@ function clientIdOf(request) {
     const id = Array.isArray(given) ? given[0] : given ?? undefined;
     return id && id.length <= 200 ? id : undefined;
 }
-/**
- * The body of a request, up to a limit
- * @param request
- * @param limit
- */
-async function readBody(request, limit) {
-    const chunks = [];
-    let size = 0;
-    for await (const chunk of request) {
-        size += chunk.length;
-        if (size > limit)
-            throw Object.assign(new Error(`The body of the request is larger than ${limit} bytes`), { status: 413 });
-        chunks.push(chunk);
-    }
-    return Buffer.concat(chunks).toString('utf8');
-}
 /**
  * The messages of a stream framed by lines, or by their Content-Length headers. A message larger than the limit is
  * skipped (the rest of its line, or the length its header declares, keeping the framing) and reported
@@ -166,11 +153,12 @@ function readMessages(input, framing, limit, receive, ended, oversized) {
  * 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
@@ -206,7 +194,8 @@ function readMessages(input, framing, limit, receive, ended, oversized) {
  *                 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"}}
@@ -304,7 +293,7 @@ function jsonRPCServiceEntrypoint(options = {}) {
                 server = (0, node_http_1.createServer)((request, response) => {
                     const url = new URL(request.url ?? '/', 'http://localhost');
                     if (request.method === 'OPTIONS')
-                        return void response.writeHead(204, CORS_HEADERS).end();
+                        return void response.writeHead(204, (0, Preflight_js_1.preflightHeaders)(request, CORS_HEADERS)).end();
                     if (request.method !== 'POST' || url.pathname !== path) {
                         return void response.writeHead(404, { ...CORS_HEADERS, 'Content-Type': 'application/json' }).end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32600, message: `POST ${path} receives the requests of JSON-RPC 2.0` } }));
                     }
@@ -313,7 +302,7 @@ function jsonRPCServiceEntrypoint(options = {}) {
                         if (!response.writableFinished)
                             aborted.abort();
                     });
-                    readBody(request, limit).then((body) => {
+                    (0, ReadBody_js_1.readBody)(request, limit).then((body) => {
                         void answer(runtime, body, { clientId: clientIdOf(request), extra: { request: request }, signal: aborted.signal }, (message) => {
                             response.writeHead(200, { ...CORS_HEADERS, 'Content-Type': 'application/json; charset=utf-8' }).end(message);
                         }).then(() => {
@@ -322,7 +311,7 @@ function jsonRPCServiceEntrypoint(options = {}) {
                                 response.writeHead(204, CORS_HEADERS).end();
                         });
                     }, (error) => {
-                        response.writeHead(error.status ?? 400, { ...CORS_HEADERS, 'Content-Type': 'application/json' }).end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32600, message: error.message } }));
+                        response.writeHead(error.statusCode ?? 400, { ...CORS_HEADERS, 'Content-Type': 'application/json' }).end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32600, message: error.message } }));
                     });
                 });
                 return await listen(server);

package/dist/cjs/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/cjs/adapter/schedule/ScheduleEntrypoint.js

@@ -64,7 +64,8 @@ const MAX_DELAY = 2 ** 31 - 1;
  *                 onSkip: (action, scheduledAt, reason): void => console.warn(`${action.name} skipped (${reason})`)
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */
@@ -95,16 +96,22 @@ function scheduleEntrypoint(options = {}) {
         timers.add(timer);
     };
     /**
-     * Write a failed run to the log of the application
+     * Give a failed run to the onError handler, or write it to the log of the application; an error of the handler is
+     * written to the log
      * @param runtime
      * @param error
      * @param action
      * @param context
      */
     const report = async (runtime, error, action, context) => {
-        if (options.onError)
-            return await options.onError(error, action, context);
-        await log(runtime, error, `The scheduled action ${action.name} (${context.schedule}) failed`);
+        if (!options.onError)
+            return await log(runtime, error, `The scheduled action ${action.name} (${context.schedule}) failed`);
+        try {
+            await options.onError(error, action, context);
+        }
+        catch (handlerError) {
+            await log(runtime, handlerError, `The onError handler of the scheduled action ${action.name} failed`);
+        }
     };
     /**
      * Write an error to the log of the application

package/dist/cjs/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/cjs/adapter/socket.io/SocketIOServiceEntrypoint.js

@@ -83,7 +83,8 @@ function clientIdOf(socket) {
  *             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/cjs/channel/BuiltinChannels.js

@@ -4,6 +4,7 @@ exports.ScheduleChannel = exports.ServiceChannel = exports.CLIChannel = exports.
 const utils_1 = require("@lakutata/utils");
 const Channel_js_1 = require("./Channel.js");
 const PatternManager_js_1 = require("../lib/pattern/PatternManager.js");
+const FlattenPattern_js_1 = require("../lib/pattern/FlattenPattern.js");
 const StringifyPattern_js_1 = require("../lib/StringifyPattern.js");
 const Prefix_js_1 = require("../lib/Prefix.js");
 const BaseContext_js_1 = require("../context/BaseContext.js");
@@ -77,12 +78,13 @@ exports.ServiceChannel = (0, Channel_js_1.defineChannel)({
     describe: (pattern) => ({ pattern: pattern }),
     prefix: (prefix, pattern) => prefix.pattern === undefined ? undefined : (0, Prefix_js_1.prefixPattern)(prefix.pattern, pattern),
     createMatcher: (entries) => {
+        //The values of the nested objects are compared one by one: {res: {name: 'user'}} matches as {'res.name': 'user'}
         const patterns = new PatternManager_js_1.PatternManager();
         for (const entry of entries)
-            patterns.add(entry.details.pattern, entry);
+            patterns.add((0, FlattenPattern_js_1.flattenPattern)(entry.details.pattern), entry);
         return {
             match: (context) => {
-                const entry = patterns.find(context.input);
+                const entry = patterns.find((0, FlattenPattern_js_1.flattenSubject)(context.input));
                 return entry ? { entry: entry } : undefined;
             }
         };

package/dist/cjs/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/cjs/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/cjs/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/cjs/decorators/Schedule.js

@@ -35,8 +35,9 @@ function ScheduleAddress(schedule) {
         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_js_1.Cron(options.cron, options.timezone);
+        //The expression is checked now, not at the first run; a valid one matching no date (February 30th) would never run
+        if (!new Cron_js_1.Cron(options.cron, options.timezone).next())
+            throw new SyntaxError(`The cron expression ${options.cron} matches no date`);
         address.cron = options.cron;
         address.schedule = `cron ${options.cron}`;
         if (options.timezone)