@bgord/bun 1.6.7 → 1.7.0

package/src/prerequisite-verifier-running-user.adapter.ts

@@ -0,0 +1,17 @@
+import os from "node:os";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierRunningUserAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { username: string }) {}
+
+  async verify() {
+    const current = os.userInfo().username;
+
+    if (current === this.config.username) return PrerequisiteVerification.success;
+    return PrerequisiteVerification.failure({ message: `Current user: ${current}` });
+  }
+
+  get kind() {
+    return "running-user";
+  }
+}

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

@@ -0,0 +1,11 @@
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierSelfAdapter implements PrerequisiteVerifierPort {
+  async verify() {
+    return PrerequisiteVerification.success;
+  }
+
+  get kind() {
+    return "self";
+  }
+}

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

@@ -0,0 +1,32 @@
+import path from "node:path";
+import * as tools from "@bgord/tools";
+import type { DiskSpaceCheckerPort } from "./disk-space-checker.port";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+type Dependencies = { DiskSpaceChecker: DiskSpaceCheckerPort };
+
+export class PrerequisiteVerifierSpaceAdapter implements PrerequisiteVerifierPort {
+  constructor(
+    private readonly config: { minimum: tools.Size },
+    private readonly deps: Dependencies,
+  ) {}
+
+  async verify() {
+    try {
+      const root = path.sep;
+      const freeDiskSpace = await this.deps.DiskSpaceChecker.get(root);
+
+      if (freeDiskSpace.isGreaterThan(this.config.minimum)) return PrerequisiteVerification.success;
+
+      const formatted = freeDiskSpace.format(tools.Size.unit.MB);
+
+      return PrerequisiteVerification.failure({ message: `Free disk space: ${formatted}` });
+    } catch (error) {
+      return PrerequisiteVerification.failure(error as Error);
+    }
+  }
+
+  get kind() {
+    return "space";
+  }
+}

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

@@ -0,0 +1,25 @@
+import type { Database } from "bun:sqlite";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierSQLiteAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { sqlite: Database }) {}
+
+  async verify() {
+    try {
+      const integrity = this.config.sqlite.query("PRAGMA integrity_check;").get() as
+        | { integrity_check?: string }
+        | undefined;
+
+      if (!integrity || (integrity.integrity_check ?? "").toLowerCase() !== "ok") {
+        return PrerequisiteVerification.failure({ message: "Integrity check failed" });
+      }
+      return PrerequisiteVerification.success;
+    } catch (error) {
+      return PrerequisiteVerification.failure(error as Error);
+    }
+  }
+
+  get kind() {
+    return "sqlite";
+  }
+}

package/src/prerequisite-verifier-ssl-certificate-expiry.adapter.ts

@@ -0,0 +1,27 @@
+import type { CertificateInspectorPort } from "./certificate-inspector.port";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+type Dependencies = { CertificateInspector: CertificateInspectorPort };
+
+export class PrerequisiteVerifierSSLCertificateExpiryAdapter implements PrerequisiteVerifierPort {
+  constructor(
+    private readonly config: { hostname: string; days: number },
+    private readonly deps: Dependencies,
+  ) {}
+
+  async verify() {
+    const result = await this.deps.CertificateInspector.inspect(this.config.hostname);
+
+    if (!result.success) return PrerequisiteVerification.failure({ message: "Certificate unavailable" });
+
+    if (result.daysRemaining <= this.config.days) {
+      return PrerequisiteVerification.failure({ message: `${result.daysRemaining} days remaining` });
+    }
+
+    return PrerequisiteVerification.success;
+  }
+
+  get kind() {
+    return "ssl-certificate-expiry";
+  }
+}

package/src/prerequisite-verifier-timezone-utc.adapter.ts

@@ -0,0 +1,20 @@
+import type * as tools from "@bgord/tools";
+import { z } from "zod/v4";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export const TimezoneUtc = z.literal("UTC");
+
+export class PrerequisiteVerifierTimezoneUtcAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { timezone: tools.TimezoneType }) {}
+
+  async verify() {
+    const result = TimezoneUtc.safeParse(this.config.timezone);
+
+    if (result.success) return PrerequisiteVerification.success;
+    return PrerequisiteVerification.failure({ message: `Timezone: ${this.config.timezone}` });
+  }
+
+  get kind() {
+    return "timezone-utc";
+  }
+}

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

