@bgord/bun 1.15.4 → 1.16.0

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/antivirus-clamav.adapter.ts

@@ -29,7 +29,7 @@ export class AntivirusClamavAdapter implements AntivirusPort {
       const signature = stdout.match(this.signature) ?? stderr.match(this.signature);
 
       // Stryker disable all
-      return { clean: false, signature: signature?.groups?.signature?.trim() ?? "unknown" };
+      return { clean: false, signature: signature?.groups?.["signature"]?.trim() ?? "unknown" };
       // Stryker restore all
     }
 

package/src/api-version-hono.middleware.ts

@@ -1,14 +1,15 @@
 import type { MiddlewareHandler } from "hono";
 import { ApiVersionMiddleware } from "./api-version.middleware";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
+import type { BuildInfoType } from "./build-info.vo";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
 import type { HashContentStrategy } from "./hash-content.strategy";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import type { ReactiveConfigPort } from "./reactive-config.port";
 
 type Dependencies = {
   CacheResolver: CacheResolverStrategy;
   HashContent: HashContentStrategy;
-  BuildInfoRepository: BuildInfoRepositoryStrategy;
+  BuildInfoConfig: ReactiveConfigPort<BuildInfoType>;
 };
 
 export class ApiVersionHonoMiddleware implements MiddlewareHonoPort {

package/src/api-version.middleware.ts

@@ -1,14 +1,15 @@
 import type * as tools from "@bgord/tools";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
+import type { BuildInfoType } from "./build-info.vo";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
 import type { HashContentStrategy } from "./hash-content.strategy";
+import type { ReactiveConfigPort } from "./reactive-config.port";
 import { SubjectApplicationResolver } from "./subject-application-resolver.vo";
 import { SubjectSegmentFixedStrategy } from "./subject-segment-fixed.strategy";
 
 type Dependencies = {
   CacheResolver: CacheResolverStrategy;
   HashContent: HashContentStrategy;
-  BuildInfoRepository: BuildInfoRepositoryStrategy;
+  BuildInfoConfig: ReactiveConfigPort<BuildInfoType>;
 };
 
 export class ApiVersionMiddleware {
@@ -16,7 +17,7 @@ export class ApiVersionMiddleware {
 
   constructor(private readonly deps: Dependencies) {}
 
-  async evaluate(): Promise<tools.PackageVersion> {
+  async evaluate(): Promise<tools.PackageVersionSchemaType> {
     const resolver = new SubjectApplicationResolver(
       [new SubjectSegmentFixedStrategy("api-version")],
       this.deps,
@@ -24,7 +25,7 @@ export class ApiVersionMiddleware {
     const subject = await resolver.resolve();
 
     const build = await this.deps.CacheResolver.resolve(subject.hex, async () =>
-      this.deps.BuildInfoRepository.extract(),
+      this.deps.BuildInfoConfig.get(),
     );
 
     return build.version;

package/src/build-info.vo.ts

@@ -0,0 +1,14 @@
+import * as tools from "@bgord/tools";
+import * as v from "valibot";
+import { CommitShaValue } from "./commit-sha-value.vo";
+
+export const BuildInfo = v.object({
+  timestamp: tools.TimestampValue,
+  version: tools.PackageVersionSchema,
+  sha: CommitShaValue,
+  size: tools.SizeBytes,
+});
+
+export type BuildInfoType = v.InferOutput<typeof BuildInfo>;
+
+export const BUILD_INFO_FILE_PATH = tools.FilePathRelative.fromString("infra/build-info.json");

package/src/error-normalizer.service.ts

@@ -8,7 +8,7 @@ export class ErrorNormalizer {
   }
 
   static isNormalizedError(value: unknown): value is NormalizedError {
-    return isPlainObject(value) && "message" in value && typeof value.message === "string";
+    return isPlainObject(value) && "message" in value && typeof value["message"] === "string";
   }
 
   private static normalizeWithGuard(error: unknown, seen: WeakSet<object>): NormalizedError {

package/src/healthcheck-hono.handler.ts

@@ -1,13 +1,14 @@
 import { createFactory } from "hono/factory";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
+import type { BuildInfoType } from "./build-info.vo";
 import type { ClockPort } from "./clock.port";
 import type { HandlerHonoPort } from "./handler-hono.port";
 import { type HealthcheckConfig, HealthcheckHandler } from "./healthcheck.handler";
 import type { LoggerStatsProviderPort } from "./logger-stats-provider.port";
+import type { ReactiveConfigPort } from "./reactive-config.port";
 
 type Dependencies = {
   Clock: ClockPort;
-  BuildInfoRepository: BuildInfoRepositoryStrategy;
+  BuildInfoConfig: ReactiveConfigPort<BuildInfoType>;
   LoggerStatsProvider?: LoggerStatsProviderPort;
 };
 

package/src/healthcheck.handler.ts

@@ -1,6 +1,6 @@
 import os from "node:os";
 import * as tools from "@bgord/tools";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
+import type { BuildInfoType } from "./build-info.vo";
 import type { ClockPort } from "./clock.port";
 import type { CommitShaValueType } from "./commit-sha-value.vo";
 import { EventLoopLag } from "./event-loop-lag.service";
@@ -15,6 +15,7 @@ import {
   type PrerequisiteVerificationResult,
 } from "./prerequisite-verifier.port";
 import { PrerequisiteVerifierSelfAdapter } from "./prerequisite-verifier-self.adapter";
+import type { ReactiveConfigPort } from "./reactive-config.port";
 import type { RedactorStrategy } from "./redactor.strategy";
 import { Stopwatch } from "./stopwatch.service";
 import { Uptime, type UptimeResultType } from "./uptime.service";
@@ -27,7 +28,7 @@ export enum HealthcheckStatusEnum {
 
 type Dependencies = {
   Clock: ClockPort;
-  BuildInfoRepository: BuildInfoRepositoryStrategy;
+  BuildInfoConfig: ReactiveConfigPort<BuildInfoType>;
   LoggerStatsProvider?: LoggerStatsProviderPort;
 };
 
@@ -125,7 +126,7 @@ export class HealthcheckHandler {
         ? HealthcheckStatusEnum.degraded
         : HealthcheckStatusEnum.healthy;
 
-    const build = await this.deps.BuildInfoRepository.extract();
+    const build = await this.deps.BuildInfoConfig.get();
     const uptime = Uptime.get(this.deps.Clock);
     const histogram = EventLoopLag.snapshot();
     const memory = MemoryConsumption.snapshot();
@@ -135,11 +136,11 @@ export class HealthcheckHandler {
       code: HealthcheckStatusCode[status],
       details,
       deployment: {
-        version: build.version.toString(),
-        timestamp: build.timestamp.ms,
-        date: new Date(build.timestamp.ms).toISOString(),
-        sha: build.sha.toString(),
-        size: build.size.format(tools.Size.unit.MB),
+        version: build.version,
+        timestamp: build.timestamp,
+        date: new Date(build.timestamp).toISOString(),
+        sha: build.sha,
+        size: tools.Size.fromBytes(build.size).format(tools.Size.unit.MB),
         environment: this.config.Env,
       },
       server: {

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";
@@ -24,10 +35,7 @@ export * from "./basic-auth-username.vo";
 export * from "./better-auth-logger.service";
 export * from "./binary.vo";
 export * from "./bots.vo";
-export * from "./build-info-repository.strategy";
-export * from "./build-info-repository-file.strategy";
-export * from "./build-info-repository-noop.strategy";
-export * from "./build-info-repository-package-json.strategy";
+export * from "./build-info.vo";
 export * from "./cache-file.service";
 export * from "./cache-repository.port";
 export * from "./cache-repository-node-cache.adapter";
@@ -222,6 +230,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 +290,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";
@@ -290,6 +300,11 @@ export * from "./randomness.strategy";
 export * from "./randomness-crypto.strategy";
 export * from "./randomness-math.strategy";
 export * from "./randomness-noop.strategy";
+export * from "./reactive-config.port";
+export * from "./reactive-config-file-json.adapter";
+export * from "./reactive-config-noop.adapter";
+export * from "./reactive-config-with-cache.adapter";
+export * from "./reactive-config-with-fallback.adapter";
 export * from "./readiness.handler";
 export * from "./readiness-hono.handler";
 export * from "./recaptcha-secret-key.vo";
@@ -373,6 +388,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/reactive-config-file-json.adapter.ts

@@ -0,0 +1,26 @@
+import type * as tools from "@bgord/tools";
+import type { FileReaderJsonPort } from "./file-reader-json.port";
+import {
+  ReactiveConfigError,
+  type ReactiveConfigPort,
+  type ReactiveConfigSchema,
+} from "./reactive-config.port";
+
+type Dependencies = { FileReaderJson: FileReaderJsonPort };
+
+export class ReactiveConfigFileJsonAdapter<T extends object> implements ReactiveConfigPort<T> {
+  constructor(
+    private readonly path: tools.FilePathAbsolute | tools.FilePathRelative,
+    private readonly schema: ReactiveConfigSchema<T>,
+    private readonly deps: Dependencies,
+  ) {}
+
+  async get(): Promise<Readonly<T>> {
+    const raw = await this.deps.FileReaderJson.read(this.path);
+
+    const result = this.schema["~standard"].validate(raw);
+    if (result instanceof Promise) throw new Error(ReactiveConfigError.NoAsyncSchema);
+    if (result.issues) throw new Error(result.issues[0]?.message);
+    return Object.freeze(result.value);
+  }
+}

package/src/reactive-config-noop.adapter.ts

@@ -0,0 +1,19 @@
+import {
+  ReactiveConfigError,
+  type ReactiveConfigPort,
+  type ReactiveConfigSchema,
+} from "./reactive-config.port";
+
+export class ReactiveConfigNoopAdapter<T extends object> implements ReactiveConfigPort<T> {
+  constructor(
+    private readonly schema: ReactiveConfigSchema<T>,
+    private readonly value: T,
+  ) {}
+
+  async get(): Promise<Readonly<T>> {
+    const result = this.schema["~standard"].validate(this.value);
+    if (result instanceof Promise) throw new Error(ReactiveConfigError.NoAsyncSchema);
+    if (result.issues) throw new Error(result.issues[0]?.message);
+    return Object.freeze(result.value);
+  }
+}

package/src/reactive-config-with-cache.adapter.ts

@@ -0,0 +1,19 @@
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import type { HashContentStrategy } from "./hash-content.strategy";
+import type { ReactiveConfigPort } from "./reactive-config.port";
+
+type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
+
+export class ReactiveConfigWithCacheAdapter<T extends object> implements ReactiveConfigPort<T> {
+  constructor(
+    private readonly inner: ReactiveConfigPort<T>,
+    private readonly subject: string,
+    private readonly deps: Dependencies,
+  ) {}
+
+  async get(): Promise<Readonly<T>> {
+    const key = await this.deps.HashContent.hash(this.subject);
+
+    return this.deps.CacheResolver.resolve(key, () => this.inner.get());
+  }
+}

package/src/reactive-config-with-fallback.adapter.ts

@@ -0,0 +1,24 @@
+import {
+  ReactiveConfigError,
+  type ReactiveConfigPort,
+  type ReactiveConfigSchema,
+} from "./reactive-config.port";
+
+export class ReactiveConfigWithFallbackAdapter<T extends object> implements ReactiveConfigPort<T> {
+  constructor(
+    private readonly inner: ReactiveConfigPort<T>,
+    private readonly schema: ReactiveConfigSchema<T>,
+    private readonly fallback: T,
+  ) {}
+
+  async get(): Promise<Readonly<T>> {
+    try {
+      return await this.inner.get();
+    } catch {
+      const result = this.schema["~standard"].validate(this.fallback);
+      if (result instanceof Promise) throw new Error(ReactiveConfigError.NoAsyncSchema);
+      if (result.issues) throw new Error(result.issues[0]?.message);
+      return Object.freeze(result.value);
+    }
+  }
+}

package/src/reactive-config.port.ts

@@ -0,0 +1,9 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+export const ReactiveConfigError = { NoAsyncSchema: "reactive.config.no.async.schema" };
+
+export type ReactiveConfigSchema<T extends object> = StandardSchemaV1<unknown, T>;
+
+export interface ReactiveConfigPort<T extends object> {
+  get(): Promise<Readonly<T>>;
+}

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

@@ -10,9 +10,8 @@ export class RedactorErrorCauseDepthLimit implements RedactorStrategy {
     // Stryker disable all
     if (!isPlainObject(input)) return input;
     // Stryker restore all
-    if (!ErrorNormalizer.isNormalizedError(input.error)) return input;
-
-    return { ...input, error: this.limit(input.error, tools.Int.nonNegative(0)) };
+    if (!ErrorNormalizer.isNormalizedError(input["error"])) return input;
+    return { ...input, error: this.limit(input["error"], tools.Int.nonNegative(0)) };
   }
 
   private limit(error: NormalizedError, depth: tools.IntegerNonNegativeType): NormalizedError {

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

@@ -7,9 +7,8 @@ export class RedactorErrorStackHide implements RedactorStrategy {
     // Stryker disable all
     if (!isPlainObject(input)) return input;
     // Stryker restore all
-    if (!ErrorNormalizer.isNormalizedError(input.error)) return input;
-
-    return { ...input, error: this.hide(input.error) };
+    if (!ErrorNormalizer.isNormalizedError(input["error"])) return input;
+    return { ...input, error: this.hide(input["error"]) };
   }
 
   private hide(error: NormalizedError): NormalizedError {

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

@@ -20,7 +20,7 @@ export class RedactorMetadataCompactArray implements RedactorStrategy {
     return {
       ...input,
       metadata: deepCloneWith(
-        input.metadata,
+        input["metadata"],
         (value) => {
           if (!Array.isArray(value)) return undefined;
           if (value.length <= this.maxItems) return undefined;

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

@@ -20,7 +20,7 @@ export class RedactorMetadataCompactObject implements RedactorStrategy {
     return {
       ...input,
       metadata: deepCloneWith(
-        input.metadata,
+        input["metadata"],
         (value) => {
           if (!isPlainObject(value) || Array.isArray(value)) return undefined;
 

package/src/setup-hono.service.ts

@@ -3,7 +3,7 @@ import type { MiddlewareHandler } from "hono";
 import { cors } from "hono/cors";
 import { secureHeaders } from "hono/secure-headers";
 import { ApiVersionHonoMiddleware } from "./api-version-hono.middleware";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
+import type { BuildInfoType } from "./build-info.vo";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
 import type { ClockPort } from "./clock.port";
 import { CorrelationHonoMiddleware } from "./correlation-hono.middleware";
@@ -15,6 +15,7 @@ import type { IdProviderPort } from "./id-provider.port";
 import type { LanguageDetectorMiddlewareConfig } from "./language-detector.middleware";
 import { LanguageDetectorHonoMiddleware } from "./language-detector-hono.middleware";
 import type { LoggerPort } from "./logger.port";
+import type { ReactiveConfigPort } from "./reactive-config.port";
 import type { ShieldCsrfConfig } from "./shield-csrf.strategy";
 import { ShieldCsrfHonoStrategy } from "./shield-csrf-hono.strategy";
 import type { ShieldMaintenanceConfig } from "./shield-maintenance.strategy";
@@ -30,7 +31,7 @@ type Dependencies = {
   Clock: ClockPort;
   CacheResolver: CacheResolverStrategy;
   HashContent: HashContentStrategy;
-  BuildInfoRepository: BuildInfoRepositoryStrategy;
+  BuildInfoConfig: ReactiveConfigPort<BuildInfoType>;
 };
 
 type Config<T extends tools.LanguageType> = {

package/src/shield-recaptcha.strategy.ts

@@ -19,7 +19,7 @@ export class ShieldRecaptchaStrategy {
   async evaluate(context: HasRequestHeader & HasRequestQuery, formToken: string | null): Promise<boolean> {
     try {
       const header = context.request.header("x-recaptcha-token");
-      const query = context.request.query().recaptchaToken;
+      const query = context.request.query()["recaptchaToken"];
       const remoteip = context.request.header("x-forwarded-for") ?? "";
 
       const token = header ?? query ?? formToken;

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();
+  }
+}