@bgord/bun 0.5.0 → 0.7.0

package/src/prerequisites.ts

@@ -0,0 +1,105 @@
+export type PrerequisiteLabelType = string;
+
+export enum PrerequisiteStrategyEnum {
+  binary = "binary",
+  mailer = "mailer",
+  self = "self",
+  timezoneUTC = "timezoneUTC",
+  path = "path",
+  node = "node",
+  bun = "bun",
+  RAM = "RAM",
+  space = "space",
+  translations = "translations",
+  port = "port",
+  jobs = "jobs",
+  memory = "memory",
+  outsideConnectivity = "outsideConnectivity",
+  sslCertificateExpiry = "sslCertificateExpiry",
+  logFile = "logFile",
+  /** @public */
+  custom = "custom",
+}
+
+export enum PrerequisiteStatusEnum {
+  success = "success",
+  failure = "failure",
+  undetermined = "undetermined",
+}
+
+export type BasePrerequisiteConfig = {
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+} & Record<string, unknown>;
+
+export abstract class AbstractPrerequisite<T extends BasePrerequisiteConfig> {
+  readonly label: PrerequisiteLabelType;
+  readonly enabled: boolean = true;
+  abstract readonly strategy: PrerequisiteStrategyEnum;
+  abstract readonly config: T;
+
+  status: PrerequisiteStatusEnum = PrerequisiteStatusEnum.undetermined;
+
+  constructor(config: T) {
+    this.label = config.label;
+    this.enabled = config.enabled ?? true;
+  }
+
+  abstract verify(): Promise<PrerequisiteStatusEnum>;
+
+  protected pass(): PrerequisiteStatusEnum.success {
+    this.status = PrerequisiteStatusEnum.success;
+    return PrerequisiteStatusEnum.success;
+  }
+
+  protected reject(): PrerequisiteStatusEnum.failure {
+    this.status = PrerequisiteStatusEnum.failure;
+    return PrerequisiteStatusEnum.failure;
+  }
+
+  report() {
+    if (this.status === PrerequisiteStatusEnum.success) {
+      // biome-ignore lint: lint/suspicious/noConsoleLog
+      console.log(`[x] ${this.config.label} verified correctly with ${this.strategy} strategy`);
+    }
+
+    if (this.status === PrerequisiteStatusEnum.failure) {
+      // biome-ignore lint: lint/suspicious/noConsoleLog
+      console.log(`[-] ${this.config.label} not verified correctly with ${this.strategy} strategy`);
+    }
+
+    if (this.status === PrerequisiteStatusEnum.undetermined) {
+      // biome-ignore lint: lint/suspicious/noConsoleLog
+      console.log(`[?] ${this.config.label} not enabled with ${this.strategy} strategy`);
+    }
+  }
+}
+
+export class Prerequisites {
+  static async check(prerequisites: AbstractPrerequisite<BasePrerequisiteConfig>[]) {
+    try {
+      const failedPrerequisiteLabels: PrerequisiteLabelType[] = [];
+
+      for (const prerequisite of prerequisites) {
+        await prerequisite.verify();
+        prerequisite.report();
+
+        if (prerequisite.status === PrerequisiteStatusEnum.failure) {
+          failedPrerequisiteLabels.push(prerequisite.label);
+        }
+      }
+
+      if (failedPrerequisiteLabels.length > 0) {
+        const failedPrerequisiteLabelsFormatted = failedPrerequisiteLabels.join(", ");
+
+        // biome-ignore lint: lint/suspicious/noConsoleLog
+        console.log(`Prerequisites failed: ${failedPrerequisiteLabelsFormatted}, quitting...`);
+
+        process.exit(1);
+      }
+    } catch (error) {
+      // biome-ignore lint: lint/suspicious/noConsoleLog
+      console.log("Prerequisites error", String(error));
+    }
+  }
+}

package/src/rate-limit-shield.ts

@@ -1,15 +1,15 @@
-import * as bg from "@bgord/node";
+import * as tools from "@bgord/tools";
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
 
