@lakutata/entrypoint 3.0.0-beta.0

package/dist/esm/adapter/fastify/FastifyHTTPEntrypoint.js

@@ -0,0 +1,333 @@
+import Fastify from 'fastify';
+import { createReadStream } from 'node:fs';
+import path from 'node:path';
+import { HTTPContext } from '../../context/HTTPContext.js';
+import { HTTPChannel } from '../../channel/BuiltinChannels.js';
+import { EventsResult, FileResult, StatusResult } from '../../lib/Result.js';
+import { RouteNotFoundException } from '../../exceptions/RouteNotFoundException.js';
+import { FastifyJSONResponder } from './Responders.js';
+/**
+ * The content types of the common file extensions
+ */
+const CONTENT_TYPES = {
+    '.txt': 'text/plain; charset=utf-8',
+    '.html': 'text/html; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.csv': 'text/csv; charset=utf-8',
+    '.xml': 'application/xml; charset=utf-8',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+    '.pdf': 'application/pdf',
+    '.zip': 'application/zip'
+};
+/**
+ * The first segments of the routes
+ * @param routes
+ */
+function actionPrefixesOf(routes) {
+    const prefixes = new Set();
+    for (const route of routes) {
+        const segment = route.split('/').find((part) => !!part);
+        //A route starting with a parameter matches every path
+        if (segment && !/^[:*]/.test(segment))
+            prefixes.add(`/${segment}`);
+    }
+    return [...prefixes];
+}
+/**
+ * The data of an event of a stream
+ * @param data
+ * @param event
+ * @param id
+ */
+function eventFrame(data, event, id) {
+    let frame = '';
+    if (id !== undefined)
+        frame += `id: ${id}\n`;
+    if (event !== undefined)
+        frame += `event: ${event}\n`;
+    const text = typeof data === 'string' ? data : JSON.stringify(data);
+    for (const line of text.split(/\r?\n/))
+        frame += `data: ${line}\n`;
+    return `${frame}\n`;
+}
+/**
+ * Whether a value is a fastify instance
+ * @param value
+ */
+function isFastifyInstance(value) {
+    return !!value && typeof value.route === 'function' && typeof value.listen === 'function';
+}
+/**
+ * Create the HTTP adapter of an entrypoint served by a fastify instance: each HTTP action (`@GET`, `@POST`,
+ * `@HTTPAction`…) becomes a fastify route. It needs the optional peer dependency `fastify`.
+ *
+ * An action's input is the request's query and body (see the `input` option) with the route parameters merged over
+ * them. Its result is written by the responder (JSON by default, 204 for no result); a `StatusResult` sets the status
+ * and the headers, a `FileResult` sends a file, a buffer or a stream (its content type guessed from the extension of
+ * its file name, 304 when its ETag matches `If-None-Match`), and an `EventsResult` streams Server-Sent Events. An action
+ * that writes the response itself (through `HTTPContext.response`) is left alone. The errors, those of fastify included
+ * (a body too large: 413, a malformed JSON body: 400), are written by the responder with their status (500 by default).
+ * A GET action also answers HEAD, unless a HEAD action is declared for its route.
+ *
+ * When the client disconnects before the response, the action's abort signal fires and nothing is written. When the
+ * entrypoint stops, fastify stops accepting connections and answers the new requests with 503, the event streams end,
+ * and the requests in progress are given up to one second after they settle to send their responses before the
+ * remaining connections are closed.
+ * @param options The adapter options; by default it listens on port 80 with a new fastify instance.
+ * @returns The adapter, to give to the `http` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {GET, POST} from 'lakutata/decorator/ctrl'
+ * import {fastifyHTTPEntrypoint} from 'lakutata/adapter/fastify'
+ *
+ * class UserController extends Controller {
+ *     //GET /users/1?verbose=true: the route parameter id merged over the query
+ *     @GET('/users/:id')
+ *     public async get(input: {id: string, verbose?: string}): Promise<{id: string}> {
+ *         return {id: input.id}
+ *     }
+ *
+ *     //POST /users with the JSON body {"name": "Ada"}
+ *     @POST('/users')
+ *     public async create(input: {name: string}): Promise<{name: string}> {
+ *         return {name: input.name}
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'web.app',
+ *     name: 'Web',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [UserController],
+ *             http: fastifyHTTPEntrypoint({
+ *                 port: 8080,
+ *                 host: '0.0.0.0',
+ *                 fastify: {bodyLimit: 5 * 1024 * 1024, trustProxy: true},
+ *                 //The application's own routes
+ *                 before: (app): void => {
+ *                     app.get('/health', async (): Promise<string> => 'ok')
+ *                 }
+ *             })
+ *         })
+ *     }
+ * })
+ * ```
+ */
+export function fastifyHTTPEntrypoint(options = {}) {
+    const respond = options.respond ?? FastifyJSONResponder;
+    const input = options.input ?? ((request) => ({
+        ...(request.query && typeof request.query === 'object' ? request.query : {}),
+        ...(request.body && typeof request.body === 'object' && !Array.isArray(request.body) ? request.body : {})
+    }));
+    const streams = new Set();
+    let app;
+    let closed;
+    let stopping = false;
+    //The responses not sent yet
+    const responding = new Set();
+    /**
+     * Stream the events of a result
+     * @param result
+     * @param reply
+     */
+    const streamEvents = async (result, reply) => {
+        const abortController = new AbortController();
+        streams.add(abortController);
+        reply.hijack();
+        const response = reply.raw;
+        response.writeHead(200, {
+            ...reply.getHeaders(),
+            'Content-Type': 'text/event-stream; charset=utf-8',
+            'Cache-Control': 'no-cache, no-transform',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no'
+        });
+        response.flushHeaders();
+        const heartbeat = setInterval(() => response.write(': ping\n\n'), options.heartbeat ?? 15000);
+        const close = () => abortController.abort();
+        response.on('close', close);
+        try {
+            await result.producer((data, event, id) => {
+                if (!abortController.signal.aborted)
+                    response.write(eventFrame(data, event, id));
+            }, abortController.signal);
+        }
+        catch {
+            //The stream is already started, its error ends it
+        }
+        finally {
+            clearInterval(heartbeat);
+            response.off('close', close);
+            streams.delete(abortController);
+            if (!response.writableEnded)
+                response.end();
+        }
+    };
+    /**
+     * Send a file
+     * @param result
+     * @param request
+     * @param reply
+     */
+    const sendFile = async (result, request, reply) => {
+        const { contentType, filename, etag, headers } = result.options;
+        if (headers)
+            reply.headers(headers);
+        if (etag) {
+            reply.header('ETag', `"${etag}"`);
+            if (request.headers['if-none-match'] === `"${etag}"`) {
+                await reply.code(304).send();
+                return;
+            }
+        }
+        const source = result.source;
+        const name = filename ?? (typeof source === 'string' ? path.basename(source) : undefined);
+        if (filename)
+            reply.header('Content-Disposition', `attachment; filename="${encodeURIComponent(filename)}"`);
+        reply.type(contentType ?? (name && CONTENT_TYPES[path.extname(name).toLowerCase()]) ?? 'application/octet-stream');
+        await reply.send(typeof source === 'string' ? createReadStream(path.resolve(source)) : source);
+    };
+    /**
+     * Write the result of an action
+     * @param result
+     * @param request
+     * @param reply
+     */
+    const output = async (result, request, reply) => {
+        //The action wrote the response itself
+        if (reply.sent || reply.raw.headersSent)
+            return;
+        if (result instanceof EventsResult)
+            return await streamEvents(result, reply);
+        if (result instanceof FileResult)
+            return await sendFile(result, request, reply);
+        if (result instanceof StatusResult) {
+            reply.code(result.status).headers(result.headers);
+            return respond.success(reply, result.data, request);
+        }
+        respond.success(reply, result, request);
+    };
+    /**
+     * The handler of the requests of an action
+     * @param runtime
+     * @param action
+     */
+    const actionHandler = (runtime, action) => async (request, reply) => {
+        const abortController = new AbortController();
+        //The client left before the response was sent
+        reply.raw.once('close', () => {
+            if (!reply.raw.writableFinished)
+                abortController.abort();
+        });
+        const context = new HTTPContext({
+            route: action.address.route,
+            method: action.address.method,
+            request: request.raw,
+            response: reply.raw,
+            data: input(request)
+        });
+        try {
+            const result = await runtime.dispatchTo(action, context, { signal: abortController.signal, params: { ...request.params } });
+            if (!abortController.signal.aborted)
+                await output(result, request, reply);
+        }
+        catch (error) {
+            if (!reply.sent && !reply.raw.headersSent && !abortController.signal.aborted)
+                respond.error(reply, error, request, 'action');
+        }
+        //The client left: nothing is sent, the request is done for fastify (it is not waited for when fastify closes)
+        if (abortController.signal.aborted && !reply.sent) {
+            reply.hijack();
+            reply.raw.destroy();
+        }
+        return reply;
+    };
+    return {
+        channel: 'http',
+        definition: HTTPChannel,
+        name: options.name,
+        middlewares: options.middlewares,
+        start: async (runtime) => {
+            const fastify = isFastifyInstance(options.fastify) ? options.fastify : Fastify(options.fastify ?? {});
+            app = fastify;
+            const routes = new Map();
+            for (const action of runtime.actions)
+                routes.set(action.address.route, (routes.get(action.address.route) ?? new Set()).add(String(action.address.method).toUpperCase()));
+            const actionPrefixes = actionPrefixesOf(routes.keys());
+            const isActionPath = (requestPath) => actionPrefixes.some((prefix) => requestPath === prefix || requestPath.startsWith(`${prefix}/`));
+            await options.before?.(fastify, { module: runtime.module, server: fastify.server, routes: routes, actionPrefixes: actionPrefixes, isActionPath: isActionPath });
+            for (const action of runtime.actions) {
+                const method = String(action.address.method).toUpperCase();
+                fastify.route({
+                    method: method,
+                    url: action.address.route,
+                    //A HEAD action of the route replaces the HEAD route fastify adds to a GET route
+                    exposeHeadRoute: method === 'GET' && !routes.get(action.address.route).has('HEAD'),
+                    handler: actionHandler(runtime, action)
+                });
+            }
+            fastify.setNotFoundHandler((request, reply) => {
+                const requestPath = request.url.split('?')[0];
+                if (options.fallback && !isActionPath(requestPath))
+                    return options.fallback(request, reply);
+                return respond.error(reply, new RouteNotFoundException('Route {route} not found', { route: requestPath }), request, 'request');
+            });
+            //The responses in progress are waited for when the adapter closes
+            fastify.addHook('onRequest', async (request, reply) => {
+                const responded = new Promise((resolve) => void reply.raw.once('close', resolve));
+                responding.add(responded);
+                //Only resolved
+                void responded.then(() => responding.delete(responded));
+            });
+            //While the adapter stops, the connections are closed once their response is sent
+            fastify.addHook('onResponse', async () => {
+                if (stopping)
+                    setImmediate(() => fastify.server.closeIdleConnections());
+            });
+            fastify.setErrorHandler((error, request, reply) => respond.error(reply, error, request, 'request'));
+            //The adapter starts once the server listens (an occupied port fails the start)
+            //Every interface by default, as the other adapters (fastify listens on localhost only)
+            if (options.host !== undefined) {
+                await fastify.listen({ port: options.port ?? 80, host: options.host });
+            }
+            else {
+                try {
+                    await fastify.listen({ port: options.port ?? 80, host: '::' });
+                }
+                catch (error) {
+                    if (!['EAFNOSUPPORT', 'EADDRNOTAVAIL'].includes(error.code ?? ''))
+                        throw error;
+                    await fastify.listen({ port: options.port ?? 80, host: '0.0.0.0' });
+                }
+            }
+        },
+        stop: () => {
+            //The event streams end; fastify stops accepting connections, closes the idle ones and answers 503 to the new requests
+            stopping = true;
+            streams.forEach((stream) => stream.abort());
+            closed = app?.close();
+        },
+        close: async () => {
+            //The requests in progress ended or were aborted: their responses are given a second to be sent, then the remaining connections are closed
+            //(a connection opened without a request would hold the close of the server)
+            let timer;
+            await Promise.race([Promise.all(responding), new Promise((resolve) => {
+                    timer = setTimeout(resolve, 1000);
+                })]);
+            clearTimeout(timer);
+            app?.server.closeAllConnections();
+            await closed;
+            await options.stop?.();
+        }
+    };
+}

