@bgord/bun 1.6.6 → 1.7.0

package/src/redactor-encrypt.adapter.ts

@@ -1,32 +0,0 @@
-import { createCipheriv, randomBytes, scryptSync } from "node:crypto";
-import cloneDeepWith from "lodash/cloneDeepWith";
-import type { RedactorPort } from "./redactor.port";
-
-export class RedactorEncryptionAdapter implements RedactorPort {
-  private readonly secret: Buffer;
-
-  constructor(
-    secret: string,
-    private readonly key: string,
-  ) {
-    this.secret = scryptSync(secret, "redactor_salt", 32);
-  }
-
-  redact<T>(input: T): T {
-    const rootObject = Object(input);
-
-    return cloneDeepWith(input, (value, key, parent) => {
-      if (parent === rootObject && typeof key === "string" && key.toLowerCase() === this.key) {
-        const iv = randomBytes(12);
-        const cipher = createCipheriv("aes-256-gcm", this.secret, iv);
-        const plaintext = Buffer.from(JSON.stringify(value), "utf8");
-        const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
-        const tag = cipher.getAuthTag();
-
-        return `enc:gcm:${Buffer.concat([iv, tag, ciphertext]).toString("base64")}`;
-      }
-
-      return undefined;
-    });
-  }
-}

package/src/redactor-mask.adapter.ts

