@bgord/bun 1.2.4 → 1.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -20,40 +20,38 @@
     "preinstall": "bunx only-allow bun"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.5",
+    "@biomejs/biome": "2.3.8",
     "@commitlint/cli": "20.1.0",
     "@commitlint/config-conventional": "20.0.0",
-    "@types/bun": "1.3.2",
-    "@types/lodash": "4.17.20",
-    "@types/mime-types": "3.0.1",
-    "@types/nodemailer": "7.0.3",
+    "@types/bun": "1.3.3",
+    "@types/lodash": "4.17.21",
+    "@types/nodemailer": "7.0.4",
     "@types/yazl": "3.3.0",
-    "cspell": "9.3.1",
-    "knip": "5.69.1",
-    "lefthook": "2.0.4",
-    "only-allow": "1.2.1",
+    "cspell": "9.4.0",
+    "knip": "5.71.0",
+    "lefthook": "2.0.6",
+    "only-allow": "1.2.2",
     "shellcheck": "4.1.0",
     "typescript": "5.9.3",
-    "zod": "4.1.12"
+    "zod": "4.1.13"
   },
   "dependencies": {
     "@axiomhq/winston": "1.3.1",
-    "@bgord/tools": "1.1.7",
-    "@hono/ua-blocker": "0.1.16",
-    "better-auth": "1.3.34",
+    "@bgord/tools": "1.1.9",
+    "@hono/ua-blocker": "0.1.20",
+    "better-auth": "1.4.5",
     "croner": "9.1.0",
     "csv": "6.4.1",
     "hcaptcha": "0.2.0",
-    "hono": "4.10.6",
+    "hono": "4.10.7",
     "lodash": "4.17.21",
-    "mime-types": "3.0.1",
     "node-cache": "5.1.2",
-    "nodemailer": "7.0.10",
+    "nodemailer": "7.0.11",
     "sharp": "0.34.5",
     "winston": "3.18.3",
     "yazl": "3.3.1"
   },
   "peerDependencies": {
-    "zod": "4.1.12"
+    "zod": "4.1.13"
   }
 }

package/src/better-auth-logger.service.ts

@@ -3,8 +3,10 @@ import { formatError } from "./logger-format-error.service";
 
 type LogLevel = "info" | "success" | "warn" | "error" | "debug";
 
