@starci/hfs 4.2.17 → 4.4.0

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

@@ -3,6 +3,7 @@ import type { DynamicModule } from "@nestjs/common"
 import { APP_PIPE } from "@nestjs/core"
 import { WEBHOOK_SIGNATURE } from "./http-security.decorators"
 import { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } from "./http-security.module-definition"
+import { ReadinessService } from "./readiness.service"
 import { RequestValidationService } from "./request-validation.service"
 import { WebhookSignatureService } from "./webhook-signature.service"
 
@@ -18,9 +19,10 @@ export class HttpSecurityModule extends ConfigurableModuleClass {
                 ...(base.providers ?? []),
                 { provide: APP_PIPE, useClass: RequestValidationService },
                 WebhookSignatureService,
+                ReadinessService,
                 { provide: WEBHOOK_SIGNATURE, useExisting: WebhookSignatureService },
             ],
-            exports: [MODULE_OPTIONS_TOKEN, WebhookSignatureService, WEBHOOK_SIGNATURE],
+            exports: [MODULE_OPTIONS_TOKEN, WebhookSignatureService, WEBHOOK_SIGNATURE, ReadinessService],
         }
     }
 }

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

@@ -22,6 +22,8 @@ export interface WebhookProviderOptions {
 export interface HttpSecurityOptions {
     /** The origins allowed to send state-changing requests from a browser. */
     readonly allowedOrigins: ReadonlyArray<string>
+    /** Plain HTTP origins are admitted only by a development or test environment reader. */
+    readonly allowHttpOrigins?: boolean
     /** The rate limit tiers. */
     readonly rateLimit: RateLimitOptions
     /** Signed-webhook providers keyed by their generated route name. */

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

@@ -4,4 +4,9 @@ export { HttpSecurityModule } from "./http-security.module"
 export type { HttpSecurityOptions } from "./http-security.options"
 export { HTTP_SECURITY_MESSAGES } from "./messages/http-security.messages"
 export { OriginGuard } from "./origin.guard"
+export { requestOf } from "./execution-request.mapper"
 export { RateLimitGuard } from "./rate-limit.guard"
+export { applyHttpSecurity } from "./edge-security.service"
+export { ReadinessService } from "./readiness.service"
+export { InjectReadiness } from "./readiness.decorators"
+export type { ReadinessReport } from "./readiness.contracts"

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

@@ -3,14 +3,21 @@ import type { MessageBundle } from "@modules/platform/i18n"
 /** Display text of the http-security codes, Vietnamese and English. */
 export const HTTP_SECURITY_MESSAGES: MessageBundle = {
     vi: {
-        "errors.HTTP_SECURITY_ORIGIN_REJECTED": "Ngu\u1ed3n g\u1eedi y\u00eau c\u1ea7u kh\u00f4ng \u0111\u01b0\u1ee3c ph\u00e9p.",
-        "errors.HTTP_SECURITY_RATE_LIMITED": "B\u1ea1n g\u1eedi qu\u00e1 nhi\u1ec1u y\u00eau c\u1ea7u, h\u00e3y th\u1eed l\u1ea1i sau.",
-        "errors.HTTP_SECURITY_REQUEST_INVALID": "D\u1eef li\u1ec7u g\u1eedi l\u00ean kh\u00f4ng h\u1ee3p l\u1ec7: {{fields}}.",
+        "errors.HTTP_SECURITY_REQUIRED_DEPENDENCY_UNAVAILABLE": "C\u01a1 s\u1edf d\u1eef li\u1ec7u b\u1eaft bu\u1ed9c hi\u1ec7n kh\u00f4ng kh\u1ea3 d\u1ee5ng.",
+        "errors.HTTP_SECURITY_ORIGIN_REJECTED":
+            "Ngu\u1ed3n g\u1eedi y\u00eau c\u1ea7u kh\u00f4ng \u0111\u01b0\u1ee3c ph\u00e9p.",
+        "errors.HTTP_SECURITY_RATE_LIMITED":
+            "B\u1ea1n g\u1eedi qu\u00e1 nhi\u1ec1u y\u00eau c\u1ea7u, h\u00e3y th\u1eed l\u1ea1i sau.",
+        "errors.HTTP_SECURITY_REQUEST_INVALID":
+            "D\u1eef li\u1ec7u g\u1eedi l\u00ean kh\u00f4ng h\u1ee3p l\u1ec7: {{fields}}.",
         "errors.HTTP_SECURITY_WEBHOOK_SIGNATURE_INVALID": "Ch\u1eef k\u00fd webhook kh\u00f4ng h\u1ee3p l\u1ec7.",
-        "errors.HTTP_SECURITY_WEBHOOK_REPLAYED": "Webhook n\u1eb1m ngo\u00e0i c\u1eeda s\u1ed5 th\u1eddi gian cho ph\u00e9p.",
-        "errors.HTTP_SECURITY_WEBHOOK_PROVIDER_UNKNOWN": "Nh\u00e0 cung c\u1ea5p webhook {{provider}} ch\u01b0a \u0111\u01b0\u1ee3c c\u1ea5u h\u00ecnh.",
+        "errors.HTTP_SECURITY_WEBHOOK_REPLAYED":
+            "Webhook n\u1eb1m ngo\u00e0i c\u1eeda s\u1ed5 th\u1eddi gian cho ph\u00e9p.",
+        "errors.HTTP_SECURITY_WEBHOOK_PROVIDER_UNKNOWN":
+            "Nh\u00e0 cung c\u1ea5p webhook {{provider}} ch\u01b0a \u0111\u01b0\u1ee3c c\u1ea5u h\u00ecnh.",
     },
     en: {
+        "errors.HTTP_SECURITY_REQUIRED_DEPENDENCY_UNAVAILABLE": "The required database is unavailable.",
         "errors.HTTP_SECURITY_ORIGIN_REJECTED": "The origin of the request is not allowed.",
         "errors.HTTP_SECURITY_RATE_LIMITED": "Too many requests, try again later.",
         "errors.HTTP_SECURITY_REQUEST_INVALID": "The submitted data is invalid: {{fields}}.",

package/templates/be/skeleton/src/modules/platform/http-security/rate-limit.guard.spec.ts

@@ -17,7 +17,9 @@ const options: HttpSecurityOptions = {
     webhooks: {},
 }
 
-const build = async (reflector: Reflector, clock: FakeClock) => {
+const build = async (clock: FakeClock, tier?: RateTier) => {
+    const reflector = mock<Reflector>()
+    reflector.getAllAndOverride.mockReturnValue(tier)
     const moduleRef = await Test.createTestingModule({
         providers: [
             RateLimitGuard,
@@ -26,7 +28,7 @@ const build = async (reflector: Reflector, clock: FakeClock) => {
             { provide: HTTP_SECURITY_OPTIONS, useValue: options },
         ],
     }).compile()
-    return moduleRef.get(RateLimitGuard)
+    return { guard: moduleRef.get(RateLimitGuard), reflector }
 }
 
 /** An execution context of one POST from `ip` on the door; the handler and the class carry the tier metadata. */
@@ -47,17 +49,20 @@ describe("RateLimit", () => {
     it("marks a door with the tier it declares, and the guard counts it under that tier's limit", async () => {
         class Door {}
         RateLimit(RateTier.Strict)(Door)
-        const guard = await build(new Reflector(), new FakeClock(AT))
-        const { context } = contextOf("127.0.0.1", () => undefined, Door)
+        const { guard, reflector } = await build(new FakeClock(AT), RateTier.Strict)
+        const handler = () => undefined
+        const { context } = contextOf("127.0.0.1", handler, Door)
 
+        expect(Reflect.getMetadata("platform.http-security.rate-tier", Door)).toBe(RateTier.Strict)
         expect(guard.canActivate(context)).toBe(true)
         expect(() => guard.canActivate(context)).toThrow(RATE_LIMITED)
+        expect(reflector.getAllAndOverride).toHaveBeenCalledWith("platform.http-security.rate-tier", [handler, Door])
     })
 })
 
 describe("RateLimitGuard", () => {
     it("counts an unmarked door under the default limit", async () => {
-        const guard = await build(mock<Reflector>(), new FakeClock(AT))
+        const { guard } = await build(new FakeClock(AT))
         const { context } = contextOf("127.0.0.1")
 
         expect(guard.canActivate(context)).toBe(true)
@@ -67,7 +72,7 @@ describe("RateLimitGuard", () => {
 
     it("opens a fresh window for a caller whose bucket expired", async () => {
         const clock = new FakeClock(AT)
-        const guard = await build(mock<Reflector>(), clock)
+        const { guard } = await build(clock)
         const { context } = contextOf("127.0.0.1")
 
         guard.canActivate(context)
@@ -80,7 +85,7 @@ describe("RateLimitGuard", () => {
     })
 
     it("counts a request without an address under the unknown bucket", async () => {
-        const guard = await build(mock<Reflector>(), new FakeClock(AT))
+        const { guard } = await build(new FakeClock(AT))
         const { context } = contextOf(undefined)
 
         guard.canActivate(context)
@@ -90,7 +95,7 @@ describe("RateLimitGuard", () => {
 
     it("prunes the expired buckets when the map outgrows the bucket cap", async () => {
         const clock = new FakeClock(AT)
-        const guard = await build(mock<Reflector>(), clock)
+        const { guard } = await build(clock)
         const { context, setIp } = contextOf("0.0.0.0")
 
         for (let index = 0; index <= 10_000; index += 1) {

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

@@ -0,0 +1,5 @@
+/** The required primary database answered before the readiness deadline. */
+export interface ReadinessReport {
+    /** Whether this process can serve requests requiring the database. */
+    readonly ok: true
+}

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"