@bgord/bun 1.21.12 → 1.22.0

package/src/job-queue-with-logger.adapter.ts

@@ -1,12 +1,18 @@
 import type * as tools from "@bgord/tools";
+import type { ClockPort } from "./clock.port";
 import { CorrelationStorage } from "./correlation-storage.service";
 import type { GenericJob } from "./job.types";
 import type { JobQueuePort } from "./job-queue.port";
 import type { JobHandler } from "./job-registry.port";
 import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
 import type { LoggerPort } from "./logger.port";
+import { Stopwatch } from "./stopwatch.service";
 
-type Dependencies<Job extends GenericJob> = { inner: JobQueuePort<Job>; Logger: LoggerPort };
+type Dependencies<Job extends GenericJob> = {
+  inner: JobQueuePort<Job>;
+  Logger: LoggerPort;
+  Clock: ClockPort;
+};
 
 export class JobQueueWithLoggerAdapter<Job extends GenericJob> implements JobQueuePort<Job> {
   private readonly base = { component: "infra", operation: "job_queue" };
@@ -14,49 +20,135 @@ export class JobQueueWithLoggerAdapter<Job extends GenericJob> implements JobQue
   constructor(private readonly deps: Dependencies<Job>) {}
 
   async enqueue<EnqueuedJob extends Job>(job: EnqueuedJob, delay?: tools.Duration): Promise<EnqueuedJob> {
-    this.deps.Logger.info({
-      message: `${job.name} enqueued`,
-      metadata: job,
-      correlationId: CorrelationStorage.get(),
-      ...this.base,
-    });
-
-    return this.deps.inner.enqueue(job, delay);
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Job queue enqueue attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata: { job, delay },
+        ...this.base,
+      });
+
+      const result = await this.deps.inner.enqueue(job, delay);
+
+      this.deps.Logger.info({
+        message: "Job queue enqueue success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { job, delay, duration: duration.stop() },
+        ...this.base,
+      });
+
+      return result;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Job queue enqueue error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { job, delay, duration: duration.stop() },
+        ...this.base,
+      });
+
+      throw error;
+    }
   }
 
   async claim(limit: tools.IntegerPositiveType): Promise<ReadonlyArray<Job>> {
-    const jobs = await this.deps.inner.claim(limit);
-
-    this.deps.Logger.info({
-      message: `Claimed ${jobs.length} job(s)`,
-      metadata: { count: jobs.length, limit, jobs },
-      correlationId: CorrelationStorage.get(),
-      ...this.base,
-    });
-
-    return jobs;
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Job queue claim attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata: { limit },
+        ...this.base,
+      });
+
+      const jobs = await this.deps.inner.claim(limit);
+
+      this.deps.Logger.info({
+        message: "Job queue claim success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { limit, count: jobs.length, jobs, duration: duration.stop() },
+        ...this.base,
+      });
+
+      return jobs;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Job queue claim error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { limit, duration: duration.stop() },
+        ...this.base,
+      });
+
+      throw error;
+    }
   }
 
   async complete(id: GenericJob["id"]): Promise<void> {
-    this.deps.Logger.info({
-      message: "Job completed",
-      metadata: { id },
-      correlationId: CorrelationStorage.get(),
-      ...this.base,
-    });
-
-    return this.deps.inner.complete(id);
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Job queue complete attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata: { id },
+        ...this.base,
+      });
+
+      await this.deps.inner.complete(id);
+
+      this.deps.Logger.info({
+        message: "Job queue complete success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { id, duration: duration.stop() },
+        ...this.base,
+      });
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Job queue complete error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { id, duration: duration.stop() },
+        ...this.base,
+      });
+
+      throw error;
+    }
   }
 
   async fail(id: GenericJob["id"]): Promise<void> {
-    this.deps.Logger.warn({
-      message: "Job failed",
-      metadata: { id },
-      correlationId: CorrelationStorage.get(),
-      ...this.base,
-    });
-
-    return this.deps.inner.fail(id);
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.warn({
+        message: "Job queue fail attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata: { id },
+        ...this.base,
+      });
+
+      await this.deps.inner.fail(id);
+
+      this.deps.Logger.warn({
+        message: "Job queue fail success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { id, duration: duration.stop() },
+        ...this.base,
+      });
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Job queue fail error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { id, duration: duration.stop() },
+        ...this.base,
+      });
+
+      throw error;
+    }
   }
 
   async requeue(
@@ -64,14 +156,35 @@ export class JobQueueWithLoggerAdapter<Job extends GenericJob> implements JobQue
     revision: GenericJob["revision"],
     delay: tools.Duration,
   ): Promise<void> {
-    this.deps.Logger.warn({
-      message: "Job requeued",
-      metadata: { id, revision, delay },
-      correlationId: CorrelationStorage.get(),
-      ...this.base,
-    });
-
-    return this.deps.inner.requeue(id, revision, delay);
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.warn({
+        message: "Job queue requeue attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata: { id, revision, delay },
+        ...this.base,
+      });
+
+      await this.deps.inner.requeue(id, revision, delay);
+
+      this.deps.Logger.warn({
+        message: "Job queue requeue success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { id, revision, delay, duration: duration.stop() },
+        ...this.base,
+      });
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Job queue requeue error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { id, revision, delay, duration: duration.stop() },
+        ...this.base,
+      });
+
+      throw error;
+    }
   }
 
   getRetryPolicy(name: GenericJob["name"]): JobRetryPolicyStrategy {

package/src/logger.port.ts

@@ -35,7 +35,6 @@ export type LogHttpType = LogCoreType & {
   status?: number;
   ms?: tools.DurationMsType;
   client: HttpClientInfo;
-  cacheHit?: boolean;
 };
 
 export type LogErrorType = LogCoreType & { level: LogLevelEnum.error; error?: unknown };

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

@@ -1,24 +1,51 @@
+import type { ClockPort } from "./clock.port";
 import { CorrelationStorage } from "./correlation-storage.service";
 import type { LoggerPort } from "./logger.port";
 import type { Message, ToMessageMap } from "./message.types";
 import type { MessageBusPort } from "./message-bus.port";
+import { Stopwatch } from "./stopwatch.service";
 
-type Dependencies<Messages extends Message> = { inner: MessageBusPort<Messages>; Logger: LoggerPort };
+type Dependencies<Messages extends Message> = {
+  inner: MessageBusPort<Messages>;
+  Logger: LoggerPort;
+  Clock: ClockPort;
+};
 
 export class MessageBusWithLoggerAdapter<Messages extends Message> implements MessageBusPort<Messages> {
-  private readonly base = { component: "infra", operation: "message_bus_emit" };
+  private readonly base = { component: "infra", operation: "message_bus" };
 
   constructor(private readonly deps: Dependencies<Messages>) {}
 
   async emit<M extends Messages>(message: M): Promise<void> {
-    this.deps.Logger.info({
-      message: `${message.name} emitted`,
-      metadata: message,
-      correlationId: CorrelationStorage.get(),
-      ...this.base,
-    });
-
-    return this.deps.inner.emit(message);
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Message bus emit attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata: { message },
+        ...this.base,
+      });
+
+      await this.deps.inner.emit(message);
+
+      this.deps.Logger.info({
+        message: "Message bus emit success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { message, duration: duration.stop() },
+        ...this.base,
+      });
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Message bus emit error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { message, duration: duration.stop() },
+        ...this.base,
+      });
+
+      throw error;
+    }
   }
 
   on<MessageName extends keyof ToMessageMap<Messages>>(

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

@@ -1,3 +1,4 @@
+import { CacheCodecIdentityStrategy } from "./cache-codec-identity.strategy";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
 import type { HashContentStrategy } from "./hash-content.strategy";
 import type { PrerequisiteVerificationResult, PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
@@ -8,13 +9,14 @@ type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashCon
 type Config = { id: string; inner: PrerequisiteVerifierPort };
 
 export class PrerequisiteVerifierWithCacheAdapter implements PrerequisiteVerifierPort {
+  private readonly codec = new CacheCodecIdentityStrategy<PrerequisiteVerificationResult>();
+  private readonly resolver: SubjectApplicationResolver;
+
   constructor(
     private readonly config: Config,
     private readonly deps: Dependencies,
-  ) {}
-
-  async verify(): Promise<PrerequisiteVerificationResult> {
-    const resolver = new SubjectApplicationResolver(
+  ) {
+    this.resolver = new SubjectApplicationResolver(
       [
         new SubjectSegmentFixedStrategy("prerequisite_verifier"),
         new SubjectSegmentFixedStrategy(this.kind),
@@ -22,11 +24,15 @@ export class PrerequisiteVerifierWithCacheAdapter implements PrerequisiteVerifie
       ],
       this.deps,
     );
+  }
 
-    const subject = await resolver.resolve();
+  async verify(): Promise<PrerequisiteVerificationResult> {
+    const subject = await this.resolver.resolve();
 
-    return this.deps.CacheResolver.resolve<PrerequisiteVerificationResult>(subject.hex, () =>
-      this.config.inner.verify(),
+    return this.deps.CacheResolver.resolve<PrerequisiteVerificationResult>(
+      subject.hex,
+      async () => this.config.inner.verify(),
+      this.codec,
     );
   }
 

package/src/rate-limiter.service.ts

@@ -0,0 +1,45 @@
+import * as tools from "@bgord/tools";
+
+type RateLimiterResultSuccessType = { allowed: true };
+type RateLimiterResultErrorType = { allowed: false; remaining: tools.Duration };
+type RateLimiterResultType = RateLimiterResultSuccessType | RateLimiterResultErrorType;
+
+export type RateLimiterStateType = { lastInvocation: tools.TimestampValueType | null };
+
+export class RateLimiter {
+  private lastInvocation: tools.Timestamp | null = null;
+
+  constructor(private readonly duration: tools.Duration) {}
+
+  static fromState(duration: tools.Duration, state: RateLimiterStateType): RateLimiter {
+    const limiter = new RateLimiter(duration);
+
+    if (state.lastInvocation !== null) {
+      limiter.lastInvocation = tools.Timestamp.fromNumber(state.lastInvocation);
+    }
+
+    return limiter;
+  }
+
+  verify(now: tools.Timestamp): RateLimiterResultType {
+    if (this.lastInvocation === null) {
+      this.lastInvocation = now;
+
+      return { allowed: true };
+    }
+
+    const nextAllowedTimestamp = this.lastInvocation.add(this.duration);
+
+    if (nextAllowedTimestamp.isBeforeOrEqual(now)) {
+      this.lastInvocation = now;
+
+      return { allowed: true };
+    }
+
+    return { allowed: false, remaining: nextAllowedTimestamp.difference(now) };
+  }
+
+  toJSON(): RateLimiterStateType {
+    return { lastInvocation: this.lastInvocation === null ? null : this.lastInvocation.toJSON() };
+  }
+}

package/src/reactive-config-with-cache.adapter.ts

@@ -1,10 +1,16 @@
+import { CacheCodecIdentityStrategy } from "./cache-codec-identity.strategy";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import type { CacheValueType } from "./cache-value.vo";
 import type { HashContentStrategy } from "./hash-content.strategy";
 import type { ReactiveConfigPort } from "./reactive-config.port";
 
 type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
 
-export class ReactiveConfigWithCacheAdapter<T extends object> implements ReactiveConfigPort<T> {
+export class ReactiveConfigWithCacheAdapter<T extends object & CacheValueType>
+  implements ReactiveConfigPort<T>
+{
+  private readonly codec = new CacheCodecIdentityStrategy<T>();
+
   constructor(
     private readonly inner: ReactiveConfigPort<T>,
     private readonly subject: string,
@@ -14,6 +20,6 @@ export class ReactiveConfigWithCacheAdapter<T extends object> implements Reactiv
   async get(): Promise<Readonly<T>> {
     const key = await this.deps.HashContent.hash(this.subject);
 
-    return Object.freeze(await this.deps.CacheResolver.resolve(key, () => this.inner.get()));
+    return Object.freeze(await this.deps.CacheResolver.resolve<T>(key, () => this.inner.get(), this.codec));
   }
 }

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

@@ -27,7 +27,11 @@ export class RequestContextHonoAdapter implements RequestContext {
       cookie: (name) => getCookie(context)[name],
       json: async () => {
         try {
-          return await context.req.raw.clone().json();
+          const body = await context.req.raw.clone().json();
+
+          if (body === null || typeof body !== "object") return {};
+
+          return body;
         } catch {
           return {};
         }

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

@@ -32,14 +32,13 @@ export class SecurityRuleViolationThresholdStrategy implements SecurityRuleStrat
     if (!violated) return false;
 
     try {
-      const count = (await this.deps.CacheRepository.get<tools.IntegerNonNegativeType>(subject.hex)) ?? 0;
+      const cached = await this.deps.CacheRepository.get(subject.hex);
+      const count = typeof cached === "number" ? cached : 0;
+      const next = tools.Int.nonNegative(count + 1);
 
-      await this.deps.CacheRepository.set<tools.IntegerNonNegativeType>(
-        subject.hex,
-        tools.Int.nonNegative(count + 1),
-      );
+      await this.deps.CacheRepository.set(subject.hex, next);
 
-      if (count + 1 >= this.config.threshold) return true;
+      if (next >= this.config.threshold) return true;
       return false;
     } catch {
       return false;

package/src/shield-rate-limit-hono.strategy.ts

@@ -1,6 +1,6 @@
 import type { MiddlewareHandler } from "hono";
 import { HTTPException } from "hono/http-exception";
-import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import type { CacheRepositoryPort } from "./cache-repository.port";
 import type { ClockPort } from "./clock.port";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
@@ -10,7 +10,7 @@ import {
   ShieldRateLimitStrategyError,
 } from "./shield-rate-limit.strategy";
 
-type Dependencies = { Clock: ClockPort; CacheResolver: CacheResolverStrategy };
+type Dependencies = { Clock: ClockPort; CacheRepository: CacheRepositoryPort };
 
 export class ShieldRateLimitHonoStrategy implements MiddlewareHonoPort {
   private readonly strategy: ShieldRateLimitStrategy;

package/src/shield-rate-limit.strategy.ts

@@ -1,13 +1,14 @@
 import * as tools from "@bgord/tools";
-import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import type { CacheRepositoryPort } from "./cache-repository.port";
 import type { ClockPort } from "./clock.port";
+import { RateLimiter, type RateLimiterStateType } from "./rate-limiter.service";
 import type { RequestContext } from "./request-context.port";
 import type { SubjectRequestResolver } from "./subject-request-resolver.vo";
 
 export type ShieldRateLimitConfig = { resolver: SubjectRequestResolver; interval: tools.Duration };
 type ShieldRateLimitResult = { allowed: true } | { allowed: false; retryAfter: tools.Duration };
 
-type Dependencies = { Clock: ClockPort; CacheResolver: CacheResolverStrategy };
+type Dependencies = { Clock: ClockPort; CacheRepository: CacheRepositoryPort };
 
 export const ShieldRateLimitStrategyError = { Rejected: "shield.rate.limit.rejected" };
 
@@ -22,14 +23,20 @@ export class ShieldRateLimitStrategy {
   async evaluate(context: RequestContext): Promise<ShieldRateLimitResult> {
     const subject = await this.config.resolver.resolve(context);
 
-    const limiter = await this.deps.CacheResolver.resolve(
-      subject.hex,
-      async () => new tools.RateLimiter(this.config.interval),
-    );
+    const state = await this.deps.CacheRepository.get(subject.hex);
+
+    const limiter =
+      state === null
+        ? new RateLimiter(this.config.interval)
+        : RateLimiter.fromState(this.config.interval, state as RateLimiterStateType);
 
     const decision = limiter.verify(this.deps.Clock.now());
 
-    if (decision.allowed) return { allowed: true };
+    if (decision.allowed) {
+      await this.deps.CacheRepository.set(subject.hex, limiter.toJSON());
+
+      return { allowed: true };
+    }
 
     return {
       allowed: false,

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

@@ -5,21 +5,29 @@ import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
 import {
   ShieldWebhookStrategy,
   type ShieldWebhookStrategyConfig,
+  type ShieldWebhookStrategyDependencies,
   ShieldWebhookStrategyError,
 } from "./shield-webhook.strategy";
 
 export class ShieldWebhookHonoStrategy implements MiddlewareHonoPort {
   private readonly strategy: ShieldWebhookStrategy;
 
-  constructor(config: ShieldWebhookStrategyConfig) {
-    this.strategy = new ShieldWebhookStrategy(config);
+  constructor(config: ShieldWebhookStrategyConfig, deps: ShieldWebhookStrategyDependencies) {
+    this.strategy = new ShieldWebhookStrategy(config, deps);
   }
 
   handle(): MiddlewareHandler {
     return async (c, next) => {
       const context = new RequestContextHonoAdapter(c);
 
-      if (await this.strategy.evaluate(context)) return next();
+      const result = await this.strategy.evaluate(context);
+
+      if (result.accepted) return next();
+
+      if (result.reason === "duplicate") {
+        return c.json({ message: ShieldWebhookStrategyError.Duplicate }, 200);
+      }
+
       throw new HTTPException(401, { message: ShieldWebhookStrategyError.Rejected });
     };
   }

package/src/shield-webhook.strategy.ts

@@ -1,26 +1,61 @@
-import type { HasRequestHeader, HasRequestText } from "./request-context.port";
+import type { HashContentStrategy } from "./hash-content.strategy";
+import type { IdempotencyStorePort } from "./idempotency-store.port";
+import type { HasRequestHeader, HasRequestJson, HasRequestText } from "./request-context.port";
 import type { WebhookBodyBuilderStrategy } from "./webhook-body-builder.strategy";
+import type { WebhookIdExtractorStrategy } from "./webhook-id-extractor.strategy";
 import type { WebhookSignatureExtractorStrategy } from "./webhook-signature-extractor.strategy";
 import type { WebhookVerifierStrategy } from "./webhook-verifier.strategy";
 
-export const ShieldWebhookStrategyError = { Rejected: "shield.webhook.rejected" };
+export const ShieldWebhookStrategyError = {
+  Rejected: "shield.webhook.rejected",
+  Duplicate: "shield.webhook.duplicate",
+};
+
+export type ShieldWebhookStrategyResult =
+  | { accepted: true }
+  | { accepted: false; reason: "rejected" }
+  | { accepted: false; reason: "duplicate" };
 
 export type ShieldWebhookStrategyConfig = {
+  namespace: string;
   WebhookBodyBuilder: WebhookBodyBuilderStrategy;
+  WebhookIdExtractor: WebhookIdExtractorStrategy;
   WebhookSignatureExtractor: WebhookSignatureExtractorStrategy;
   WebhookVerifier: WebhookVerifierStrategy;
 };
 
+export type ShieldWebhookStrategyDependencies = {
+  HashContent: HashContentStrategy;
+  IdempotencyStore: IdempotencyStorePort;
+};
+
 export class ShieldWebhookStrategy {
-  constructor(private readonly config: ShieldWebhookStrategyConfig) {}
+  constructor(
+    private readonly config: ShieldWebhookStrategyConfig,
+    private readonly deps: ShieldWebhookStrategyDependencies,
+  ) {}
 
-  async evaluate(context: HasRequestHeader & HasRequestText): Promise<boolean> {
+  async evaluate(
+    context: HasRequestHeader & HasRequestJson & HasRequestText,
+  ): Promise<ShieldWebhookStrategyResult> {
     const signature = this.config.WebhookSignatureExtractor.extract(context);
 
-    if (!signature) return false;
+    if (!signature) return { accepted: false, reason: "rejected" };
 
     const body = await this.config.WebhookBodyBuilder.build(context);
 
-    return this.config.WebhookVerifier.verify(body, signature);
+    if (!this.config.WebhookVerifier.verify(body, signature)) return { accepted: false, reason: "rejected" };
+
+    const id = await this.config.WebhookIdExtractor.extract(context);
+
+    if (!id) return { accepted: false, reason: "rejected" };
+
+    const subject = await this.deps.HashContent.hash(JSON.stringify([[this.config.namespace, id]]));
+
+    const claimed = await this.deps.IdempotencyStore.claim(subject);
+
+    if (!claimed) return { accepted: false, reason: "duplicate" };
+
+    return { accepted: true };
   }
 }

package/src/sitemap-entries-provider-with-cache.adapter.ts

@@ -1,3 +1,4 @@
+import { CacheCodecSitemapEntriesStrategy } from "./cache-codec-sitemap-entries.strategy";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
 import type { HashContentStrategy } from "./hash-content.strategy";
 import type { SitemapEntriesProvider } from "./sitemap-entries-provider.port";
@@ -9,24 +10,29 @@ type Config = { id: string; inner: SitemapEntriesProvider };
 type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
 
 export class SitemapEntriesProviderWithCacheAdapter implements SitemapEntriesProvider {
+  private readonly codec = new CacheCodecSitemapEntriesStrategy();
+  private readonly resolver: SubjectApplicationResolver;
+
   constructor(
     private readonly config: Config,
     private readonly deps: Dependencies,
-  ) {}
-
-  async produce(): Promise<ReadonlyArray<SitemapEntry>> {
-    const resolver = new SubjectApplicationResolver(
+  ) {
+    this.resolver = new SubjectApplicationResolver(
       [
         new SubjectSegmentFixedStrategy("sitemap_entries_provider"),
         new SubjectSegmentFixedStrategy(this.config.id),
       ],
       this.deps,
     );
+  }
 
-    const subject = await resolver.resolve();
+  async produce(): Promise<ReadonlyArray<SitemapEntry>> {
+    const subject = await this.resolver.resolve();
 
-    return this.deps.CacheResolver.resolve<ReadonlyArray<SitemapEntry>>(subject.hex, () =>
-      this.config.inner.produce(),
+    return this.deps.CacheResolver.resolve<ReadonlyArray<SitemapEntry>>(
+      subject.hex,
+      async () => this.config.inner.produce(),
+      this.codec,
     );
   }
 }