@bgord/bun 0.29.13 → 0.29.14

package/dist/uptime.service.d.ts

@@ -1,10 +1,11 @@
 import * as tools from "@bgord/tools";
 import type { ClockPort } from "./clock.port";
 export type UptimeResultType = {
-    seconds: tools.TimestampType;
+    duration: tools.Duration;
     formatted: ReturnType<(typeof tools.DateFormatters)["relative"]>;
 };
 export declare class Uptime {
+    private static readonly rounding;
     static get(clock: ClockPort): UptimeResultType;
 }
 //# sourceMappingURL=uptime.service.d.ts.map

package/dist/uptime.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uptime.service.d.ts","sourceRoot":"","sources":["../src/uptime.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,KAAK,CAAC,aAAa,CAAC;IAC7B,SAAS,EAAE,UAAU,CAAC,CAAC,OAAO,KAAK,CAAC,cAAc,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;CAClE,CAAC;AAEF,qBAAa,MAAM;IACjB,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,gBAAgB;CAS/C"}
+{"version":3,"file":"uptime.service.d.ts","sourceRoot":"","sources":["../src/uptime.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC;IACzB,SAAS,EAAE,UAAU,CAAC,CAAC,OAAO,KAAK,CAAC,cAAc,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;CAClE,CAAC;AAEF,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IAE9D,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,gBAAgB;CAM/C"}

package/dist/uptime.service.js

@@ -1,10 +1,10 @@
 import * as tools from "@bgord/tools";
 export class Uptime {
+    static rounding = new tools.RoundToNearest();
     static get(clock) {
-        const rounding = new tools.RoundToNearest();
-        const uptime = tools.Time.Seconds(rounding.round(process.uptime()));
-        const uptimeFormatted = tools.DateFormatters.relative(clock.now().Minus(uptime).ms);
-        return { seconds: tools.Timestamp.parse(uptime.seconds), formatted: uptimeFormatted };
+        const uptime = tools.Duration.Seconds(Uptime.rounding.round(process.uptime()));
+        const uptimeFormatted = tools.DateFormatters.relative(clock.now().Minus(uptime));
+        return { duration: uptime, formatted: uptimeFormatted };
     }
 }
 //# sourceMappingURL=uptime.service.js.map

package/dist/uptime.service.js.map

@@ -1 +1 @@
-{"version":3,"file":"uptime.service.js","sourceRoot":"","sources":["../src/uptime.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAQtC,MAAM,OAAO,MAAM;IACjB,MAAM,CAAC,GAAG,CAAC,KAAgB;QACzB,MAAM,QAAQ,GAAG,IAAI,KAAK,CAAC,cAAc,EAAE,CAAC;QAE5C,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAEpE,MAAM,eAAe,GAAG,KAAK,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;QAEpF,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,SAAS,EAAE,eAAe,EAAE,CAAC;IACxF,CAAC;CACF"}
+{"version":3,"file":"uptime.service.js","sourceRoot":"","sources":["../src/uptime.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAQtC,MAAM,OAAO,MAAM;IACT,MAAM,CAAU,QAAQ,GAAG,IAAI,KAAK,CAAC,cAAc,EAAE,CAAC;IAE9D,MAAM,CAAC,GAAG,CAAC,KAAgB;QACzB,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAC/E,MAAM,eAAe,GAAG,KAAK,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;QAEjF,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,CAAC;IAC1D,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "0.29.13",
+  "version": "0.29.14",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -38,18 +38,18 @@
   },
   "dependencies": {
     "@axiomhq/winston": "1.3.1",
-    "@bgord/tools": "0.16.2",
+    "@bgord/tools": "0.17.1",
     "@hono/ua-blocker": "0.1.12",
     "better-auth": "1.3.26",
     "check-disk-space": "3.4.0",
     "croner": "9.1.0",
     "csv": "6.4.1",
     "hcaptcha": "0.2.0",
-    "hono": "4.9.9",
+    "hono": "4.9.10",
     "lodash": "4.17.21",
     "mime-types": "3.0.1",
     "node-cache": "5.1.2",
-    "nodemailer": "7.0.6",
+    "nodemailer": "7.0.7",
     "sharp": "0.34.4",
     "ssl-checker": "2.0.10",
     "winston": "3.18.3",

package/src/basic-auth.service.ts

@@ -1,9 +1,21 @@
 import { z } from "zod/v4";
 
-export const BasicAuthUsername = z.string().min(1).max(128).brand("BasicAuthUsername");
+export const BasicAuthUsernameTypeError = { error: "basic.auth.username.invalid_type" } as const;
+export const BasicAuthUsernameLengthError = { error: "basic.auth.username.invalid_length" } as const;
+export const BasicAuthUsername = z
+  .string(BasicAuthUsernameTypeError)
+  .min(1, BasicAuthUsernameLengthError)
+  .max(128, BasicAuthUsernameLengthError)
+  .brand("BasicAuthUsername");
 export type BasicAuthUsernameType = z.infer<typeof BasicAuthUsername>;
 
-export const BasicAuthPassword = z.string().min(1).max(128).brand("BasicAuthPassword");
+export const BasicAuthPasswordTypeError = { error: "basic.auth.password.invalid_type" } as const;
+export const BasicAuthPasswordLengthError = { error: "basic.auth.password.invalid_length" } as const;
+export const BasicAuthPassword = z
+  .string(BasicAuthPasswordTypeError)
+  .min(1, BasicAuthPasswordLengthError)
+  .max(128, BasicAuthPasswordLengthError)
+  .brand("BasicAuthPassword");
 export type BasicAuthPasswordType = z.infer<typeof BasicAuthPassword>;
 
 type BasicAuthHeaderValueType = { authorization: string };

package/src/better-auth-logger.service.ts

@@ -15,10 +15,9 @@ export class BetterAuthLogger {
 
         switch (level) {
           case LogLevelEnum.error: {
-            this.logger.error({
-              ...base,
-              error: formatError(args.find((a) => a instanceof Error) ?? new Error(message)),
-            });
+            const error = formatError(args.find((a) => a instanceof Error) ?? new Error(message));
+
+            this.logger.error({ ...base, error });
             break;
           }
           case LogLevelEnum.warn: {

package/src/clock-fixed.adapter.ts

@@ -9,14 +9,14 @@ export class ClockFixedAdapter implements ClockPort {
   }
 
   nowMs() {
-    return tools.Timestamp.parse(this.value);
+    return this.value;
   }
 
   now(): ReturnType<typeof tools.Time.Now> {
     return tools.Time.Now(this.value);
   }
 
-  advanceBy(time: tools.TimeResultInterface): void {
-    this.value = tools.Timestamp.parse(this.value + time.ms);
+  advanceBy(duration: tools.Duration): void {
+    this.value = tools.Time.Now(this.value).Add(duration);
   }
 }

package/src/command-logger.service.ts

@@ -12,7 +12,6 @@ export class CommandLogger {
     commandData: Record<string, any> | undefined,
   ) {
     if (type === "subscribe") return;
-
     if (typeof commandName === "symbol") return;
 
     this.logger.info({ message: `${commandName} emitted`, metadata: commandData, ...this.base });

package/src/env-validator.service.ts

@@ -5,6 +5,8 @@ type NodeEnvironmentEnumType = z.infer<typeof NodeEnvironment>;
 type AnyZodSchema = z.ZodSchema<any, any>;
 type EnvironmentValidatorConfig = { type: unknown; schema: AnyZodSchema };
 
+export const InvalidNodeEnvironmentError = "invalid.node.environment" as const;
+
 export class EnvironmentValidator<SchemaType> {
   type: NodeEnvironmentEnumType;
   schema: z.Schema<SchemaType>;
@@ -19,7 +21,7 @@ export class EnvironmentValidator<SchemaType> {
       return;
     }
 
-    throw new Error("Invalid node environment");
+    throw new Error(InvalidNodeEnvironmentError);
   }
 
   load(): SchemaType & { type: NodeEnvironmentEnumType } {

package/src/event-store.ts

@@ -54,12 +54,8 @@ export class EventStore<AllEvents extends GenericEventSchema> {
     })) as z.infer<AllEvents>[];
   }
 
-  async saveAfter(
-    events: z.infer<AllEvents>[],
-    time: tools.TimeResultInterface,
-  ): Promise<z.infer<AllEvents>[]> {
-    await Bun.sleep(time.ms);
-
+  async saveAfter(events: z.infer<AllEvents>[], offset: tools.Duration): Promise<z.infer<AllEvents>[]> {
+    await Bun.sleep(offset.ms);
     return this.save(events);
   }
 }

package/src/event-stream.vo.ts

@@ -1,4 +1,9 @@
 import { z } from "zod/v4";
 
-export const EventStream = z.string().min(1).max(256);
+export const EventStreamInvalidError = { error: "event.stream.invalid.error" } as const;
+
+export const EventStream = z
+  .string(EventStreamInvalidError)
+  .min(1, EventStreamInvalidError)
+  .max(256, EventStreamInvalidError);
 export type EventStreamType = z.infer<typeof EventStream>;

package/src/healthcheck.service.ts

@@ -14,7 +14,8 @@ type HealthcheckResultType = {
   details: { label: prereqs.PrerequisiteLabelType; outcome: prereqs.VerifyOutcome }[];
   uptime: UptimeResultType;
   memory: { bytes: tools.Size["bytes"]; formatted: ReturnType<tools.Size["format"]> };
-} & tools.StopwatchResultType;
+  durationMs: tools.Duration["ms"];
+};
 
 type Dependencies = { Clock: ClockPort };
 
@@ -46,7 +47,7 @@ export class Healthcheck {
           bytes: MemoryConsumption.get().toBytes(),
           formatted: MemoryConsumption.get().format(tools.SizeUnit.MB),
         },
-        ...stopwatch.stop(),
+        durationMs: stopwatch.stop().ms,
       };
 
       return c.json(result, code);

package/src/http-logger.middleware.ts

@@ -70,7 +70,7 @@ export class HttpLogger {
 
       const stopwatch = new tools.Stopwatch(deps.Clock.nowMs());
       await next();
-      const { durationMs } = stopwatch.stop();
+      const duration = stopwatch.stop();
 
       const response = c.res.clone();
 
@@ -82,7 +82,7 @@ export class HttpLogger {
         method: request.method,
         url: request.url,
         status: response.status,
-        durationMs,
+        durationMs: duration.ms,
         client,
         cacheHit: response.headers.get(CacheResponse.CACHE_HIT_HEADER) === CacheHitEnum.hit,
         metadata: { response: await HttpLogger.parseJSON(response) },

package/src/rate-limit-store-node-cache.adapter.ts

@@ -5,10 +5,10 @@ import type { RateLimitStore, RateLimitStoreSubjectType } from "./rate-limit-sto
 export class RateLimitStoreNodeCache implements RateLimitStore {
   private readonly store: NodeCache;
 
-  constructor(readonly time: tools.TimeResultInterface) {
+  constructor(readonly ttl: tools.Duration) {
     this.store = new NodeCache({
-      stdTTL: this.time.seconds,
-      checkperiod: this.time.seconds,
+      stdTTL: this.ttl.seconds,
+      checkperiod: this.ttl.seconds,
       deleteOnExpire: true,
       maxKeys: 100_000,
     });

package/src/rate-limit-store.port.ts

@@ -3,7 +3,7 @@ import type * as tools from "@bgord/tools";
 export type RateLimitStoreSubjectType = string;
 
 export interface RateLimitStore {
-  readonly time: tools.TimeResultInterface;
+  readonly ttl: tools.Duration;
   get(subject: RateLimitStoreSubjectType): Promise<tools.RateLimiter | undefined>;
   set(subject: RateLimitStoreSubjectType, limiter: tools.RateLimiter): Promise<void>;
 }

package/src/shield-rate-limit.middleware.ts

@@ -23,7 +23,7 @@ export const ShieldRateLimit = (options: RateLimitShieldOptionsType, deps: Depen
     let limiter = await options.store.get(subject);
 
     if (!limiter) {
-      limiter = new tools.RateLimiter(options.store.time);
+      limiter = new tools.RateLimiter(options.store.ttl);
       options.store.set(subject, limiter);
     }
 

package/src/slower.middleware.ts

@@ -2,9 +2,9 @@ import type * as tools from "@bgord/tools";
 import { createMiddleware } from "hono/factory";
 
 export class Slower {
-  static handle = (time: tools.TimeResultInterface) =>
+  static handle = (offset: tools.Duration) =>
     createMiddleware(async (_c, next) => {
-      await Bun.sleep(time.ms);
+      await Bun.sleep(offset.ms);
       return next();
     });
 }

package/src/time-zone-offset.middleware.ts

@@ -1,13 +1,7 @@
 import * as tools from "@bgord/tools";
 import { createMiddleware } from "hono/factory";
 
-export type TimeZoneOffsetVariables = {
-  timeZoneOffset: {
-    minutes: tools.TimeResultInterface["minutes"];
-    seconds: tools.TimeResultInterface["seconds"];
-    miliseconds: tools.TimeResultInterface["ms"];
-  };
-};
+export type TimeZoneOffsetVariables = { timeZoneOffset: tools.Duration };
 
 export class TimeZoneOffset {
   static TIME_ZONE_OFFSET_HEADER_NAME = "time-zone-offset";
@@ -17,25 +11,16 @@ export class TimeZoneOffset {
       c.req.header(TimeZoneOffset.TIME_ZONE_OFFSET_HEADER_NAME),
     );
 
-    const timeZoneOffset = {
-      minutes: timeZoneOffsetMinutes,
-      seconds: tools.Time.Minutes(timeZoneOffsetMinutes).seconds,
-      miliseconds: tools.Time.Minutes(timeZoneOffsetMinutes).ms,
-    };
-
-    c.set("timeZoneOffset", timeZoneOffset);
+    c.set("timeZoneOffset", tools.Duration.Minutes(timeZoneOffsetMinutes));
 
     await next();
   });
 
-  static adjustTimestamp(
-    timestamp: tools.TimestampType,
-    timeZoneOffsetMs: tools.TimeResultInterface["ms"],
-  ): tools.TimestampType {
-    return tools.Timestamp.parse(timestamp - timeZoneOffsetMs);
+  static adjustTimestamp(timestamp: tools.TimestampType, offset: tools.Duration): tools.TimestampType {
+    return tools.Timestamp.parse(timestamp - offset.ms);
   }
 
-  static adjustDate(timestamp: tools.TimestampType, timeZoneOffsetMs: tools.TimeResultInterface["ms"]): Date {
-    return new Date(timestamp - timeZoneOffsetMs);
+  static adjustDate(timestamp: tools.TimestampType, offset: tools.Duration): Date {
+    return new Date(timestamp - offset.ms);
   }
 }

package/src/uptime.service.ts

@@ -2,18 +2,17 @@ import * as tools from "@bgord/tools";
 import type { ClockPort } from "./clock.port";
 
 export type UptimeResultType = {
-  seconds: tools.TimestampType;
+  duration: tools.Duration;
   formatted: ReturnType<(typeof tools.DateFormatters)["relative"]>;
 };
 
 export class Uptime {
-  static get(clock: ClockPort): UptimeResultType {
-    const rounding = new tools.RoundToNearest();
-
-    const uptime = tools.Time.Seconds(rounding.round(process.uptime()));
+  private static readonly rounding = new tools.RoundToNearest();
 
-    const uptimeFormatted = tools.DateFormatters.relative(clock.now().Minus(uptime).ms);
+  static get(clock: ClockPort): UptimeResultType {
+    const uptime = tools.Duration.Seconds(Uptime.rounding.round(process.uptime()));
+    const uptimeFormatted = tools.DateFormatters.relative(clock.now().Minus(uptime));
 
-    return { seconds: tools.Timestamp.parse(uptime.seconds), formatted: uptimeFormatted };
+    return { duration: uptime, formatted: uptimeFormatted };
   }
 }