@bgord/bun 1.16.4 → 1.17.0

package/src/job-queue.adapter.ts

@@ -0,0 +1,66 @@
+import type * as tools from "@bgord/tools";
+import type { GenericJob } from "./job.types";
+import type { JobClaimerPort } from "./job-claimer.port";
+import type { JobCompleterPort } from "./job-completer.port";
+import type { JobEnqueuerPort } from "./job-enqueuer.port";
+import type { JobFailerPort } from "./job-failer.port";
+import type { JobQueuePort } from "./job-queue.port";
+import type { JobHandler, JobRegistryPort } from "./job-registry.port";
+import type { JobRequeuerPort } from "./job-requeuer.port";
+import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
+import type { PayloadSerializerPort } from "./payload-serializer.port";
+
+type Config<Job extends GenericJob> = {
+  registry: JobRegistryPort<Job>;
+  enqueuer: JobEnqueuerPort;
+  claimer: JobClaimerPort;
+  completer: JobCompleterPort;
+  failer: JobFailerPort;
+  requeuer: JobRequeuerPort;
+  serializer: PayloadSerializerPort;
+};
+
+export class JobQueueAdapter<Job extends GenericJob> implements JobQueuePort<Job> {
+  constructor(private readonly config: Config<Job>) {}
+
+  async enqueue<EnqueuedJob extends Job>(job: EnqueuedJob): Promise<EnqueuedJob> {
+    const serialized = await this.config.enqueuer.enqueue({
+      ...job,
+      payload: this.config.serializer.serialize(job.payload),
+    });
+
+    return { ...serialized, payload: this.config.serializer.deserialize(serialized.payload) } as EnqueuedJob;
+  }
+
+  async claim(limit: tools.IntegerPositiveType): Promise<ReadonlyArray<Job>> {
+    const jobs = await this.config.claimer.claim(this.config.registry.names, limit);
+
+    return jobs
+      .map((job) => ({ ...job, payload: this.config.serializer.deserialize(job.payload) }))
+      .map((job) => this.config.registry.validate(job));
+  }
+
+  async complete(id: GenericJob["id"]): Promise<void> {
+    return this.config.completer.complete(id);
+  }
+
+  async fail(id: GenericJob["id"]): Promise<void> {
+    return this.config.failer.fail(id);
+  }
+
+  async requeue(
+    id: GenericJob["id"],
+    revision: GenericJob["revision"],
+    delay: tools.Duration,
+  ): Promise<void> {
+    return this.config.requeuer.requeue(id, revision, delay);
+  }
+
+  getRetryPolicy(name: GenericJob["name"]): JobRetryPolicyStrategy {
+    return this.config.registry.getRetryPolicy(name);
+  }
+
+  getHandler(name: GenericJob["name"]): JobHandler<Job> {
+    return this.config.registry.getHandler(name);
+  }
+}

package/src/job-queue.port.ts

@@ -0,0 +1,20 @@
+import type * as tools from "@bgord/tools";
+import type { GenericJob } from "./job.types";
+import type { JobHandler } from "./job-registry.port";
+import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
+
+export interface JobQueuePort<Job extends GenericJob> {
+  enqueue<EnqueuedJob extends Job>(job: EnqueuedJob): Promise<EnqueuedJob>;
+
+  claim(limit: tools.IntegerPositiveType): Promise<ReadonlyArray<Job>>;
+
+  complete(id: GenericJob["id"]): Promise<void>;
+
+  fail(id: GenericJob["id"]): Promise<void>;
+
+  requeue(id: GenericJob["id"], revision: GenericJob["revision"], delay: tools.Duration): Promise<void>;
+
+  getRetryPolicy(name: GenericJob["name"]): JobRetryPolicyStrategy;
+
+  getHandler(name: GenericJob["name"]): JobHandler<Job>;
+}

package/src/job-registry.adapter.ts

