@bgord/bun 1.4.23 → 1.4.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.4.23",
+  "version": "1.4.24",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@axiomhq/winston": "1.3.1",
-    "@bgord/tools": "1.1.20",
+    "@bgord/tools": "1.2.0",
     "@hono/ua-blocker": "0.1.21",
     "better-auth": "1.4.7",
     "croner": "9.1.0",

package/readme.md

@@ -88,6 +88,7 @@ src/
 ├── file-cleaner.port.ts
 ├── file-draft-zip.service.ts
 ├── file-draft.service.ts
+├── file-etag.vo.ts
 ├── file-hash-noop.adapter.ts
 ├── file-hash-sha256-bun.adapter.ts
 ├── file-hash.port.ts

package/src/file-etag.vo.ts

@@ -0,0 +1,13 @@
+import { z } from "zod/v4";
+
+export const FileEtagError = { Type: "file.etag.type", InvalidHex: "file.etag.invalid.hex" } as const;
+
+// 64 hex chars allowed
+const CHARS_WHITELIST = /^[a-fA-F0-9]{64}$/;
+
+export const FileEtag = z
+  .string(FileEtagError.Type)
+  .regex(CHARS_WHITELIST, FileEtagError.InvalidHex)
+  .brand("FileEtag");
+
+export type FileEtagType = z.infer<typeof FileEtag>;

package/src/file-hash-noop.adapter.ts

@@ -1,10 +1,11 @@
 import * as tools from "@bgord/tools";
