@bgord/bun 1.10.22 → 1.11.0

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/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/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();
+    };
+  }
+}

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