@bgord/bun 1.6.6 → 1.7.0

package/src/prerequisites/memory.ts

@@ -1,34 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import { MemoryConsumption } from "../memory-consumption.service";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteMemory implements prereqs.Prerequisite {
-  readonly kind = "memory";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly maximum: tools.Size;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { maximum: tools.Size }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.maximum = config.maximum;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    const memoryConsumption = MemoryConsumption.get();
-
-    if (memoryConsumption.isGreaterThan(this.maximum)) {
-      return prereqs.Verification.failure(stopwatch.stop(), {
-        message: `Memory consumption: ${memoryConsumption.format(tools.Size.unit.MB)}`,
-      });
-    }
-    return prereqs.Verification.success(stopwatch.stop());
-  }
-}

package/src/prerequisites/node.ts

@@ -1,37 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteNode implements prereqs.Prerequisite {
-  readonly kind = "node";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly version: tools.PackageVersion;
-  private readonly current: string;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { version: tools.PackageVersion; current: string }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.version = config.version;
-    this.current = config.current;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      const current = tools.PackageVersion.fromVersionString(this.current);
-
-      if (current.isGreaterThanOrEqual(this.version)) return prereqs.Verification.success(stopwatch.stop());
-      return prereqs.Verification.failure(stopwatch.stop(), { message: `Version: ${this.current}` });
-    } catch {
-      return prereqs.Verification.failure(stopwatch.stop(), {
-        message: `Invalid version passed: ${this.current}`,
-      });
-    }
-  }
-}

package/src/prerequisites/os.ts

@@ -1,33 +0,0 @@
-import os from "node:os";
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteOs implements prereqs.Prerequisite {
-  readonly kind = "os";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly accepted: string[];
-
-  constructor(config: prereqs.PrerequisiteConfigType & { accepted: string[] }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-    this.accepted = config.accepted;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    const type = os.type();
-
-    if (this.accepted.map((type) => type.toLowerCase()).includes(type.toLowerCase())) {
-      return prereqs.Verification.success(stopwatch.stop());
-    }
-    return prereqs.Verification.failure(stopwatch.stop(), {
-      message: `Unacceptable os: ${this.accepted.join(", ")}`,
-    });
-  }
-}

package/src/prerequisites/outside-connectivity.ts

@@ -1,38 +0,0 @@
-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 PrerequisiteOutsideConnectivity implements prereqs.Prerequisite {
-  readonly kind = "outside-connectivity";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private static readonly URL = tools.UrlWithoutSlash.parse("https://google.com");
-  readonly timeout: tools.Duration;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { timeout?: tools.Duration }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.timeout = config.timeout ?? tools.Duration.Seconds(2);
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    try {
-      if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-      const response = await Timeout.cancellable(
-        (signal: AbortSignal) => fetch(PrerequisiteOutsideConnectivity.URL, { method: "HEAD", signal }),
-        this.timeout,
-      );
-
-      if (response.ok) return prereqs.Verification.success(stopwatch.stop());
-      return prereqs.Verification.failure(stopwatch.stop(), { message: `HTTP ${response.status}` });
-    } catch (error) {
-      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
-    }
-  }
-}

package/src/prerequisites/port.ts

@@ -1,34 +0,0 @@
-import net from "node:net";
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import type { PortType } from "../port.vo";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisitePort implements prereqs.Prerequisite {
-  readonly kind = "port";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly port: PortType;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { port: PortType }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.port = config.port;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    return new Promise((resolve) => {
-      const server = net.createServer();
-      server.listen(this.port, () =>
-        server.close(() => resolve(prereqs.Verification.success(stopwatch.stop()))),
-      );
-      server.on("error", () => resolve(prereqs.Verification.failure(stopwatch.stop())));
-    });
-  }
-}

package/src/prerequisites/ram.ts

@@ -1,32 +0,0 @@
-import os from "node:os";
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteRAM implements prereqs.Prerequisite {
-  readonly kind = "ram";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly minimum: tools.Size;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { minimum: tools.Size }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.minimum = config.minimum;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    const freeRAM = tools.Size.fromBytes(os.freemem());
-
-    if (freeRAM.isGreaterThan(this.minimum)) return prereqs.Verification.success(stopwatch.stop());
-    return prereqs.Verification.failure(stopwatch.stop(), {
-      message: `Free RAM: ${freeRAM.format(tools.Size.unit.MB)}`,
-    });
-  }
-}

