@bgord/bun 1.23.12 → 1.24.1

package/src/shield-auth-hono.strategy.ts

@@ -2,8 +2,9 @@ import type hono from "hono";
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
 import type { AuthSessionReaderPort } from "./auth-session-reader.port";
+import { RequestIdentityError } from "./request-context.port";
 import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
-import { ShieldAuthStrategy, ShieldAuthStrategyError } from "./shield-auth.strategy";
+import { ShieldAuthStrategy } from "./shield-auth.strategy";
 
 type Dependencies<User, Session> = { AuthSessionReader: AuthSessionReaderPort<User, Session> };
 
@@ -27,13 +28,13 @@ export class ShieldAuthHonoStrategy<User, Session> {
     const user = c.get("user");
 
     if (this.strategy.verify(user)) return next();
-    throw new HTTPException(401, { message: ShieldAuthStrategyError.Rejected });
+    throw new HTTPException(401, { message: RequestIdentityError.Rejected });
   });
 
   reverse = createMiddleware(async (c: hono.Context, next: hono.Next) => {
     const user = c.get("user");
 
     if (this.strategy.reverse(user)) return next();
-    throw new HTTPException(403, { message: ShieldAuthStrategyError.Rejected });
+    throw new HTTPException(403, { message: RequestIdentityError.Rejected });
   });
 }

package/src/shield-auth.strategy.ts

@@ -1,13 +1,8 @@
 import type { AuthSessionReaderPort, AuthSessionType } from "./auth-session-reader.port";
-import type { HasRequestHeaders } from "./request-context.port";
+import { type HasRequestHeaders, RequestIdentityError } from "./request-context.port";
 
 type Dependencies<User, Session> = { AuthSessionReader: AuthSessionReaderPort<User, Session> };
 
-export const ShieldAuthStrategyError = {
-  Rejected: "shield.auth.rejected",
-  NotAttached: "shield.auth.not.attached",
-};
-
 export class ShieldAuthStrategy<User, Session> {
   constructor(private readonly deps: Dependencies<User, Session>) {}
 
@@ -16,12 +11,12 @@ export class ShieldAuthStrategy<User, Session> {
   }
 
   verify(user: User | null | undefined): boolean {
-    if (user === undefined) throw new Error(ShieldAuthStrategyError.NotAttached);
+    if (user === undefined) throw new Error(RequestIdentityError.NotAttached);
     return user !== null;
   }
 
   reverse(user: User | null | undefined): boolean {
-    if (user === undefined) throw new Error(ShieldAuthStrategyError.NotAttached);
+    if (user === undefined) throw new Error(RequestIdentityError.NotAttached);
     return user === null;
   }
 }

package/src/shield-maintenance.strategy.ts

@@ -1,5 +1,6 @@
 import * as tools from "@bgord/tools";
 import * as v from "valibot";
+import { PathMatcher } from "./path-matcher.service";
 import type { ReactiveConfigPort } from "./reactive-config.port";
 import type { HasRequestPath } from "./request-context.port";
 
@@ -31,12 +32,7 @@ export class ShieldMaintenanceStrategy {
   }
 
   shouldSkip(context: HasRequestPath): boolean {
-    return (
-      this.config?.skip?.some((rule) => {
-        if (rule instanceof URLPattern) return rule.test({ pathname: context.request.path });
-        return context.request.path.startsWith(rule);
-      }) ?? false
-    );
+    return PathMatcher.matches(this.config?.skip, context.request.path);
   }
 
   async evaluate(): Promise<ShieldMaintenanceResult> {

package/src/temporary-file-absolute.adapter.ts

@@ -1,15 +1,11 @@
 import * as tools from "@bgord/tools";
+import type { AtomicFileWriterPort } from "./atomic-file-writer.port";
 import type { FileCleanerPort } from "./file-cleaner.port";
-import type { FileRenamerPort } from "./file-renamer.port";
-import type { FileWriterPort } from "./file-writer.port";
-import type { NonceProviderPort } from "./nonce-provider.port";
 import type { TemporaryFilePort } from "./temporary-file.port";
 
 type Dependencies = {
+  AtomicFileWriter: AtomicFileWriterPort;
   FileCleaner: FileCleanerPort;
-  FileRenamer: FileRenamerPort;
-  FileWriter: FileWriterPort;
-  NonceProvider: NonceProviderPort;
 };
 
 export class TemporaryFileAbsoluteAdapter implements TemporaryFilePort {
@@ -19,20 +15,9 @@ export class TemporaryFileAbsoluteAdapter implements TemporaryFilePort {
   ) {}
 
   async write(filename: tools.Filename, content: File): Promise<tools.FilePathAbsolute> {
-    const temporary = tools.FilePathAbsolute.fromPartsSafe(
-      this.directory,
-      filename.withSuffix(`-part-${this.deps.NonceProvider.generate()}`),
-    );
     const final = tools.FilePathAbsolute.fromPartsSafe(this.directory, filename);
 
-    await this.deps.FileWriter.write(temporary.get(), content);
-
-    try {
-      await this.deps.FileRenamer.rename(temporary, final);
-    } catch (error) {
-      await this.deps.FileCleaner.delete(temporary);
-      throw error;
-    }
+    await this.deps.AtomicFileWriter.write(final, content);
 
     return final;
   }

package/src/timing.middleware.ts

@@ -1,4 +1,5 @@
 import type { ClockPort } from "./clock.port";
+import { EventStreamAccept } from "./event-stream-accept.service";
 import type { HasRequestHeader } from "./request-context.port";
 import { Stopwatch } from "./stopwatch.service";
 
@@ -10,7 +11,7 @@ export class TimingMiddleware {
   constructor(private readonly deps: TimingMiddlewareDependencies) {}
 
   async measure(context: HasRequestHeader, action: () => void | Promise<void>): Promise<string | null> {
-    if (TimingMiddleware.isEventStream(context.request.header("accept"))) return null;
+    if (EventStreamAccept.matches(context.request.header("accept"))) return null;
 
     const stopwatch = new Stopwatch(this.deps);
 
@@ -18,13 +19,4 @@ export class TimingMiddleware {
 
     return `total;dur=${Math.max(0, stopwatch.stop().ms)}`;
   }
-
-  private static isEventStream(accept: string | undefined): boolean {
-    if (!accept) return false;
-
-    return accept
-      .toLowerCase()
-      .split(",")
-      .some((type) => type.split(";")[0]?.trim() === "text/event-stream");
-  }
 }