@@ -0,0 +1,86 @@
+import { constants } from "node:fs";
+import fsp from "node:fs/promises";
+import type * as tools from "@bgord/tools";
+import type { FileReaderJsonPort } from "./file-reader-json.port";
+import type * as types from "./i18n.service";
+import { I18n } from "./i18n.service";
+import type { LoggerPort } from "./logger.port";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+type PrerequisiteTranslationsProblemType = {
+  key: types.TranslationsKeyType;
+  existsIn: tools.LanguageType;
+  missingIn: tools.LanguageType;
+};
+
+type Dependencies = { Logger: LoggerPort; JsonFileReader: FileReaderJsonPort };
+
+export class PrerequisiteVerifierTranslationsAdapter implements PrerequisiteVerifierPort {
+  constructor(
+    private readonly config: {
+      translationsPath?: typeof I18n.DEFAULT_TRANSLATIONS_PATH;
+      supportedLanguages: types.I18nConfigType["supportedLanguages"];
+    },
+    private readonly deps: Dependencies,
+  ) {}
+
+  async verify() {
+    const translationsPath = this.config.translationsPath ?? I18n.DEFAULT_TRANSLATIONS_PATH;
+
+    const supportedLanguages = Object.keys(this.config.supportedLanguages);
+    const i18n = new I18n(this.deps);
+
+    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 PrerequisiteVerification.failure(error as Error);
+    }
+
+    if (supportedLanguages.length === 1) return PrerequisiteVerification.success;
+
+    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 PrerequisiteVerification.success;
+
+    const summary = problems
+      .map((problem) => `Key: ${problem.key}, exists in ${problem.existsIn}, missing in ${problem.missingIn}`)
+      .join("\n");
+
+    return PrerequisiteVerification.failure({ message: summary });
+  }
+
+  get kind() {
+    return "translations";
+  }
+}

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

