@temporary-name/server 1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827 → 1.9.3-alpha.305aebe633f301e28426c6b15cdfd58ddf45641c

package/dist/shared/server.B7tjiDal.mjs

@@ -1,354 +0,0 @@
-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 { safeDecodeAsync, safeEncodeAsync } from '@temporary-name/zod';
-
-function isStartWithMiddlewares(middlewares, compare) {
-  if (compare.length > middlewares.length) {
-    return false;
-  }
-  for (let i = 0; i < middlewares.length; i++) {
-    if (compare[i] === void 0) {
-      return true;
-    }
-    if (middlewares[i] !== compare[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-function mergeMiddlewares(first, second, options) {
-  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
-    return second;
-  }
-  return [...first, ...second];
-}
-function addMiddleware(middlewares, addition) {
-  return [...middlewares, addition];
-}
-
-class Contract {
-  /**
-   * This property holds the defined options.
-   */
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-}
-class Procedure extends Contract {
-}
-function isProcedure(item) {
-  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 getRouter(router, path) {
-  let current = router;
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i];
-    if (!current) {
-      return void 0;
-    }
-    if (isProcedure(current)) {
-      return void 0;
-    }
-    if (!isLazy(current)) {
-      current = current[segment];
-      continue;
-    }
-    const lazied = current;
-    const rest = path.slice(i);
-    return lazyInternal(async () => {
-      const unwrapped = await unlazy(lazied);
-      const next = getRouter(unwrapped.default, rest);
-      return unlazy(next);
-    }, getLazyMeta(lazied));
-  }
-  return current;
-}
-function createAccessibleLazyRouter(lazied) {
-  const recursive = new Proxy(lazied, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      const next = getRouter(lazied, [key]);
-      return createAccessibleLazyRouter(next);
-    }
-  });
-  return recursive;
-}
-function enhanceRouter(router, options) {
-  if (isLazy(router)) {
-    const laziedMeta = getLazyMeta(router);
-    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
-    const enhanced2 = lazyInternal(
-      async () => {
-        const { default: unlaziedRouter } = await unlazy(router);
-        const enhanced3 = enhanceRouter(unlaziedRouter, options);
-        return unlazy(enhanced3);
-      },
-      {
-        ...laziedMeta,
-        prefix: enhancedPrefix
-      }
-    );
-    const accessible = createAccessibleLazyRouter(enhanced2);
-    return accessible;
-  }
-  if (isProcedure(router)) {
-    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, {
-      dedupeLeading: options.dedupeLeadingMiddlewares
-    });
-    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
-    const enhanced2 = new Procedure({
-      ...router["~orpc"],
-      route: enhanceRoute(router["~orpc"].route, options),
-      middlewares: newMiddlewares,
-      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
-      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
-    });
-    return enhanced2;
-  }
-  const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = enhanceRouter(router[key], options);
-  }
-  return enhanced;
-}
-function traverseContractProcedures(options, callback, lazyOptions = []) {
-  const currentRouter = options.router;
-  if (isLazy(currentRouter)) {
-    lazyOptions.push({
-      router: currentRouter,
-      path: options.path
-    });
-  } 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(
-        {
-          router: currentRouter[key],
-          path: [...options.path, key]
-        },
-        callback,
-        lazyOptions
-      );
-    }
-  }
-  return lazyOptions;
-}
-async function resolveContractProcedures(options, callback) {
-  const pending = [options];
-  for (const options2 of pending) {
-    const lazyOptions = traverseContractProcedures(options2, callback);
-    for (const options3 of lazyOptions) {
-      const { default: router } = await unlazy(options3.router);
-      pending.push({
-        router,
-        path: options3.path
-      });
-    }
-  }
-}
-async function unlazyRouter(router) {
-  if (isProcedure(router)) {
-    return router;
-  }
-  const unlazied = {};
-  for (const key in router) {
-    const item = router[key];
-    const { default: unlaziedRouter } = await unlazy(item);
-    unlazied[key] = await unlazyRouter(unlaziedRouter);
-  }
-  return unlazied;
-}
-
-const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
-function lazyInternal(loader, meta = {}) {
-  return {
-    [LAZY_SYMBOL]: {
-      loader,
-      meta
-    }
-  };
-}
-function lazy(prefix, loader) {
-  return enhanceRouter(lazyInternal(loader), {
-    middlewares: [],
-    dedupeLeadingMiddlewares: true,
-    prefix
-  });
-}
-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 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 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 overlayProxy(
-        output,
-        mapEventIterator(
-          asyncIteratorWithSpan(
-            { name: "consume_event_iterator_output", signal: callerOptions?.signal },
-            output
-          ),
-          {
-            value: (v) => v,
-            error: async (e) => e
-          }
-        )
-      );
-    }
-    return output;
-  };
-}
-async function validateInput(procedure, input) {
-  const schemas = procedure["~orpc"].schemas;
-  return runWithSpan({ name: "validate_input" }, async () => {
-    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] })));
-    }
-    if (!resultPath.success) {
-      issues.push(...resultPath.error.issues.map((i) => ({ ...i, path: ["path", ...i.path] })));
-    }
-    if (!resultQuery.success) {
-      issues.push(...resultQuery.error.issues.map((i) => ({ ...i, path: ["query", ...i.path] })));
-    }
-    if (issues.length > 0) {
-      throw new ORPCError("BAD_REQUEST", {
-        message: "Input validation failed",
-        data: {
-          issues
-        },
-        cause: new ValidationError({
-          message: "Input validation failed",
-          issues,
-          data: input
-        })
-      });
-    }
-    const results = {
-      body: resultBody.data,
-      path: resultPath.data,
-      query: resultQuery.data
-    };
-    return results;
-  });
-}
-async function validateOutput(procedure, output) {
-  const schema = procedure["~orpc"].schemas.outputSchema;
-  if (!schema) {
-    return output;
-  }
-  return runWithSpan({ name: "validate_output" }, async () => {
-    const result = await safeEncodeAsync(schema, output, { parseType: "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, input, 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, input2) => {
-    let currentInput = input2;
-    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),
-              // 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
-            };
-          }
-        },
-        currentInput,
-        middlewareOutputFn
-      );
-      return result.output;
-    }) : await runWithSpan(
-      { name: "handler", signal: options.signal },
-      () => procedure["~orpc"].handler(currentInput, { ...options, context })
-    );
-    if (index === outputValidationIndex) {
-      return await validateOutput(procedure, output);
-    }
-    return output;
-  };
-  return next(0, options.context, input);
-}
-
-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 };