@bgord/bun 1.10.23 → 1.11.0

package/src/prerequisite-verifier-with-fail-safe.adapter.ts

@@ -5,20 +5,20 @@ import {
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
-export type PrerequisiteVerifierWithFailSafeAdapterConfigType = (
+export type PrerequisiteVerifierWithFailSafeAdapterConfig = (
   result: PrerequisiteVerificationResult,
 ) => boolean;
 
-const AnyErrorFailSafe: PrerequisiteVerifierWithFailSafeAdapterConfigType = (result) =>
+const AnyErrorFailSafe: PrerequisiteVerifierWithFailSafeAdapterConfig = (result) =>
   result.outcome === PrerequisiteVerificationOutcome.failure;
 
 export class PrerequisiteVerifierWithFailSafeAdapter implements PrerequisiteVerifierPort {
-  private readonly when: PrerequisiteVerifierWithFailSafeAdapterConfigType;
+  private readonly when: PrerequisiteVerifierWithFailSafeAdapterConfig;
 
   constructor(
     private readonly config: {
       inner: PrerequisiteVerifierPort;
-      when?: PrerequisiteVerifierWithFailSafeAdapterConfigType;
+      when?: PrerequisiteVerifierWithFailSafeAdapterConfig;
     },
   ) {
     this.when = config.when ?? AnyErrorFailSafe;

package/src/prerequisite-verifier-with-logger.adapter.ts

@@ -10,6 +10,8 @@ import { Stopwatch } from "./stopwatch.service";
 
 type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
 
+type Config = { inner: PrerequisiteVerifierPort };
+
 export class PrerequisiteVerifierWithLoggerAdapter implements PrerequisiteVerifierPort {
   private readonly base = (duration: tools.Duration) => ({
     component: "infra",
@@ -18,7 +20,7 @@ export class PrerequisiteVerifierWithLoggerAdapter implements PrerequisiteVerifi
   });
 
   constructor(
-    private readonly config: { inner: PrerequisiteVerifierPort },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 

package/src/prerequisite-verifier-with-retry.adapter.ts

@@ -4,14 +4,15 @@ import {
   type PrerequisiteVerificationResult,
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
-import { Retry, type RetryConfigType } from "./retry.service";
+import { Retry, type RetryConfig } from "./retry.service";
 import type { SleeperPort } from "./sleeper.port";
 
 type Dependencies = { Sleeper: SleeperPort };
+type Config = { inner: PrerequisiteVerifierPort; retry: RetryConfig };
 
 export class PrerequisiteVerifierWithRetryAdapter implements PrerequisiteVerifierPort {
   constructor(
-    private readonly config: { inner: PrerequisiteVerifierPort; retry: RetryConfigType },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 

package/src/prerequisite-verifier-with-timeout.adapter.ts

@@ -7,10 +7,11 @@ import {
 import type { TimeoutRunnerPort } from "./timeout-runner.port";
 
 type Dependencies = { TimeoutRunner: TimeoutRunnerPort };
+type Config = { inner: PrerequisiteVerifierPort; timeout: tools.Duration };
 
 export class PrerequisiteVerifierWithTimeoutAdapter implements PrerequisiteVerifierPort {
   constructor(
-    private readonly config: { inner: PrerequisiteVerifierPort; timeout: tools.Duration },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 

package/src/prerequisite-verifier.decorator.ts

@@ -7,12 +7,12 @@ import type { PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
 import { PrerequisiteVerifierWithCacheAdapter } from "./prerequisite-verifier-with-cache.adapter";
 import {
   PrerequisiteVerifierWithFailSafeAdapter,
-  type PrerequisiteVerifierWithFailSafeAdapterConfigType,
+  type PrerequisiteVerifierWithFailSafeAdapterConfig,
 } from "./prerequisite-verifier-with-fail-safe.adapter";
 import { PrerequisiteVerifierWithLoggerAdapter } from "./prerequisite-verifier-with-logger.adapter";
 import { PrerequisiteVerifierWithRetryAdapter } from "./prerequisite-verifier-with-retry.adapter";
 import { PrerequisiteVerifierWithTimeoutAdapter } from "./prerequisite-verifier-with-timeout.adapter";
-import type { RetryConfigType } from "./retry.service";
+import type { RetryConfig } from "./retry.service";
 import type { SleeperPort } from "./sleeper.port";
 import type { TimeoutRunnerPort } from "./timeout-runner.port";
 
@@ -37,12 +37,12 @@ const withLogger =
     new PrerequisiteVerifierWithLoggerAdapter({ inner }, deps);
 
 const withRetry =
-  (retry: RetryConfigType, deps: { Sleeper: SleeperPort }): PrerequisiteVerifierDecorator =>
+  (retry: RetryConfig, deps: { Sleeper: SleeperPort }): PrerequisiteVerifierDecorator =>
   (inner) =>
     new PrerequisiteVerifierWithRetryAdapter({ inner, retry }, deps);
 
 const withFailSafe =
-  (when: PrerequisiteVerifierWithFailSafeAdapterConfigType): PrerequisiteVerifierDecorator =>
+  (when: PrerequisiteVerifierWithFailSafeAdapterConfig): PrerequisiteVerifierDecorator =>
   (inner) =>
     new PrerequisiteVerifierWithFailSafeAdapter({ inner, when });
 

package/src/prerequisite.vo.ts

@@ -3,10 +3,7 @@ import type { PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
 
 export type PrerequisiteLabelType = string;
 
-type PrerequisiteConfigType = {
-  decorators?: ReadonlyArray<PrerequisiteVerifierDecorator>;
-  enabled?: boolean;
-};
+type Config = { decorators?: ReadonlyArray<PrerequisiteVerifierDecorator>; enabled?: boolean };
 
 export class Prerequisite {
   private readonly decorators: ReadonlyArray<PrerequisiteVerifierDecorator>;
@@ -15,7 +12,7 @@ export class Prerequisite {
   constructor(
     readonly label: PrerequisiteLabelType,
     private readonly verifier: PrerequisiteVerifierPort,
-    config?: PrerequisiteConfigType,
+    config?: Config,
   ) {
     this.decorators = config?.decorators ?? [];
     this.enabled = config?.enabled ?? true;

package/src/remote-file-storage-disk.adapter.ts

@@ -11,8 +11,6 @@ import type {
   RemotePutFromPathResult,
 } from "./remote-file-storage.port";
 
-type RemoteFileStorageDiskConfig = { root: tools.DirectoryPathAbsoluteType };
-
 type Dependencies = {
   HashFile: HashFilePort;
   FileCleaner: FileCleanerPort;
@@ -21,9 +19,11 @@ type Dependencies = {
   DirectoryEnsurer: DirectoryEnsurerPort;
 };
 
+type Config = { root: tools.DirectoryPathAbsoluteType };
+
 export class RemoteFileStorageDiskAdapter implements RemoteFileStoragePort {
   constructor(
-    private readonly config: RemoteFileStorageDiskConfig,
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 

package/src/request-context-hono.adapter.ts

@@ -3,7 +3,7 @@ import { getConnInfo } from "hono/bun";
 import { getCookie } from "hono/cookie";
 import type { RequestContext } from "./request-context.port";
 
-export class RequestContextAdapterHono implements RequestContext {
+export class RequestContextHonoAdapter implements RequestContext {
   readonly request: RequestContext["request"];
   readonly identity: RequestContext["identity"];
 
@@ -11,9 +11,20 @@ export class RequestContextAdapterHono implements RequestContext {
     this.request = {
       path: context.req.path,
       method: context.req.method,
+      url: () => context.req.url,
       header: (name) => context.req.header(name),
       headers: () => context.req.raw.headers,
+      headersObject: () => {
+        const headers: Record<string, string> = {};
+
+        context.req.raw.headers.forEach((value, key) => {
+          headers[key] = value;
+        });
+
+        return headers;
+      },
       query: () => context.req.query(),
+      params: () => context.req.param(),
       cookie: (name) => getCookie(context)[name],
       json: async () => {
         try {

package/src/request-context.port.ts

@@ -4,11 +4,14 @@ export interface RequestContext {
   readonly request: {
     readonly path: string;
     readonly method: string;
+    url(): string;
     header(name: string): string | undefined;
     query(): Record<string, string>;
+    params(): Record<string, string>;
     cookie(name: string): string | undefined;
     json(): Promise<Record<string, unknown>>;
     headers: () => Headers;
+    headersObject: () => Record<string, string>;
   };
 
   readonly identity: {
@@ -18,6 +21,10 @@ export interface RequestContext {
   };
 }
 
+export interface HasRequestUrl {
+  readonly request: { url(): string };
+}
+
 export interface HasRequestPath {
   readonly request: { readonly path: string };
 }
@@ -34,10 +41,18 @@ export interface HasRequestHeaders {
   readonly request: { headers: () => Headers };
 }
 
+export interface HasRequestHeadersObject {
+  readonly request: { headers: () => Record<string, string> };
+}
+
 export interface HasRequestQuery {
   readonly request: { query(): Record<string, string> };
 }
 
+export interface HasRequestParams {
+  readonly request: { params(): Record<string, string> };
+}
+
 export interface HasRequestCookie {
   readonly request: { cookie(name: string): string | undefined };
 }

package/src/retry.service.ts

@@ -2,20 +2,20 @@ import * as tools from "@bgord/tools";
 import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
 import type { SleeperPort } from "./sleeper.port";
 
+export const RetryError = { InvalidMax: "retry.invalid.max" };
+
 type Dependencies = { Sleeper: SleeperPort };
 
-export type RetryConfigType = {
+export type RetryConfig = {
   max: tools.IntegerPositiveType;
   backoff: RetryBackoffStrategy;
   when?: (error: unknown) => boolean;
 };
 
-export const RetryError = { InvalidMax: "retry.invalid.max" };
-
 export class Retry {
   constructor(private readonly deps: Dependencies) {}
 
-  async run<T>(action: () => Promise<T>, config: RetryConfigType): Promise<T> {
+  async run<T>(action: () => Promise<T>, config: RetryConfig): Promise<T> {
     if (config.max < 1) throw new Error(RetryError.InvalidMax);
 
     let lastError: unknown;

package/src/security-countermeasure-ban.strategy.ts

@@ -16,6 +16,10 @@ import {
   type SecurityCountermeasureNameType,
 } from "./security-countermeasure-name.vo";
 
+export const SecurityCountermeasureBanStrategyError = {
+  Executed: "security.countermeasure.ban.strategy.executed",
+};
+
 type Dependencies = {
   IdProvider: IdProviderPort;
   Clock: ClockPort;
@@ -23,14 +27,12 @@ type Dependencies = {
   EventStore: EventStoreLike<SecurityViolationDetectedEventType>;
 };
 
-export const SecurityCountermeasureBanStrategyError = {
-  Executed: "security.countermeasure.ban.strategy.executed",
-};
+type Config = { response: { status: number } };
 
 export class SecurityCountermeasureBanStrategy implements SecurityCountermeasureStrategy {
   constructor(
     private readonly deps: Dependencies,
-    private readonly config: { response: { status: number } } = { response: { status: 403 } },
+    private readonly config: Config = { response: { status: 403 } },
   ) {}
 
   async execute(context: SecurityContext): Promise<SecurityAction> {

package/src/security-countermeasure-mirage.strategy.ts

@@ -8,11 +8,12 @@ import {
 } from "./security-countermeasure-name.vo";
 
 type Dependencies = { Logger: LoggerPort };
+type Config = { response: { status: number } };
 
 export class SecurityCountermeasureMirageStrategy implements SecurityCountermeasureStrategy {
   constructor(
     private readonly deps: Dependencies,
-    private readonly config: { response: { status: number } } = { response: { status: 200 } },
+    private readonly config: Config = { response: { status: 200 } },
   ) {}
 
   async execute(context: SecurityContext): Promise<SecurityAction> {

package/src/security-countermeasure-tarpit.strategy.ts

@@ -9,11 +9,12 @@ import {
 } from "./security-countermeasure-name.vo";
 
 type Dependencies = { Logger: LoggerPort };
+type Config = { duration: tools.Duration; after: SecurityAction };
 
 export class SecurityCountermeasureTarpitStrategy implements SecurityCountermeasureStrategy {
   constructor(
     private readonly deps: Dependencies,
-    private readonly config: { duration: tools.Duration; after: SecurityAction },
+    private readonly config: Config,
   ) {}
 
   async execute(context: SecurityContext): Promise<SecurityAction> {

package/src/security-rule-violation-threshold.strategy.ts

@@ -1,26 +1,27 @@
 import * as tools from "@bgord/tools";
 import type { CacheRepositoryPort } from "./cache-repository.port";
-import { CacheSubjectRequestResolver } from "./cache-subject-request-resolver.vo";
-import { CacheSubjectSegmentFixedStrategy } from "./cache-subject-segment-fixed.strategy";
-import { CacheSubjectSegmentIpStrategy } from "./cache-subject-segment-ip.strategy";
 import type { HashContentStrategy } from "./hash-content.strategy";
 import type { RequestContext } from "./request-context.port";
 import type { SecurityRuleStrategy } from "./security-rule.strategy";
 import { SecurityRuleName, type SecurityRuleNameType } from "./security-rule-name.vo";
+import { SubjectRequestResolver } from "./subject-request-resolver.vo";
+import { SubjectSegmentFixedStrategy } from "./subject-segment-fixed.strategy";
+import { SubjectSegmentIpStrategy } from "./subject-segment-ip.strategy";
 
 type Dependencies = { CacheRepository: CacheRepositoryPort; HashContent: HashContentStrategy };
+type Config = { threshold: tools.IntegerPositiveType };
 
 export class SecurityRuleViolationThresholdStrategy implements SecurityRuleStrategy {
   constructor(
     private readonly rule: SecurityRuleStrategy,
-    private readonly config: { threshold: tools.IntegerPositiveType },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 
   // Best-effort increment, occasional lost increments are acceptable for concurrent requests.
   async isViolated(context: RequestContext): Promise<boolean> {
-    const resolver = new CacheSubjectRequestResolver(
-      [new CacheSubjectSegmentFixedStrategy(this.name), new CacheSubjectSegmentIpStrategy()],
+    const resolver = new SubjectRequestResolver(
+      [new SubjectSegmentFixedStrategy(this.name), new SubjectSegmentIpStrategy()],
       this.deps,
     );
     const subject = await resolver.resolve(context);

package/src/{setup.service.ts → setup-hono.service.ts}

@@ -1,60 +1,56 @@
 import * as tools from "@bgord/tools";
-import { bodyLimit } from "hono/body-limit";
 import { cors } from "hono/cors";
 import { languageDetector } from "hono/language";
-import { requestId } from "hono/request-id";
 import { secureHeaders } from "hono/secure-headers";
-import { timing } from "hono/timing";
-import { trimTrailingSlash } from "hono/trailing-slash";
-import { ApiVersion } from "./api-version.middleware";
+import { ApiVersionHonoMiddleware } from "./api-version-hono.middleware";
 import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
 import type { ClockPort } from "./clock.port";
-import { Context } from "./context.middleware";
-import { CorrelationStorage } from "./correlation-storage.service";
-import { ETagExtractor } from "./etag-extractor.middleware";
+import { CorrelationHonoMiddleware } from "./correlation-hono.middleware";
+import { ETagExtractorHonoMiddleware } from "./etag-extractor-hono.middleware";
 import type { HashContentStrategy } from "./hash-content.strategy";
-import { HttpLogger, type HttpLoggerOptions } from "./http-logger.middleware";
-import type { I18nConfigType } from "./i18n.service";
+import type { HttpLoggerConfig } from "./http-logger.middleware";
+import { HttpLoggerHonoMiddleware } from "./http-logger-hono.middleware";
+import type { I18nConfig } from "./i18n.service";
 import type { IdProviderPort } from "./id-provider.port";
 import type { LoggerPort } from "./logger.port";
-import { MaintenanceMode, type MaintenanceModeConfigType } from "./maintenance-mode.middleware";
-import { type ShieldCsrfConfigType, ShieldCsrfStrategy } from "./shield-csrf.strategy";
-import { TimeZoneOffset } from "./time-zone-offset.middleware";
-import { WeakETagExtractor } from "./weak-etag-extractor.middleware";
-
-type SetupConfigType = {
-  csrf: ShieldCsrfConfigType;
-  cors?: Parameters<typeof cors>[0];
-  httpLogger?: HttpLoggerOptions;
-  maintenanceMode?: MaintenanceModeConfigType;
-  BODY_LIMIT_MAX_SIZE?: tools.Size;
-};
+import type { ShieldCsrfConfig } from "./shield-csrf.strategy";
+import { ShieldCsrfHonoStrategy } from "./shield-csrf-hono.strategy";
+import type { ShieldMaintenanceConfig } from "./shield-maintenance.strategy";
+import { ShieldMaintenanceHonoStrategy } from "./shield-maintenance-hono.strategy";
+import { TimeZoneOffsetHonoMiddleware } from "./time-zone-offset-hono.middleware";
+import { TimingHonoMiddleware } from "./timing-hono.middleware";
+import { TrailingSlashHonoMiddleware } from "./trailing-slash-hono.middleware";
+import { WeakETagExtractorHonoMiddleware } from "./weak-etag-extractor-hono.middleware";
 
 type Dependencies = {
   Logger: LoggerPort;
   IdProvider: IdProviderPort;
-  I18n: I18nConfigType;
+  I18n: I18nConfig;
   Clock: ClockPort;
   CacheResolver: CacheResolverStrategy;
   HashContent: HashContentStrategy;
   BuildInfoRepository: BuildInfoRepositoryStrategy;
 };
 
-export class Setup {
-  static essentials(config: SetupConfigType, deps: Dependencies) {
-    const BODY_LIMIT_MAX_SIZE = config.BODY_LIMIT_MAX_SIZE ?? tools.Size.fromKb(128);
+type Config = {
+  csrf: ShieldCsrfConfig;
+  cors?: Parameters<typeof cors>[0];
+  httpLogger?: HttpLoggerConfig;
+  maintenanceMode?: ShieldMaintenanceConfig;
+};
 
+export class SetupHono {
+  // Configure body size limit at the framework level
+  // - Bun: maxRequestBodySize in Bun.serve()
+  // - Express: limit in express.json()
+  static essentials(config: Config, deps: Dependencies) {
     return [
-      MaintenanceMode.build(config.maintenanceMode),
-      trimTrailingSlash({ alwaysRedirect: true }),
-      requestId({
-        limitLength: 36,
-        headerName: "x-correlation-id",
-        generator: () => deps.IdProvider.generate(),
-      }),
-      ApiVersion.build(deps),
-      new ShieldCsrfStrategy(config.csrf).verify,
+      new ShieldMaintenanceHonoStrategy(config.maintenanceMode).handle(),
+      new TrailingSlashHonoMiddleware().handle(),
+      new CorrelationHonoMiddleware(deps).handle(),
+      new ApiVersionHonoMiddleware(deps).handle(),
+      new ShieldCsrfHonoStrategy(config.csrf).handle(),
       secureHeaders({
         referrerPolicy: "no-referrer",
         xContentTypeOptions: "nosniff",
@@ -67,7 +63,6 @@ export class Setup {
         originAgentCluster: false,
         xFrameOptions: false,
       }),
-      bodyLimit({ maxSize: BODY_LIMIT_MAX_SIZE.toBytes() }),
       cors({
         // Stryker disable all
         origin: (origin, c) => {
@@ -92,13 +87,11 @@ export class Setup {
         caches: false,
         // Stryker restore all
       }),
-      TimeZoneOffset.attach,
-      Context.attach,
-      WeakETagExtractor.attach,
-      ETagExtractor.attach,
-      HttpLogger.build(deps, config.httpLogger),
-      timing(),
-      CorrelationStorage.handle(),
+      new TimeZoneOffsetHonoMiddleware().handle(),
+      new WeakETagExtractorHonoMiddleware().handle(),
+      new ETagExtractorHonoMiddleware().handle(),
+      new HttpLoggerHonoMiddleware(deps, config.httpLogger).handle(),
+      new TimingHonoMiddleware(deps).handle(),
     ];
   }
 }

package/src/shield-api-key-hono.strategy.ts

@@ -0,0 +1,28 @@
+import type { MiddlewareHandler } from "hono";
+import { HTTPException } from "hono/http-exception";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+import {
+  type ApiKeyShieldConfig,
+  ShieldApiKeyStrategy,
+  ShieldApiKeyStrategyError,
+} from "./shield-api-key.strategy";
+
+export const ShieldApiKeyError = new HTTPException(403, { message: ShieldApiKeyStrategyError.Rejected });
+
+export class ShieldApiKeyHonoStrategy implements MiddlewareHonoPort {
+  private readonly strategy: ShieldApiKeyStrategy;
+
+  constructor(config: ApiKeyShieldConfig) {
+    this.strategy = new ShieldApiKeyStrategy(config);
+  }
+
+  handle(): MiddlewareHandler {
+    return async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+
+      if (this.strategy.evaluate(context)) return next();
+      throw ShieldApiKeyError;
+    };
+  }
+}

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

@@ -1,22 +1,16 @@
 import type * as tools from "@bgord/tools";
-import { createMiddleware } from "hono/factory";
-import { HTTPException } from "hono/http-exception";
-import { RequestContextAdapterHono } from "./request-context-hono.adapter";
-import type { ShieldStrategy } from "./shield.strategy";
+import type { HasRequestHeader } from "./request-context.port";
 
-type ApiKeyShieldConfigType = { API_KEY: tools.ApiKeyType };
+export type ApiKeyShieldConfig = { API_KEY: tools.ApiKeyType };
 
-export const ShieldApiKeyError = new HTTPException(403, { message: "shield.api.key" });
+export const ShieldApiKeyStrategyError = { Rejected: "shield.api.key.rejected" };
 
-export class ShieldApiKeyStrategy implements ShieldStrategy {
-  static readonly HEADER_NAME = "bgord-api-key";
+export class ShieldApiKeyStrategy {
+  static readonly HEADER_NAME = "api-key";
 
-  constructor(private readonly config: ApiKeyShieldConfigType) {}
+  constructor(private readonly config: ApiKeyShieldConfig) {}
 
-  verify = createMiddleware(async (c, next) => {
-    const context = new RequestContextAdapterHono(c);
-
-    if (context.request.header(ShieldApiKeyStrategy.HEADER_NAME) === this.config.API_KEY) return next();
-    throw ShieldApiKeyError;
-  });
+  evaluate(context: HasRequestHeader): boolean {
+    return context.request.header(ShieldApiKeyStrategy.HEADER_NAME) === this.config.API_KEY;
+  }
 }

package/src/shield-auth-hono.strategy.ts

@@ -0,0 +1,41 @@
+import type hono from "hono";
+import { createMiddleware } from "hono/factory";
+import { HTTPException } from "hono/http-exception";
+import type { AuthSessionReaderPort } from "./auth-session-reader.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+import { ShieldAuthStrategy, ShieldAuthStrategyError } from "./shield-auth.strategy";
+
+type Dependencies<User, Session> = { AuthSessionReader: AuthSessionReaderPort<User, Session> };
+
+export const ShieldAuthError = new HTTPException(403, { message: ShieldAuthStrategyError.Rejected });
+
+export class ShieldAuthHonoStrategy<User, Session> {
+  private readonly strategy: ShieldAuthStrategy<User, Session>;
+
+  constructor(deps: Dependencies<User, Session>) {
+    this.strategy = new ShieldAuthStrategy(deps);
+  }
+
+  attach = createMiddleware(async (c: hono.Context, next: hono.Next) => {
+    const context = new RequestContextHonoAdapter(c);
+    const auth = await this.strategy.attach(context);
+
+    c.set("user", auth.user);
+    c.set("session", auth.session);
+    return next();
+  });
+
+  verify = createMiddleware(async (c: hono.Context, next: hono.Next) => {
+    const user = c.get("user");
+
+    if (this.strategy.verify(user)) return next();
+    throw ShieldAuthError;
+  });
+
+  reverse = createMiddleware(async (c: hono.Context, next: hono.Next) => {
+    const user = c.get("user");
+
+    if (this.strategy.reverse(user)) return next();
+    throw ShieldAuthError;
+  });
+}

package/src/shield-auth.strategy.ts

@@ -1,36 +1,22 @@
-import type hono from "hono";
-import { createMiddleware } from "hono/factory";
-import { HTTPException } from "hono/http-exception";
-import type { AuthSessionReaderPort } from "./auth-session-reader.port";
-import { RequestContextAdapterHono } from "./request-context-hono.adapter";
+import type { AuthSessionReaderPort, AuthSessionType } from "./auth-session-reader.port";
+import type { HasRequestHeaders } from "./request-context.port";
 
 type Dependencies<User, Session> = { AuthSessionReader: AuthSessionReaderPort<User, Session> };
 
-export const ShieldAuthError = new HTTPException(403, { message: "shield.auth" });
+export const ShieldAuthStrategyError = { Rejected: "shield.auth.rejected" };
 
 export class ShieldAuthStrategy<User, Session> {
   constructor(private readonly deps: Dependencies<User, Session>) {}
 
-  attach = createMiddleware(async (c: hono.Context, next: hono.Next) => {
-    const context = new RequestContextAdapterHono(c);
-    const auth = await this.deps.AuthSessionReader.getSession(context);
+  async attach(context: HasRequestHeaders): Promise<AuthSessionType<User, Session>> {
+    return await this.deps.AuthSessionReader.getSession(context);
+  }
 
-    c.set("user", auth.user);
-    c.set("session", auth.session);
-    return next();
-  });
+  verify(user: User | null): boolean {
+    return user !== null;
+  }
 
-  verify = createMiddleware(async (c: hono.Context, next: hono.Next) => {
-    const user = c.get("user");
-
-    if (!user) throw ShieldAuthError;
-    return next();
-  });
-
-  reverse = createMiddleware(async (c: hono.Context, next: hono.Next) => {
-    const user = c.get("user");
-
-    if (user) throw ShieldAuthError;
-    return next();
-  });
+  reverse(user: User | null): boolean {
+    return user === null;
+  }
 }

package/src/shield-basic-auth-hono.strategy.ts

@@ -0,0 +1,30 @@
+import type { MiddlewareHandler } from "hono";
+import { HTTPException } from "hono/http-exception";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+import {
+  type ShieldBasicAuthConfig,
+  ShieldBasicAuthStrategy,
+  ShieldBasicAuthStrategyError,
+} from "./shield-basic-auth.strategy";
+
+export const ShieldBasicAuthError = new HTTPException(401, {
+  message: ShieldBasicAuthStrategyError.Rejected,
+});
+
+export class ShieldBasicAuthHonoStrategy implements MiddlewareHonoPort {
+  private readonly strategy: ShieldBasicAuthStrategy;
+
+  constructor(config: ShieldBasicAuthConfig) {
+    this.strategy = new ShieldBasicAuthStrategy(config);
+  }
+
+  handle(): MiddlewareHandler {
+    return async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+
+      if (this.strategy.evaluate(context)) return next();
+      throw ShieldBasicAuthError;
+    };
+  }
+}