@lakutata/entrypoint 3.0.0-beta.0

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

@@ -0,0 +1,194 @@
+import type { ChannelRuntime } from '../../channel/EntrypointAdapter.js';
+import { ServiceContext } from '../../context/ServiceContext.js';
+/**
+ * The error codes of the JSON-RPC 2.0 responses sent by {@link jsonRPCServiceEntrypoint}.
+ */
+export declare const JSONRPCErrorCode: {
+    /**
+     * The message is not valid JSON.
+     */
+    readonly PARSE_ERROR: -32700;
+    /**
+     * The message is not a JSON-RPC 2.0 request (or is an empty batch, or the HTTP request is not a `POST` to the path).
+     */
+    readonly INVALID_REQUEST: -32600;
+    /**
+     * No service action matches the request (`ControllerActionNotFoundException`).
+     */
+    readonly METHOD_NOT_FOUND: -32601;
+    /**
+     * The params are given by position without the `positionalParams` option, or fail the action's input validation
+     * (`InvalidValueException`).
+     */
+    readonly INVALID_PARAMS: -32602;
+    /**
+     * Reserved by the specification for the internal errors; the adapter does not send it.
+     */
+    readonly INTERNAL_ERROR: -32603;
+    /**
+     * Any other error thrown by an action (in the server error range, -32000 to -32099), with the whole error object as
+     * the error's `data`.
+     */
+    readonly SERVER_ERROR: -32000;
+    /**
+     * The entrypoint is stopping and refuses the new requests (`EntrypointStoppedException`).
+     */
+    readonly STOPPING: -32001;
+};
+/**
+ * A JSON-RPC 2.0 request, as a client sends it. Without an `id`, it is a notification: the action runs but no response
+ * is sent.
+ */
+export type JSONRPCRequest = {
+    /**
+     * The protocol version, always `'2.0'`.
+     */
+    jsonrpc: '2.0';
+    /**
+     * The method, mapped to the service action's pattern (see `JSONRPCMappingOptions`).
+     */
+    method: string;
+    /**
+     * The params: by name (an object, merged into the action's input), or by position (an array, accepted only with the
+     * `positionalParams` option).
+     */
+    params?: Record<string, unknown> | unknown[];
+    /**
+     * The request id, echoed in its response; omitted for a notification.
+     */
+    id?: string | number | null;
+};
+/**
+ * A JSON-RPC 2.0 response, as the adapter sends it: either `result` or `error`.
+ */
+export type JSONRPCResponse = {
+    /**
+     * The protocol version, always `'2.0'`.
+     */
+    jsonrpc: '2.0';
+    /**
+     * The id of the request answered; `null` when it could not be read (a parse error, an invalid request).
+     */
+    id: string | number | null;
+    /**
+     * The action's result, `null` when it returned nothing.
+     */
+    result?: unknown;
+    /**
+     * The error: its code (see {@link JSONRPCErrorCode}), its message, and for an action's error the whole error object as
+     * `data`.
+     */
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+};
+/**
+ * How {@link jsonRPCServiceEntrypoint} maps a JSON-RPC request to a service action's pattern and input.
+ */
+export type JSONRPCMappingOptions = {
+    /**
+     * The pattern field receiving the request's method: with `'method'`, `{"method": "user.get", "params": {"id": 1}}`
+     * is dispatched as `{method: 'user.get', id: 1}`, the action declared with `@ServiceAction({method: 'user.get'})`.
+     * @default 'method'
+     */
+    methodField?: string;
+    /**
+     * Build the pattern and the input of a request's action from its method and its params, replacing `methodField` and
+     * `positionalParams`. A thrown error answers the request with `INVALID_PARAMS`.
+     */
+    toPattern?: (method: string, params: Record<string, unknown> | unknown[] | undefined) => Record<string, unknown>;
+    /**
+     * The input field receiving the params given by position (an array): with `'args'`, `{"method": "sum", "params":
+     * [1, 2]}` is dispatched as `{method: 'sum', args: [1, 2]}`.
+     * @default none: the params by position are refused with `INVALID_PARAMS`
+     */
+    positionalParams?: string;
+};
+/**
+ * The JSON-RPC request behind a service action's request, as {@link jsonRPCRequestOfContext} returns it.
+ */
+export type JSONRPCRequestInfo = {
+    /**
+     * The request's method.
+     */
+    method: string;
+    /**
+     * The request's id; `undefined` for a notification (no response is sent).
+     */
+    id: string | number | null | undefined;
+    /**
+     * The transport the request came through.
+     */
+    transport: 'http' | 'websocket' | 'stdio';
+};
+/**
+ * Get the JSON-RPC request behind a service action's request, when {@link jsonRPCServiceEntrypoint} serves it (to
+ * tell a notification from a request, or read the transport).
+ * @param context The service action's context (`this.context` in a controller).
+ * @returns The request's method, id and transport, or `undefined` when another adapter serves the request.
+ * @example
+ * ```typescript
+ * import {Controller, ServiceContext} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ * import {jsonRPCRequestOfContext, type JSONRPCRequestInfo} from 'lakutata/adapter/jsonrpc'
+ *
+ * class LogController extends Controller {
+ *     //{"jsonrpc": "2.0", "method": "log.write", "params": {"line": "started"}}: a notification, no id
+ *     @ServiceAction({method: 'log.write'})
+ *     public async write(input: {line: string}): Promise<void> {
+ *         const request: JSONRPCRequestInfo | undefined = jsonRPCRequestOfContext(this.context as ServiceContext)
+ *         console.log(`${request?.transport}: ${input.line}`)
+ *     }
+ * }
+ * ```
+ */
+export declare function jsonRPCRequestOfContext(context: ServiceContext): JSONRPCRequestInfo | undefined;
+/**
+ * The context of a dispatch of a request
+ */
+export type JSONRPCDispatch = {
+    runtime: ChannelRuntime<ServiceContext>;
+    transport: JSONRPCRequestInfo['transport'];
+    clientId?: string;
+    /**
+     * The properties added to the contexts (the request of HTTP, the socket)
+     */
+    extra?: Record<string, unknown>;
+    signal?: AbortSignal;
+    stopping: () => boolean;
+};
+/**
+ * The requests of JSON-RPC 2.0 dispatched to the service actions: the single ones, the batches, the notifications (no
+ * response); their methods given to the patterns of the actions
+ */
+export declare class JSONRPCProtocol {
+    protected readonly options: JSONRPCMappingOptions;
+    constructor(options?: JSONRPCMappingOptions);
+    /**
+     * The pattern and the input of the action of a request
+     * @param request
+     * @protected
+     */
+    protected pattern(request: JSONRPCRequest): Record<string, unknown>;
+    /**
+     * The response of a request (none for a notification)
+     * @param request
+     * @param dispatch
+     * @protected
+     */
+    protected one(request: unknown, dispatch: JSONRPCDispatch): Promise<JSONRPCResponse | undefined>;
+    /**
+     * The response of a message (a request, a batch): undefined when there is none (notifications)
+     * @param message its text
+     * @param dispatch
+     */
+    handle(message: string, dispatch: JSONRPCDispatch): Promise<JSONRPCResponse | JSONRPCResponse[] | undefined>;
+    /**
+     * A notification sent to a client (an event pushed)
+     * @param event
+     * @param args
+     */
+    static notification(event: string, args: unknown[]): string;
+}

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