@@ -0,0 +1,35 @@
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import { CacheSubjectResolver } from "./cache-subject-resolver.vo";
+import { CacheSubjectSegmentFixedStrategy } from "./cache-subject-segment-fixed.strategy";
+import type { HashContentStrategy } from "./hash-content.strategy";
+import type { PrerequisiteVerificationResult, PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
+
+export class PrerequisiteVerifierWithCacheAdapter implements PrerequisiteVerifierPort {
+  constructor(
+    private readonly config: { id: string; inner: PrerequisiteVerifierPort },
+    private readonly deps: Dependencies,
+  ) {}
+
+  async verify() {
+    const resolver = new CacheSubjectResolver(
+      [
+        new CacheSubjectSegmentFixedStrategy("prerequisite_verifier"),
+        new CacheSubjectSegmentFixedStrategy(this.kind),
+        new CacheSubjectSegmentFixedStrategy(this.config.id),
+      ],
+      this.deps,
+    );
+
+    const subject = await resolver.resolve();
+
+    return this.deps.CacheResolver.resolve<PrerequisiteVerificationResult>(subject.hex, () =>
+      this.config.inner.verify(),
+    );
+  }
+
+  get kind() {
+    return this.config.inner.kind;
+  }
+}

package/src/prerequisite-verifier-with-fail-safe.adapter.ts

@@ -0,0 +1,37 @@
+import {
+  PrerequisiteVerification,
+  PrerequisiteVerificationOutcome,
+  type PrerequisiteVerificationResult,
+  type PrerequisiteVerifierPort,
+} from "./prerequisite-verifier.port";
+
+export type PrerequisiteVerifierWithFailSafeAdapterConfigType = (
+  result: PrerequisiteVerificationResult,
+) => boolean;
+
+const AnyErrorFailSafe: PrerequisiteVerifierWithFailSafeAdapterConfigType = (result) =>
+  result.outcome === PrerequisiteVerificationOutcome.failure;
+
+export class PrerequisiteVerifierWithFailSafeAdapter implements PrerequisiteVerifierPort {
+  private readonly when: PrerequisiteVerifierWithFailSafeAdapterConfigType;
+
+  constructor(
+    private readonly config: {
+      inner: PrerequisiteVerifierPort;
+      when?: PrerequisiteVerifierWithFailSafeAdapterConfigType;
+    },
+  ) {
+    this.when = config.when ?? AnyErrorFailSafe;
+  }
+
+  async verify() {
+    const result = await this.config.inner.verify();
+
+    if (this.when(result)) return PrerequisiteVerification.undetermined;
+    return result;
+  }
+
+  get kind() {
+    return this.config.inner.kind;
+  }
+}

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

@@ -0,0 +1,51 @@
+import type * as tools from "@bgord/tools";
+import type { ClockPort } from "./clock.port";
+import type { ErrorInfo, LoggerPort } from "./logger.port";
+import { PrerequisiteVerificationOutcome, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+import { Stopwatch } from "./stopwatch.service";
+
+type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
+
+export class PrerequisiteVerifierWithLoggerAdapter implements PrerequisiteVerifierPort {
+  private readonly base = (durationMs: tools.DurationMsType) => ({
+    component: "infra",
+    operation: "prerequisite_verify",
+    durationMs,
+  });
+
+  constructor(
+    private readonly config: { inner: PrerequisiteVerifierPort },
+    private readonly deps: Dependencies,
+  ) {}
+
+  async verify() {
+    const stopwatch = new Stopwatch(this.deps);
+    const result = await this.config.inner.verify();
+    const durationMs = stopwatch.stop().ms;
+
+    switch (result.outcome) {
+      case PrerequisiteVerificationOutcome.success: {
+        this.deps.Logger.info({ message: `Success - ${this.kind}`, ...this.base(durationMs) });
+        break;
+      }
+      case PrerequisiteVerificationOutcome.failure: {
+        this.deps.Logger.error({
+          message: `Failure - ${this.kind}`,
+          error: result.error as ErrorInfo,
+          ...this.base(durationMs),
+        });
+        break;
+      }
+      case PrerequisiteVerificationOutcome.undetermined: {
+        this.deps.Logger.info({ message: `Undetermined - ${this.kind}`, ...this.base(durationMs) });
+        break;
+      }
+    }
+
+    return result;
+  }
+
+  get kind() {
+    return this.config.inner.kind;
+  }
+}

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

@@ -0,0 +1,35 @@
+import type { ErrorInfo } from "./logger.port";
+import {
+  PrerequisiteVerification,
+  PrerequisiteVerificationOutcome,
+  type PrerequisiteVerificationResult,
+  type PrerequisiteVerifierPort,
+} from "./prerequisite-verifier.port";
+import { Retry, type RetryConfigType } from "./retry.service";
+import type { SleeperPort } from "./sleeper.port";
+
+type Dependencies = { Sleeper: SleeperPort };
+
+export class PrerequisiteVerifierWithRetryAdapter implements PrerequisiteVerifierPort {
+  constructor(
+    private readonly config: { inner: PrerequisiteVerifierPort; retry: RetryConfigType },
+    private readonly deps: Dependencies,
+  ) {}
+
+  async verify() {
+    try {
+      return await new Retry(this.deps).run<PrerequisiteVerificationResult>(async () => {
+        const result = await this.config.inner.verify();
+
+        if (result.outcome === PrerequisiteVerificationOutcome.failure) throw result.error;
+        return result;
+      }, this.config.retry);
+    } catch (error) {
+      return PrerequisiteVerification.failure(error as ErrorInfo);
+    }
+  }
+
+  get kind() {
+    return this.config.inner.kind;
+  }
+}

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

@@ -0,0 +1,31 @@
+import type * as tools from "@bgord/tools";
+import {
+  PrerequisiteVerification,
+  type PrerequisiteVerificationResult,
+  type PrerequisiteVerifierPort,
+} from "./prerequisite-verifier.port";
+import type { TimeoutRunnerPort } from "./timeout-runner.port";
+
+type Dependencies = { TimeoutRunner: TimeoutRunnerPort };
+
+export class PrerequisiteVerifierWithTimeoutAdapter implements PrerequisiteVerifierPort {
+  constructor(
+    private readonly config: { inner: PrerequisiteVerifierPort; timeout: tools.Duration },
+    private readonly deps: Dependencies,
+  ) {}
+
+  async verify() {
+    try {
+      return await this.deps.TimeoutRunner.run<PrerequisiteVerificationResult>(
+        this.config.inner.verify(),
+        this.config.timeout,
+      );
+    } catch (error) {
+      return PrerequisiteVerification.failure(error as Error);
+    }
+  }
+
+  get kind() {
+    return this.config.inner.kind;
+  }
+}

package/src/prerequisite-verifier.decorator.ts

@@ -0,0 +1,49 @@
+import type * as tools from "@bgord/tools";
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import type { ClockPort } from "./clock.port";
+import type { HashContentStrategy } from "./hash-content.strategy";
+import type { LoggerPort } from "./logger.port";
+import type { PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+import { PrerequisiteVerifierWithCacheAdapter } from "./prerequisite-verifier-with-cache.adapter";
+import {
+  PrerequisiteVerifierWithFailSafeAdapter,
+  type PrerequisiteVerifierWithFailSafeAdapterConfigType,
+} from "./prerequisite-verifier-with-fail-safe.adapter";
+import { PrerequisiteVerifierWithLoggerAdapter } from "./prerequisite-verifier-with-logger.adapter";
+import { PrerequisiteVerifierWithRetryAdapter } from "./prerequisite-verifier-with-retry.adapter";
+import { PrerequisiteVerifierWithTimeoutAdapter } from "./prerequisite-verifier-with-timeout.adapter";
+import type { RetryConfigType } from "./retry.service";
+import type { SleeperPort } from "./sleeper.port";
+import type { TimeoutRunnerPort } from "./timeout-runner.port";
+
+export type PrerequisiteVerifierDecorator = (verifier: PrerequisiteVerifierPort) => PrerequisiteVerifierPort;
+
+const withTimeout =
+  (timeout: tools.Duration, deps: { TimeoutRunner: TimeoutRunnerPort }): PrerequisiteVerifierDecorator =>
+  (inner) =>
+    new PrerequisiteVerifierWithTimeoutAdapter({ inner, timeout }, deps);
+
+const withCache =
+  (
+    id: string,
+    deps: { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy },
+  ): PrerequisiteVerifierDecorator =>
+  (inner) =>
+    new PrerequisiteVerifierWithCacheAdapter({ id, inner }, deps);
+
+const withLogger =
+  (deps: { Clock: ClockPort; Logger: LoggerPort }): PrerequisiteVerifierDecorator =>
+  (inner) =>
+    new PrerequisiteVerifierWithLoggerAdapter({ inner }, deps);
+
+const withRetry =
+  (retry: RetryConfigType, deps: { Sleeper: SleeperPort }): PrerequisiteVerifierDecorator =>
+  (inner) =>
+    new PrerequisiteVerifierWithRetryAdapter({ inner, retry }, deps);
+
+const withFailSafe =
+  (when: PrerequisiteVerifierWithFailSafeAdapterConfigType): PrerequisiteVerifierDecorator =>
+  (inner) =>
+    new PrerequisiteVerifierWithFailSafeAdapter({ inner, when });
+
+export const PrerequisiteDecorator = { withTimeout, withCache, withLogger, withRetry, withFailSafe };

package/src/prerequisite-verifier.port.ts

@@ -0,0 +1,38 @@
+import type { ErrorInfo } from "./logger.port";
+import { formatError } from "./logger-format-error.service";
+
+export enum PrerequisiteVerificationOutcome {
+  success = "success",
+  failure = "failure",
+  undetermined = "undetermined",
+}
+
+export type PrerequisiteVerificationSuccess = { outcome: PrerequisiteVerificationOutcome.success };
+export type PrerequisiteVerificationFailure = {
+  outcome: PrerequisiteVerificationOutcome.failure;
+  error?: ErrorInfo;
+};
+export type PrerequisiteVerificationUndetermined = { outcome: PrerequisiteVerificationOutcome.undetermined };
+export type PrerequisiteVerificationResult =
+  | PrerequisiteVerificationSuccess
+  | PrerequisiteVerificationFailure
+  | PrerequisiteVerificationUndetermined;
+
+export class PrerequisiteVerification {
+  static success = { outcome: PrerequisiteVerificationOutcome.success };
+
+  static failure(meta?: Error | ErrorInfo): PrerequisiteVerificationFailure {
+    return {
+      outcome: PrerequisiteVerificationOutcome.failure,
+      error: meta instanceof Error ? formatError(meta) : meta,
+    };
+  }
+
+  static undetermined = { outcome: PrerequisiteVerificationOutcome.undetermined };
+}
+
+export interface PrerequisiteVerifierPort {
+  verify(): Promise<PrerequisiteVerificationResult>;
+
+  get kind(): string;
+}

package/src/prerequisite.vo.ts

@@ -0,0 +1,28 @@
+import type { PrerequisiteVerifierDecorator } from "./prerequisite-verifier.decorator";
+import type { PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export type PrerequisiteLabelType = string;
+
+type PrerequisiteConfigType = { decorators?: PrerequisiteVerifierDecorator[]; enabled?: boolean };
+
+export class Prerequisite {
+  private readonly decorators: PrerequisiteVerifierDecorator[];
+  readonly enabled: boolean;
+
+  constructor(
+    readonly label: PrerequisiteLabelType,
+    private readonly verifier: PrerequisiteVerifierPort,
+    config?: PrerequisiteConfigType,
+  ) {
+    this.decorators = config?.decorators ?? [];
+    this.enabled = config?.enabled ?? true;
+  }
+
+  build(): PrerequisiteVerifierPort {
+    return this.decorators.reduceRight((verifier, decorator) => decorator(verifier), this.verifier);
+  }
+
+  get kind() {
+    return this.verifier.kind;
+  }
+}

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

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

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

@@ -0,0 +1,24 @@
+import _ from "lodash";
+import type { RedactorStrategy } from "./redactor.strategy";
+
+type RedactorWideObjectOptions = { maxKeys?: number };
+
+export class RedactorCompactObjectStrategy implements RedactorStrategy {
+  private static readonly DEFAULT_MAX_KEYS = 20;
+
+  private readonly maxKeys: number;
+
+  constructor(options: RedactorWideObjectOptions = {}) {
+    this.maxKeys = options.maxKeys ?? RedactorCompactObjectStrategy.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.strategy.ts

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

package/src/redactor-mask.strategy.ts

@@ -0,0 +1,38 @@
+import cloneDeepWith from "lodash/cloneDeepWith";
+import type { RedactorStrategy } from "./redactor.strategy";
+
+export class RedactorMaskStrategy implements RedactorStrategy {
+  static readonly DEFAULT_KEYS: readonly string[] = [
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "x-api-key",
+    "apiKey",
+    "token",
+    "accessToken",
+    "refreshToken",
+
+    "password",
+    "currentPassword",
+    "newPassword",
+    "passwordConfirmation",
+    "clientSecret",
+    "secret",
+
+    "otp",
+    "code",
+  ];
+
+  private readonly keys: Set<string>;
+
+  constructor(keys: readonly string[]) {
+    this.keys = new Set(keys.map((key) => key.toLowerCase()));
+  }
+
+  redact<T>(input: T): T {
+    return cloneDeepWith(input, (_value, key) => {
+      if (typeof key === "string" && this.keys.has(key.toLowerCase())) return "***";
+      return undefined;
+    });
+  }
+}

package/src/redactor-noop.strategy.ts

@@ -0,0 +1,7 @@
+import type { RedactorStrategy } from "./redactor.strategy";
+
+export class RedactorNoopStrategy implements RedactorStrategy {
+  redact<T>(input: T): T {
+    return input;
+  }
+}

package/src/redactor.strategy.ts

@@ -0,0 +1,3 @@
+export interface RedactorStrategy {
+  redact<T>(value: T): T;
+}

package/src/retry-backoff-exponential.strategy.ts

@@ -0,0 +1,11 @@
+import * as tools from "@bgord/tools";
+import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
+
+export class RetryBackoffExponentialStrategy implements RetryBackoffStrategy {
+  constructor(private readonly delay: tools.Duration) {}
+
+  next(attempt: number) {
+    if (attempt === 0) return tools.Duration.Ms(0);
+    return this.delay.times(tools.MultiplicationFactor.parse(2 ** (attempt - 1)));
+  }
+}

package/src/retry-backoff-fibonacci.strategy.ts

@@ -0,0 +1,16 @@
+import * as tools from "@bgord/tools";
+import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
+
+export class RetryBackoffFibonacciStrategy implements RetryBackoffStrategy {
+  constructor(private readonly delay: tools.Duration) {}
+
+  next(attempt: number) {
+    return this.delay.times(tools.MultiplicationFactor.parse(this.fibonacci(attempt)));
+  }
+
+  private fibonacci(n: number): number {
+    if (n === 0) return 0;
+    if (n === 1) return 1;
+    return this.fibonacci(n - 1) + this.fibonacci(n - 2);
+  }
+}