package/src/prerequisites/running-user.ts

@@ -1,30 +0,0 @@
-import os from "node:os";
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteRunningUser implements prereqs.Prerequisite {
-  readonly kind = "running-user";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly username: string;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { username: string }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.username = config.username;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    const current = os.userInfo().username;
-
-    if (current === this.username) return prereqs.Verification.success(stopwatch.stop());
-    return prereqs.Verification.failure(stopwatch.stop(), { message: `Current user: ${current}` });
-  }
-}

package/src/prerequisites/self.ts

@@ -1,21 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteSelf implements prereqs.Prerequisite {
-  readonly kind = "self";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  constructor(config: prereqs.PrerequisiteConfigType) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-    return prereqs.Verification.success(stopwatch.stop());
-  }
-}

package/src/prerequisites/space.ts

@@ -1,45 +0,0 @@
-import path from "node:path";
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import type { DiskSpaceCheckerPort } from "../disk-space-checker.port";
-import { DiskSpaceCheckerBunAdapter } from "../disk-space-checker-bun.adapter";
-import * as prereqs from "../prerequisites.service";
-
-type Dependencies = { DiskSpaceChecker?: DiskSpaceCheckerPort };
-
-export class PrerequisiteSpace implements prereqs.Prerequisite {
-  readonly kind = "space";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly minimum: tools.Size;
-
-  constructor(
-    config: prereqs.PrerequisiteConfigType & { minimum: tools.Size },
-    private readonly deps?: Dependencies,
-  ) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.minimum = config.minimum;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const DiskSpaceChecker = this.deps?.DiskSpaceChecker ?? new DiskSpaceCheckerBunAdapter();
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      const root = path.sep;
-      const freeDiskSpace = await DiskSpaceChecker.get(root);
-
-      if (freeDiskSpace.isGreaterThan(this.minimum)) return prereqs.Verification.success(stopwatch.stop());
-      return prereqs.Verification.failure(stopwatch.stop(), {
-        message: `Free disk space: ${freeDiskSpace.format(tools.Size.unit.MB)}`,
-      });
-    } catch (error) {
-      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
-    }
-  }
-}

package/src/prerequisites/sqlite.ts

@@ -1,38 +0,0 @@
-import type { Database } from "bun:sqlite";
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteSQLite implements prereqs.Prerequisite {
-  readonly kind = "sqlite";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly sqlite: Database;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { sqlite: Database }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.sqlite = config.sqlite;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      const integrity = this.sqlite.query("PRAGMA integrity_check;").get() as
-        | { integrity_check?: string }
-        | undefined;
-
-      if (!integrity || (integrity.integrity_check ?? "").toLowerCase() !== "ok") {
-        return prereqs.Verification.failure(stopwatch.stop(), { message: "Integrity check failed" });
-      }
-      return prereqs.Verification.success(stopwatch.stop());
-    } catch (error) {
-      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
-    }
-  }
-}

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

@@ -1,43 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { CertificateInspectorPort } from "../certificate-inspector.port";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-type Dependencies = { CertificateInspector: CertificateInspectorPort };
-
-export class PrerequisiteSSLCertificateExpiry implements prereqs.Prerequisite {
-  readonly kind = "ssl-certificate-expiry";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly hostname: string;
-  private readonly days: number;
-
-  constructor(
-    config: prereqs.PrerequisiteConfigType & { hostname: string; days: number },
-    private readonly deps: Dependencies,
-  ) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.hostname = config.hostname;
-    this.days = config.days;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    const result = await this.deps.CertificateInspector.inspect(this.hostname);
-
-    if (!result.success)
-      return prereqs.Verification.failure(stopwatch.stop(), { message: "Certificate unavailable" });
-    if (result.daysRemaining <= this.days) {
-      return prereqs.Verification.failure(stopwatch.stop(), {
-        message: `${result.daysRemaining} days remaining`,
-      });
-    }
-    return prereqs.Verification.success(stopwatch.stop());
-  }
-}

package/src/prerequisites/timezone-utc.ts

@@ -1,32 +0,0 @@
-import * as tools from "@bgord/tools";
-import { z } from "zod/v4";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export const TimezoneUtc = z.literal("UTC");
-
-export class PrerequisiteTimezoneUTC implements prereqs.Prerequisite {
-  readonly kind = "timezone-utc";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly timezone: tools.TimezoneType;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { timezone: tools.TimezoneType }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.timezone = config.timezone;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    const result = TimezoneUtc.safeParse(this.timezone);
-
-    if (result.success) return prereqs.Verification.success(stopwatch.stop());
-    return prereqs.Verification.failure(stopwatch.stop(), { message: `Timezone: ${this.timezone}` });
-  }
-}

