@bgord/bun 1.15.3 → 1.15.5

package/src/index.ts

@@ -10,6 +10,17 @@ export * from "./ab-variant.vo";
 export * from "./ab-variant-selector.service";
 export * from "./ab-variant-weight.vo";
 export * from "./ab-variants.vo";
+export * from "./alert-channel.builder";
+export * from "./alert-channel.port";
+export * from "./alert-channel-collecting.adapter";
+export * from "./alert-channel-composite.adapter";
+export * from "./alert-channel-mailer.adapter";
+export * from "./alert-channel-noop.adapter";
+export * from "./alert-channel-sms.adapter";
+export * from "./alert-channel-with-logger.adapter";
+export * from "./alert-channel-with-retry.adapter";
+export * from "./alert-channel-with-timeout.adapter";
+export * from "./alert-message.vo";
 export * from "./antivirus.port";
 export * from "./antivirus-clamav.adapter";
 export * from "./antivirus-noop.adapter";
@@ -32,6 +43,7 @@ export * from "./cache-file.service";
 export * from "./cache-repository.port";
 export * from "./cache-repository-node-cache.adapter";
 export * from "./cache-repository-noop.adapter";
+export * from "./cache-repository-redis.adapter";
 export * from "./cache-resolver.strategy";
 export * from "./cache-resolver-simple.strategy";
 export * from "./cache-response.middleware";
@@ -182,6 +194,9 @@ export * from "./image-exif-clear-sharp.adapter";
 export * from "./image-formatter.port";
 export * from "./image-formatter-noop.adapter";
 export * from "./image-formatter-sharp.adapter";
+export * from "./image-grayscale.port";
+export * from "./image-grayscale-noop.adapter";
+export * from "./image-grayscale-sharp.adapter";
 export * from "./image-info.port";
 export * from "./image-info-noop.adapter";
 export * from "./image-info-sharp.adapter";
@@ -208,6 +223,8 @@ export * from "./language-detector-header.strategy";
 export * from "./language-detector-hono.middleware";
 export * from "./language-detector-query.strategy";
 export * from "./languages.vo";
+export * from "./liveness.handler";
+export * from "./liveness-hono.handler";
 export * from "./logger.port";
 export * from "./logger-collecting.adapter";
 export * from "./logger-noop.adapter";
@@ -216,6 +233,7 @@ export * from "./logger-stats-provider-noop.adapter";
 export * from "./mailer.builder";
 export * from "./mailer.builder";
 export * from "./mailer.port";
+export * from "./mailer-collecting.adapter";
 export * from "./mailer-content-html.vo";
 export * from "./mailer-noop.adapter";
 export * from "./mailer-resend.adapter";
@@ -253,8 +271,6 @@ export * from "./nonce-value.vo";
 export * from "./pdf-generator.port";
 export * from "./pdf-generator-noop.adapter";
 export * from "./pdf-generator-with-logger.adapter";
-export * from "./ping.handler";
-export * from "./ping-hono.handler";
 export * from "./port.vo";
 export * from "./prerequisite.vo";
 export * from "./prerequisite-runner-startup.service";
@@ -277,11 +293,18 @@ export * from "./prerequisite-verifier-port.adapter";
 export * from "./prerequisite-verifier-ram.adapter";
 export * from "./prerequisite-verifier-running-user.adapter";
 export * from "./prerequisite-verifier-self.adapter";
+export * from "./prerequisite-verifier-sms.adapter";
 export * from "./prerequisite-verifier-space.adapter";
 export * from "./prerequisite-verifier-sqlite.adapter";
 export * from "./prerequisite-verifier-ssl-certificate-expiry.adapter";
 export * from "./prerequisite-verifier-timezone-utc.adapter";
 export * from "./prerequisite-verifier-translations.adapter";