+import { FileEtag } from "./file-etag.vo";
 import type { FileHashPort } from "./file-hash.port";
 
 export class FileHashNoopAdapter implements FileHashPort {
   async hash(_path: tools.FilePathAbsolute | tools.FilePathRelative) {
     return {
-      etag: "noop",
+      etag: FileEtag.parse("0000000000000000000000000000000000000000000000000000000000000000"),
       size: tools.Size.fromBytes(10),
       lastModified: tools.Timestamp.fromNumber(1000),
       mime: tools.MIMES.text,

package/src/file-hash-sha256-bun.adapter.ts

@@ -1,4 +1,5 @@
 import * as tools from "@bgord/tools";
+import { FileEtag } from "./file-etag.vo";
 import type { FileHashPort } from "./file-hash.port";
 
 export class FileHashSha256BunAdapter implements FileHashPort {
@@ -8,10 +9,9 @@ export class FileHashSha256BunAdapter implements FileHashPort {
 
     const arrayBuffer = await file.arrayBuffer();
     const digest = await crypto.subtle.digest("SHA-256", arrayBuffer);
-    const etag = Buffer.from(digest).toString("hex");
 
     return {
-      etag,
+      etag: FileEtag.parse(Buffer.from(digest).toString("hex")),
       size: tools.Size.fromBytes(arrayBuffer.byteLength),
       lastModified: tools.Timestamp.fromNumber(file.lastModified),
       mime: tools.Mime.fromExtension(extension),

package/src/file-hash.port.ts

@@ -1,7 +1,8 @@
 import type * as tools from "@bgord/tools";
+import type { FileEtagType } from "./file-etag.vo";
 
 export type FileHashResult = {
-  etag: string;
+  etag: FileEtagType;
   size: tools.Size;
   lastModified: tools.Timestamp;
   mime: tools.Mime;

package/src/index.ts

@@ -59,6 +59,7 @@ export * from "./file-cleaner-bun-forgiving.adapter";
 export * from "./file-cleaner-noop.adapter";
 export * from "./file-draft.service";
 export * from "./file-draft-zip.service";
+export * from "./file-etag.vo";
 export * from "./file-hash.port";
 export * from "./file-hash-noop.adapter";
 export * from "./file-hash-sha256-bun.adapter";

package/src/mailer.vo.ts

@@ -27,12 +27,4 @@ export const EmailContentHtml = z
   .max(10_000, EmailContentHtmlError.Invalid);
 export type EmailContentHtmlType = z.infer<typeof EmailContentHtml>;
 
-export const EmailFromError = { Invalid: "email.from.invalid" } as const;
-export const EmailFrom = z.email(EmailFromError.Invalid);
-export type EmailFromType = z.infer<typeof EmailFrom>;
-
-export const EmailToError = { Invalid: "email.to.invalid" } as const;
-export const EmailTo = z.email(EmailToError.Invalid);
-export type EmailToType = z.infer<typeof EmailTo>;
-
 export type EmailAttachmentType = { filename: string; path: string };

package/src/prerequisites/outside-connectivity.ts

@@ -8,7 +8,7 @@ export class PrerequisiteOutsideConnectivity implements prereqs.Prerequisite {
   readonly label: prereqs.PrerequisiteLabelType;
   readonly enabled?: boolean = true;
 
-  private readonly url = "https://google.com";
+  private static readonly URL = tools.UrlWithoutSlash.parse("https://google.com");
   readonly timeout: tools.Duration;
 
   constructor(config: prereqs.PrerequisiteConfigType & { timeout?: tools.Duration }) {
@@ -25,7 +25,7 @@ export class PrerequisiteOutsideConnectivity implements prereqs.Prerequisite {
       if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
       const response = await Timeout.cancellable(
-        (signal: AbortSignal) => fetch(this.url, { method: "HEAD", signal }),
+        (signal: AbortSignal) => fetch(PrerequisiteOutsideConnectivity.URL, { method: "HEAD", signal }),
         this.timeout,
       );
 

package/src/remote-file-storage-noop.adapter.ts

@@ -1,5 +1,6 @@
 import * as tools from "@bgord/tools";
 import type { ClockPort } from "./clock.port";
+import { FileEtag } from "./file-etag.vo";
 import type { LoggerPort } from "./logger.port";
 import type {
   RemoteFileStoragePort,
@@ -8,9 +9,10 @@ import type {
   RemotePutFromPathResult,
 } from "./remote-file-storage.port";
 
-type RemoteFileStorageNoopConfig = { root: tools.DirectoryPathAbsoluteType; publicBaseUrl?: string };
 type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
 
+type RemoteFileStorageNoopConfig = { root: tools.DirectoryPathAbsoluteType; publicBaseUrl?: string };
+
 export class RemoteFileStorageNoopAdapter implements RemoteFileStoragePort {
   private readonly base = { component: "infra", operation: "RemoteFileStorageNoopAdapter" };
 
@@ -32,7 +34,7 @@ export class RemoteFileStorageNoopAdapter implements RemoteFileStoragePort {
     });
 
     return {
-      etag: "noop",
+      etag: FileEtag.parse("0000000000000000000000000000000000000000000000000000000000000000"),
       size: tools.Size.fromBytes(10),
       lastModified: this.deps.Clock.now(),
       mime: tools.MIMES.text,

package/src/shield-captcha-recaptcha.adapter.ts

@@ -1,3 +1,4 @@
+import * as tools from "@bgord/tools";
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
 import type { RecaptchaSecretKeyType } from "./recaptcha-secret-key.vo";
@@ -9,6 +10,10 @@ export type RecaptchaResultType = { success: boolean; score: number };
 export const AccessDeniedRecaptchaError = new HTTPException(403, { message: "access_denied_recaptcha" });
 
 export class ShieldCaptchaRecaptchaAdapter implements ShieldPort {
+  private static readonly URL = tools.UrlWithoutSlash.parse(
+    "https://www.google.com/recaptcha/api/siteverify",
+  );
+
   constructor(private readonly config: RecaptchaVerifierConfigType) {}
 
   verify = createMiddleware(async (c, next) => {
@@ -26,7 +31,7 @@ export class ShieldCaptchaRecaptchaAdapter implements ShieldPort {
 
       const params = new URLSearchParams({ secret: this.config.secretKey, response: token, remoteip });
 
-      const response = await fetch("https://www.google.com/recaptcha/api/siteverify", {
+      const response = await fetch(ShieldCaptchaRecaptchaAdapter.URL, {
         method: "POST",
         headers: { "Content-Type": "application/x-www-form-urlencoded" },
         body: params,

package/src/timekeeper-google.adapter.ts

@@ -2,7 +2,7 @@ import * as tools from "@bgord/tools";
 import type { TimekeeperPort } from "./timekeeper.port";
 
 export class TimekeeperGoogleAdapter implements TimekeeperPort {
-  static URL = "https://www.google.com/generate_204";
+  static URL = tools.UrlWithoutSlash.parse("https://www.google.com/generate_204");
 
   async get(signal?: AbortSignal) {
     try {