package/src/prerequisites/translations.ts

@@ -1,103 +0,0 @@
-import { constants } from "node:fs";
-import fsp from "node:fs/promises";
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import type * as types from "../i18n.service";
-import { I18n } from "../i18n.service";
-import type { JsonFileReaderPort } from "../json-file-reader.port";
-import { JsonFileReaderBunForgivingAdapter } from "../json-file-reader-bun-forgiving.adapter";
-import type { LoggerPort } from "../logger.port";
-import * as prereqs from "../prerequisites.service";
-
-type PrerequisiteTranslationsProblemType = {
-  key: types.TranslationsKeyType;
-  existsIn: tools.LanguageType;
-  missingIn: tools.LanguageType;
-};
-
-type Dependencies = { Logger: LoggerPort; JsonFileReader?: JsonFileReaderPort };
-
-export class PrerequisiteTranslations implements prereqs.Prerequisite {
-  readonly kind = "translations";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly translationsPath?: typeof I18n.DEFAULT_TRANSLATIONS_PATH;
-  private readonly supportedLanguages: types.I18nConfigType["supportedLanguages"];
-
-  constructor(
-    config: prereqs.PrerequisiteConfigType & {
-      translationsPath?: typeof I18n.DEFAULT_TRANSLATIONS_PATH;
-      supportedLanguages: types.I18nConfigType["supportedLanguages"];
-    },
-    private readonly deps: Dependencies,
-  ) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.translationsPath = config.translationsPath;
-    this.supportedLanguages = config.supportedLanguages;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const JsonFileReader = this.deps.JsonFileReader ?? new JsonFileReaderBunForgivingAdapter();
-
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    const translationsPath = this.translationsPath ?? I18n.DEFAULT_TRANSLATIONS_PATH;
-
-    const supportedLanguages = Object.keys(this.supportedLanguages);
-    const i18n = new I18n({ Logger: this.deps.Logger, JsonFileReader: JsonFileReader });
-
-    try {
-      await fsp.access(translationsPath, constants.R_OK);
-
-      for (const language of supportedLanguages) {
-        await fsp.access(i18n.getTranslationPathForLanguage(language).get(), constants.R_OK);
-      }
-    } catch (error) {
-      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
-    }
-
-    if (supportedLanguages.length === 1) return prereqs.Verification.success(stopwatch.stop());
-
-    const languageToTranslationKeys: Record<tools.LanguageType, types.TranslationsKeyType[]> = {};
-
-    const problems: PrerequisiteTranslationsProblemType[] = [];
-
-    for (const language of supportedLanguages) {
-      const translations = await i18n.getTranslations(language);
-      const translationKeys = Object.keys(translations);
-
-      languageToTranslationKeys[language] = translationKeys;
-    }
-
-    for (const language in languageToTranslationKeys) {
-      const translationKeys = languageToTranslationKeys[language] ?? [];
-
-      for (const translationKey of translationKeys) {
-        for (const supportedLanguage of supportedLanguages) {
-          if (supportedLanguage === language) continue;
-
-          const translationKeyExists = languageToTranslationKeys[supportedLanguage]?.some(
-            (key) => translationKey === key,
-          );
-
-          if (!translationKeyExists) {
-            problems.push({ key: translationKey, existsIn: language, missingIn: supportedLanguage });
-          }
-        }
-      }
-    }
-
-    if (problems.length === 0) return prereqs.Verification.success(stopwatch.stop());
-
-    const summary = problems
-      .map((problem) => `Key: ${problem.key}, exists in ${problem.existsIn}, missing in ${problem.missingIn}`)
-      .join("\n");
-
-    return prereqs.Verification.failure(stopwatch.stop(), { message: summary });
-  }
-}

package/src/prerequisites.service.ts

