@starci/hfs 4.3.0 → 4.4.1

package/templates/be/skeleton/src/modules/platform/http-security/readiness.decorators.ts

@@ -0,0 +1,7 @@
+import { injector } from "@modules/platform/composition"
+import type { TypedParameterDecorator } from "@modules/platform/composition"
+import { ReadinessService } from "./readiness.service"
+
+/** Injects the bounded required-dependency probe. Parameter type: ReadinessService. */
+export const InjectReadiness = (): TypedParameterDecorator<ReadinessService> =>
+    injector<ReadinessService>(ReadinessService)

package/templates/be/skeleton/src/modules/platform/http-security/readiness.service.spec.ts

@@ -0,0 +1,86 @@
+import { Test } from "@nestjs/testing"
+import { mock } from "@starci/jest-preset"
+import { DATABASE_PROBE } from "@modules/platform/database"
+import type { DatabaseProbeService } from "@modules/platform/database"
+import { TIMER } from "@modules/platform/retry"
+import type { Timer } from "@modules/platform/retry"
+import { HTTP_SECURITY_ERROR_KINDS, HttpSecurityError, HttpSecurityErrorCode } from "./errors/http-security.error"
+import { ReadinessService } from "./readiness.service"
+
+const build = async () => {
+    const database = mock<DatabaseProbeService>()
+    const timer = mock<Timer>()
+    const cancel = jest.fn()
+    timer.schedule.mockReturnValue(cancel)
+    const moduleRef = await Test.createTestingModule({
+        providers: [
+            ReadinessService,
+            { provide: DATABASE_PROBE, useValue: database },
+            { provide: TIMER, useValue: timer },
+        ],
+    }).compile()
+    return { service: moduleRef.get(ReadinessService), database, timer, cancel }
+}
+
+describe("ReadinessService", () => {
+    it("probes the required database before reporting ready", async () => {
+        const { service, database, timer } = await build()
+        database.probe.mockResolvedValue(undefined)
+
+        await expect(service.probeRequired()).resolves.toEqual({ ok: true })
+
+        expect(database.probe).toHaveBeenCalledTimes(1)
+        expect(timer.schedule).toHaveBeenCalledWith(expect.any(Function), 1000)
+    })
+
+    it("preserves the database failure under the unavailable error kind that answers 503", async () => {
+        const { service, database, cancel } = await build()
+        const cause = new Error("connection unavailable")
+        database.probe.mockRejectedValue(cause)
+        const probe = service.probeRequired()
+
+        await expect(probe).rejects.toBeInstanceOf(HttpSecurityError)
+        await expect(probe).rejects.toMatchObject({ code: HttpSecurityErrorCode.RequiredDependencyUnavailable, cause })
+        expect(HTTP_SECURITY_ERROR_KINDS[HttpSecurityErrorCode.RequiredDependencyUnavailable]).toBe("unavailable")
+        expect(cancel).toHaveBeenCalledTimes(1)
+    })
+
+    it("fails within the bounded timeout when the required database never answers", async () => {
+        const { service, database, timer, cancel } = await build()
+        database.probe.mockReturnValue(new Promise(() => undefined))
+        const probe = service.probeRequired()
+        const expected = expect(probe).rejects.toMatchObject({
+            code: HttpSecurityErrorCode.RequiredDependencyUnavailable,
+            cause: new Error("Required database readiness timed out"),
+        })
+
+        expect(timer.schedule).toHaveBeenCalledWith(expect.any(Function), 1000)
+        timer.schedule.mock.calls.at(0)?.[0]()
+        await expected
+        expect(cancel).toHaveBeenCalledTimes(1)
+    })
+
+    it("cancels the deadline when the database answers early", async () => {
+        const { service, database, cancel } = await build()
+        database.probe.mockResolvedValue(undefined)
+
+        await expect(service.probeRequired()).resolves.toEqual({ ok: true })
+
+        expect(cancel).toHaveBeenCalledTimes(1)
+    })
+
+    it("preserves a synchronous database failure before a deadline can be scheduled", async () => {
+        const { service, database, timer, cancel } = await build()
+        const cause = new HttpSecurityError({ code: HttpSecurityErrorCode.RequiredDependencyUnavailable })
+        database.probe.mockImplementation(() => {
+            throw cause
+        })
+
+        await expect(service.probeRequired()).rejects.toMatchObject({
+            code: HttpSecurityErrorCode.RequiredDependencyUnavailable,
+            cause,
+        })
+        expect(timer.schedule).not.toHaveBeenCalled()
+        expect(cancel).not.toHaveBeenCalled()
+    })
+})