+export * from "./randomness.strategy";
+export * from "./randomness-crypto.strategy";
+export * from "./randomness-math.strategy";
+export * from "./randomness-noop.strategy";
+export * from "./readiness.handler";
+export * from "./readiness-hono.handler";
 export * from "./recaptcha-secret-key.vo";
 export * from "./recaptcha-site-key.vo";
 export * from "./redactor.strategy";
@@ -300,7 +323,7 @@ export * from "./request-context-hono.adapter";
 export * from "./retry.service";
 export * from "./retry-backoff.strategy";
 export * from "./retry-backoff-exponential.strategy";
-export * from "./retry-backoff-fibonacci.strategy";
+export * from "./retry-backoff-jitter.strategy";
 export * from "./retry-backoff-linear.strategy";
 export * from "./retry-backoff-noop.strategy";
 export * from "./sealer.port";
@@ -342,6 +365,10 @@ export * from "./shield-csrf-hono.strategy";
 export * from "./shield-hcaptcha.strategy";
 export * from "./shield-hcaptcha-hono.strategy";
 export * from "./shield-hcaptcha-hono-local.strategy";
+export * from "./shield-ip-blacklist.strategy";
+export * from "./shield-ip-blacklist-hono.strategy";
+export * from "./shield-ip-whitelist.strategy";
+export * from "./shield-ip-whitelist-hono.strategy";
 export * from "./shield-maintenance.strategy";
 export * from "./shield-maintenance-hono.strategy";
 export * from "./shield-rate-limit.strategy";
@@ -359,6 +386,13 @@ export * from "./sleeper-noop.adapter";
 export * from "./sleeper-system.adapter";
 export * from "./slower.middleware";
 export * from "./slower-hono.middleware";
+export * from "./sms.builder";
+export * from "./sms.port";
+export * from "./sms-collecting.adapter";
+export * from "./sms-noop.adapter";
+export * from "./sms-with-logger.adapter";
+export * from "./sms-with-retry.adapter";
+export * from "./sms-with-timeout.adapter";
 export * from "./smtp-host.vo";
 export * from "./smtp-pass.vo";
 export * from "./smtp-port.vo";

package/src/liveness-hono.handler.ts

@@ -0,0 +1,13 @@
+import { createFactory } from "hono/factory";
+import type { HandlerHonoPort } from "./handler-hono.port";
+import { LivenessHandler } from "./liveness.handler";
+
+const factory = createFactory();
+
+export class LivenessHonoHandler implements HandlerHonoPort {
+  private readonly handler = new LivenessHandler();
+
+  handle() {
+    return factory.createHandlers(async (c) => c.json(this.handler.execute(), 200));
+  }
+}

package/src/liveness.handler.ts

@@ -0,0 +1,5 @@
+export class LivenessHandler {
+  execute(): { ok: true } {
+    return { ok: true };
+  }
+}

package/src/mailer-collecting.adapter.ts

@@ -0,0 +1,14 @@
+import type { MailerPort } from "./mailer.port";
+import type { MailerTemplate } from "./mailer-template.vo";
+
+export class MailerCollectingAdapter implements MailerPort {
+  messages: Array<MailerTemplate> = [];
+
+  async send(template: MailerTemplate): Promise<void> {
+    this.messages.push(template);
+  }
+
+  async verify(): Promise<boolean> {
+    return true;
+  }
+}

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

@@ -0,0 +1,26 @@
+import {
+  PrerequisiteVerification,
+  type PrerequisiteVerificationResult,
+  type PrerequisiteVerifierPort,
+} from "./prerequisite-verifier.port";
+import type { SmsPort } from "./sms.port";
+
+type Dependencies = { Sms: SmsPort };
+
+export class PrerequisiteVerifierSmsAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async verify(): Promise<PrerequisiteVerificationResult> {
+    try {
+      await this.deps.Sms.verify();
+
+      return PrerequisiteVerification.success;
+    } catch (error) {
+      return PrerequisiteVerification.failure(error);
+    }
+  }
+
+  get kind(): string {
+    return "sms";
+  }
+}

