@bgord/bun 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,9 +1,16 @@
-export * from "./graceful-shutdown";
+export * from "./api-key-shield";
 export * from "./api-version";
-export * from "./time-zone-offset";
+export * from "./auth-shield";
 export * from "./context";
 export * from "./etag-extractor";
+export * from "./graceful-shutdown";
+export * from "./healthcheck";
 export * from "./http-logger";
-export * from "./api-key-shield";
 export * from "./rate-limit-shield";
-export * from "./healthcheck";
+export * from "./time-zone-offset";
+export * from "./cache-static-files";
+export * from "./cache-response";
+export * from "./download-file";
+export * from "./i18n";
+export * from "./file-uploader";
+export * from "./image-processor";

package/dist/rate-limit-shield.d.ts

@@ -4,8 +4,5 @@ declare type RateLimitShieldOptionsType = {
     ms: bg.Schema.TimestampType;
 };
 export declare const TooManyRequestsError: HTTPException;
-export declare const rateLimitShield: (options: RateLimitShieldOptionsType) => import("hono/types").MiddlewareHandler<{
-    Bindings: any;
-    Variables: any;
-}, string, {}>;
+export declare const rateLimitShield: (options: RateLimitShieldOptionsType) => import("hono").MiddlewareHandler<any, string, {}>;
 export {};

package/dist/time-zone-offset.d.ts

@@ -8,10 +8,7 @@ export declare type TimeZoneOffsetVariables = {
 };
 export declare class TimeZoneOffset {
     static TIME_ZONE_OFFSET_HEADER_NAME: string;
-    static attach: import("hono/types").MiddlewareHandler<{
-        Bindings: any;
-        Variables: any;
-    }, string, {}>;
+    static attach: import("hono").MiddlewareHandler<any, string, {}>;
     static adjustTimestamp(timestamp: bg.Schema.TimestampType, timeZoneOffsetMs: bg.Schema.TimeZoneOffsetValueType): bg.Schema.TimestampType;
     static adjustDate(timestamp: bg.Schema.TimestampType, timeZoneOffsetMs: bg.Schema.TimeZoneOffsetValueType): Date;
 }

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "name": "@bgord/bun",
   "type": "module",
@@ -28,9 +28,9 @@
     "@commitlint/config-conventional": "19.5.0",
     "@types/bun": "1.1.11",
     "@types/lodash": "4.17.10",
-    "cspell": "8.14.4",
+    "cspell": "8.15.3",
     "husky": "9.1.6",
-    "knip": "5.33.2",
+    "knip": "5.33.3",
     "microbundle": "0.15.1",
     "only-allow": "1.2.1",
     "shellcheck": "3.0.0",
