@bgord/bun 0.30.1 → 1.0.0

package/src/prerequisites/translations.ts

@@ -1,11 +1,14 @@
 import { constants } from "node:fs";
 import fsp from "node:fs/promises";
 import type * as tools from "@bgord/tools";
-import * as i18n from "../i18n.service";
+import type * as types from "../i18n.service";
+import { I18n } from "../i18n.service";
+import type { JsonFileReaderPort } from "../json-file-reader.port";
+import type { LoggerPort } from "../logger.port";
 import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteTranslationsProblemType = {
-  key: i18n.TranslationsKeyType;
+  key: types.TranslationsKeyType;
   existsIn: tools.LanguageType;
   missingIn: tools.LanguageType;
 };
@@ -15,13 +18,18 @@ export class PrerequisiteTranslations implements prereqs.Prerequisite {
   readonly label: prereqs.PrerequisiteLabelType;
   readonly enabled?: boolean = true;
 
-  private readonly translationsPath?: typeof i18n.I18n.DEFAULT_TRANSLATIONS_PATH;
-  private readonly supportedLanguages: i18n.I18nConfigType["supportedLanguages"];
+  private readonly translationsPath?: typeof I18n.DEFAULT_TRANSLATIONS_PATH;
+  private readonly supportedLanguages: types.I18nConfigType["supportedLanguages"];
+
+  private readonly Logger: LoggerPort;
+  private readonly JsonFileReader: JsonFileReaderPort;
 
   constructor(
     config: prereqs.PrerequisiteConfigType & {
-      translationsPath?: typeof i18n.I18n.DEFAULT_TRANSLATIONS_PATH;
-      supportedLanguages: i18n.I18nConfigType["supportedLanguages"];
+      translationsPath?: typeof I18n.DEFAULT_TRANSLATIONS_PATH;
+      supportedLanguages: types.I18nConfigType["supportedLanguages"];
+      Logger: LoggerPort;
+      JsonFileReader: JsonFileReaderPort;
     },
   ) {
     this.label = config.label;
@@ -29,51 +37,55 @@ export class PrerequisiteTranslations implements prereqs.Prerequisite {
 
     this.translationsPath = config.translationsPath;
     this.supportedLanguages = config.supportedLanguages;
+
+    this.Logger = config.Logger;
+    this.JsonFileReader = config.JsonFileReader;
   }
 
   async verify(): Promise<prereqs.VerifyOutcome> {
     if (!this.enabled) return prereqs.Verification.undetermined();
 
-    const translationsPath = this.translationsPath ?? i18n.I18n.DEFAULT_TRANSLATIONS_PATH;
+    const translationsPath = this.translationsPath ?? I18n.DEFAULT_TRANSLATIONS_PATH;
+
+    const supportedLanguages = Object.keys(this.supportedLanguages);
+    const i18n = new I18n({ Logger: this.Logger, JsonFileReader: this.JsonFileReader });
 
     try {
       await fsp.access(translationsPath, constants.R_OK);
 
-      for (const language in this.supportedLanguages) {
-        await fsp.access(new i18n.I18n().getTranslationPathForLanguage(language).get(), constants.R_OK);
+      for (const language in supportedLanguages) {
+        await fsp.access(i18n.getTranslationPathForLanguage(language).get(), constants.R_OK);
       }
     } catch (error) {
       return prereqs.Verification.failure(error as Error);
     }
 
-    const supportedLanguages = Object.keys(this.supportedLanguages);
-
     if (supportedLanguages.length === 1) return prereqs.Verification.success();
 
-    const languageToTranslationKeys: Record<tools.LanguageType, i18n.TranslationsKeyType[]> = {};
+    const languageToTranslationKeys: Record<tools.LanguageType, types.TranslationsKeyType[]> = {};
 
     const problems: PrerequisiteTranslationsProblemType[] = [];
 
     for (const language of supportedLanguages) {
-      const translations = await new i18n.I18n().getTranslations(language);
+      const translations = await i18n.getTranslations(language);
       const translationKeys = Object.keys(translations);
 
       languageToTranslationKeys[language] = translationKeys;
     }
 
-    for (const currentLanguage in languageToTranslationKeys) {
-      const translationKeys = languageToTranslationKeys[currentLanguage] ?? [];
+    for (const language in languageToTranslationKeys) {
+      const translationKeys = languageToTranslationKeys[language] ?? [];
 
       for (const translationKey of translationKeys) {
         for (const supportedLanguage of supportedLanguages) {
-          if (supportedLanguage === currentLanguage) continue;
+          if (supportedLanguage === language) continue;
 
           const translationKeyExists = languageToTranslationKeys[supportedLanguage]?.some(
             (key) => translationKey === key,
           );
 
           if (!translationKeyExists) {
-            problems.push({ key: translationKey, existsIn: currentLanguage, missingIn: supportedLanguage });
+            problems.push({ key: translationKey, existsIn: language, missingIn: supportedLanguage });
           }
         }
       }

package/src/prerequisites.service.ts

@@ -48,6 +48,8 @@ export class Verification {
 
 export type PrerequisiteConfigType = { label: string; enabled?: boolean };
 
+export const PrerequisitesError = { Failure: "prerequisites.failure" } as const;
+
 /** @public */
 export class Prerequisites {
   private readonly base = { component: "infra", operation: "startup" };
@@ -61,9 +63,7 @@ export class Prerequisites {
 
     const failed = results.filter((result) => result.outcome.status === PrerequisiteStatusEnum.failure);
 
-    if (failed.length === 0) {
-      return this.logger.info({ message: "Prerequisites ok", ...this.base });
-    }
+    if (failed.length === 0) return this.logger.info({ message: "Prerequisites ok", ...this.base });
 
     for (const failure of failed) {
       this.logger.error({
@@ -75,6 +75,6 @@ export class Prerequisites {
       });
     }
 
-    throw new Error("Prerequisites failed");
+    throw new Error(PrerequisitesError.Failure);
   }
 }

package/src/rate-limit-store-node-cache.adapter.ts

@@ -1,8 +1,8 @@
 import type * as tools from "@bgord/tools";
 import NodeCache from "node-cache";
-import type { RateLimitStore, RateLimitStoreSubjectType } from "./rate-limit-store.port";
+import type { RateLimitStorePort, RateLimitStoreSubjectType } from "./rate-limit-store.port";
 
-export class RateLimitStoreNodeCache implements RateLimitStore {
+export class RateLimitStoreNodeCacheAdapter implements RateLimitStorePort {
   private readonly store: NodeCache;
 
   constructor(readonly ttl: tools.Duration) {

package/src/rate-limit-store.port.ts

@@ -2,7 +2,7 @@ import type * as tools from "@bgord/tools";
 
 export type RateLimitStoreSubjectType = string;
 
-export interface RateLimitStore {
+export interface RateLimitStorePort {
   readonly ttl: tools.Duration;
   get(subject: RateLimitStoreSubjectType): Promise<tools.RateLimiter | undefined>;
   set(subject: RateLimitStoreSubjectType, limiter: tools.RateLimiter): Promise<void>;

package/src/recaptcha-secret-key.vo.ts

@@ -0,0 +1,13 @@
+import { z } from "zod/v4";
+
+export const RecaptchaSecretKeyError = {
+  Type: "recaptcha.secret.key.type",
+  Length: "recaptcha.secret.key.length",
+} as const;
+
+export const RecaptchaSecretKey = z
+  .string(RecaptchaSecretKeyError.Type)
+  .length(40, RecaptchaSecretKeyError.Length)
+  .brand("RecaptchaSecretKey");
+
+export type RecaptchaSecretKeyType = z.infer<typeof RecaptchaSecretKey>;

package/src/recaptcha-site-key.vo.ts

@@ -0,0 +1,13 @@
+import { z } from "zod/v4";
+
+export const RecaptchaSiteKeyError = {
+  Type: "recaptcha.site.key.type",
+  Length: "recaptcha.site.key.length",
+} as const;
+
+export const RecaptchaSiteKey = z
+  .string(RecaptchaSiteKeyError.Type)
+  .length(40, RecaptchaSiteKeyError.Length)
+  .brand("RecaptchaSiteKey");
+
+export type RecaptchaSiteKeyType = z.infer<typeof RecaptchaSiteKey>;

package/src/redactor-encrypt.adapter.ts

@@ -15,8 +15,8 @@ export class RedactorEncryptionAdapter implements RedactorPort {
   redact<T>(input: T): T {
     const rootObject = Object(input);
 
-    return cloneDeepWith(input, (value, key, parentObj) => {
-      if (parentObj === rootObject && typeof key === "string" && key.toLowerCase() === this.key) {
+    return cloneDeepWith(input, (value, key, parent) => {
+      if (parent === rootObject && typeof key === "string" && key.toLowerCase() === this.key) {
         const iv = randomBytes(12);
         const cipher = createCipheriv("aes-256-gcm", this.secret, iv);
         const plaintext = Buffer.from(JSON.stringify(value), "utf8");

package/src/redactor-mask.adapter.ts

@@ -3,7 +3,6 @@ import type { RedactorPort } from "./redactor.port";
 
 export class RedactorMaskAdapter implements RedactorPort {
   static readonly DEFAULT_KEYS: readonly string[] = [
-    // auth & cookies
     "authorization",
     "cookie",
     "set-cookie",
@@ -13,7 +12,6 @@ export class RedactorMaskAdapter implements RedactorPort {
     "accessToken",
     "refreshToken",
 
-    // passwords & secrets
     "password",
     "currentPassword",
     "newPassword",
@@ -21,7 +19,6 @@ export class RedactorMaskAdapter implements RedactorPort {
     "clientSecret",
     "secret",
 
-    // one-time codes
     "otp",
     "code",
   ];

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

@@ -1,6 +1,8 @@
 import fs from "node:fs/promises";
 import * as tools from "@bgord/tools";
+import type { FileCleanerPort } from "./file-cleaner.port";
 import type { FileHashPort } from "./file-hash.port";
+import type { FileRenamerPort } from "./file-renamer.port";
 import type {
   RemoteFileStoragePort,
   RemoteHeadResult,
@@ -8,14 +10,15 @@ import type {
   RemotePutFromPathResult,
 } from "./remote-file-storage.port";
 
-type RemoteFileStorageDiskConfig = {
-  root: tools.DirectoryPathAbsoluteType;
-  hasher: FileHashPort;
-  publicBaseUrl?: string;
-};
+type RemoteFileStorageDiskConfig = { root: tools.DirectoryPathAbsoluteType; publicBaseUrl?: string };
+
+type Dependencies = { FileHash: FileHashPort; FileCleaner: FileCleanerPort; FileRenamer: FileRenamerPort };
 
 export class RemoteFileStorageDiskAdapter implements RemoteFileStoragePort {
-  constructor(private readonly config: RemoteFileStorageDiskConfig) {}
+  constructor(
+    private readonly config: RemoteFileStorageDiskConfig,
+    private readonly deps: Dependencies,
+  ) {}
 
   private resolveKeyToAbsoluteFilePath(key: tools.ObjectKeyType): tools.FilePathAbsolute {
     const parts = key.split("/");
@@ -39,16 +42,16 @@ export class RemoteFileStorageDiskAdapter implements RemoteFileStoragePort {
 
     const source = Bun.file(input.path.get());
     await Bun.write(temporary.get(), source);
-    await fs.rename(temporary.get(), final.get());
+    await this.deps.FileRenamer.rename(temporary, final);
 
-    return this.config.hasher.hash(final);
+    return this.deps.FileHash.hash(final);
   }
 
   async head(key: tools.ObjectKeyType): Promise<RemoteHeadResult> {
     const path = this.resolveKeyToAbsoluteFilePath(key);
 
     try {
-      return { exists: true, ...(await this.config.hasher.hash(path)) };
+      return { exists: true, ...(await this.deps.FileHash.hash(path)) };
     } catch {
       return { exists: false };
     }
@@ -65,10 +68,6 @@ export class RemoteFileStorageDiskAdapter implements RemoteFileStoragePort {
   }
 
   async delete(key: tools.ObjectKeyType): Promise<void> {
-    const path = this.resolveKeyToAbsoluteFilePath(key);
-
-    try {
-      await fs.unlink(path.get());
-    } catch (error) {}
+    await this.deps.FileCleaner.delete(this.resolveKeyToAbsoluteFilePath(key));
   }
 }

package/src/safe-parse-body.service.ts

@@ -3,7 +3,8 @@ import type hono from "hono";
 export async function safeParseBody(c: hono.Context): Promise<any> {
   try {
     const rawBody = await c.req.text();
-    if (!rawBody.trim()) return {}; // handles truly empty body
+
+    if (!rawBody.trim()) return {};
     return JSON.parse(rawBody);
   } catch {
     return {};

package/src/setup.service.ts

@@ -15,6 +15,7 @@ import { ETagExtractor } from "./etag-extractor.middleware";
 import { HttpLogger, type HttpLoggerOptions } from "./http-logger.middleware";
 import type { I18nConfigType } from "./i18n.service";
 import type { IdProviderPort } from "./id-provider.port";
+import type { JsonFileReaderPort } from "./json-file-reader.port";
 import type { LoggerPort } from "./logger.port";
 import { TimeZoneOffset } from "./time-zone-offset.middleware";
 import { WeakETagExtractor } from "./weak-etag-extractor.middleware";
@@ -32,6 +33,7 @@ type Dependencies = {
   IdProvider: IdProviderPort;
   I18n: I18nConfigType;
   Clock: ClockPort;
+  JsonFileReader: JsonFileReaderPort;
 };
 
 export class Setup {
@@ -43,7 +45,7 @@ export class Setup {
       secureHeaders(secureHeadersOptions),
       bodyLimit({ maxSize: BODY_LIMIT_MAX_SIZE }),
       uaBlocker({ blocklist: BOTS_REGEX }),
-      ApiVersion.build({ Clock: deps.Clock }),
+      ApiVersion.build({ Clock: deps.Clock, JsonFileReader: deps.JsonFileReader }),
       cors(corsOptions),
       languageDetector({
         supportedLanguages: Object.keys(deps.I18n.supportedLanguages),

package/src/shield-api-key.middleware.ts

@@ -12,9 +12,7 @@ export class ShieldApiKey {
   constructor(private readonly config: ApiKeyShieldConfigType) {}
 
   verify = createMiddleware(async (c, next) => {
-    if (c.req.header(ShieldApiKey.HEADER_NAME) === this.config.API_KEY) {
-      return next();
-    }
+    if (c.req.header(ShieldApiKey.HEADER_NAME) === this.config.API_KEY) return next();
 
     throw AccessDeniedApiKeyError;
   });

package/src/shield-auth.middleware.ts

@@ -5,9 +5,7 @@ import type hono from "hono";
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
 
-export const AccessDeniedAuthShieldError = new HTTPException(403, {
-  message: "access_denied_auth_shield",
-});
+export const AccessDeniedAuthShieldError = new HTTPException(403, { message: "access_denied_auth_shield" });
 
 export class ShieldAuth {
   cors = {
@@ -25,22 +23,26 @@ export class ShieldAuth {
     if (!session) {
       c.set("user", null);
       c.set("session", null);
+
       return next();
     }
 
     c.set("user", session.user);
     c.set("session", session.session);
+
     return next();
   });
 
   verify = createMiddleware(async (c: hono.Context, next: hono.Next) => {
     const user = c.get("user");
+
     if (!user) throw AccessDeniedAuthShieldError;
     return next();
   });
 
   reverse = createMiddleware(async (c: hono.Context, next: hono.Next) => {
     const user = c.get("user");
+
     if (user) throw AccessDeniedAuthShieldError;
     return next();
   });

package/src/shield-captcha-hcaptcha-local.adapter.ts

@@ -1,22 +1,23 @@
 import hcaptcha from "hcaptcha";
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
+import type { HCaptchaSecretKeyType } from "./hcaptcha-secret-key.vo";
 import type { ShieldCaptchaPort } from "./shield-captcha.port";
-import type { HCaptchaSecretKeyType } from "./shield-captcha-hcaptcha.adapter";
 
 export const AccessDeniedHcaptchaLocalError = new HTTPException(403, {
   message: "access_denied_hcaptcha_local",
 });
 
-export class ShieldCaptchaHcaptchaLocal implements ShieldCaptchaPort {
+export class ShieldCaptchaHcaptchaLocalAdapter implements ShieldCaptchaPort {
   constructor(private readonly secretKey: HCaptchaSecretKeyType) {}
 
   verify = createMiddleware(async (_c, next) => {
     try {
       const result = await hcaptcha.verify(this.secretKey, "10000000-aaaa-bbbb-cccc-000000000001");
+
       if (!result?.success) throw AccessDeniedHcaptchaLocalError;
       return next();
-    } catch (_error) {
+    } catch {
       throw AccessDeniedHcaptchaLocalError;
     }
   });

package/src/shield-captcha-hcaptcha.adapter.ts

@@ -1,31 +1,23 @@
 import hcaptcha from "hcaptcha";
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
-import { z } from "zod/v4";
+import type { HCaptchaSecretKeyType } from "./hcaptcha-secret-key.vo";
 import type { ShieldCaptchaPort } from "./shield-captcha.port";
 
-export const HCaptchaSecretKey = z.string().trim().length(42).brand("HCaptchaSecretKey");
-export type HCaptchaSecretKeyType = z.infer<typeof HCaptchaSecretKey>;
-
-export const HCaptchaSiteKey = z.string().trim().length(36);
-export type HCaptchaSiteKeyType = z.infer<typeof HCaptchaSiteKey>;
-
-export const HCaptchaResponseToken = z.string().trim();
-export type HCaptchaResponseTokenType = z.infer<typeof HCaptchaResponseToken>;
-
 export const AccessDeniedHcaptchaError = new HTTPException(403, { message: "access_denied_hcaptcha" });
 
-export class ShieldCaptchaHcaptcha implements ShieldCaptchaPort {
+export class ShieldCaptchaHcaptchaAdapter implements ShieldCaptchaPort {
   constructor(private readonly secretKey: HCaptchaSecretKeyType) {}
 
   verify = createMiddleware(async (c, next) => {
     try {
       const form = await c.req.formData();
-      const hcaptchaTokenFormData = form.get("h-captcha-response")?.toString() as HCaptchaResponseTokenType;
+      const hcaptchaTokenFormData = form.get("h-captcha-response")?.toString() as string;
       const result = await hcaptcha.verify(this.secretKey, hcaptchaTokenFormData);
+
       if (!result?.success) throw AccessDeniedHcaptchaError;
       return next();
-    } catch (_error) {
+    } catch {
       throw AccessDeniedHcaptchaError;
     }
   });

package/src/shield-captcha-noop.adapter.ts

@@ -1,6 +1,6 @@
 import { createMiddleware } from "hono/factory";
 import type { ShieldCaptchaPort } from "./shield-captcha.port";
 
-export class ShieldCaptchaNoop implements ShieldCaptchaPort {
+export class ShieldCaptchaNoopAdapter implements ShieldCaptchaPort {
   verify = createMiddleware(async (_c, next) => next());
 }

package/src/shield-captcha-recaptcha.adapter.ts

@@ -1,42 +1,30 @@
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
-import { z } from "zod/v4";
+import type { RecaptchaSecretKeyType } from "./recaptcha-secret-key.vo";
 import type { ShieldCaptchaPort } from "./shield-captcha.port";
 
-export const RecaptchaSiteKey = z.string().trim().length(40);
-export type RecaptchaSiteKeyType = z.infer<typeof RecaptchaSiteKey>;
-
-export const RecaptchaSecretKey = z.string().trim().length(40).brand("RecaptchaSecretKey");
-export type RecaptchaSecretKeyType = z.infer<typeof RecaptchaSecretKey>;
-
 export type RecaptchaVerifierConfigType = { secretKey: RecaptchaSecretKeyType };
 export type RecaptchaResultType = { success: boolean; score: number };
 
 export const AccessDeniedRecaptchaError = new HTTPException(403, { message: "access_denied_recaptcha" });
 
-export class ShieldCaptchaRecaptcha implements ShieldCaptchaPort {
-  private readonly secretKey: RecaptchaVerifierConfigType["secretKey"];
-
-  constructor(config: RecaptchaVerifierConfigType) {
-    this.secretKey = config.secretKey;
-  }
+export class ShieldCaptchaRecaptchaAdapter implements ShieldCaptchaPort {
+  constructor(private readonly config: RecaptchaVerifierConfigType) {}
 
   verify = createMiddleware(async (c, next) => {
     try {
-      const recaptchaTokenHeader = c.req.header("x-recaptcha-token");
-      const recaptchaTokenQuery = c.req.query("recaptchaToken");
+      const header = c.req.header("x-recaptcha-token");
+      const query = c.req.query("recaptchaToken");
+      const form = (await c.req.formData()).get("g-recaptcha-response")?.toString();
 
-      const form = await c.req.formData();
-      const recaptchaTokenFormData = form.get("g-recaptcha-response")?.toString();
-
-      const xForwardedForHeader = c.req.header("x-forwarded-for");
-      // cSpell:ignore remoteip
-      const remoteip = xForwardedForHeader ?? "";
+      const token = header ?? query ?? form;
 
-      const token = recaptchaTokenHeader ?? recaptchaTokenQuery ?? recaptchaTokenFormData;
       if (!token) throw AccessDeniedRecaptchaError;
 
-      const params = new URLSearchParams({ secret: this.secretKey, response: token, remoteip });
+      // cSpell:ignore remoteip
+      const remoteip = c.req.header("x-forwarded-for") ?? "";
+
+      const params = new URLSearchParams({ secret: this.config.secretKey, response: token, remoteip });
 
       const response = await fetch("https://www.google.com/recaptcha/api/siteverify", {
         method: "POST",
@@ -44,10 +32,12 @@ export class ShieldCaptchaRecaptcha implements ShieldCaptchaPort {
         body: params,
       });
 
-      const result = (await response.json()) as RecaptchaResultType;
+      const result: RecaptchaResultType = await response.json();
+
       if (!result.success || result.score < 0.5) throw AccessDeniedRecaptchaError;
+
       await next();
-    } catch (_error) {
+    } catch {
       throw AccessDeniedRecaptchaError;
     }
   });

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

@@ -3,10 +3,10 @@ import type { Context } from "hono";
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
 import type { ClockPort } from "./clock.port";
-import type { RateLimitStore } from "./rate-limit-store.port";
+import type { RateLimitStorePort } from "./rate-limit-store.port";
 
 type SubjectResolver = (c: Context) => string;
-type RateLimitShieldOptionsType = { enabled: boolean; store: RateLimitStore; subject: SubjectResolver };
+type RateLimitShieldOptionsType = { enabled: boolean; store: RateLimitStorePort; subject: SubjectResolver };
 type Dependencies = { Clock: ClockPort };
 
 export const AnonSubjectResolver: SubjectResolver = () => "anon";

package/src/slower.middleware.ts

@@ -5,6 +5,7 @@ export class Slower {
   static handle = (offset: tools.Duration) =>
     createMiddleware(async (_c, next) => {
       await Bun.sleep(offset.ms);
+
       return next();
     });
 }

package/src/temporary-file-absolute.adapter.ts

@@ -1,25 +1,27 @@
-import fs from "node:fs/promises";
 import * as tools from "@bgord/tools";
+import type { FileCleanerPort } from "./file-cleaner.port";
+import type { FileRenamerPort } from "./file-renamer.port";
 import type { TemporaryFilePort } from "./temporary-file.port";
 
-export class TemporaryFileAbsolute implements TemporaryFilePort {
-  constructor(private readonly directory: tools.DirectoryPathAbsoluteType) {}
+type Dependencies = { FileCleaner: FileCleanerPort; FileRenamer: FileRenamerPort };
 
-  async write(filename: tools.Filename, data: File) {
-    const partPath = tools.FilePathAbsolute.fromPartsSafe(this.directory, filename.withSuffix("-part"));
-    const finalPath = tools.FilePathAbsolute.fromPartsSafe(this.directory, filename);
+export class TemporaryFileAbsoluteAdapter implements TemporaryFilePort {
+  constructor(
+    private readonly directory: tools.DirectoryPathAbsoluteType,
+    private readonly deps: Dependencies,
+  ) {}
 
-    await Bun.write(partPath.get(), data);
-    await fs.rename(partPath.get(), finalPath.get());
+  async write(filename: tools.Filename, content: File) {
+    const temporary = tools.FilePathAbsolute.fromPartsSafe(this.directory, filename.withSuffix("-part"));
+    const final = tools.FilePathAbsolute.fromPartsSafe(this.directory, filename);
 
-    return { path: finalPath };
+    await Bun.write(temporary.get(), content);
+    await this.deps.FileRenamer.rename(temporary, final);
+
+    return { path: final };
   }
 
   async cleanup(filename: tools.Filename) {
-    const path = tools.FilePathAbsolute.fromPartsSafe(this.directory, filename);
-
-    try {
-      await fs.unlink(path.get());
-    } catch (error) {}
+    await this.deps.FileCleaner.delete(tools.FilePathAbsolute.fromPartsSafe(this.directory, filename));
   }
 }

package/src/temporary-file-noop.adapter.ts

@@ -1,7 +1,7 @@
 import * as tools from "@bgord/tools";
 import type { TemporaryFilePort } from "./temporary-file.port";
 
-export class TemporaryFileNoop implements TemporaryFilePort {
+export class TemporaryFileNoopAdapter implements TemporaryFilePort {
   constructor(private readonly directory: tools.DirectoryPathAbsoluteType) {}
 
   async write(filename: tools.Filename) {

package/src/temporary-file.port.ts

@@ -1,6 +1,7 @@
 import type * as tools from "@bgord/tools";
 
 export interface TemporaryFilePort {
-  write(filename: tools.Filename, data: File): Promise<{ path: tools.FilePathAbsolute }>;
+  write(filename: tools.Filename, content: File): Promise<{ path: tools.FilePathAbsolute }>;
+
   cleanup(filename: tools.Filename): Promise<void>;
 }

package/src/time-zone-offset.middleware.ts

@@ -7,11 +7,8 @@ export class TimeZoneOffset {
   static TIME_ZONE_OFFSET_HEADER_NAME = "time-zone-offset";
 
   static attach = createMiddleware(async (c, next) => {
-    const timeZoneOffsetMinutes = tools.TimeZoneOffsetValue.parse(
-      c.req.header(TimeZoneOffset.TIME_ZONE_OFFSET_HEADER_NAME),
-    );
-
-    c.set("timeZoneOffset", tools.Duration.Minutes(timeZoneOffsetMinutes));
+    const offset = tools.TimeZoneOffsetValue.parse(c.req.header(TimeZoneOffset.TIME_ZONE_OFFSET_HEADER_NAME));
+    c.set("timeZoneOffset", tools.Duration.Minutes(offset));
 
     await next();
   });

package/src/translations.service.ts

@@ -1,14 +1,17 @@
-import type * as tools from "@bgord/tools";
 import { createFactory } from "hono/factory";
 import { I18n } from "./i18n.service";
+import type { JsonFileReaderPort } from "./json-file-reader.port";
+import type { LoggerPort } from "./logger.port";
 
 const handler = createFactory();
 
+type Dependencies = { JsonFileReader: JsonFileReaderPort; Logger: LoggerPort };
+
 export class Translations {
-  static build = () =>
+  static build = (deps: Dependencies) =>
     handler.createHandlers(async (c) => {
-      const language = c.get("language") as tools.LanguageType;
-      const translations = await new I18n().getTranslations(language);
+      const language = c.get("language");
+      const translations = await new I18n(deps).getTranslations(language);
 
       return c.json({ translations, language });
     });

package/src/uptime.service.ts

@@ -10,9 +10,9 @@ export class Uptime {
   private static readonly rounding = new tools.RoundToNearest();
 
   static get(clock: ClockPort): UptimeResultType {
-    const uptime = tools.Duration.Seconds(Uptime.rounding.round(process.uptime()));
-    const uptimeFormatted = tools.DateFormatters.relative(clock.now().Minus(uptime));
+    const duration = tools.Duration.Seconds(Uptime.rounding.round(process.uptime()));
+    const formatted = tools.DateFormatters.relative(clock.now().Minus(duration));
 
-    return { duration: uptime, formatted: uptimeFormatted };
+    return { duration, formatted };
   }
 }