package/src/randomness-crypto.strategy.ts

@@ -0,0 +1,9 @@
+import type { RandomnessStrategy } from "./randomness.strategy";
+
+export class RandomnessCryptoStrategy implements RandomnessStrategy {
+  next(): number {
+    const array = new Uint32Array(1);
+    crypto.getRandomValues(array);
+    return array[0]! / 0xffffffff;
+  }
+}

package/src/randomness-math.strategy.ts

@@ -0,0 +1,7 @@
+import type { RandomnessStrategy } from "./randomness.strategy";
+
+export class RandomnessMathStrategy implements RandomnessStrategy {
+  next(): number {
+    return Math.random();
+  }
+}

package/src/randomness-noop.strategy.ts

@@ -0,0 +1,9 @@
+import type { RandomnessStrategy } from "./randomness.strategy";
+
+export class RandomnessNoopStrategy implements RandomnessStrategy {
+  constructor(private readonly value: number) {}
+
+  next(): number {
+    return this.value;
+  }
+}

package/src/randomness.strategy.ts

@@ -0,0 +1,3 @@
+export interface RandomnessStrategy {
+  next(): number;
+}

package/src/readiness-hono.handler.ts

@@ -0,0 +1,22 @@
+import { createFactory } from "hono/factory";
+import type { HandlerHonoPort } from "./handler-hono.port";
+import { type ReadinessConfig, ReadinessHandler } from "./readiness.handler";
+
+const factory = createFactory();
+
+export class ReadinessHonoHandler implements HandlerHonoPort {
+  private readonly handler: ReadinessHandler;
+
+  constructor(config: ReadinessConfig) {
+    this.handler = new ReadinessHandler(config);
+  }
+
+  handle() {
+    return factory.createHandlers(async (c) => {
+      const readiness = await this.handler.check();
+      const code = readiness.ok ? 200 : 503;
+
+      return c.json(readiness, code);
+    });
+  }
+}

package/src/readiness.handler.ts

@@ -0,0 +1,33 @@
+import type { Prerequisite, PrerequisiteLabelType } from "./prerequisite.vo";
+import {
+  PrerequisiteVerificationOutcome,
+  type PrerequisiteVerificationResult,
+} from "./prerequisite-verifier.port";
+
+export type ReadinessConfig = { prerequisites: ReadonlyArray<Prerequisite> };
+
+type ReadinessResult = {
+  ok: boolean;
+  details: ReadonlyArray<{ label: PrerequisiteLabelType; outcome: PrerequisiteVerificationResult }>;
+};
+
+export class ReadinessHandler {
+  constructor(private readonly config: ReadinessConfig) {}
+
+  async check(): Promise<ReadinessResult> {
+    const prerequisites = this.config.prerequisites
+      .filter((prerequisite) => prerequisite.enabled)
+      .filter((prerequisite) => prerequisite.kind !== "port");
+
+    const details = await Promise.all(
+      prerequisites.map(async (prerequisite) => ({
+        label: prerequisite.label,
+        outcome: await prerequisite.build().verify(),
+      })),
+    );
+
+    const ok = details.every((detail) => detail.outcome.outcome !== PrerequisiteVerificationOutcome.failure);
+
+    return { ok, details };
+  }
+}

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

@@ -0,0 +1,15 @@
+import * as tools from "@bgord/tools";
+import * as v from "valibot";
+import type { RandomnessStrategy } from "./randomness.strategy";
+import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
+
+export class RetryBackoffJitterStrategy implements RetryBackoffStrategy {
+  constructor(
+    private readonly delay: tools.Duration,
+    private readonly randomness: RandomnessStrategy,
+  ) {}
+
+  next(attempt: tools.IntegerPositiveType): tools.Duration {
+    return this.delay.times(v.parse(tools.MultiplicationFactor, attempt * this.randomness.next()));
+  }
+}

