@bgord/bun 1.15.4 → 1.15.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.15.4",
+  "version": "1.15.5",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -28,10 +28,10 @@
     "@types/bun": "1.3.11",
     "@types/nodemailer": "7.0.11",
     "@types/yazl": "3.3.0",
-    "better-auth": "1.5.5",
+    "better-auth": "1.5.6",
     "cspell": "9.7.0",
     "csv": "6.5.1",
-    "knip": "6.0.0",
+    "knip": "6.0.2",
     "lefthook": "2.1.4",
     "lockfile-lint": "5.0.0",
     "nodemailer": "8.0.3",
@@ -43,13 +43,13 @@
     "yazl": "3.3.1"
   },
   "dependencies": {
-    "@bgord/tools": "1.4.3",
+    "@bgord/tools": "1.4.4",
     "emittery": "2.0.0",
     "hono": "4.12.8",
     "node-cache": "5.1.2"
   },
   "peerDependencies": {
-    "better-auth": "1.5.5",
+    "better-auth": "1.5.6",
     "csv": "6.5.1",
     "nodemailer": "8.0.3",
     "resend": "6.9.4",

package/readme.md

@@ -36,6 +36,17 @@ src/
 ├── ab-variant.vo.ts
 ├── ab-variants.vo.ts
 ├── ab.middleware.ts
+├── alert-channel-collecting.adapter.ts
+├── alert-channel-composite.adapter.ts
+├── alert-channel-mailer.adapter.ts
+├── alert-channel-noop.adapter.ts
+├── alert-channel-sms.adapter.ts
+├── alert-channel-with-logger.adapter.ts
+├── alert-channel-with-retry.adapter.ts
+├── alert-channel-with-timeout.adapter.ts
+├── alert-channel.builder.ts
+├── alert-channel.port.ts
+├── alert-message.vo.ts
 ├── antivirus-clamav.adapter.ts
 ├── antivirus-noop.adapter.ts
 ├── antivirus.port.ts
@@ -248,6 +259,7 @@ src/
 ├── logger-stats-provider-noop.adapter.ts
 ├── logger-stats-provider.port.ts
 ├── logger.port.ts
+├── mailer-collecting.adapter.ts
 ├── mailer-content-html.vo.ts
 ├── mailer-noop.adapter.ts
 ├── mailer-resend.adapter.ts
@@ -344,6 +356,7 @@ src/
 ├── prerequisite-verifier-ram.adapter.ts
 ├── prerequisite-verifier-running-user.adapter.ts
 ├── prerequisite-verifier-self.adapter.ts
+├── prerequisite-verifier-sms.adapter.ts
 ├── prerequisite-verifier-space.adapter.ts
 ├── prerequisite-verifier-sqlite.adapter.ts
 ├── prerequisite-verifier-ssl-certificate-expiry.adapter.ts
@@ -444,6 +457,13 @@ src/
 ├── sleeper.port.ts
 ├── slower-hono.middleware.ts
 ├── slower.middleware.ts
+├── sms-collecting.adapter.ts
+├── sms-noop.adapter.ts
+├── sms-with-logger.adapter.ts
+├── sms-with-retry.adapter.ts
+├── sms-with-timeout.adapter.ts
+├── sms.builder.ts
+├── sms.port.ts
 ├── smtp-host.vo.ts
 ├── smtp-pass.vo.ts
 ├── smtp-port.vo.ts

package/src/alert-channel-collecting.adapter.ts

@@ -0,0 +1,14 @@
+import type { AlertChannelPort } from "./alert-channel.port";
+import type { AlertMessage } from "./alert-message.vo";
+
+export class AlertChannelCollectingAdapter implements AlertChannelPort {
+  readonly alerts: Array<AlertMessage> = [];
+
+  async send(alert: AlertMessage): Promise<void> {
+    this.alerts.push(alert);
+  }
+
+  async verify(): Promise<boolean> {
+    return true;
+  }
+}

package/src/alert-channel-composite.adapter.ts

@@ -0,0 +1,24 @@
+import type { AlertChannelPort } from "./alert-channel.port";
+import type { AlertMessage } from "./alert-message.vo";
+
+export const AlertChannelCompositeError = {
+  Min: "alert.channel.composite.channels.min",
+  Max: "alert.channel.composite.channels.max",
+};
+
+export class AlertChannelCompositeAdapter implements AlertChannelPort {
+  constructor(private readonly channels: ReadonlyArray<AlertChannelPort>) {
+    if (this.channels.length === 0) throw new Error(AlertChannelCompositeError.Min);
+    if (this.channels.length > 5) throw new Error(AlertChannelCompositeError.Max);
+  }
+
+  async send(alert: AlertMessage): Promise<void> {
+    await Promise.allSettled(this.channels.map((channel) => channel.send(alert)));
+  }
+
+  async verify(): Promise<boolean> {
+    const checks = await Promise.all(this.channels.map((channel) => channel.verify()));
+
+    return checks.every(Boolean);
+  }
+}

package/src/alert-channel-mailer.adapter.ts

@@ -0,0 +1,22 @@
+import type { AlertChannelPort } from "./alert-channel.port";
+import type { AlertMessage } from "./alert-message.vo";
+import type { MailerPort } from "./mailer.port";
+import type { MailerTemplate } from "./mailer-template.vo";
+
+export type AlertChannelMailerAdapterConfig = { template: (alert: AlertMessage) => MailerTemplate };
+export type AlertChannelMailerAdapterDependencies = { Mailer: MailerPort };
+
+export class AlertChannelMailerAdapter implements AlertChannelPort {
+  constructor(
+    private readonly config: AlertChannelMailerAdapterConfig,
+    private readonly deps: AlertChannelMailerAdapterDependencies,
+  ) {}
+
+  async send(alert: AlertMessage): Promise<void> {
+    await this.deps.Mailer.send(this.config.template(alert));
+  }
+
+  async verify(): Promise<boolean> {
+    return this.deps.Mailer.verify();
+  }
+}

package/src/alert-channel-noop.adapter.ts

@@ -0,0 +1,10 @@
+import type { AlertChannelPort } from "./alert-channel.port";
+import type { AlertMessage } from "./alert-message.vo";
+
+export class AlertChannelNoopAdapter implements AlertChannelPort {
+  async send(_alert: AlertMessage): Promise<void> {}
+
+  async verify(): Promise<boolean> {
+    return true;
+  }
+}

package/src/alert-channel-sms.adapter.ts

@@ -0,0 +1,22 @@
+import type * as tools from "@bgord/tools";
+import type { AlertChannelPort } from "./alert-channel.port";
+import type { AlertMessage } from "./alert-message.vo";
+import type { SmsPort } from "./sms.port";
+
+export type AlertChannelSmsAdapterConfig = { message: (alert: AlertMessage) => tools.SmsMessage };
+export type AlertChannelSmsAdapterDependencies = { Sms: SmsPort };
+
+export class AlertChannelSmsAdapter implements AlertChannelPort {
+  constructor(
+    private readonly config: AlertChannelSmsAdapterConfig,
+    private readonly deps: AlertChannelSmsAdapterDependencies,
+  ) {}
+
+  async send(alert: AlertMessage): Promise<void> {
+    await this.deps.Sms.send(this.config.message(alert));
+  }
+
+  async verify(): Promise<boolean> {
+    return this.deps.Sms.verify();
+  }
+}

package/src/alert-channel-with-logger.adapter.ts

@@ -0,0 +1,46 @@
+import type { AlertChannelPort } from "./alert-channel.port";
+import type { AlertMessage } from "./alert-message.vo";
+import type { ClockPort } from "./clock.port";
+import type { LoggerPort } from "./logger.port";
+import { Stopwatch } from "./stopwatch.service";
+
+export type AlertChannelWithLoggerAdapterDependencies = {
+  inner: AlertChannelPort;
+  Logger: LoggerPort;
+  Clock: ClockPort;
+};
+
+export class AlertChannelWithLoggerAdapter implements AlertChannelPort {
+  private readonly base = { component: "infra", operation: "alert_channel" };
+
+  constructor(private readonly deps: AlertChannelWithLoggerAdapterDependencies) {}
+
+  async send(alert: AlertMessage): Promise<void> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({ message: "Alert channel attempt", metadata: alert.toJSON(), ...this.base });
+
+      await this.deps.inner.send(alert);
+
+      this.deps.Logger.info({
+        message: "Alert channel success",
+        metadata: { alert: alert.toJSON(), duration: duration.stop() },
+        ...this.base,
+      });
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Alert channel error",
+        error,
+        metadata: duration.stop(),
+        ...this.base,
+      });
+
+      throw error;
+    }
+  }
+
+  async verify(): Promise<boolean> {
+    return this.deps.inner.verify();
+  }
+}

