@lakutata/entrypoint 3.0.0-beta.1 → 3.0.0-beta.2

package/README.md

@@ -111,7 +111,7 @@ import {buildEntrypoints, Controller, type ActionInvocation, type Next} from 'la
 import {GET, UseMiddlewares} from 'lakutata/decorator/ctrl'
 
 //Runs around the action: before its input validation and its access control
-async function Timing(invocation: ActionInvocation, next: Next): Promise<unknown> {
+async function timing(invocation: ActionInvocation, next: Next): Promise<unknown> {
     const started: number = Date.now()
     try {
         return await next()
@@ -120,7 +120,7 @@ async function Timing(invocation: ActionInvocation, next: Next): Promise<unknown
     }
 }
 
-@UseMiddlewares(Timing)
+@UseMiddlewares(timing)
 class HealthController extends Controller {
     @GET('/health')
     public async health(): Promise<string> {
@@ -132,7 +132,7 @@ Application.run(() => ({
     id: 'health.app',
     name: 'Health',
     components: {
-        entrypoint: buildEntrypoints({controllers: [HealthController], middlewares: [Timing]})
+        entrypoint: buildEntrypoints({controllers: [HealthController], middlewares: [timing]})
     }
 }))
 ```

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

@@ -49,12 +49,23 @@ export type JSONEnvelopeOptions = {
      * @default `errorStatus`
      */
     actionErrorStatus?: number;
+    /**
+     * The extra fields of the envelope, such as the `timestamp`, `nonce` or `requestId` of the envelopes of the
+     * applications of lakutata 2.x: called for each response (a result or an error), its fields added after `errno`,
+     * `errMsg` and `data`, which they never replace. When it throws, a result is answered as an error, and an error
+     * without the extra fields.
+     * @param request The express request being answered.
+     * @returns The fields to add to the envelope.
+     * @default no extra field
+     */
+    extra?: (request: Request) => Record<string, unknown>;
 };
 /**
  * Create a responder for {@link expressHTTPEntrypoint} 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.
+ * the `errorStatus` option, or for the errors of the actions the `actionErrorStatus` option; the `extra` option adds
+ * fields to both.
  * @param options The envelope options.
  * @returns The responder, to give to the `respond` option of `expressHTTPEntrypoint`.
  * @example
@@ -79,8 +90,15 @@ export type JSONEnvelopeOptions = {
  *         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 express middlewares with their status (404, 401…)
- *             http: expressHTTPEntrypoint({port: 8080, respond: jsonEnvelope({actionErrorStatus: 200})})
+ *             //found and the errors of the express middlewares with their status (404, 401…); every envelope with
+ *             //its timestamp ({"errno": null, "errMsg": null, "data": "pong", "timestamp": 1767225600000})
+ *             http: expressHTTPEntrypoint({
+ *                 port: 8080,
+ *                 respond: jsonEnvelope({
+ *                     actionErrorStatus: 200,
+ *                     extra: (): Record<string, unknown> => ({timestamp: Date.now()})
+ *                 })
+ *             })
  *         })
  *     }
  * })

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

@@ -5,6 +5,7 @@ exports.jsonEnvelope = jsonEnvelope;
 const HTTPErrors_js_1 = require("../../lib/HTTPErrors.js");
 Object.defineProperty(exports, "describeError", { enumerable: true, get: function () { return HTTPErrors_js_1.describeError; } });
 Object.defineProperty(exports, "statusOfError", { enumerable: true, get: function () { return HTTPErrors_js_1.statusOfError; } });
+const Envelope_js_1 = require("../../lib/Envelope.js");
 /**
  * The default responder of {@link expressHTTPEntrypoint}: 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
@@ -26,7 +27,8 @@ exports.JSONResponder = {
  * Create a responder for {@link expressHTTPEntrypoint} 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.
+ * the `errorStatus` option, or for the errors of the actions the `actionErrorStatus` option; the `extra` option adds
+ * fields to both.
  * @param options The envelope options.
  * @returns The responder, to give to the `respond` option of `expressHTTPEntrypoint`.
  * @example
@@ -51,8 +53,15 @@ exports.JSONResponder = {
  *         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 express middlewares with their status (404, 401…)
- *             http: expressHTTPEntrypoint({port: 8080, respond: jsonEnvelope({actionErrorStatus: 200})})
+ *             //found and the errors of the express middlewares with their status (404, 401…); every envelope with
+ *             //its timestamp ({"errno": null, "errMsg": null, "data": "pong", "timestamp": 1767225600000})
+ *             http: expressHTTPEntrypoint({
+ *                 port: 8080,
+ *                 respond: jsonEnvelope({
+ *                     actionErrorStatus: 200,
+ *                     extra: (): Record<string, unknown> => ({timestamp: Date.now()})
+ *                 })
+ *             })
  *         })
  *     }
  * })
@@ -60,12 +69,12 @@ exports.JSONResponder = {
  */
 function jsonEnvelope(options = {}) {
     return {
-        success: (response, data) => {
-            response.json({ errno: null, errMsg: null, data: data === undefined ? null : data });
+        success: (response, data, request) => {
+            response.json((0, Envelope_js_1.envelopeOf)({ errno: null, errMsg: null, data: data === undefined ? null : data }, options.extra?.(request)));
         },
-        error: (response, error, _request, origin) => {
+        error: (response, error, request, origin) => {
             const status = origin === 'action' ? options.actionErrorStatus ?? options.errorStatus : options.errorStatus;
-            response.status(status ?? (0, HTTPErrors_js_1.statusOfError)(error)).json({ ...(0, HTTPErrors_js_1.describeError)(error), data: null });
+            response.status(status ?? (0, HTTPErrors_js_1.statusOfError)(error)).json((0, Envelope_js_1.envelopeOf)({ ...(0, HTTPErrors_js_1.describeError)(error), data: null }, (0, Envelope_js_1.errorExtraOf)(options.extra, request)));
         }
     };
 }

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

@@ -48,12 +48,23 @@ export type FastifyJSONEnvelopeOptions = {
      * @default `errorStatus`
      */
     actionErrorStatus?: number;
+    /**
+     * The extra fields of the envelope, such as the `timestamp`, `nonce` or `requestId` of the envelopes of the
+     * applications of lakutata 2.x: called for each response (a result or an error), its fields added after `errno`,
+     * `errMsg` and `data`, which they never replace. When it throws, a result is answered as an error, and an error
+     * without the extra fields.
+     * @param request The fastify request being answered.
+     * @returns The fields to add to the envelope.
+     * @default no extra field
+     */
+    extra?: (request: FastifyRequest) => Record<string, unknown>;
 };
 /**
  * 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.
+ * the `errorStatus` option, or for the errors of the actions the `actionErrorStatus` option; the `extra` option adds
+ * fields to both.
  * @param options The envelope options.
  * @returns The responder, to give to the `respond` option of `fastifyHTTPEntrypoint`.
  * @example
@@ -78,8 +89,15 @@ export type FastifyJSONEnvelopeOptions = {
  *         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})})
+ *             //found and the errors of the hooks with their status (404, 401…); every envelope with
+ *             //its timestamp ({"errno": null, "errMsg": null, "data": "pong", "timestamp": 1767225600000})
+ *             http: fastifyHTTPEntrypoint({
+ *                 port: 8080,
+ *                 respond: fastifyJSONEnvelope({
+ *                     actionErrorStatus: 200,
+ *                     extra: (): Record<string, unknown> => ({timestamp: Date.now()})
+ *                 })
+ *             })
  *         })
  *     }
  * })

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastifyJSONResponder = void 0;
 exports.fastifyJSONEnvelope = fastifyJSONEnvelope;
 const HTTPErrors_js_1 = require("../../lib/HTTPErrors.js");
+const Envelope_js_1 = require("../../lib/Envelope.js");
 /**
  * Send JSON
  * @param reply
@@ -33,7 +34,8 @@ exports.FastifyJSONResponder = {
  * 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.
+ * the `errorStatus` option, or for the errors of the actions the `actionErrorStatus` option; the `extra` option adds
+ * fields to both.
  * @param options The envelope options.
  * @returns The responder, to give to the `respond` option of `fastifyHTTPEntrypoint`.
  * @example
@@ -58,8 +60,15 @@ exports.FastifyJSONResponder = {
  *         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})})
+ *             //found and the errors of the hooks with their status (404, 401…); every envelope with
+ *             //its timestamp ({"errno": null, "errMsg": null, "data": "pong", "timestamp": 1767225600000})
+ *             http: fastifyHTTPEntrypoint({
+ *                 port: 8080,
+ *                 respond: fastifyJSONEnvelope({
+ *                     actionErrorStatus: 200,
+ *                     extra: (): Record<string, unknown> => ({timestamp: Date.now()})
+ *                 })
+ *             })
  *         })
  *     }
  * })
@@ -67,11 +76,11 @@ exports.FastifyJSONResponder = {
  */
 function fastifyJSONEnvelope(options = {}) {
     return {
-        success: (reply, data) => sendJSON(reply, { errno: null, errMsg: null, data: data === undefined ? null : data }),
-        error: (reply, error, _request, origin) => {
+        success: (reply, data, request) => sendJSON(reply, (0, Envelope_js_1.envelopeOf)({ errno: null, errMsg: null, data: data === undefined ? null : data }, options.extra?.(request))),
+        error: (reply, error, request, origin) => {
             const status = origin === 'action' ? options.actionErrorStatus ?? options.errorStatus : options.errorStatus;
             reply.code(status ?? (0, HTTPErrors_js_1.statusOfError)(error));
-            sendJSON(reply, { ...(0, HTTPErrors_js_1.describeError)(error), data: null });
+            sendJSON(reply, (0, Envelope_js_1.envelopeOf)({ ...(0, HTTPErrors_js_1.describeError)(error), data: null }, (0, Envelope_js_1.errorExtraOf)(options.extra, request)));
         }
     };
 }

package/dist/cjs/lib/Envelope.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The envelope of a response: its fields, then the extra fields not named as one of them (an extra field never
+ * replaces errno, errMsg or data)
+ * @param fields The fields of the envelope.
+ * @param extra The extra fields, ignored when they are not an object.
+ */
+export declare function envelopeOf(fields: Record<string, unknown>, extra: unknown): Record<string, unknown>;
+/**
+ * The extra fields of an error response: none when the function giving them fails, an error being answered anyway
+ * @param extra The function giving the extra fields.
+ * @param request The request answered.
+ */
+export declare function errorExtraOf<Request>(extra: ((request: Request) => Record<string, unknown>) | undefined, request: Request): unknown;

package/dist/cjs/lib/Envelope.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envelopeOf = envelopeOf;
+exports.errorExtraOf = errorExtraOf;
+/**
+ * The envelope of a response: its fields, then the extra fields not named as one of them (an extra field never
+ * replaces errno, errMsg or data)
+ * @param fields The fields of the envelope.
+ * @param extra The extra fields, ignored when they are not an object.
+ */
+function envelopeOf(fields, extra) {
+    const envelope = { ...fields };
+    if (extra === null || typeof extra !== 'object')
+        return envelope;
+    for (const [key, value] of Object.entries(extra))
+        if (!Object.prototype.hasOwnProperty.call(envelope, key))
+            envelope[key] = value;
+    return envelope;
+}
+/**
+ * The extra fields of an error response: none when the function giving them fails, an error being answered anyway
+ * @param extra The function giving the extra fields.
+ * @param request The request answered.
+ */
+function errorExtraOf(extra, request) {
+    try {
+        return extra?.(request);
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -1,4 +1,5 @@
 import { describeError, statusOfError } from '../../lib/HTTPErrors.js';
+import { envelopeOf, errorExtraOf } from '../../lib/Envelope.js';
 export { describeError, statusOfError };
 /**
  * The default responder of {@link expressHTTPEntrypoint}: a result is sent as JSON, no result as an empty 204 (or the
@@ -21,7 +22,8 @@ export const JSONResponder = {
  * Create a responder for {@link expressHTTPEntrypoint} 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.
+ * the `errorStatus` option, or for the errors of the actions the `actionErrorStatus` option; the `extra` option adds
+ * fields to both.
  * @param options The envelope options.
  * @returns The responder, to give to the `respond` option of `expressHTTPEntrypoint`.
  * @example
@@ -46,8 +48,15 @@ export const JSONResponder = {
  *         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 express middlewares with their status (404, 401…)
- *             http: expressHTTPEntrypoint({port: 8080, respond: jsonEnvelope({actionErrorStatus: 200})})
+ *             //found and the errors of the express middlewares with their status (404, 401…); every envelope with
+ *             //its timestamp ({"errno": null, "errMsg": null, "data": "pong", "timestamp": 1767225600000})
+ *             http: expressHTTPEntrypoint({
+ *                 port: 8080,
+ *                 respond: jsonEnvelope({
+ *                     actionErrorStatus: 200,
+ *                     extra: (): Record<string, unknown> => ({timestamp: Date.now()})
+ *                 })
+ *             })
  *         })
  *     }
  * })
@@ -55,12 +64,12 @@ export const JSONResponder = {
  */
 export function jsonEnvelope(options = {}) {
     return {
-        success: (response, data) => {
-            response.json({ errno: null, errMsg: null, data: data === undefined ? null : data });
+        success: (response, data, request) => {
+            response.json(envelopeOf({ errno: null, errMsg: null, data: data === undefined ? null : data }, options.extra?.(request)));
         },
-        error: (response, error, _request, origin) => {
+        error: (response, error, request, origin) => {
             const status = origin === 'action' ? options.actionErrorStatus ?? options.errorStatus : options.errorStatus;
-            response.status(status ?? statusOfError(error)).json({ ...describeError(error), data: null });
+            response.status(status ?? statusOfError(error)).json(envelopeOf({ ...describeError(error), data: null }, errorExtraOf(options.extra, request)));
         }
     };
 }

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

@@ -1,4 +1,5 @@
 import { describeError, statusOfError } from '../../lib/HTTPErrors.js';
+import { envelopeOf, errorExtraOf } from '../../lib/Envelope.js';
 /**
  * Send JSON
  * @param reply
@@ -29,7 +30,8 @@ export const FastifyJSONResponder = {
  * 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.
+ * the `errorStatus` option, or for the errors of the actions the `actionErrorStatus` option; the `extra` option adds
+ * fields to both.
  * @param options The envelope options.
  * @returns The responder, to give to the `respond` option of `fastifyHTTPEntrypoint`.
  * @example
@@ -54,8 +56,15 @@ export const FastifyJSONResponder = {
  *         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})})
+ *             //found and the errors of the hooks with their status (404, 401…); every envelope with
+ *             //its timestamp ({"errno": null, "errMsg": null, "data": "pong", "timestamp": 1767225600000})
+ *             http: fastifyHTTPEntrypoint({
+ *                 port: 8080,
+ *                 respond: fastifyJSONEnvelope({
+ *                     actionErrorStatus: 200,
+ *                     extra: (): Record<string, unknown> => ({timestamp: Date.now()})
+ *                 })
+ *             })
  *         })
  *     }
  * })
@@ -63,11 +72,11 @@ export const FastifyJSONResponder = {
  */
 export function fastifyJSONEnvelope(options = {}) {
     return {
-        success: (reply, data) => sendJSON(reply, { errno: null, errMsg: null, data: data === undefined ? null : data }),
-        error: (reply, error, _request, origin) => {
+        success: (reply, data, request) => sendJSON(reply, envelopeOf({ errno: null, errMsg: null, data: data === undefined ? null : data }, options.extra?.(request))),
+        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 });
+            sendJSON(reply, envelopeOf({ ...describeError(error), data: null }, errorExtraOf(options.extra, request)));
         }
     };
 }

package/dist/esm/lib/Envelope.js

@@ -0,0 +1,28 @@
+/**
+ * The envelope of a response: its fields, then the extra fields not named as one of them (an extra field never
+ * replaces errno, errMsg or data)
+ * @param fields The fields of the envelope.
+ * @param extra The extra fields, ignored when they are not an object.
+ */
+export function envelopeOf(fields, extra) {
+    const envelope = { ...fields };
+    if (extra === null || typeof extra !== 'object')
+        return envelope;
+    for (const [key, value] of Object.entries(extra))
+        if (!Object.prototype.hasOwnProperty.call(envelope, key))
+            envelope[key] = value;
+    return envelope;
+}
+/**
+ * The extra fields of an error response: none when the function giving them fails, an error being answered anyway
+ * @param extra The function giving the extra fields.
+ * @param request The request answered.
+ */
+export function errorExtraOf(extra, request) {
+    try {
+        return extra?.(request);
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -49,12 +49,23 @@ export type JSONEnvelopeOptions = {
      * @default `errorStatus`
      */
     actionErrorStatus?: number;
+    /**
+     * The extra fields of the envelope, such as the `timestamp`, `nonce` or `requestId` of the envelopes of the
+     * applications of lakutata 2.x: called for each response (a result or an error), its fields added after `errno`,
+     * `errMsg` and `data`, which they never replace. When it throws, a result is answered as an error, and an error
+     * without the extra fields.
+     * @param request The express request being answered.
+     * @returns The fields to add to the envelope.
+     * @default no extra field
+     */
+    extra?: (request: Request) => Record<string, unknown>;
 };
 /**
  * Create a responder for {@link expressHTTPEntrypoint} 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.
+ * the `errorStatus` option, or for the errors of the actions the `actionErrorStatus` option; the `extra` option adds
+ * fields to both.
  * @param options The envelope options.
  * @returns The responder, to give to the `respond` option of `expressHTTPEntrypoint`.
  * @example
@@ -79,8 +90,15 @@ export type JSONEnvelopeOptions = {
  *         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 express middlewares with their status (404, 401…)
- *             http: expressHTTPEntrypoint({port: 8080, respond: jsonEnvelope({actionErrorStatus: 200})})
+ *             //found and the errors of the express middlewares with their status (404, 401…); every envelope with
+ *             //its timestamp ({"errno": null, "errMsg": null, "data": "pong", "timestamp": 1767225600000})
+ *             http: expressHTTPEntrypoint({
+ *                 port: 8080,
+ *                 respond: jsonEnvelope({
+ *                     actionErrorStatus: 200,
+ *                     extra: (): Record<string, unknown> => ({timestamp: Date.now()})
+ *                 })
+ *             })
  *         })
  *     }
  * })

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

@@ -48,12 +48,23 @@ export type FastifyJSONEnvelopeOptions = {
      * @default `errorStatus`
      */
     actionErrorStatus?: number;
+    /**
+     * The extra fields of the envelope, such as the `timestamp`, `nonce` or `requestId` of the envelopes of the
+     * applications of lakutata 2.x: called for each response (a result or an error), its fields added after `errno`,
+     * `errMsg` and `data`, which they never replace. When it throws, a result is answered as an error, and an error
+     * without the extra fields.
+     * @param request The fastify request being answered.
+     * @returns The fields to add to the envelope.
+     * @default no extra field
+     */
+    extra?: (request: FastifyRequest) => Record<string, unknown>;
 };
 /**
  * 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.
+ * the `errorStatus` option, or for the errors of the actions the `actionErrorStatus` option; the `extra` option adds
+ * fields to both.
  * @param options The envelope options.
  * @returns The responder, to give to the `respond` option of `fastifyHTTPEntrypoint`.
  * @example
@@ -78,8 +89,15 @@ export type FastifyJSONEnvelopeOptions = {
  *         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})})
+ *             //found and the errors of the hooks with their status (404, 401…); every envelope with
+ *             //its timestamp ({"errno": null, "errMsg": null, "data": "pong", "timestamp": 1767225600000})
+ *             http: fastifyHTTPEntrypoint({
+ *                 port: 8080,
+ *                 respond: fastifyJSONEnvelope({
+ *                     actionErrorStatus: 200,
+ *                     extra: (): Record<string, unknown> => ({timestamp: Date.now()})
+ *                 })
+ *             })
  *         })
  *     }
  * })

package/dist/types/lib/Envelope.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The envelope of a response: its fields, then the extra fields not named as one of them (an extra field never
+ * replaces errno, errMsg or data)
+ * @param fields The fields of the envelope.
+ * @param extra The extra fields, ignored when they are not an object.
+ */
+export declare function envelopeOf(fields: Record<string, unknown>, extra: unknown): Record<string, unknown>;
+/**
+ * The extra fields of an error response: none when the function giving them fails, an error being answered anyway
+ * @param extra The function giving the extra fields.
+ * @param request The request answered.
+ */
+export declare function errorExtraOf<Request>(extra: ((request: Request) => Record<string, unknown>) | undefined, request: Request): unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakutata/entrypoint",
-  "version": "3.0.0-beta.1",
+  "version": "3.0.0-beta.2",
   "description": "The entrypoint component of the lakutata framework: controllers and the dispatch of the CLI, HTTP and service actions.",
   "type": "module",
   "main": "./dist/cjs/exports/Entrypoint.js",
@@ -110,8 +110,8 @@
   },
   "peerDependencies": {
     "@inquirer/prompts": "^7.0.0 || ^8.0.0",
-    "@lakutata/core": "3.0.0-beta.1",
-    "@lakutata/utils": "3.0.0-beta.1",
+    "@lakutata/core": "3.0.0-beta.2",
+    "@lakutata/utils": "3.0.0-beta.2",
     "commander": "^12.0.0 || ^13.0.0 || ^14.0.0 || ^15.0.0",
     "express": "^4.21.0 || ^5.0.0",
     "fastify": "^5.0.0",