package/src/shield-ip-blacklist-hono.strategy.ts

@@ -0,0 +1,30 @@
+import type { MiddlewareHandler } from "hono";
+import { HTTPException } from "hono/http-exception";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+import {
+  type ShieldIpBlacklistConfig,
+  ShieldIpBlacklistStrategy,
+  ShieldIpBlacklistStrategyError,
+} from "./shield-ip-blacklist.strategy";
+
+export const ShieldIpBlacklistError = new HTTPException(403, {
+  message: ShieldIpBlacklistStrategyError.Rejected,
+});
+
+export class ShieldIpBlacklistHonoStrategy implements MiddlewareHonoPort {
+  private readonly strategy: ShieldIpBlacklistStrategy;
+
+  constructor(config: ShieldIpBlacklistConfig) {
+    this.strategy = new ShieldIpBlacklistStrategy(config);
+  }
+
+  handle(): MiddlewareHandler {
+    return async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+
+      if (this.strategy.evaluate(context)) return next();
+      throw ShieldIpBlacklistError;
+    };
+  }
+}

package/src/shield-ip-blacklist.strategy.ts

@@ -0,0 +1,18 @@
+import * as v from "valibot";
+import { ClientIp, type ClientIpType } from "./client-ip.vo";
+import type { HasIdentityIp } from "./request-context.port";
+
+export type ShieldIpBlacklistConfig = { blacklist: Array<ClientIpType> };
+
+export const ShieldIpBlacklistStrategyError = { Rejected: "shield.ip.blacklist.rejected" };
+
+export class ShieldIpBlacklistStrategy {
+  constructor(private readonly config: ShieldIpBlacklistConfig) {}
+
+  evaluate(context: HasIdentityIp): boolean {
+    const ip = v.safeParse(ClientIp, context.identity.ip());
+
+    if (!ip.success) return false;
+    return !this.config.blacklist.includes(ip.output);
+  }
+}

package/src/shield-ip-whitelist-hono.strategy.ts

@@ -0,0 +1,30 @@
+import type { MiddlewareHandler } from "hono";
+import { HTTPException } from "hono/http-exception";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+import {
+  type ShieldIpWhitelistConfig,
+  ShieldIpWhitelistStrategy,
+  ShieldIpWhitelistStrategyError,
+} from "./shield-ip-whitelist.strategy";
+
+export const ShieldIpWhitelistError = new HTTPException(403, {
+  message: ShieldIpWhitelistStrategyError.Rejected,
+});
+
+export class ShieldIpWhitelistHonoStrategy implements MiddlewareHonoPort {
+  private readonly strategy: ShieldIpWhitelistStrategy;
+
+  constructor(config: ShieldIpWhitelistConfig) {
+    this.strategy = new ShieldIpWhitelistStrategy(config);
+  }
+
+  handle(): MiddlewareHandler {
+    return async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+
+      if (this.strategy.evaluate(context)) return next();
+      throw ShieldIpWhitelistError;
+    };
+  }
+}

package/src/shield-ip-whitelist.strategy.ts

@@ -0,0 +1,18 @@
+import * as v from "valibot";
+import { ClientIp, type ClientIpType } from "./client-ip.vo";
+import type { HasIdentityIp } from "./request-context.port";
+
+export type ShieldIpWhitelistConfig = { whitelist: Array<ClientIpType> };
+
+export const ShieldIpWhitelistStrategyError = { Rejected: "shield.ip.whitelist.rejected" };
+
+export class ShieldIpWhitelistStrategy {
+  constructor(private readonly config: ShieldIpWhitelistConfig) {}
+
+  evaluate(context: HasIdentityIp): boolean {
+    const ip = v.safeParse(ClientIp, context.identity.ip());
+
+    if (!ip.success) return false;
+    return this.config.whitelist.includes(ip.output);
+  }
+}

