@bgord/bun 1.8.20 → 1.8.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.8.20",
+  "version": "1.8.21",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -12,8 +12,7 @@
     "types": "./dist/index.d.ts"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "scripts": {
     "build": "bash scripts/package-build.sh",

package/src/antivirus-clamav.adapter.ts

@@ -1,34 +0,0 @@
-import { type AntivirusPort, AntivirusPortError, type AntivirusScanResult } from "./antivirus.port";
-
-// Stryker disable all
-export class AntivirusClamavAdapter implements AntivirusPort {
-  async scanBytes(bytes: Uint8Array): Promise<AntivirusScanResult> {
-    const SIGNATURE_REGEX = /:\s+(?<signature>.+)\s+FOUND\s*$/m;
-
-    const antivirus = Bun.spawn({
-      cmd: ["clamscan", "--infected", "--no-summary", "--stdout", "-"],
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-
-    if (!antivirus.stdin) throw new Error(AntivirusPortError.ScanFailed);
-    antivirus.stdin.write(bytes);
-    await antivirus.stdin.end();
-    await antivirus.exited;
-
-    const stdout = await new Response(antivirus.stdout).text();
-    const stderr = await new Response(antivirus.stderr).text();
-
-    if (antivirus.exitCode === 0) return { clean: true };
-
-    if (antivirus.exitCode === 1) {
-      const signature = stdout.match(SIGNATURE_REGEX) ?? stderr.match(SIGNATURE_REGEX);
-
-      return { clean: false, signature: signature?.groups?.signature?.trim() ?? "unknown" };
-    }
-
-    throw new Error(AntivirusPortError.ScanFailed);
-  }
-}
-// Stryker restore all

package/src/antivirus-noop.adapter.ts

@@ -1,8 +0,0 @@
-import type * as tools from "@bgord/tools";
-import type { AntivirusPort, AntivirusScanResult } from "./antivirus.port";
-
-export class AntivirusNoopAdapter implements AntivirusPort {
-  async scanBytes(_bytes: Uint8Array, _filename?: tools.Filename): Promise<AntivirusScanResult> {
-    return { clean: true };
-  }
-}

package/src/antivirus.port.ts

@@ -1,9 +0,0 @@
-import type * as tools from "@bgord/tools";
-
-export type AntivirusScanResult = { clean: true } | { clean: false; signature: string };
-
-export const AntivirusPortError = { ScanFailed: "antivirus.scan.failed" } as const;
-
-export interface AntivirusPort {
-  scanBytes(bytes: Uint8Array, filename?: tools.Filename): Promise<AntivirusScanResult>;
-}

package/src/api-version.middleware.ts

@@ -1,31 +0,0 @@
-import { createMiddleware } from "hono/factory";
-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";
-
-type Dependencies = {
-  CacheResolver: CacheResolverStrategy;
-  HashContent: HashContentStrategy;
-  BuildInfoRepository: BuildInfoRepositoryStrategy;
-};
-
-export class ApiVersion {
-  static readonly HEADER_NAME = "api-version";
-
-  static build = (deps: Dependencies) =>
-    createMiddleware(async (context, next) => {
-      const resolver = new CacheSubjectApplicationResolver(
-        [new CacheSubjectSegmentFixedStrategy("api-version")],
-        deps,
-      );
-      const subject = await resolver.resolve();
-
-      const build = await deps.CacheResolver.resolve(subject.hex, async () =>
-        deps.BuildInfoRepository.extract(),
-      );
-      context.res.headers.set(ApiVersion.HEADER_NAME, build.version.toString());
-      await next();
-    });
-}

package/src/basic-auth-password.vo.ts

@@ -1,17 +0,0 @@
-import { z } from "zod/v4";
-
-export const BasicAuthPasswordError = {
-  Type: "basic.auth.password.type",
-  Empty: "basic.auth.password.empty",
-  TooLong: "basic.auth.password.too.long",
-};
-
-// Stryker disable all
-export const BasicAuthPassword = z
-  // Stryker restore all
-  .string(BasicAuthPasswordError.Type)
-  .min(1, BasicAuthPasswordError.Empty)
-  .max(128, BasicAuthPasswordError.TooLong)
-  .brand("BasicAuthPassword");
-
-export type BasicAuthPasswordType = z.infer<typeof BasicAuthPassword>;

package/src/basic-auth-username.vo.ts

@@ -1,17 +0,0 @@
-import { z } from "zod/v4";
-
-export const BasicAuthUsernameError = {
-  Type: "basic.auth.username.type",
-  Empty: "basic.auth.username.empty",
-  TooLong: "basic.auth.username.too.long",
-};
-
-// Stryker disable all
-export const BasicAuthUsername = z
-  // Stryker restore all
-  .string(BasicAuthUsernameError.Type)
-  .min(1, BasicAuthUsernameError.Empty)
-  .max(128, BasicAuthUsernameError.TooLong)
-  .brand("BasicAuthUsername");
-
-export type BasicAuthUsernameType = z.infer<typeof BasicAuthUsername>;

package/src/basic-auth.service.ts

@@ -1,14 +0,0 @@
-import type { BasicAuthPasswordType } from "./basic-auth-password.vo";
-import type { BasicAuthUsernameType } from "./basic-auth-username.vo";
-
-type BasicAuthConfigType = { username: BasicAuthUsernameType; password: BasicAuthPasswordType };
-
-export class BasicAuth {
-  static toHeaderValue(config: BasicAuthConfigType): { authorization: string } {
-    return { authorization: `Basic ${btoa(`${config.username}:${config.password}`)}` };
-  }
-
-  static toHeader(config: BasicAuthConfigType): Headers {
-    return new Headers(BasicAuth.toHeaderValue(config));
-  }
-}

package/src/better-auth-logger.service.ts

@@ -1,45 +0,0 @@
-import { type LoggerPort, LogLevelEnum } from "./logger.port";
-import { formatError } from "./logger-format-error.service";
-
-type LogLevel = "info" | "success" | "warn" | "error" | "debug";
-
-type Dependencies = { Logger: LoggerPort };
-
-export class BetterAuthLogger {
-  constructor(private readonly deps: Dependencies) {}
-
-  attach() {
-    return {
-      disabled: false,
-      level: "debug",
-      log: (lvl: LogLevel | undefined, message: string, ...args: unknown[]) => {
-        const level = this.mapLevel(lvl);
-        const base = { component: "infra", operation: "better-auth", message, metadata: { args } } as const;
-
-        switch (level) {
-          case LogLevelEnum.error: {
-            this.deps.Logger.error({
-              ...base,
-              error: formatError(args.find((arg) => arg instanceof Error) ?? new Error(message)),
-            });
-            break;
-          }
-          case LogLevelEnum.warn: {
-            this.deps.Logger.warn(base);
-            break;
-          }
-          default: {
-            this.deps.Logger.info(base);
-            break;
-          }
-        }
-      },
-    } as const;
-  }
-
-  private mapLevel(level: LogLevel | undefined) {
-    if (level === "warn") return LogLevelEnum.warn;
-    if (level === "error") return LogLevelEnum.error;
-    return LogLevelEnum.info;
-  }
-}

package/src/binary.vo.ts

@@ -1,22 +0,0 @@
-import { z } from "zod/v4";
-
-export const BinaryError = {
-  Type: "binary.type",
-  Empty: "binary.empty",
-  TooLong: "binary.too.long",
-  BadChars: "binary.bad.chars",
-};
-
-// One to sixty four letters, digits, hyphens, or underscores
-const CHARS_WHITELIST = /^[a-zA-Z0-9-_]{1,64}$/;
-
-// Stryker disable all
-export const Binary = z
-  // Stryker restore all
-  .string(BinaryError.Type)
-  .min(1, BinaryError.Empty)
-  .max(64, BinaryError.TooLong)
-  .regex(CHARS_WHITELIST, BinaryError.BadChars)
-  .brand("Binary");
-
-export type BinaryType = z.infer<typeof Binary>;

package/src/bots.vo.ts

@@ -1,132 +0,0 @@
-// Source: https://github.com/honojs/middleware/blob/main/packages/ua-blocker/src/generated.ts
-export const ALL_BOTS = [
-  "AddSearchBot",
-  "AI2Bot",
-  "AI2Bot-DeepResearchEval",
-  "Ai2Bot-Dolma",
-  "aiHitBot",
-  "amazon-kendra",
-  "Amazonbot",
-  "AmazonBuyForMe",
-  "Andibot",
-  "Anomura",
-  "anthropic-ai",
-  "Applebot",
-  "Applebot-Extended",
-  "atlassian-bot",
-  "Awario",
-  "bedrockbot",
-  "bigsur.ai",
-  "Bravebot",
-  "Brightbot 1.0",
-  "BuddyBot",
-  "Bytespider",
-  "CCBot",
-  "Channel3Bot",
-  "ChatGLM-Spider",
-  "ChatGPT Agent",
-  "ChatGPT-User",
-  "Claude-SearchBot",
-  "Claude-User",
-  "Claude-Web",
-  "ClaudeBot",
-  "Cloudflare-AutoRAG",
-  "CloudVertexBot",
-  "cohere-ai",
-  "cohere-training-data-crawler",
-  "Cotoyogi",
-  "Crawl4AI",
-  "Crawlspace",
-  "Datenbank Crawler",
-  "DeepSeekBot",
-  "Devin",
-  "Diffbot",
-  "DuckAssistBot",
-  "Echobot Bot",
-  "EchoboxBot",
-  "FacebookBot",
-  "facebookexternalhit",
-  "Factset_spyderbot",
-  "FirecrawlAgent",
-  "FriendlyCrawler",
-  "Gemini-Deep-Research",
-  "Google-CloudVertexBot",
-  "Google-Extended",
-  "Google-Firebase",
-  "Google-NotebookLM",
-  "GoogleAgent-Mariner",
-  "GoogleOther",
-  "GoogleOther-Image",
-  "GoogleOther-Video",
-  "GPTBot",
-  "iAskBot",
-  "iaskspider",
-  "iaskspider/2.0",
-  "IbouBot",
-  "ICC-Crawler",
-  "ImagesiftBot",
-  "imageSpider",
-  "img2dataset",
-  "ISSCyberRiskCrawler",
-  "Kangaroo Bot",
-  "KlaviyoAIBot",
-  "KunatoCrawler",
-  "laion-huggingface-processor",
-  "LAIONDownloader",
-  "LCC",
-  "LinerBot",
-  "Linguee Bot",
-  "LinkupBot",
-  "Manus-User",
-  "meta-externalagent",
-  "Meta-ExternalAgent",
-  "meta-externalfetcher",
-  "Meta-ExternalFetcher",
-  "meta-webindexer",
-  "MistralAI-User",
-  "MistralAI-User/1.0",
-  "MyCentralAIScraperBot",
-  "netEstate Imprint Crawler",
-  "NotebookLM",
-  "NovaAct",
-  "OAI-SearchBot",
-  "omgili",
-  "omgilibot",
-  "OpenAI",
-  "Operator",
-  "PanguBot",
-  "Panscient",
-  "panscient.com",
-  "Perplexity-User",
-  "PerplexityBot",
-  "PetalBot",
-  "PhindBot",
-  "Poggio-Citations",
-  "Poseidon Research Crawler",
-  "QualifiedBot",
-  "QuillBot",
-  "quillbot.com",
-  "SBIntuitionsBot",
-  "Scrapy",
-  "SemrushBot-OCOB",
-  "SemrushBot-SWA",
-  "ShapBot",
-  "Sidetrade indexer bot",
-  "Spider",
-  "TerraCotta",
-  "Thinkbot",
-  "TikTokSpider",
-  "Timpibot",
-  "TwinAgent",
-  "VelenPublicWebCrawler",
-  "WARDBot",
-  "Webzio-Extended",
-  "webzio-extended",
-  "wpbot",
-  "WRTNBot",
-  "YaK",
-  "YandexAdditional",
-  "YandexAdditionalBot",
-  "YouBot",
-  "ZanistaBot",
-];

package/src/build-info-repository-file.strategy.ts

@@ -1,23 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
-import { CommitSha } from "./commit-sha.vo";
-import type { FileReaderJsonPort } from "./file-reader-json.port";
-
-type Dependencies = { FileReaderJson: FileReaderJsonPort };
-
-export const BUILD_INFO_REPOSITORY_FILE_PATH = tools.FilePathRelative.fromString("infra/build-info.json");
-
-export class BuildInfoRepositoryFileStrategy implements BuildInfoRepositoryStrategy {
-  constructor(private readonly deps: Dependencies) {}
-
-  async extract() {
-    const file = await this.deps.FileReaderJson.read(BUILD_INFO_REPOSITORY_FILE_PATH.get());
-
-    const version = tools.PackageVersion.fromString(file.version);
-    const timestamp = tools.Timestamp.fromNumber(file.timestamp);
-    const sha = CommitSha.fromString(file.sha);
-    const size = tools.Size.fromBytes(file.size);
-
-    return { version, timestamp, sha, size };
-  }
-}

package/src/build-info-repository-noop.strategy.ts

@@ -1,16 +0,0 @@
-import type * as tools from "@bgord/tools";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
-import type { CommitSha } from "./commit-sha.vo";
-
-export class BuildInfoRepositoryNoopStrategy implements BuildInfoRepositoryStrategy {
-  constructor(
-    private readonly timestamp: tools.Timestamp,
-    private readonly version: tools.PackageVersion,
-    private readonly sha: CommitSha,
-    private readonly size: tools.Size,
-  ) {}
-
-  async extract() {
-    return { timestamp: this.timestamp, version: this.version, sha: this.sha, size: this.size };
-  }
-}

package/src/build-info-repository-package-json.strategy.ts

@@ -1,25 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
-import type { ClockPort } from "./clock.port";
-import { CommitSha } from "./commit-sha.vo";
-import type { FileReaderJsonPort } from "./file-reader-json.port";
-
-type Dependencies = { Clock: ClockPort; FileReaderJson: FileReaderJsonPort };
-
-export class BuildInfoRepositoryPackageJsonStrategy implements BuildInfoRepositoryStrategy {
-  constructor(private readonly deps: Dependencies) {}
-
-  async extract() {
-    const timestamp = this.deps.Clock.now();
-    const sha = CommitSha.fromString("a".repeat(40));
-    const size = tools.Size.fromBytes(0);
-
-    try {
-      const packageJson = await this.deps.FileReaderJson.read("package.json");
-
-      return { timestamp, version: tools.PackageVersion.fromString(packageJson.version), sha, size };
-    } catch {
-      return { timestamp, version: tools.PackageVersion.fromString("0.0.0"), sha, size };
-    }
-  }
-}

package/src/build-info-repository.strategy.ts

@@ -1,13 +0,0 @@
-import type * as tools from "@bgord/tools";
-import type { CommitSha } from "./commit-sha.vo";
-
-export type BuildInfoType = {
-  timestamp: tools.Timestamp;
-  version: tools.PackageVersion;
-  sha: CommitSha;
-  size: tools.Size;
-};
-
-export interface BuildInfoRepositoryStrategy {
-  extract(): Promise<BuildInfoType>;
-}

package/src/cache-file.service.ts

@@ -1,37 +0,0 @@
-import type { HashFileResult } from "./hash-file.port";
-
-type CacheFileOverridesType = Record<string, string>;
-
-interface CacheFileHandler {
-  notModified(options: HashFileResult, overrides?: CacheFileOverridesType): Response;
-
-  fresh(options: HashFileResult, overrides?: CacheFileOverridesType): Headers;
-}
-
-export const CacheFileMustRevalidate: CacheFileHandler = {
-  notModified(options: HashFileResult, overrides: CacheFileOverridesType = {}) {
-    return new Response(null, {
-      status: 304,
-      headers: new Headers({
-        ETag: options.etag.get(),
-        "Cache-Control": "private, max-age=0, must-revalidate",
-        "Last-Modified": new Date(options.lastModified.ms).toUTCString(),
-        Vary: "Authorization, Cookie",
-        ...overrides,
-      }),
-    });
-  },
-
-  fresh(options: HashFileResult, overrides: CacheFileOverridesType = {}) {
-    return new Headers({
-      "Content-Type": options.mime.toString(),
-      "Cache-Control": "private, max-age=0, must-revalidate",
-      ETag: options.etag.get(),
-      "Content-Length": options.size.toBytes().toString(),
-      "Last-Modified": new Date(options.lastModified.ms).toUTCString(),
-      "Accept-Ranges": "bytes",
-      Vary: "Authorization, Cookie",
-      ...overrides,
-    });
-  },
-};

package/src/cache-repository-lru-cache.adapter.ts

@@ -1,58 +0,0 @@
-import type { LRUCache } from "lru-cache";
-import type { CacheRepositoryPort, CacheRepositoryTtlType } from "./cache-repository.port";
-import type { Hash } from "./hash.vo";
-import type { HashValueType } from "./hash-value.vo";
-
-export const CacheRepositoryLruCacheAdapterError = {
-  MissingDependency: "cache.repository.lru.cache.adapter.error.missing.dependency",
-};
-
-export class CacheRepositoryLruCacheAdapter implements CacheRepositoryPort {
-  private readonly store: LRUCache<HashValueType, any>;
-
-  private constructor(store: LRUCache<HashValueType, any>) {
-    this.store = store;
-  }
-
-  static async build(config: CacheRepositoryTtlType): Promise<CacheRepositoryLruCacheAdapter> {
-    const library = await CacheRepositoryLruCacheAdapter.resolve();
-
-    const store = new library<HashValueType, any>({
-      max: 100_000,
-      ttl: config.type === "finite" ? config.ttl.ms : undefined,
-      ttlAutopurge: true,
-    });
-
-    return new CacheRepositoryLruCacheAdapter(store);
-  }
-
-  private static async resolve() {
-    try {
-      const library = await CacheRepositoryLruCacheAdapter.import();
-
-      return library.LRUCache;
-    } catch {
-      throw new Error(CacheRepositoryLruCacheAdapterError.MissingDependency);
-    }
-  }
-
-  static async import() {
-    return import("lru-cache");
-  }
-
-  async get<T>(subject: Hash): Promise<T | null> {
-    return (this.store.get(subject.get()) as T) ?? null;
-  }
-
-  async set<T>(subject: Hash, value: T): Promise<void> {
-    this.store.set(subject.get(), value);
-  }
-
-  async delete(subject: Hash): Promise<void> {
-    this.store.delete(subject.get());
-  }
-
-  async flush(): Promise<void> {
-    this.store.clear();
-  }
-}

package/src/cache-repository-node-cache.adapter.ts

@@ -1,32 +0,0 @@
-import NodeCache from "node-cache";
-import type { CacheRepositoryPort, CacheRepositoryTtlType } from "./cache-repository.port";
-import type { Hash } from "./hash.vo";
-
-export class CacheRepositoryNodeCacheAdapter implements CacheRepositoryPort {
-  private readonly store: NodeCache;
-
-  constructor(config: CacheRepositoryTtlType) {
-    this.store = new NodeCache({
-      stdTTL: config.type === "finite" ? config.ttl.seconds : 0,
-      deleteOnExpire: true,
-      maxKeys: 100_000,
-      useClones: false,
-    });
-  }
-
-  async get<T>(subject: Hash): Promise<T | null> {
-    return this.store.get(subject.get()) ?? null;
-  }
-
-  async set<T>(subject: Hash, value: T) {
-    this.store.set(subject.get(), value);
-  }
-
-  async delete(subject: Hash) {
-    this.store.del(subject.get());
-  }
-
-  async flush() {
-    this.store.flushAll();
-  }
-}

package/src/cache-repository-noop.adapter.ts

@@ -1,15 +0,0 @@
-import type { CacheRepositoryPort, CacheRepositoryTtlType } from "./cache-repository.port";
-
-export class CacheRepositoryNoopAdapter implements CacheRepositoryPort {
-  constructor(_config: CacheRepositoryTtlType) {}
-
-  async get<T>(): Promise<T | null> {
-    return null;
-  }
-
-  async set() {}
-
-  async delete() {}
-
-  async flush() {}
-}

package/src/cache-repository.port.ts

@@ -1,11 +0,0 @@
-import type * as tools from "@bgord/tools";
-import type { Hash } from "./hash.vo";
-
-export type CacheRepositoryTtlType = { type: "finite"; ttl: tools.Duration } | { type: "infinite" };
-
-export interface CacheRepositoryPort {
-  get<T>(subject: Hash): Promise<T | null>;
-  set<T>(subject: Hash, value: T): Promise<void>;
-  delete(subject: Hash): Promise<void>;
-  flush(): Promise<void>;
-}

package/src/cache-resolver-simple.strategy.ts

@@ -1,33 +0,0 @@
-import type { CacheRepositoryPort } from "./cache-repository.port";
-import { type CacheResolverStrategy, CacheSourceEnum } from "./cache-resolver.strategy";
-import type { Hash } from "./hash.vo";
-
-type Dependencies = { CacheRepository: CacheRepositoryPort };
-
-export class CacheResolverSimpleStrategy implements CacheResolverStrategy {
-  constructor(private readonly deps: Dependencies) {}
-
-  async resolve<T>(subject: Hash, producer: () => Promise<T>): Promise<T> {
-    const result = await this.resolveWithContext(subject, producer);
-
-    return result.value;
-  }
-
-  async resolveWithContext<T>(
-    subject: Hash,
-    producer: () => Promise<T>,
-  ): Promise<{ value: T; source: CacheSourceEnum }> {
-    const cached = await this.deps.CacheRepository.get<T>(subject);
-
-    if (cached !== null) return { value: cached, source: CacheSourceEnum.hit };
-
-    const value = await producer();
-    await this.deps.CacheRepository.set(subject, value);
-
-    return { value, source: CacheSourceEnum.miss };
-  }
-
-  async flush() {
-    await this.deps.CacheRepository.flush();
-  }
-}

package/src/cache-resolver.strategy.ts

@@ -1,17 +0,0 @@
-import type { Hash } from "./hash.vo";
-
-export enum CacheSourceEnum {
-  hit = "hit",
-  miss = "miss",
-}
-
-export interface CacheResolverStrategy {
-  resolve<T>(subject: Hash, producer: () => Promise<T>): Promise<T>;
-
-  resolveWithContext<T>(
-    subject: Hash,
-    producer: () => Promise<T>,
-  ): Promise<{ value: T; source: CacheSourceEnum }>;
-
-  flush(): Promise<void>;
-}