@bgord/bun 1.16.0 → 1.16.2

package/src/file-copier.adapter.ts

@@ -6,9 +6,7 @@ export class FileCopierAdapter implements FileCopierPort {
     source: tools.FilePathRelative | tools.FilePathAbsolute | string,
     destination: tools.FilePathRelative | tools.FilePathAbsolute | string,
   ): Promise<void> {
-    // Stryker disable all
     const file = Bun.file(typeof source === "string" ? source : source.get());
-    // Stryker restore all
 
     await Bun.write(typeof destination === "string" ? destination : destination.get(), file);
   }

package/src/file-writer-forgiving.adapter.ts

@@ -0,0 +1,14 @@
+import type * as tools from "@bgord/tools";
+import type { FileWriterContent, FileWriterPort } from "./file-writer.port";
+
+export class FileWriterForgivingAdapter implements FileWriterPort {
+  async write(
+    path: tools.FilePathRelative | tools.FilePathAbsolute | string,
+    content: FileWriterContent,
+  ): Promise<void> {
+    try {
+      // Types are different than the runtime behavior
+      await Bun.write(typeof path === "string" ? path : path.get(), content as any);
+    } catch {}
+  }
+}

package/src/graceful-shutdown.service.ts

@@ -11,9 +11,7 @@ export class GracefulShutdown {
 
   constructor(
     private readonly deps: Dependencies,
-    // Stryker disable all
     private readonly exitFn: (code: number) => never = (code: number) => process.exit(code),
-    // Stryker restore all
   ) {}
 
   private shutdown(server: ServerType, cleanup: () => any, exitCode: number) {

package/src/image-alpha-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageAlphaPort, ImageAlphaStrategy } from "./image-alpha.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageAlphaPort; semaphore: Semaphore };
+
+export class ImageAlphaWithSemaphoreAdapter implements ImageAlphaPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async flatten(recipe: ImageAlphaStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return this.deps.semaphore.run(() => this.deps.inner.flatten(recipe));
+  }
+}

package/src/image-blur-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageBlurPort, ImageBlurStrategy } from "./image-blur.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageBlurPort; semaphore: Semaphore };
+
+export class ImageBlurWithSemaphoreAdapter implements ImageBlurPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async blur(recipe: ImageBlurStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return this.deps.semaphore.run(() => this.deps.inner.blur(recipe));
+  }
+}

package/src/image-compressor-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageCompressorPort, ImageCompressorStrategy } from "./image-compressor.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageCompressorPort; semaphore: Semaphore };
+
+export class ImageCompressorWithSemaphoreAdapter implements ImageCompressorPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async compress(recipe: ImageCompressorStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return this.deps.semaphore.run(() => this.deps.inner.compress(recipe));
+  }
+}

package/src/image-exif-clear-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageExifClearPort, ImageExifClearStrategy } from "./image-exif-clear.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageExifClearPort; semaphore: Semaphore };
+
+export class ImageExifClearWithSemaphoreAdapter implements ImageExifClearPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async clear(recipe: ImageExifClearStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return this.deps.semaphore.run(() => this.deps.inner.clear(recipe));
+  }
+}

package/src/image-formatter-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageFormatterPort, ImageFormatterStrategy } from "./image-formatter.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageFormatterPort; semaphore: Semaphore };
+
+export class ImageFormatterWithSemaphoreAdapter implements ImageFormatterPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async format(recipe: ImageFormatterStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return this.deps.semaphore.run(() => this.deps.inner.format(recipe));
+  }
+}

package/src/image-grayscale-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageGrayscalePort, ImageGrayscaleStrategy } from "./image-grayscale.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageGrayscalePort; semaphore: Semaphore };
+
+export class ImageGrayscaleWithSemaphoreAdapter implements ImageGrayscalePort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async grayscale(recipe: ImageGrayscaleStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return this.deps.semaphore.run(() => this.deps.inner.grayscale(recipe));
+  }
+}

package/src/image-info-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageInfoPort, ImageInfoType } from "./image-info.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageInfoPort; semaphore: Semaphore };
+
+export class ImageInfoWithSemaphoreAdapter implements ImageInfoPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async inspect(input: tools.FilePathRelative | tools.FilePathAbsolute): Promise<ImageInfoType> {
+    return this.deps.semaphore.run(() => this.deps.inner.inspect(input));
+  }
+}