package/src/sms-collecting.adapter.ts

@@ -0,0 +1,14 @@
+import type * as tools from "@bgord/tools";
+import type { SmsPort } from "./sms.port";
+
+export class SmsCollectingAdapter implements SmsPort {
+  readonly messages: Array<tools.SmsMessage> = [];
+
+  async send(message: tools.SmsMessage): Promise<void> {
+    this.messages.push(message);
+  }
+
+  async verify(): Promise<boolean> {
+    return true;
+  }
+}

package/src/sms-noop.adapter.ts

@@ -0,0 +1,10 @@
+import type * as tools from "@bgord/tools";
+import type { SmsPort } from "./sms.port";
+
+export class SmsNoopAdapter implements SmsPort {
+  async send(_message: tools.SmsMessage): Promise<void> {}
+
+  async verify(): Promise<boolean> {
+    return true;
+  }
+}

package/src/sms-with-logger.adapter.ts

@@ -0,0 +1,37 @@
+import type * as tools from "@bgord/tools";
+import type { ClockPort } from "./clock.port";
+import type { LoggerPort } from "./logger.port";
+import type { SmsPort } from "./sms.port";
+import { Stopwatch } from "./stopwatch.service";
+
+export type SmsWithLoggerAdapterDependencies = { inner: SmsPort; Logger: LoggerPort; Clock: ClockPort };
+
+export class SmsWithLoggerAdapter implements SmsPort {
+  private readonly base = { component: "infra", operation: "sms" };
+
+  constructor(private readonly deps: SmsWithLoggerAdapterDependencies) {}
+
+  async send(message: tools.SmsMessage): Promise<void> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({ message: "SMS attempt", metadata: message.toJSON(), ...this.base });
+
+      await this.deps.inner.send(message);
+
+      this.deps.Logger.info({
+        message: "SMS success",
+        metadata: { message: message.toJSON(), duration: duration.stop() },
+        ...this.base,
+      });
+    } catch (error) {
+      this.deps.Logger.error({ message: "SMS error", error, metadata: duration.stop(), ...this.base });
+
+      throw error;
+    }
+  }
+
+  async verify(): Promise<boolean> {
+    return this.deps.inner.verify();
+  }
+}

package/src/sms-with-retry.adapter.ts

@@ -0,0 +1,22 @@
+import type * as tools from "@bgord/tools";
+import { Retry, type RetryConfig } from "./retry.service";
+import type { SleeperPort } from "./sleeper.port";
+import type { SmsPort } from "./sms.port";
+
+export type SmsWithRetryAdapterDependencies = { Sleeper: SleeperPort; inner: SmsPort };
+export type SmsWithRetryAdapterConfig = { retry: RetryConfig };
+
+export class SmsWithRetryAdapter implements SmsPort {
+  constructor(
+    private readonly config: SmsWithRetryAdapterConfig,
+    private readonly deps: SmsWithRetryAdapterDependencies,
+  ) {}
+
+  async send(message: tools.SmsMessage): Promise<void> {
+    await new Retry(this.deps).run(async () => this.deps.inner.send(message), this.config.retry);
+  }
+
+  async verify(): Promise<boolean> {
+    return this.deps.inner.verify();
+  }
+}

package/src/sms-with-timeout.adapter.ts

@@ -0,0 +1,21 @@
+import type * as tools from "@bgord/tools";
+import type { SmsPort } from "./sms.port";
+import type { TimeoutRunnerPort } from "./timeout-runner.port";
+
+export type SmsWithTimeoutAdapterDependencies = { TimeoutRunner: TimeoutRunnerPort; inner: SmsPort };
+export type SmsWithTimeoutAdapterConfig = { timeout: tools.Duration };
+
+export class SmsWithTimeoutAdapter implements SmsPort {
+  constructor(
+    private readonly config: SmsWithTimeoutAdapterConfig,
+    private readonly deps: SmsWithTimeoutAdapterDependencies,
+  ) {}
+
+  async send(message: tools.SmsMessage): Promise<void> {
+    await this.deps.TimeoutRunner.run(this.deps.inner.send(message), this.config.timeout);
+  }
+
+  async verify(): Promise<boolean> {
+    return this.deps.inner.verify();
+  }
+}

