@bgord/bun 1.21.11 → 1.22.0

package/src/cron-scheduler-with-logger.adapter.ts

@@ -1,21 +1,47 @@
+import type { ClockPort } from "./clock.port";
+import { CorrelationStorage } from "./correlation-storage.service";
 import type { CronSchedulerPort } from "./cron-scheduler.port";
 import type { CronTask } from "./cron-task.vo";
 import type { LoggerPort } from "./logger.port";
+import { Stopwatch } from "./stopwatch.service";
 
-type Dependencies = { inner: CronSchedulerPort; Logger: LoggerPort };
+type Dependencies = { inner: CronSchedulerPort; Logger: LoggerPort; Clock: ClockPort };
 
 export class CronSchedulerWithLoggerAdapter implements CronSchedulerPort {
+  private readonly base = { component: "infra", operation: "cron_scheduler" };
+
   constructor(private readonly deps: Dependencies) {}
 
   schedule(task: CronTask): void {
-    this.deps.Logger.info({
-      message: "Cron scheduler schedule",
-      component: "infra",
-      operation: "cron_scheduler_schedule",
-      metadata: { label: task.label, cron: task.cron },
-    });
-
-    this.deps.inner.schedule(task);
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Cron scheduler schedule attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata: { label: task.label, cron: task.cron },
+        ...this.base,
+      });
+
+      this.deps.inner.schedule(task);
+
+      this.deps.Logger.info({
+        message: "Cron scheduler schedule success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { label: task.label, cron: task.cron, duration: duration.stop() },
+        ...this.base,
+      });
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Cron scheduler schedule error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { label: task.label, cron: task.cron, duration: duration.stop() },
+        ...this.base,
+      });
+
+      throw error;
+    }
   }
 
   async verify(): Promise<boolean> {

package/src/cron-task-handler-with-logger.strategy.ts

@@ -35,7 +35,7 @@ export class CronTaskHandlerWithLoggerStrategy implements CronTaskHandlerStrateg
             ...this.base,
           });
 
