@bgord/bun 0.4.0 → 0.6.0

package/package.json

@@ -1,45 +1,46 @@
 {
-  "version": "0.4.0",
-  "license": "MIT",
   "name": "@bgord/bun",
+  "version": "0.6.0",
+  "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
-  "source": "src/index.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    "require": "./dist/bgord-bun.cjs",
-    "default": "./dist/bgord-bun.modern.js"
+    "import": "./dist/index.js",
+    "types": "./dist/index.d.ts"
   },
-  "main": "./dist/bgord-bun.cjs",
-  "module": "./dist/bgord-bun.module.js",
-  "unpkg": "./dist/bgord-bun.umd.js",
-  "typings": "./dist/index.d.ts",
+  "files": ["dist", "src"],
   "scripts": {
-    "build": "microbundle",
+    "build": "tsc --build",
     "preinstall": "bunx only-allow bun"
   },
-  "files": ["dist", "src"],
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
-    "@commitlint/cli": "19.6.0",
-    "@commitlint/config-conventional": "19.6.0",
-    "@types/bun": "1.1.13",
-    "@types/lodash": "4.17.13",
-    "cspell": "8.16.0",
-    "knip": "5.37.2",
-    "lefthook": "1.8.4",
-    "microbundle": "0.15.1",
+    "@commitlint/cli": "19.8.1",
+    "@commitlint/config-conventional": "19.8.1",
+    "@types/bun": "1.2.15",
+    "@types/lodash": "4.17.17",
+    "@types/nodemailer": "6.4.17",
+    "cspell": "9.0.2",
+    "knip": "5.60.2",
+    "lefthook": "1.11.13",
     "only-allow": "1.2.1",
-    "shellcheck": "3.0.0",
-    "supertest": "7.0.0",
-    "typescript": "5.6.3"
+    "shellcheck": "3.1.0",
+    "typescript": "5.8.3"
   },
   "dependencies": {
-    "@bgord/node": "0.84.0",
-    "hono": "4.6.9",
+    "@bgord/tools": "0.6.0",
+    "check-disk-space": "3.4.0",
+    "croner": "9.0.0",
+    "hono": "4.7.11",
     "lodash": "4.17.21",
-    "sharp": "0.33.5"
-  },
-  "resolutions": {
-    "typescript": "4.7.4"
+    "lucia": "3.2.2",
+    "node-cache": "5.1.2",
+    "nodemailer": "7.0.3",
+    "sharp": "0.34.2",
+    "ssl-checker": "2.0.10",
+    "winston": "3.17.0"
   }
 }

package/src/api-key-shield.ts

@@ -1,8 +1,8 @@
-import * as bg from "@bgord/node";
+import * as tools from "@bgord/tools";
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
 
