@bgord/bun 0.3.4 → 0.3.5

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.3.4",
+  "version": "0.3.5",
   "license": "MIT",
   "name": "@bgord/bun",
   "type": "module",
@@ -15,22 +15,18 @@
   "typings": "./dist/index.d.ts",
   "scripts": {
     "build": "microbundle",
-    "prepare": "husky",
     "preinstall": "bunx only-allow bun"
   },
-  "files": [
-    "dist",
-    "src"
-  ],
+  "files": ["dist", "src"],
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@commitlint/cli": "19.5.0",
     "@commitlint/config-conventional": "19.5.0",
-    "@types/bun": "1.1.12",
-    "@types/lodash": "4.17.12",
-    "cspell": "8.15.4",
-    "husky": "9.1.6",
-    "knip": "5.34.0",
+    "@types/bun": "1.1.13",
+    "@types/lodash": "4.17.13",
+    "cspell": "8.16.0",
+    "knip": "5.36.7",
+    "lefthook": "1.8.2",
     "microbundle": "0.15.1",
     "only-allow": "1.2.1",
     "shellcheck": "3.0.0",
@@ -39,7 +35,7 @@
   },
   "dependencies": {
     "@bgord/node": "0.83.3",
-    "hono": "4.6.6",
+    "hono": "4.6.9",
     "lodash": "4.17.21",
     "sharp": "0.33.5"
   },

package/src/api-version.ts

