@temporary-name/server 1.9.3-alpha.32780b2c7ad58cf8dcbc93a40f13494185223e6e → 1.9.3-alpha.3bfad2d4c9c25a8fb0e01d57b30d58f74bc8f953

package/dist/shared/server.DlRH_uit.mjs

@@ -1,409 +0,0 @@
-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 { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
-import { safeParseAsync } 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 Procedure {
-  /**
-   * This property holds the defined options.
-   */
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-}
-function isProcedure(item) {
-  if (item instanceof Procedure) {
-    return true;
-  }
-  return isContractProcedure(item) && "middlewares" 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++) {
-    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),
-      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
-      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 = []) {
-  let currentRouter = options.router;
-  const hiddenContract = getHiddenRouterContract(options.router);
-  if (hiddenContract !== void 0) {
-    currentRouter = hiddenContract;
-  }
-  if (isLazy(currentRouter)) {
-    lazyOptions.push({
-      router: currentRouter,
-      path: options.path
-    });
-  } else if (isContractProcedure(currentRouter)) {
-    callback({
-      contract: currentRouter,
-      path: options.path
-    });
-  } 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: [],
-    errorMap: {},
-    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 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,
-            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 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 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 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, 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 };

package/dist/shared/server.Kxw442A9.mjs

@@ -1,247 +0,0 @@
-import { isObject, NullProtoObj, isAsyncIteratorObject, isORPCErrorJson, createORPCErrorFromJson, toORPCError } from '@temporary-name/shared';
-import { mapEventIterator, ErrorEvent } from '@temporary-name/standard-server';
-
-function bracketNotationSerialize(data, segments = [], result = []) {
-  if (Array.isArray(data)) {
-    data.forEach((item, i) => {
-      bracketNotationSerialize(item, [...segments, i], result);
-    });
-  } else if (isObject(data)) {
-    for (const key in data) {
-      bracketNotationSerialize(data[key], [...segments, key], result);
-    }
-  } else {
-    result.push([stringifyPath(segments), data]);
-  }
-  return result;
-}
-function bracketNotationDeserialize(serialized, { maxArrayIndex = 9999 } = {}) {
-  if (serialized.length === 0) {
-    return {};
-  }
-  const arrayPushStyles = /* @__PURE__ */ new WeakSet();
-  const ref = { value: [] };
-  for (const [path, value] of serialized) {
-    const segments = parsePath(path);
-    let currentRef = ref;
-    let nextSegment = "value";
-    segments.forEach((segment, i) => {
-      if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
-        currentRef[nextSegment] = [];
-      }
-      if (i !== segments.length - 1) {
-        if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment, maxArrayIndex)) {
-          if (arrayPushStyles.has(currentRef[nextSegment])) {
-            arrayPushStyles.delete(currentRef[nextSegment]);
-            currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
-          } else {
-            currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
-          }
-        }
-      } else {
-        if (Array.isArray(currentRef[nextSegment])) {
-          if (segment === "") {
-            if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
-              currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
-            }
-          } else {
-            if (arrayPushStyles.has(currentRef[nextSegment])) {
-              arrayPushStyles.delete(currentRef[nextSegment]);
-              currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
-            } else if (!isValidArrayIndex(segment, maxArrayIndex)) {
-              currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
-            }
-          }
-        }
-      }
-      currentRef = currentRef[nextSegment];
-      nextSegment = segment;
-    });
-    if (Array.isArray(currentRef) && nextSegment === "") {
-      arrayPushStyles.add(currentRef);
-      currentRef.push(value);
-    } else if (nextSegment in currentRef) {
-      if (Array.isArray(currentRef[nextSegment])) {
-        currentRef[nextSegment].push(value);
-      } else {
-        currentRef[nextSegment] = [currentRef[nextSegment], value];
-      }
-    } else {
-      currentRef[nextSegment] = value;
-    }
-  }
-  return ref.value;
-}
-function stringifyPath(segments) {
-  return segments.map((segment) => {
-    return segment.toString().replace(/[\\[\]]/g, (match) => {
-      switch (match) {
-        case "\\":
-          return "\\\\";
-        case "[":
-          return "\\[";
-        case "]":
-          return "\\]";
-        /* v8 ignore next 2 */
-        default:
-          return match;
-      }
-    });
-  }).reduce((result, segment, i) => {
-    if (i === 0) {
-      return segment;
-    }
-    return `${result}[${segment}]`;
-  }, "");
-}
-function parsePath(path) {
-  const segments = [];
-  let inBrackets = false;
-  let currentSegment = "";
-  let backslashCount = 0;
-  for (let i = 0; i < path.length; i++) {
-    const char = path[i];
-    const nextChar = path[i + 1];
-    if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
-      if (nextChar === void 0) {
-        inBrackets = false;
-      }
-      segments.push(currentSegment);
-      currentSegment = "";
-      i++;
-    } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
-      inBrackets = true;
-      segments.push(currentSegment);
-      currentSegment = "";
-    } else if (char === "\\") {
-      backslashCount++;
-    } else {
-      currentSegment += "\\".repeat(backslashCount / 2) + char;
-      backslashCount = 0;
-    }
-  }
-  return inBrackets || segments.length === 0 ? [path] : segments;
-}
-function isValidArrayIndex(value, maxIndex) {
-  return /^0$|^[1-9]\d*$/.test(value) && Number(value) <= maxIndex;
-}
-function arrayToObject(array) {
-  const obj = new NullProtoObj();
-  array.forEach((item, i) => {
-    obj[i] = item;
-  });
-  return obj;
-}
-function pushStyleArrayToObject(array) {
-  const obj = new NullProtoObj();
-  obj[""] = array.length === 1 ? array[0] : array;
-  return obj;
-}
-
-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];
-}
-
-function serialize(data, options = {}) {
-  if (isAsyncIteratorObject(data) && !options.outputFormat) {
-    return mapEventIterator(data, {
-      value: async (value) => _serialize(value, { outputFormat: "plain" }),
-      error: async (e) => {
-        return new ErrorEvent({
-          data: _serialize(toORPCError(e).toJSON(), { outputFormat: "plain" }),
-          cause: e
-        });
-      }
-    });
-  }
-  return _serialize(data, options);
-}
-function _serialize(data, options) {
-  const [json, hasBlob] = jsonSerialize(data);
-  if (options.outputFormat === "plain") {
-    return json;
-  }
-  if (options.outputFormat === "URLSearchParams") {
-    const params = new URLSearchParams();
-    for (const [path, value] of bracketNotationSerialize(json)) {
-      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        params.append(path, value.toString());
-      }
-    }
-    return params;
-  }
-  if (json instanceof Blob || json === void 0 || !hasBlob) {
-    return json;
-  }
-  const form = new FormData();
-  for (const [path, value] of bracketNotationSerialize(json)) {
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      form.append(path, value.toString());
-    } else if (value instanceof Blob) {
-      form.append(path, value);
-    }
-  }
-  return form;
-}
-function deserialize(data) {
-  if (data instanceof URLSearchParams || data instanceof FormData) {
-    return bracketNotationDeserialize(Array.from(data.entries()));
-  }
-  if (isAsyncIteratorObject(data)) {
-    return mapEventIterator(data, {
-      value: async (value) => value,
-      error: async (e) => {
-        if (e instanceof ErrorEvent && isORPCErrorJson(e.data)) {
-          return createORPCErrorFromJson(e.data, { cause: e });
-        }
-        return e;
-      }
-    });
-  }
-  return data;
-}
-
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-function getDynamicParams(path) {
-  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
-    raw: v,
-    name: v.match(/\{\+?([^}]+)\}/)[1]
-  })) : void 0;
-}
-
-export { standardizeHTTPPath as a, bracketNotationDeserialize as b, deserialize as d, getDynamicParams as g, jsonSerialize as j, serialize as s };