@@ -0,0 +1,61 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { GenericJob } from "./job.types";
+import { type JobHandler, JobRegistryError, type JobRegistryPort } from "./job-registry.port";
+import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
+
+export type JobRegistryEntry<Specific extends GenericJob> = {
+  schema: StandardSchemaV1<unknown, Specific>;
+  retry: JobRetryPolicyStrategy;
+  handler: (job: Specific) => Promise<void>;
+};
+
+export type GenericJobRegistry<Job extends GenericJob> = {
+  [Name in Job["name"]]: JobRegistryEntry<Extract<Job, { name: Name }>>;
+};
+
+const JobRegistryAdapterError = {
+  MissingName: "job.registry.adapter.error.missing.name",
+  UnknownJob: "job.registry.adapter.error.unknown.job",
+};
+
+export class JobRegistryAdapter<Job extends GenericJob> implements JobRegistryPort<Job> {
+  private readonly map: Map<GenericJob["name"], JobRegistryEntry<any>>;
+  readonly names: ReadonlyArray<GenericJob["name"]>;
+
+  constructor(registry: GenericJobRegistry<Job>) {
+    this.map = new Map(Object.entries(registry));
+    this.names = Object.keys(registry);
+  }
+
+  accepts(name: GenericJob["name"]): boolean {
+    return this.map.has(name);
+  }
+
+  validate(raw: unknown): Job {
+    const name = (raw as { name?: GenericJob["name"] }).name;
+    if (!name) throw new Error(JobRegistryAdapterError.MissingName);
+
+    const entry = this.map.get(name);
+    if (!entry) throw new Error(JobRegistryAdapterError.UnknownJob);
+
+    const result = entry.schema["~standard"].validate(raw);
+
+    if (result instanceof Promise) throw new Error(JobRegistryError.NoAsyncSchema);
+    if (result.issues) throw new Error(result.issues[0]?.message);
+    return result.value;
+  }
+
+  getRetryPolicy(name: GenericJob["name"]): JobRetryPolicyStrategy {
+    const entry = this.map.get(name);
+    if (!entry) throw new Error(JobRegistryAdapterError.UnknownJob);
+
+    return entry.retry;
+  }
+
+  getHandler(name: GenericJob["name"]): JobHandler<Job> {
+    const entry = this.map.get(name);
+    if (!entry) throw new Error(JobRegistryAdapterError.UnknownJob);
+
+    return entry.handler as JobHandler<Job>;
+  }
+}

package/src/job-registry.port.ts

@@ -0,0 +1,18 @@
+import type { GenericJob } from "./job.types";
+import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
+
+export const JobRegistryError = { NoAsyncSchema: "job.registry.no.async.schema" };
+
+export type JobHandler<Job extends GenericJob> = (job: Job) => Promise<void>;
+
+export interface JobRegistryPort<Job extends GenericJob> {
+  readonly names: ReadonlyArray<GenericJob["name"]>;
+
+  accepts(name: GenericJob["name"]): boolean;
+
+  validate(raw: unknown): Job;
+
+  getRetryPolicy(name: GenericJob["name"]): JobRetryPolicyStrategy;
+
+  getHandler(name: GenericJob["name"]): JobHandler<Job>;
+}

package/src/job-requeuer-collecting.adapter.ts

@@ -0,0 +1,17 @@
+import type * as tools from "@bgord/tools";
+import type { GenericJob } from "./job.types";
+import type { JobRequeuerPort } from "./job-requeuer.port";
+
+type RequeueEntry = { id: GenericJob["id"]; revision: GenericJob["revision"]; delay: tools.Duration };
+
+export class JobRequeuerCollectingAdapter implements JobRequeuerPort {
+  readonly requeued: Array<RequeueEntry> = [];
+
+  async requeue(
+    id: GenericJob["id"],
+    revision: GenericJob["revision"],
+    delay: tools.Duration,
+  ): Promise<void> {
+    this.requeued.push({ id, revision, delay });
+  }
+}

package/src/job-requeuer-noop.adapter.ts

@@ -0,0 +1,11 @@
+import type * as tools from "@bgord/tools";
+import type { GenericJob } from "./job.types";
+import type { JobRequeuerPort } from "./job-requeuer.port";
+
+export class JobRequeuerNoopAdapter implements JobRequeuerPort {
+  async requeue(
+    _id: GenericJob["id"],
+    _revision: GenericJob["revision"],
+    _delay: tools.Duration,
+  ): Promise<void> {}
+}

package/src/job-requeuer-sqlite.adapter.ts

@@ -0,0 +1,22 @@
+import type { Database } from "bun:sqlite";
+import type * as tools from "@bgord/tools";
+import type { ClockPort } from "./clock.port";
+import type { GenericJob } from "./job.types";
+import type { JobRequeuerPort } from "./job-requeuer.port";
+
+type Dependencies = { db: Database; Clock: ClockPort };
+
+export class JobRequeuerSqliteAdapter implements JobRequeuerPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async requeue(
+    id: GenericJob["id"],
+    revision: GenericJob["revision"],
+    delay: tools.Duration,
+  ): Promise<void> {
+    this.deps.db.run<[GenericJob["revision"], tools.TimestampValueType, GenericJob["id"]]>(
+      "UPDATE jobs SET status = 'pending', revision = ?, claimableAt = ? WHERE id = ?",
+      [revision, this.deps.Clock.now().add(delay).ms, id],
+    );
+  }
+}