@@ -9,10 +9,7 @@ export class ApiVersion {
   static attach = createMiddleware(async (c, next) => {
     const build = await bg.BuildInfoRepository.extract();
 
-    c.res.headers.set(
-      ApiVersion.HEADER_NAME,
-      build.BUILD_VERSION ?? ApiVersion.DEFAULT_API_VERSION
-    );
+    c.res.headers.set(ApiVersion.HEADER_NAME, build.BUILD_VERSION ?? ApiVersion.DEFAULT_API_VERSION);
 
     await next();
   });

package/src/auth-shield.ts

@@ -1,8 +1,8 @@
-import hono from "hono";
 import * as bgn from "@bgord/node";
-import { Lucia } from "lucia";
+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;
@@ -28,20 +28,15 @@ 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: bgn.PasswordType; id: bgn.IdType }> {
   private readonly config: AuthShieldConfigType<T>;
 
   constructor(
-    overrides: Omit<
-      AuthShieldConfigType<T>,
-      "Username" | "Password" | "HashedPassword"
-    > & {
+    overrides: Omit<AuthShieldConfigType<T>, "Username" | "Password" | "HashedPassword"> & {
       Username?: typeof bgn.Username;
       Password?: typeof bgn.Password;
       HashedPassword?: typeof bgn.HashedPassword;
-    }
+    },
   ) {
     const config = {
       Username: overrides.Username ?? bgn.Username,
@@ -98,15 +93,10 @@ export class AuthShield<
       return next();
     }
 
-    const { session, user } = await this.config.lucia.validateSession(
-      sessionId
-    );
+    const { session, user } = await this.config.lucia.validateSession(sessionId);
 
     if (!session) {
-      c.res.headers.set(
-        "Set-Cookie",
-        this.config.lucia.createBlankSessionCookie().serialize()
-      );
+      c.res.headers.set("Set-Cookie", this.config.lucia.createBlankSessionCookie().serialize());
       c.set("user", null);
       c.set("session", null);
 
@@ -114,10 +104,7 @@ export class AuthShield<
     }
 
     if (session.fresh) {
-      c.res.headers.set(
-        "Set-Cookie",
-        this.config.lucia.createSessionCookie(session.id).serialize()
-      );
+      c.res.headers.set("Set-Cookie", this.config.lucia.createSessionCookie(session.id).serialize());
     }
     c.set("user", user);
     c.set("session", session);
@@ -134,9 +121,7 @@ export class AuthShield<
 
       const user = await this.config.findUniqueUserOrThrow(username);
 
-      const hashedPassword = await this.config.HashedPassword.fromHash(
-        user.password
-      );
+      const hashedPassword = await this.config.HashedPassword.fromHash(user.password);
       await hashedPassword.matchesOrThrow(password);
 
       const session = await this.config.lucia.createSession(user.id, {});

package/src/cache-response.ts

@@ -1,6 +1,6 @@
 import { createMiddleware } from "hono/factory";
-import NodeCache from "node-cache";
 import _ from "lodash";
+import NodeCache from "node-cache";
 
 export enum CacheHitEnum {
   hit = "hit",

package/src/cache-static-files.ts

@@ -11,22 +11,13 @@ export class CacheStaticFiles {
   static handle(strategy: CacheStaticFilesStrategy) {
     return createMiddleware(async (c, next) => {
       if (strategy === CacheStaticFilesStrategy.never) {
-        c.res.headers.set(
-          "cache-control",
-          "private, no-cache, no-store, must-revalidate"
-        );
+        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=${bg.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=${bg.Time.Minutes(5).seconds}`);
       }
       return next();
     });

package/src/download-file.ts

@@ -1,5 +1,5 @@
-import * as bgn from "@bgord/node";
 import type { PathLike } from "node:fs";
+import * as bgn from "@bgord/node";
 
 export type DownloadFileConfigType = { filename: PathLike; mime: bgn.Mime };
 

package/src/etag-extractor.ts

@@ -7,35 +7,31 @@ export type EtagVariables = {
 };
 
 export class ETagExtractor {
-  static attach = createMiddleware<{ Variables: EtagVariables }>(
-    async (c, next) => {
-      try {
-        const header = String(c.req.header(bg.ETag.IF_MATCH_HEADER_NAME));
+  static attach = createMiddleware<{ Variables: EtagVariables }>(async (c, next) => {
+    try {
+      const header = String(c.req.header(bg.ETag.IF_MATCH_HEADER_NAME));
 
-        if (!header || header === "undefined") c.set("ETag", null);
-        else c.set("ETag", bg.ETag.fromHeader(header));
-      } catch (error) {
-        c.set("ETag", null);
-      }
-
-      await next();
+      if (!header || header === "undefined") c.set("ETag", null);
+      else c.set("ETag", bg.ETag.fromHeader(header));
+    } catch (error) {
+      c.set("ETag", null);
     }
-  );
+
+    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));
+  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();
+      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,7 +1,7 @@
 import * as bgn from "@bgord/node";
+import { bodyLimit } from "hono/body-limit";
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
-import { bodyLimit } from "hono/body-limit";
 
 export const InvalidFileMimeTypeError = new HTTPException(400, {
   message: "invalid_file_mime_type_error",
@@ -37,7 +37,7 @@ export class FileUploader {
 
         const contentType = new bgn.Mime(file.type);
         const accepted = config.mimeTypes.some((acceptedMimeType) =>
-          new bgn.Mime(acceptedMimeType).isSatisfiedBy(contentType)
+          new bgn.Mime(acceptedMimeType).isSatisfiedBy(contentType),
         );
 
         if (!accepted) throw InvalidFileMimeTypeError;

package/src/graceful-shutdown.ts

@@ -3,10 +3,7 @@ import * as bg from "@bgord/node";
 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 = bg.noop) {
     server.stop();
     await callback();
     // biome-ignore lint: lint/suspicious/noConsoleLog
@@ -30,9 +27,7 @@ export class GracefulShutdown {
 
     process.on("unhandledRejection", async (event) => {
       // biome-ignore lint: lint/suspicious/noConsoleLog
-      console.log(
-        "UnhandledPromiseRejectionWarning received: closing HTTP server"
-      );
+      console.log("UnhandledPromiseRejectionWarning received: closing HTTP server");
 
       // biome-ignore lint: lint/suspicious/noConsoleLog
       console.log(JSON.stringify(event));

package/src/healthcheck.ts

@@ -18,9 +18,7 @@ type HealthcheckResultType = {
 } & bg.StopwatchResultType;
 
 export class Healthcheck {
-  static build = (
-    prerequisites: bg.AbstractPrerequisite<bg.BasePrerequisiteConfig>[]
-  ) =>
+  static build = (prerequisites: bg.AbstractPrerequisite<bg.BasePrerequisiteConfig>[]) =>
     handler.createHandlers(async (c) => {
       const stopwatch = new bg.Stopwatch();
 
@@ -33,9 +31,7 @@ export class Healthcheck {
         details.push({ label: prerequisite.label, status });
       }
 
-      const ok = details.every(
-        (result) => result.status !== bg.PrerequisiteStatusEnum.failure
-      )
+      const ok = details.every((result) => result.status !== bg.PrerequisiteStatusEnum.failure)
         ? bg.PrerequisiteStatusEnum.success
         : bg.PrerequisiteStatusEnum.failure;
 

package/src/http-logger.ts

@@ -1,12 +1,12 @@
 import * as bg from "@bgord/node";
-import { createMiddleware } from "hono/factory";
 import { getConnInfo } from "hono/bun";
+import { createMiddleware } from "hono/factory";
 import _ from "lodash";
 
 export class HttpLogger {
   private static simplify(response: unknown) {
     const result = JSON.stringify(response, (_key, value) =>
-      Array.isArray(value) ? { type: "Array", length: value.length } : value
+      Array.isArray(value) ? { type: "Array", length: value.length } : value,
     );
 
     return JSON.parse(result);
@@ -42,10 +42,7 @@ export class HttpLogger {
       const method = c.req.method;
 
       const client = {
-        ip:
-          c.req.header("x-real-ip") ||
-          c.req.header("x-forwarded-for") ||
-          info.remote.address,
+        ip: c.req.header("x-real-ip") || c.req.header("x-forwarded-for") || info.remote.address,
         userAgent: c.req.header("user-agent"),
       };
 
@@ -57,10 +54,7 @@ export class HttpLogger {
 
       const httpRequestBeforeMetadata = {
         params: c.req.param(),
-        headers: _.omit(
-          c.req.raw.clone().headers.toJSON(),
-          HttpLogger.uninformativeHeaders
-        ),
+        headers: _.omit(c.req.raw.clone().headers.toJSON(), HttpLogger.uninformativeHeaders),
         body,
         query: c.req.queries(),
       };
@@ -72,22 +66,14 @@ export class HttpLogger {
         method,
         url,
         client,
-        metadata: _.pickBy(
-          httpRequestBeforeMetadata,
-          (value) => !_.isEmpty(value)
-        ),
+        metadata: _.pickBy(httpRequestBeforeMetadata, (value) => !_.isEmpty(value)),
       });
 
       await next();
 
-      const cacheHitHeader = c.res
-        .clone()
-        .headers.get(bg.CacheResponse.CACHE_HIT_HEADER);
+      const cacheHitHeader = c.res.clone().headers.get(bg.CacheResponse.CACHE_HIT_HEADER);
 
-      const cacheHit =
-        cacheHitHeader === bg.CacheHitEnum.hit
-          ? bg.CacheHitEnum.hit
-          : undefined;
+      const cacheHit = cacheHitHeader === bg.CacheHitEnum.hit ? bg.CacheHitEnum.hit : undefined;
 
       let response: any;
       try {
@@ -101,12 +87,9 @@ export class HttpLogger {
 
       const serverTimingMs = c.res.clone().headers.get("Server-Timing");
 
-      const durationMsMatch =
-        serverTimingMs?.match(/dur=([0-9]*\.?[0-9]+)/) ?? undefined;
+      const durationMsMatch = serverTimingMs?.match(/dur=([0-9]*\.?[0-9]+)/) ?? undefined;
 
-      const durationMs = durationMsMatch?.[1]
-        ? Number(durationMsMatch[1])
-        : undefined;
+      const durationMs = durationMsMatch?.[1] ? Number(durationMsMatch[1]) : undefined;
 
       logger.http({
         operation: "http_request_after",

package/src/i18n.ts

@@ -1,21 +1,15 @@
-import * as bgn from "@bgord/node";
 import path from "node:path";
-import { createMiddleware } from "hono/factory";
+import * as bgn from "@bgord/node";
 import { getCookie } from "hono/cookie";
+import { createMiddleware } from "hono/factory";
 
 export type TranslationsKeyType = string;
 export type TranslationsValueType = string;
-export type TranslationsType = Record<
-  TranslationsKeyType,
-  TranslationsValueType
->;
+export type TranslationsType = Record<TranslationsKeyType, TranslationsValueType>;
 
 export type TranslationPlaceholderType = string;
 export type TranslationPlaceholderValueType = string | number;
-export type TranslationVariableType = Record<
-  TranslationPlaceholderType,
-  TranslationPlaceholderValueType
->;
+export type TranslationVariableType = Record<TranslationPlaceholderType, TranslationPlaceholderValueType>;
 
 export type I18nConfigType = {
   translationsPath?: bgn.Schema.PathType;
@@ -32,24 +26,19 @@ export type I18nVariablesType = {
 export class I18n {
   static LANGUAGE_COOKIE_NAME = "accept-language";
 
-  static DEFAULT_TRANSLATIONS_PATH =
-    bgn.Schema.Path.parse("infra/translations");
+  static DEFAULT_TRANSLATIONS_PATH = bgn.Schema.Path.parse("infra/translations");
 
   static FALLBACK_LANGUAGE = "en";
 
   static applyTo(config: I18nConfigType) {
     return createMiddleware(async (c, next) => {
-      const translationsPath =
-        config?.translationsPath ?? I18n.DEFAULT_TRANSLATIONS_PATH;
+      const translationsPath = config?.translationsPath ?? I18n.DEFAULT_TRANSLATIONS_PATH;
 
       const defaultLanguage = config?.defaultLanguage ?? I18n.FALLBACK_LANGUAGE;
 
-      const chosenLanguage =
-        getCookie(c, I18n.LANGUAGE_COOKIE_NAME) ?? defaultLanguage;
+      const chosenLanguage = getCookie(c, I18n.LANGUAGE_COOKIE_NAME) ?? defaultLanguage;
 
-      const language = Object.keys(config.supportedLanguages).find(
-        (language) => language === chosenLanguage
-      )
+      const language = Object.keys(config.supportedLanguages).find((language) => language === chosenLanguage)
         ? chosenLanguage
         : I18n.FALLBACK_LANGUAGE;
 
@@ -63,12 +52,10 @@ export class I18n {
 
   static async getTranslations(
     language: bgn.Schema.LanguageType,
-    translationsPath: bgn.Schema.PathType
+    translationsPath: bgn.Schema.PathType,
   ): Promise<TranslationsType> {
     try {
-      return Bun.file(
-        I18n.getTranslationPathForLanguage(language, translationsPath)
-      ).json();
+      return Bun.file(I18n.getTranslationPathForLanguage(language, translationsPath)).json();
     } catch (error) {
       // biome-ignore lint: lint/suspicious/noConsoleLog
       console.log("I18n#getTranslations", error);
@@ -78,10 +65,7 @@ export class I18n {
   }
 
   static useTranslations(translations: TranslationsType) {
-    return function translate(
-      key: TranslationsKeyType,
-      variables?: TranslationVariableType
-    ) {
+    return function translate(key: TranslationsKeyType, variables?: TranslationVariableType) {
       const translation = translations[key];
 
       if (!translation) {
@@ -92,19 +76,16 @@ export class I18n {
       if (!variables) return translation;
 
       return Object.entries(variables).reduce(
-        (result, [placeholder, value]) =>
-          result.replace(`{{${placeholder}}}`, String(value)),
-        translation
+        (result, [placeholder, value]) => result.replace(`{{${placeholder}}}`, String(value)),
+        translation,
       );
     };
   }
 
   static getTranslationPathForLanguage(
     language: bgn.Schema.LanguageType,
-    translationsPath = I18n.DEFAULT_TRANSLATIONS_PATH
+    translationsPath = I18n.DEFAULT_TRANSLATIONS_PATH,
   ): bgn.Schema.PathType {
-    return bgn.Schema.Path.parse(
-      path.join(translationsPath, `${language}.json`)
-    );
+    return bgn.Schema.Path.parse(path.join(translationsPath, `${language}.json`));
   }
 }

package/src/rate-limit-shield.ts

@@ -1,6 +1,6 @@
 import * as bg from "@bgord/node";
-import { HTTPException } from "hono/http-exception";
 import { createMiddleware } from "hono/factory";
+import { HTTPException } from "hono/http-exception";
 
 type RateLimitShieldOptionsType = { ms: bg.Schema.TimestampType };
 

package/src/setup.ts

@@ -1,15 +1,15 @@
 import * as bgn from "@bgord/node";
 import { bodyLimit } from "hono/body-limit";
 import { cors } from "hono/cors";
-import { secureHeaders } from "hono/secure-headers";
 import { requestId } from "hono/request-id";
+import { secureHeaders } from "hono/secure-headers";
 import { timing } from "hono/timing";
 
 import { ApiVersion } from "./api-version";
-import { TimeZoneOffset } from "./time-zone-offset";
 import { Context } from "./context";
-import { WeakETagExtractor, ETagExtractor } from "./etag-extractor";
+import { ETagExtractor, WeakETagExtractor } from "./etag-extractor";
 import { HttpLogger } from "./http-logger";
+import { TimeZoneOffset } from "./time-zone-offset";
 
 export const BODY_LIMIT_MAX_SIZE = new bgn.Size({
   value: 128,

package/src/time-zone-offset.ts

@@ -14,7 +14,7 @@ export class TimeZoneOffset {
 
   static attach = createMiddleware(async (c, next) => {
     const timeZoneOffsetMinutes = bg.Schema.TimeZoneOffsetHeaderValue.parse(
-      c.req.header(TimeZoneOffset.TIME_ZONE_OFFSET_HEADER_NAME)
+      c.req.header(TimeZoneOffset.TIME_ZONE_OFFSET_HEADER_NAME),
     );
 
     const timeZoneOffset = {
@@ -30,14 +30,14 @@ export class TimeZoneOffset {
 
   static adjustTimestamp(
     timestamp: bg.Schema.TimestampType,
-    timeZoneOffsetMs: bg.Schema.TimeZoneOffsetValueType
+    timeZoneOffsetMs: bg.Schema.TimeZoneOffsetValueType,
   ): bg.Schema.TimestampType {
     return timestamp - timeZoneOffsetMs;
   }
 
   static adjustDate(
     timestamp: bg.Schema.TimestampType,
-    timeZoneOffsetMs: bg.Schema.TimeZoneOffsetValueType
+    timeZoneOffsetMs: bg.Schema.TimeZoneOffsetValueType,
   ): Date {
     return new Date(timestamp - timeZoneOffsetMs);
   }