@bgord/bun 1.21.12 → 1.22.0

package/src/cache-response-hono.middleware.ts

@@ -1,53 +0,0 @@
-import { createMiddleware } from "hono/factory";
-import type { ContentfulStatusCode } from "hono/utils/http-status";
-import {
-  CacheResponseMiddleware,
-  type CacheResponseMiddlewareConfig,
-  type CacheResponseMiddlewareDependencies,
-} from "./cache-response.middleware";
-import type { MiddlewareHonoPort } from "./middleware-hono.port";
-import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
-
-export class CacheResponseHonoMiddleware implements MiddlewareHonoPort {
-  private readonly middleware: CacheResponseMiddleware;
-
-  constructor(config: CacheResponseMiddlewareConfig, deps: CacheResponseMiddlewareDependencies) {
-    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,47 +0,0 @@
-import type { CacheResolverStrategy, CacheSourceEnum } from "./cache-resolver.strategy";
-import type { RequestContext } from "./request-context.port";
-import type { SubjectRequestResolver } from "./subject-request-resolver.vo";
-
-export type CacheResponseMiddlewareDependencies = { CacheResolver: CacheResolverStrategy };
-
-export type CacheResponseMiddlewareConfig = { enabled: boolean; resolver: SubjectRequestResolver };
-
-export type CachedResponse<T = string> = {
-  body: T;
-  headers: Record<string, string>;
-  status: number;
-};
-
-export type CacheResponseResult<T = string> = {
-  response: CachedResponse<T>;
-  source: CacheSourceEnum;
-};
-
-export class CacheResponseMiddleware {
-  static readonly CACHE_HIT_HEADER = "Cache-Hit";
-
-  constructor(
-    private readonly config: CacheResponseMiddlewareConfig,
-    private readonly deps: CacheResponseMiddlewareDependencies,
-  ) {}
-
-  async evaluate<T = string>(
-    context: RequestContext,
-    generateResponse: () => Promise<CachedResponse<T>>,
-  ): Promise<CacheResponseResult<T> | null> {
-    if (!this.config.enabled) return null;
-
-    const subject = await this.config.resolver.resolve(context);
-
-    const result = await this.deps.CacheResolver.resolveWithContext<CachedResponse<T>>(
-      subject.hex,
-      generateResponse,
-    );
-
-    return { response: result.value, source: result.source };
-  }
-
-  async clear(): Promise<void> {
-    await this.deps.CacheResolver.flush();
-  }
-}

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

@@ -1,30 +0,0 @@
-import type { CacheResolverStrategy } from "./cache-resolver.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: Config,
-    private readonly deps: Dependencies,
-  ) {}
-
-  async get(): Promise<CryptoKey> {
-    const resolver = new SubjectApplicationResolver(
-      [
-        new SubjectSegmentFixedStrategy("crypto_key_provider"),
-        new SubjectSegmentFixedStrategy(this.config.id),
-      ],
-      this.deps,
-    );
-
-    const subject = await resolver.resolve();
-
-    return this.deps.CacheResolver.resolve<CryptoKey>(subject.hex, () => this.config.inner.get());
-  }
-}

package/src/file-draft-zip.service.ts

@@ -1,56 +0,0 @@
-// cspell:ignore Yazl
-import { Readable } from "node:stream";
-import * as tools from "@bgord/tools";
-import * as v from "valibot";
-import { DynamicImport } from "./dynamic-import.service";
-import { FileDraft } from "./file-draft.service";
-
-export const FileDraftZipError = {
-  MissingDependency: "file.draft.zip.error.missing.dependency",
-};
-
-type YazlLibrary = typeof import("yazl");
-
-export class FileDraftZip extends FileDraft {
-  private static readonly importer = DynamicImport.for<YazlLibrary>(
-    "yazl",
-    FileDraftZipError.MissingDependency,
-  );
-
-  private constructor(
-    basename: tools.BasenameType,
-    private readonly parts: ReadonlyArray<FileDraft>,
-    private readonly yazl: YazlLibrary,
-  ) {
-    super(basename, v.parse(tools.Extension, "zip"), tools.Mimes.zip.mime);
-  }
-
-  static async build(basename: tools.BasenameType, parts: ReadonlyArray<FileDraft>): Promise<FileDraftZip> {
-    const library = await FileDraftZip.importer.resolve();
-    return new FileDraftZip(basename, parts, library);
-  }
-
-  async create(): Promise<BodyInit> {
-    const zip = new this.yazl.ZipFile();
-    const chunks: Array<Buffer> = [];
-
-    zip.outputStream.on("data", (buffer: Buffer) => chunks.push(buffer));
-
-    const output = new Promise<BodyInit>((resolve, reject) => {
-      zip.outputStream.on("end", () => resolve(Uint8Array.from(Buffer.concat(chunks))));
-      // Stryker disable all
-      zip.outputStream.on("error", reject);
-      // Stryker restore all
-    });
-
-    for (const part of this.parts) {
-      const bytes = await new Response(await part.create()).bytes();
-
-      zip.addReadStream(Readable.from([bytes]), part.filename.get());
-    }
-
-    zip.end();
-
-    return output;
-  }
-}