@bgord/bun 1.10.23 → 1.11.0

package/src/file-uploader-hono.middleware.ts

@@ -0,0 +1,47 @@
+import { createMiddleware } from "hono/factory";
+import { HTTPException } from "hono/http-exception";
+import {
+  type FileUploaderConfig,
+  FileUploaderError,
+  FileUploaderMiddleware,
+} from "./file-uploader.middleware";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+
+export const FileUploaderMissingFileError = new HTTPException(400, {
+  message: FileUploaderError.MissingFile,
+});
+export const FileUploaderEmptyFileError = new HTTPException(400, { message: FileUploaderError.EmptyFile });
+export const FileUploaderSizeLimitError = new HTTPException(400, { message: FileUploaderError.SizeLimit });
+export const FileUploaderInvalidMimeError = new HTTPException(400, {
+  message: FileUploaderError.InvalidMime,
+});
+
+export class FileUploaderHonoMiddleware implements MiddlewareHonoPort {
+  private readonly middleware: FileUploaderMiddleware;
+
+  constructor(config: FileUploaderConfig) {
+    this.middleware = new FileUploaderMiddleware(config);
+  }
+
+  handle() {
+    return createMiddleware(async (context, next) => {
+      const body = await context.req.raw.clone().formData();
+      const file = body.get("file");
+
+      const result = this.middleware.validate(file instanceof File ? file : null);
+
+      if (result.valid) return next();
+
+      switch (result.error) {
+        case FileUploaderError.MissingFile:
+          throw FileUploaderMissingFileError;
+        case FileUploaderError.EmptyFile:
+          throw FileUploaderEmptyFileError;
+        case FileUploaderError.SizeLimit:
+          throw FileUploaderSizeLimitError;
+        case FileUploaderError.InvalidMime:
+          throw FileUploaderInvalidMimeError;
+      }
+    });
+  }
+}

package/src/file-uploader.middleware.ts

@@ -1,38 +1,34 @@
 import * as tools from "@bgord/tools";
-import { bodyLimit } from "hono/body-limit";
-import { createMiddleware } from "hono/factory";
-import { HTTPException } from "hono/http-exception";
 
-type FileUploaderConfigType = { MimeRegistry: tools.MimeRegistry; maxFilesSize: tools.Size };
+export type FileUploaderConfig = { MimeRegistry: tools.MimeRegistry; maxSize: tools.Size };
 
-export const FileUploaderInvalidMimeError = new HTTPException(400, { message: "file.uploader.invalid.mime" });
+export const FileUploaderError = {
+  MissingFile: "file.uploader.missing.file",
+  EmptyFile: "file.uploader.empty.file",
+  InvalidMime: "file.uploader.invalid.mime",
+  SizeLimit: "file.uploader.size.limit",
+} as const;
 
-export const FileUploaderTooBigError = new HTTPException(400, { message: "file.uploader.too.big" });
+export type FileValidationError = (typeof FileUploaderError)[keyof typeof FileUploaderError];
 