package/src/sms.builder.ts

@@ -0,0 +1,39 @@
+import type { SmsPort } from "./sms.port";
+import { SmsWithLoggerAdapter, type SmsWithLoggerAdapterDependencies } from "./sms-with-logger.adapter";
+import {
+  SmsWithRetryAdapter,
+  type SmsWithRetryAdapterConfig,
+  type SmsWithRetryAdapterDependencies,
+} from "./sms-with-retry.adapter";
+import {
+  SmsWithTimeoutAdapter,
+  type SmsWithTimeoutAdapterConfig,
+  type SmsWithTimeoutAdapterDependencies,
+} from "./sms-with-timeout.adapter";
+
+export class SmsBuilder {
+  constructor(private inner: SmsPort) {}
+
+  static of(sms: SmsPort): SmsBuilder {
+    return new SmsBuilder(sms);
+  }
+
+  withLogger(deps: Omit<SmsWithLoggerAdapterDependencies, "inner">) {
+    this.inner = new SmsWithLoggerAdapter({ ...deps, inner: this.inner });
+    return this;
+  }
+
+  withRetry(config: SmsWithRetryAdapterConfig, deps: Omit<SmsWithRetryAdapterDependencies, "inner">) {
+    this.inner = new SmsWithRetryAdapter(config, { ...deps, inner: this.inner });
+    return this;
+  }
+
+  withTimeout(config: SmsWithTimeoutAdapterConfig, deps: Omit<SmsWithTimeoutAdapterDependencies, "inner">) {
+    this.inner = new SmsWithTimeoutAdapter(config, { ...deps, inner: this.inner });
+    return this;
+  }
+
+  build() {
+    return this.inner;
+  }
+}

package/src/sms.port.ts

@@ -0,0 +1,6 @@
+import type * as tools from "@bgord/tools";
+
+export interface SmsPort {
+  send(message: tools.SmsMessage): Promise<void>;
+  verify(): Promise<boolean>;
+}

package/dist/ping-hono.handler.d.ts

@@ -1,6 +0,0 @@
-import type { HandlerHonoPort } from "./handler-hono.port";
-export declare class PingHonoHandler implements HandlerHonoPort {
-    private readonly handler;
-    handle(): [import("hono/types").H<import("hono").Env, string, {}, Promise<Response & import("hono").TypedResponse<"pong", 200, "text">>>];
-}
-//# sourceMappingURL=ping-hono.handler.d.ts.map

package/dist/ping-hono.handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ping-hono.handler.d.ts","sourceRoot":"","sources":["../src/ping-hono.handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAK3D,qBAAa,eAAgB,YAAW,eAAe;IACrD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAE7C,MAAM;CAOP"}

package/dist/ping-hono.handler.js

@@ -1,13 +0,0 @@
-import { createFactory } from "hono/factory";
-import { PingHandler } from "./ping.handler";
-const factory = createFactory();
-export class PingHonoHandler {
-    handler = new PingHandler();
-    handle() {
-        return factory.createHandlers(async (c) => {
-            const result = this.handler.execute();
-            return c.text(result, 200);
-        });
-    }
-}
-//# sourceMappingURL=ping-hono.handler.js.map

package/dist/ping-hono.handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ping-hono.handler.js","sourceRoot":"","sources":["../src/ping-hono.handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,MAAM,OAAO,GAAG,aAAa,EAAE,CAAC;AAEhC,MAAM,OAAO,eAAe;IACT,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;IAE7C,MAAM;QACJ,OAAO,OAAO,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAEtC,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/ping.handler.d.ts