package/templates/be/skeleton/src/modules/platform/http-security/readiness.service.ts

@@ -0,0 +1,39 @@
+import { Injectable } from "@nestjs/common"
+import { InjectDatabaseProbe } from "@modules/platform/database"
+import type { DatabaseProbeService } from "@modules/platform/database"
+import { InjectTimer } from "@modules/platform/retry"
+import type { Timer } from "@modules/platform/retry"
+import { HttpSecurityError, HttpSecurityErrorCode } from "./errors/http-security.error"
+import type { ReadinessReport } from "./readiness.contracts"
+
+const READINESS_TIMEOUT_MS = 1000
+
+@Injectable()
+/** Required-dependency readiness; liveness never calls this database probe. */
+export class ReadinessService {
+    constructor(
+        @InjectDatabaseProbe() private readonly database: DatabaseProbeService,
+        @InjectTimer() private readonly timer: Timer,
+    ) {}
+
+    /** Returns ready only when the required primary database answers within one second. */
+    async probeRequired(): Promise<ReadinessReport> {
+        let cancel: () => void = () => undefined
+        try {
+            await Promise.race([
+                this.database.probe(),
+                new Promise<never>((_resolve, reject) => {
+                    cancel = this.timer.schedule(
+                        () => reject(new Error("Required database readiness timed out")),
+                        READINESS_TIMEOUT_MS,
+                    )
+                }),
+            ])
+        } catch (cause) {
+            throw new HttpSecurityError({ code: HttpSecurityErrorCode.RequiredDependencyUnavailable, cause })
+        } finally {
+            cancel()
+        }
+        return { ok: true }
+    }
+}

package/templates/be/skeleton/src/modules/platform/http-security/webhook-signature.service.spec.ts