package/dist/esm/adapter/fastify/Responders.js

@@ -0,0 +1,73 @@
+import { describeError, statusOfError } from '../../lib/HTTPErrors.js';
+/**
+ * Send JSON
+ * @param reply
+ * @param data
+ */
+function sendJSON(reply, data) {
+    reply.type('application/json; charset=utf-8').send(JSON.stringify(data));
+}
+/**
+ * The default responder of {@link fastifyHTTPEntrypoint}: a result is sent as JSON, no result as an empty 204 (or the
+ * status set by a `StatusResult`); an error is sent as `{errno, errMsg}` (see `describeError`) with its HTTP status
+ * (see `statusOfError`: the first 4xx status in its cause chain, its own status, or 500).
+ */
+export const FastifyJSONResponder = {
+    success: (reply, data) => {
+        if (data === undefined) {
+            reply.code(reply.statusCode === 200 ? 204 : reply.statusCode).send();
+            return;
+        }
+        sendJSON(reply, data);
+    },
+    error: (reply, error) => {
+        reply.code(statusOfError(error));
+        sendJSON(reply, describeError(error));
+    }
+};
+/**
+ * Create a responder for {@link fastifyHTTPEntrypoint} that wraps every response in the envelope
+ * `{errno, errMsg, data}`: a result as `{errno: null, errMsg: null, data}` (`data` is `null` when the action returned
+ * nothing, and its status is not turned into 204), an error as `{errno, errMsg, data: null}` with the error's status,
+ * the `errorStatus` option, or for the errors of the actions the `actionErrorStatus` option.
+ * @param options The envelope options.
+ * @returns The responder, to give to the `respond` option of `fastifyHTTPEntrypoint`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {GET} from 'lakutata/decorator/ctrl'
+ * import {fastifyHTTPEntrypoint, fastifyJSONEnvelope} from 'lakutata/adapter/fastify'
+ *
+ * class PingController extends Controller {
+ *     //GET /ping answers {"errno": null, "errMsg": null, "data": "pong"}
+ *     @GET('/ping')
+ *     public async ping(): Promise<string> {
+ *         return 'pong'
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'web.app',
+ *     name: 'Web',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [PingController],
+ *             //The errors of the actions answered with 200 too (as the applications of lakutata 2.x), the routes not
+ *             //found and the errors of the hooks with their status (404, 401…)
+ *             http: fastifyHTTPEntrypoint({port: 8080, respond: fastifyJSONEnvelope({actionErrorStatus: 200})})
+ *         })
+ *     }
+ * })
+ * ```
+ */
+export function fastifyJSONEnvelope(options = {}) {
+    return {
+        success: (reply, data) => sendJSON(reply, { errno: null, errMsg: null, data: data === undefined ? null : data }),
+        error: (reply, error, _request, origin) => {
+            const status = origin === 'action' ? options.actionErrorStatus ?? options.errorStatus : options.errorStatus;
+            reply.code(status ?? statusOfError(error));
+            sendJSON(reply, { ...describeError(error), data: null });
+        }
+    };
+}