@@ -1,38 +0,0 @@
-import cloneDeepWith from "lodash/cloneDeepWith";
-import type { RedactorPort } from "./redactor.port";
-
-export class RedactorMaskAdapter implements RedactorPort {
-  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.adapter.ts

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

package/src/redactor.port.ts

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

package/src/secret.vo.ts

@@ -1,7 +0,0 @@
-import type * as tools from "@bgord/tools";
-import type { z } from "zod/v4";
-
-export interface Secret<T> {
-  key: tools.ObjectKeyType;
-  schema: z.ZodType<T>;
-}

package/src/shield-api-key.adapter.ts

@@ -1,20 +0,0 @@
-import type * as tools from "@bgord/tools";
-import { createMiddleware } from "hono/factory";
-import { HTTPException } from "hono/http-exception";
-import type { ShieldPort } from "./shield.port";
-
-type ApiKeyShieldConfigType = { API_KEY: tools.ApiKeyType };
-
-export const AccessDeniedApiKeyError = new HTTPException(403, { message: "access_denied_api_key" });
-
-export class ShieldApiKeyAdapter implements ShieldPort {
-  static readonly HEADER_NAME = "bgord-api-key";
-
-  constructor(private readonly config: ApiKeyShieldConfigType) {}
-
-  verify = createMiddleware(async (c, next) => {
-    if (c.req.header(ShieldApiKeyAdapter.HEADER_NAME) === this.config.API_KEY) return next();
-
-    throw AccessDeniedApiKeyError;
-  });
-}

package/src/shield-auth.middleware.ts

@@ -1,42 +0,0 @@
-// TODO: tests
-
-import type { betterAuth } from "better-auth";
-import type hono from "hono";
-import { createMiddleware } from "hono/factory";
-import { HTTPException } from "hono/http-exception";
-
-export const AccessDeniedAuthShieldError = new HTTPException(403, { message: "access_denied_auth_shield" });
-
-export class ShieldAuth {
-  constructor(private readonly Auth: ReturnType<typeof betterAuth>) {}
-
-  attach = createMiddleware(async (c: hono.Context, next: hono.Next) => {
-    const session = await this.Auth.api.getSession({ headers: c.req.raw.headers });
-
-    if (!session) {
-      c.set("user", null);
-      c.set("session", null);
-
-      return next();
-    }
-
-    c.set("user", session.user);
-    c.set("session", session.session);
-
-    return next();
-  });
-
-  verify = createMiddleware(async (c: hono.Context, next: hono.Next) => {
-    const user = c.get("user");
-
-    if (!user) throw AccessDeniedAuthShieldError;
-    return next();
-  });
-
-  reverse = createMiddleware(async (c: hono.Context, next: hono.Next) => {
-    const user = c.get("user");
-
-    if (user) throw AccessDeniedAuthShieldError;
-    return next();
-  });
-}

package/src/shield-basic-auth.adapter.ts

@@ -1,17 +0,0 @@
-import { basicAuth } from "hono/basic-auth";
-import { createMiddleware } from "hono/factory";
-import type { BasicAuthPasswordType } from "./basic-auth-password.vo";
-import type { BasicAuthUsernameType } from "./basic-auth-username.vo";
-import type { ShieldPort } from "./shield.port";
-
-type ShieldBasicAuthConfigType = { username: BasicAuthUsernameType; password: BasicAuthPasswordType };
-
-export class ShieldBasicAuthAdapter implements ShieldPort {
-  private readonly basicAuth;
-
-  constructor(config: ShieldBasicAuthConfigType) {
-    this.basicAuth = basicAuth(config);
-  }
-
-  verify = createMiddleware(async (c, next) => this.basicAuth(c, next));
-}

package/src/shield-captcha-hcaptcha-local.adapter.ts

@@ -1,24 +0,0 @@
-import hcaptcha from "hcaptcha";
-import { createMiddleware } from "hono/factory";
-import { HTTPException } from "hono/http-exception";
-import type { HCaptchaSecretKeyType } from "./hcaptcha-secret-key.vo";
-import type { ShieldPort } from "./shield.port";
-
-export const AccessDeniedHcaptchaLocalError = new HTTPException(403, {
-  message: "access_denied_hcaptcha_local",
-});
-
-export class ShieldCaptchaHcaptchaLocalAdapter implements ShieldPort {
-  constructor(private readonly secretKey: HCaptchaSecretKeyType) {}
-
-  verify = createMiddleware(async (_c, next) => {
-    try {
-      const result = await hcaptcha.verify(this.secretKey, "10000000-aaaa-bbbb-cccc-000000000001");
-
-      if (!result?.success) throw AccessDeniedHcaptchaLocalError;
-      return next();
-    } catch {
-      throw AccessDeniedHcaptchaLocalError;
-    }
-  });
-}

package/src/shield-captcha-hcaptcha.adapter.ts

@@ -1,24 +0,0 @@
-import hcaptcha from "hcaptcha";
-import { createMiddleware } from "hono/factory";
-import { HTTPException } from "hono/http-exception";
-import type { HCaptchaSecretKeyType } from "./hcaptcha-secret-key.vo";
-import type { ShieldPort } from "./shield.port";
-
-export const AccessDeniedHcaptchaError = new HTTPException(403, { message: "access_denied_hcaptcha" });
-
-export class ShieldCaptchaHcaptchaAdapter implements ShieldPort {
-  constructor(private readonly secretKey: HCaptchaSecretKeyType) {}
-
-  verify = createMiddleware(async (c, next) => {
-    try {
-      const form = await c.req.formData();
-      const hcaptchaTokenFormData = form.get("h-captcha-response")?.toString() as string;
-      const result = await hcaptcha.verify(this.secretKey, hcaptchaTokenFormData);
-
-      if (!result?.success) throw AccessDeniedHcaptchaError;
-      return next();
-    } catch {
-      throw AccessDeniedHcaptchaError;
-    }
-  });
-}

package/src/shield-captcha-recaptcha.adapter.ts

@@ -1,49 +0,0 @@
-import * as tools from "@bgord/tools";
-import { createMiddleware } from "hono/factory";
-import { HTTPException } from "hono/http-exception";
-import type { RecaptchaSecretKeyType } from "./recaptcha-secret-key.vo";
-import type { ShieldPort } from "./shield.port";
-
-export type RecaptchaVerifierConfigType = { secretKey: RecaptchaSecretKeyType };
-export type RecaptchaResultType = { success: boolean; score: number };
-
-export const AccessDeniedRecaptchaError = new HTTPException(403, { message: "access_denied_recaptcha" });
-
-export class ShieldCaptchaRecaptchaAdapter implements ShieldPort {
-  private static readonly URL = tools.UrlWithoutSlash.parse(
-    "https://www.google.com/recaptcha/api/siteverify",
-  );
-
-  constructor(private readonly config: RecaptchaVerifierConfigType) {}
-
-  verify = createMiddleware(async (c, next) => {
-    try {
-      const header = c.req.header("x-recaptcha-token");
-      const query = c.req.query("recaptchaToken");
-      const form = (await c.req.formData()).get("g-recaptcha-response")?.toString();
-
-      const token = header ?? query ?? form;
-
-      if (!token) throw AccessDeniedRecaptchaError;
-
-      // cSpell:ignore remoteip
-      const remoteip = c.req.header("x-forwarded-for") ?? "";
-
-      const params = new URLSearchParams({ secret: this.config.secretKey, response: token, remoteip });
-
-      const response = await fetch(ShieldCaptchaRecaptchaAdapter.URL, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body: params,
-      });
-
-      const result: RecaptchaResultType = await response.json();
-
-      if (!result.success || result.score < 0.5) throw AccessDeniedRecaptchaError;
-
-      await next();
-    } catch {
-      throw AccessDeniedRecaptchaError;
-    }
-  });
-}

package/src/shield-noop.adapter.ts

@@ -1,6 +0,0 @@
-import { createMiddleware } from "hono/factory";
-import type { ShieldPort } from "./shield.port";
-
-export class ShieldNoopAdapter implements ShieldPort {
-  verify = createMiddleware(async (_c, next) => next());
-}

package/src/shield-rate-limit.adapter.ts

