@bgord/bun 1.10.23 → 1.12.0

package/src/etag-extractor.middleware.ts

@@ -1,20 +1,14 @@
 import * as tools from "@bgord/tools";
-import { createMiddleware } from "hono/factory";
-import { RequestContextAdapterHono } from "./request-context-hono.adapter";
+import type { RequestContext } from "./request-context.port";
 
-export type EtagVariables = { ETag: tools.ETag | null; WeakETag: tools.WeakETag | null };
-
-export class ETagExtractor {
-  static attach = createMiddleware<{ Variables: EtagVariables }>(async (c, next) => {
+export class ETagExtractorMiddleware {
+  evaluate(context: RequestContext): tools.ETag | null {
     try {
-      const context = new RequestContextAdapterHono(c);
       const header = context.request.header(tools.ETag.IF_MATCH_HEADER_NAME);
 
-      c.set("ETag", tools.ETag.fromHeader(header));
+      return tools.ETag.fromHeader(header);
     } catch {
-      c.set("ETag", null);
+      return null;
     }
-
-    await next();
-  });
+  }
 }

package/src/event-bus-collecting.adapter.ts

@@ -0,0 +1,15 @@
+import type { EventBusPort } from "./event-bus.port";
+import type { ToEventMap } from "./to-event-map.types";
+
+export class EventBusCollectingAdapter<E extends { name: string }> implements EventBusPort<E> {
+  public events: Array<E> = [];
+
+  async emit<K extends keyof ToEventMap<E>>(_name: K, event: ToEventMap<E>[K]): Promise<void> {
+    this.events.push(event as E);
+  }
+
+  on<K extends keyof ToEventMap<E>>(
+    _name: K,
+    _handler: (event: ToEventMap<E>[K]) => void | Promise<void>,
+  ): void {}
+}

package/src/event-bus-emittery-v1.adapter.ts

@@ -0,0 +1,22 @@
+import Emittery from "emittery";
+import type { EventBusPort } from "./event-bus.port";
+import type { ToEventMap } from "./to-event-map.types";
+
+export class EventBusEmitteryV1Adapter<E extends { name: string }> implements EventBusPort<E> {
+  private readonly emittery: Emittery<ToEventMap<E>>;
+
+  constructor() {
+    this.emittery = new Emittery<ToEventMap<E>>();
+  }
+
+  async emit<K extends keyof ToEventMap<E>>(name: K, event: ToEventMap<E>[K]): Promise<void> {
+    await this.emittery.emit(name, event);
+  }
+
+  on<K extends keyof ToEventMap<E>>(
+    name: K,
+    handler: (event: ToEventMap<E>[K]) => void | Promise<void>,
+  ): void {
+    this.emittery.on(name, handler);
+  }
+}

package/src/event-bus-noop.adapter.ts

@@ -0,0 +1,11 @@
+import type { EventBusPort } from "./event-bus.port";
+import type { ToEventMap } from "./to-event-map.types";
+
+export class EventBusNoopAdapter<E extends { name: string }> implements EventBusPort<E> {
+  async emit<K extends keyof ToEventMap<E>>(_name: K, _event: ToEventMap<E>[K]): Promise<void> {}
+
+  on<K extends keyof ToEventMap<E>>(
+    _name: K,
+    _handler: (event: ToEventMap<E>[K]) => void | Promise<void>,
+  ): void {}
+}

package/src/event-bus-with-logger.adapter.ts

@@ -0,0 +1,31 @@
+import type { EventBusPort } from "./event-bus.port";
+import type { LogCoreType, LoggerPort } from "./logger.port";
+import type { ToEventMap } from "./to-event-map.types";
+
+type Dependencies = { Logger: LoggerPort };
+
+export class EventBusWithLoggerAdapter<E extends { name: string }> implements EventBusPort<E> {
+  private readonly base = { component: "infra", operation: "event_emitted" };
+
+  constructor(
+    private readonly inner: EventBusPort<E>,
+    private readonly deps: Dependencies,
+  ) {}
+
+  async emit<K extends keyof ToEventMap<E>>(name: K, event: ToEventMap<E>[K]): Promise<void> {
+    this.deps.Logger.info({
+      message: `${name.toString()} emitted`,
+      metadata: event as LogCoreType["metadata"],
+      ...this.base,
+    });
+
+    return this.inner.emit(name, event);
+  }
+
+  on<K extends keyof ToEventMap<E>>(
+    name: K,
+    handler: (event: ToEventMap<E>[K]) => void | Promise<void>,
+  ): void {
+    this.inner.on(name, handler);
+  }
+}

package/src/event-bus.port.ts

@@ -0,0 +1,10 @@
+import type { ToEventMap } from "./to-event-map.types";
+
+export interface EventBusPort<E extends { name: string }> {
+  emit<K extends keyof ToEventMap<E>>(name: K, event: ToEventMap<E>[K]): Promise<void>;
+
+  on<K extends keyof ToEventMap<E>>(
+    name: K,
+    handler: (event: ToEventMap<E>[K]) => void | Promise<void>,
+  ): void;
+}

package/src/event-store.ts

@@ -14,10 +14,10 @@ type InserterEventsHandler = (
   events: ReadonlyArray<z.infer<GenericParsedEventSchema>>,
 ) => Promise<ReadonlyArray<z.infer<GenericParsedEventSchema>>>;
 
-type EventStoreConfigType = { finder: FindEventsHandler; inserter: InserterEventsHandler };
+type Config = { finder: FindEventsHandler; inserter: InserterEventsHandler };
 
 export class EventStore<AllEvents extends GenericEventSchema> {
-  constructor(private readonly config: EventStoreConfigType) {}
+  constructor(private readonly config: Config) {}
 
   static EMPTY_STREAM_REVISION = -1;
 

package/src/file-inspection-noop.adapter.ts

@@ -1,7 +1,7 @@
 import * as tools from "@bgord/tools";
 import type { FileInspectionPort } from "./file-inspection.port";
 
-type FileInspectionNoopAdapterConfigType = {
+type Config = {
   exists: boolean;
   isDirectory?: boolean;
   permissions?: { read?: boolean; write?: boolean; execute?: boolean };
@@ -10,7 +10,7 @@ type FileInspectionNoopAdapterConfigType = {
 };
 
 export class FileInspectionNoopAdapter implements FileInspectionPort {
-  constructor(private readonly config: FileInspectionNoopAdapterConfigType) {}
+  constructor(private readonly config: Config) {}
 
   async exists(_path: tools.FilePathRelative | tools.FilePathAbsolute | string): Promise<boolean> {
     return this.config.exists;

package/src/file-reader-json-with-cache.adapter.ts

@@ -1,26 +1,27 @@
 import type * as tools from "@bgord/tools";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
-import { CacheSubjectApplicationResolver } from "./cache-subject-application-resolver.vo";
-import { CacheSubjectSegmentFixedStrategy } from "./cache-subject-segment-fixed.strategy";
 import type { FileReaderJsonOutputType, FileReaderJsonPort } from "./file-reader-json.port";
 import type { HashContentStrategy } from "./hash-content.strategy";
+import { SubjectApplicationResolver } from "./subject-application-resolver.vo";
+import { SubjectSegmentFixedStrategy } from "./subject-segment-fixed.strategy";
 
 type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
+type Config = { id: string; inner: FileReaderJsonPort };
 
 export class FileReaderJsonWithCacheAdapter implements FileReaderJsonPort {
   constructor(
-    private readonly config: { id: string; inner: FileReaderJsonPort },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 
   async read(
     path: tools.FilePathRelative | tools.FilePathAbsolute | string,
   ): Promise<FileReaderJsonOutputType> {
-    const resolver = new CacheSubjectApplicationResolver(
+    const resolver = new SubjectApplicationResolver(
       [
-        new CacheSubjectSegmentFixedStrategy("file_reader_json"),
-        new CacheSubjectSegmentFixedStrategy(this.config.id),
-        new CacheSubjectSegmentFixedStrategy(typeof path === "string" ? path : path.get()),
+        new SubjectSegmentFixedStrategy("file_reader_json"),
+        new SubjectSegmentFixedStrategy(this.config.id),
+        new SubjectSegmentFixedStrategy(typeof path === "string" ? path : path.get()),
       ],
       this.deps,
     );

package/src/file-reader-raw-with-cache.adapter.ts

@@ -1,24 +1,25 @@
 import type * as tools from "@bgord/tools";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
-import { CacheSubjectApplicationResolver } from "./cache-subject-application-resolver.vo";
-import { CacheSubjectSegmentFixedStrategy } from "./cache-subject-segment-fixed.strategy";
 import type { FileReaderRawPort } from "./file-reader-raw.port";
 import type { HashContentStrategy } from "./hash-content.strategy";
+import { SubjectApplicationResolver } from "./subject-application-resolver.vo";
+import { SubjectSegmentFixedStrategy } from "./subject-segment-fixed.strategy";
 
 type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
+type Config = { id: string; inner: FileReaderRawPort };
 
 export class FileReaderRawWithCacheAdapter implements FileReaderRawPort {
   constructor(
-    private readonly config: { id: string; inner: FileReaderRawPort },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 
   async read(path: tools.FilePathRelative | tools.FilePathAbsolute | string): Promise<ArrayBuffer> {
-    const resolver = new CacheSubjectApplicationResolver(
+    const resolver = new SubjectApplicationResolver(
       [
-        new CacheSubjectSegmentFixedStrategy("file_reader_raw"),
-        new CacheSubjectSegmentFixedStrategy(this.config.id),
-        new CacheSubjectSegmentFixedStrategy(typeof path === "string" ? path : path.get()),
+        new SubjectSegmentFixedStrategy("file_reader_raw"),
+        new SubjectSegmentFixedStrategy(this.config.id),
+        new SubjectSegmentFixedStrategy(typeof path === "string" ? path : path.get()),
       ],
       this.deps,
     );

package/src/file-reader-text-with-cache.adapter.ts

@@ -1,24 +1,25 @@
 import type * as tools from "@bgord/tools";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
-import { CacheSubjectApplicationResolver } from "./cache-subject-application-resolver.vo";
-import { CacheSubjectSegmentFixedStrategy } from "./cache-subject-segment-fixed.strategy";
 import type { FileReaderTextPort } from "./file-reader-text.port";
 import type { HashContentStrategy } from "./hash-content.strategy";
+import { SubjectApplicationResolver } from "./subject-application-resolver.vo";
+import { SubjectSegmentFixedStrategy } from "./subject-segment-fixed.strategy";
 
 type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
+type Config = { id: string; inner: FileReaderTextPort };
 
 export class FileReaderTextWithCacheAdapter implements FileReaderTextPort {
   constructor(
-    private readonly config: { id: string; inner: FileReaderTextPort },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 
   async read(path: tools.FilePathRelative | tools.FilePathAbsolute | string): Promise<string> {
-    const resolver = new CacheSubjectApplicationResolver(
+    const resolver = new SubjectApplicationResolver(
       [
-        new CacheSubjectSegmentFixedStrategy("file_reader_text"),
-        new CacheSubjectSegmentFixedStrategy(this.config.id),
-        new CacheSubjectSegmentFixedStrategy(typeof path === "string" ? path : path.get()),
+        new SubjectSegmentFixedStrategy("file_reader_text"),
+        new SubjectSegmentFixedStrategy(this.config.id),
+        new SubjectSegmentFixedStrategy(typeof path === "string" ? path : path.get()),
       ],
       this.deps,
     );

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 {}
+  }
+}