@@ -0,0 +1,154 @@
+import { type Server } from 'node:http';
+import type { Readable, Writable } from 'node:stream';
+import type { EntrypointAdapter } from '../../channel/EntrypointAdapter.js';
+import type { MiddlewareDefinition } from '../../lib/Middleware.js';
+import type { ServiceContext } from '../../context/ServiceContext.js';
+import { type JSONRPCMappingOptions } from './JSONRPCProtocol.js';
+/**
+ * The options of {@link jsonRPCServiceEntrypoint}: its transport, and how the requests map to the service actions (see
+ * {@link JSONRPCMappingOptions}).
+ */
+export type JSONRPCServiceEntrypointOptions = JSONRPCMappingOptions & {
+    /**
+     * The adapter name, to tell apart several service adapters of one entrypoint.
+     */
+    name?: string;
+    /**
+     * 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).
+     * @default 'http'
+     */
+    transport?: 'http' | 'websocket' | 'stdio';
+    /**
+     * The port of the HTTP or WebSocket server; 0 picks a random free port. The entrypoint fails to start when the port
+     * is in use.
+     * @default 3000
+     */
+    port?: number;
+    /**
+     * The host or address of the HTTP or WebSocket server.
+     * @default all the interfaces
+     */
+    host?: string;
+    /**
+     * The path receiving the requests (HTTP) or the connections (WebSocket).
+     * @default '/'
+     */
+    path?: string;
+    /**
+     * The largest message, in bytes. Over HTTP a larger body is answered with 413; over WebSocket the connection is
+     * closed by `ws`; over stdio a larger message is skipped (the rest of its line, or the length its header declares)
+     * and answered with an Invalid Request error without id (`-32600`).
+     * @default 10485760 (10 MiB)
+     */
+    limit?: number;
+    /**
+     * How the messages are delimited on stdio: `'newline'` (one JSON message per line), or `'content-length'` (each
+     * message after a `Content-Length` header and a blank line, as in the Language Server Protocol). The responses and
+     * the notifications are written the same way.
+     * @default 'newline'
+     */
+    framing?: 'newline' | 'content-length';
+    /**
+     * The stream the stdio transport reads.
+     * @default process.stdin
+     */
+    input?: Readable;
+    /**
+     * The stream the stdio transport writes.
+     * @default process.stdout
+     */
+    output?: Writable;
+    /**
+     * What happens when the stdio input ends (the parent process is gone): `'application'` exits the application with
+     * the code 0 once the requests in progress are answered, `'none'` does nothing, or a function run once they are
+     * answered.
+     * @default 'application'
+     */
+    end?: 'application' | 'none' | (() => void | Promise<void>);
+    /**
+     * The interval between the pings of the WebSocket connections, in milliseconds; 0 sends none. A connection that has
+     * not answered a ping by the next one is terminated.
+     * @default 30000
+     */
+    heartbeat?: number;
+    /**
+     * The middlewares of this adapter's actions, run after the entrypoint's global middlewares.
+     */
+    middlewares?: MiddlewareDefinition[];
+    /**
+     * Run once the HTTP or WebSocket server listens, with the server (to read the port picked for port 0). A failure
+     * fails the entrypoint start. Not called with stdio.
+     */
+    listening?: (server: Server) => void | Promise<void>;
+};
+/**
+ * Create a service adapter of an entrypoint served over JSON-RPC 2.0, on HTTP, WebSocket or stdio. Only the WebSocket
+ * transport needs an optional peer dependency, `ws`; without it, the entrypoint fails to start.
+ *
+ * A request's method and named params become the service action's pattern and input: by default
+ * `{"method": "user.get", "params": {"id": 1}}` is dispatched as `{method: 'user.get', id: 1}` (see
+ * {@link JSONRPCMappingOptions} for the other mappings). The batches are answered with an array of responses, the
+ * notifications (no `id`) run without a response. The action's result is the response's `result` (`null` for none);
+ * its error becomes a JSON-RPC error (see {@link JSONRPCErrorCode}): `METHOD_NOT_FOUND`, `INVALID_PARAMS` for a failed
+ * 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.
+ *
+ * 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
+ * the WebSocket connections are closed (code 1001) and the server shuts down.
+ * @param options The adapter options; by default it serves HTTP on port 3000 of all the interfaces, on the path `/`.
+ * @returns The adapter, to give to the `service` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ * import {jsonRPCServiceEntrypoint} from 'lakutata/adapter/jsonrpc'
+ * import WebSocket from 'ws'
+ *
+ * class UserController extends Controller {
+ *     @ServiceAction({method: 'user.get'})
+ *     public async get(input: {id: number}): Promise<{id: number, name: string}> {
+ *         return {id: input.id, name: 'Ada'}
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'user.service',
+ *     name: 'Users',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [UserController],
+ *             service: [
+ *                 //POST http://localhost:3000/rpc
+ *                 jsonRPCServiceEntrypoint({name: 'rpc-http', port: 3000, path: '/rpc'}),
+ *                 //ws://localhost:3001/rpc, with the events pushed
+ *                 jsonRPCServiceEntrypoint({name: 'rpc-ws', transport: 'websocket', port: 3001, path: '/rpc'})
+ *             ]
+ *         })
+ *     }
+ * })
+ *
+ * //An HTTP client: {"jsonrpc": "2.0", "id": 1, "result": {"id": 1, "name": "Ada"}}
+ * const response: Response = await fetch('http://localhost:3000/rpc', {
+ *     method: 'POST',
+ *     headers: {'Content-Type': 'application/json'},
+ *     body: JSON.stringify({jsonrpc: '2.0', id: 1, method: 'user.get', params: {id: 1}})
+ * })
+ * console.log(await response.json())
+ *
+ * //A WebSocket client, identified as client-1: the responses and the notifications arrive as messages
+ * const socket: WebSocket = new WebSocket('ws://localhost:3001/rpc?id=client-1')
+ * socket.on('open', (): void => socket.send(JSON.stringify({jsonrpc: '2.0', id: 2, method: 'user.get', params: {id: 2}})))
+ * socket.on('message', (data: WebSocket.RawData): void => console.log(JSON.parse(data.toString())))
+ * ```
+ */
+export declare function jsonRPCServiceEntrypoint(options?: JSONRPCServiceEntrypointOptions): EntrypointAdapter<ServiceContext>;

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

