@lakutata/entrypoint 3.0.0 → 3.1.0

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

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

package/dist/esm/Entrypoint.js

@@ -58,7 +58,8 @@ export { ScheduleContext } from './context/ScheduleContext.js';
  *                 if (cliMap.has(command)) console.log(await handler(new CLIContext({command: command, data: {}})))
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * }))
  * ```
  */
@@ -90,8 +91,9 @@ export const buildCLIEntrypoint = (entrypoint) => entrypoint;
  *             controllers: [HealthController],
  *             http: buildHTTPEntrypoint((module, routeMap, handler, registerDestroy): void => {
  *                 const server: Server = createServer(async (request, response): Promise<void> => {
+ *                     //The route map holds the routes and the methods as declared: '/health', 'get'
  *                     const route: string = (request.url ?? '/').split('?')[0]
- *                     const method: string = request.method ?? 'GET'
+ *                     const method: string = (request.method ?? 'GET').toLowerCase()
  *                     if (!routeMap.get(route)?.has(method)) {
  *                         response.writeHead(404).end()
  *                         return
@@ -108,7 +110,8 @@ export const buildCLIEntrypoint = (entrypoint) => entrypoint;
  *                 registerDestroy((): Promise<void> => new Promise((resolve): void => void server.close((): void => resolve())))
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * }))
  * ```
  */
@@ -149,7 +152,8 @@ export const buildHTTPEntrypoint = (entrypoint) => entrypoint;
  *                 registerDestroy((): void => void bus.off('request', listener))
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * }))
  * ```
  */
@@ -199,7 +203,8 @@ export const buildServiceEntrypoint = (entrypoint) => entrypoint;
  *             http: expressHTTPEntrypoint({port: 3000}),
  *             schedule: scheduleEntrypoint()
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * }))
  * ```
  */
@@ -269,7 +274,8 @@ const LEGACY_CHANNELS = new Set(['cli', 'http', 'service']);
  *                 http: expressHTTPEntrypoint({port: 3000}),
  *                 service: socketIOServiceEntrypoint({port: 3001})
  *             })