package/src/alert-channel-with-retry.adapter.ts

@@ -0,0 +1,22 @@
+import type { AlertChannelPort } from "./alert-channel.port";
+import type { AlertMessage } from "./alert-message.vo";
+import { Retry, type RetryConfig } from "./retry.service";
+import type { SleeperPort } from "./sleeper.port";
+
+export type AlertChannelWithRetryAdapterDependencies = { Sleeper: SleeperPort; inner: AlertChannelPort };
+export type AlertChannelWithRetryAdapterConfig = { retry: RetryConfig };
+
+export class AlertChannelWithRetryAdapter implements AlertChannelPort {
+  constructor(
+    private readonly config: AlertChannelWithRetryAdapterConfig,
+    private readonly deps: AlertChannelWithRetryAdapterDependencies,
+  ) {}
+
+  async send(alert: AlertMessage): Promise<void> {
+    await new Retry(this.deps).run(async () => this.deps.inner.send(alert), this.config.retry);
+  }
+
+  async verify(): Promise<boolean> {
+    return this.deps.inner.verify();
+  }
+}

package/src/alert-channel-with-timeout.adapter.ts

@@ -0,0 +1,25 @@
+import type * as tools from "@bgord/tools";
+import type { AlertChannelPort } from "./alert-channel.port";
+import type { AlertMessage } from "./alert-message.vo";
+import type { TimeoutRunnerPort } from "./timeout-runner.port";
+
+export type AlertChannelWithTimeoutAdapterDependencies = {
+  TimeoutRunner: TimeoutRunnerPort;
+  inner: AlertChannelPort;
+};
+export type AlertChannelWithTimeoutAdapterConfig = { timeout: tools.Duration };
+
+export class AlertChannelWithTimeoutAdapter implements AlertChannelPort {
+  constructor(
+    private readonly config: AlertChannelWithTimeoutAdapterConfig,
+    private readonly deps: AlertChannelWithTimeoutAdapterDependencies,
+  ) {}
+
+  async send(alert: AlertMessage): Promise<void> {
+    await this.deps.TimeoutRunner.run(this.deps.inner.send(alert), this.config.timeout);
+  }
+
+  async verify(): Promise<boolean> {
+    return this.deps.inner.verify();
+  }
+}