@@ -1,92 +0,0 @@
-import type * as tools from "@bgord/tools";
-import type { ClockPort } from "../src/clock.port";
-import type { ErrorInfo, LoggerPort } from "../src/logger.port";
-import { formatError } from "../src/logger-format-error.service";
-
-export type PrerequisiteLabelType = string;
-
-export enum PrerequisiteStatusEnum {
-  success = "success",
-  failure = "failure",
-  undetermined = "undetermined",
-}
-
-export type VerifySuccess = { status: PrerequisiteStatusEnum.success; durationMs: tools.DurationMsType };
-export type VerifyFailure = {
-  status: PrerequisiteStatusEnum.failure;
-  durationMs: tools.DurationMsType;
-  error?: ErrorInfo;
-};
-export type VerifyUndetermined = {
-  status: PrerequisiteStatusEnum.undetermined;
-  durationMs: tools.DurationMsType;
-};
-export type VerifyOutcome = VerifySuccess | VerifyFailure | VerifyUndetermined;
-
-export interface Prerequisite {
-  readonly label: PrerequisiteLabelType;
-  readonly kind: string;
-  readonly enabled?: boolean;
-  verify(clock: ClockPort): Promise<VerifyOutcome>;
-}
-
-export type PrerequisiteResult = {
-  label: PrerequisiteLabelType;
-  status: PrerequisiteStatusEnum;
-  kind: string;
-  error?: ErrorInfo;
-};
-
-export class Verification {
-  static success(duration: tools.Duration): VerifySuccess {
-    return { status: PrerequisiteStatusEnum.success, durationMs: duration.ms };
-  }
-  static failure(duration: tools.Duration, meta?: Error | ErrorInfo): VerifyFailure {
-    return {
-      status: PrerequisiteStatusEnum.failure,
-      durationMs: duration.ms,
-      error: meta instanceof Error ? formatError(meta) : meta,
-    };
-  }
-  static undetermined(duration: tools.Duration): VerifyUndetermined {
-    return { status: PrerequisiteStatusEnum.undetermined, durationMs: duration.ms };
-  }
-}
-
-export type PrerequisiteConfigType = { label: string; enabled?: boolean };
-
-export const PrerequisitesError = { Failure: "prerequisites.failure" } as const;
-
-type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
-
-/** @public */
-export class Prerequisites {
-  private readonly base = { component: "infra", operation: "startup" };
-
-  constructor(private readonly deps: Dependencies) {}
-
-  async check(prerequisites: Prerequisite[]) {
-    const results = await Promise.all(
-      prerequisites.map(async (prerequisite) => ({
-        prerequisite,
-        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 });
-
-    for (const failure of failed) {
-      this.deps.Logger.error({
-        message: "Prerequisite failed",
-        metadata: { label: failure.prerequisite.label, kind: failure.prerequisite.kind },
-        // @ts-expect-error
-        error: failure.outcome.error ?? { message: "unknown error" },
-        ...this.base,
-      });
-    }
-
-    throw new Error(PrerequisitesError.Failure);
-  }
-}

package/src/redactor-compact-array.adapter.ts

@@ -1,10 +0,0 @@
-import cloneDeepWith from "lodash/cloneDeepWith";
-import type { RedactorPort } from "./redactor.port";
-
-export class RedactorCompactArrayAdapter implements RedactorPort {
-  redact<T>(input: T): T {
-    return cloneDeepWith(input, (value) =>
-      Array.isArray(value) ? { type: "Array", length: value.length } : undefined,
-    );
-  }
-}

package/src/redactor-compact-object.adapter.ts

@@ -1,24 +0,0 @@
-import _ from "lodash";
-import type { RedactorPort } from "./redactor.port";
-
-type RedactorWideObjectOptions = { maxKeys?: number };
-
-export class RedactorCompactObjectAdapter implements RedactorPort {
-  private static readonly DEFAULT_MAX_KEYS = 20;
-
-  private readonly maxKeys: number;
-
-  constructor(options: RedactorWideObjectOptions = {}) {
-    this.maxKeys = options.maxKeys ?? RedactorCompactObjectAdapter.DEFAULT_MAX_KEYS;
-  }
-
-  redact<T>(input: T): T {
-    return _.cloneDeepWith(input, (value) => {
-      if (!_.isPlainObject(value)) return undefined;
-
-      const keys = Object.keys(value).length;
-
-      return keys <= this.maxKeys ? undefined : { type: "Object", keys };
-    });
-  }
-}

package/src/redactor-composite.adapter.ts

@@ -1,9 +0,0 @@
-import type { RedactorPort } from "./redactor.port";
-
-export class RedactorCompositeAdapter implements RedactorPort {
-  constructor(private readonly pipeline: readonly RedactorPort[]) {}
-
-  redact<T>(input: T): T {
-    return this.pipeline.reduce((result, redactor) => redactor.redact(result), input);
-  }
-}