-          return;
+          throw error;
         }
 
         this.deps.Logger.info({

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

@@ -0,0 +1,21 @@
+import type { CryptoKeyProviderPort } from "./crypto-key-provider.port";
+
+type Config = { inner: CryptoKeyProviderPort };
+
+export class CryptoKeyProviderWithMemoAdapter implements CryptoKeyProviderPort {
+  private memoized: Promise<CryptoKey> | null = null;
+
+  constructor(private readonly config: Config) {}
+
+  async get(): Promise<CryptoKey> {
+    if (this.memoized === null) {
+      this.memoized = this.config.inner.get().catch((error) => {
+        this.memoized = null;
+
+        throw error;
+      });
+    }
+
+    return this.memoized;
+  }
+}

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

@@ -1,4 +1,6 @@
+import { CacheCodecIdentityStrategy } from "./cache-codec-identity.strategy";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import type { CacheValueType } from "./cache-value.vo";
 import type {
   EnvironmentLoaderConfig,
   EnvironmentLoaderPort,
@@ -11,7 +13,11 @@ import { SubjectSegmentFixedStrategy } from "./subject-segment-fixed.strategy";
 
 type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
 
-export class EnvironmentLoaderProcessSafeAdapter<T extends object> implements EnvironmentLoaderPort<T> {
+export class EnvironmentLoaderProcessSafeAdapter<T extends object & CacheValueType>
+  implements EnvironmentLoaderPort<T>
+{
+  private readonly codec = new CacheCodecIdentityStrategy<T>();
+
   constructor(
     private env: NodeJS.ProcessEnv,
     private readonly config: EnvironmentLoaderConfig<T>,
@@ -22,8 +28,10 @@ export class EnvironmentLoaderProcessSafeAdapter<T extends object> implements En
     const resolver = new SubjectApplicationResolver([new SubjectSegmentFixedStrategy("env")], this.deps);
     const subject = await resolver.resolve();
 
-    const parsed = await this.deps.CacheResolver.resolve(subject.hex, async () =>
-      StandardSchemaValidator.validate(this.config.EnvironmentSchema, this.env),
+    const parsed = await this.deps.CacheResolver.resolve<T>(
+      subject.hex,
+      async () => StandardSchemaValidator.validate(this.config.EnvironmentSchema, this.env),
+      this.codec,
     );
 
     for (const key of Object.keys(parsed)) {
@@ -31,6 +39,6 @@ export class EnvironmentLoaderProcessSafeAdapter<T extends object> implements En
       delete process.env[key];
     }
 
-    return Object.freeze({ ...parsed, type: this.config.type });
+    return Object.freeze(Object.assign({}, parsed, { type: this.config.type }));
   }
 }

package/src/event-store-with-logger.adapter.ts

@@ -1,16 +1,21 @@
+import type { ClockPort } from "./clock.port";
 import { CorrelationStorage } from "./correlation-storage.service";
 import type { GenericEvent } from "./event.types";
 import type { EventFinderConfig, EventStorePort } from "./event-store.port";
 import type { EventStreamType } from "./event-stream.vo";
 import type { EventValidatorRegistryPort } from "./event-validator-registry.port";
 import type { LoggerPort } from "./logger.port";
+import { Stopwatch } from "./stopwatch.service";
 
 type Dependencies<Event extends GenericEvent> = {
   inner: EventStorePort<Event>;
   Logger: LoggerPort;
+  Clock: ClockPort;
 };
 
 export class EventStoreWithLoggerAdapter<Event extends GenericEvent> implements EventStorePort<Event> {
+  private readonly base = { component: "infra", operation: "event_store" };
+
   constructor(private readonly deps: Dependencies<Event>) {}
 
   async find<FoundEvent extends Event>(
@@ -18,49 +23,114 @@ export class EventStoreWithLoggerAdapter<Event extends GenericEvent> implements
     stream: EventStreamType,
     config?: EventFinderConfig,
   ): Promise<ReadonlyArray<FoundEvent>> {
-    const result = await this.deps.inner.find(registry, stream, config);
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Event store find attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata: { stream, names: registry.names, config },
+        ...this.base,
+      });
+
+      const result = await this.deps.inner.find(registry, stream, config);
 
-    this.deps.Logger.info({
-      message: "Event store find",
-      component: "infra",
-      operation: "event_store_find",
-      correlationId: CorrelationStorage.get(),
-      metadata: { stream, names: registry.names, config, count: result.length },
-    });
+      this.deps.Logger.info({
+        message: "Event store find success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { stream, names: registry.names, config, count: result.length, duration: duration.stop() },
+        ...this.base,
+      });
 
-    return result;
+      return result;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Event store find error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { stream, names: registry.names, config, duration: duration.stop() },
+        ...this.base,
+      });
+
+      throw error;
+    }
   }
 
   async findLast<FoundEvent extends Event>(
     registry: EventValidatorRegistryPort<FoundEvent>,
     stream: EventStreamType,
   ): Promise<FoundEvent | null> {
-    const result = await this.deps.inner.findLast(registry, stream);
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Event store find last attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata: { stream, names: registry.names },
+        ...this.base,
+      });
 
-    this.deps.Logger.info({
-      message: "Event store find last",
-      component: "infra",
-      operation: "event_store_find_last",
-      correlationId: CorrelationStorage.get(),
-      metadata: { stream, names: registry.names, found: !!result },
-    });
+      const result = await this.deps.inner.findLast(registry, stream);
 
-    return result;
+      this.deps.Logger.info({
+        message: "Event store find last success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { stream, names: registry.names, found: !!result, duration: duration.stop() },
+        ...this.base,
+      });
+
+      return result;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Event store find last error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { stream, names: registry.names, duration: duration.stop() },
+        ...this.base,
+      });
+
+      throw error;
+    }
   }
 
   async save<SavedEvent extends Event>(
     events: ReadonlyArray<SavedEvent>,
   ): Promise<ReadonlyArray<SavedEvent>> {
-    const result = await this.deps.inner.save(events);
+    const duration = new Stopwatch(this.deps);
+    const metadata = {
+      stream: events[0]?.stream,
+      names: events.map((event) => event.name),
+      count: events.length,
+    };
+
+    try {
+      this.deps.Logger.info({
+        message: "Event store save attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata,
+        ...this.base,
+      });
+
+      const result = await this.deps.inner.save(events);
+
+      this.deps.Logger.info({
+        message: "Event store save success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { ...metadata, duration: duration.stop() },
+        ...this.base,
+      });
 
-    this.deps.Logger.info({
-      message: "Event store save",
-      component: "infra",
-      operation: "event_store_save",
-      correlationId: CorrelationStorage.get(),
-      metadata: { stream: events[0]?.stream, names: events.map((event) => event.name), count: events.length },
-    });
+      return result;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Event store save error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { ...metadata, duration: duration.stop() },
+        ...this.base,
+      });
 
-    return result;
+      throw error;
+    }
   }
 }

package/src/event-stream.vo.ts