package/src/job-requeuer.port.ts

@@ -0,0 +1,6 @@
+import type * as tools from "@bgord/tools";
+import type { GenericJob } from "./job.types";
+
+export interface JobRequeuerPort {
+  requeue(id: GenericJob["id"], revision: GenericJob["revision"], delay: tools.Duration): Promise<void>;
+}

package/src/job-retry-policy-backoff.strategy.ts

@@ -0,0 +1,12 @@
+import * as tools from "@bgord/tools";
+import type { GenericJob } from "./job.types";
+import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
+import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
+
+export class JobRetryPolicyBackoffStrategy implements JobRetryPolicyStrategy {
+  constructor(private readonly backoff: RetryBackoffStrategy) {}
+
+  evaluate(job: GenericJob, _error: tools.NormalizedError): false | tools.Duration {
+    return this.backoff.next(tools.Int.positive(job.revision + 1));
+  }
+}

package/src/job-retry-policy-composite.strategy.ts

@@ -0,0 +1,29 @@
+import * as tools from "@bgord/tools";
+import type { GenericJob } from "./job.types";
+import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
+
+export const JobRetryPolicyCompositeStrategyError = {
+  MissingPolicies: "job.retry.policy.composite.strategy.error.missing.policies",
+  MaxPolicies: "job.retry.policy.composite.strategy.error.max.policies",
+};
+
+export class JobRetryPolicyCompositeStrategy implements JobRetryPolicyStrategy {
+  constructor(private readonly policies: ReadonlyArray<JobRetryPolicyStrategy>) {
+    if (policies.length === 0) throw new Error(JobRetryPolicyCompositeStrategyError.MissingPolicies);
+    if (policies.length > 5) throw new Error(JobRetryPolicyCompositeStrategyError.MaxPolicies);
+  }
+
+  evaluate(job: GenericJob, error: tools.NormalizedError): false | tools.Duration {
+    let delay: tools.Duration = tools.Duration.ZERO;
+
+    for (const policy of this.policies) {
+      const result = policy.evaluate(job, error);
+
+      if (!result) return false;
+
+      delay = result;
+    }
+
+    return delay;
+  }
+}

package/src/job-retry-policy-error-filter.strategy.ts

@@ -0,0 +1,14 @@
+import * as tools from "@bgord/tools";
+import type { GenericJob } from "./job.types";
+import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
+
+type Config = { retry: (error: tools.NormalizedError) => boolean };
+
+export class JobRetryPolicyErrorFilterStrategy implements JobRetryPolicyStrategy {
+  constructor(private readonly config: Config) {}
+
+  evaluate(_job: GenericJob, error: tools.NormalizedError): false | tools.Duration {
+    if (!this.config.retry(error)) return false;
+    return tools.Duration.ZERO;
+  }
+}

package/src/job-retry-policy-limit.strategy.ts

@@ -0,0 +1,12 @@
+import * as tools from "@bgord/tools";
+import type { GenericJob } from "./job.types";
+import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
+
+export class JobRetryPolicyLimitStrategy implements JobRetryPolicyStrategy {
+  constructor(private readonly retries: tools.IntegerNonNegativeType) {}
+
+  evaluate(job: GenericJob, _error: tools.NormalizedError): false | tools.Duration {
+    if (job.revision >= this.retries) return false;
+    return tools.Duration.ZERO;
+  }
+}

package/src/job-retry-policy-noop.strategy.ts

@@ -0,0 +1,9 @@
+import type * as tools from "@bgord/tools";
+import type { GenericJob } from "./job.types";
+import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
+
+export class JobRetryPolicyNoopStrategy implements JobRetryPolicyStrategy {
+  evaluate(_job: GenericJob, _error: tools.NormalizedError): false | tools.Duration {
+    return false;
+  }
+}

package/src/job-retry-policy.strategy.ts

@@ -0,0 +1,6 @@
+import type * as tools from "@bgord/tools";
+import type { GenericJob } from "./job.types";
+
+export interface JobRetryPolicyStrategy {
+  evaluate(job: GenericJob, error: tools.NormalizedError): false | tools.Duration;
+}

