@bgord/bun 1.10.23 → 1.11.0

package/src/healthcheck.service.ts

@@ -1,154 +0,0 @@
-import os from "node:os";
-import * as tools from "@bgord/tools";
-import { createFactory } from "hono/factory";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
-import type { ClockPort } from "./clock.port";
-import type { CommitShaValueType } from "./commit-sha-value.vo";
-import { EventLoopLag } from "./event-loop-lag.service";
-import { EventLoopUtilization, type EventLoopUtilizationSnapshot } from "./event-loop-utilization.service";
-import { InFlightRequestsTracker } from "./in-flight-requests-tracker.service";
-import type { LoggerStatsProviderPort, LoggerStatsSnapshot } from "./logger-stats-provider.port";
-import { MemoryConsumption } from "./memory-consumption.service";
-import type { NodeEnvironmentEnum } from "./node-env.vo";
-import { Prerequisite, type PrerequisiteLabelType } from "./prerequisite.vo";
-import {
-  PrerequisiteVerificationOutcome,
-  type PrerequisiteVerificationResult,
-} from "./prerequisite-verifier.port";
-import { PrerequisiteVerifierSelfAdapter } from "./prerequisite-verifier-self.adapter";
-import type { RedactorStrategy } from "./redactor.strategy";
-import { Stopwatch } from "./stopwatch.service";
-import { Uptime, type UptimeResultType } from "./uptime.service";
-
-type HealthcheckConfigType = {
-  Env: NodeEnvironmentEnum;
-  prerequisites: ReadonlyArray<Prerequisite>;
-  redactor?: RedactorStrategy;
-};
-
-type Dependencies = {
-  Clock: ClockPort;
-  BuildInfoRepository: BuildInfoRepositoryStrategy;
-  LoggerStatsProvider?: LoggerStatsProviderPort;
-};
-
-const handler = createFactory();
-const self = new Prerequisite("self", new PrerequisiteVerifierSelfAdapter());
-
-type HealthcheckResultType = {
-  ok: boolean;
-  deployment: {
-    version: string;
-    timestamp: tools.TimestampValueType;
-    date: string;
-    sha: CommitShaValueType;
-    size: string;
-    environment: NodeEnvironmentEnum;
-  };
-  server: {
-    pid: typeof process.pid;
-    hostname: ReturnType<typeof os.hostname>;
-    cpus: tools.IntegerNonNegativeType;
-    startup: tools.TimestampValueType;
-    uptime: Omit<UptimeResultType, "duration"> & { durationMs: tools.DurationMsType };
-    memory: {
-      total: { bytes: tools.Size["bytes"]; formatted: ReturnType<tools.Size["format"]> };
-      heap: {
-        used: { bytes: tools.Size["bytes"]; formatted: ReturnType<tools.Size["format"]> };
-        total: { bytes: tools.Size["bytes"]; formatted: ReturnType<tools.Size["format"]> };
-      };
-    };
-    eventLoop: {
-      lag: { p50: tools.DurationMsType; p95: tools.DurationMsType; p99: tools.DurationMsType };
-      utilization: EventLoopUtilizationSnapshot;
-    };
-    inFlight: tools.IntegerType;
-  };
-  details: ReadonlyArray<{
-    label: PrerequisiteLabelType;
-    outcome: PrerequisiteVerificationResult;
-    durationMs: tools.DurationMsType;
-  }>;
-  logger?: LoggerStatsSnapshot;
-  durationMs: tools.Duration["ms"];
-  timestamp: tools.TimestampValueType;
-};
-
-export class Healthcheck {
-  static build = (config: HealthcheckConfigType, deps: Dependencies) =>
-    handler.createHandlers(async (c) => {
-      const stopwatch = new Stopwatch(deps);
-
-      const prerequisites = [self, ...config.prerequisites]
-        .filter((prerequisite) => prerequisite.enabled)
-        .filter((prerequisite) => prerequisite.kind !== "port");
-
-      const details = await Promise.all(
-        prerequisites.map(async (prerequisite) => {
-          const stopwatch = new Stopwatch(deps);
-
-          const outcome = await prerequisite.build().verify();
-
-          return {
-            label: prerequisite.label,
-            outcome: config.redactor ? config.redactor.redact(outcome) : outcome,
-            durationMs: stopwatch.stop().ms,
-          };
-        }),
-      );
-
-      const ok = details.every(
-        (result) => result.outcome.outcome !== PrerequisiteVerificationOutcome.failure,
-      );
-
-      const code = ok ? 200 : 424;
-
-      const build = await deps.BuildInfoRepository.extract();
-      const uptime = Uptime.get(deps.Clock);
-      const histogram = EventLoopLag.snapshot();
-      const memory = MemoryConsumption.snapshot();
-
-      const response: HealthcheckResultType = {
-        ok,
-        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),
-          environment: config.Env,
-        },
-        server: {
-          pid: process.pid,
-          hostname: os.hostname(),
-          cpus: tools.IntegerNonNegative.parse(os.cpus().length),
-          startup: deps.Clock.now().subtract(uptime.duration).ms,
-          uptime: { durationMs: uptime.duration.ms, formatted: uptime.formatted },
-          memory: {
-            total: { bytes: memory.total.toBytes(), formatted: memory.total.format(tools.Size.unit.MB) },
-            heap: {
-              used: {
-                bytes: memory.heap.used.toBytes(),
-                formatted: memory.heap.used.format(tools.Size.unit.MB),
-              },
-              total: {
-                bytes: memory.heap.total.toBytes(),
-                formatted: memory.heap.total.format(tools.Size.unit.MB),
-              },
-            },
-          },
-          eventLoop: {
-            lag: { p50: histogram.p50.ms, p95: histogram.p95.ms, p99: histogram.p99.ms },
-            utilization: EventLoopUtilization.snapshot(),
-          },
-          inFlight: InFlightRequestsTracker.get(),
-        },
-        logger: deps.LoggerStatsProvider?.getStats(),
-        durationMs: stopwatch.stop().ms,
-        timestamp: deps.Clock.now().ms,
-      };
-
-      return c.json(response, code);
-    });
-}