-export class FileUploader {
-  static validate(config: FileUploaderConfigType) {
-    return [
-      bodyLimit({
-        maxSize: config.maxFilesSize.toBytes(),
-        onError: () => {
-          throw FileUploaderTooBigError;
-        },
-      }),
+export type FileValidationResult = { valid: true } | { valid: false; error: FileValidationError };
 
-      createMiddleware(async (context, next) => {
-        const body = await context.req.raw.clone().formData();
+export class FileUploaderMiddleware {
+  constructor(private readonly config: FileUploaderConfig) {}
 
-        const file = body.get("file");
+  validate(file: File | null): FileValidationResult {
+    if (!file) return { valid: false, error: FileUploaderError.MissingFile };
+    if (file.size === 0) return { valid: false, error: FileUploaderError.EmptyFile };
 
-        if (!(file instanceof File)) throw FileUploaderInvalidMimeError;
+    const size = tools.Size.fromBytes(file.size);
 
-        const mime = tools.Mime.fromString(file.type);
+    if (size.isGreaterThan(this.config.maxSize)) return { valid: false, error: FileUploaderError.SizeLimit };
 
-        const accepted = config.MimeRegistry.hasMime(mime);
+    const mime = tools.Mime.fromString(file.type);
 
-        if (!accepted) throw FileUploaderInvalidMimeError;
-        return next();
-      }),
-    ];
+    if (!this.config.MimeRegistry.hasMime(mime)) {
+      return { valid: false, error: FileUploaderError.InvalidMime };
+    }
+    return { valid: true };
   }
 }

package/src/handler-hono.port.ts

@@ -0,0 +1,5 @@
+import type { Handler } from "hono";
+
+export interface HandlerHonoPort {
+  handle(): Handler | Array<Handler>;
+}

package/src/hash-bucket.vo.ts

@@ -0,0 +1,19 @@
+import * as tools from "@bgord/tools";
+import type { Hash } from "./hash.vo";
+
+export class HashBucket {
+  private constructor(readonly value: tools.IntegerNonNegativeType) {}
+
+  static fromHash(hash: Hash): HashBucket {
+    const hex = hash.get().substring(0, 8);
+    const integer = Number.parseInt(hex, 16);
+
+    const bucket = integer % 100;
+
+    return new HashBucket(tools.IntegerNonNegative.parse(bucket));
+  }
+
+  isLessThan(threshold: tools.IntegerNonNegativeType): boolean {
+    return this.value < threshold;
+  }
+}

package/src/healthcheck-hono.handler.ts

@@ -0,0 +1,31 @@
+import { createFactory } from "hono/factory";
+import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
+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";
+
+type Dependencies = {
+  Clock: ClockPort;
+  BuildInfoRepository: BuildInfoRepositoryStrategy;
+  LoggerStatsProvider?: LoggerStatsProviderPort;
+};
+
+const factory = createFactory();
+
+export class HealthcheckHonoHandler implements HandlerHonoPort {
+  private readonly handler: HealthcheckHandler;
+
+  constructor(config: HealthcheckConfig, deps: Dependencies) {
+    this.handler = new HealthcheckHandler(config, deps);
+  }
+
+  handle() {
+    return factory.createHandlers(async (c) => {
+      const healthcheck = await this.handler.check();
+      const code = healthcheck.ok ? 200 : 424;
+
+      return c.json(healthcheck, code);
+    });
+  }
+}

package/src/healthcheck.handler.ts

@@ -0,0 +1,150 @@
+import os from "node:os";
+import * as tools from "@bgord/tools";
+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 Dependencies = {
+  Clock: ClockPort;
+  BuildInfoRepository: BuildInfoRepositoryStrategy;
+  LoggerStatsProvider?: LoggerStatsProviderPort;
+};
+
+export type HealthcheckConfig = {
+  Env: NodeEnvironmentEnum;
+  prerequisites: ReadonlyArray<Prerequisite>;
+  redactor?: RedactorStrategy;
+};
+
+const self = new Prerequisite("self", new PrerequisiteVerifierSelfAdapter());
+
+export type HealthcheckResult = {
+  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 HealthcheckHandler {
+  constructor(
+    private readonly config: HealthcheckConfig,
+    private readonly deps: Dependencies,
+  ) {}
+
+  async check(): Promise<HealthcheckResult> {
+    const stopwatch = new Stopwatch(this.deps);
+
+    const prerequisites = [self, ...this.config.prerequisites]
+      .filter((prerequisite) => prerequisite.enabled)
+      .filter((prerequisite) => prerequisite.kind !== "port");
+
+    const details = await Promise.all(
+      prerequisites.map(async (prerequisite) => {
+        const stopwatch = new Stopwatch(this.deps);
+
+        const outcome = await prerequisite.build().verify();
+
+        return {
+          label: prerequisite.label,
+          outcome: this.config.redactor ? this.config.redactor.redact(outcome) : outcome,
+          durationMs: stopwatch.stop().ms,
+        };
+      }),
+    );
+
+    const ok = details.every((result) => result.outcome.outcome !== PrerequisiteVerificationOutcome.failure);
+
+    const build = await this.deps.BuildInfoRepository.extract();
+    const uptime = Uptime.get(this.deps.Clock);
+    const histogram = EventLoopLag.snapshot();
+    const memory = MemoryConsumption.snapshot();
+
+    return {
+      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: this.config.Env,
+      },
+      server: {
+        pid: process.pid,
+        hostname: os.hostname(),
+        cpus: tools.IntegerNonNegative.parse(os.cpus().length),
+        startup: this.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: this.deps.LoggerStatsProvider?.getStats(),
+      durationMs: stopwatch.stop().ms,
+      timestamp: this.deps.Clock.now().ms,
+    };
+  }
+}

package/src/http-logger-hono.middleware.ts

@@ -0,0 +1,50 @@
+import type { MiddlewareHandler } from "hono";
+import { CacheSourceEnum } from "./cache-resolver.strategy";
+import { CacheResponseMiddleware } from "./cache-response.middleware";
+import type { ClockPort } from "./clock.port";
+import { type HttpLoggerConfig, HttpLoggerMiddleware } from "./http-logger.middleware";
+import type { LoggerPort } from "./logger.port";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+
+type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
+
+export class HttpLoggerHonoMiddleware implements MiddlewareHonoPort {
+  private readonly middleware: HttpLoggerMiddleware;
+
+  constructor(deps: Dependencies, config?: HttpLoggerConfig) {
+    this.middleware = new HttpLoggerMiddleware(deps, config);
+  }
+
+  handle(): MiddlewareHandler {
+    return async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+
+      if (this.middleware.shouldSkip(context)) return await next();
+
+      const request = c.req.raw.clone();
+      const correlationId = c.get("correlationId");
+      const body = await HttpLoggerHonoMiddleware.parseJSON(request);
+
+      const { stopwatch } = this.middleware.before(context, correlationId, body);
+
+      await next();
+
+      const response = c.res.clone();
+      const responseBody = await HttpLoggerHonoMiddleware.parseJSON(response);
+
+      this.middleware.after(context, correlationId, {
+        stopwatch,
+        status: response.status,
+        cacheHit: response.headers.get(CacheResponseMiddleware.CACHE_HIT_HEADER) === CacheSourceEnum.hit,
+        responseBody,
+      });
+    };
+  }
+
+  private static async parseJSON(resource: Request | Response): Promise<any> {
+    try {
+      return await resource.json();
+    } catch {}
+  }
+}

package/src/http-logger.middleware.ts

@@ -1,9 +1,6 @@
-import { createMiddleware } from "hono/factory";
-import { CacheSourceEnum } from "./cache-resolver.strategy";
-import { CacheResponse } from "./cache-response.middleware";
 import type { ClockPort } from "./clock.port";
 import { type LoggerPort, LogLevelEnum } from "./logger.port";
-import { RequestContextAdapterHono } from "./request-context-hono.adapter";
+import type { HasRequestPath, RequestContext } from "./request-context.port";
 import { Stopwatch } from "./stopwatch.service";
 
 export const UNINFORMATIVE_HEADERS = [
@@ -30,75 +27,71 @@ export const UNINFORMATIVE_HEADERS = [
 
 type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
 
-export type HttpLoggerOptions = { skip?: ReadonlyArray<string> };
+export type HttpLoggerConfig = { skip?: ReadonlyArray<string> };
 
-export class HttpLogger {
-  static build = (deps: Dependencies, options?: HttpLoggerOptions) =>
-    createMiddleware(async (c, next) => {
-      const context = new RequestContextAdapterHono(c);
-      const client = { ip: context.identity.ip(), ua: context.identity.ua() };
+export type HttpLoggerBeforeResult = { stopwatch: Stopwatch };
+export type HttpLoggerAfterInput = {
+  stopwatch: Stopwatch;
+  status: number;
+  cacheHit: boolean;
+  responseBody: any;
+};
 
-      const request = c.req.raw.clone();
+export class HttpLoggerMiddleware {
+  constructor(
+    private readonly deps: Dependencies,
+    private readonly config?: HttpLoggerConfig,
+  ) {}
 
-      // Stryker disable all
-      if (options?.skip?.some((prefix) => new URL(request.url).pathname.startsWith(prefix))) {
-        return await next();
-      }
-      // Stryker restore all
+  shouldSkip(context: HasRequestPath): boolean {
+    return this.config?.skip?.some((prefix) => context.request.path.startsWith(prefix)) ?? false;
+  }
 
-      const correlationId = c.get("requestId");
+  before(context: RequestContext, correlationId: string, body: any = {}): HttpLoggerBeforeResult {
+    const client = { ip: context.identity.ip(), ua: context.identity.ua() };
 
-      const httpRequestBeforeMetadata = {
-        params: c.req.param(),
-        headers: Object.fromEntries(
-          Object.entries(request.headers.toJSON()).filter(
-            ([header]) => !UNINFORMATIVE_HEADERS.includes(header),
-          ),
+    const metadata = {
+      params: context.request.params(),
+      headers: Object.fromEntries(
+        Object.entries(context.request.headersObject()).filter(
+          ([header]) => !UNINFORMATIVE_HEADERS.includes(header),
         ),
-        body: (await HttpLogger.parseJSON(request)) ?? {},
-        query: context.request.query(),
-      };
-
-      deps.Logger.http({
-        component: "http",
-        operation: "http_request_before",
-        correlationId,
-        message: "request",
-        method: request.method,
-        url: request.url,
-        client,
-        metadata: httpRequestBeforeMetadata,
-      });
+      ),
+      body,
+      query: context.request.query(),
+    };
 
-      const stopwatch = new Stopwatch(deps);
-      await next();
-      const duration = stopwatch.stop();
+    this.deps.Logger.http({
+      component: "http",
+      operation: "http_request_before",
+      correlationId,
+      message: "request",
+      method: context.request.method,
+      url: context.request.url(),
+      client,
+      metadata,
+    });
 
-      const response = c.res.clone();
+    return { stopwatch: new Stopwatch(this.deps) };
+  }
 
-      const level = response.status >= 400 ? LogLevelEnum.error : LogLevelEnum.http;
+  after(context: RequestContext, correlationId: string, input: HttpLoggerAfterInput): void {
+    const client = { ip: context.identity.ip(), ua: context.identity.ua() };
+    const duration = input.stopwatch.stop();
+    const level = input.status >= 400 ? LogLevelEnum.error : LogLevelEnum.http;
 
-      deps.Logger[level]({
-        component: "http",
-        operation: "http_request_after",
-        correlationId,
-        message: "response",
-        method: request.method,
-        url: request.url,
-        status: response.status,
-        durationMs: duration.ms,
-        client,
-        cacheHit: response.headers.get(CacheResponse.CACHE_HIT_HEADER) === CacheSourceEnum.hit,
-        metadata: { response: await HttpLogger.parseJSON(response) },
-      });
+    this.deps.Logger[level]({
+      component: "http",
+      operation: "http_request_after",
+      correlationId,
+      message: "response",
+      method: context.request.method,
+      url: context.request.url(),
+      status: input.status,
+      durationMs: duration.ms,
+      client,
+      cacheHit: input.cacheHit,
+      metadata: { response: input.responseBody },
     });
-
-  private static async parseJSON(resource: Request | Response) {
-    let result: any;
-    try {
-      result = await resource.json();
-    } catch {}
-
-    return result;
   }
 }

package/src/i18n.service.ts

@@ -11,7 +11,7 @@ export type TranslationVariableType = Record<TranslationPlaceholderType, Transla
 
 export type TranslationsSupportedLanguagesType = Record<string, string>;
 
-export type I18nConfigType = {
+export type I18nConfig = {
   supportedLanguages: TranslationsSupportedLanguagesType;
   translationsPath?: tools.DirectoryPathRelativeType;
   defaultLanguage?: string;

package/src/image-info-noop.adapter.ts

@@ -4,7 +4,7 @@ import type { ImageInfoPort, ImageInfoType } from "./image-info.port";
 export class ImageInfoNoopAdapter implements ImageInfoPort {
   constructor(private readonly mime: tools.Mime) {}
 
-  async inspect(_filePath: tools.FilePathRelative | tools.FilePathAbsolute): Promise<ImageInfoType> {
+  async inspect(_input: tools.FilePathRelative | tools.FilePathAbsolute): Promise<ImageInfoType> {
     return {
       width: tools.ImageWidth.parse(400),
       height: tools.ImageHeight.parse(400),

package/src/image-info-sharp.adapter.ts

@@ -37,10 +37,10 @@ export class ImageInfoSharpAdapter implements ImageInfoPort {
   }
   // Stryker restore all
 
-  async inspect(path: tools.FilePathRelative | tools.FilePathAbsolute): Promise<ImageInfoType> {
-    const size = await this.deps.FileInspection.size(path);
+  async inspect(input: tools.FilePathRelative | tools.FilePathAbsolute): Promise<ImageInfoType> {
+    const size = await this.deps.FileInspection.size(input);
 
-    const pipeline = this.sharp(path.get());
+    const pipeline = this.sharp(input.get());
     using _sharp_ = { [Symbol.dispose]: () => pipeline.destroy() };
 
     const metadata = await pipeline.metadata();

package/src/image-info.port.ts

@@ -8,5 +8,5 @@ export type ImageInfoType = {
 };
 
 export interface ImageInfoPort {
-  inspect(filePath: tools.FilePathRelative | tools.FilePathAbsolute): Promise<ImageInfoType>;
+  inspect(input: tools.FilePathRelative | tools.FilePathAbsolute): Promise<ImageInfoType>;
 }

package/src/in-flight-requests-hono.middleware.ts

@@ -0,0 +1,19 @@
+import type { MiddlewareHandler } from "hono";
+import { InFlightRequestsMiddleware } from "./in-flight-requests.middleware";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+
+export class InFlightRequestsHonoMiddleware implements MiddlewareHonoPort {
+  private readonly middleware = new InFlightRequestsMiddleware();
+
+  handle(): MiddlewareHandler {
+    return async (_c, next) => {
+      await this.middleware.evaluate();
+
+      try {
+        await next();
+      } finally {
+        this.middleware.cleanup();
+      }
+    };
+  }
+}

package/src/in-flight-requests-tracker.service.ts

@@ -15,10 +15,8 @@ export class InFlightRequestsTracker {
     return InFlightRequestsTracker.count;
   }
 
-  // Stryker disable all
   /** @internal */
   static _resetForTest(): void {
     InFlightRequestsTracker.count = tools.Integer.parse(0);
   }
-  // Stryker restore all
 }

package/src/in-flight-requests.middleware.ts

@@ -1,15 +1,11 @@
-import { createMiddleware } from "hono/factory";
 import { InFlightRequestsTracker } from "./in-flight-requests-tracker.service";
 
-export class InFlightRequests {
-  static handle = () =>
-    createMiddleware(async (_, next) => {
-      InFlightRequestsTracker.increment();
+export class InFlightRequestsMiddleware {
+  async evaluate(): Promise<void> {
+    InFlightRequestsTracker.increment();
+  }
 
-      try {
-        await next();
-      } finally {
-        InFlightRequestsTracker.decrement();
-      }
-    });
+  cleanup(): void {
+    InFlightRequestsTracker.decrement();
+  }
 }