@bgord/bun 1.10.23 → 1.12.0

package/src/ab-hono.middleware.ts

@@ -0,0 +1,28 @@
+import type { MiddlewareHandler } from "hono";
+import { AbMiddleware } from "./ab.middleware";
+import type { AbAssignmentStrategy } from "./ab-assignment.strategy";
+import type { AbVariant } from "./ab-variant.vo";
+import type { AbVariants } from "./ab-variants.vo";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+
+export type AbVariables = { abVariant: AbVariant | undefined };
+
+export class AbHonoMiddleware implements MiddlewareHonoPort {
+  private readonly middleware: AbMiddleware;
+
+  constructor(variants: AbVariants, strategy: AbAssignmentStrategy) {
+    this.middleware = new AbMiddleware(variants, strategy);
+  }
+
+  handle(): MiddlewareHandler {
+    return async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+      const variant = await this.middleware.evaluate(context);
+
+      c.set("abVariant", variant);
+
+      return next();
+    };
+  }
+}

package/src/ab-variant-selector.service.ts

@@ -0,0 +1,27 @@
+import * as tools from "@bgord/tools";
+import type { AbVariant } from "./ab-variant.vo";
+import type { AbVariants } from "./ab-variants.vo";
+import type { Hash } from "./hash.vo";
+import { HashBucket } from "./hash-bucket.vo";
+
+// Stryker disable all
+export const AbVariantSelectorError = { NoVariantSelected: "ab.variant.selector.no.variant.selected" };
+// Stryker restore all
+
+export class AbVariantSelector {
+  constructor(private readonly variants: AbVariants) {}
+
+  select(hash: Hash): AbVariant {
+    const bucket = HashBucket.fromHash(hash);
+
+    let cumulative = tools.IntegerNonNegative.parse(0);
+
+    for (const variant of this.variants.variants) {
+      cumulative = tools.IntegerNonNegative.parse(cumulative + variant.config.weight);
+
+      if (bucket.isLessThan(cumulative)) return variant;
+    }
+
+    throw new Error(AbVariantSelectorError.NoVariantSelected);
+  }
+}

package/src/ab-variant-weight.vo.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+
+export const AbVariantWeightErrors = { MinMax: "ab.variant.weight.min.max" };
+
+// Stryker disable all
+export const AbVariantWeight = z
+  // Stryker restore all
+  .int(AbVariantWeightErrors.MinMax)
+  .gte(1, AbVariantWeightErrors.MinMax)
+  .lte(99, AbVariantWeightErrors.MinMax)
+  .brand("AbVariantWeight");
+
+export type AbVariantWeightType = z.infer<typeof AbVariantWeight>;

package/src/ab-variant.vo.ts

@@ -0,0 +1,7 @@
+import type { AbVariantWeightType } from "./ab-variant-weight.vo";
+
+type Config = { name: string; weight: AbVariantWeightType };
+
+export class AbVariant {
+  constructor(readonly config: Config) {}
+}

package/src/ab-variants.vo.ts

@@ -0,0 +1,24 @@
+import * as tools from "@bgord/tools";
+import type { AbVariant } from "./ab-variant.vo";
+
+export const AbVariantsError = {
+  Min: "ab.variants.min",
+  Max: "ab.variants.max",
+  UniqueNames: "ab.variants.unique.names",
+  Sum: "ab.variants.sum",
+};
+
+export class AbVariants {
+  constructor(readonly variants: ReadonlyArray<AbVariant>) {
+    if (variants.length <= 1) throw new Error(AbVariantsError.Min);
+    if (variants.length > 5) throw new Error(AbVariantsError.Max);
+
+    const names = new Set(variants.map((variant) => variant.config.name));
+
+    if (names.size !== variants.length) throw new Error(AbVariantsError.UniqueNames);
+
+    const sum = tools.Sum.of(variants.map((variant) => variant.config.weight));
+
+    if (sum !== 100) throw new Error(AbVariantsError.Sum);
+  }
+}