@@ -10,6 +10,7 @@ export const EventStream = v.pipe(
   v.string(EventStreamError.Type),
   v.minLength(1, EventStreamError.Empty),
   v.maxLength(256, EventStreamError.TooLong),
+  // Stryker disable next-line StringLiteral
   v.brand("EventStream"),
 );
 

package/src/file-draft-tar-gz.service.ts

@@ -0,0 +1,23 @@
+// [BUN DEPENDENCY]
+import * as tools from "@bgord/tools";
+import * as v from "valibot";
+import { FileDraft } from "./file-draft.service";
+
+export class FileDraftTarGz extends FileDraft {
+  constructor(
+    basename: tools.BasenameType,
+    private readonly parts: ReadonlyArray<FileDraft>,
+  ) {
+    super(basename, v.parse(tools.Extension, tools.Mimes.tar.extensions[0]), tools.Mimes.tar.mime);
+  }
+
+  async create(): Promise<BodyInit> {
+    const parts: Record<string, Uint8Array> = {};
+
+    for (const part of this.parts) {
+      parts[part.filename.get()] = await new Response(await part.create()).bytes();
+    }
+
+    return new Bun.Archive(parts, { compress: "gzip" }).blob();
+  }
+}

package/src/file-reader-json-with-cache.adapter.ts

@@ -1,4 +1,5 @@
 import type * as tools from "@bgord/tools";
+import { CacheCodecIdentityStrategy } from "./cache-codec-identity.strategy";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
 import type { FileReaderJsonOutputType, FileReaderJsonPort } from "./file-reader-json.port";
 import type { HashContentStrategy } from "./hash-content.strategy";
@@ -9,6 +10,8 @@ type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashCon
 type Config = { id: string; inner: FileReaderJsonPort };
 
 export class FileReaderJsonWithCacheAdapter implements FileReaderJsonPort {
+  private readonly codec = new CacheCodecIdentityStrategy<FileReaderJsonOutputType>();
+
   constructor(
     private readonly config: Config,
     private readonly deps: Dependencies,
@@ -28,8 +31,10 @@ export class FileReaderJsonWithCacheAdapter implements FileReaderJsonPort {
 
     const subject = await resolver.resolve();
 
-    return this.deps.CacheResolver.resolve<FileReaderJsonOutputType>(subject.hex, () =>
-      this.config.inner.read(path),
+    return this.deps.CacheResolver.resolve<FileReaderJsonOutputType>(
+      subject.hex,
+      async () => this.config.inner.read(path),
+      this.codec,
     );
   }
 }

package/src/file-reader-text-with-cache.adapter.ts

@@ -1,4 +1,5 @@
 import type * as tools from "@bgord/tools";
+import { CacheCodecIdentityStrategy } from "./cache-codec-identity.strategy";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
 import type { FileReaderTextPort } from "./file-reader-text.port";
 import type { HashContentStrategy } from "./hash-content.strategy";
@@ -9,6 +10,8 @@ type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashCon
 type Config = { id: string; inner: FileReaderTextPort };
 
 export class FileReaderTextWithCacheAdapter implements FileReaderTextPort {
+  private readonly codec = new CacheCodecIdentityStrategy<string>();
+
   constructor(
     private readonly config: Config,
     private readonly deps: Dependencies,
@@ -26,6 +29,10 @@ export class FileReaderTextWithCacheAdapter implements FileReaderTextPort {
 
     const subject = await resolver.resolve();
 
-    return this.deps.CacheResolver.resolve<string>(subject.hex, () => this.config.inner.read(path));
+    return this.deps.CacheResolver.resolve<string>(
+      subject.hex,
+      async () => this.config.inner.read(path),
+      this.codec,
+    );
   }
 }

package/src/healthcheck-hono.handler.ts

@@ -17,9 +17,9 @@ export class HealthcheckHonoHandler implements HandlerHonoPort {
 
   handle() {
     return factory.createHandlers(async () => {
-      const healthcheck = await this.handler.check();
+      const { headers, ...healthcheck } = await this.handler.check();
 
-      return Response.json(healthcheck, { status: healthcheck.code });
+      return Response.json(healthcheck, { status: healthcheck.code, headers });
     });
   }
 }

package/src/healthcheck.handler.ts

@@ -87,6 +87,7 @@ export type HealthcheckResult = {
   queue?: JobQueueStatsSnapshot;
   ms: tools.Duration["ms"];
   timestamp: tools.TimestampValueType;
+  headers: Record<string, string>;
 };
 
 export class HealthcheckHandler {
@@ -175,6 +176,7 @@ export class HealthcheckHandler {
       queue: await this.deps.JobQueueStatsProvider?.getStats(),
       ms: stopwatch.stop().ms,
       timestamp: this.deps.Clock.now().ms,
+      headers: { "Cache-Control": "no-store" },
     };
   }
 }

package/src/http-logger-hono.middleware.ts

@@ -1,6 +1,4 @@
 import type { MiddlewareHandler } from "hono";
-import { CacheSourceEnum } from "./cache-resolver.strategy";
-import { CacheResponseMiddleware } from "./cache-response.middleware";
 import {
   type HttpLoggerConfig,
   HttpLoggerMiddleware,
@@ -36,7 +34,6 @@ export class HttpLoggerHonoMiddleware implements MiddlewareHonoPort {
       this.middleware.after(context, correlationId, {
         stopwatch,
         status: response.status,
-        cacheHit: response.headers.get(CacheResponseMiddleware.CACHE_HIT_HEADER) === CacheSourceEnum.hit,
         responseBody,
       });
     };

package/src/http-logger.middleware.ts

@@ -34,7 +34,6 @@ export type HttpLoggerBeforeResult = { stopwatch: Stopwatch };
 export type HttpLoggerAfterInput = {
   stopwatch: Stopwatch;
   status: number;
-  cacheHit: boolean;
   responseBody: any;
 };
 
@@ -98,7 +97,6 @@ export class HttpLoggerMiddleware {
       status: input.status,
       ms: duration.ms,
       client,
-      cacheHit: input.cacheHit,
       metadata: { response: input.responseBody },
     });
   }

package/src/idempotency-store-cache.adapter.ts

@@ -0,0 +1,19 @@
+import type { CacheRepositoryPort } from "./cache-repository.port";
+import type { Hash } from "./hash.vo";
+import type { IdempotencyStorePort } from "./idempotency-store.port";
+
+type Dependencies = { CacheRepository: CacheRepositoryPort };
+
+export class IdempotencyStoreCacheAdapter implements IdempotencyStorePort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async claim(subject: Hash): Promise<boolean> {
+    const processed = await this.deps.CacheRepository.get(subject);
+
+    if (processed !== null) return false;
+
+    await this.deps.CacheRepository.set(subject, true);
+
+    return true;
+  }
+}

