@bgord/bun 1.20.5 → 1.21.1

package/src/cache-repository-node-cache.adapter.ts

@@ -19,7 +19,9 @@ export class CacheRepositoryNodeCacheAdapter implements CacheRepositoryPort {
   }
 
   async set<T>(subject: Hash, value: T): Promise<void> {
-    this.store.set(subject.get(), value);
+    try {
+      this.store.set(subject.get(), value);
+    } catch {}
   }
 
   async delete(subject: Hash): Promise<void> {

package/src/cache-response-hono.middleware.ts

@@ -1,17 +1,17 @@
 import { createMiddleware } from "hono/factory";
 import type { ContentfulStatusCode } from "hono/utils/http-status";
-import type { CacheResolverStrategy } from "./cache-resolver.strategy";
-import type { CacheResponseConfig } from "./cache-response.middleware";
-import { CacheResponseMiddleware } from "./cache-response.middleware";
+import {
+  CacheResponseMiddleware,
+  type CacheResponseMiddlewareConfig,
+  type CacheResponseMiddlewareDependencies,
+} from "./cache-response.middleware";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
 
-type Dependencies = { CacheResolver: CacheResolverStrategy };
-
 export class CacheResponseHonoMiddleware implements MiddlewareHonoPort {
   private readonly middleware: CacheResponseMiddleware;
 
-  constructor(config: CacheResponseConfig, deps: Dependencies) {
+  constructor(config: CacheResponseMiddlewareConfig, deps: CacheResponseMiddlewareDependencies) {
     this.middleware = new CacheResponseMiddleware(config, deps);
   }
 

package/src/cache-response.middleware.ts

@@ -2,9 +2,9 @@ import type { CacheResolverStrategy, CacheSourceEnum } from "./cache-resolver.st
 import type { RequestContext } from "./request-context.port";
 import type { SubjectRequestResolver } from "./subject-request-resolver.vo";
 
-type Dependencies = { CacheResolver: CacheResolverStrategy };
+export type CacheResponseMiddlewareDependencies = { CacheResolver: CacheResolverStrategy };
 
-export type CacheResponseConfig = { enabled: boolean; resolver: SubjectRequestResolver };
+export type CacheResponseMiddlewareConfig = { enabled: boolean; resolver: SubjectRequestResolver };
 
 export type CachedResponse<T = string> = {
   body: T;
@@ -21,8 +21,8 @@ export class CacheResponseMiddleware {
   static readonly CACHE_HIT_HEADER = "Cache-Hit";
 
   constructor(
-    private readonly config: CacheResponseConfig,
-    private readonly deps: Dependencies,
+    private readonly config: CacheResponseMiddlewareConfig,
+    private readonly deps: CacheResponseMiddlewareDependencies,
   ) {}
 
   async evaluate<T = string>(

package/src/certificate-inspector-tls.adapter.ts

@@ -11,35 +11,37 @@ export class CertificateInspectorTLSAdapter implements CertificateInspectorPort
 
   async inspect(hostname: HostnameType): Promise<CertificateInspection> {
     return new Promise((resolve) => {
-      // Stryker disable all
-      const cleanup = (socket: tls.TLSSocket) => socket.destroy();
-      // Stryker restore all
+      const settle = (result: CertificateInspection) => {
+        // Stryker disable all
+        socket.destroy();
+        // Stryker restore all
+        resolve(result);
+      };
 
       const socket = tls.connect(
         { host: hostname, port: 443, servername: hostname, rejectUnauthorized: false },
         () => {
-          const certificate = socket.getPeerCertificate();
+          try {
+            const certificate = socket.getPeerCertificate();
 
-          if (!certificate?.valid_to) {
-            cleanup(socket);
-            return resolve({ success: false });
-          }
-          // biome-ignore lint: lint/style/noRestrictedGlobals
-          const remaining = tools.Timestamp.fromNumber(new Date(certificate.valid_to).getTime()).difference(
-            this.deps.Clock.now(),
-          );
+            // Stryker disable next-line ConditionalExpression
+            if (!certificate.valid_to) return settle({ success: false });
 
-          cleanup(socket);
-          resolve({ success: true, remaining });
+            // biome-ignore lint: lint/style/noRestrictedGlobals
+            const remaining = tools.Timestamp.fromNumber(new Date(certificate.valid_to).getTime()).difference(
+              this.deps.Clock.now(),
+            );
+
+            settle({ success: true, remaining });
+          } catch {
+            settle({ success: false });
+          }
         },
       );
 
       // Stryker disable all
-      socket.once("error", () => {
-        // Stryker restore all
-        cleanup(socket);
-        resolve({ success: false });
-      });
+      socket.once("error", () => settle({ success: false }));
+      // Stryker restore all
     });
   }
 }

package/src/correlation-hono.middleware.ts

@@ -1,32 +1,32 @@
 import { createMiddleware } from "hono/factory";
-import { CorrelationMiddleware } from "./correlation.middleware";
+import { CorrelationMiddleware, type CorrelationMiddlewareDependencies } from "./correlation.middleware";
 import { CorrelationStorage } from "./correlation-storage.service";
-import type { IdProviderPort } from "./id-provider.port";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
 import type { UUIDType } from "./uuid.vo";
 
-type Dependencies = { IdProvider: IdProviderPort };
-
 export type CorrelationVariables = { correlationId: UUIDType };
 
 export class CorrelationHonoMiddleware implements MiddlewareHonoPort {
   private readonly correlationId: CorrelationMiddleware;
 
-  constructor(deps: Dependencies) {
+  constructor(deps: CorrelationMiddlewareDependencies) {
     this.correlationId = new CorrelationMiddleware(deps);
   }
 
   handle() {
-    return createMiddleware(async (c, next) => {
+    return createMiddleware<{ Variables: CorrelationVariables }>(async (c, next) => {
       const context = new RequestContextHonoAdapter(c);
 
       const result = this.correlationId.evaluate(context);
 
       c.set("correlationId", result);
-      c.header(CorrelationMiddleware.HEADER_NAME, result);
 
-      return CorrelationStorage.run(result, next);
+      return CorrelationStorage.run(result, async () => {
+        await next();
+
+        c.header(CorrelationMiddleware.HEADER_NAME, result);
+      });
     });
   }
 }

package/src/correlation.middleware.ts

@@ -3,12 +3,12 @@ import { CorrelationId, type CorrelationIdType } from "./correlation-id.vo";
 import type { IdProviderPort } from "./id-provider.port";
 import type { HasRequestHeader } from "./request-context.port";
 
-type Dependencies = { IdProvider: IdProviderPort };
+export type CorrelationMiddlewareDependencies = { IdProvider: IdProviderPort };
 
 export class CorrelationMiddleware {
   static readonly HEADER_NAME = "correlation-id";
 
-  constructor(private readonly deps: Dependencies) {}
+  constructor(private readonly deps: CorrelationMiddlewareDependencies) {}
 
   evaluate(context: HasRequestHeader): CorrelationIdType {
     const incoming = context.request.header(CorrelationMiddleware.HEADER_NAME);

package/src/cron-scheduler.adapter.ts

@@ -2,11 +2,13 @@ import type { CronSchedulerPort } from "./cron-scheduler.port";
 import type { CronTask } from "./cron-task.vo";
 
 export class CronSchedulerAdapter implements CronSchedulerPort {
+  private readonly tasks: Array<Bun.CronJob> = [];
+
   schedule(task: CronTask): void {
-    Bun.cron(task.cron, task.handler);
+    this.tasks.push(Bun.cron(task.cron, task.handler));
   }
 
   async verify(): Promise<boolean> {
-    return true;
+    return this.tasks.length > 0;
   }
 }

package/src/cron-task-handler-with-logger.strategy.ts

@@ -24,13 +24,6 @@ export class CronTaskHandlerWithLoggerStrategy implements CronTaskHandlerStrateg
           this.deps.Logger.info({ message: `${task.label} start`, correlationId, ...this.base });
 
           await CorrelationStorage.run(correlationId, task.handler);
-
-          this.deps.Logger.info({
-            message: `${task.label} success`,
-            correlationId,
-            metadata: { duration: duration.stop() },
-            ...this.base,
-          });
         } catch (error) {
           this.deps.Logger.error({
             message: `${task.label} error`,
@@ -40,8 +33,15 @@ export class CronTaskHandlerWithLoggerStrategy implements CronTaskHandlerStrateg
             ...this.base,
           });
 
-          throw error;
+          return;
         }
+
+        this.deps.Logger.info({
+          message: `${task.label} success`,
+          correlationId,
+          metadata: { duration: duration.stop() },
+          ...this.base,
+        });
       },
     };
   }

package/src/csv-stringifier.adapter.ts

@@ -23,8 +23,8 @@ export class CsvStringifierAdapter implements CsvStringifierPort {
     return new CsvStringifierAdapter(dependency);
   }
 
-  async process(columns: ReadonlyArray<CsvColumnType>, data: Array<CsvRowType>): Promise<string> {
+  async process(columns: ReadonlyArray<CsvColumnType>, data: ReadonlyArray<CsvRowType>): Promise<string> {
     // TODO: Potential formula injection
-    return text(this.csv.stringify(data, { header: true, columns }));
+    return text(this.csv.stringify([...data], { header: true, columns }));
   }
 }

package/src/disk-space-checker-fs.adapter.ts

@@ -0,0 +1,12 @@
+/* cSpell:disable */
+import fs from "node:fs/promises";
+import * as tools from "@bgord/tools";
+import type { DiskSpaceCheckerPort } from "./disk-space-checker.port";
+
+export class DiskSpaceCheckerFsAdapter implements DiskSpaceCheckerPort {
+  async get(root: tools.DirectoryPathAbsoluteType): Promise<tools.Size> {
+    const stats = await fs.statfs(root);
+
+    return tools.Size.fromBytes(stats.bavail * stats.bsize);
+  }
+}

package/src/dynamic-import.service.ts

@@ -11,8 +11,8 @@ export class DynamicImport<T> {
   async resolve(): Promise<T> {
     try {
       return await this.import();
-    } catch {
-      throw new Error(this.error);
+    } catch (error) {
+      throw new Error(this.error, { cause: error });
     }
   }
 

package/src/environment-loader-process-safe.adapter.ts

@@ -26,7 +26,10 @@ export class EnvironmentLoaderProcessSafeAdapter<T extends object> implements En
       StandardSchemaValidator.validate(this.config.EnvironmentSchema, this.env),
     );
 
-    for (const key of Object.keys(parsed)) delete process.env[key];
+    for (const key of Object.keys(parsed)) {
+      delete this.env[key];
+      delete process.env[key];
+    }
 
     return Object.freeze({ ...parsed, type: this.config.type });
   }

package/src/environment-loader.port.ts

@@ -1,5 +1,5 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { NodeEnvironmentEnum } from "../src/node-env.vo";
+import type { NodeEnvironmentEnum } from "./node-env.vo";
 
 export type EnvironmentLoaderConfig<T extends object> = {
   type: NodeEnvironmentEnum;

package/src/etag-extractor-header.strategy.ts

@@ -7,6 +7,8 @@ export class ETagExtractorHeaderStrategy implements ETagExtractorStrategy {
     try {
       const header = context.request.header(tools.ETag.IF_MATCH_HEADER_NAME);
 
+      if (!header?.trim()) return null;
+
       return tools.ETag.fromHeader(header);
     } catch {
       return null;

package/src/etag-extractor-hono.middleware.ts

@@ -13,7 +13,7 @@ export class ETagExtractorHonoMiddleware implements MiddlewareHonoPort {
     this.middleware = new ETagExtractorMiddleware(config);
   }
 
-  handle(): MiddlewareHandler {
+  handle(): MiddlewareHandler<{ Variables: ETagVariables }> {
     return async (c, next) => {
       const context = new RequestContextHonoAdapter(c);
       const etag = this.middleware.evaluate(context);

package/src/etag-extractor-param.strategy.ts

@@ -9,6 +9,8 @@ export class ETagExtractorParamStrategy implements ETagExtractorStrategy {
     try {
       const value = context.request.param(this.name);
 
+      if (!value?.trim()) return null;
+
       return tools.ETag.fromHeader(value);
     } catch {
       return null;

package/src/etag-extractor.strategy.ts

@@ -1,6 +1,6 @@
 import type * as tools from "@bgord/tools";
-import type { RequestContext } from "./request-context.port";
+import type { HasRequestHeader, HasRequestParam } from "./request-context.port";
 
 export interface ETagExtractorStrategy {
-  detect(context: RequestContext): tools.ETag | null;
+  detect(context: HasRequestHeader & HasRequestParam): tools.ETag | null;
 }

package/src/file-inspection.adapter.ts

@@ -50,16 +50,16 @@ export class FileInspectionAdapter implements FileInspectionPort {
   }
 
   async size(path: tools.FilePathRelative | tools.FilePathAbsolute | string): Promise<tools.Size> {
-    const file = Bun.file(typeof path === "string" ? path : path.get());
+    const node = await stat(typeof path === "string" ? path : path.get());
 
-    return tools.Size.fromBytes(file.size);
+    return tools.Size.fromBytes(node.size);
   }
 
   async lastModified(
     path: tools.FilePathRelative | tools.FilePathAbsolute | string,
   ): Promise<tools.Timestamp> {
-    const file = Bun.file(typeof path === "string" ? path : path.get());
+    const node = await stat(typeof path === "string" ? path : path.get());
 
-    return tools.Timestamp.fromNumber(file.lastModified);
+    return tools.Timestamp.fromNumber(Math.round(node.mtimeMs));
   }
 }

package/src/file-reader-json-forgiving.adapter.ts

@@ -6,7 +6,7 @@ export class FileReaderJsonForgivingAdapter implements FileReaderJsonPort {
     path: tools.FilePathRelative | tools.FilePathAbsolute | string,
   ): Promise<FileReaderJsonOutputType> {
     try {
-      return Bun.file(typeof path === "string" ? path : path.get()).json();
+      return await Bun.file(typeof path === "string" ? path : path.get()).json();
     } catch {
       return {};
     }

package/src/graceful-shutdown.service.ts

@@ -12,7 +12,7 @@ export class GracefulShutdown {
 
   constructor(
     private readonly deps: Dependencies,
-    private readonly config: Config = { cleanup: tools.noop, exit: process.exit },
+    private readonly config: Config = { cleanup: tools.noop },
   ) {}
 
   private async shutdown(server: ServerType, exitCode: number) {
@@ -22,7 +22,7 @@ export class GracefulShutdown {
     // Stryker restore all
 
     try {
-      server.stop();
+      await server.stop();
     } catch (error) {
       this.deps.Logger.error({ message: "Server stop failed", error, ...this.base });
     }
@@ -33,7 +33,7 @@ export class GracefulShutdown {
     } catch (error) {
       this.deps.Logger.error({ message: "Cleanup hook failed", error, ...this.base });
     } finally {
-      this.config.exit?.(exitCode);
+      (this.config.exit ?? process.exit)(exitCode);
     }
   }
 

package/src/hash.vo.ts

@@ -13,7 +13,7 @@ export class Hash {
   }
 
   static fromString(candidate: string): Hash {
-    return new Hash(v.parse(HashValue, candidate));
+    return new Hash(v.parse(HashValue, candidate.toLowerCase()));
   }
 
   get(): HashValueType {

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>> {