package/src/ab.middleware.ts

@@ -0,0 +1,15 @@
+import type { AbAssignmentStrategy } from "./ab-assignment.strategy";
+import type { AbVariant } from "./ab-variant.vo";
+import type { AbVariants } from "./ab-variants.vo";
+import type { RequestContext } from "./request-context.port";
+
+export class AbMiddleware {
+  constructor(
+    private readonly variants: AbVariants,
+    private readonly strategy: AbAssignmentStrategy,
+  ) {}
+
+  async evaluate(context: RequestContext): Promise<AbVariant | undefined> {
+    return this.strategy.assign(context, this.variants);
+  }
+}

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

@@ -0,0 +1,30 @@
+import type { MiddlewareHandler } from "hono";
+import { ApiVersionMiddleware } from "./api-version.middleware";
+import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import type { HashContentStrategy } from "./hash-content.strategy";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+
+type Dependencies = {
+  CacheResolver: CacheResolverStrategy;
+  HashContent: HashContentStrategy;
+  BuildInfoRepository: BuildInfoRepositoryStrategy;
+};
+
+export class ApiVersionHonoMiddleware implements MiddlewareHonoPort {
+  private readonly middleware: ApiVersionMiddleware;
+
+  constructor(deps: Dependencies) {
+    this.middleware = new ApiVersionMiddleware(deps);
+  }
+
+  handle(): MiddlewareHandler {
+    return async (c, next) => {
+      const version = await this.middleware.evaluate();
+
+      c.res.headers.set(ApiVersionMiddleware.HEADER_NAME, version.toString());
+
+      return next();
+    };
+  }
+}

package/src/api-version.middleware.ts

@@ -1,9 +1,9 @@
-import { createMiddleware } from "hono/factory";
+import type * as tools from "@bgord/tools";
 import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
 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 { HashContentStrategy } from "./hash-content.strategy";