@@ -39,8 +39,9 @@
   },
   "dependencies": {
     "@bgord/node": "0.82.0",
-    "hono": "4.6.4",
-    "lodash": "4.17.21"
+    "hono": "4.6.5",
+    "lodash": "4.17.21",
+    "sharp": "0.33.5"
   },
   "resolutions": {
     "typescript": "4.7.4"

package/src/auth-shield.ts

@@ -0,0 +1,152 @@
+import hono from "hono";
+import * as bgn from "@bgord/node";
+import { Lucia } from "lucia";
+import { createMiddleware } from "hono/factory";
+import { HTTPException } from "hono/http-exception";
+
+class SessionId {
+  private value: string | null;
+
+  constructor(cookie: string | undefined, lucia: Lucia) {
+    this.value = lucia.readSessionCookie(cookie ?? "");
+  }
+
+  get(): SessionId["value"] {
+    return this.value;
+  }
+}
+
+type AuthShieldConfigType<T> = {
+  Username: typeof bgn.Username;
+  Password: typeof bgn.Password;
+  HashedPassword: typeof bgn.HashedPassword;
+  lucia: Lucia;
+  findUniqueUserOrThrow: (username: bgn.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 }
+> {
+  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;
+    }
+  ) {
+    const config = {
+      Username: overrides.Username ?? bgn.Username,
+      Password: overrides.Password ?? bgn.Password,
+      HashedPassword: overrides.HashedPassword ?? bgn.HashedPassword,
+      lucia: overrides.lucia,
+      findUniqueUserOrThrow: overrides.findUniqueUserOrThrow,
+    };
+
+    this.config = config;
+  }
+
+  verify = createMiddleware(async (c: hono.Context, next: hono.Next) => {
+    const user = c.get("user");
+
+    if (!user) {
+      throw AccessDeniedAuthShieldError;
+    }
+
+    return next();
+  });
+
+  reverse = createMiddleware(async (c: hono.Context, next: hono.Next) => {
+    const user = c.get("user");
+
+    if (user) {
+      throw AccessDeniedAuthShieldError;
+    }
+
+    return next();
+  });
+
+  detach = createMiddleware(async (c: hono.Context, next: hono.Next) => {
+    const cookie = c.req.header("cookie");
+
+    const sessionId = new SessionId(cookie, this.config.lucia).get();
+
+    if (!sessionId) return next();
+
+    await this.config.lucia.invalidateSession(sessionId);
+
+    return next();
+  });
+
+  build = createMiddleware(async (c: hono.Context, next: hono.Next) => {
+    const cookie = c.req.header("cookie");
+
+    const sessionId = new SessionId(cookie, this.config.lucia).get();
+
+    if (!sessionId) {
+      c.set("user", null);
+      c.set("session", null);
+
+      return next();
+    }
+
+    const { session, user } = await this.config.lucia.validateSession(
+      sessionId
+    );
+
+    if (!session) {
+      c.res.headers.set(
+        "Set-Cookie",
+        this.config.lucia.createBlankSessionCookie().serialize()
+      );
+      c.set("user", null);
+      c.set("session", null);
+
+      return next();
+    }
+
+    if (session.fresh) {
+      c.res.headers.set(
+        "Set-Cookie",
+        this.config.lucia.createSessionCookie(session.id).serialize()
+      );
+    }
+    c.set("user", user);
+    c.set("session", session);
+
+    return next();
+  });
+
+  attach = createMiddleware(async (c: hono.Context, next: hono.Next) => {
+    try {
+      const body = await c.req.raw.clone().formData();
+
+      const username = new this.config.Username(body.get("username") as string);
+      const password = new this.config.Password(body.get("password") as string);
+
+      const user = await this.config.findUniqueUserOrThrow(username);
+
+      const hashedPassword = await this.config.HashedPassword.fromHash(
+        user.password
+      );
+      await hashedPassword.matchesOrThrow(password);
+
+      const session = await this.config.lucia.createSession(user.id, {});
+      const sessionCookie = this.config.lucia.createSessionCookie(session.id);
+
+      c.res.headers.set("Set-Cookie", sessionCookie.serialize());
+
+      return next();
+    } catch (error) {
+      throw AccessDeniedAuthShieldError;
+    }
+  });
+}

package/src/cache-response.ts

@@ -0,0 +1,35 @@
+import { createMiddleware } from "hono/factory";
+import NodeCache from "node-cache";
+import _ from "lodash";
+
+export enum CacheHitEnum {
+  hit = "hit",
+  miss = "miss",
+}
+
+export class CacheResponse {
+  static readonly CACHE_HIT_HEADER = "Cache-Hit";
+
+  constructor(private readonly cache: NodeCache) {}
+
+  handle = createMiddleware(async (c, next) => {
+    const url = _.escape(c.req.url);
+
+    if (this.cache.has(url)) {
+      c.res.headers.set(CacheResponse.CACHE_HIT_HEADER, CacheHitEnum.hit);
+
+      // @ts-ignore
+      return c.json(this.cache.get(url));
+    }
+
+    c.res.headers.set(CacheResponse.CACHE_HIT_HEADER, CacheHitEnum.miss);
+
+    return next();
+  });
+
+  clear = createMiddleware(async (_c, next) => {
+    this.cache.flushAll();
+
+    return next();
+  });
+}

package/src/cache-static-files.ts