@@ -36,137 +36,145 @@ const build = async () => {
 
 const refusal = (code: HttpSecurityErrorCode) => expect.objectContaining({ code })
 
-describe("WebhookSignatureService", () => {
-    describe("verify", () => {
-        it("accepts a current delivery signed with the configured secret", async () => {
-            const { service } = await build()
-            const timestamp = String(SIGNED_AT)
-
-            expect(() =>
-                service.verify({
-                    provider: "payments",
-                    rawBody: BODY,
-                    signature: `sha256=${sign(timestamp)}`,
-                    timestamp,
-                }),
-            ).not.toThrow()
-        })
-
-        it("refuses a provider that is not configured", async () => {
-            const { service } = await build()
-
-            expect(() =>
-                service.verify({
-                    provider: "unknown",
-                    rawBody: BODY,
-                    signature: "sha256=x",
-                    timestamp: "1",
-                }),
-            ).toThrow(refusal(HttpSecurityErrorCode.WebhookProviderUnknown))
-        })
-
-        it.each([
-            {
-                rawBody: undefined,
+const signedPartCases = () => {
+    it("accepts a current delivery signed with the configured secret", async () => {
+        const { service } = await build()
+        const timestamp = String(SIGNED_AT)
+
+        expect(() =>
+            service.verify({
+                provider: "payments",
+                rawBody: BODY,
+                signature: `sha256=${sign(timestamp)}`,
+                timestamp,
+            }),
+        ).not.toThrow()
+    })
+
+    it("refuses a provider that is not configured", async () => {
+        const { service } = await build()
+
+        expect(() =>
+            service.verify({
+                provider: "unknown",
+                rawBody: BODY,
                 signature: "sha256=x",
-                timestamp: String(SIGNED_AT),
-            },
-            { rawBody: BODY, signature: undefined, timestamp: String(SIGNED_AT) },
-            { rawBody: BODY, signature: "sha256=x", timestamp: undefined },
-            { rawBody: BODY, signature: "sha256=x", timestamp: "yesterday" },
-        ])("refuses a delivery missing a signed part (%#)", async (part) => {
-            const { service } = await build()
-
-            expect(() => service.verify({ provider: "payments", ...part })).toThrow(
-                refusal(HttpSecurityErrorCode.WebhookSignatureInvalid),
-            )
-        })
-
-        it("refuses a signature without the sha256 scheme", async () => {
-            const { service } = await build()
-            const timestamp = String(SIGNED_AT)
-
-            expect(() =>
-                service.verify({
-                    provider: "payments",
-                    rawBody: BODY,
-                    signature: sign(timestamp),
-                    timestamp,
-                }),
-            ).toThrow(refusal(HttpSecurityErrorCode.WebhookSignatureInvalid))
-        })
-
-        it("refuses a signature of another length and one made with another secret", async () => {
-            const { service } = await build()
-            const timestamp = String(SIGNED_AT)
-
-            expect(() =>
-                service.verify({
-                    provider: "payments",
-                    rawBody: BODY,
-                    signature: "sha256=abc",
-                    timestamp,
-                }),
-            ).toThrow(refusal(HttpSecurityErrorCode.WebhookSignatureInvalid))
-            expect(() =>
-                service.verify({
-                    provider: "payments",
-                    rawBody: BODY,
-                    signature: `sha256=${sign(timestamp, BODY, "other")}`,
-                    timestamp,
-                }),
-            ).toThrow(refusal(HttpSecurityErrorCode.WebhookSignatureInvalid))
-        })
-
-        it("refuses a delivery whose body was changed after signing", async () => {
-            const { service } = await build()
-            const timestamp = String(SIGNED_AT)
-
-            expect(() =>
-                service.verify({
-                    provider: "payments",
-                    rawBody: Buffer.from("{}"),
-                    signature: `sha256=${sign(timestamp)}`,
-                    timestamp,
-                }),
-            ).toThrow(refusal(HttpSecurityErrorCode.WebhookSignatureInvalid))
-        })
-
-        it("refuses a correctly signed delivery outside the replay window, in either direction", async () => {
-            const { service } = await build()
-            const stale = String(SIGNED_AT - 300_001)
-            const future = String(SIGNED_AT + 300_001)
-
-            expect(() =>
-                service.verify({
-                    provider: "payments",
-                    rawBody: BODY,
-                    signature: `sha256=${sign(stale)}`,
-                    timestamp: stale,
-                }),
-            ).toThrow(refusal(HttpSecurityErrorCode.WebhookReplayed))
-            expect(() =>
-                service.verify({
-                    provider: "payments",
-                    rawBody: BODY,
-                    signature: `sha256=${sign(future)}`,
-                    timestamp: future,
-                }),
-            ).toThrow(refusal(HttpSecurityErrorCode.WebhookReplayed))
-        })
-
-        it("accepts a delivery exactly at the edge of the replay window", async () => {
-            const { service } = await build()
-            const edge = String(SIGNED_AT - 300_000)
-
-            expect(() =>
-                service.verify({
-                    provider: "payments",
-                    rawBody: BODY,
-                    signature: `sha256=${sign(edge)}`,
-                    timestamp: edge,
-                }),
-            ).not.toThrow()
-        })
+                timestamp: "1",
+            }),
+        ).toThrow(refusal(HttpSecurityErrorCode.WebhookProviderUnknown))
+    })
+
+    it.each([
+        {
+            rawBody: undefined,
+            signature: "sha256=x",
+            timestamp: String(SIGNED_AT),
+        },
+        { rawBody: BODY, signature: undefined, timestamp: String(SIGNED_AT) },
+        { rawBody: BODY, signature: "sha256=x", timestamp: undefined },
+        { rawBody: BODY, signature: "sha256=x", timestamp: "yesterday" },
+    ])("refuses a delivery missing a signed part (%#)", async (part) => {
+        const { service } = await build()
+
+        expect(() => service.verify({ provider: "payments", ...part })).toThrow(
+            refusal(HttpSecurityErrorCode.WebhookSignatureInvalid),
+        )
+    })
+}
+
+const digestCases = () => {
+    it("refuses a signature without the sha256 scheme", async () => {
+        const { service } = await build()
+        const timestamp = String(SIGNED_AT)
+
+        expect(() =>
+            service.verify({
+                provider: "payments",
+                rawBody: BODY,
+                signature: sign(timestamp),
+                timestamp,
+            }),
+        ).toThrow(refusal(HttpSecurityErrorCode.WebhookSignatureInvalid))
+    })
+
+    it("refuses a signature of another length and one made with another secret", async () => {
+        const { service } = await build()
+        const timestamp = String(SIGNED_AT)
+
+        expect(() =>
+            service.verify({
+                provider: "payments",
+                rawBody: BODY,
+                signature: "sha256=abc",
+                timestamp,
+            }),
+        ).toThrow(refusal(HttpSecurityErrorCode.WebhookSignatureInvalid))
+        expect(() =>
+            service.verify({
+                provider: "payments",
+                rawBody: BODY,
+                signature: `sha256=${sign(timestamp, BODY, "other")}`,
+                timestamp,
+            }),
+        ).toThrow(refusal(HttpSecurityErrorCode.WebhookSignatureInvalid))
     })
+
+    it("refuses a delivery whose body was changed after signing", async () => {
+        const { service } = await build()
+        const timestamp = String(SIGNED_AT)
+
+        expect(() =>
+            service.verify({
+                provider: "payments",
+                rawBody: Buffer.from("{}"),
+                signature: `sha256=${sign(timestamp)}`,
+                timestamp,
+            }),
+        ).toThrow(refusal(HttpSecurityErrorCode.WebhookSignatureInvalid))
+    })
+}
+
+const replayWindowCases = () => {
+    it("refuses a correctly signed delivery outside the replay window, in either direction", async () => {
+        const { service } = await build()
+        const stale = String(SIGNED_AT - 300_001)
+        const future = String(SIGNED_AT + 300_001)
+
+        expect(() =>
+            service.verify({
+                provider: "payments",
+                rawBody: BODY,
+                signature: `sha256=${sign(stale)}`,
+                timestamp: stale,
+            }),
+        ).toThrow(refusal(HttpSecurityErrorCode.WebhookReplayed))
+        expect(() =>
+            service.verify({
+                provider: "payments",
+                rawBody: BODY,
+                signature: `sha256=${sign(future)}`,
+                timestamp: future,
+            }),
+        ).toThrow(refusal(HttpSecurityErrorCode.WebhookReplayed))
+    })
+
+    it("accepts a delivery exactly at the edge of the replay window", async () => {
+        const { service } = await build()
+        const edge = String(SIGNED_AT - 300_000)
+
+        expect(() =>
+            service.verify({
+                provider: "payments",
+                rawBody: BODY,
+                signature: `sha256=${sign(edge)}`,
+                timestamp: edge,
+            }),
+        ).not.toThrow()
+    })
+}
+
+describe("WebhookSignatureService", () => {
+    describe("verify signed parts", signedPartCases)
+    describe("verify digest", digestCases)
+    describe("verify replay window", replayWindowCases)
 })

package/templates/be/skeleton/src/modules/platform/i18n/index.ts

@@ -1,4 +1,4 @@
 export type { Locale, MessageBundle } from "./i18n.contracts"
-export { InjectMessageCatalog, InjectRequestLocale, MESSAGE_CATALOG } from "./i18n.decorators"
+export { InjectMessageCatalog, InjectRequestLocale, MESSAGE_CATALOG, REQUEST_LOCALE } from "./i18n.decorators"
 export { I18nModule } from "./i18n.module"
 export type { MessageCatalog, RequestLocale } from "./i18n.port"

package/templates/be/skeleton/src/modules/platform/logging/json-logger.service.spec.ts

@@ -6,21 +6,22 @@ import { createJsonLogger, JsonLoggerService } from "./json-logger.service"
 import { LOG_ERR, LOG_OUT } from "./logging.decorators"
 import { LoggingLogEvent } from "./logging.log-events"
 
+type WrittenLine = { stream: "out" | "err"; line: string }
+
+const readJsonLine = (line: string | undefined): Record<string, unknown> => {
+    try {
+        const entry: Record<string, unknown> = JSON.parse(line ?? "")
+        return entry
+    } catch (error) {
+        throw error
+    }
+}
+
 const build = async () => {
     const clock = new FakeClock("2026-05-06T07:08:09.000Z")
-    const written: Array<{ stream: "out" | "err"; line: string }> = []
-    const out = mock<Writable>({
-        write: (chunk: string) => {
-            written.push({ stream: "out", line: chunk })
-            return true
-        },
-    })
-    const err = mock<Writable>({
-        write: (chunk: string) => {
-            written.push({ stream: "err", line: chunk })
-            return true
-        },
-    })
+    const written: Array<WrittenLine> = []
+    const out = mock<Writable>({ write: (chunk: string) => written.push({ stream: "out", line: chunk }) > 0 })
+    const err = mock<Writable>({ write: (chunk: string) => written.push({ stream: "err", line: chunk }) > 0 })
     const moduleRef = await Test.createTestingModule({
         providers: [
             JsonLoggerService,
@@ -33,84 +34,107 @@ const build = async () => {
 }
 
 describe("JsonLoggerService", () => {
-    it("writes an info line to the out stream stamped by the clock", async () => {
+    it("writes one info JSON line to stdout stamped by the clock", async () => {
         const { logger, written } = await build()
-
         logger.info("cart.opened", { personId: "p-1" })
-
         expect(written).toEqual([
             {
                 stream: "out",
-                line: `${JSON.stringify({ level: "info", event: "cart.opened", time: "2026-05-06T07:08:09.000Z", personId: "p-1" })}\n`,
+                line: `${JSON.stringify({ personId: "p-1", level: "info", event: "cart.opened", time: "2026-05-06T07:08:09.000Z" })}\n`,
             },
         ])
     })
 
-    it("writes a warn line without fields to the err stream", async () => {
+    it("writes a warning without caller fields to stderr", async () => {
         const { logger, clock, written } = await build()
         clock.advance(1000)
-
         logger.warn(LoggingLogEvent.StartupFailed)
-
-        expect(written).toEqual([
-            {
-                stream: "err",
-                line: `${JSON.stringify({ level: "warn", event: LoggingLogEvent.StartupFailed, time: "2026-05-06T07:08:10.000Z" })}\n`,
-            },
-        ])
+        expect(readJsonLine(written[0]?.line)).toEqual({
+            level: "warn",
+            event: LoggingLogEvent.StartupFailed,
+            time: "2026-05-06T07:08:10.000Z",
+        })
+        expect(written[0]?.stream).toBe("err")
     })
+})
 
-    it("writes an error line with the name and message of an Error cause", async () => {
+describe("JsonLoggerService error details", () => {
+    it("retains the error name, message and stack without dumping the Error object", async () => {
         const { logger, written } = await build()
-
-        logger.error("db.failed", new TypeError("boom"), { operation: "PlaceOrderHandler" })
-
-        expect(written).toEqual([
-            {
-                stream: "err",
-                line: `${JSON.stringify({
-                    level: "error",
-                    event: "db.failed",
-                    time: "2026-05-06T07:08:09.000Z",
-                    errorName: "TypeError",
-                    errorMessage: "boom",
-                    operation: "PlaceOrderHandler",
-                })}\n`,
-            },
-        ])
+        const cause = new TypeError("boom")
+        logger.error("db.failed", cause, { operation: "PlaceOrderHandler" })
+        expect(readJsonLine(written[0]?.line)).toEqual({
+            operation: "PlaceOrderHandler",
+            errorName: "TypeError",
+            errorMessage: "boom",
+            stack: cause.stack,
+            level: "error",
+            event: "db.failed",
+            time: "2026-05-06T07:08:09.000Z",
+        })
+        expect(written[0]?.stream).toBe("err")
     })
 
-    it("writes an error line with the text of a cause that is not an Error", async () => {
+    it("retains an error's code, including zero, and protects cause details from caller fields", async () => {
         const { logger, written } = await build()
+        const cause = Object.assign(new Error("connection lost"), { code: 0 })
+        logger.error("db.failed", cause, { errorName: "fake", errorMessage: "fake", errorCode: "fake", stack: "fake" })
+        expect(readJsonLine(written[0]?.line)).toEqual({
+            errorName: "Error",
+            errorMessage: "connection lost",
+            errorCode: 0,
+            stack: cause.stack,
+            level: "error",
+            event: "db.failed",
+            time: "2026-05-06T07:08:09.000Z",
+        })
+    })
 
+    it("serializes a non-Error cause and preserves a code carried by an object cause", async () => {
+        const { logger, written } = await build()
         logger.error("db.failed", "plain failure")
-
-        expect(written).toEqual([
-            {
-                stream: "err",
-                line: `${JSON.stringify({ level: "error", event: "db.failed", time: "2026-05-06T07:08:09.000Z", errorMessage: "plain failure" })}\n`,
-            },
+        logger.error("db.failed", { code: "CONNECTION_CLOSED" })
+        logger.error("db.failed", null)
+        expect(written.map(({ line }) => readJsonLine(line).errorMessage)).toEqual([
+            "plain failure",
+            "[object Object]",
+            "null",
         ])
+        expect(readJsonLine(written[1]?.line).errorCode).toBe("CONNECTION_CLOSED")
+        expect(readJsonLine(written[0]?.line)).not.toHaveProperty("errorCode")
     })
+})
 
-    describe("createJsonLogger", () => {
-        afterEach(() => {
-            jest.restoreAllMocks()
-        })
-
-        it("builds a logger that writes info to stdout and errors to stderr, stamped by the clock", () => {
-            const lines: Array<string> = []
-            jest.spyOn(process.stdout, "write").mockImplementation((chunk) => lines.push(`out:${String(chunk)}`) > 0)
-            jest.spyOn(process.stderr, "write").mockImplementation((chunk) => lines.push(`err:${String(chunk)}`) > 0)
-            const logger = createJsonLogger(new FakeClock("2026-05-06T07:08:09.000Z"))
+describe("JsonLoggerService reserved fields", () => {
+    it("writes reserved level, event and time last so caller fields cannot forge them", async () => {
+        const { logger, written } = await build()
+        const fields = { level: "error", event: "forged", time: "1900-01-01T00:00:00Z", personId: "p-1" }
+        logger.info("cart.opened", fields)
+        logger.warn("cart.warning", fields)
+        logger.error("cart.failed", "failure", fields)
+        expect(written.map(({ line }) => readJsonLine(line).level)).toEqual(["info", "warn", "error"])
+        expect(written.map(({ line }) => readJsonLine(line).event)).toEqual([
+            "cart.opened",
+            "cart.warning",
+            "cart.failed",
+        ])
+        expect(written.every(({ line }) => readJsonLine(line).time === "2026-05-06T07:08:09.000Z")).toBe(true)
+    })
+})
 
-            logger.info(LoggingLogEvent.ServerStarted)
-            logger.warn(LoggingLogEvent.StartupFailed)
+describe("createJsonLogger", () => {
+    afterEach(() => jest.restoreAllMocks())
 
-            expect(lines).toEqual([
-                `out:${JSON.stringify({ level: "info", event: LoggingLogEvent.ServerStarted, time: "2026-05-06T07:08:09.000Z" })}\n`,
-                `err:${JSON.stringify({ level: "warn", event: LoggingLogEvent.StartupFailed, time: "2026-05-06T07:08:09.000Z" })}\n`,
-            ])
-        })
+    it("uses process stdout and stderr before the DI container exists", () => {
+        const lines: Array<string> = []
+        jest.spyOn(process.stdout, "write").mockImplementation((chunk) => lines.push(`out:${String(chunk)}`) > 0)
+        jest.spyOn(process.stderr, "write").mockImplementation((chunk) => lines.push(`err:${String(chunk)}`) > 0)
+        const logger = createJsonLogger(new FakeClock("2026-05-06T07:08:09.000Z"))
+        logger.info(LoggingLogEvent.ServerStarted)
+        logger.warn(LoggingLogEvent.StartupFailed)
+        expect(lines).toEqual([
+            `out:${JSON.stringify({ level: "info", event: LoggingLogEvent.ServerStarted, time: "2026-05-06T07:08:09.000Z" })}\n`,
+            `err:${JSON.stringify({ level: "warn", event: LoggingLogEvent.StartupFailed, time: "2026-05-06T07:08:09.000Z" })}\n`,
+        ])
     })
 })

package/templates/be/skeleton/src/modules/platform/logging/json-logger.service.ts

@@ -24,17 +24,18 @@ export class JsonLoggerService implements Logger {
         this.write("warn", this.err, event, fields)
     }
 
-    /** Writes an error line with the cause serialized by name and message. */
+    /** Writes the cause's name, message, optional error code and stack without allowing caller fields to replace them. */
     error(event: string, cause: unknown, fields?: LogFields): void {
+        const code = typeof cause === "object" && cause !== null && "code" in cause ? { errorCode: cause.code } : {}
         const detail =
             cause instanceof Error
-                ? { errorName: cause.name, errorMessage: cause.message }
+                ? { errorName: cause.name, errorMessage: cause.message, stack: cause.stack }
                 : { errorMessage: String(cause) }
-        this.write("error", this.err, event, { ...detail, ...fields })
+        this.write("error", this.err, event, { ...fields, ...detail, ...code })
     }
 
     private write(level: Level, sink: Writable, event: string, fields?: LogFields): void {
-        sink.write(`${JSON.stringify({ level, event, time: this.clock.now().toISOString(), ...fields })}\n`)
+        sink.write(`${JSON.stringify({ ...fields, level, event, time: this.clock.now().toISOString() })}\n`)
     }
 }
 

package/templates/be/skeleton/src/modules/platform/logging/logging.log-events.ts

@@ -4,8 +4,6 @@ export enum LoggingLogEvent {
     ServerStarted = "server.started",
     /** The service failed before it could serve; the process exits non-zero. */
     StartupFailed = "server.startup_failed",
-    /** The worker started: its jobs are ticking and its consumers are polling. */
-    WorkerStarted = "worker.started",
     /** The cli app's migrate run finished; the names of the applied migrations ride in the fields. */
     MigrationsApplied = "migrations.applied",
     /** The seed command finished; the seed files it ran ride in the fields, by connection. */