@@ -1,37 +0,0 @@
-import * as tools from "@bgord/tools";
-import { createMiddleware } from "hono/factory";
-import { HTTPException } from "hono/http-exception";
-import type { CacheResolverPort } from "./cache-resolver.port";
-import type { CacheSubjectResolver } from "./cache-subject-resolver.vo";
-import type { ClockPort } from "./clock.port";
-import type { ShieldPort } from "./shield.port";
-
-type ShieldRateLimitOptionsType = { enabled: boolean; resolver: CacheSubjectResolver };
-
-type Dependencies = { Clock: ClockPort; CacheResolver: CacheResolverPort };
-
-export const TooManyRequestsError = new HTTPException(429, { message: "app.too_many_requests" });
-
-export class ShieldRateLimitAdapter implements ShieldPort {
-  constructor(
-    private readonly options: ShieldRateLimitOptionsType,
-    private readonly deps: Dependencies,
-  ) {}
-
-  verify = createMiddleware(async (c, next) => {
-    if (!this.options.enabled) return next();
-
-    const subject = await this.options.resolver.resolve(c);
-
-    const limiter = await this.deps.CacheResolver.resolve(
-      subject.hex,
-      async () => new tools.RateLimiter(this.deps.CacheResolver.ttl),
-    );
-
-    const result = limiter.verify(this.deps.Clock.now());
-
-    if (!result.allowed) throw TooManyRequestsError;
-
-    return next();
-  });
-}

package/src/shield-timeout.adapter.ts

@@ -1,19 +0,0 @@
-import type * as tools from "@bgord/tools";
-import { createMiddleware } from "hono/factory";
-import { HTTPException } from "hono/http-exception";
-import { timeout } from "hono/timeout";
-import type { ShieldPort } from "./shield.port";
-
-export const RequestTimeoutError = new HTTPException(408, { message: "request_timeout_error" });
-
-type ShieldTimeoutConfigType = { duration: tools.Duration };
-
-export class ShieldTimeoutAdapter implements ShieldPort {
-  private readonly timeout;
-
-  constructor(config: ShieldTimeoutConfigType) {
-    this.timeout = timeout(config.duration.ms, RequestTimeoutError);
-  }
-
-  verify = createMiddleware(async (c, next) => this.timeout(c, next));
-}

package/src/shield.port.ts

@@ -1,5 +0,0 @@
-import type { MiddlewareHandler } from "hono";
-
-export interface ShieldPort {
-  verify: MiddlewareHandler;
-}

package/src/timeout.service.ts

@@ -1,71 +0,0 @@
-import type * as tools from "@bgord/tools";
-import type { LoggerPort } from "../src/logger.port";
-
-export const TimeoutError = { Exceeded: "timeout.exceeded" };
-
-export class Timeout {
-  static async run<T>(action: Promise<T>, timeout: tools.Duration): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      const reason = new Error(TimeoutError.Exceeded);
-
-      const canceller = setTimeout(() => reject(reason), timeout.ms);
-
-      action.then(
-        (value) => {
-          clearTimeout(canceller);
-          resolve(value);
-        },
-        (error) => {
-          clearTimeout(canceller);
-          reject(error);
-        },
-      );
-    });
-  }
-
-  static async monitor<T>(action: Promise<T>, timeout: tools.Duration, logger: LoggerPort): Promise<T> {
-    const monitor = setTimeout(
-      () =>
-        logger.warn({
-          message: "Timeout",
-          component: "infra",
-          operation: "timeout_monitor",
-          metadata: { timeoutMs: timeout.ms },
-        }),
-      timeout.ms,
-    );
-
-    return action.finally(() => clearTimeout(monitor));
-  }
-
-  static async cancellable<T>(
-    action: (signal: AbortSignal) => Promise<T>,
-    timeout: tools.Duration,
-  ): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      const controller = new AbortController();
-
-      const reason = new Error(TimeoutError.Exceeded);
-
-      const canceller = setTimeout(() => {
-        controller.abort(reason);
-        reject(reason);
-      }, timeout.ms);
-
-      // Promise.resolve.then used to prevent the initial action(controller.signal) call
-      // from throwing before the resulting work-promise is run by promise.then.
-      const promise: Promise<T> = Promise.resolve().then(() => action(controller.signal));
-
-      promise.then(
-        (value) => {
-          clearTimeout(canceller);
-          resolve(value);
-        },
-        (error) => {
-          clearTimeout(canceller);
-          reject(error);
-        },
-      );
-    });
-  }
-}

package/src/visitor-id-client.adapter.ts

@@ -1,20 +0,0 @@
-import type { Client } from "./client.vo";
-import type { HashContentPort } from "./hash-content.port";
-import type { VisitorIdPort } from "./visitor-id.port";
-
-type Dependencies = { HashContent: HashContentPort };
-
-export class VisitorIdClientAdapter implements VisitorIdPort {
-  constructor(
-    private readonly client: Client,
-    private readonly deps: Dependencies,
-  ) {}
-
-  async get() {
-    const { ip, ua } = this.client.toJSON();
-
-    const value = `${ip}|${ua}`;
-
-    return this.deps.HashContent.hash(value);
-  }
-}

package/src/visitor-id.port.ts

@@ -1,5 +0,0 @@
-import type { Hash } from "./hash.vo";
-
-export interface VisitorIdPort {
-  get(): Promise<Hash>;
-}