- *         }
+ *         },
+ *         bootstrap: ['entrypoint']
  *     }))
  *     .onLaunched(async (app: Application): Promise<void> => {
  *         const entrypoint: Entrypoint = await app.getObject<Entrypoint>('entrypoint')

package/dist/esm/adapter/commander/CommanderCLIEntrypoint.js

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

package/dist/esm/adapter/electron/ElectronIPCServiceEntrypoint.js

@@ -90,7 +90,8 @@ async function loadIPCMain() {
  *             controllers: [EchoController],
  *             service: electronIPCServiceEntrypoint()
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  *
  * //In the preload script of a window

package/dist/esm/adapter/express/ExpressHTTPEntrypoint.js

@@ -6,6 +6,7 @@ import { HTTPChannel } from '../../channel/BuiltinChannels.js';
 import { EventsResult, FileResult, StatusResult } from '../../lib/Result.js';
 import { RouteNotFoundException } from '../../exceptions/RouteNotFoundException.js';
 import { trackConnections } from '../../lib/Connections.js';
+import { markExplicitStatus } from '../../lib/ExplicitStatus.js';
 import { JSONResponder } from './Responders.js';
 /**
  * The first segments of the routes
@@ -94,7 +95,8 @@ function eventFrame(data, event, id) {
  *                 fallback: staticUI('./ui/dist')
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */
@@ -193,6 +195,7 @@ export function expressHTTPEntrypoint(options = {}) {
             return await sendFile(result, request, response);
         if (result instanceof StatusResult) {
             response.status(result.status).set(result.headers);
+            markExplicitStatus(response);
             return respond.success(response, result.data, request);
         }
         respond.success(response, result, request);
@@ -251,7 +254,10 @@ export function expressHTTPEntrypoint(options = {}) {
             await options.before?.(app, { module: runtime.module, server: server, routes: routes, actionPrefixes: actionPrefixes, isActionPath: isActionPath });
             if (options.body !== false)
                 app.use(express.json({ limit: options.body?.limit ?? '1mb' }), express.urlencoded({ extended: true, limit: options.body?.limit ?? '1mb' }));
-            for (const action of runtime.actions) {
+            //The HEAD actions first: express answers a HEAD request with the first GET route of its path when no HEAD route
+            //comes before it
+            const isHead = (action) => String(action.address.method).toLowerCase() === 'head';
+            for (const action of [...runtime.actions.filter(isHead), ...runtime.actions.filter((action) => !isHead(action))]) {
                 const method = String(action.address.method).toLowerCase();
                 const register = app[method];
                 if (typeof register !== 'function')

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

@@ -1,5 +1,6 @@
 import { describeError, statusOfError } from '../../lib/HTTPErrors.js';
 import { envelopeOf, errorExtraOf } from '../../lib/Envelope.js';
+import { hasExplicitStatus } from '../../lib/ExplicitStatus.js';
 export { describeError, statusOfError };
 /**
  * The default responder of {@link expressHTTPEntrypoint}: a result is sent as JSON, no result as an empty 204 (or the
@@ -9,7 +10,7 @@ export { describeError, statusOfError };
 export const JSONResponder = {
     success: (response, data) => {
         if (data === undefined) {
-            response.status(response.statusCode === 200 ? 204 : response.statusCode).end();
+            response.status(response.statusCode === 200 && !hasExplicitStatus(response) ? 204 : response.statusCode).end();
             return;
         }
         response.json(data);
@@ -58,7 +59,8 @@ export const JSONResponder = {
  *                 })
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */

package/dist/esm/adapter/express/StaticUI.js

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

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

@@ -6,6 +6,7 @@ import { HTTPChannel } from '../../channel/BuiltinChannels.js';
 import { EventsResult, FileResult, StatusResult } from '../../lib/Result.js';
 import { RouteNotFoundException } from '../../exceptions/RouteNotFoundException.js';
 import { trackConnections } from '../../lib/Connections.js';
+import { markExplicitStatus } from '../../lib/ExplicitStatus.js';
 import { FastifyJSONResponder } from './Responders.js';
 /**
  * The content types of the common file extensions
@@ -121,7 +122,8 @@ function isFastifyInstance(value) {
  *                 }
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */
@@ -216,6 +218,7 @@ export function fastifyHTTPEntrypoint(options = {}) {
             return await sendFile(result, request, reply);
         if (result instanceof StatusResult) {
             reply.code(result.status).headers(result.headers);
+            markExplicitStatus(reply.raw);
             return respond.success(reply, result.data, request);
         }
         respond.success(reply, result, request);

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

@@ -1,5 +1,6 @@
 import { describeError, statusOfError } from '../../lib/HTTPErrors.js';
 import { envelopeOf, errorExtraOf } from '../../lib/Envelope.js';
+import { hasExplicitStatus } from '../../lib/ExplicitStatus.js';
 /**
  * Send JSON
  * @param reply
@@ -16,7 +17,7 @@ function sendJSON(reply, data) {
 export const FastifyJSONResponder = {
     success: (reply, data) => {
         if (data === undefined) {
-            reply.code(reply.statusCode === 200 ? 204 : reply.statusCode).send();
+            reply.code(reply.statusCode === 200 && !hasExplicitStatus(reply.raw) ? 204 : reply.statusCode).send();
             return;
         }
         sendJSON(reply, data);
@@ -66,7 +67,8 @@ export const FastifyJSONResponder = {
  *                 })
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */

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

@@ -5,6 +5,8 @@ import { ServiceChannel } from '../../channel/BuiltinChannels.js';
 import { ServiceResponseCodec } from '../../lib/ServiceResponseCodec.js';
 import { EntrypointStoppedException } from '../../exceptions/EntrypointStoppedException.js';
 import { trackConnections } from '../../lib/Connections.js';
+import { readBody } from '../../lib/ReadBody.js';
+import { preflightHeaders } from '../../lib/Preflight.js';
 /**
  * Get the HTTP request carrying a service action's request, when {@link httpServiceEntrypoint} serves it (to read its
  * headers, its remote address…).
@@ -27,7 +29,8 @@ 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)
+ * The headers of the responses: the tools of the browsers may call the adapter (the development of the applications);
+ * a preflight is allowed the headers it asks for
  */
 const CORS_HEADERS = {
     'Access-Control-Allow-Origin': '*',
@@ -55,22 +58,6 @@ function reply(response, status, body) {
         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.
@@ -78,8 +65,8 @@ async function readBody(request, limit) {
  * A request is a `POST` to the path whose JSON body holds the action's pattern and input (`{"cmd": "echo", "text":
  * "hi"}`). The response is always 200 with the body `{success, error, payload}` (see `ServiceResponseCodec`): `payload`
  * is the result, or `error` the whole error object when the action failed (no matching action, validation…). A body that
- * is not JSON or exceeds `limit` is answered with 400 and an error body; any other method or path with 404. The CORS
- * headers allow any origin.
+ * is not JSON is answered with 400 and an error body, a body over `limit` with 413; any other method or path with 404.
+ * The CORS headers allow any origin, and the headers a preflight asks for (`Authorization`…).
  *
  * The events pushed to the clients (`Entrypoint.notify`, `Entrypoint.broadcast`) are streamed as Server-Sent Events by
  * `GET <path>/events`: each event's name is the SSE event, its arguments the JSON array of its data. A client gives its
@@ -114,7 +101,8 @@ async function readBody(request, limit) {
  *             controllers: [EchoController],
  *             service: httpServiceEntrypoint({port: 3000, path: '/rpc'})
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  *
  * //A client: the response is {"success": true, "error": null, "payload": "hi"}
@@ -211,7 +199,7 @@ export function httpServiceEntrypoint(options = {}) {
             server = 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, preflightHeaders(request, CORS_HEADERS)).end();
                 if (request.method === 'GET' && url.pathname === eventsPath)
                     return listen(request, response, url);
                 if (request.method === 'POST' && url.pathname === requestPath)