package/src/job-worker.service.ts

@@ -0,0 +1,37 @@
+import * as tools from "@bgord/tools";
+import { CorrelationStorage } from "./correlation-storage.service";
+import type { CronTask } from "./cron-task.vo";
+import type { GenericJob } from "./job.types";
+import type { JobQueuePort } from "./job-queue.port";
+
+type Config = { label: CronTask["label"]; cron: CronTask["cron"]; limit: tools.IntegerPositiveType };
+
+type Dependencies<Job extends GenericJob> = { queue: JobQueuePort<Job> };
+
+export function JobWorker<Job extends GenericJob>(config: Config, deps: Dependencies<Job>): CronTask {
+  return {
+    label: config.label,
+    cron: config.cron,
+    handler: async () => {
+      const jobs = await deps.queue.claim(config.limit);
+
+      for (const job of jobs) {
+        await CorrelationStorage.run(job.correlationId, async () => {
+          try {
+            const handler = deps.queue.getHandler(job.name);
+
+            await handler(job);
+            await deps.queue.complete(job.id);
+          } catch (error) {
+            const policy = deps.queue.getRetryPolicy(job.name);
+
+            const retry = policy.evaluate(job, tools.ErrorNormalizer.normalize(error));
+
+            if (!retry) return deps.queue.fail(job.id);
+            await deps.queue.requeue(job.id, job.revision + 1, retry);
+          }
+        });
+      }
+    },
+  };
+}

package/src/job.types.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { UUIDType } from "./uuid.vo";
+
+export type GenericJob = {
+  id: UUIDType;
+  correlationId: UUIDType;
+  createdAt: number;
+  name: string;
+  revision: tools.RevisionValueType;
+  payload: Record<string, unknown>;
+};
+
+export type GenericJobSerialized = Omit<GenericJob, "payload"> & { payload: string };

package/src/logger-collecting.adapter.ts