package/src/image-processor-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageProcessorPort, ImageProcessorStrategy } from "./image-processor.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageProcessorPort; semaphore: Semaphore };
+
+export class ImageProcessorWithSemaphoreAdapter implements ImageProcessorPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async process(recipe: ImageProcessorStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return this.deps.semaphore.run(() => this.deps.inner.process(recipe));
+  }
+}

package/src/image-resizer-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageResizerPort, ImageResizerStrategy } from "./image-resizer.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageResizerPort; semaphore: Semaphore };
+
+export class ImageResizerWithSemaphoreAdapter implements ImageResizerPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async resize(recipe: ImageResizerStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return this.deps.semaphore.run(() => this.deps.inner.resize(recipe));
+  }
+}

package/src/index.ts

@@ -24,6 +24,8 @@ export * from "./alert-message.vo";
 export * from "./antivirus.port";
 export * from "./antivirus-clamav.adapter";
 export * from "./antivirus-noop.adapter";
+export * from "./antivirus-with-logger.adapter";
+export * from "./antivirus-with-semaphore.adapter";
 export * from "./api-version.middleware";
 export * from "./api-version-hono.middleware";
 export * from "./auth-session-reader.port";
@@ -70,6 +72,7 @@ export * from "./crypto-key-provider-noop.adapter";
 export * from "./crypto-key-provider-with-cache.adapter";
 export * from "./csv-stringifier.adapter";
 export * from "./csv-stringifier.port";
+export * from "./csv-stringifier-noop.adapter";
 export * from "./directory-ensurer.adapter";
 export * from "./directory-ensurer.port";
 export * from "./directory-ensurer-noop.adapter";
@@ -87,7 +90,6 @@ export * from "./environment-loader-encrypted.adapter";
 export * from "./environment-loader-noop.adapter";
 export * from "./environment-loader-process.adapter";
 export * from "./environment-loader-process-safe.adapter";
-export * from "./error-normalizer.service";
 export * from "./etag-extractor.middleware";
 export * from "./etag-extractor-hono.middleware";
 export * from "./event.types";
@@ -111,6 +113,10 @@ export * from "./event-store-dispatching.adapter";
 export * from "./event-store-noop.adapter";
 export * from "./event-store-with-logger.adapter";
 export * from "./event-stream.vo";
+export * from "./event-upcaster.port";
+export * from "./event-upcaster-chain.adapter";
+export * from "./event-upcaster-noop.adapter";
+export * from "./event-upcaster-step.vo";
 export * from "./event-validator-registry.adapter";
 export * from "./event-validator-registry.port";
 export * from "./file-cleaner.adapter";
@@ -149,6 +155,7 @@ export * from "./file-uploader.middleware";
 export * from "./file-uploader-hono.middleware";
 export * from "./file-writer.adapter";
 export * from "./file-writer.port";
+export * from "./file-writer-forgiving.adapter";
 export * from "./file-writer-noop.adapter";
 export * from "./fnv1a32.service";
 export * from "./graceful-shutdown.service";
@@ -179,30 +186,39 @@ export * from "./id-provider-deterministic.adapter";
 export * from "./image-alpha.port";
 export * from "./image-alpha-noop.adapter";
 export * from "./image-alpha-sharp.adapter";
+export * from "./image-alpha-with-semaphore.adapter";
 export * from "./image-blur.port";
 export * from "./image-blur-noop.adapter";
 export * from "./image-blur-sharp.adapter";
+export * from "./image-blur-with-semaphore.adapter";
 export * from "./image-compressor.port";
 export * from "./image-compressor-noop.adapter";
 export * from "./image-compressor-sharp.adapter";
+export * from "./image-compressor-with-semaphore.adapter";
 export * from "./image-exif-clear.port";
 export * from "./image-exif-clear-noop.adapter";
 export * from "./image-exif-clear-sharp.adapter";
+export * from "./image-exif-clear-with-semaphore.adapter";
 export * from "./image-formatter.port";
 export * from "./image-formatter-noop.adapter";
 export * from "./image-formatter-sharp.adapter";
+export * from "./image-formatter-with-semaphore.adapter";
 export * from "./image-grayscale.port";
 export * from "./image-grayscale-noop.adapter";
 export * from "./image-grayscale-sharp.adapter";
+export * from "./image-grayscale-with-semaphore.adapter";
 export * from "./image-info.port";
 export * from "./image-info-noop.adapter";
 export * from "./image-info-sharp.adapter";