+type Dependencies = { Logger: LoggerPort };
+
 export class BetterAuthLogger {
-  constructor(private readonly logger: LoggerPort) {}
+  constructor(private readonly deps: Dependencies) {}
 
   attach() {
     return {
@@ -16,18 +18,18 @@ export class BetterAuthLogger {
 
         switch (level) {
           case LogLevelEnum.error: {
-            this.logger.error({
+            this.deps.Logger.error({
               ...base,
               error: formatError(args.find((a) => a instanceof Error) ?? new Error(message)),
             });
             break;
           }
           case LogLevelEnum.warn: {
-            this.logger.warn(base);
+            this.deps.Logger.warn(base);
             break;
           }
           default: {
-            this.logger.info(base);
+            this.deps.Logger.info(base);
             break;
           }
         }

package/src/command-logger.service.ts

@@ -1,9 +1,11 @@
 import type { LoggerPort } from "./logger.port";
 
+type Dependencies = { Logger: LoggerPort };
+
 export class CommandLogger {
   private readonly base = { component: "infra", operation: "command_emitted" };
 
-  constructor(private readonly logger: LoggerPort) {}
+  constructor(private readonly deps: Dependencies) {}
 
   private _handle(
     type: string,
@@ -14,7 +16,7 @@ export class CommandLogger {
     if (type === "subscribe") return;
     if (typeof commandName === "symbol") return;
 
-    this.logger.info({ message: `${commandName} emitted`, metadata: commandData, ...this.base });
+    this.deps.Logger.info({ message: `${commandName} emitted`, metadata: commandData, ...this.base });
   }
 
   handle = this._handle.bind(this);

package/src/encryption-bun.adapter.ts

@@ -4,11 +4,13 @@ import { EncryptionIV } from "./encryption-iv.vo";
 
 export const EncryptionBunAdapterError = { InvalidPayload: "encryption.bun.adapter.invalid.payload" };
 
+type Dependencies = { CryptoKeyProvider: CryptoKeyProviderPort };
+
 export class EncryptionBunAdapter implements EncryptionPort {
-  constructor(private readonly cryptoKeyProvider: CryptoKeyProviderPort) {}
+  constructor(private readonly deps: Dependencies) {}
 
   async encrypt(recipe: EncryptionRecipe) {
-    const key = await this.cryptoKeyProvider.get();
+    const key = await this.deps.CryptoKeyProvider.get();
     const iv = EncryptionIV.generate();
 
     const plaintext = await Bun.file(recipe.input.get()).arrayBuffer();
@@ -30,7 +32,7 @@ export class EncryptionBunAdapter implements EncryptionPort {
   }
 
   async decrypt(recipe: EncryptionRecipe) {
-    const key = await this.cryptoKeyProvider.get();
+    const key = await this.deps.CryptoKeyProvider.get();
 
     const bytes = new Uint8Array(await Bun.file(recipe.input.get()).arrayBuffer());
     if (bytes.length < EncryptionIV.LENGTH + 1) throw new Error(EncryptionBunAdapterError.InvalidPayload);

package/src/event-handler.service.ts

@@ -3,15 +3,17 @@ import type { GenericEventSchema } from "./event.types";
 import type { LoggerPort } from "./logger.port";
 import { formatError } from "./logger-format-error.service";
 
+type Dependencies = { Logger: LoggerPort };
+
 export class EventHandler {
-  constructor(private readonly logger: LoggerPort) {}
+  constructor(private readonly deps: Dependencies) {}
 
   handle<T extends { name: z.infer<GenericEventSchema["shape"]["name"]> }>(fn: (event: T) => Promise<void>) {
     return async (event: T) => {
       try {
         await fn(event);
       } catch (error) {
-        this.logger.error({
+        this.deps.Logger.error({
           message: `Unknown ${event.name} event handler error`,
           component: "infra",
           operation: "unknown_event_handler_error",

package/src/event-logger.service.ts

@@ -1,9 +1,11 @@
 import type { LoggerPort } from "./logger.port";
 
+type Dependencies = { Logger: LoggerPort };
+
 export class EventLogger {
   private readonly base = { component: "infra", operation: "event_emitted" };
 
-  constructor(private readonly logger: LoggerPort) {}
+  constructor(private readonly deps: Dependencies) {}
 
   private _handle(
     type: string,
@@ -14,7 +16,7 @@ export class EventLogger {
     if (type === "subscribe") return;
     if (typeof eventName === "symbol") return;
 
-    this.logger.info({ message: `${eventName} emitted`, metadata: eventData, ...this.base });
+    this.deps.Logger.info({ message: `${eventName} emitted`, metadata: eventData, ...this.base });
   }
 
   handle = this._handle.bind(this);

package/src/graceful-shutdown.service.ts

@@ -4,12 +4,14 @@ import { formatError } from "./logger-format-error.service";
 
 type ServerType = ReturnType<typeof Bun.serve>;
 
+type Dependencies = { Logger: LoggerPort };
+
 export class GracefulShutdown {
   private readonly base = { operation: "shutdown", component: "infra" } as const;
   private isShuttingDown = false;
 
   constructor(
-    private readonly logger: LoggerPort,
+    private readonly deps: Dependencies,
     private readonly exitFn: (code: number) => never = ((code: number) => process.exit(code)) as never,
   ) {}
 
@@ -20,36 +22,44 @@ export class GracefulShutdown {
     try {
       server.stop();
     } catch (error) {
-      this.logger.error({ message: "Server stop failed", error: formatError(error), ...this.base });
+      this.deps.Logger.error({ message: "Server stop failed", error: formatError(error), ...this.base });
     }
 
     Promise.resolve()
       .then(() => cleanup())
-      .then(() => this.logger.info({ message: "HTTP server closed", ...this.base }))
+      .then(() => this.deps.Logger.info({ message: "HTTP server closed", ...this.base }))
       .catch((error) =>
-        this.logger.error({ message: "Cleanup hook failed", error: formatError(error), ...this.base }),
+        this.deps.Logger.error({ message: "Cleanup hook failed", error: formatError(error), ...this.base }),
       )
       .finally(() => this.exitFn(exitCode));
   }
 
   applyTo(server: ServerType, cleanup: () => any = tools.noop) {
     process.once("SIGTERM", () => {
-      this.logger.info({ message: "SIGTERM received", ...this.base });
+      this.deps.Logger.info({ message: "SIGTERM received", ...this.base });
       this.shutdown(server, cleanup, 0);
     });
 
     process.once("SIGINT", () => {
-      this.logger.info({ message: "SIGINT received", ...this.base });
+      this.deps.Logger.info({ message: "SIGINT received", ...this.base });
       this.shutdown(server, cleanup, 0);
     });
 
     process.once("unhandledRejection", (reason) => {
-      this.logger.error({ message: "UnhandledRejection received", error: formatError(reason), ...this.base });
+      this.deps.Logger.error({
+        message: "UnhandledRejection received",
+        error: formatError(reason),
+        ...this.base,
+      });
       this.shutdown(server, cleanup, 1);
     });
 
     process.once("uncaughtException", (error) => {
-      this.logger.error({ message: "UncaughtException received", error: formatError(error), ...this.base });
+      this.deps.Logger.error({
+        message: "UncaughtException received",
+        error: formatError(error),
+        ...this.base,
+      });
       this.shutdown(server, cleanup, 1);
     });
   }

package/src/jobs.service.ts

@@ -9,6 +9,7 @@ import { formatError } from "./logger-format-error.service";
 export type JobNameType = string;
 export type MultipleJobsType = Record<JobNameType, Cron>;
 export type JobProcessorType = { cron: string; label: JobNameType; process: () => Promise<void> };
+
 type Dependencies = { Logger: LoggerPort; IdProvider: IdProviderPort; Clock: ClockPort };
 
 export class Jobs {

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

@@ -5,28 +5,29 @@ import type { MailerPort } from "./mailer.port";
 import type { MailerSmtpAdapter } from "./mailer-smtp.adapter";
 
 type MailerSendOptionsType = SendMailOptions;
-type SmtpMailerWithLoggerConfigType = { smtpMailer: MailerSmtpAdapter; logger: LoggerPort };
+
+type Dependencies = { MailerSmtp: MailerSmtpAdapter; Logger: LoggerPort };
 
 export class MailerSmtpWithLoggerAdapter implements MailerPort {
   private readonly base = { component: "infra", operation: "mailer" };
 
-  constructor(private readonly config: SmtpMailerWithLoggerConfigType) {}
+  constructor(private readonly deps: Dependencies) {}
 
   async send(message: MailerSendOptionsType): Promise<unknown> {
     try {
-      this.config.logger.info({ message: "Mailer attempt", metadata: message, ...this.base });
-      const result = await this.config.smtpMailer.send(message);
-      this.config.logger.info({ message: "Mailer success", metadata: { message, result }, ...this.base });
+      this.deps.Logger.info({ message: "Mailer attempt", metadata: message, ...this.base });
+      const result = await this.deps.MailerSmtp.send(message);
+      this.deps.Logger.info({ message: "Mailer success", metadata: { message, result }, ...this.base });
 
       return result;
     } catch (error) {
-      this.config.logger.error({ message: "Mailer error", error: formatError(error), ...this.base });
+      this.deps.Logger.error({ message: "Mailer error", error: formatError(error), ...this.base });
 
       throw error;
     }
   }
 
   async verify() {
-    return this.config.smtpMailer.verify();
+    return this.deps.MailerSmtp.verify();
   }
 }

package/src/pdf-generator-noop.adapter.ts

@@ -4,13 +4,19 @@ import type { PdfGeneratorPort, PdfGeneratorTemplateType } from "./pdf-generator
 export const PLACEHOLDER_PDF_BASE64 =
   "JVBERi0xLjQKMSAwIG9iago8PC9UeXBlIC9DYXRhbG9nCi9QYWdlcyAyIDAgUgo+PgplbmRvYmoK MiAwIG9iago8PC9UeXBlIC9QYWdlcwovS2lkcyBbMyAwIFJdCi9Db3VudCAxCj4+CmVuZG9iagoz IDAgb2JqCjw8L1R5cGUgL1BhZ2UKL1BhcmVudCAyIDAgUgovTWVkaWFCb3ggWzAgMCA1OTUgODQy XQovQ29udGVudHMgNSAwIFIKL1Jlc291cmNlcyA8PC9Qcm9jU2V0IFsvUERGIC9UZXh0XQovRm9u dCA8PC9GMSA0IDAgUj4+Cj4+Cj4+CmVuZG9iago0IDAgb2JqCjw8L1R5cGUgL0ZvbnQKL1N1YnR5 cGUgL1R5cGUxCi9OYW1lIC9GMQovQmFzZUZvbnQgL0hlbHZldGljYQovRW5jb2RpbmcgL01hY1Jv bWFuRW5jb2RpbmcKPj4KZW5kb2JqCjUgMCBvYmoKPDwvTGVuZ3RoIDUzCj4+CnN0cmVhbQpCVAov RjEgMjAgVGYKMjIwIDQwMCBUZAooRHVtbXkgUERGKSBUagpFVAplbmRzdHJlYW0KZW5kb2JqCnhy ZWYKMCA2CjAwMDAwMDAwMDAgNjU1MzUgZgowMDAwMDAwMDA5IDAwMDAwIG4KMDAwMDAwMDA2MyAw MDAwMCBuCjAwMDAwMDAxMjQgMDAwMDAgbgowMDAwMDAwMjc3IDAwMDAwIG4KMDAwMDAwMDM5MiAw MDAwMCBuCnRyYWlsZXIKPDwvU2l6ZSA2Ci9Sb290IDEgMCBSCj4+CnN0YXJ0eHJlZgo0OTUKJSVF T0YK";
 
+type Dependencies = { Logger: LoggerPort };
+
 export class PdfGeneratorNoopAdapter implements PdfGeneratorPort {
   private readonly base = { component: "infra", operation: "pdf_generator" };
 
-  constructor(private readonly logger: LoggerPort) {}
+  constructor(private readonly deps: Dependencies) {}
 
   async request(template: PdfGeneratorTemplateType, data: Record<string, unknown>) {
-    this.logger.info({ message: "[NOOP] PDF generator adapter", metadata: { template, data }, ...this.base });
+    this.deps.Logger.info({
+      message: "[NOOP] PDF generator adapter",
+      metadata: { template, data },
+      ...this.base,
+    });
 
     return Buffer.from(PLACEHOLDER_PDF_BASE64, "base64");
   }

package/src/prerequisites/clock-drift.ts

@@ -11,13 +11,13 @@ export class PrerequisiteClockDrift implements prereqs.Prerequisite {
   readonly enabled?: boolean = true;
 
   readonly skew: tools.Duration;
-  readonly timekeeper: TimekeeperPort;
+  readonly Timekeeper: TimekeeperPort;
   readonly timeout: tools.Duration;
 
   constructor(
     config: prereqs.PrerequisiteConfigType & {
       skew: tools.Duration;
-      timekeeper?: TimekeeperPort;
+      Timekeeper?: TimekeeperPort;
       timeout?: tools.Duration;
     },
   ) {
@@ -25,7 +25,7 @@ export class PrerequisiteClockDrift implements prereqs.Prerequisite {
     this.enabled = config.enabled === undefined ? true : config.enabled;
 
     this.skew = config.skew;
-    this.timekeeper = config.timekeeper ?? new TimekeeperGoogleAdapter();
+    this.Timekeeper = config.Timekeeper ?? new TimekeeperGoogleAdapter();
     this.timeout = config.timeout ?? tools.Duration.Seconds(2);
   }
 
@@ -36,7 +36,7 @@ export class PrerequisiteClockDrift implements prereqs.Prerequisite {
 
     try {
       const timestamp = await Timeout.cancellable(
-        (signal: AbortSignal) => this.timekeeper.get(signal),
+        (signal: AbortSignal) => this.Timekeeper.get(signal),
         this.timeout,
       );
       if (!timestamp) return prereqs.Verification.undetermined(stopwatch.stop());

package/src/prerequisites/log-file.ts

@@ -8,13 +8,13 @@ export class PrerequisiteLogFile implements prereqs.Prerequisite {
   readonly label: prereqs.PrerequisiteLabelType;
   readonly enabled?: boolean = true;
 
-  private readonly logger: LoggerWinstonProductionAdapter;
+  private readonly Logger: LoggerWinstonProductionAdapter;
 
-  constructor(config: prereqs.PrerequisiteConfigType & { logger: LoggerWinstonProductionAdapter }) {
+  constructor(config: prereqs.PrerequisiteConfigType & { Logger: LoggerWinstonProductionAdapter }) {
     this.label = config.label;
     this.enabled = config.enabled === undefined ? true : config.enabled;
 
-    this.logger = config.logger;
+    this.Logger = config.Logger;
   }
 
   async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
@@ -23,7 +23,7 @@ export class PrerequisiteLogFile implements prereqs.Prerequisite {
     if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
-      const path = this.logger.prodLogFile;
+      const path = this.Logger.prodLogFile;
       const result = await Bun.file(path).exists();
 
       if (result) return prereqs.Verification.success(stopwatch.stop());

package/src/prerequisites/mailer.ts

@@ -9,14 +9,14 @@ export class PrerequisiteMailer implements prereqs.Prerequisite {
   readonly label: prereqs.PrerequisiteLabelType;
   readonly enabled?: boolean = true;
 
-  private readonly mailer: MailerPort;
+  private readonly Mailer: MailerPort;
   readonly timeout: tools.Duration;
 
-  constructor(config: prereqs.PrerequisiteConfigType & { mailer: MailerPort; timeout?: tools.Duration }) {
+  constructor(config: prereqs.PrerequisiteConfigType & { Mailer: MailerPort; timeout?: tools.Duration }) {
     this.label = config.label;
     this.enabled = config.enabled === undefined ? true : config.enabled;
 
-    this.mailer = config.mailer;
+    this.Mailer = config.Mailer;
     this.timeout = config.timeout ?? tools.Duration.Seconds(2);
   }
 
@@ -26,7 +26,7 @@ export class PrerequisiteMailer implements prereqs.Prerequisite {
     if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
-      await Timeout.run(this.mailer.verify(), this.timeout);
+      await Timeout.run(this.Mailer.verify(), this.timeout);
       return prereqs.Verification.success(stopwatch.stop());
     } catch (error) {
       return prereqs.Verification.failure(stopwatch.stop(), error as Error);

package/src/prerequisites/space.ts

@@ -11,16 +11,16 @@ export class PrerequisiteSpace implements prereqs.Prerequisite {
   readonly enabled?: boolean = true;
 
   private readonly minimum: tools.Size;
-  private readonly checker: DiskSpaceCheckerPort;
+  private readonly DiskSpaceChecker: DiskSpaceCheckerPort;
 
   constructor(
-    config: prereqs.PrerequisiteConfigType & { minimum: tools.Size; checker?: DiskSpaceCheckerPort },
+    config: prereqs.PrerequisiteConfigType & { minimum: tools.Size; DiskSpaceChecker?: DiskSpaceCheckerPort },
   ) {
     this.label = config.label;
     this.enabled = config.enabled === undefined ? true : config.enabled;
 
     this.minimum = config.minimum;
-    this.checker = config.checker ?? new DiskSpaceCheckerBunAdapter();
+    this.DiskSpaceChecker = config.DiskSpaceChecker ?? new DiskSpaceCheckerBunAdapter();
   }
 
   async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
@@ -30,7 +30,7 @@ export class PrerequisiteSpace implements prereqs.Prerequisite {
 
     try {
       const root = path.sep;
-      const freeDiskSpace = await this.checker.get(root);
+      const freeDiskSpace = await this.DiskSpaceChecker.get(root);
 
       if (freeDiskSpace.isGreaterThan(this.minimum)) return prereqs.Verification.success(stopwatch.stop());
       return prereqs.Verification.failure(stopwatch.stop(), {

package/src/prerequisites/ssl-certificate-expiry.ts

@@ -10,13 +10,13 @@ export class PrerequisiteSSLCertificateExpiry implements prereqs.Prerequisite {
 
   private readonly host: string;
   private readonly days: number;
-  private readonly inspector: CertificateInspectorPort;
+  private readonly CertificateInspector: CertificateInspectorPort;
 
   constructor(
     config: prereqs.PrerequisiteConfigType & {
       host: string;
       days: number;
-      inspector: CertificateInspectorPort;
+      CertificateInspector: CertificateInspectorPort;
     },
   ) {
     this.label = config.label;
@@ -24,7 +24,7 @@ export class PrerequisiteSSLCertificateExpiry implements prereqs.Prerequisite {
 
     this.host = config.host;
     this.days = config.days;
-    this.inspector = config.inspector;
+    this.CertificateInspector = config.CertificateInspector;
   }
 
   async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
@@ -32,7 +32,7 @@ export class PrerequisiteSSLCertificateExpiry implements prereqs.Prerequisite {
 
     if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
-    const result = await this.inspector.inspect(this.host);
+    const result = await this.CertificateInspector.inspect(this.host);
 
     if (!result.success)
       return prereqs.Verification.failure(stopwatch.stop(), { message: "Certificate unavailable" });

package/src/prerequisites/translations.ts

@@ -23,15 +23,15 @@ export class PrerequisiteTranslations implements prereqs.Prerequisite {
   private readonly translationsPath?: typeof I18n.DEFAULT_TRANSLATIONS_PATH;
   private readonly supportedLanguages: types.I18nConfigType["supportedLanguages"];
 
-  private readonly logger: LoggerPort;
-  private readonly jsonFileReader: JsonFileReaderPort;
+  private readonly Logger: LoggerPort;
+  private readonly JsonFileReader: JsonFileReaderPort;
 
   constructor(
     config: prereqs.PrerequisiteConfigType & {
       translationsPath?: typeof I18n.DEFAULT_TRANSLATIONS_PATH;
       supportedLanguages: types.I18nConfigType["supportedLanguages"];
-      logger: LoggerPort;
-      jsonFileReader?: JsonFileReaderPort;
+      Logger: LoggerPort;
+      JsonFileReader?: JsonFileReaderPort;
     },
   ) {
     this.label = config.label;
@@ -40,8 +40,8 @@ export class PrerequisiteTranslations implements prereqs.Prerequisite {
     this.translationsPath = config.translationsPath;
     this.supportedLanguages = config.supportedLanguages;
 
-    this.logger = config.logger;
-    this.jsonFileReader = config.jsonFileReader ?? new JsonFileReaderBunForgivingAdapter();
+    this.Logger = config.Logger;
+    this.JsonFileReader = config.JsonFileReader ?? new JsonFileReaderBunForgivingAdapter();
   }
 
   async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
@@ -52,7 +52,7 @@ export class PrerequisiteTranslations implements prereqs.Prerequisite {
     const translationsPath = this.translationsPath ?? I18n.DEFAULT_TRANSLATIONS_PATH;
 
     const supportedLanguages = Object.keys(this.supportedLanguages);
-    const i18n = new I18n({ Logger: this.logger, JsonFileReader: this.jsonFileReader });
+    const i18n = new I18n({ Logger: this.Logger, JsonFileReader: this.JsonFileReader });
 
     try {
       await fsp.access(translationsPath, constants.R_OK);

package/src/prerequisites.service.ts

@@ -57,7 +57,7 @@ export type PrerequisiteConfigType = { label: string; enabled?: boolean };
 
 export const PrerequisitesError = { Failure: "prerequisites.failure" } as const;
 
-type Dependencies = { logger: LoggerPort; clock: ClockPort };
+type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
 
 /** @public */
 export class Prerequisites {
@@ -69,16 +69,16 @@ export class Prerequisites {
     const results = await Promise.all(
       prerequisites.map(async (prerequisite) => ({
         prerequisite,
-        outcome: await prerequisite.verify(this.deps.clock),
+        outcome: await prerequisite.verify(this.deps.Clock),
       })),
     );
 
     const failed = results.filter((result) => result.outcome.status === PrerequisiteStatusEnum.failure);
 
-    if (failed.length === 0) return this.deps.logger.info({ message: "Prerequisites ok", ...this.base });
+    if (failed.length === 0) return this.deps.Logger.info({ message: "Prerequisites ok", ...this.base });
 
     for (const failure of failed) {
-      this.deps.logger.error({
+      this.deps.Logger.error({
         message: "Prerequisite failed",
         metadata: { label: failure.prerequisite.label, kind: failure.prerequisite.kind },
         // @ts-expect-error

package/src/remote-file-storage-noop.adapter.ts

@@ -8,20 +8,24 @@ import type {
   RemotePutFromPathResult,
 } from "./remote-file-storage.port";
 
-type RemoteFileStorageNoopConfig = { Logger: LoggerPort; Clock: ClockPort; publicBaseUrl?: string };
+type RemoteFileStorageNoopConfig = { publicBaseUrl?: string };
+type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
 
 export class RemoteFileStorageNoopAdapter implements RemoteFileStoragePort {
   private readonly base = { component: "infra", operation: "RemoteFileStorageNoopAdapter" };
 
-  constructor(private readonly config: RemoteFileStorageNoopConfig) {}
+  constructor(
+    private readonly deps: Dependencies,
+    private readonly config?: RemoteFileStorageNoopConfig,
+  ) {}
 
   publicUrl(key: tools.ObjectKeyType): string {
-    if (!this.config.publicBaseUrl) return `/${key}`;
-    return `${this.config.publicBaseUrl}/${key}`;
+    if (!this.config?.publicBaseUrl) return `/${key}`;
+    return `${this.config?.publicBaseUrl}/${key}`;
   }
 
   async putFromPath(input: RemotePutFromPathInput): Promise<RemotePutFromPathResult> {
-    this.config.Logger.info({
+    this.deps.Logger.info({
       message: "[NOOP] RemoteFileStorageNoopAdapter putFromPath",
       metadata: { input },
       ...this.base,
@@ -30,13 +34,13 @@ export class RemoteFileStorageNoopAdapter implements RemoteFileStoragePort {
     return {
       etag: "noop",
       size: tools.Size.fromBytes(10),
-      lastModified: this.config.Clock.now(),
+      lastModified: this.deps.Clock.now(),
       mime: new tools.Mime("text/plain"),
     };
   }
 
   async head(key: tools.ObjectKeyType): Promise<RemoteHeadResult> {
-    this.config.Logger.info({
+    this.deps.Logger.info({
       message: "[NOOP] RemoteFileStorageNoopAdapter head",
       metadata: { key },
       ...this.base,
@@ -46,7 +50,7 @@ export class RemoteFileStorageNoopAdapter implements RemoteFileStoragePort {
   }
 
   async getStream(key: tools.ObjectKeyType): Promise<ReadableStream | null> {
-    this.config.Logger.info({
+    this.deps.Logger.info({
       message: "[NOOP] RemoteFileStorageNoopAdapter getStream",
       metadata: { key },
       ...this.base,
@@ -56,7 +60,7 @@ export class RemoteFileStorageNoopAdapter implements RemoteFileStoragePort {
   }
 
   async delete(key: tools.ObjectKeyType): Promise<void> {
-    this.config.Logger.info({
+    this.deps.Logger.info({
       message: "[NOOP] RemoteFileStorageNoopAdapter delete",
       metadata: { key },
       ...this.base,

package/src/shield-rate-limit.middleware.ts

@@ -7,6 +7,7 @@ import type { RateLimitStorePort } from "./rate-limit-store.port";
 
 type SubjectResolver = (c: Context) => string;
 type RateLimitShieldOptionsType = { enabled: boolean; store: RateLimitStorePort; subject: SubjectResolver };
+
 type Dependencies = { Clock: ClockPort };
 
 export const AnonSubjectResolver: SubjectResolver = () => "anon";

package/src/timekeeper-noop.adapter.ts

@@ -1,10 +1,12 @@
 import type { ClockPort } from "./clock.port";
 import type { TimekeeperPort } from "./timekeeper.port";
 
+type Dependencies = { Clock: ClockPort };
+
 export class TimekeeperNoopAdapter implements TimekeeperPort {
-  constructor(private readonly clock: ClockPort) {}
+  constructor(private readonly deps: Dependencies) {}
 
   async get() {
-    return this.clock.now();
+    return this.deps.Clock.now();
   }
 }

package/src/translations.service.ts

@@ -6,6 +6,7 @@ import type { LoggerPort } from "./logger.port";
 const handler = createFactory();
 
 type Config = TranslationsSupportedLanguagesType;
+
 type Dependencies = { JsonFileReader: JsonFileReaderPort; Logger: LoggerPort };
 
 export class Translations {