@@ -1,4 +0,0 @@
-export declare class PingHandler {
-    execute(): "pong";
-}
-//# sourceMappingURL=ping.handler.d.ts.map

package/dist/ping.handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ping.handler.d.ts","sourceRoot":"","sources":["../src/ping.handler.ts"],"names":[],"mappings":"AAAA,qBAAa,WAAW;IACtB,OAAO,IAAI,MAAM;CAGlB"}

package/dist/ping.handler.js

@@ -1,6 +0,0 @@
-export class PingHandler {
-    execute() {
-        return "pong";
-    }
-}
-//# sourceMappingURL=ping.handler.js.map

package/dist/ping.handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ping.handler.js","sourceRoot":"","sources":["../src/ping.handler.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,WAAW;IACtB,OAAO;QACL,OAAO,MAAM,CAAC;IAChB,CAAC;CACF"}

package/dist/retry-backoff-fibonacci.strategy.d.ts

@@ -1,9 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
-export declare class RetryBackoffFibonacciStrategy implements RetryBackoffStrategy {
-    private readonly delay;
-    constructor(delay: tools.Duration);
-    next(attempt: tools.IntegerPositiveType): tools.Duration;
-    private fibonacci;
-}
-//# sourceMappingURL=retry-backoff-fibonacci.strategy.d.ts.map

package/dist/retry-backoff-fibonacci.strategy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retry-backoff-fibonacci.strategy.d.ts","sourceRoot":"","sources":["../src/retry-backoff-fibonacci.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,qBAAa,6BAA8B,YAAW,oBAAoB;IAC5D,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAAL,KAAK,EAAE,KAAK,CAAC,QAAQ;IAElD,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,mBAAmB,GAAG,KAAK,CAAC,QAAQ;IAIxD,OAAO,CAAC,SAAS;CAKlB"}

package/dist/retry-backoff-fibonacci.strategy.js

@@ -1,19 +0,0 @@
-import * as tools from "@bgord/tools";
-import * as v from "valibot";
-export class RetryBackoffFibonacciStrategy {
-    delay;
-    constructor(delay) {
-        this.delay = delay;
-    }
-    next(attempt) {
-        return this.delay.times(v.parse(tools.MultiplicationFactor, this.fibonacci(attempt)));
-    }
-    fibonacci(n) {
-        if (n === 0)
-            return 0;
-        if (n === 1)
-            return 1;
-        return this.fibonacci(n - 1) + this.fibonacci(n - 2);
-    }
-}
-//# sourceMappingURL=retry-backoff-fibonacci.strategy.js.map

package/dist/retry-backoff-fibonacci.strategy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"retry-backoff-fibonacci.strategy.js","sourceRoot":"","sources":["../src/retry-backoff-fibonacci.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAG7B,MAAM,OAAO,6BAA6B;IACX;IAA7B,YAA6B,KAAqB;QAArB,UAAK,GAAL,KAAK,CAAgB;IAAG,CAAC;IAEtD,IAAI,CAAC,OAAkC;QACrC,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,oBAAoB,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACxF,CAAC;IAEO,SAAS,CAAC,CAAS;QACzB,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,CAAC,CAAC;QACtB,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,CAAC,CAAC;QACtB,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACvD,CAAC;CACF"}

package/src/ping-hono.handler.ts

@@ -1,17 +0,0 @@
-import { createFactory } from "hono/factory";
-import type { HandlerHonoPort } from "./handler-hono.port";
-import { PingHandler } from "./ping.handler";
-
-const factory = createFactory();
-
-export class PingHonoHandler implements HandlerHonoPort {
-  private readonly handler = new PingHandler();
-
-  handle() {
-    return factory.createHandlers(async (c) => {
-      const result = this.handler.execute();
-
-      return c.text(result, 200);
-    });
-  }
-}