@@ -0,0 +1,86 @@
+import type { ChannelActionInfo, EntrypointAdapter } from '../../channel/EntrypointAdapter.js';
+import type { MiddlewareDefinition } from '../../lib/Middleware.js';
+import { ScheduleContext } from '../../context/ScheduleContext.js';
+/**
+ * The options of {@link scheduleEntrypoint}.
+ */
+export type ScheduleEntrypointOptions = {
+    /**
+     * The adapter name, to tell apart several schedule adapters of one entrypoint.
+     */
+    name?: string;
+    /**
+     * The middlewares of this adapter's runs, run after the entrypoint's global middlewares.
+     */
+    middlewares?: MiddlewareDefinition[];
+    /**
+     * Called when a run fails (the action, a middleware or the access control threw), with the error, the action and
+     * the run's context. A failed run does not stop the next ones.
+     * @default the error is written to the application's `log` component (`console.error` without one)
+     */
+    onError?: (error: unknown, action: ChannelActionInfo, context: ScheduleContext) => void | Promise<void>;
+    /**
+     * Called when a run is skipped, with the action, the time the run was due and why: `'overlap'` when the action's
+     * previous run is still in progress (an action without `overlap: true`), `'exclusive'` when another instance of the
+     * application holds the run's lock (an `exclusive` action). An error it throws is written to the application's
+     * `log` component; the schedule goes on.
+     */
+    onSkip?: (action: ChannelActionInfo, scheduledAt: Date, reason: 'overlap' | 'exclusive') => void;
+};
+/**
+ * Create the schedule adapter of an entrypoint: it runs the controller actions declared with `@Schedule`, which never
+ * run without it. It needs no optional dependency.
+ *
+ * The runs begin once the application has launched (all its objects, its bootstrap and the other adapters are ready).
+ * Each run is dispatched like a request: a new controller in its own scope, the middlewares and the access control, a
+ * {@link ScheduleContext} giving the schedule, the time the run was due and its number. An interval keeps its pace:
+ * the runs missed while the process was suspended are skipped, not caught up. An action whose previous run is still in
+ * progress skips its run unless it allows `overlap`.
+ *
+ * An `exclusive` action runs in one instance of the application at a time: each run first tries to acquire a lock
+ * named `schedule:<key>` (the `key` of its `exclusive` option, the action name by default) from the mutex component
+ * (the `Mutex` of `lakutata/com/mutex`, named `mutex` by default), and is skipped when another
+ * instance holds it; the lock is kept after the run for half of its period (30 seconds at most) so that the instances
+ * whose clocks are late skip it too. An exclusive action whose mutex component cannot be resolved never runs (the
+ * error is logged).
+ *
+ * When the entrypoint stops, no new run starts, the kept locks are released and the entrypoint waits for the runs in
+ * progress (aborting them after its `shutdownTimeout`).
+ * @param options The adapter options.
+ * @returns The adapter, to give to the `schedule` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller, ScheduleContext, scheduleEntrypoint} from 'lakutata/com/entrypoint'
+ * import {Schedule} from 'lakutata/decorator/ctrl'
+ *
+ * class MaintenanceController extends Controller {
+ *     //Every 5 minutes, and once the application launched
+ *     @Schedule({every: '5m', immediate: true})
+ *     public async purge(): Promise<void> {
+ *         const context: ScheduleContext = this.context as ScheduleContext
+ *         console.log(`Run ${context.run}, due at ${context.scheduledAt.toISOString()}`)
+ *     }
+ *
+ *     //Every day at 03:00 in Shanghai
+ *     @Schedule({cron: '0 3 * * *', timezone: 'Asia/Shanghai'})
+ *     public async report(): Promise<void> {
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'worker.app',
+ *     name: 'Worker',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [MaintenanceController],
+ *             schedule: scheduleEntrypoint({
+ *                 onError: (error, action): void => console.error(`${action.name} failed`, error),
+ *                 onSkip: (action, scheduledAt, reason): void => console.warn(`${action.name} skipped (${reason})`)
+ *             })
+ *         })
+ *     }
+ * })
+ * ```
+ */
+export declare function scheduleEntrypoint(options?: ScheduleEntrypointOptions): EntrypointAdapter<ScheduleContext>;

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