package/src/maintenance-mode.middleware.ts

@@ -1,15 +0,0 @@
-import * as tools from "@bgord/tools";
-import { createMiddleware } from "hono/factory";
-
-export type MaintenanceModeConfigType = { enabled: boolean; RetryAfter?: tools.Duration };
-
-export class MaintenanceMode {
-  static build = (config?: MaintenanceModeConfigType) =>
-    createMiddleware(async (context, next) => {
-      const enabled = config?.enabled ?? false;
-      const RetryAfter = config?.RetryAfter ?? tools.Duration.Hours(1);
-
-      if (!enabled) return next();
-      return context.json({ reason: "maintenance" }, 503, { "Retry-After": RetryAfter.seconds.toString() });
-    });
-}

package/src/ping.service.ts

@@ -1,7 +0,0 @@
-import { createFactory } from "hono/factory";
-
-const handler = createFactory();
-
-export class Ping {
-  static build = () => handler.createHandlers(async (c) => c.text("pong", 200));
-}

package/src/shield-hcaptcha-local.strategy.ts

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

package/src/shield-noop.strategy.ts

@@ -1,6 +0,0 @@
-import { createMiddleware } from "hono/factory";
-import type { ShieldStrategy } from "./shield.strategy";
-
-export class ShieldNoopStrategy implements ShieldStrategy {
-  verify = createMiddleware(async (_, next) => next());
-}

package/src/shield.strategy.ts

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

package/src/ssr.ts

@@ -1,57 +0,0 @@
-import { secureHeaders } from "hono/secure-headers";
-import type { NonceProviderPort } from "./nonce-provider.port";
-import type { NonceValueType } from "./nonce-value.vo";
-
-const noop = async () => {};
-
-type Dependencies = { NonceProvider: NonceProviderPort };
-
-export class SSR {
-  static essentials(
-    handler: (request: Request, nonce: NonceValueType) => Promise<Response>,
-    deps: Dependencies,
-  ) {
-    return async (request: Request): Promise<Response> => {
-      const nonce = deps.NonceProvider.generate();
-
-      const response = await handler(request, nonce);
-
-      secureHeaders({
-        crossOriginResourcePolicy: "same-origin",
-        contentSecurityPolicy: {
-          defaultSrc: ["'none'"],
-          baseUri: ["'none'"],
-          objectSrc: ["'none'"],
-          frameAncestors: ["'none'"],
-
-          scriptSrc: ["'self'", `'nonce-${nonce}'`],
-          scriptSrcElem: ["'self'", `'nonce-${nonce}'`],
-
-          styleSrc: ["'self'", `'nonce-${nonce}'`],
-          styleSrcAttr: ["'unsafe-inline'"],
-
-          imgSrc: ["'self'"],
-          fontSrc: ["'self'"],
-          connectSrc: ["'self'"],
-          formAction: ["'self'"],
-        },
-        permissionsPolicy: {
-          accelerometer: [],
-          autoplay: [],
-          camera: [],
-          fullscreen: ["self"],
-          geolocation: [],
-          gyroscope: [],
-          magnetometer: [],
-          microphone: [],
-          payment: [],
-          usb: [],
-        },
-        xFrameOptions: false,
-        originAgentCluster: false,
-      })({ req: request, res: response } as any, noop);
-
-      return response;
-    };
-  }
-}

package/src/translations.service.ts

@@ -1,20 +0,0 @@
-import { createFactory } from "hono/factory";
-import type { FileReaderJsonPort } from "./file-reader-json.port";
-import { I18n, type TranslationsSupportedLanguagesType } from "./i18n.service";
-import type { LoggerPort } from "./logger.port";
-
-const handler = createFactory();
-
-type Config = TranslationsSupportedLanguagesType;
-
-type Dependencies = { FileReaderJson: FileReaderJsonPort; Logger: LoggerPort };
-
-export class Translations {
-  static build = (config: Config, deps: Dependencies) =>
-    handler.createHandlers(async (c) => {
-      const language = c.get("language");
-      const translations = await new I18n(deps).getTranslations(language);
-
-      return c.json({ translations, language, supportedLanguages: config });
-    });
-}