+export * from "./image-info-with-semaphore.adapter";
 export * from "./image-processor.port";
 export * from "./image-processor-noop.adapter";
 export * from "./image-processor-sharp.adapter";
+export * from "./image-processor-with-semaphore.adapter";
 export * from "./image-resizer.port";
 export * from "./image-resizer-noop.adapter";
 export * from "./image-resizer-sharp.adapter";
+export * from "./image-resizer-with-semaphore.adapter";
 export * from "./in-flight-requests-hono.middleware";
 export * from "./in-flight-requests-tracker.service";
 export * from "./instrumentation.service";
@@ -320,6 +336,7 @@ export * from "./redactor-noop.strategy";
 export * from "./remote-file-storage.port";
 export * from "./remote-file-storage-disk.adapter";
 export * from "./remote-file-storage-noop.adapter";
+export * from "./remote-file-storage-with-logger.adapter";
 export * from "./request-context.port";
 export * from "./request-context-hono.adapter";
 export * from "./retry.service";
@@ -353,6 +370,7 @@ export * from "./security-rule-or.strategy";
 export * from "./security-rule-pass.strategy";
 export * from "./security-rule-user-agent.strategy";
 export * from "./security-rule-violation-threshold.strategy";
+export * from "./semaphore.service";
 export * from "./setup-hono.service";
 export * from "./shield-api-key.strategy";
 export * from "./shield-api-key-hono.strategy";

package/src/language-detector-header.strategy.ts

@@ -12,11 +12,9 @@ export class LanguageDetectorHeaderStrategy<T extends tools.LanguageType>
     if (!header) return null;
 
     // Example Accept-Language header: en-US,en;q=0.9,pl;q=0.8
-    // Stryker disable all
     const incoming = header
       .split(",")
       .map((language) => language.split(";")[0]?.trim().toLowerCase().split("-")[0]);
-    // Stryker restore all
 
     return incoming.find((language) => languages.isSupported(language)) ?? null;
   }

package/src/logger.port.ts

@@ -1,6 +1,5 @@
 import type * as tools from "@bgord/tools";
 import type { CorrelationIdType } from "./correlation-id.vo";
-import type { NormalizedError } from "./error-normalizer.service";
 import type { NodeEnvironmentEnum } from "./node-env.vo";
 
 export type LoggerAppType = string;
@@ -50,7 +49,7 @@ export type LoggerEntryBare = Omit<
   AdapterInjectedFields
 >;
 
-export type LoggerEntryBareWithError = Omit<LoggerEntryBare, "error"> & { error: NormalizedError };
+export type LoggerEntryBareWithError = Omit<LoggerEntryBare, "error"> & { error: tools.NormalizedError };
 
 export type LoggerEntry = LogCoreType | LogHttpType | LogWarnType | LogErrorType;
 

package/src/modules/preferences/command-handlers/handleSetUserLanguageCommand.ts

@@ -1,7 +1,6 @@
 import type * as tools from "@bgord/tools";
-import * as v from "valibot";
 import type { ClockPort } from "../../../clock.port";
-import { createEventEnvelope } from "../../../event-envelope";
+import { event } from "../../../event-envelope";
 import type { EventStorePort } from "../../../event-store.port";
 import type { IdProviderPort } from "../../../id-provider.port";
 import type { Languages } from "../../../languages.vo";
@@ -34,11 +33,12 @@ export const handleSetUserLanguageCommand =
 
     if (!Invariants.UserLanguageHasChanged.passes({ current, candidate })) return;
 
-    const event = v.parse(Events.UserLanguageSetEvent, {
-      ...createEventEnvelope(`preferences_${command.payload.userId}`, deps),
-      name: Events.USER_LANGUAGE_SET_EVENT,
-      payload: { userId: command.payload.userId, language: candidate },
-    } satisfies Events.UserLanguageSetEventType);
-
-    await deps.EventStore.save([event]);
+    await deps.EventStore.save([
+      event(
+        Events.UserLanguageSetEvent,
+        `preferences_${command.payload.userId}`,
+        { userId: command.payload.userId, language: candidate },
+        deps,
+      ),
+    ]);
   };

package/src/modules/system/services/passage-of-time-hourly.service.ts

@@ -1,15 +1,10 @@
-import * as v from "valibot";
 import type { ClockPort } from "../../../clock.port";