-type RateLimitShieldOptionsType = { ms: bg.Schema.TimestampType };
+type RateLimitShieldOptionsType = { ms: tools.TimestampType };
 
 export const TooManyRequestsError = new HTTPException(429, {
   message: "app.too_many_requests",
 });
 
 export const rateLimitShield = (options: RateLimitShieldOptionsType) => {
-  const rateLimiter = new bg.RateLimiter(options);
+  const rateLimiter = new tools.RateLimiter(options);
 
   return createMiddleware(async (_c, next) => {
     const currentTimestampMs = Date.now();

package/src/session-id.ts

@@ -0,0 +1,13 @@
+import { Lucia } from "lucia";
+
+export class SessionId {
+  private value: string | null;
+
+  constructor(cookie: string | undefined, lucia: Lucia) {
+    this.value = lucia.readSessionCookie(cookie ?? "");
+  }
+
+  get(): SessionId["value"] {
+    return this.value;
+  }
+}

package/src/setup.ts

@@ -1,29 +1,36 @@
-import * as bgn from "@bgord/node";
+import * as tools from "@bgord/tools";
 import { bodyLimit } from "hono/body-limit";
 import { cors } from "hono/cors";
+import { languageDetector } from "hono/language";
 import { requestId } from "hono/request-id";
 import { secureHeaders } from "hono/secure-headers";
 import { timing } from "hono/timing";
 
 import { ApiVersion } from "./api-version";
 import { Context } from "./context";
-import { ETagExtractor, WeakETagExtractor } from "./etag-extractor";
+import { ETagExtractor } from "./etag-extractor";
 import { HttpLogger } from "./http-logger";
+import { I18nConfigType } from "./i18n";
+import { Logger } from "./logger";
 import { TimeZoneOffset } from "./time-zone-offset";
+import { WeakETagExtractor } from "./weak-etag-extractor";
 
-// TODO: fix bgord/node types
-export const BODY_LIMIT_MAX_SIZE = new bgn.Size({
+export const BODY_LIMIT_MAX_SIZE = new tools.Size({
   value: 128,
-  unit: bgn.SizeUnit.kB,
-}).toBytes() as number;
+  unit: tools.SizeUnit.kB,
+}).toBytes();
 
 export class Setup {
-  static essentials(logger: bgn.Logger) {
+  static essentials(logger: Logger, i18n: I18nConfigType) {
     return [
       secureHeaders(),
       bodyLimit({ maxSize: BODY_LIMIT_MAX_SIZE }),
       ApiVersion.attach,
       cors({ origin: "*" }),
+      languageDetector({
+        supportedLanguages: Object.keys(i18n.supportedLanguages),
+        fallbackLanguage: i18n.defaultLanguage,
+      }),
       requestId(),
       TimeZoneOffset.attach,
       Context.attach,

package/src/time-zone-offset.ts

@@ -1,11 +1,11 @@
-import * as bg from "@bgord/node";
+import * as tools from "@bgord/tools";
 import { createMiddleware } from "hono/factory";
 
 export type TimeZoneOffsetVariables = {
   timeZoneOffset: {
-    minutes: bg.Schema.TimeZoneOffsetValueType;
-    seconds: bg.Schema.TimeZoneOffsetValueType;
-    miliseconds: bg.Schema.TimeZoneOffsetValueType;
+    minutes: tools.TimeResult["minutes"];
+    seconds: tools.TimeResult["seconds"];
+    miliseconds: tools.TimeResult["ms"];
   };
 };
 
@@ -13,14 +13,14 @@ export class TimeZoneOffset {
   static TIME_ZONE_OFFSET_HEADER_NAME = "time-zone-offset";
 
   static attach = createMiddleware(async (c, next) => {
-    const timeZoneOffsetMinutes = bg.Schema.TimeZoneOffsetHeaderValue.parse(
+    const timeZoneOffsetMinutes = tools.TimeZoneOffsetValue.parse(
       c.req.header(TimeZoneOffset.TIME_ZONE_OFFSET_HEADER_NAME),
     );
 
     const timeZoneOffset = {
       minutes: timeZoneOffsetMinutes,
-      seconds: bg.Time.Minutes(timeZoneOffsetMinutes).seconds,
-      miliseconds: bg.Time.Minutes(timeZoneOffsetMinutes).ms,
+      seconds: tools.Time.Minutes(timeZoneOffsetMinutes).seconds,
+      miliseconds: tools.Time.Minutes(timeZoneOffsetMinutes).ms,
     };
 
     c.set("timeZoneOffset", timeZoneOffset);
@@ -29,16 +29,13 @@ export class TimeZoneOffset {
   });
 
   static adjustTimestamp(
-    timestamp: bg.Schema.TimestampType,
-    timeZoneOffsetMs: bg.Schema.TimeZoneOffsetValueType,
-  ): bg.Schema.TimestampType {
+    timestamp: tools.TimestampType,
+    timeZoneOffsetMs: tools.TimeResult["ms"],
+  ): tools.TimestampType {
     return timestamp - timeZoneOffsetMs;
   }
 
-  static adjustDate(
-    timestamp: bg.Schema.TimestampType,
-    timeZoneOffsetMs: bg.Schema.TimeZoneOffsetValueType,
-  ): Date {
+  static adjustDate(timestamp: tools.TimestampType, timeZoneOffsetMs: tools.TimeResult["ms"]): Date {
     return new Date(timestamp - timeZoneOffsetMs);
   }
 }

package/src/uptime.ts

@@ -0,0 +1,16 @@
+import * as tools from "@bgord/tools";
+
+export type UptimeResultType = {
+  seconds: tools.TimestampType;
+  formatted: ReturnType<(typeof tools.DateFormatters)["relative"]>;
+};
+
+export class Uptime {
+  static get(): UptimeResultType {
+    const rounding = new tools.RoundToNearest();
+    const uptime = tools.Time.Seconds(rounding.round(process.uptime()));
+    const uptimeFormatted = tools.DateFormatters.relative(Date.now() - uptime.ms);
+
+    return { seconds: uptime.seconds, formatted: uptimeFormatted };
+  }
+}

package/src/username.ts

@@ -0,0 +1,20 @@
+import { z } from "zod/v4";
+
+export type IdType = string;
+
+type UsernameType = string;
+
+export class Username {
+  private readonly schema: z.ZodSchema = z.string().max(256);
+
+  private readonly value: UsernameType;
+
+  constructor(value: UsernameType, schema?: z.ZodSchema) {
+    this.schema = schema ?? this.schema;
+    this.value = this.schema.parse(value) as UsernameType;
+  }
+
+  read(): UsernameType {
+    return this.value;
+  }
+}

package/src/uuid.ts

@@ -0,0 +1,6 @@
+import { z } from "zod/v4";
+
+import { NewUUID } from "./new-uuid";
+
+export const UUID = z.uuid().default(() => NewUUID.generate());
+export type UUIDType = z.infer<typeof UUID>;

package/src/weak-etag-extractor.ts

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

package/src/image-processor.ts

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