package/src/idempotency-store-noop.adapter.ts

@@ -0,0 +1,8 @@
+import type { Hash } from "./hash.vo";
+import type { IdempotencyStorePort } from "./idempotency-store.port";
+
+export class IdempotencyStoreNoopAdapter implements IdempotencyStorePort {
+  async claim(_subject: Hash): Promise<boolean> {
+    return true;
+  }
+}

package/src/idempotency-store-with-logger.adapter.ts

@@ -0,0 +1,59 @@
+import type { ClockPort } from "./clock.port";
+import { CorrelationStorage } from "./correlation-storage.service";
+import type { Hash } from "./hash.vo";
+import type { IdempotencyStorePort } from "./idempotency-store.port";
+import type { LoggerPort } from "./logger.port";
+import { Stopwatch } from "./stopwatch.service";
+
+type Dependencies = { inner: IdempotencyStorePort; Logger: LoggerPort; Clock: ClockPort };
+
+export class IdempotencyStoreWithLoggerAdapter implements IdempotencyStorePort {
+  private readonly base = { component: "infra", operation: "idempotency_store" };
+
+  constructor(private readonly deps: Dependencies) {}
+
+  async claim(subject: Hash): Promise<boolean> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Idempotency store claim attempt",
+        correlationId: CorrelationStorage.get(),
+        metadata: { subject: subject.get() },
+        ...this.base,
+      });
+
+      const claimed = await this.deps.inner.claim(subject);
+
+      if (!claimed) {
+        this.deps.Logger.warn({
+          message: "Idempotency store claim duplicate",
+          correlationId: CorrelationStorage.get(),
+          metadata: { subject: subject.get(), duration: duration.stop() },
+          ...this.base,
+        });
+
+        return false;
+      }
+
+      this.deps.Logger.info({
+        message: "Idempotency store claim success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { subject: subject.get(), duration: duration.stop() },
+        ...this.base,
+      });
+
+      return true;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Idempotency store claim error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { subject: subject.get(), duration: duration.stop() },
+        ...this.base,
+      });
+
+      throw error;
+    }
+  }
+}

package/src/idempotency-store.port.ts

