@beignet/core 0.0.50 → 0.0.52

package/src/server/server.ts

@@ -204,15 +204,18 @@ export type CreateServerOptions<
    * `ports.devtools`) when one is installed.
    *
    * Pass `false` to disable headers and event recording. Context factories
-   * still receive `requestId` and `trace` arguments.
+   * still receive `requestId` and `trace` arguments, and request-scoped
+   * correlation remains available to ambient audit wrappers.
    */
   instrumentation?: ServerInstrumentationOptions<Ctx> | false;
   /**
-   * Whether route-owned responses are validated against the contract's
-   * declared statuses and response schemas before they are sent.
+   * Whether route-owned responses are parsed against the contract's declared
+   * statuses and response schemas before they are sent. The parsed schema
+   * output becomes the response body.
    *
-   * Disable this to trade response guarantees for throughput, mirroring the
-   * client-side `validateResponses` option.
+   * Disable this to send route-owned handler bodies as-is without validation,
+   * unknown-key stripping, or transforms, mirroring the client-side
+   * `validateResponses` option.
    *
    * @default true
    */
@@ -407,9 +410,7 @@ export async function createServer<
     options.instrumentation,
   );
   const hooks = [
-    ...(instrumentation.hook
-      ? [instrumentation.hook as ServerHook<Ctx, FinalPorts>]
-      : []),
+    instrumentation.hook as ServerHook<Ctx, FinalPorts>,
     ...((options.hooks ?? []) as ServerHook<Ctx, FinalPorts>[]),
   ];
   const contracts = options.routes ? contractsFromRoutes(options.routes) : [];
@@ -669,24 +670,6 @@ export async function createServer<
     registryNeedsSort = true;
   };
 