@@ -13,7 +13,6 @@ export class LoggerCollectingAdapter implements LoggerPort {
     | Omit<LogWarnType, AdapterInjectedFields>
     | Omit<LogCoreType, AdapterInjectedFields>
     | Omit<LogHttpType, AdapterInjectedFields>
-    | Omit<LogCoreType, AdapterInjectedFields>
   > = [];
 
   warn: LoggerPort["warn"] = (log): void => {

package/src/logger-noop.adapter.ts

@@ -1,7 +1,11 @@
 import type { LoggerPort } from "./logger.port";
-import { LoggerState, type LoggerStatsSnapshot } from "./logger-stats-provider.port";
+import {
+  LoggerState,
+  type LoggerStatsProviderPort,
+  type LoggerStatsSnapshot,
+} from "./logger-stats-provider.port";
 
-export class LoggerNoopAdapter implements LoggerPort {
+export class LoggerNoopAdapter implements LoggerPort, LoggerStatsProviderPort {
   error: LoggerPort["error"] = (_log): void => {};
   warn: LoggerPort["warn"] = (_log): void => {};
   info: LoggerPort["info"] = (_log): void => {};

package/src/mailer-resend.adapter.ts

@@ -16,7 +16,7 @@ export class MailerResendAdapter implements MailerPort {
     MailerResendAdapterError.MissingDependency,
   );
 
-  private constructor(readonly transport: Resend) {}
+  private constructor(private readonly transport: Resend) {}
 
   static async build(config: Config): Promise<MailerResendAdapter> {
     const library = await MailerResendAdapter.importer.resolve();

package/src/mailer-smtp.adapter.ts

@@ -26,7 +26,7 @@ export class MailerSmtpAdapter implements MailerPort {
     MailerSmtpAdapterError.MissingDependency,
   );
 
-  private constructor(readonly transport: Nodemailer.Transporter) {}
+  private constructor(private readonly transport: Nodemailer.Transporter) {}
 
   static async build(config: Config): Promise<MailerSmtpAdapter> {
     const library = await MailerSmtpAdapter.importer.resolve();

package/src/mailer-template.vo.ts

@@ -22,6 +22,6 @@ export class MailerTemplate {
   ) {}
 
   toJSON() {
-    return { config: this.config, message: this.message };
+    return { config: this.config, message: this.message, attachments: this.attachments?.length };
   }
 }

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

@@ -1,4 +1,5 @@
 import type { ClockPort } from "./clock.port";
+import { CorrelationStorage } from "./correlation-storage.service";
 import type { LoggerPort } from "./logger.port";
 import type { MailerPort } from "./mailer.port";
 import type { MailerTemplate } from "./mailer-template.vo";
@@ -15,17 +16,29 @@ export class MailerWithLoggerAdapter implements MailerPort {
     const duration = new Stopwatch(this.deps);
 
     try {
-      this.deps.Logger.info({ message: "Mailer attempt", metadata: template.toJSON(), ...this.base });
+      this.deps.Logger.info({
+        message: "Mailer attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata: template.toJSON(),
+        ...this.base,
+      });
 
       await this.deps.inner.send(template);
 
       this.deps.Logger.info({
         message: "Mailer success",
+        correlationId: CorrelationStorage.get(),
         metadata: { template: template.toJSON(), duration: duration.stop() },
         ...this.base,
       });
     } catch (error) {
-      this.deps.Logger.error({ message: "Mailer error", error, metadata: duration.stop(), ...this.base });
+      this.deps.Logger.error({
+        message: "Mailer error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: duration.stop(),
+        ...this.base,
+      });
 
       throw error;
     }

package/src/mailer.builder.ts

@@ -15,28 +15,25 @@ import {
 } from "./mailer-with-timeout.adapter";
 
 export class MailerBuilder {
-  constructor(private inner: MailerPort) {}
+  constructor(private readonly inner: MailerPort) {}
 
   static of(mailer: MailerPort): MailerBuilder {
     return new MailerBuilder(mailer);
   }
 
   withLogger(deps: Omit<MailerWithLoggerAdapterDependencies, "inner">) {
-    this.inner = new MailerWithLoggerAdapter({ ...deps, inner: this.inner });
-    return this;
+    return MailerBuilder.of(new MailerWithLoggerAdapter({ ...deps, inner: this.inner }));
   }
 
   withRetry(config: MailerWithRetryAdapterConfig, deps: Omit<MailerWithRetryAdapterDependencies, "inner">) {
-    this.inner = new MailerWithRetryAdapter(config, { ...deps, inner: this.inner });
-    return this;
+    return MailerBuilder.of(new MailerWithRetryAdapter(config, { ...deps, inner: this.inner }));
   }
 
   withTimeout(
     config: MailerWithTimeoutAdapterConfig,
     deps: Omit<MailerWithTimeoutAdapterDependencies, "inner">,
   ) {
-    this.inner = new MailerWithTimeoutAdapter(config, { ...deps, inner: this.inner });
-    return this;
+    return MailerBuilder.of(new MailerWithTimeoutAdapter(config, { ...deps, inner: this.inner }));
   }
 
   build() {

package/src/memory-consumption.service.ts

@@ -12,12 +12,11 @@ export class MemoryConsumption {
   }
 
   static snapshot(): MemoryConsumptionSnapshotType {
+    const { rss, heapUsed, heapTotal } = process.memoryUsage();
+
     return {
-      total: tools.Size.fromBytes(process.memoryUsage().rss),
-      heap: {
-        used: tools.Size.fromBytes(process.memoryUsage().heapUsed),
-        total: tools.Size.fromBytes(process.memoryUsage().heapTotal),
-      },
+      total: tools.Size.fromBytes(rss),
+      heap: { used: tools.Size.fromBytes(heapUsed), total: tools.Size.fromBytes(heapTotal) },
     };
   }
 }

package/src/modules/system/cron-tasks/index.ts

@@ -0,0 +1,2 @@
+export * from "./passage-of-time-hourly";
+export * from "./passage-of-time-minute";

package/src/modules/system/{services/passage-of-time-hourly.service.ts → cron-tasks/passage-of-time-hourly.ts}

@@ -12,7 +12,7 @@ type Dependencies = {
   IdProvider: IdProviderPort;
 };
 
-export const PassageOfTimeHourly = (deps: Dependencies): CronTask => ({
+export const PassageOfTimeHourlyCronTask = (deps: Dependencies): CronTask => ({
   label: "PassageOfTimeHourly",
   cron: CronExpressionSchedules.EVERY_HOUR,
   handler: async () => {

package/src/modules/system/{services/passage-of-time-minute.service.ts → cron-tasks/passage-of-time-minute.ts}

@@ -12,7 +12,7 @@ type Dependencies = {
   IdProvider: IdProviderPort;
 };
 
-export const PassageOfTimeMinute = (deps: Dependencies): CronTask => ({
+export const PassageOfTimeMinuteCronTask = (deps: Dependencies): CronTask => ({
   label: "PassageOfTimeMinute",
   cron: CronExpressionSchedules.EVERY_MINUTE,
   handler: async () => {

package/src/modules/system/index.ts

@@ -1,2 +1,2 @@
+export * as CronTasks from "./cron-tasks";
 export * as Events from "./events";
-export * as Services from "./services";

package/src/payload-serializer-collecting.adapter.ts

@@ -0,0 +1,19 @@
+import type { PayloadSerializerPort } from "./payload-serializer.port";
+
+export class PayloadSerializerCollectingAdapter implements PayloadSerializerPort {
+  readonly serialized: Array<Record<string, unknown>> = [];
+
+  readonly deserialized: Array<string> = [];
+
+  serialize(payload: Record<string, unknown>): string {
+    this.serialized.push(payload);
+
+    return JSON.stringify(payload);
+  }
+
+  deserialize(raw: string): Record<string, unknown> {
+    this.deserialized.push(raw);
+
+    return JSON.parse(raw);
+  }
+}

package/src/payload-serializer-json.adapter.ts

@@ -0,0 +1,11 @@
+import type { PayloadSerializerPort } from "./payload-serializer.port";
+
+export class PayloadSerializerJsonAdapter implements PayloadSerializerPort {
+  serialize(payload: Record<string, unknown>): string {
+    return JSON.stringify(payload);
+  }
+
+  deserialize(raw: string): Record<string, unknown> {
+    return JSON.parse(raw);
+  }
+}

package/src/payload-serializer.port.ts

@@ -0,0 +1,4 @@
+export interface PayloadSerializerPort {
+  serialize(payload: Record<string, unknown>): string;
+  deserialize(raw: string): Record<string, unknown>;
+}

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

@@ -1,5 +1,6 @@
 import * as tools from "@bgord/tools";
 import type { ClockPort } from "./clock.port";
+import { CorrelationStorage } from "./correlation-storage.service";
 import type { LoggerPort } from "./logger.port";
 import type { PdfGeneratorPort, PdfGeneratorTemplateType } from "./pdf-generator.port";
 import { Stopwatch } from "./stopwatch.service";
@@ -15,13 +16,19 @@ export class PdfGeneratorWithLoggerAdapter implements PdfGeneratorPort {
     const duration = new Stopwatch(this.deps);
 
     try {
-      this.deps.Logger.info({ message: "PDF generator attempt", metadata: { template, data }, ...this.base });
+      this.deps.Logger.info({
+        message: "PDF generator attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata: { template, data },
+        ...this.base,
+      });
 
       const pdf = await this.deps.inner.request(template, data);
       const size = tools.Size.fromBytes(pdf.byteLength);
 
       this.deps.Logger.info({
         message: "PDF generator success",
+        correlationId: CorrelationStorage.get(),
         metadata: { size, duration: duration.stop() },
         ...this.base,
       });
@@ -30,6 +37,7 @@ export class PdfGeneratorWithLoggerAdapter implements PdfGeneratorPort {
     } catch (error) {
       this.deps.Logger.error({
         message: "PDF generator error",
+        correlationId: CorrelationStorage.get(),
         error,
         metadata: duration.stop(),
         ...this.base,

package/src/pdf-generator.port.ts

@@ -1,5 +1,5 @@
 export type PdfGeneratorTemplateType = string;
 
-export abstract class PdfGeneratorPort {
-  abstract request(template: PdfGeneratorTemplateType, data: Record<string, unknown>): Promise<ArrayBuffer>;
+export interface PdfGeneratorPort {
+  request(template: PdfGeneratorTemplateType, data: Record<string, unknown>): Promise<ArrayBuffer>;
 }

package/src/prerequisite-runner-startup.service.ts

@@ -1,5 +1,5 @@
-import type { ClockPort } from "../src/clock.port";
-import type { LoggerPort } from "../src/logger.port";
+import type { ClockPort } from "./clock.port";
+import type { LoggerPort } from "./logger.port";
 import type { Prerequisite } from "./prerequisite.vo";
 import { PrerequisiteVerificationOutcome } from "./prerequisite-verifier.port";
 

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

@@ -1,5 +1,5 @@
 import type * as tools from "@bgord/tools";
-import type { FileInspectionPort } from "../src/file-inspection.port";
+import type { FileInspectionPort } from "./file-inspection.port";
 import {
   PrerequisiteVerification,
   type PrerequisiteVerificationResult,