+import { SubjectApplicationResolver } from "./subject-application-resolver.vo";
+import { SubjectSegmentFixedStrategy } from "./subject-segment-fixed.strategy";
 
 type Dependencies = {
   CacheResolver: CacheResolverStrategy;
@@ -11,21 +11,22 @@ type Dependencies = {
   BuildInfoRepository: BuildInfoRepositoryStrategy;
 };
 
-export class ApiVersion {
+export class ApiVersionMiddleware {
   static readonly HEADER_NAME = "api-version";
 
-  static build = (deps: Dependencies) =>
-    createMiddleware(async (c, next) => {
-      const resolver = new CacheSubjectApplicationResolver(
-        [new CacheSubjectSegmentFixedStrategy("api-version")],
-        deps,
-      );
-      const subject = await resolver.resolve();
+  constructor(private readonly deps: Dependencies) {}
 
-      const build = await deps.CacheResolver.resolve(subject.hex, async () =>
-        deps.BuildInfoRepository.extract(),
-      );
-      c.res.headers.set(ApiVersion.HEADER_NAME, build.version.toString());
-      await next();
-    });
+  async evaluate(): Promise<tools.PackageVersion> {
+    const resolver = new SubjectApplicationResolver(
+      [new SubjectSegmentFixedStrategy("api-version")],
+      this.deps,
+    );
+    const subject = await resolver.resolve();
+
+    const build = await this.deps.CacheResolver.resolve(subject.hex, async () =>
+      this.deps.BuildInfoRepository.extract(),
+    );
+
+    return build.version;
+  }
 }

package/src/auth-session-reader.port.ts

@@ -1,7 +1,7 @@
 import type { HasRequestHeaders } from "./request-context.port";
 
+export type AuthSessionType<User, Session> = { user: User; session: Session } | { user: null; session: null };
+
 export interface AuthSessionReaderPort<User, Session> {
-  getSession(
-    context: HasRequestHeaders,
-  ): Promise<{ user: User; session: Session } | { user: null; session: null }>;
+  getSession(context: HasRequestHeaders): Promise<AuthSessionType<User, Session>>;
 }

package/src/basic-auth.service.ts

@@ -1,14 +1,14 @@
 import type { BasicAuthPasswordType } from "./basic-auth-password.vo";
 import type { BasicAuthUsernameType } from "./basic-auth-username.vo";
 
-type BasicAuthConfigType = { username: BasicAuthUsernameType; password: BasicAuthPasswordType };
+type Config = { username: BasicAuthUsernameType; password: BasicAuthPasswordType };
 
 export class BasicAuth {
-  static toHeaderValue(config: BasicAuthConfigType): { authorization: string } {
+  static toHeaderValue(config: Config): { authorization: string } {
     return { authorization: `Basic ${btoa(`${config.username}:${config.password}`)}` };
   }
 
-  static toHeader(config: BasicAuthConfigType): Headers {
+  static toHeader(config: Config): Headers {
     return new Headers(BasicAuth.toHeaderValue(config));
   }
 }

package/src/cache-response-hono.middleware.ts

@@ -0,0 +1,53 @@
+import { createMiddleware } from "hono/factory";
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import type { CacheResponseConfig } from "./cache-response.middleware";
+import { CacheResponseMiddleware } from "./cache-response.middleware";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+
+type Dependencies = { CacheResolver: CacheResolverStrategy };
+
+export class CacheResponseHonoMiddleware implements MiddlewareHonoPort {
+  private readonly middleware: CacheResponseMiddleware;
+
+  constructor(config: CacheResponseConfig, deps: Dependencies) {
+    this.middleware = new CacheResponseMiddleware(config, deps);
+  }
+
+  handle() {
+    return createMiddleware(async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+
+      const result = await this.middleware.evaluate(context, async () => {
+        await next();
+
+        const response = c.res.clone();
+
+        return {
+          body: await response.text(),
+          headers: response.headers.toJSON(),
+          status: response.status as ContentfulStatusCode,
+        };
+      });
+
+      if (!result) return next();
+
+      c.header(CacheResponseMiddleware.CACHE_HIT_HEADER, result.source);
+
+      return c.newResponse(
+        result.response.body,
+        result.response.status as ContentfulStatusCode,
+        result.response.headers,
+      );
+    });
+  }
+
+  clear() {
+    return createMiddleware(async (_c, next) => {
+      await this.middleware.clear();
+
+      return next();
+    });
+  }
+}

package/src/cache-response.middleware.ts

@@ -1,53 +1,47 @@
-import { createMiddleware } from "hono/factory";
-import type { ContentfulStatusCode } from "hono/utils/http-status";
-import type { CacheResolverStrategy } from "./cache-resolver.strategy";
-import type { CacheSubjectRequestResolver } from "./cache-subject-request-resolver.vo";
-import { RequestContextAdapterHono } from "./request-context-hono.adapter";
+import type { CacheResolverStrategy, CacheSourceEnum } from "./cache-resolver.strategy";
+import type { RequestContext } from "./request-context.port";
+import type { SubjectRequestResolver } from "./subject-request-resolver.vo";
 
 type Dependencies = { CacheResolver: CacheResolverStrategy };
 
-type CacheResponseOptions = { enabled: boolean; resolver: CacheSubjectRequestResolver };
+export type CacheResponseConfig = { enabled: boolean; resolver: SubjectRequestResolver };
 
-type CachedResponse = {
-  body: string;
+export type CachedResponse<T = string> = {
+  body: T;
   headers: Record<string, string>;
-  status: ContentfulStatusCode;
+  status: number;
 };
 
-export class CacheResponse {
+export type CacheResponseResult<T = string> = {
+  response: CachedResponse<T>;
+  source: CacheSourceEnum;
+};
+
+export class CacheResponseMiddleware {
   static readonly CACHE_HIT_HEADER = "Cache-Hit";
 
   constructor(
-    private readonly config: CacheResponseOptions,
+    private readonly config: CacheResponseConfig,
     private readonly deps: Dependencies,
   ) {}
 
-  handle = createMiddleware(async (c, next) => {
-    if (!this.config.enabled) return next();
+  async evaluate<T = string>(
+    context: RequestContext,
+    generateResponse: () => Promise<CachedResponse<T>>,
+  ): Promise<CacheResponseResult<T> | null> {
+    if (!this.config.enabled) return null;
 
-    const context = new RequestContextAdapterHono(c);
     const subject = await this.config.resolver.resolve(context);
 
-    const result = await this.deps.CacheResolver.resolveWithContext<CachedResponse>(subject.hex, async () => {
-      await next();
-
-      const response = c.res.clone();
+    const result = await this.deps.CacheResolver.resolveWithContext<CachedResponse<T>>(
+      subject.hex,
+      generateResponse,
+    );
 
-      return {
-        body: await response.text(),
-        headers: response.headers.toJSON(),
-        status: response.status as ContentfulStatusCode,
-      };
-    });
+    return { response: result.value, source: result.source };
+  }
 
-    c.header(CacheResponse.CACHE_HIT_HEADER, result.source);
-
-    return c.newResponse(result.value.body, result.value.status, result.value.headers);
-  });
-
-  clear = createMiddleware(async (_, next) => {
+  async clear(): Promise<void> {
     await this.deps.CacheResolver.flush();
-
-    return next();
-  });
+  }
 }

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

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

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

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

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

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

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

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

package/src/command-bus.port.ts

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

package/src/correlation-hono.middleware.ts

@@ -0,0 +1,32 @@
+import { createMiddleware } from "hono/factory";
+import { CorrelationIdMiddleware } from "./correlation-id.middleware";
+import { CorrelationStorage } from "./correlation-storage.service";
+import type { IdProviderPort } from "./id-provider.port";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+import type { UUIDType } from "./uuid.vo";
+
+type Dependencies = { IdProvider: IdProviderPort };
+
+export type CorrelationVariables = { correlationId: UUIDType };
+
+export class CorrelationHonoMiddleware implements MiddlewareHonoPort {
+  private readonly correlationId: CorrelationIdMiddleware;
+
+  constructor(deps: Dependencies) {
+    this.correlationId = new CorrelationIdMiddleware(deps);
+  }
+
+  handle() {
+    return createMiddleware(async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+
+      const result = this.correlationId.evaluate(context);
+
+      c.set("correlationId", result);
+      c.header(CorrelationIdMiddleware.HEADER_NAME, result);
+
+      return CorrelationStorage.run(result, next);
+    });
+  }
+}

package/src/correlation-id.middleware.ts

@@ -0,0 +1,20 @@
+import type { IdProviderPort } from "./id-provider.port";
+import type { HasRequestHeader } from "./request-context.port";
+import { UUID, type UUIDType } from "./uuid.vo";
+
+type Dependencies = { IdProvider: IdProviderPort };
+
+export class CorrelationIdMiddleware {
+  static readonly HEADER_NAME = "correlation-id";
+
+  constructor(private readonly deps: Dependencies) {}
+
+  evaluate(context: HasRequestHeader): UUIDType {
+    const incoming = context.request.header(CorrelationIdMiddleware.HEADER_NAME);
+
+    const existing = UUID.safeParse(incoming);
+
+    if (existing.success) return existing.data;
+    return this.deps.IdProvider.generate();
+  }
+}

package/src/correlation-storage.service.ts

@@ -1,5 +1,4 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { createMiddleware } from "hono/factory";
 import type { CorrelationIdType } from "./correlation-id.vo";
 
 type CorrelationContext = { correlationId: CorrelationIdType };
@@ -25,6 +24,4 @@ export class CorrelationStorage {
     if (!store) throw new Error(CorrelationStorageError.Missing);
     return store.correlationId;
   }
-
-  static handle = () => createMiddleware(async (c, next) => CorrelationStorage.run(c.get("requestId"), next));
 }

package/src/crypto-key-provider-with-cache.adapter.ts

@@ -1,22 +1,24 @@
 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 { CryptoKeyProviderPort } from "./crypto-key-provider.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: CryptoKeyProviderPort };
+
 export class CryptoKeyProviderWithCacheAdapter implements CryptoKeyProviderPort {
   constructor(
-    private readonly config: { id: string; inner: CryptoKeyProviderPort },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 
   async get(): Promise<CryptoKey> {
-    const resolver = new CacheSubjectApplicationResolver(
+    const resolver = new SubjectApplicationResolver(
       [
-        new CacheSubjectSegmentFixedStrategy("crypto_key_provider"),
-        new CacheSubjectSegmentFixedStrategy(this.config.id),
+        new SubjectSegmentFixedStrategy("crypto_key_provider"),
+        new SubjectSegmentFixedStrategy(this.config.id),
       ],
       this.deps,
     );

package/src/dispatching-event-store.ts

@@ -1,7 +1,7 @@
 // Stryker disable all
 import type * as z from "zod/v4";
 import type { GenericEventSchema, GenericParsedEventSchema } from "./event.types";
-import type { EventPublisher } from "./event-publisher.types";
+import type { EventBusPort } from "./event-bus.port";
 import { EventStore as BaseStore } from "./event-store";
 import type { EventStreamType } from "./event-stream.vo";
 import type { ToEventMap } from "./to-event-map.types";
@@ -19,7 +19,7 @@ export class DispatchingEventStore<AllEvents extends GenericEventSchema> extends
         events: ReadonlyArray<z.infer<GenericParsedEventSchema>>,
       ) => Promise<ReadonlyArray<z.infer<GenericParsedEventSchema>>>;
     },
-    private readonly publisher: EventPublisher<ToEventMap<z.infer<AllEvents>>>,
+    private readonly publisher: EventBusPort<z.infer<AllEvents>>,
   ) {
     super(config);
   }

package/src/environment-loader-process-safe.adapter.ts

@@ -1,10 +1,10 @@
 import type * as z from "zod/v4";
 import type { NodeEnvironmentEnum } from "../src/node-env.vo";
 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 { EnvironmentLoaderPort, EnvironmentResultType } from "./environment-loader.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 };
 
@@ -18,10 +18,7 @@ export class EnvironmentLoaderProcessSafeAdapter<Schema extends z.ZodObject<any>
   ) {}
 
   async load(): Promise<Readonly<EnvironmentResultType<Schema>>> {
-    const resolver = new CacheSubjectApplicationResolver(
-      [new CacheSubjectSegmentFixedStrategy("env")],
-      this.deps,
-    );
+    const resolver = new SubjectApplicationResolver([new SubjectSegmentFixedStrategy("env")], this.deps);
     const subject = await resolver.resolve();
 
     const result = await this.deps.CacheResolver.resolve(subject.hex, async () =>

package/src/etag-extractor-hono.middleware.ts

@@ -0,0 +1,27 @@
+import type * as tools from "@bgord/tools";
+import type { MiddlewareHandler } from "hono";
+import { ETagExtractorMiddleware } from "./etag-extractor.middleware";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+
+/** @public */
+export type ETagVariables = { ETag: tools.ETag | null };
+
+export class ETagExtractorHonoMiddleware implements MiddlewareHonoPort {
+  private readonly middleware: ETagExtractorMiddleware;
+
+  constructor() {
+    this.middleware = new ETagExtractorMiddleware();
+  }
+
+  handle(): MiddlewareHandler {
+    return async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+      const etag = this.middleware.evaluate(context);
+
+      c.set("ETag", etag);
+
+      await next();
+    };
+  }
+}