@bgord/bun 1.10.23 → 1.12.0

package/src/prerequisite-verifier-clock-drift.adapter.ts

@@ -8,10 +8,11 @@ import {
 import type { TimekeeperPort } from "./timekeeper.port";
 
 type Dependencies = { Clock: ClockPort; Timekeeper: TimekeeperPort };
+type Config = { skew: tools.Duration };
 
 export class PrerequisiteVerifierClockDriftAdapter implements PrerequisiteVerifierPort {
   constructor(
-    private readonly config: { skew: tools.Duration },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 

package/src/prerequisite-verifier-directory.adapter.ts

@@ -8,14 +8,16 @@ import {
 
 type Dependencies = { FileInspection: FileInspectionPort };
 
+type Config = {
+  directory: tools.DirectoryPathAbsoluteType | tools.DirectoryPathRelativeType;
+  permissions?: PrerequisiteDirectoryPermissionsType;
+};
+
 export type PrerequisiteDirectoryPermissionsType = { read?: boolean; write?: boolean; execute?: boolean };
 
 export class PrerequisiteVerifierDirectoryAdapter implements PrerequisiteVerifierPort {
   constructor(
-    private readonly config: {
-      directory: tools.DirectoryPathAbsoluteType | tools.DirectoryPathRelativeType;
-      permissions?: PrerequisiteDirectoryPermissionsType;
-    },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 

package/src/prerequisite-verifier-dns.adapter.ts

@@ -5,8 +5,10 @@ import {
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
+type Config = { hostname: string };
+
 export class PrerequisiteVerifierDnsAdapter implements PrerequisiteVerifierPort {
-  constructor(private readonly config: { hostname: string }) {}
+  constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
     try {

package/src/prerequisite-verifier-external-api.adapter.ts

@@ -4,8 +4,10 @@ import {
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
+type Config = { request: () => Promise<Response> };
+
 export class PrerequisiteVerifierExternalApiAdapter implements PrerequisiteVerifierPort {
-  constructor(private readonly config: { request: () => Promise<Response> }) {}
+  constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
     try {

package/src/prerequisite-verifier-file.adapter.ts

@@ -8,14 +8,16 @@ import {
 
 type Dependencies = { FileInspection: FileInspectionPort };
 
+type Config = {
+  file: tools.FilePathAbsolute | tools.FilePathRelative;
+  permissions?: PrerequisiteFilePermissionsType;
+};
+
 export type PrerequisiteFilePermissionsType = { read?: boolean; write?: boolean; execute?: boolean };
 
 export class PrerequisiteVerifierFileAdapter implements PrerequisiteVerifierPort {
   constructor(
-    private readonly config: {
-      file: tools.FilePathAbsolute | tools.FilePathRelative;
-      permissions?: PrerequisiteFilePermissionsType;
-    },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 

package/src/prerequisite-verifier-jobs.adapter.ts

@@ -5,8 +5,10 @@ import {
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
+type Config = { Jobs: MultipleJobsType };
+
 export class PrerequisiteVerifierJobsAdapter implements PrerequisiteVerifierPort {
-  constructor(private readonly config: { Jobs: MultipleJobsType }) {}
+  constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
     if (Jobs.areAllRunning(this.config.Jobs)) return PrerequisiteVerification.success;

package/src/prerequisite-verifier-memory.adapter.ts

@@ -6,8 +6,10 @@ import {
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
+type Config = { maximum: tools.Size };
+
 export class PrerequisiteVerifierMemoryAdapter implements PrerequisiteVerifierPort {
-  constructor(private readonly config: { maximum: tools.Size }) {}
+  constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
     const memoryConsumption = MemoryConsumption.get();

package/src/prerequisite-verifier-node.adapter.ts

@@ -5,8 +5,10 @@ import {
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
+type Config = { version: tools.PackageVersion; current: string };
+
 export class PrerequisiteVerifierNodeAdapter implements PrerequisiteVerifierPort {
-  constructor(private readonly config: { version: tools.PackageVersion; current: string }) {}
+  constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
     try {

package/src/prerequisite-verifier-os.adapter.ts

@@ -5,8 +5,10 @@ import {
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
+type Config = { accepted: ReadonlyArray<string> };
+
 export class PrerequisiteVerifierOsAdapter implements PrerequisiteVerifierPort {
-  constructor(private readonly config: { accepted: ReadonlyArray<string> }) {}
+  constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
     const type = os.type().toLowerCase();

package/src/prerequisite-verifier-port.adapter.ts

@@ -6,8 +6,10 @@ import {
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
+type Config = { port: PortType };
+
 export class PrerequisiteVerifierPortAdapter implements PrerequisiteVerifierPort {
-  constructor(private readonly config: { port: PortType }) {}
+  constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
     return new Promise((resolve) => {

package/src/prerequisite-verifier-ram.adapter.ts

@@ -6,8 +6,10 @@ import {
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
+type Config = { minimum: tools.Size };
+
 export class PrerequisiteVerifierRamAdapter implements PrerequisiteVerifierPort {
-  constructor(private readonly config: { minimum: tools.Size }) {}
+  constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
     const freeRAM = tools.Size.fromBytes(os.freemem());

package/src/prerequisite-verifier-running-user.adapter.ts

@@ -5,8 +5,10 @@ import {
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
+type Config = { username: string };
+
 export class PrerequisiteVerifierRunningUserAdapter implements PrerequisiteVerifierPort {
-  constructor(private readonly config: { username: string }) {}
+  constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
     const current = os.userInfo().username;

package/src/prerequisite-verifier-space.adapter.ts

@@ -8,10 +8,11 @@ import {
 } from "./prerequisite-verifier.port";
 
 type Dependencies = { DiskSpaceChecker: DiskSpaceCheckerPort };
+type Config = { minimum: tools.Size };
 
 export class PrerequisiteVerifierSpaceAdapter implements PrerequisiteVerifierPort {
   constructor(
-    private readonly config: { minimum: tools.Size },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 

package/src/prerequisite-verifier-sqlite.adapter.ts

@@ -5,8 +5,10 @@ import {
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
+type Config = { sqlite: Database };
+
 export class PrerequisiteVerifierSQLiteAdapter implements PrerequisiteVerifierPort {
-  constructor(private readonly config: { sqlite: Database }) {}
+  constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
     try {

package/src/prerequisite-verifier-ssl-certificate-expiry.adapter.ts

@@ -8,9 +8,11 @@ import {
 
 type Dependencies = { CertificateInspector: CertificateInspectorPort };
 
+type Config = { hostname: string; minimum: tools.Duration };
+
 export class PrerequisiteVerifierSSLCertificateExpiryAdapter implements PrerequisiteVerifierPort {
   constructor(
-    private readonly config: { hostname: string; minimum: tools.Duration },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 

package/src/prerequisite-verifier-timezone-utc.adapter.ts

@@ -8,8 +8,10 @@ import {
 
 export const TimezoneUtc = z.literal("UTC");
 
+type Config = { timezone: tools.TimezoneType };
+
 export class PrerequisiteVerifierTimezoneUtcAdapter implements PrerequisiteVerifierPort {
-  constructor(private readonly config: { timezone: tools.TimezoneType }) {}
+  constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
     const result = TimezoneUtc.safeParse(this.config.timezone);

package/src/prerequisite-verifier-translations.adapter.ts

@@ -16,8 +16,7 @@ type PrerequisiteTranslationsProblemType = {
 };
 
 type Dependencies = { Logger: LoggerPort; FileReaderJson: FileReaderJsonPort };
-
-type Config = { supportedLanguages: types.I18nConfigType["supportedLanguages"] };
+type Config = { supportedLanguages: types.I18nConfig["supportedLanguages"] };
 
 export class PrerequisiteVerifierTranslationsAdapter implements PrerequisiteVerifierPort {
   constructor(

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

@@ -1,23 +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 { HashContentStrategy } from "./hash-content.strategy";
 import type { PrerequisiteVerificationResult, PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+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: PrerequisiteVerifierPort };
 
 export class PrerequisiteVerifierWithCacheAdapter implements PrerequisiteVerifierPort {
   constructor(
-    private readonly config: { id: string; inner: PrerequisiteVerifierPort },
+    private readonly config: Config,
     private readonly deps: Dependencies,
   ) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
-    const resolver = new CacheSubjectApplicationResolver(
+    const resolver = new SubjectApplicationResolver(
       [
-        new CacheSubjectSegmentFixedStrategy("prerequisite_verifier"),
-        new CacheSubjectSegmentFixedStrategy(this.kind),
-        new CacheSubjectSegmentFixedStrategy(this.config.id),
+        new SubjectSegmentFixedStrategy("prerequisite_verifier"),
+        new SubjectSegmentFixedStrategy(this.kind),
+        new SubjectSegmentFixedStrategy(this.config.id),
       ],
       this.deps,
     );

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);