@@ -0,0 +1,34 @@
+import * as bg from "@bgord/node";
+import { createMiddleware } from "hono/factory";
+
+export enum CacheStaticFilesStrategy {
+  never = "never",
+  always = "always",
+  five_minutes = "five_minutes",
+}
+
+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"
+        );
+      }
+      if (strategy === CacheStaticFilesStrategy.always) {
+        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}`
+        );
+      }
+      return next();
+    });
+  }
+}

package/src/download-file.ts

@@ -0,0 +1,15 @@
+import * as bgn from "@bgord/node";
+import type { PathLike } from "node:fs";
+
+export type DownloadFileConfigType = { filename: PathLike; mime: bgn.Mime };
+
+export class DownloadFile {
+  static attach(config: DownloadFileConfigType) {
+    return {
+      headers: new Headers({
+        "Content-Disposition": `attachment; filename="${config.filename}"`,
+        "Content-Type": config.mime.raw,
+      }),
+    };
+  }
+}

package/src/file-uploader.ts

@@ -0,0 +1,48 @@
+import * as bgn from "@bgord/node";
+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",
+});
+
+export const FileTooBigError = new HTTPException(400, {
+  message: "file_too_big_error",
+});
+
+type FileUploaderConfigType = {
+  mimeTypes: string[];
+  maxFilesSize: bgn.SizeValueType;
+};
+
+export class FileUploader {
+  static validate(config: FileUploaderConfigType) {
+    return [
+      bodyLimit({
+        maxSize: config.maxFilesSize,
+        onError: () => {
+          throw FileTooBigError;
+        },
+      }),
+
+      createMiddleware(async (c, next) => {
+        const body = await c.req.raw.clone().formData();
+
+        const file = body.get("file");
+
+        if (!(file instanceof File)) {
+          throw InvalidFileMimeTypeError;
+        }
+
+        const contentType = new bgn.Mime(file.type);
+        const accepted = config.mimeTypes.some((acceptedMimeType) =>
+          new bgn.Mime(acceptedMimeType).isSatisfiedBy(contentType)
+        );
+
+        if (!accepted) throw InvalidFileMimeTypeError;
+        return next();
+      }),
+    ];
+  }
+}

package/src/http-logger.ts

@@ -52,13 +52,13 @@ export class HttpLogger {
       let body: any;
 
       try {
-        body = await c.req.json();
+        body = await c.req.raw.clone().json();
       } catch (error) {}
 
       const httpRequestBeforeMetadata = {
         params: c.req.param(),
         headers: _.omit(
-          c.req.raw.headers.toJSON(),
+          c.req.raw.clone().headers.toJSON(),
           HttpLogger.uninformativeHeaders
         ),
         body,
@@ -80,9 +80,9 @@ export class HttpLogger {
 
       await next();
 
-      const cacheHitHeader = c.res.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
@@ -99,7 +99,7 @@ export class HttpLogger {
         cacheHit,
       };
 
-      const serverTimingMs = c.res.headers.get("Server-Timing");
+      const serverTimingMs = c.res.clone().headers.get("Server-Timing");
 
       const durationMsMatch =
         serverTimingMs?.match(/dur=([0-9]*\.?[0-9]+)/) ?? undefined;

package/src/i18n.ts

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

package/src/image-processor.ts

@@ -0,0 +1,5 @@
+import sharp from "sharp";
+
+export class ImageProcessor {
+  static sharp = sharp;
+}

package/src/index.ts

@@ -1,9 +1,16 @@
-export * from "./graceful-shutdown";
+export * from "./api-key-shield";
 export * from "./api-version";
-export * from "./time-zone-offset";
+export * from "./auth-shield";
 export * from "./context";
 export * from "./etag-extractor";
+export * from "./graceful-shutdown";
+export * from "./healthcheck";
 export * from "./http-logger";
-export * from "./api-key-shield";
 export * from "./rate-limit-shield";
-export * from "./healthcheck";
+export * from "./time-zone-offset";
+export * from "./cache-static-files";
+export * from "./cache-response";
+export * from "./download-file";
+export * from "./i18n";
+export * from "./file-uploader";
+export * from "./image-processor";