-type ApiKeyShieldConfigType = { API_KEY: bg.Schema.ApiKeyType };
+type ApiKeyShieldConfigType = { API_KEY: tools.ApiKeyType };
 
 export const AccessDeniedApiKeyError = new HTTPException(403, {
   message: "access_denied_api_key",

package/src/api-version.ts

@@ -1,13 +1,14 @@
-import * as bg from "@bgord/node";
 import { createMiddleware } from "hono/factory";
 
+import { BuildInfoRepository } from "./build-info-repository";
+
 export class ApiVersion {
   static HEADER_NAME = "api-version";
 
   static DEFAULT_API_VERSION = "unknown";
 
   static attach = createMiddleware(async (c, next) => {
-    const build = await bg.BuildInfoRepository.extract();
+    const build = await BuildInfoRepository.extract();
 
     c.res.headers.set(ApiVersion.HEADER_NAME, build.BUILD_VERSION ?? ApiVersion.DEFAULT_API_VERSION);
 

package/src/auth-shield.ts

@@ -1,47 +1,38 @@
-import * as bgn from "@bgord/node";
 import hono from "hono";
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
 import { Lucia } from "lucia";
 
-class SessionId {
-  private value: string | null;
-
-  constructor(cookie: string | undefined, lucia: Lucia) {
-    this.value = lucia.readSessionCookie(cookie ?? "");
-  }
-
-  get(): SessionId["value"] {
-    return this.value;
-  }
-}
+import { HashedPassword, Password, PasswordType } from "./passwords";
+import { SessionId } from "./session-id";
+import { IdType, Username } from "./username";
 
 type AuthShieldConfigType<T> = {
-  Username: typeof bgn.Username;
-  Password: typeof bgn.Password;
-  HashedPassword: typeof bgn.HashedPassword;
+  Username: typeof Username;
+  Password: typeof Password;
+  HashedPassword: typeof HashedPassword;
   lucia: Lucia;
-  findUniqueUserOrThrow: (username: bgn.Username) => Promise<T>;
+  findUniqueUserOrThrow: (username: Username) => Promise<T>;
 };
 
 export const AccessDeniedAuthShieldError = new HTTPException(403, {
   message: "access_denied_auth_shield",
 });
 
-export class AuthShield<T extends { password: bgn.PasswordType; id: bgn.IdType }> {
+export class AuthShield<T extends { password: PasswordType; id: IdType }> {
   private readonly config: AuthShieldConfigType<T>;
 
   constructor(
     overrides: Omit<AuthShieldConfigType<T>, "Username" | "Password" | "HashedPassword"> & {
-      Username?: typeof bgn.Username;
-      Password?: typeof bgn.Password;
-      HashedPassword?: typeof bgn.HashedPassword;
+      Username?: typeof Username;
+      Password?: typeof Password;
+      HashedPassword?: typeof HashedPassword;
     },
   ) {
     const config = {
-      Username: overrides.Username ?? bgn.Username,
-      Password: overrides.Password ?? bgn.Password,
-      HashedPassword: overrides.HashedPassword ?? bgn.HashedPassword,
+      Username: overrides.Username ?? Username,
+      Password: overrides.Password ?? Password,
+      HashedPassword: overrides.HashedPassword ?? HashedPassword,
       lucia: overrides.lucia,
       findUniqueUserOrThrow: overrides.findUniqueUserOrThrow,
     };

package/src/build-info-repository.ts

@@ -0,0 +1,26 @@
+import * as tools from "@bgord/tools";
+
+export type BuildInfoType = {
+  BUILD_DATE: tools.TimestampType;
+  BUILD_VERSION?: tools.BuildVersionType;
+};
+
+export class BuildInfoRepository {
+  static async extract(): Promise<BuildInfoType> {
+    const BUILD_DATE = Date.now();
+
+    try {
+      const packageJson = await BuildInfoRepository.getPackageJson();
+
+      const BUILD_VERSION = tools.BuildVersion.parse(packageJson.version);
+
+      return { BUILD_DATE, BUILD_VERSION };
+    } catch (error) {
+      return { BUILD_DATE };
+    }
+  }
+
+  static async getPackageJson() {
+    return Bun.file("package.json").json();
+  }
+}

package/src/cache-resolver.ts

@@ -0,0 +1,93 @@
+import { Context } from "hono";
+import NodeCache, { Key } from "node-cache";
+
+export enum CacheHitEnum {
+  hit = "hit",
+  miss = "miss",
+}
+
+export enum CacheResolverStrategy {
+  simple = "simple",
+  with_metadata = "with_metadata",
+  request_headers = "request_headers",
+}
+
+type Resolver<T> = () => Promise<T>;
+
+type BaseOptions<T> = { key: Key; resolver: Resolver<T> };
+
+type CacheResolverSimpleResult<T> = { data: T };
+
+type CacheResolverWithMetadataResult<T> = {
+  data: T;
+  meta: { hit: CacheHitEnum };
+};
+
+type CacheResolverRequestHeadersResult<T> = {
+  data: T;
+  header: {
+    name: "cache-hit";
+    value: CacheHitEnum;
+  };
+  respond: (c: Context) => Promise<void>;
+};
+
+export class CacheResolver {
+  static async resolve<T>(
+    cache: NodeCache,
+    options: BaseOptions<T> & { strategy?: CacheResolverStrategy.simple },
+  ): Promise<CacheResolverSimpleResult<T>>;
+
+  static async resolve<T>(
+    cache: NodeCache,
+    options: BaseOptions<T> & { strategy: CacheResolverStrategy.with_metadata },
+  ): Promise<CacheResolverWithMetadataResult<T>>;
+
+  static async resolve<T>(
+    cache: NodeCache,
+    options: BaseOptions<T> & {
+      strategy: CacheResolverStrategy.request_headers;
+    },
+  ): Promise<CacheResolverRequestHeadersResult<T>>;
+
+  static async resolve<T>(
+    cache: NodeCache,
+    options: BaseOptions<T> & { strategy?: CacheResolverStrategy },
+  ): Promise<any> {
+    const strategy = options.strategy ?? CacheResolverStrategy.simple;
+
+    const cached = cache.get<T>(options.key);
+
+    const hit = cached !== undefined;
+
+    const data = hit ? cached : await options.resolver();
+
+    if (!hit) cache.set(options.key, data);
+
+    switch (strategy) {
+      case CacheResolverStrategy.with_metadata:
+        return {
+          data,
+          meta: { hit: hit ? CacheHitEnum.hit : CacheHitEnum.miss },
+        };
+
+      case CacheResolverStrategy.request_headers:
+        return {
+          data,
+          respond: (c: Context) => {
+            c.header("cache-hit", hit ? CacheHitEnum.hit : CacheHitEnum.miss);
+
+            // @ts-expect-error
+            return c.json(data);
+          },
+          header: {
+            name: "cache-hit",
+            value: hit ? CacheHitEnum.hit : CacheHitEnum.miss,
+          },
+        };
+
+      default:
+        return { data };
+    }
+  }
+}

package/src/cache-response.ts

@@ -2,10 +2,7 @@ import { createMiddleware } from "hono/factory";
 import _ from "lodash";
 import NodeCache from "node-cache";
 
-export enum CacheHitEnum {
-  hit = "hit",
-  miss = "miss",
-}
+import { CacheHitEnum } from "./cache-resolver";
 
 export class CacheResponse {
   static readonly CACHE_HIT_HEADER = "Cache-Hit";
@@ -18,7 +15,7 @@ export class CacheResponse {
     if (this.cache.has(url)) {
       c.res.headers.set(CacheResponse.CACHE_HIT_HEADER, CacheHitEnum.hit);
 
-      // @ts-ignore
+      // @ts-expect-error
       return c.json(this.cache.get(url));
     }
 

package/src/cache-static-files.ts

@@ -1,4 +1,4 @@
-import * as bg from "@bgord/node";
+import * as tools from "@bgord/tools";
 import { createMiddleware } from "hono/factory";
 
 export enum CacheStaticFilesStrategy {
@@ -14,10 +14,10 @@ export class CacheStaticFiles {
         c.res.headers.set("cache-control", "private, no-cache, no-store, must-revalidate");
       }
       if (strategy === CacheStaticFilesStrategy.always) {
-        c.res.headers.set("cache-control", `public, max-age=${bg.Time.Days(365).seconds}, immutable`);
+        c.res.headers.set("cache-control", `public, max-age=${tools.Time.Days(365).seconds}, immutable`);
       }
       if (strategy === CacheStaticFilesStrategy.five_minutes) {
-        c.res.headers.set("cache-control", `public, max-age=${bg.Time.Minutes(5).seconds}`);
+        c.res.headers.set("cache-control", `public, max-age=${tools.Time.Minutes(5).seconds}`);
       }
       return next();
     });

package/src/context.ts

@@ -1,17 +1,22 @@
-import * as bg from "@bgord/node";
 import { createMiddleware } from "hono/factory";
 
+import { CorrelationIdType } from "./correlation-id";
 import { TimeZoneOffsetVariables } from "./time-zone-offset";
 
+export type ContextType = {
+  requestId: CorrelationIdType;
+  timeZoneOffset: TimeZoneOffsetVariables["timeZoneOffset"];
+};
+
 export type ContextVariables = {
-  context: bg.ContextType;
-  requestId: string;
+  context: ContextType;
+  requestId: CorrelationIdType;
 } & TimeZoneOffsetVariables;
 
 export class Context {
   static attach = createMiddleware(async (c, next) => {
     c.set("context", {
-      requestId: c.get("requestId") as bg.Schema.CorrelationIdType,
+      requestId: c.get("requestId") as CorrelationIdType,
       timeZoneOffset: c.get("timeZoneOffset"),
     });
 

package/src/correlation-id.ts

@@ -0,0 +1,6 @@
+import { z } from "zod/v4";
+
+import { UUID } from "./uuid";
+
+export const CorrelationId = UUID;
+export type CorrelationIdType = z.infer<typeof CorrelationId>;

package/src/download-file.ts

@@ -1,7 +1,7 @@
 import type { PathLike } from "node:fs";
-import * as bgn from "@bgord/node";
+import * as tools from "@bgord/tools";
 
-export type DownloadFileConfigType = { filename: PathLike; mime: bgn.Mime };
+type DownloadFileConfigType = { filename: PathLike; mime: tools.Mime };
 
 export class DownloadFile {
   static attach(config: DownloadFileConfigType) {

package/src/etag-extractor.ts

@@ -1,18 +1,18 @@
-import * as bg from "@bgord/node";
+import * as tools from "@bgord/tools";
 import { createMiddleware } from "hono/factory";
 
 export type EtagVariables = {
-  ETag: bg.ETag | null;
-  WeakETag: bg.WeakETag | null;
+  ETag: tools.ETag | null;
+  WeakETag: tools.WeakETag | null;
 };
 
 export class ETagExtractor {
   static attach = createMiddleware<{ Variables: EtagVariables }>(async (c, next) => {
     try {
-      const header = String(c.req.header(bg.ETag.IF_MATCH_HEADER_NAME));
+      const header = String(c.req.header(tools.ETag.IF_MATCH_HEADER_NAME));
 
       if (!header || header === "undefined") c.set("ETag", null);
-      else c.set("ETag", bg.ETag.fromHeader(header));
+      else c.set("ETag", tools.ETag.fromHeader(header));
     } catch (error) {
       c.set("ETag", null);
     }
@@ -20,18 +20,3 @@ export class ETagExtractor {
     await next();
   });
 }
-
-export class WeakETagExtractor {
-  static attach = createMiddleware<{ Variables: EtagVariables }>(async (c, next) => {
-    try {
-      const header = String(c.req.header(bg.WeakETag.IF_MATCH_HEADER_NAME));
-
-      if (!header || header === "undefined") c.set("WeakETag", null);
-      else c.set("WeakETag", bg.WeakETag.fromHeader(header));
-    } catch (error) {
-      c.set("WeakETag", null);
-    }
-
-    await next();
-  });
-}

package/src/file-uploader.ts

@@ -1,4 +1,4 @@
-import * as bgn from "@bgord/node";
+import * as tools from "@bgord/tools";
 import { bodyLimit } from "hono/body-limit";
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
@@ -13,7 +13,7 @@ export const FileTooBigError = new HTTPException(400, {
 
 type FileUploaderConfigType = {
   mimeTypes: string[];
-  maxFilesSize: bgn.SizeValueType;
+  maxFilesSize: tools.SizeValueType;
 };
 
 export class FileUploader {
@@ -35,9 +35,9 @@ export class FileUploader {
           throw InvalidFileMimeTypeError;
         }
 
-        const contentType = new bgn.Mime(file.type);
+        const contentType = new tools.Mime(file.type);
         const accepted = config.mimeTypes.some((acceptedMimeType) =>
-          new bgn.Mime(acceptedMimeType).isSatisfiedBy(contentType),
+          new tools.Mime(acceptedMimeType).isSatisfiedBy(contentType),
         );
 
         if (!accepted) throw InvalidFileMimeTypeError;

package/src/graceful-shutdown.ts

@@ -1,16 +1,16 @@
-import * as bg from "@bgord/node";
+import * as tools from "@bgord/tools";
 
 type ServerType = ReturnType<typeof Bun.serve>;
 
 export class GracefulShutdown {
-  private static async shutdown(server: ServerType, callback: () => any = bg.noop) {
+  private static async shutdown(server: ServerType, callback: () => any = tools.noop) {
     server.stop();
     await callback();
     // biome-ignore lint: lint/suspicious/noConsoleLog
     console.log("HTTP server closed");
   }
 
-  static applyTo(server: ServerType, callback: () => any = bg.noop) {
+  static applyTo(server: ServerType, callback: () => any = tools.noop) {
     process.on("SIGTERM", async () => {
       // biome-ignore lint: lint/suspicious/noConsoleLog
       console.log("SIGTERM signal received: closing HTTP server");

package/src/healthcheck.ts

@@ -1,28 +1,38 @@
-import * as bg from "@bgord/node";
+import * as tools from "@bgord/tools";
 import { createFactory } from "hono/factory";
 
+import { BuildInfoRepository } from "./build-info-repository";
+import { MemoryConsumption } from "./memory-consumption";
+import {
+  AbstractPrerequisite,
+  BasePrerequisiteConfig,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+} from "./prerequisites";
+import { Uptime, UptimeResultType } from "./uptime";
+
 const handler = createFactory();
 
 type HealthcheckResultType = {
-  ok: bg.PrerequisiteStatusEnum;
-  version: bg.Schema.BuildVersionType;
+  ok: PrerequisiteStatusEnum;
+  version: tools.BuildVersionType;
   details: {
-    label: bg.PrerequisiteLabelType;
-    status: bg.PrerequisiteStatusEnum;
+    label: PrerequisiteLabelType;
+    status: PrerequisiteStatusEnum;
   }[];
-  uptime: bg.UptimeResultType;
+  uptime: UptimeResultType;
   memory: {
-    bytes: bg.Size["bytes"];
-    formatted: ReturnType<bg.Size["format"]>;
+    bytes: tools.Size["bytes"];
+    formatted: ReturnType<tools.Size["format"]>;
   };
-} & bg.StopwatchResultType;
+} & tools.StopwatchResultType;
 
 export class Healthcheck {
-  static build = (prerequisites: bg.AbstractPrerequisite<bg.BasePrerequisiteConfig>[]) =>
+  static build = (prerequisites: AbstractPrerequisite<BasePrerequisiteConfig>[]) =>
     handler.createHandlers(async (c) => {
-      const stopwatch = new bg.Stopwatch();
+      const stopwatch = new tools.Stopwatch();
 
-      const build = await bg.BuildInfoRepository.extract();
+      const build = await BuildInfoRepository.extract();
 
       const details: HealthcheckResultType["details"][number][] = [];
 
@@ -31,20 +41,20 @@ export class Healthcheck {
         details.push({ label: prerequisite.label, status });
       }
 
-      const ok = details.every((result) => result.status !== bg.PrerequisiteStatusEnum.failure)
-        ? bg.PrerequisiteStatusEnum.success
-        : bg.PrerequisiteStatusEnum.failure;
+      const ok = details.every((result) => result.status !== PrerequisiteStatusEnum.failure)
+        ? PrerequisiteStatusEnum.success
+        : PrerequisiteStatusEnum.failure;
 
-      const code = ok === bg.PrerequisiteStatusEnum.success ? 200 : 424;
+      const code = ok === PrerequisiteStatusEnum.success ? 200 : 424;
 
       const result: HealthcheckResultType = {
         ok,
         details,
-        version: build.BUILD_VERSION ?? bg.Schema.BuildVersion.parse("unknown"),
-        uptime: bg.Uptime.get(),
+        version: build.BUILD_VERSION ?? tools.BuildVersion.parse("unknown"),
+        uptime: Uptime.get(),
         memory: {
-          bytes: bg.MemoryConsumption.get().toBytes(),
-          formatted: bg.MemoryConsumption.get().format(bg.SizeUnit.MB),
+          bytes: MemoryConsumption.get().toBytes(),
+          formatted: MemoryConsumption.get().format(tools.SizeUnit.MB),
         },
         ...stopwatch.stop(),
       };

package/src/http-logger.ts

@@ -1,8 +1,12 @@
-import * as bg from "@bgord/node";
 import { getConnInfo } from "hono/bun";
 import { createMiddleware } from "hono/factory";
 import _ from "lodash";
 
+import { CacheHitEnum } from "./cache-resolver";
+import { CacheResponse } from "./cache-response";
+import { CorrelationIdType } from "./correlation-id";
+import { Logger } from "./logger";
+
 export class HttpLogger {
   private static simplify(response: unknown) {
     const result = JSON.stringify(response, (_key, value) =>
@@ -34,9 +38,9 @@ export class HttpLogger {
     "if-none-match",
   ];
 
-  static build = (logger: bg.Logger) =>
+  static build = (logger: Logger) =>
     createMiddleware(async (c, next) => {
-      const correlationId = c.get("requestId") as bg.Schema.CorrelationIdType;
+      const correlationId = c.get("requestId") as CorrelationIdType;
       const info = getConnInfo(c);
       const url = c.req.url;
       const method = c.req.method;
@@ -54,7 +58,7 @@ export class HttpLogger {
 
       const httpRequestBeforeMetadata = {
         params: c.req.param(),
-        headers: _.omit(c.req.raw.clone().headers.toJSON(), HttpLogger.uninformativeHeaders),
+        headers: _.omit(Object.fromEntries(c.req.raw.clone().headers), HttpLogger.uninformativeHeaders),
         body,
         query: c.req.queries(),
       };
@@ -71,9 +75,9 @@ export class HttpLogger {
 
       await next();
 
-      const cacheHitHeader = c.res.clone().headers.get(bg.CacheResponse.CACHE_HIT_HEADER);
+      const cacheHitHeader = c.res.clone().headers.get(CacheResponse.CACHE_HIT_HEADER);
 
-      const cacheHit = cacheHitHeader === bg.CacheHitEnum.hit ? bg.CacheHitEnum.hit : undefined;
+      const cacheHit = cacheHitHeader === CacheHitEnum.hit ? CacheHitEnum.hit : undefined;
 
       let response: any;
       try {