@bgord/bun 0.5.0 → 0.6.0

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;
-}