package/dist/esm/adapter/http/HTTPServiceEntrypoint.js

@@ -0,0 +1,253 @@
+import { randomUUID } from 'node:crypto';
+import { createServer } from 'node:http';
+import { ServiceContext } from '../../context/ServiceContext.js';
+import { ServiceChannel } from '../../channel/BuiltinChannels.js';
+import { ServiceResponseCodec } from '../../lib/ServiceResponseCodec.js';
+import { EntrypointStoppedException } from '../../exceptions/EntrypointStoppedException.js';
+/**
+ * Get the HTTP request carrying a service action's request, when {@link httpServiceEntrypoint} serves it (to read its
+ * headers, its remote address…).
+ * @param context The service action's context (`this.context` in a controller).
+ * @returns The Node.js HTTP request, or `undefined` when another adapter serves the request.
+ * @example
+ * ```typescript
+ * import {Controller, httpRequestOfContext, ServiceContext} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ *
+ * class WhoAmIController extends Controller {
+ *     @ServiceAction({cmd: 'whoami'})
+ *     public async whoami(): Promise<string | undefined> {
+ *         return httpRequestOfContext(this.context as ServiceContext)?.socket.remoteAddress
+ *     }
+ * }
+ * ```
+ */
+export function httpRequestOfContext(context) {
+    return context.request;
+}
+/**
+ * The headers of the responses: the tools of the browsers may call the adapter (the development of the applications)
+ */
+const CORS_HEADERS = {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, id'
+};
+/**
+ * The id of the client of a request: its header id, its query id
+ * @param request
+ * @param url
+ */
+function clientIdOf(request, url) {
+    const given = request.headers.id ?? url.searchParams.get('id');
+    const id = Array.isArray(given) ? given[0] : given ?? undefined;
+    return id && id.length <= 200 ? id : undefined;
+}
+/**
+ * Write a response of JSON
+ * @param response
+ * @param status
+ * @param body
+ */
+function reply(response, status, body) {
+    if (response.headersSent || response.writableEnded)
+        return;
+    response.writeHead(status, { ...CORS_HEADERS, 'Content-Type': 'application/json; charset=utf-8' }).end(JSON.stringify(body));
+}
+/**
+ * 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`), { statusCode: 413 });
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+/**
+ * Create a service adapter of an entrypoint served over plain HTTP, handy to call the service actions from tools such
+ * as curl or Postman during development. It needs no optional dependency.
+ *
+ * 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.
+ *
+ * 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
+ * id in the `id` header or the `id` query parameter (at most 200 characters), the same on its requests so that they
+ * carry it as `ServiceContext.clientId`; without one, the stream assigns a random id, sent first as the `client` event.
+ * The streams receive a keep-alive comment every 15 seconds.
+ *
+ * When a client disconnects before its response, the action's abort signal fires. When the entrypoint stops, the new
+ * requests are answered with an `EntrypointStoppedException` error; once the requests in progress end, the event
+ * streams are closed and the server shuts down.
+ * @param options The adapter options; by default it listens 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, httpServiceEntrypoint} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ *
+ * 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: httpServiceEntrypoint({port: 3000, path: '/rpc'})
+ *         })
+ *     }
+ * })
+ *
+ * //A client: the response is {"success": true, "error": null, "payload": "hi"}
+ * const response: Response = await fetch('http://localhost:3000/rpc', {
+ *     method: 'POST',
+ *     headers: {'Content-Type': 'application/json', 'id': 'client-1'},
+ *     body: JSON.stringify({cmd: 'echo', text: 'hi'})
+ * })
+ * console.log(await response.json())
+ * //The events pushed to client-1: GET http://localhost:3000/rpc/events?id=client-1 (text/event-stream)
+ * ```
+ */
+export function httpServiceEntrypoint(options = {}) {
+    const base = (options.path ?? '/').replace(/\/+$/, '');
+    const requestPath = base || '/';
+    const eventsPath = `${base}/events`;
+    const limit = options.limit ?? 10 * 1024 * 1024;
+    let server;
+    let stopping = false;
+    let keepAlive;
+    //The event streams of each client (a client may listen several times)
+    const clients = new Map();
+    /**
+     * Write an event to a stream
+     * @param stream
+     * @param event
+     * @param args
+     */
+    const write = (stream, event, args) => {
+        stream.write(`event: ${event.replace(/[\r\n]+/g, ' ')}\ndata: ${JSON.stringify(args)}\n\n`);
+    };
+    /**
+     * Stream the events of a client
+     * @param request
+     * @param response
+     * @param url
+     */
+    const listen = (request, response, url) => {
+        const clientId = clientIdOf(request, url) ?? randomUUID();
+        response.writeHead(200, { ...CORS_HEADERS, 'Content-Type': 'text/event-stream; charset=utf-8', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
+        //Its id, given to the requests of the client (their header id)
+        write(response, 'client', [clientId]);
+        if (!clients.has(clientId))
+            clients.set(clientId, new Set());
+        clients.get(clientId).add(response);
+        request.once('close', () => {
+            clients.get(clientId)?.delete(response);
+            if (!clients.get(clientId)?.size)
+                clients.delete(clientId);
+        });
+    };
+    /**
+     * Answer a request of an action
+     * @param runtime
+     * @param request
+     * @param response
+     * @param url
+     */
+    const invoke = async (runtime, request, response, url) => {
+        if (stopping)
+            return reply(response, 200, ServiceResponseCodec.encodeError(new EntrypointStoppedException('The entrypoint is stopping')));
+        //Aborted when its client leaves before its response
+        const aborted = new AbortController();
+        response.once('close', () => {
+            if (!response.writableFinished)
+                aborted.abort();
+        });
+        let data;
+        try {
+            const body = await readBody(request, limit);
+            data = body ? JSON.parse(body) : {};
+        }
+        catch (error) {
+            //413 for a body larger than the limit, 400 for a body which is not JSON
+            return reply(response, error.statusCode ?? 400, ServiceResponseCodec.encodeError(error instanceof SyntaxError ? new Error('The body of the request is not JSON') : error));
+        }
+        let result;
+        try {
+            const context = new ServiceContext({ data: data && typeof data === 'object' ? data : {}, request: request, clientId: clientIdOf(request, url) });
+            result = ServiceResponseCodec.encode(await runtime.dispatch(context, { signal: aborted.signal }), false);
+        }
+        catch (error) {
+            result = ServiceResponseCodec.encodeError(error);
+        }
+        reply(response, 200, result);
+    };
+    return {
+        channel: 'service',
+        definition: ServiceChannel,
+        name: options.name,
+        middlewares: options.middlewares,
+        start: async (runtime) => {
+            server = createServer((request, response) => {
+                const url = new URL(request.url ?? '/', 'http://localhost');
+                if (request.method === 'OPTIONS')
+                    return void response.writeHead(204, CORS_HEADERS).end();
+                if (request.method === 'GET' && url.pathname === eventsPath)
+                    return listen(request, response, url);
+                if (request.method === 'POST' && url.pathname === requestPath)
+                    return void invoke(runtime, request, response, url);
+                reply(response, 404, { success: false, error: { message: `POST ${requestPath} invokes the actions, GET ${eventsPath} streams their events` }, payload: null });
+            });
+            //The event streams kept open by the proxies
+            keepAlive = setInterval(() => clients.forEach((streams) => streams.forEach((stream) => stream.write(': keep-alive\n\n'))), 15000);
+            keepAlive.unref();
+            await new Promise((resolve, reject) => {
+                server.once('error', reject).listen(options.port ?? 3000, options.host, () => {
+                    server.off('error', reject);
+                    resolve();
+                });
+            });
+            await options.listening?.(server);
+        },
+        stop: () => {
+            //The new requests are refused, the requests in progress end
+            stopping = true;
+        },
+        close: async () => {
+            clearInterval(keepAlive);
+            clients.forEach((streams) => streams.forEach((stream) => stream.end()));
+            clients.clear();
+            if (!server)
+                return;
+            const closing = new Promise((resolve) => void server.close(() => resolve()));
+            server.closeAllConnections();
+            await closing;
+        },
+        notify: (clientId, event, args) => {
+            const streams = clients.get(clientId);
+            streams?.forEach((stream) => write(stream, event, args));
+            return !!streams?.size;
+        },
+        broadcast: (event, args) => {
+            clients.forEach((streams) => streams.forEach((stream) => write(stream, event, args)));
+            return clients.size;
+        }
+    };
+}