@bgord/bun 1.2.5 → 1.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -27,9 +27,9 @@
     "@types/lodash": "4.17.21",
     "@types/nodemailer": "7.0.4",
     "@types/yazl": "3.3.0",
-    "cspell": "9.3.2",
+    "cspell": "9.4.0",
     "knip": "5.71.0",
-    "lefthook": "2.0.4",
+    "lefthook": "2.0.7",
     "only-allow": "1.2.2",
     "shellcheck": "4.1.0",
     "typescript": "5.9.3",
@@ -37,14 +37,16 @@
   },
   "dependencies": {
     "@axiomhq/winston": "1.3.1",
-    "@bgord/tools": "1.1.8",
-    "@hono/ua-blocker": "0.1.19",
-    "better-auth": "1.4.4",
+    "@bgord/tools": "1.1.11",
+    "@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.7",
+    "isomorphic-dompurify": "2.33.0",
     "lodash": "4.17.21",
+    "marked": "17.0.1",
     "node-cache": "5.1.2",
     "nodemailer": "7.0.11",
     "sharp": "0.34.5",

package/readme.md

@@ -50,6 +50,9 @@ src/
 ├── command-envelope.ts
 ├── command-logger.service.ts
 ├── command.types.ts
+├── content-hash-noop.adapter.ts
+├── content-hash-sha256-bun.adapter.ts
+├── content-hash.port.ts
 ├── context.middleware.ts
 ├── correlation-id.vo.ts
 ├── correlation-storage.service.ts
@@ -148,6 +151,9 @@ src/
 ├── mailer-smtp.adapter.ts
 ├── mailer.port.ts
 ├── mailer.vo.ts
+├── markdown-generator-marked.adapter.ts
+├── markdown-generator-noop.adapter.ts
+├── markdown-generator.port.ts
 ├── memory-consumption.service.ts
 ├── modules
 │   ├── history
@@ -194,6 +200,7 @@ src/
 │   ├── clock-drift.ts
 │   ├── dependency-vulnerabilities.ts
 │   ├── directory.ts
+│   ├── dns.ts
 │   ├── external-api.ts
 │   ├── jobs.ts
 │   ├── log-file.ts

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/content-hash-noop.adapter.ts

@@ -0,0 +1,7 @@
+import type { ContentHashPort } from "./content-hash.port";
+
+export class ContentHashNoopAdapter implements ContentHashPort {
+  async hash(_content: string) {
+    return { etag: "noop" };
+  }
+}

package/src/content-hash-sha256-bun.adapter.ts

@@ -0,0 +1,10 @@
+import type { ContentHashPort } from "./content-hash.port";
+
+export class ContentHashSha256BunAdapter implements ContentHashPort {
+  async hash(content: string) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(content));
+    const etag = Buffer.from(digest).toString("hex");
+
+    return { etag };
+  }
+}

package/src/content-hash.port.ts

@@ -0,0 +1,5 @@
+export type ContentHashResult = { etag: string };
+
+export interface ContentHashPort {
+  hash(content: string): Promise<ContentHashResult>;
+}

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/index.ts

@@ -23,6 +23,9 @@ export * from "./clock-system.adapter";
 export * from "./command.types";
 export * from "./command-envelope";
 export * from "./command-logger.service";
+export * from "./content-hash.port";
+export * from "./content-hash-noop.adapter";
+export * from "./content-hash-sha256-bun.adapter";
 export * from "./context.middleware";
 export * from "./correlation-id.vo";
 export * from "./correlation-storage.service";
@@ -124,6 +127,9 @@ export * from "./mailer.vo";
 export * from "./mailer-noop.adapter";
 export * from "./mailer-smtp.adapter";
 export * from "./mailer-smtp-with-logger.adapter";
+export * from "./markdown-generator.port";
+export * from "./markdown-generator-marked.adapter";
+export * from "./markdown-generator-noop.adapter";
 export * from "./memory-consumption.service";
 export * as History from "./modules/history";
 export * as Preferences from "./modules/preferences";

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/markdown-generator-marked.adapter.ts

@@ -0,0 +1,15 @@
+import DOMPurify from "isomorphic-dompurify";
+import { Marked } from "marked";
+import type { MarkdownGeneratorPort } from "./markdown-generator.port";
+
+export class MarkdownGeneratorMarkedAdapter implements MarkdownGeneratorPort {
+  private readonly instance: Marked;
+
+  constructor() {
+    this.instance = new Marked();
+  }
+
+  async generate(content: string) {
+    return DOMPurify.sanitize(await this.instance.parse(content));
+  }
+}

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

@@ -0,0 +1,7 @@
+import type { MarkdownGeneratorPort } from "./markdown-generator.port";
+
+export class MarkdownGeneratorNoopAdapter implements MarkdownGeneratorPort {
+  async generate(_content: string) {
+    return "<p>noop</p>";
+  }
+}

package/src/markdown-generator.port.ts

@@ -0,0 +1,3 @@
+export abstract class MarkdownGeneratorPort {
+  abstract generate(input: string): Promise<string>;
+}

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/dns.ts

@@ -0,0 +1,36 @@
+import dns from "dns/promises";
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
+import * as prereqs from "../prerequisites.service";
+import { Timeout } from "../timeout.service";
+
+export class PrerequisiteDNS implements prereqs.Prerequisite {
+  readonly kind = "dns";
+  readonly label: prereqs.PrerequisiteLabelType;
+  readonly enabled?: boolean = true;
+
+  private readonly hostname: string;
+  readonly timeout: tools.Duration;
+
+  constructor(config: prereqs.PrerequisiteConfigType & { hostname: string; timeout?: tools.Duration }) {
+    this.label = config.label;
+    this.enabled = config.enabled === undefined ? true : config.enabled;
+
+    this.hostname = config.hostname;
+    this.timeout = config.timeout ?? tools.Duration.Seconds(1);
+  }
+
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
+
+    try {
+      await Timeout.run(dns.lookup(this.hostname), this.timeout);
+
+      return prereqs.Verification.success(stopwatch.stop());
+    } catch (error) {
+      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
+    }
+  }
+}

package/src/prerequisites/index.ts

@@ -3,6 +3,7 @@ export * from "./bun";
 export * from "./clock-drift";
 export * from "./dependency-vulnerabilities";
 export * from "./directory";
+export * from "./dns";
 export * from "./external-api";
 export * from "./jobs";
 export * from "./log-file";

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);