@temporary-name/server 1.9.3-alpha.21b0289906d115f2f3db137ea407a6d8d50b5ad6 → 1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827

package/dist/shared/{server.DmGicgbG.mjs → server.B7tjiDal.mjs}

@@ -1,7 +1,7 @@
-import { isContractProcedure, mergePrefix, mergeErrorMap, enhanceRoute, validateORPCError, ValidationError } from '@temporary-name/contract';
-import { resolveMaybeOptionalOptions, ORPCError, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan } from '@temporary-name/shared';
+import { mergePrefix, enhanceRoute, ValidationError } from '@temporary-name/contract';
+import { resolveMaybeOptionalOptions, toArray, value, runWithSpan, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan, ORPCError } from '@temporary-name/shared';
 import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
-import { safeParseAsync } from '@temporary-name/zod';
+import { safeDecodeAsync, safeEncodeAsync } from '@temporary-name/zod';
 
 function isStartWithMiddlewares(middlewares, compare) {
   if (compare.length > middlewares.length) {
@@ -27,7 +27,7 @@ function addMiddleware(middlewares, addition) {
   return [...middlewares, addition];
 }
 
-class Procedure {
+class Contract {
   /**
    * This property holds the defined options.
    */
@@ -36,55 +36,17 @@ class Procedure {
     this["~orpc"] = def;
   }
 }
+class Procedure extends Contract {
+}
 function isProcedure(item) {
-  if (item instanceof Procedure) {
-    return true;
-  }
-  return isContractProcedure(item) && "middlewares" in item["~orpc"] && "handler" in item["~orpc"];
+  return item instanceof Procedure || // This is so we'll return true for Proxy-wrapped Procedures e.g. as returned by `callable`
+  (typeof item === "object" || typeof item === "function") && item !== null && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "route" in item["~orpc"] && "meta" in item["~orpc"] && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
 }
 
 function mergeCurrentContext(context, other) {
   return { ...context, ...other };
 }
 
-function createORPCErrorConstructorMap(errors) {
-  const proxy = new Proxy(errors, {
-    get(target, code) {
-      if (typeof code !== "string") {
-        return Reflect.get(target, code);
-      }
-      const item = (...rest) => {
-        const options = resolveMaybeOptionalOptions(rest);
-        const config = errors[code];
-        return new ORPCError(code, {
-          defined: Boolean(config),
-          status: config?.status,
-          message: options.message ?? config?.message,
-          data: options.data,
-          cause: options.cause
-        });
-      };
-      return item;
-    }
-  });
-  return proxy;
-}
-
-const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
-function setHiddenRouterContract(router, contract) {
-  return new Proxy(router, {
-    get(target, key) {
-      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
-        return contract;
-      }
-      return Reflect.get(target, key);
-    }
-  });
-}
-function getHiddenRouterContract(router) {
-  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
-}
-
 function getRouter(router, path) {
   let current = router;
   for (let i = 0; i < path.length; i++) {
@@ -147,7 +109,6 @@ function enhanceRouter(router, options) {
     const enhanced2 = new Procedure({
       ...router["~orpc"],
       route: enhanceRoute(router["~orpc"].route, options),
-      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
       middlewares: newMiddlewares,
       inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
       outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
@@ -161,21 +122,19 @@ function enhanceRouter(router, options) {
   return enhanced;
 }
 function traverseContractProcedures(options, callback, lazyOptions = []) {
-  let currentRouter = options.router;
-  const hiddenContract = getHiddenRouterContract(options.router);
-  if (hiddenContract !== void 0) {
-    currentRouter = hiddenContract;
-  }
+  const currentRouter = options.router;
   if (isLazy(currentRouter)) {
     lazyOptions.push({
       router: currentRouter,
       path: options.path
     });
-  } else if (isContractProcedure(currentRouter)) {
+  } else if (currentRouter instanceof Contract) {
     callback({
       contract: currentRouter,
       path: options.path
     });
+  } else if (typeof currentRouter === "string") {
+    throw new Error("Unexpected: got string instead of router");
   } else {
     for (const key in currentRouter) {
       traverseContractProcedures(
@@ -228,7 +187,6 @@ function lazyInternal(loader, meta = {}) {
 function lazy(prefix, loader) {
   return enhanceRouter(lazyInternal(loader), {
     middlewares: [],
-    errorMap: {},
     dedupeLeadingMiddlewares: true,
     prefix
   });
@@ -254,64 +212,44 @@ function createProcedureClient(lazyableProcedure, ...rest) {
     const { default: procedure } = await unlazy(lazyableProcedure);
     const clientContext = callerOptions?.context ?? {};
     const context = await value(options.context ?? {}, clientContext);
-    const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
-    const validateError = async (e) => {
-      if (e instanceof ORPCError) {
-        return await validateORPCError(procedure["~orpc"].errorMap, e);
+    const output = await runWithSpan({ name: "call_procedure", signal: callerOptions?.signal }, (span) => {
+      span?.setAttribute("procedure.path", [...path]);
+      return executeProcedureInternal(procedure, input, {
+        context,
+        path,
+        procedure,
+        request: callerOptions?.request,
+        signal: callerOptions?.signal,
+        lastEventId: callerOptions?.lastEventId
+      });
+    });
+    if (isAsyncIteratorObject(output)) {
+      if (output instanceof HibernationEventIterator) {
+        return output;
       }
-      return e;
-    };
-    try {
-      const output = await runWithSpan({ name: "call_procedure", signal: callerOptions?.signal }, (span) => {
-        span?.setAttribute("procedure.path", [...path]);
-        return intercept(
-          toArray(options.interceptors),
+      return overlayProxy(
+        output,
+        mapEventIterator(
+          asyncIteratorWithSpan(
+            { name: "consume_event_iterator_output", signal: callerOptions?.signal },
+            output
+          ),
           {
-            context,
-            input,
-            errors,
-            path,
-            procedure,
-            request: callerOptions?.request,
-            signal: callerOptions?.signal,
-            lastEventId: callerOptions?.lastEventId
-          },
-          (interceptorOptions) => {
-            const { input: input2, ...opts } = interceptorOptions;
-            return executeProcedureInternal(interceptorOptions.procedure, input2, opts);
+            value: (v) => v,
+            error: async (e) => e
           }
-        );
-      });
-      if (isAsyncIteratorObject(output)) {
-        if (output instanceof HibernationEventIterator) {
-          return output;
-        }
-        return overlayProxy(
-          output,
-          mapEventIterator(
-            asyncIteratorWithSpan(
-              { name: "consume_event_iterator_output", signal: callerOptions?.signal },
-              output
-            ),
-            {
-              value: (v) => v,
-              error: (e) => validateError(e)
-            }
-          )
-        );
-      }
-      return output;
-    } catch (e) {
-      throw await validateError(e);
+        )
+      );
     }
+    return output;
   };
 }
 async function validateInput(procedure, input) {
   const schemas = procedure["~orpc"].schemas;
   return runWithSpan({ name: "validate_input" }, async () => {
-    const resultBody = await safeParseAsync(schemas.bodySchema, input.body);
-    const resultPath = await safeParseAsync(schemas.pathSchema, input.path);
-    const resultQuery = await safeParseAsync(schemas.querySchema, input.query);
+    const resultBody = await safeDecodeAsync(schemas.bodySchema, input.body, { parseType: "body" });
+    const resultPath = await safeDecodeAsync(schemas.pathSchema, input.path, { parseType: "path" });
+    const resultQuery = await safeDecodeAsync(schemas.querySchema, input.query, { parseType: "query" });
     const issues = [];
     if (!resultBody.success) {
       issues.push(...resultBody.error.issues.map((i) => ({ ...i, path: ["body", ...i.path] })));
@@ -349,7 +287,7 @@ async function validateOutput(procedure, output) {
     return output;
   }
   return runWithSpan({ name: "validate_output" }, async () => {
-    const result = await safeParseAsync(schema, output);
+    const result = await safeEncodeAsync(schema, output, { parseType: "output" });
     if (!result.success) {
       throw new ORPCError("INTERNAL_SERVER_ERROR", {
         message: "Output validation failed",
@@ -390,6 +328,9 @@ async function executeProcedureInternal(procedure, input, options) {
             const nextContext = nextOptions?.context ?? {};
             return {
               output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
+              // NB: Pretty sure this isn't used (or meant to be used) at runtime, it's just there
+              // to get type inference in the builder (via the caller returning the output of next() in
+              // the middleware function)
               context: nextContext
             };
           }
@@ -410,4 +351,4 @@ async function executeProcedureInternal(procedure, input, options) {
   return next(0, options.context, input);
 }
 
-export { LAZY_SYMBOL as L, Procedure as P, addMiddleware as a, isLazy as b, createProcedureClient as c, getRouter as d, enhanceRouter as e, createORPCErrorConstructorMap as f, getLazyMeta as g, lazy as h, isProcedure as i, middlewareOutputFn as j, isStartWithMiddlewares as k, lazyInternal as l, mergeCurrentContext as m, mergeMiddlewares as n, getHiddenRouterContract as o, createAccessibleLazyRouter as p, unlazyRouter as q, resolveContractProcedures as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u };
+export { Contract as C, LAZY_SYMBOL as L, Procedure as P, addMiddleware as a, isLazy as b, createProcedureClient as c, getRouter as d, enhanceRouter as e, lazy as f, getLazyMeta as g, middlewareOutputFn as h, isProcedure as i, isStartWithMiddlewares as j, mergeMiddlewares as k, lazyInternal as l, mergeCurrentContext as m, createAccessibleLazyRouter as n, unlazyRouter as o, resolveContractProcedures as r, traverseContractProcedures as t, unlazy as u };

package/dist/shared/server.C1RJffw4.mjs

@@ -0,0 +1,30 @@
+import { parse, serialize } from 'cookie';
+
+function setCookie(headers, name, value, options = {}) {
+  if (headers === void 0) {
+    return;
+  }
+  const cookieString = serialize(name, value, {
+    path: "/",
+    ...options
+  });
+  headers.append("Set-Cookie", cookieString);
+}
+function getCookie(headers, name, options = {}) {
+  if (headers === void 0) {
+    return void 0;
+  }
+  const cookieHeader = headers.get("cookie");
+  if (cookieHeader === null) {
+    return void 0;
+  }
+  return parse(cookieHeader, options)[name];
+}
+function deleteCookie(headers, name, options = {}) {
+  return setCookie(headers, name, "", {
+    ...options,
+    maxAge: 0
+  });
+}
+
+export { deleteCookie as d, getCookie as g, setCookie as s };

package/dist/shared/server.CQIFwyhc.mjs

@@ -0,0 +1,40 @@
+import { isObject } from '@temporary-name/shared';
+
+function jsonSerialize(data, hasBlobRef = { value: false }) {
+  if (data instanceof Blob) {
+    hasBlobRef.value = true;
+    return [data, hasBlobRef.value];
+  }
+  if (data instanceof Set) {
+    return jsonSerialize(Array.from(data), hasBlobRef);
+  }
+  if (data instanceof Map) {
+    return jsonSerialize(Array.from(data.entries()), hasBlobRef);
+  }
+  if (Array.isArray(data)) {
+    const json = data.map((v) => v === void 0 ? null : jsonSerialize(v, hasBlobRef)[0]);
+    return [json, hasBlobRef.value];
+  }
+  if (isObject(data)) {
+    const json = {};
+    for (const k in data) {
+      if (k === "toJSON" && typeof data[k] === "function") {
+        continue;
+      }
+      json[k] = jsonSerialize(data[k], hasBlobRef)[0];
+    }
+    return [json, hasBlobRef.value];
+  }
+  if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
+    return [data.toString(), hasBlobRef.value];
+  }
+  if (data instanceof Date) {
+    return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
+  }
+  if (Number.isNaN(data)) {
+    return [null, hasBlobRef.value];
+  }
+  return [data, hasBlobRef.value];
+}
+
+export { jsonSerialize as j };