@@ -0,0 +1,5 @@
+import type { Hash } from "./hash.vo";
+
+export interface IdempotencyStorePort {
+  claim(subject: Hash): Promise<boolean>;
+}

package/src/index.ts

@@ -44,15 +44,18 @@ export * from "./better-auth-logger.service";
 export * from "./binary.vo";
 export * from "./bots.vo";
 export * from "./build-info.vo";
+export * from "./cache-codec.strategy";
+export * from "./cache-codec-identity.strategy";
+export * from "./cache-codec-sitemap-entries.strategy";
 export * from "./cache-file.service";
 export * from "./cache-repository.port";
 export * from "./cache-repository-node-cache.adapter";
 export * from "./cache-repository-noop.adapter";
 export * from "./cache-repository-redis.adapter";
 export * from "./cache-resolver.strategy";
-export * from "./cache-resolver-simple.strategy";
-export * from "./cache-response.middleware";
-export * from "./cache-response-hono.middleware";
+export * from "./cache-resolver-noop.strategy";
+export * from "./cache-resolver-read-through.strategy";
+export * from "./cache-value.vo";
 export * from "./certificate-inspector.port";
 export * from "./certificate-inspector-noop.adapter";
 export * from "./certificate-inspector-tls.adapter";
@@ -85,7 +88,7 @@ export * from "./crypto-key-provider.port";
 export * from "./crypto-key-provider-file.adapter";
 export * from "./crypto-key-provider-memory.adapter";
 export * from "./crypto-key-provider-noop.adapter";
-export * from "./crypto-key-provider-with-cache.adapter";
+export * from "./crypto-key-provider-with-memo.adapter";
 export * from "./csv-stringifier.adapter";
 export * from "./csv-stringifier.port";
 export * from "./csv-stringifier-noop.adapter";
@@ -147,7 +150,7 @@ export * from "./file-copier.adapter";
 export * from "./file-copier.port";
 export * from "./file-copier-noop.adapter";
 export * from "./file-draft.service";
-export * from "./file-draft-zip.service";
+export * from "./file-draft-tar-gz.service";
 export * from "./file-inspection.adapter";
 export * from "./file-inspection.port";
 export * from "./file-inspection-noop.adapter";
@@ -206,6 +209,10 @@ export * from "./http-logger-hono.middleware";
 export * from "./id-provider.port";
 export * from "./id-provider-crypto.adapter";
 export * from "./id-provider-deterministic.adapter";
+export * from "./idempotency-store.port";
+export * from "./idempotency-store-cache.adapter";
+export * from "./idempotency-store-noop.adapter";
+export * from "./idempotency-store-with-logger.adapter";
 export * from "./image.types";
 export * from "./image-blur.adapter";
 export * from "./image-blur.port";
@@ -376,6 +383,7 @@ export * from "./randomness.strategy";
 export * from "./randomness-crypto.strategy";
 export * from "./randomness-math.strategy";
 export * from "./randomness-noop.strategy";
+export * from "./rate-limiter.service";
 export * from "./reactive-config.port";
 export * from "./reactive-config-file-json.adapter";
 export * from "./reactive-config-noop.adapter";
@@ -547,6 +555,7 @@ export * from "./translations-hono.handler";
 export * from "./translations-provider.port";
 export * from "./translations-provider-json.adapter";
 export * from "./translations-provider-noop.adapter";
+export * from "./translations-provider-with-cache.adapter";
 export * from "./translator.service";
 export * from "./uptime.service";
 export * from "./uuid.vo";
@@ -560,13 +569,17 @@ export * from "./weak-etag-extractor-hono.middleware";
 export * from "./weak-etag-extractor-param.strategy";
 export * from "./webhook-body-builder.strategy";
 export * from "./webhook-body-builder-text.strategy";
+export * from "./webhook-id.vo";
+export * from "./webhook-id-extractor.strategy";
+export * from "./webhook-id-extractor-header.strategy";
+export * from "./webhook-id-extractor-json-field.strategy";
 export * from "./webhook-secret.vo";
 export * from "./webhook-signature.vo";
 export * from "./webhook-signature-creator.strategy";
 export * from "./webhook-signature-creator-noop.strategy";
 export * from "./webhook-signature-creator-sha256.strategy";
 export * from "./webhook-signature-extractor.strategy";
-export * from "./webhook-signature-extractor-header-exact.strategy";
+export * from "./webhook-signature-extractor-header.strategy";
 export * from "./webhook-verifier.strategy";
 export * from "./webhook-verifier-noop.strategy";
 export * from "./webhook-verifier-sha256.strategy";