-import { createEventEnvelope } from "../../../event-envelope";
+import { event } from "../../../event-envelope";
 import type { EventStorePort } from "../../../event-store.port";
 import type { IdProviderPort } from "../../../id-provider.port";
 import type { UnitOfWork } from "../../../job-handler.strategy";
 import { Jobs } from "../../../jobs.service";
-import {
-  HOUR_HAS_PASSED_EVENT,
-  HourHasPassedEvent,
-  type HourHasPassedEventType,
-} from "../events/HOUR_HAS_PASSED_EVENT";
+import { HourHasPassedEvent, type HourHasPassedEventType } from "../events/HOUR_HAS_PASSED_EVENT";
 
 type Dependencies = {
   EventStore: EventStorePort<HourHasPassedEventType>;
@@ -25,12 +20,8 @@ export class PassageOfTimeHourly implements UnitOfWork {
   label = "PassageOfTime";
 
   async process() {
-    const event = v.parse(HourHasPassedEvent, {
-      ...createEventEnvelope("passage_of_time", this.deps),
-      name: HOUR_HAS_PASSED_EVENT,
-      payload: { timestamp: this.deps.Clock.now().ms },
-    } satisfies HourHasPassedEventType);
-
-    await this.deps.EventStore.save([event]);
+    await this.deps.EventStore.save([
+      event(HourHasPassedEvent, "passage_of_time", { timestamp: this.deps.Clock.now().ms }, this.deps),
+    ]);
   }
 }

package/src/modules/system/services/passage-of-time-minute.service.ts

@@ -1,15 +1,10 @@
-import * as v from "valibot";
 import type { ClockPort } from "../../../clock.port";
-import { createEventEnvelope } from "../../../event-envelope";
+import { event } from "../../../event-envelope";
 import type { EventStorePort } from "../../../event-store.port";
 import type { IdProviderPort } from "../../../id-provider.port";
 import type { UnitOfWork } from "../../../job-handler.strategy";
 import { Jobs } from "../../../jobs.service";
-import {
-  MINUTE_HAS_PASSED_EVENT,
-  MinuteHasPassedEvent,
-  type MinuteHasPassedEventType,
-} from "../events/MINUTE_HAS_PASSED_EVENT";
+import { MinuteHasPassedEvent, type MinuteHasPassedEventType } from "../events/MINUTE_HAS_PASSED_EVENT";
 
 type Dependencies = {
   EventStore: EventStorePort<MinuteHasPassedEventType>;
@@ -25,12 +20,8 @@ export class PassageOfTimeMinute implements UnitOfWork {
   label = "PassageOfTime";
 
   async process() {
-    const event = v.parse(MinuteHasPassedEvent, {
-      ...createEventEnvelope("passage_of_time", this.deps),
-      name: MINUTE_HAS_PASSED_EVENT,
-      payload: { timestamp: this.deps.Clock.now().ms },
-    } satisfies MinuteHasPassedEventType);
-
-    await this.deps.EventStore.save([event]);
+    await this.deps.EventStore.save([
+      event(MinuteHasPassedEvent, "passage_of_time", { timestamp: this.deps.Clock.now().ms }, this.deps),
+    ]);
   }
 }

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

@@ -1,4 +1,4 @@
-import dns from "dns/promises";
+import dns from "node:dns/promises";
 import {
   PrerequisiteVerification,
   type PrerequisiteVerificationResult,

package/src/prerequisite-verifier-with-retry.adapter.ts

@@ -21,9 +21,7 @@ export class PrerequisiteVerifierWithRetryAdapter implements PrerequisiteVerifie
       return await new Retry(this.deps).run<PrerequisiteVerificationResult>(async () => {
         const result = await this.config.inner.verify();
 
-        // Stryker disable all
         if (result.outcome === PrerequisiteVerificationOutcome.failure) throw result.error?.message;
-        // Stryker restore all
         return result;
       }, this.config.retry);
     } catch (error) {

package/src/prerequisite-verifier.port.ts

@@ -1,4 +1,4 @@
-import { ErrorNormalizer, type NormalizedError } from "./error-normalizer.service";
+import * as tools from "@bgord/tools";
 
 export enum PrerequisiteVerificationOutcome {
   success = "success",
@@ -9,7 +9,7 @@ export enum PrerequisiteVerificationOutcome {
 export type PrerequisiteVerificationSuccess = { outcome: PrerequisiteVerificationOutcome.success };
 export type PrerequisiteVerificationFailure = {
   outcome: PrerequisiteVerificationOutcome.failure;
-  error?: NormalizedError;
+  error?: tools.NormalizedError;
 };
 export type PrerequisiteVerificationUndetermined = { outcome: PrerequisiteVerificationOutcome.undetermined };
 export type PrerequisiteVerificationResult =
@@ -23,7 +23,7 @@ export class PrerequisiteVerification {
   static failure(meta?: unknown): PrerequisiteVerificationFailure {
     return {
       outcome: PrerequisiteVerificationOutcome.failure,
-      error: meta ? ErrorNormalizer.normalize(meta) : undefined,
+      error: meta ? tools.ErrorNormalizer.normalize(meta) : undefined,
     };
   }
 

package/src/randomness-crypto.strategy.ts

@@ -4,6 +4,6 @@ export class RandomnessCryptoStrategy implements RandomnessStrategy {
   next(): number {
     const array = new Uint32Array(1);
     crypto.getRandomValues(array);
-    return array[0]! / 0xffffffff;
+    return (array[0] ?? 0) / 0xffffffff;
   }
 }

package/src/redactor-error-cause-depth-limit.strategy.ts

@@ -1,20 +1,16 @@
 import * as tools from "@bgord/tools";
-import { ErrorNormalizer, type NormalizedError } from "./error-normalizer.service";
-import { isPlainObject } from "./is-plain-object";
 import type { RedactorStrategy } from "./redactor.strategy";
 
 export class RedactorErrorCauseDepthLimit implements RedactorStrategy {
   constructor(private readonly max: tools.IntegerNonNegativeType) {}
 
   redact<T>(input: T): T {
-    // Stryker disable all
-    if (!isPlainObject(input)) return input;
-    // Stryker restore all
-    if (!ErrorNormalizer.isNormalizedError(input["error"])) return input;
+    if (!tools.isPlainObject(input)) return input;
+    if (!tools.ErrorNormalizer.isNormalizedError(input["error"])) return input;
     return { ...input, error: this.limit(input["error"], tools.Int.nonNegative(0)) };
   }
 
-  private limit(error: NormalizedError, depth: tools.IntegerNonNegativeType): NormalizedError {
+  private limit(error: tools.NormalizedError, depth: tools.IntegerNonNegativeType): tools.NormalizedError {
     if (!error.cause || depth >= this.max) return { ...error, cause: undefined };
     return { ...error, cause: this.limit(error.cause, tools.Int.nonNegative(depth + 1)) };
   }

package/src/redactor-error-stack-hide.strategy.ts

@@ -1,17 +1,14 @@
-import { ErrorNormalizer, type NormalizedError } from "./error-normalizer.service";
-import { isPlainObject } from "./is-plain-object";
+import * as tools from "@bgord/tools";
 import type { RedactorStrategy } from "./redactor.strategy";
 
 export class RedactorErrorStackHide implements RedactorStrategy {
   redact<T>(input: T): T {
-    // Stryker disable all
-    if (!isPlainObject(input)) return input;
-    // Stryker restore all
-    if (!ErrorNormalizer.isNormalizedError(input["error"])) return input;
+    if (!tools.isPlainObject(input)) return input;
+    if (!tools.ErrorNormalizer.isNormalizedError(input["error"])) return input;
     return { ...input, error: this.hide(input["error"]) };
   }
 
-  private hide(error: NormalizedError): NormalizedError {
+  private hide(error: tools.NormalizedError): tools.NormalizedError {
     return {
       ...error,
       stack: undefined,

package/src/redactor-mask.strategy.ts

@@ -1,4 +1,4 @@
-import { deepCloneWith } from "./deep-clone-with";
+import * as tools from "@bgord/tools";
 import type { RedactorStrategy } from "./redactor.strategy";
 
 export class RedactorMask implements RedactorStrategy {
@@ -28,7 +28,7 @@ export class RedactorMask implements RedactorStrategy {
   }
 
   redact<T>(input: T): T {
-    return deepCloneWith(input, (_value, key) =>
+    return tools.deepCloneWith(input, (_value, key) =>
       typeof key === "string" && this.keys.has(key.toLowerCase()) ? "***" : undefined,
     );
   }

package/src/redactor-metadata-compact-array.strategy.ts

@@ -1,6 +1,4 @@
 import * as tools from "@bgord/tools";
-import { deepCloneWith } from "./deep-clone-with";
-import { isPlainObject } from "./is-plain-object";
 import type { RedactorStrategy } from "./redactor.strategy";
 
 type RedactorMetadataCompactArrayOptions = { maxItems?: tools.IntegerPositiveType };
@@ -15,11 +13,11 @@ export class RedactorMetadataCompactArray implements RedactorStrategy {
   }
 
   redact<T>(input: T): T {
-    if (!isPlainObject(input)) return input;
+    if (!tools.isPlainObject(input)) return input;
 
     return {
       ...input,
-      metadata: deepCloneWith(
+      metadata: tools.deepCloneWith(
         input["metadata"],
         (value) => {
           if (!Array.isArray(value)) return undefined;

package/src/redactor-metadata-compact-object.strategy.ts

@@ -1,6 +1,4 @@
 import * as tools from "@bgord/tools";
-import { deepCloneWith } from "./deep-clone-with";
-import { isPlainObject } from "./is-plain-object";
 import type { RedactorStrategy } from "./redactor.strategy";
 
 type RedactorMetadataCompactObjectOptions = { maxKeys?: tools.IntegerPositiveType };
@@ -15,14 +13,14 @@ export class RedactorMetadataCompactObject implements RedactorStrategy {
   }
 
   redact<T>(input: T): T {
-    if (!isPlainObject(input)) return input;
+    if (!tools.isPlainObject(input)) return input;
 
     return {
       ...input,
-      metadata: deepCloneWith(
+      metadata: tools.deepCloneWith(
         input["metadata"],
         (value) => {
-          if (!isPlainObject(value) || Array.isArray(value)) return undefined;
+          if (!tools.isPlainObject(value) || Array.isArray(value)) return undefined;
 
           const keys = Object.keys(value).length;
 

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

@@ -1,7 +1,6 @@
 import * as tools from "@bgord/tools";
 import type { ClockPort } from "./clock.port";
 import { Hash } from "./hash.vo";
-import type { LoggerPort } from "./logger.port";
 import type {
   RemoteFileStoragePort,
   RemoteHeadResult,
@@ -9,25 +8,17 @@ import type {
   RemotePutFromPathResult,
 } from "./remote-file-storage.port";
 
-type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
+type Dependencies = { Clock: ClockPort };
 
 type RemoteFileStorageNoopConfig = { root: tools.DirectoryPathAbsoluteType };
 
 export class RemoteFileStorageNoopAdapter implements RemoteFileStoragePort {
-  private readonly base = { component: "infra", operation: "RemoteFileStorageNoopAdapter" };
-
   constructor(
     private readonly config: RemoteFileStorageNoopConfig,
     private readonly deps: Dependencies,
   ) {}
 
-  async putFromPath(input: RemotePutFromPathInput): Promise<RemotePutFromPathResult> {
-    this.deps.Logger.info({
-      message: "[NOOP] RemoteFileStorageNoopAdapter putFromPath",
-      metadata: { input },
-      ...this.base,
-    });
-
+  async putFromPath(_input: RemotePutFromPathInput): Promise<RemotePutFromPathResult> {
     return {
       etag: Hash.fromString("0".repeat(64)),
       size: tools.Size.fromBytes(10),
@@ -36,33 +27,15 @@ export class RemoteFileStorageNoopAdapter implements RemoteFileStoragePort {
     };
   }
 
-  async head(key: tools.ObjectKeyType): Promise<RemoteHeadResult> {
-    this.deps.Logger.info({
-      message: "[NOOP] RemoteFileStorageNoopAdapter head",
-      metadata: { key },
-      ...this.base,
-    });
-
+  async head(_key: tools.ObjectKeyType): Promise<RemoteHeadResult> {
     return { exists: false };
   }
 
-  async getStream(key: tools.ObjectKeyType): Promise<ReadableStream | null> {
-    this.deps.Logger.info({
-      message: "[NOOP] RemoteFileStorageNoopAdapter getStream",
-      metadata: { key },
-      ...this.base,
-    });
-
+  async getStream(_key: tools.ObjectKeyType): Promise<ReadableStream | null> {
     return null;
   }
 
-  async delete(key: tools.ObjectKeyType): Promise<void> {
-    this.deps.Logger.info({
-      message: "[NOOP] RemoteFileStorageNoopAdapter delete",
-      metadata: { key },
-      ...this.base,
-    });
-  }
+  async delete(_key: tools.ObjectKeyType): Promise<void> {}
 
   get root(): tools.DirectoryPathAbsoluteType {
     return this.config.root;