@temporary-name/server 1.9.3-alpha.03f5d40e5b399f85012c2fb4e98167e26d551d36 → 1.9.3-alpha.102eab0800942eb736f7669a86c850ebfdfcd4a3

package/dist/shared/server.DcfsPloY.mjs

@@ -1,202 +0,0 @@
-import { validateORPCError, ValidationError } from '@temporary-name/contract';
-import { resolveMaybeOptionalOptions, ORPCError, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan } from '@temporary-name/shared';
-import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
-import { safeParseAsync } from '@temporary-name/zod';
-
-const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
-function lazy(loader, meta = {}) {
-  return {
-    [LAZY_SYMBOL]: {
-      loader,
-      meta
-    }
-  };
-}
-function isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
-}
-function getLazyMeta(lazied) {
-  return lazied[LAZY_SYMBOL].meta;
-}
-function unlazy(lazied) {
-  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
-}
-
-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;
-}
-
-function middlewareOutputFn(output) {
-  return { output, context: {} };
-}
-
-function createProcedureClient(lazyableProcedure, ...rest) {
-  const options = resolveMaybeOptionalOptions(rest);
-  return async (...[input, callerOptions]) => {
-    const path = toArray(options.path);
-    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);
-      }
-      return e;
-    };
-    try {
-      const output = await runWithSpan({ name: "call_procedure", signal: callerOptions?.signal }, (span) => {
-        span?.setAttribute("procedure.path", [...path]);
-        return intercept(
-          toArray(options.interceptors),
-          {
-            context,
-            input,
-            // input only optional when it undefinable so we can safely cast it
-            errors,
-            path,
-            procedure,
-            signal: callerOptions?.signal,
-            lastEventId: callerOptions?.lastEventId
-          },
-          (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
-        );
-      });
-      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);
-    }
-  };
-}
-async function validateInput(procedure, input) {
-  const schema = procedure["~orpc"].inputSchema;
-  if (!schema) {
-    return input;
-  }
-  return runWithSpan({ name: "validate_input" }, async () => {
-    const result = await safeParseAsync(schema, input);
-    if (!result.success) {
-      throw new ORPCError("BAD_REQUEST", {
-        message: "Input validation failed",
-        data: {
-          issues: result.error.issues
-        },
-        cause: new ValidationError({
-          message: "Input validation failed",
-          issues: result.error.issues,
-          data: input
-        })
-      });
-    }
-    return result.data;
-  });
-}
-async function validateOutput(procedure, output) {
-  const schema = procedure["~orpc"].outputSchema;
-  if (!schema) {
-    return output;
-  }
-  return runWithSpan({ name: "validate_output" }, async () => {
-    const result = await safeParseAsync(schema, output);
-    if (!result.success) {
-      throw new ORPCError("INTERNAL_SERVER_ERROR", {
-        message: "Output validation failed",
-        cause: new ValidationError({
-          message: "Output validation failed",
-          issues: result.error.issues,
-          data: output
-        })
-      });
-    }
-    return result.data;
-  });
-}
-async function executeProcedureInternal(procedure, options) {
-  const middlewares = procedure["~orpc"].middlewares;
-  const inputValidationIndex = Math.min(
-    Math.max(0, procedure["~orpc"].inputValidationIndex),
-    middlewares.length
-  );
-  const outputValidationIndex = Math.min(
-    Math.max(0, procedure["~orpc"].outputValidationIndex),
-    middlewares.length
-  );
-  const next = async (index, context, input) => {
-    let currentInput = input;
-    if (index === inputValidationIndex) {
-      currentInput = await validateInput(procedure, currentInput);
-    }
-    const mid = middlewares[index];
-    const output = mid ? await runWithSpan({ name: `middleware.${mid.name}`, signal: options.signal }, async (span) => {
-      span?.setAttribute("middleware.index", index);
-      span?.setAttribute("middleware.name", mid.name);
-      const result = await mid(
-        {
-          ...options,
-          context,
-          next: async (...[nextOptions]) => {
-            const nextContext = nextOptions?.context ?? {};
-            return {
-              output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
-              context: nextContext
-            };
-          }
-        },
-        currentInput,
-        middlewareOutputFn
-      );
-      return result.output;
-    }) : await runWithSpan(
-      { name: "handler", signal: options.signal },
-      () => procedure["~orpc"].handler({ ...options, context, input: currentInput })
-    );
-    if (index === outputValidationIndex) {
-      return await validateOutput(procedure, output);
-    }
-    return output;
-  };
-  return next(0, options.context, options.input);
-}
-
-export { LAZY_SYMBOL as L, createORPCErrorConstructorMap as a, middlewareOutputFn as b, createProcedureClient as c, getLazyMeta as g, isLazy as i, lazy as l, mergeCurrentContext as m, unlazy as u };