@@ -0,0 +1,138 @@
+import { Server as SocketIOServer, type ServerOptions, type Socket } from 'socket.io';
+import { type Server } from 'node:http';
+import type { EntrypointAdapter } from '../../channel/EntrypointAdapter.js';
+import type { MiddlewareDefinition } from '../../lib/Middleware.js';
+import { ServiceContext } from '../../context/ServiceContext.js';
+/**
+ * The options of {@link socketIOServiceEntrypoint}.
+ */
+export type SocketIOServiceEntrypointOptions = {
+    /**
+     * The adapter name, to tell apart several service adapters of one entrypoint.
+     */
+    name?: string;
+    /**
+     * The socket.io event carrying the requests: `socket.emit('message', {cmd: 'echo', …}, (response) => …)`.
+     * @default 'message'
+     */
+    event?: string;
+    /**
+     * The socket.io namespace receiving the requests.
+     * @default '/'
+     */
+    namespace?: string;
+    /**
+     * An HTTP server to attach the socket.io server to (such as the one of `expressHTTPEntrypoint`, given to its
+     * `before` hook), or a function returning it when the adapter starts. The adapter then does not listen itself, and
+     * when it stops it disconnects the sockets but leaves the HTTP server to its owner.
+     * @default a server of its own, listening on `port`
+     */
+    server?: Server | (() => Server);
+    /**
+     * An existing socket.io server to serve the requests on, used as is: the adapter neither makes it listen nor closes
+     * it, and ignores `server`, `port`, `host` and `options`.
+     * @default a socket.io server created by the adapter
+     */
+    io?: SocketIOServer;
+    /**
+     * The port of the adapter's own server (without `server` and `io`); 0 picks a random free port. The entrypoint fails
+     * to start when the port is in use.
+     * @default 3000
+     */
+    port?: number;
+    /**
+     * The host or address of the adapter's own server.
+     * @default all the interfaces
+     */
+    host?: string;
+    /**
+     * The options of the socket.io server created by the adapter (`path`, `cors`, `transports`…).
+     */
+    options?: Partial<ServerOptions>;
+    /**
+     * The middlewares of this adapter's actions, run after the entrypoint's global middlewares.
+     */
+    middlewares?: MiddlewareDefinition[];
+    /**
+     * Run once the adapter is ready, with the socket.io server and its HTTP server (`undefined` when `io` is given
+     * without `server`).
+     * A failure fails the entrypoint start.
+     */
+    listening?: (io: SocketIOServer, server: Server | undefined) => void | Promise<void>;
+};
+/**
+ * Get the socket.io socket that sent a service action's request, when {@link socketIOServiceEntrypoint} serves it (to
+ * read its handshake, join it to rooms, emit to it…).
+ * @param context The service action's context (`this.context` in a controller).
+ * @returns The socket, or `undefined` when another adapter serves the request.
+ * @example
+ * ```typescript
+ * import {Controller, ServiceContext} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ * import {socketOfContext} from 'lakutata/adapter/socket.io'
+ *
+ * class RoomController extends Controller {
+ *     //socket.emit('message', {cmd: 'room.join', room: 'lobby'}, (response) => …)
+ *     @ServiceAction({cmd: 'room.join'})
+ *     public async join(input: {room: string}): Promise<void> {
+ *         await socketOfContext(this.context as ServiceContext)?.join(input.room)
+ *     }
+ * }
+ * ```
+ */
+export declare function socketOfContext(context: ServiceContext): Socket | undefined;
+/**
+ * Create a service adapter of an entrypoint served by socket.io. It needs the optional peer dependency `socket.io`
+ * (and `socket.io-client` on the clients).
+ *
+ * A request is an emit of the request event (`'message'` by default) whose data holds the action's pattern and input,
+ * with an acknowledgement callback receiving the response `{success, error, payload}` (see `ServiceResponseCodec`):
+ * `payload` is the result, or `error` the whole error object when the action failed (no matching action, validation…).
+ * An emit without an acknowledgement still runs the action.
+ *
+ * Each socket belongs to a client, identified by the id it gives when it connects (`auth.id`, else the `id` header,
+ * else the `id` query parameter; at most 200 characters), else by its socket id; its requests carry it as
+ * `ServiceContext.clientId`. The events pushed by `Entrypoint.notify` are emitted to every socket of the client, those
+ * of `Entrypoint.broadcast` to every socket of the namespace, with the event's arguments as the emit's arguments.
+ *
+ * When a socket disconnects, its requests in progress are aborted (their abort signal fires). When the entrypoint
+ * stops, the new requests are answered with an `EntrypointStoppedException` error; once the requests in progress end,
+ * the socket.io server is closed (the sockets disconnected, with the attached HTTP server left open).
+ * @param options The adapter options; by default it listens on port 3000 of all the interfaces with a server of its own.
+ * @returns The adapter, to give to the `service` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ * import {socketIOServiceEntrypoint} from 'lakutata/adapter/socket.io'
+ * import {io} from 'socket.io-client'
+ *
+ * class EchoController extends Controller {
+ *     @ServiceAction({cmd: 'echo'})
+ *     public async echo(input: {text: string}): Promise<string> {
+ *         return input.text
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'echo.service',
+ *     name: 'Echo',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [EchoController],
+ *             service: socketIOServiceEntrypoint({port: 3000, options: {cors: {origin: '*'}}})
+ *         })
+ *     }
+ * })
+ *
+ * //A client, identified as client-1 (the events pushed by entrypoint.notify('client-1', 'progress', 50) reach it)
+ * const socket = io('http://localhost:3000', {auth: {id: 'client-1'}})
+ * socket.on('progress', (percent: number): void => console.log(`${percent}%`))
+ * socket.emit('message', {cmd: 'echo', text: 'hi'}, (response: {success: boolean, error: unknown, payload: unknown}): void => {
+ *     //{success: true, error: null, payload: 'hi'}
+ *     console.log(response)
+ * })
+ * ```
+ */
+export declare function socketIOServiceEntrypoint(options?: SocketIOServiceEntrypointOptions): EntrypointAdapter<ServiceContext>;

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

@@ -0,0 +1,18 @@
+import { ChannelDefinition } from './Channel.js';
+/**
+ * The HTTP channel, addressed by route and method
+ */
+export declare const HTTPChannel: ChannelDefinition;
+/**
+ * The CLI channel, addressed by command
+ */
+export declare const CLIChannel: ChannelDefinition;
+/**
+ * The service channel, addressed by pattern
+ */
+export declare const ServiceChannel: ChannelDefinition;
+/**
+ * The schedule channel: no external caller, each action is run by the timers of the schedule adapter.
+ * The address of an action is its schedule, with the key telling apart the actions of a same schedule
+ */
+export declare const ScheduleChannel: ChannelDefinition;