gencow 0.1.251 → 0.1.253

package/core/index.js

@@ -4,6 +4,78 @@ function defineApi(api) {
 }
 
 // ../core/src/http-route.ts
+var discardedResponseSymbol = /* @__PURE__ */ Symbol.for("@gencow/core/http-route/discarded-response/v1");
+var discardedResponseCauseSymbol = /* @__PURE__ */ Symbol.for("@gencow/core/http-route/discarded-response-cause/v1");
+var outputValidationFailureSymbol = /* @__PURE__ */ Symbol.for("@gencow/core/http-route/output-validation-failure/v1");
+function getHttpRouteDiscardedResponse(value) {
+  if (!value || typeof value !== "object" && typeof value !== "function") return void 0;
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, discardedResponseSymbol);
+    const response = descriptor && "value" in descriptor ? descriptor.value : void 0;
+    return response instanceof Response ? response : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getHttpRouteDiscardedResponseCause(value) {
+  if (!value || typeof value !== "object" && typeof value !== "function") return void 0;
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, discardedResponseCauseSymbol);
+    return descriptor && "value" in descriptor ? descriptor.value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isHttpRouteOutputValidationFailure(value) {
+  if (!value || typeof value !== "object" && typeof value !== "function") return false;
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, outputValidationFailureSymbol);
+    return !!descriptor && "value" in descriptor && descriptor.value === true;
+  } catch {
+    return false;
+  }
+}
+function addDiscardedResponse(value, response) {
+  try {
+    Object.defineProperty(value, discardedResponseSymbol, {
+      configurable: false,
+      enumerable: false,
+      value: response,
+      writable: false
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function routeResultResponse(value) {
+  if (value instanceof Response) return value;
+  return value?.body instanceof Response ? value.body : void 0;
+}
+function markDroppedResponse(value, response) {
+  if (!response || routeResultResponse(value) === response) return value;
+  if (value && (typeof value === "object" || typeof value === "function")) {
+    addDiscardedResponse(value, response);
+  }
+  return value;
+}
+function markDiscardedResponseError(error, response) {
+  if (error && (typeof error === "object" || typeof error === "function")) {
+    if (addDiscardedResponse(error, response)) return error;
+  }
+  const wrapped = error instanceof HttpRouteOutputValidationError ? new HttpRouteOutputValidationError(error.message) : new Error("httpRoute output validation failed", { cause: error });
+  addDiscardedResponse(wrapped, response);
+  try {
+    Object.defineProperty(wrapped, discardedResponseCauseSymbol, {
+      configurable: false,
+      enumerable: false,
+      value: error,
+      writable: false
+    });
+  } catch {
+  }
+  return wrapped;
+}
 function hasStandardSchema(schema) {
   return !!schema && typeof schema === "object" && "~standard" in schema && !!schema["~standard"] && typeof schema["~standard"].validate === "function";
 }
@@ -65,10 +137,28 @@ async function buildInputFromRequest(method, req) {
 }
 async function maybeValidateRouteOutput(result, outputSchema) {
   if (!outputSchema) return result;
-  const isSuccessStatus = result?.status === void 0 || result.status < 400;
-  if (!isSuccessStatus) return result;
-  const validatedBody = await validateOutput(outputSchema, result?.body);
-  return { status: result?.status, headers: result?.headers, body: validatedBody };
+  const source = routeResultResponse(result);
+  try {
+    const isSuccessStatus = result instanceof Response ? result.status < 400 : result?.status === void 0 || result.status < 400;
+    if (!isSuccessStatus) return result;
+    const response = result instanceof Response ? result : void 0;
+    const validatedBody = await validateOutput(
+      outputSchema,
+      response ? response.body : result?.body
+    );
+    if (response) {
+      if (validatedBody === response.body) return result;
+      return markDroppedResponse(
+        { status: response.status, headers: response.headers, body: validatedBody },
+        source
+      );
+    }
+    const normalized = { status: result?.status, headers: result?.headers, body: validatedBody };
+    return markDroppedResponse(normalized, source);
+  } catch (error) {
+    if (source) throw markDiscardedResponseError(error, source);
+    throw error;
+  }
 }
 function composeRouteMiddlewares(middlewares, handler, inputSchema, outputSchema, inputValidationIndex, outputValidationIndex) {
   return async (initialContext, initialInput, request) => {
@@ -210,15 +300,7 @@ var HttpRouteBuilderImpl = class _HttpRouteBuilderImpl {
     const inputSchema = this.inputSchema;
     const outputSchema = this.outputSchema;
     const inputErrorMapper = this.inputErrorMapper;
-    const runRoute = composeRouteMiddlewares(
-      this.middlewares,
-      handler,
-      inputSchema,
-      outputSchema,
-      this.inputValidationIndex,
-      this.outputValidationIndex
-    );
-    const wrappedHandler = async (ctx, req) => {
+    const invokeRoute = async (ctx, req) => {
       let normalizedInput;
       try {
         normalizedInput = inputSchema ? await buildInputFromRequest(method, req) : void 0;
@@ -231,14 +313,37 @@ var HttpRouteBuilderImpl = class _HttpRouteBuilderImpl {
       }
       let result;
       try {
-        result = await runRoute(ctx, normalizedInput, req);
+        result = await composeRouteMiddlewares(
+          this.middlewares,
+          handler,
+          inputSchema,
+          outputSchema,
+          this.inputValidationIndex,
+          this.outputValidationIndex
+        )(ctx, normalizedInput, req);
       } catch (err) {
         if (err instanceof HttpRouteInputValidationError) {
           if (inputErrorMapper) return await inputErrorMapper(err.issues);
           return { status: 400, body: { error: err.message } };
         }
         if (err instanceof HttpRouteOutputValidationError) {
-          return { status: 500, body: { error: `Output validation failed: ${err.message}` } };
+          const discardedResponse = getHttpRouteDiscardedResponse(err);
+          const failure = {
+            status: 500,
+            body: {
+              error: discardedResponse ? "Output validation failed" : `Output validation failed: ${err.message}`
+            }
+          };
+          if (discardedResponse) {
+            addDiscardedResponse(failure, discardedResponse);
+            Object.defineProperty(failure, outputValidationFailureSymbol, {
+              configurable: false,
+              enumerable: false,
+              value: true,
+              writable: false
+            });
+          }
+          return failure;
         }
         throw err;
       }
@@ -248,7 +353,7 @@ var HttpRouteBuilderImpl = class _HttpRouteBuilderImpl {
       method,
       path: routePath,
       isPublic,
-      handler: wrappedHandler,
+      handler: invokeRoute,
       middlewares: [...this.middlewares],
       inputValidationIndex: this.inputValidationIndex,
       outputValidationIndex: this.outputValidationIndex,
@@ -1668,7 +1773,9 @@ async function validateWithSchema(schema, value, options) {
     }
     throw new GencowValidationError("Validation failed");
   }
-  throw new Error("procedure.query / procedure.mutation / procedure.internal only supports Standard Schema v1 validators");
+  throw new Error(
+    "procedure.query / procedure.mutation / procedure.internal only supports Standard Schema v1 validators"
+  );
 }
 function composeMiddlewares(middlewares, handler, inputSchema, outputSchema, inputValidationIndex, outputValidationIndex) {
   return async (initialContext, initialInput) => {
@@ -1798,14 +1905,14 @@ var GencowProcedureBuilderImpl = class _GencowProcedureBuilderImpl {
     if (!this.procedureName) {
       throw new Error("Procedure name is required. Call .name(...) before .handler(...)");
     }
-    const run = composeMiddlewares(
+    const run = (context, input) => composeMiddlewares(
       this.middlewares,
       handler,
       this.inputSchema,
       this.outputSchema,
       this.inputValidationIndex,
       this.outputValidationIndex
-    );
+    )(context, input);
     return {
       kind: this.kind,
       name: this.procedureName,
@@ -6148,6 +6255,8 @@ export {
   eqRlsContextColumn,
   filterTenantRuntimeEnvVars,
   formatBytes,
+  getHttpRouteDiscardedResponse,
+  getHttpRouteDiscardedResponseCause,
   getJobAdmissionStatus,
   getMinuteBucketStart,
   getMsUntilNextMinute,
@@ -6167,6 +6276,7 @@ export {
   hasMapSessionToContext,
   inferTableNameFromColumn,
   isCronJobsBuilder,
+  isHttpRouteOutputValidationFailure,
   isJobAdmissionError,
   isJobAdmissionKillSwitchActive,
   isReservedTenantRuntimeEnvKey,