-  const createBuilder = <C extends HttpContractConfig>(
-    contract: C,
-    shouldRegister: boolean,
-  ): RouteBuilder<Ctx, C> => ({
-    handle: (fn) => {
-      const wrapped = buildHandler(
-        options,
-        finalPorts,
-        contextRuntime,
-        contract,
-        fn,
-        hooks,
-      );
-      if (shouldRegister) registerRoute(contract, fn);
-      return wrapped;
-    },
-  });
-
   if (options.routes) {
     try {
       for (const route of options.routes) {
@@ -917,7 +900,58 @@ export async function createServer<
     api,
     route: (contractLike) => {
       const contract = resolveContract(contractLike);
-      return createBuilder(contract, true);
+      return {
+        handle: (fn) => {
+          const wrapped = buildHandler(
+            options,
+            finalPorts,
+            contextRuntime,
+            contract,
+            fn,
+            hooks,
+          );
+          registerRoute(contract, fn);
+          const compiled = compilePath(contract.path);
+
+          return async (req: HttpRequestLike) => {
+            const method = req.method.toUpperCase();
+            let url: URL;
+            try {
+              url = parseHttpRequestUrl(req.url);
+            } catch (error) {
+              return await executeFallback(
+                {
+                  contract: fallbackContract("invalidRequestUrl", method, "/"),
+                  handler: async () => {
+                    throw error;
+                  },
+                },
+                req,
+                {},
+              );
+            }
+
+            const requestMethod = method;
+            const contractMethod = contract.method.toUpperCase();
+            const methodMatches =
+              requestMethod === contractMethod ||
+              (requestMethod === "HEAD" && contractMethod === "GET");
+            if (!methodMatches || !compiled.pattern.test(url.pathname)) {
+              const pathname = url.pathname || "/";
+              return await executeFallback(
+                {
+                  contract: fallbackContract("notFound", method, pathname),
+                  handler: notFoundHandler,
+                },
+                req,
+                {},
+              );
+            }
+
+            return await wrapped(req);
+          };
+        },
+      };
     },
     rawRoute: (init) => ({
       handle: (fn) => {

package/src/testing/index.ts

@@ -15,7 +15,7 @@ import {
 } from "../notifications/index.js";
 import {
   createMemoryOutbox,
-  enqueueEvent,
+  createOutboxEventRecorder,
   type MemoryOutboxPort,
 } from "../outbox/index.js";
 import {
@@ -489,10 +489,17 @@ export function createTestPorts<
               outbox: MemoryOutboxPort;
             }
           ).outbox;
-          for (const entry of events.entries()) {
-            await enqueueEvent(outbox, entry.event, entry.payload);
-          }
-          events.clear();
+          const outboxRecorder = createOutboxEventRecorder(outbox);
+          await events.flush({
+            publish(event, payload, options) {
+              return outboxRecorder.record(event, payload, options);
+            },
+            subscribe() {
+              throw new Error(
+                "The test outbox event publisher does not support subscriptions.",
+              );
+            },
+          });
         }
         await transactionOptions?.afterCommit?.(tx);
       },
@@ -619,18 +626,19 @@ function completeTestPortOverrides<Ports extends AnyPorts>(
 
 function resolveBufferedTransactionEvents(
   tx: unknown,
-): Pick<BufferedDomainEventRecorder, "entries" | "clear"> {
+): Pick<BufferedDomainEventRecorder, "entries" | "clear" | "flush"> {
   const events =
     tx && typeof tx === "object"
       ? (tx as { events?: unknown }).events
       : undefined;
   const recorder = events as
-    | Partial<Pick<BufferedDomainEventRecorder, "entries" | "clear">>
+    | Partial<Pick<BufferedDomainEventRecorder, "entries" | "clear" | "flush">>
     | undefined;
   if (
     !recorder ||
     typeof recorder.entries !== "function" ||
-    typeof recorder.clear !== "function"
+    typeof recorder.clear !== "function" ||
+    typeof recorder.flush !== "function"
   ) {
     throw new Error(
       "createTestPorts transaction.outbox requires tx.events to be a buffered domain event recorder. " +
@@ -638,7 +646,10 @@ function resolveBufferedTransactionEvents(
     );
   }
 
-  return recorder as Pick<BufferedDomainEventRecorder, "entries" | "clear">;
+  return recorder as Pick<
+    BufferedDomainEventRecorder,
+    "entries" | "clear" | "flush"
+  >;
 }
 
 /**

package/src/uploads/index.ts

@@ -968,29 +968,47 @@ export function createUploadRouter<Ctx>(
             },
           });
         }
-        const object = needsUploadBodyVerification(upload, file)
+        const verifyBody = needsUploadBodyVerification(upload, file);
+        const objectBody = verifyBody
           ? await options.storage.get(file.key)
+          : null;
+        const object = verifyBody
+          ? objectBody
           : await options.storage.stat(file.key);
         if (!object) {
           throw new UploadObjectNotFoundError({
             message: `Uploaded object "${file.key}" was not found.`,
           });
         }
-        assertStoredObject(upload, file, object);
-        const verified = await verifyStoredUploadFile(upload, file, object);
-        const completedObject = storageObjectMetadata(object);
-        const completedFile = {
-          ...file,
-          ...(verified.checksum ? { checksum: verified.checksum } : {}),
-          object: completedObject,
-        };
-        await assertVerifiedFile(upload, {
-          ctx,
-          metadata,
-          file: completedFile,
-          storage: options.storage,
-        });
-        files.push(completedFile);
+        let operationFailed = false;
+        try {
+          assertStoredObject(upload, file, object);
+          const verified = await verifyStoredUploadFile(upload, file, object);
+          const completedObject = storageObjectMetadata(object);
+          const completedFile = {
+            ...file,
+            ...(verified.checksum ? { checksum: verified.checksum } : {}),
+            object: completedObject,
+          };
+          await assertVerifiedFile(upload, {
+            ctx,
+            metadata,
+            file: completedFile,
+            storage: options.storage,
+          });
+          files.push(completedFile);
+        } catch (error) {
+          operationFailed = true;
+          throw error;
+        } finally {
+          if (objectBody && !objectBody.bodyUsed) {
+            if (operationFailed) {
+              await objectBody.cancel().catch(() => undefined);
+            } else {
+              await objectBody.cancel();
+            }
+          }
+        }
       }
 
       const result = await upload.onComplete?.({ ctx, metadata, files });