@bgord/bun 1.20.4 → 1.21.0

package/src/hcaptcha.service.ts

@@ -2,16 +2,16 @@ import type { HCaptchaSecretKeyType } from "./hcaptcha-secret-key.vo";
 
 export const HCaptchaServiceError = { Error: "hcaptcha.service.error" };
 
-type HcaptchaTokenType = string | undefined;
+type HcaptchaTokenType = string;
 
-export type HCaptchaVerificationResult = { success: boolean; errorCodes?: ReadonlyArray<string> };
+export type HCaptchaVerificationResult = { success: boolean };
 
 export class HCaptchaService {
   async verify(
     secretKey: HCaptchaSecretKeyType,
     token: HcaptchaTokenType,
   ): Promise<HCaptchaVerificationResult> {
-    const body = new URLSearchParams({ secret: secretKey, response: token ?? "" });
+    const body = new URLSearchParams({ secret: secretKey, response: token });
 
     const response = await fetch("https://hcaptcha.com/siteverify", {
       method: "POST",

package/src/http-logger-hono.middleware.ts

@@ -1,18 +1,18 @@
 import type { MiddlewareHandler } from "hono";
 import { CacheSourceEnum } from "./cache-resolver.strategy";
 import { CacheResponseMiddleware } from "./cache-response.middleware";
-import type { ClockPort } from "./clock.port";
-import { type HttpLoggerConfig, HttpLoggerMiddleware } from "./http-logger.middleware";
-import type { LoggerPort } from "./logger.port";
+import {
+  type HttpLoggerConfig,
+  HttpLoggerMiddleware,
+  type HttpLoggerMiddlewareDependencies,
+} from "./http-logger.middleware";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
 
-type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
-
 export class HttpLoggerHonoMiddleware implements MiddlewareHonoPort {
   private readonly middleware: HttpLoggerMiddleware;
 
-  constructor(deps: Dependencies, config?: HttpLoggerConfig) {
+  constructor(deps: HttpLoggerMiddlewareDependencies, config?: HttpLoggerConfig) {
     this.middleware = new HttpLoggerMiddleware(deps, config);
   }
 

package/src/http-logger.middleware.ts

@@ -25,7 +25,7 @@ export const UNINFORMATIVE_HEADERS = [
   "priority",
 ];
 
-type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
+export type HttpLoggerMiddlewareDependencies = { Logger: LoggerPort; Clock: ClockPort };
 
 export type HttpLoggerConfig = { skip?: ReadonlyArray<string | URLPattern> };
 
@@ -39,7 +39,7 @@ export type HttpLoggerAfterInput = {
 
 export class HttpLoggerMiddleware {
   constructor(
-    private readonly deps: Dependencies,
+    private readonly deps: HttpLoggerMiddlewareDependencies,
     private readonly config?: HttpLoggerConfig,
   ) {}
 

package/src/image-blur-noop.adapter.ts

@@ -3,6 +3,6 @@ import type { ImageBlurPort, ImageBlurStrategy } from "./image-blur.port";
 
 export class ImageBlurNoopAdapter implements ImageBlurPort {
   async blur(recipe: ImageBlurStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
-    return recipe.strategy === "output_path" ? recipe.output : recipe.input;
+    return recipe.output;
   }
 }

package/src/image-blur.adapter.ts

@@ -1,7 +1,6 @@
 import type * as tools from "@bgord/tools";
 import type { FileRenamerPort } from "./file-renamer.port";
 import type { FileWriterPort } from "./file-writer.port";
-import type { ImageSupportedType } from "./image.types";
 import type { ImageBlurPort, ImageBlurStrategy } from "./image-blur.port";
 import type { NonceProviderPort } from "./nonce-provider.port";
 
@@ -15,17 +14,14 @@ export class ImageBlurAdapter implements ImageBlurPort {
   constructor(private readonly deps: Dependencies) {}
 
   async blur(recipe: ImageBlurStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
-    const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;
+    const final = recipe.output;
 
     const filename = final.getFilename();
     const temporary = final.withFilename(
       filename.withSuffix(`-blurred-${this.deps.NonceProvider.generate()}`),
     );
 
-    const extension = final.getFilename().getExtension();
-    const format = (extension === "jpg" ? "jpeg" : extension) as ImageSupportedType;
-
-    const blurred = await Bun.file(recipe.input.get()).image()[format]().placeholder();
+    const blurred = await Bun.file(recipe.input.get()).image().placeholder();
     const bytes = Buffer.from(blurred.substring(blurred.indexOf(",") + 1), "base64");
 
     await this.deps.FileWriter.write(temporary.get(), bytes);

package/src/image-blur.port.ts

@@ -1,15 +1,9 @@
 import type * as tools from "@bgord/tools";
 
-type ImageBlurOutputPathStrategy = {
-  strategy: "output_path";
+export type ImageBlurStrategy = {
   input: tools.FilePathRelative | tools.FilePathAbsolute;
   output: tools.FilePathRelative | tools.FilePathAbsolute;
 };
-type ImageBlurInPlaceStrategy = {
-  strategy: "in_place";
-  input: tools.FilePathRelative | tools.FilePathAbsolute;
-};
-export type ImageBlurStrategy = ImageBlurOutputPathStrategy | ImageBlurInPlaceStrategy;
 
 export interface ImageBlurPort {
   blur(recipe: ImageBlurStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute>;

package/src/in-flight-requests-hono.middleware.ts

@@ -2,6 +2,7 @@ import type { MiddlewareHandler } from "hono";
 import { InFlightRequestsMiddleware } from "./in-flight-requests.middleware";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 
+// Counts handler execution, not connection lifetime - a streamed body drains after next() resolves
 export class InFlightRequestsHonoMiddleware implements MiddlewareHonoPort {
   private readonly middleware = new InFlightRequestsMiddleware();
 

package/src/in-flight-requests-tracker.service.ts

@@ -4,11 +4,11 @@ export class InFlightRequestsTracker {
   private static count: tools.IntegerType = tools.Int.of(0);
 
   static increment(): void {
-    InFlightRequestsTracker.count++;
+    InFlightRequestsTracker.count = tools.Int.of(InFlightRequestsTracker.count + 1);
   }
 
   static decrement(): void {
-    InFlightRequestsTracker.count--;
+    InFlightRequestsTracker.count = tools.Int.of(Math.max(0, InFlightRequestsTracker.count - 1));
   }
 
   static get(): tools.IntegerType {

package/src/index.ts

@@ -74,7 +74,6 @@ export * from "./correlation-storage.service";
 export * from "./cron-expression.vo";
 export * from "./cron-scheduler.adapter";
 export * from "./cron-scheduler.port";
-export * from "./cron-scheduler-croner.adapter";
 export * from "./cron-scheduler-noop.adapter";
 export * from "./cron-scheduler-with-logger.adapter";
 export * from "./cron-task.vo";
@@ -94,8 +93,8 @@ export * from "./directory-ensurer.adapter";
 export * from "./directory-ensurer.port";
 export * from "./directory-ensurer-noop.adapter";
 export * from "./disk-space-checker.port";
+export * from "./disk-space-checker-fs.adapter";
 export * from "./disk-space-checker-noop.adapter";
-export * from "./disk-space-checker-shell.adapter";
 export * from "./dynamic-import.service";
 export * from "./encryption.port";
 export * from "./encryption-aes-gcm.adapter";
@@ -160,7 +159,6 @@ export * from "./file-reader-raw.adapter";
 export * from "./file-reader-raw.port";
 export * from "./file-reader-raw-forgiving.adapter";
 export * from "./file-reader-raw-noop.adapter";
-export * from "./file-reader-raw-with-cache.adapter";
 export * from "./file-reader-text.adapter";
 export * from "./file-reader-text.port";
 export * from "./file-reader-text-forgiving.adapter";
@@ -384,6 +382,7 @@ export * from "./reactive-config-file-json.adapter";
 export * from "./reactive-config-noop.adapter";
 export * from "./reactive-config-with-cache.adapter";
 export * from "./reactive-config-with-fallback.adapter";
+export * from "./reactive-config-with-logger.adapter";
 export * from "./readiness.handler";
 export * from "./readiness-hono.handler";
 export * from "./recaptcha-secret-key.vo";
@@ -396,6 +395,7 @@ export * from "./redactor-mask.strategy";
 export * from "./redactor-metadata-compact-array.strategy";
 export * from "./redactor-metadata-compact-object.strategy";
 export * from "./redactor-noop.strategy";
+export * from "./redactor-url-query.strategy";
 export * from "./remote-file-storage.port";
 export * from "./remote-file-storage-disk.adapter";
 export * from "./remote-file-storage-noop.adapter";
@@ -518,6 +518,7 @@ export * from "./subject-segment-env.strategy";
 export * from "./subject-segment-fixed.strategy";
 export * from "./subject-segment-header.strategy";
 export * from "./subject-segment-ip.strategy";
+export * from "./subject-segment-method.strategy";
 export * from "./subject-segment-param.strategy";
 export * from "./subject-segment-path.strategy";
 export * from "./subject-segment-query.strategy";

package/src/instrumentation.service.ts

@@ -1,4 +1,5 @@
 import type { ClockPort } from "./clock.port";
+import { CorrelationStorage } from "./correlation-storage.service";
 import type { LoggerPort } from "./logger.port";
 import { Stopwatch } from "./stopwatch.service";
 
@@ -14,9 +15,10 @@ export class Instrumentation {
 
     this.deps.Logger.info({
       message: `${label} measurement`,
+      correlationId: CorrelationStorage.get(),
       component: "infra",
       operation: "instrumentation_measure",
-      metadata: stopwatch.stop(),
+      metadata: { duration: stopwatch.stop() },
     });
 
     return result;
@@ -29,9 +31,10 @@ export class Instrumentation {
 
     this.deps.Logger.info({
       message: `${label} measurement`,
+      correlationId: CorrelationStorage.get(),
       component: "infra",
       operation: "instrumentation_measure",
-      metadata: stopwatch.stop(),
+      metadata: { duration: stopwatch.stop() },
     });
 
     return result;

package/src/job-queue-sqlite-store.service.ts

@@ -10,6 +10,7 @@ export class JobQueueSqliteStore {
     this.db = new Database(config.database);
 
     this.db.run("PRAGMA journal_mode = WAL");
+    this.db.run("PRAGMA busy_timeout = 5000");
     this.db.run(`
       CREATE TABLE IF NOT EXISTS jobs (
         id TEXT PRIMARY KEY,

package/src/job-queue-with-logger.adapter.ts

@@ -13,7 +13,7 @@ export class JobQueueWithLoggerAdapter<Job extends GenericJob> implements JobQue
 
   constructor(private readonly deps: Dependencies<Job>) {}
 
-  async enqueue<EnqueuedJob extends Job>(job: EnqueuedJob): Promise<EnqueuedJob> {
+  async enqueue<EnqueuedJob extends Job>(job: EnqueuedJob, delay?: tools.Duration): Promise<EnqueuedJob> {
     this.deps.Logger.info({
       message: `${job.name} enqueued`,
       metadata: job,
@@ -21,7 +21,7 @@ export class JobQueueWithLoggerAdapter<Job extends GenericJob> implements JobQue
       ...this.base,
     });
 
-    return this.deps.inner.enqueue(job);
+    return this.deps.inner.enqueue(job, delay);
   }
 
   async claim(limit: tools.IntegerPositiveType): Promise<ReadonlyArray<Job>> {

package/src/language-detector-cookie.strategy.ts

@@ -9,7 +9,7 @@ export class LanguageDetectorCookieStrategy<T extends tools.LanguageType>
   constructor(private readonly name: string) {}
 
   detect(context: HasRequestCookie, languages: Languages<T>): T | null {
-    const detected = context.request.cookie(this.name);
+    const detected = context.request.cookie(this.name)?.toLowerCase();
 
     return languages.isSupported(detected) ? detected : null;
   }

package/src/language-detector-header.strategy.ts

@@ -14,7 +14,19 @@ export class LanguageDetectorHeaderStrategy<T extends tools.LanguageType>
     // Example Accept-Language header: en-US,en;q=0.9,pl;q=0.8
     const incoming = header
       .split(",")
-      .map((language) => language.split(";")[0]?.trim().toLowerCase().split("-")[0]);
+      .map((part) => {
+        // Stryker disable next-line StringLiteral
+        const [tag = "", quality = "q=1"] = part.split(";");
+
+        return {
+          language: tag.trim().toLowerCase().split("-")[0],
+          quality: Number(quality.replace("q=", "")),
+        };
+      })
+      // Quality of 0 means the language is explicitly not acceptable
+      .filter((candidate) => candidate.quality > 0)
+      .sort((first, second) => second.quality - first.quality)
+      .map((candidate) => candidate.language);
 
     return incoming.find((language) => languages.isSupported(language)) ?? null;
   }

package/src/language-detector-hono.middleware.ts

@@ -16,7 +16,7 @@ export class LanguageDetectorHonoMiddleware<T extends tools.LanguageType> implem
     this.middleware = new LanguageDetectorMiddleware(config);
   }
 
-  handle(): MiddlewareHandler {
+  handle(): MiddlewareHandler<{ Variables: LanguageDetectorVariables }> {
     return async (c, next) => {
       const context = new RequestContextHonoAdapter(c);
 

package/src/language-detector-query.strategy.ts

@@ -9,7 +9,7 @@ export class LanguageDetectorQueryStrategy<T extends tools.LanguageType>
   constructor(private readonly name: string) {}
 
   detect(context: HasRequestQuery, languages: Languages<T>): T | null {
-    const detected = context.request.query()[this.name];
+    const detected = context.request.query()[this.name]?.toLowerCase();
 
     return languages.isSupported(detected) ? detected : null;
   }

package/src/language-detector.middleware.ts

@@ -1,7 +1,7 @@
 import type * as tools from "@bgord/tools";
 import type { LanguageDetectorStrategy } from "./language-detector.strategy";
 import type { Languages } from "./languages.vo";
-import type { RequestContext } from "./request-context.port";
+import type { HasRequestCookie, HasRequestHeaders, HasRequestQuery } from "./request-context.port";
 
 export const LanguageDetectorMiddlewareError = {
   MaxStrategies: "language.detector.middleware.max.strategies",
@@ -17,7 +17,7 @@ export class LanguageDetectorMiddleware<T extends tools.LanguageType> {
     if (config.strategies.length > 5) throw new Error(LanguageDetectorMiddlewareError.MaxStrategies);
   }
 
-  evaluate(context: RequestContext): T {
+  evaluate(context: HasRequestCookie & HasRequestHeaders & HasRequestQuery): T {
     for (const strategy of this.config.strategies) {
       const detected = strategy.detect(context, this.config.languages);
       if (detected !== null) return detected;

package/src/language-detector.strategy.ts

@@ -1,7 +1,7 @@
 import type * as tools from "@bgord/tools";
 import type { Languages } from "./languages.vo";
-import type { RequestContext } from "./request-context.port";
+import type { HasRequestCookie, HasRequestHeaders, HasRequestQuery } from "./request-context.port";
 
 export interface LanguageDetectorStrategy<T extends tools.LanguageType> {
-  detect(context: RequestContext, languages: Languages<T>): T | null;
+  detect(context: HasRequestCookie & HasRequestHeaders & HasRequestQuery, languages: Languages<T>): T | null;
 }

package/src/liveness-hono.handler.ts

@@ -8,6 +8,10 @@ export class LivenessHonoHandler implements HandlerHonoPort {
   private readonly handler = new LivenessHandler();
 
   handle() {
-    return factory.createHandlers(async (c) => c.json(this.handler.execute(), 200));
+    return factory.createHandlers(async (c) => {
+      const { headers, ...body } = this.handler.execute();
+
+      return c.json(body, 200, headers);
+    });
   }
 }

package/src/liveness.handler.ts

@@ -1,5 +1,5 @@
 export class LivenessHandler {
-  execute(): { ok: true } {
-    return { ok: true };
+  execute(): { ok: true; headers: Record<string, string> } {
+    return { ok: true, headers: { "Cache-Control": "no-store" } };
   }
 }

package/src/mailer-content-html.vo.ts

@@ -5,10 +5,9 @@ export const MailerContentHtmlError = { Invalid: "mailer.content.html.invalid" }
 export const MailerContentHtml = v.pipe(
   v.string(MailerContentHtmlError.Invalid),
   v.minLength(1, MailerContentHtmlError.Invalid),
-  v.maxLength(10_000, MailerContentHtmlError.Invalid),
+  v.maxLength(100_000, MailerContentHtmlError.Invalid),
   // Stryker disable next-line StringLiteral
   v.brand("MailerContentHtml"),
 );
 
 export type MailerContentHtmlType = v.InferOutput<typeof MailerContentHtml>;
-export type EmailAttachmentType = { filename: string; path: string };

package/src/mailer-smtp.adapter.ts

@@ -36,6 +36,7 @@ export class MailerSmtpAdapter implements MailerPort {
         host: config.SMTP_HOST,
         port: config.SMTP_PORT,
         auth: { user: config.SMTP_USER, pass: config.SMTP_PASS },
+        requireTLS: true,
       }),
     );
   }

package/src/mailer-with-logger.adapter.ts

@@ -19,7 +19,7 @@ export class MailerWithLoggerAdapter implements MailerPort {
       this.deps.Logger.info({
         message: "Mailer attempt",
         correlationId: CorrelationStorage.get(),
-        metadata: template.toJSON(),
+        metadata: { template: template.toJSON() },
         ...this.base,
       });
 
@@ -36,7 +36,7 @@ export class MailerWithLoggerAdapter implements MailerPort {
         message: "Mailer error",
         correlationId: CorrelationStorage.get(),
         error,
-        metadata: duration.stop(),
+        metadata: { duration: duration.stop() },
         ...this.base,
       });
 

package/src/markdown-generator.adapter.ts

@@ -2,6 +2,6 @@ import type { MarkdownGeneratorPort } from "./markdown-generator.port";
 
 export class MarkdownGeneratorAdapter implements MarkdownGeneratorPort {
   generate(template: string): string {
-    return Bun.markdown.html(template);
+    return Bun.markdown.html(template, { tagFilter: true, noHtmlBlocks: true, noHtmlSpans: true });
   }
 }

package/src/memory-consumption.service.ts

@@ -7,10 +7,6 @@ type MemoryConsumptionSnapshotType = { total: tools.Size; heap: { used: tools.Si
 // Heap used - how much of the reserved memory is actually used for the JS heap
 
 export class MemoryConsumption {
-  static get(): tools.Size {
-    return tools.Size.fromBytes(process.memoryUsage().rss);
-  }
-
   static snapshot(): MemoryConsumptionSnapshotType {
     const { rss, heapUsed, heapTotal } = process.memoryUsage();
 

package/src/nonce-provider-crypto.adapter.ts

@@ -4,7 +4,7 @@ import { NonceValue, type NonceValueType } from "./nonce-value.vo";
 
 export class NonceProviderCryptoAdapter implements NonceProviderPort {
   generate(): NonceValueType {
-    const buffer = new Uint8Array(8);
+    const buffer = new Uint8Array(16);
     crypto.getRandomValues(buffer);
 
     return v.parse(NonceValue, buffer.toHex());

package/src/nonce-provider-noop.adapter.ts

@@ -4,6 +4,6 @@ import { NonceValue, type NonceValueType } from "./nonce-value.vo";
 
 export class NonceProviderNoopAdapter implements NonceProviderPort {
   generate(): NonceValueType {
-    return v.parse(NonceValue, "0000000000000000");
+    return v.parse(NonceValue, "00000000000000000000000000000000");
   }
 }

package/src/nonce-value.vo.ts

@@ -5,8 +5,8 @@ export const NonceValueError = {
   InvalidHex: "nonce.value.invalid.hex",
 };
 
-// 16 hex chars allowed
-const CHARS_WHITELIST = /^[a-fA-F0-9]{16}$/;
+// 32 hex chars allowed
+const CHARS_WHITELIST = /^[a-fA-F0-9]{32}$/;
 
 export const NonceValue = v.pipe(
   v.string(NonceValueError.Type),

package/src/pdf-generator-with-logger.adapter.ts

@@ -39,7 +39,7 @@ export class PdfGeneratorWithLoggerAdapter implements PdfGeneratorPort {
         message: "PDF generator error",
         correlationId: CorrelationStorage.get(),
         error,
-        metadata: duration.stop(),
+        metadata: { duration: duration.stop() },
         ...this.base,
       });
 

package/src/prerequisite-verifier-memory.adapter.ts

@@ -12,7 +12,7 @@ export class PrerequisiteVerifierMemoryAdapter implements PrerequisiteVerifierPo
   constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
-    const memoryConsumption = MemoryConsumption.get();
+    const memoryConsumption = MemoryConsumption.snapshot().total;
 
     if (memoryConsumption.isSmallerThan(this.config.maximum)) return PrerequisiteVerification.success;
     return PrerequisiteVerification.failure(

package/src/prerequisite-verifier-translations.adapter.ts

@@ -26,12 +26,12 @@ export class PrerequisiteVerifierTranslationsAdapter<T extends tools.LanguageTyp
   async verify(): Promise<PrerequisiteVerificationResult> {
     const languages = this.config.values;
 
-    const dictionary: Partial<Record<T, ReadonlyArray<TranslationsKeyType>>> = {};
+    const translations = new Map<T, Set<TranslationsKeyType>>();
 
     for (const language of languages) {
       try {
-        const translations = await this.deps.TranslationsProvider.getTranslationsFor(language);
-        dictionary[language] = Object.keys(translations);
+        const dictionary = await this.deps.TranslationsProvider.getTranslationsFor(language);
+        translations.set(language, new Set(Object.keys(dictionary)));
       } catch {
         return PrerequisiteVerification.failure(`${language} translations not available`);
       }
@@ -39,16 +39,10 @@ export class PrerequisiteVerifierTranslationsAdapter<T extends tools.LanguageTyp
 
     const problems: Array<PrerequisiteTranslationsProblemType> = [];
 
-    for (const language in dictionary) {
-      // Stryker disable all
-      const translations = dictionary[language] ?? [];
-      // Stryker restore all
-
-      for (const key of translations) {
-        for (const supportedLanguage of languages) {
-          const exists = new Set(dictionary[supportedLanguage]).has(key);
-
-          if (!exists) problems.push({ key, existsIn: language, missingIn: supportedLanguage });
+    for (const [language, keys] of translations) {
+      for (const key of keys) {
+        for (const [supportedLanguage, supported] of translations) {
+          if (!supported.has(key)) problems.push({ key, existsIn: language, missingIn: supportedLanguage });
         }
       }
     }

package/src/prerequisite-verifier-with-logger.adapter.ts

@@ -16,7 +16,7 @@ export class PrerequisiteVerifierWithLoggerAdapter implements PrerequisiteVerifi
   private readonly base = (duration: tools.Duration) => ({
     component: "infra",
     operation: "prerequisite_verify",
-    metadata: duration,
+    metadata: { duration },
   });
 
   constructor(

package/src/randomness.strategy.ts

@@ -1,3 +1,4 @@
 export interface RandomnessStrategy {
+  // Returns a number in the [0, 1) range
   next(): number;
 }

package/src/reactive-config-noop.adapter.ts

@@ -2,12 +2,13 @@ import type { ReactiveConfigPort, ReactiveConfigSchema } from "./reactive-config
 import { StandardSchemaValidator } from "./standard-schema-validator.service";
 
 export class ReactiveConfigNoopAdapter<T extends object> implements ReactiveConfigPort<T> {
-  constructor(
-    private readonly schema: ReactiveConfigSchema<T>,
-    private readonly value: T,
-  ) {}
+  private readonly value: Readonly<T>;
+
+  constructor(schema: ReactiveConfigSchema<T>, value: T) {
+    this.value = Object.freeze(StandardSchemaValidator.validate(schema, value));
+  }
 
   async get(): Promise<Readonly<T>> {
-    return Object.freeze(StandardSchemaValidator.validate(this.schema, this.value));
+    return this.value;
   }
 }

package/src/reactive-config-with-cache.adapter.ts

@@ -14,6 +14,6 @@ export class ReactiveConfigWithCacheAdapter<T extends object> implements Reactiv
   async get(): Promise<Readonly<T>> {
     const key = await this.deps.HashContent.hash(this.subject);
 
-    return this.deps.CacheResolver.resolve(key, () => this.inner.get());
+    return Object.freeze(await this.deps.CacheResolver.resolve(key, () => this.inner.get()));
   }
 }

package/src/reactive-config-with-fallback.adapter.ts

@@ -2,17 +2,21 @@ import type { ReactiveConfigPort, ReactiveConfigSchema } from "./reactive-config
 import { StandardSchemaValidator } from "./standard-schema-validator.service";
 
 export class ReactiveConfigWithFallbackAdapter<T extends object> implements ReactiveConfigPort<T> {
+  private readonly fallback: Readonly<T>;
+
   constructor(
     private readonly inner: ReactiveConfigPort<T>,
-    private readonly schema: ReactiveConfigSchema<T>,
-    private readonly fallback: T,
-  ) {}
+    schema: ReactiveConfigSchema<T>,
+    fallback: T,
+  ) {
+    this.fallback = Object.freeze(StandardSchemaValidator.validate(schema, fallback));
+  }
 
   async get(): Promise<Readonly<T>> {
     try {
       return await this.inner.get();
     } catch {
-      return Object.freeze(StandardSchemaValidator.validate(this.schema, this.fallback));
+      return this.fallback;
     }
   }
 }

package/src/reactive-config-with-logger.adapter.ts

@@ -0,0 +1,50 @@
+import type { ClockPort } from "./clock.port";
+import { CorrelationStorage } from "./correlation-storage.service";
+import type { LoggerPort } from "./logger.port";
+import type { ReactiveConfigPort } from "./reactive-config.port";
+import { Stopwatch } from "./stopwatch.service";
+
+export type ReactiveConfigWithLoggerAdapterDependencies<T extends object> = {
+  inner: ReactiveConfigPort<T>;
+  Logger: LoggerPort;
+  Clock: ClockPort;
+};
+
+export class ReactiveConfigWithLoggerAdapter<T extends object> implements ReactiveConfigPort<T> {
+  private readonly base = { component: "infra", operation: "reactive_config" };
+
+  constructor(private readonly deps: ReactiveConfigWithLoggerAdapterDependencies<T>) {}
+
+  async get(): Promise<Readonly<T>> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Reactive config read attempt",
+        correlationId: CorrelationStorage.get(),
+        ...this.base,
+      });
+
+      const result = await this.deps.inner.get();
+
+      this.deps.Logger.info({
+        message: "Reactive config read success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { duration: duration.stop() },
+        ...this.base,
+      });
+
+      return result;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Reactive config read error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { duration: duration.stop() },
+        ...this.base,
+      });
+
+      throw error;
+    }
+  }
+}