package/src/alert-channel.builder.ts

@@ -0,0 +1,48 @@
+import type { AlertChannelPort } from "./alert-channel.port";
+import {
+  AlertChannelWithLoggerAdapter,
+  type AlertChannelWithLoggerAdapterDependencies,
+} from "./alert-channel-with-logger.adapter";
+import {
+  AlertChannelWithRetryAdapter,
+  type AlertChannelWithRetryAdapterConfig,
+  type AlertChannelWithRetryAdapterDependencies,
+} from "./alert-channel-with-retry.adapter";
+import {
+  AlertChannelWithTimeoutAdapter,
+  type AlertChannelWithTimeoutAdapterConfig,
+  type AlertChannelWithTimeoutAdapterDependencies,
+} from "./alert-channel-with-timeout.adapter";
+
+export class AlertChannelBuilder {
+  constructor(private inner: AlertChannelPort) {}
+
+  static of(channel: AlertChannelPort): AlertChannelBuilder {
+    return new AlertChannelBuilder(channel);
+  }
+
+  withLogger(deps: Omit<AlertChannelWithLoggerAdapterDependencies, "inner">) {
+    this.inner = new AlertChannelWithLoggerAdapter({ ...deps, inner: this.inner });
+    return this;
+  }
+
+  withRetry(
+    config: AlertChannelWithRetryAdapterConfig,
+    deps: Omit<AlertChannelWithRetryAdapterDependencies, "inner">,
+  ) {
+    this.inner = new AlertChannelWithRetryAdapter(config, { ...deps, inner: this.inner });
+    return this;
+  }
+
+  withTimeout(
+    config: AlertChannelWithTimeoutAdapterConfig,
+    deps: Omit<AlertChannelWithTimeoutAdapterDependencies, "inner">,
+  ) {
+    this.inner = new AlertChannelWithTimeoutAdapter(config, { ...deps, inner: this.inner });
+    return this;
+  }
+
+  build(): AlertChannelPort {
+    return this.inner;
+  }
+}

package/src/alert-channel.port.ts

@@ -0,0 +1,7 @@
+import type { AlertMessage } from "./alert-message.vo";
+
+export interface AlertChannelPort {
+  send(alert: AlertMessage): Promise<void>;
+
+  verify(): Promise<boolean>;
+}

package/src/alert-message.vo.ts

@@ -0,0 +1,10 @@
+export class AlertMessage {
+  constructor(
+    readonly message: string,
+    readonly error?: unknown,
+  ) {}
+
+  toJSON() {
+    return { message: this.message, error: this.error };
+  }
+}

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";
@@ -222,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";
@@ -281,6 +293,7 @@ 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";
@@ -373,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/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/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>;
+}