@orpc/server 0.0.0-next.d137cdf → 0.0.0-next.d16a1b6

package/dist/chunk-MZXEMHFS.js

@@ -1,272 +0,0 @@
-// src/utils.ts
-function mergeContext(a, b) {
-  if (!a)
-    return b;
-  if (!b)
-    return a;
-  return {
-    ...a,
-    ...b
-  };
-}
-
-// src/middleware.ts
-var decoratedMiddlewareSymbol = Symbol("\u{1F512}decoratedMiddleware");
-function decorateMiddleware(middleware) {
-  if (Reflect.get(middleware, decoratedMiddlewareSymbol)) {
-    return middleware;
-  }
-  const concat = (concatMiddleware, mapInput2) => {
-    const concatMiddleware_ = mapInput2 ? decorateMiddleware(concatMiddleware).mapInput(mapInput2) : concatMiddleware;
-    return decorateMiddleware(async (input, context, meta, ...rest) => {
-      const input_ = input;
-      const context_ = context;
-      const meta_ = meta;
-      const next = async (options) => {
-        return concatMiddleware_(input_, mergeContext(context_, options.context), meta_, ...rest);
-      };
-      const m1 = await middleware(input_, context_, {
-        ...meta_,
-        next
-      }, ...rest);
-      return m1;
-    });
-  };
-  const mapInput = (map) => {
-    return decorateMiddleware(
-      (input, ...rest) => middleware(map(input), ...rest)
-    );
-  };
-  return Object.assign(middleware, {
-    [decoratedMiddlewareSymbol]: true,
-    concat,
-    mapInput
-  });
-}
-
-// src/procedure-caller.ts
-import { executeWithHooks, trim, value } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-
-// src/procedure.ts
-import {
-  DecoratedContractProcedure,
-  isContractProcedure
-} from "@orpc/contract";
-var Procedure = class {
-  constructor(zz$p) {
-    this.zz$p = zz$p;
-  }
-};
-var DECORATED_PROCEDURE_SYMBOL = Symbol("DECORATED_PROCEDURE");
-function decorateProcedure(procedure) {
-  if (DECORATED_PROCEDURE_SYMBOL in procedure) {
-    return procedure;
-  }
-  return Object.assign(createProcedureCaller({
-    procedure,
-    context: void 0
-  }), {
-    [DECORATED_PROCEDURE_SYMBOL]: true,
-    zz$p: procedure.zz$p,
-    prefix(prefix) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract
-          ).prefix(prefix)
-        }
-      });
-    },
-    route(opts) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract
-          ).route(opts)
-        }
-      });
-    },
-    use(middleware, mapInput) {
-      const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          middlewares: [middleware_, ...procedure.zz$p.middlewares ?? []]
-        }
-      });
-    }
-  });
-}
-function isProcedure(item) {
-  if (item instanceof Procedure)
-    return true;
-  return (typeof item === "object" || typeof item === "function") && item !== null && "zz$p" in item && typeof item.zz$p === "object" && item.zz$p !== null && "contract" in item.zz$p && isContractProcedure(item.zz$p.contract) && "func" in item.zz$p && typeof item.zz$p.func === "function";
-}
-
-// src/procedure-caller.ts
-function createProcedureCaller(options) {
-  const caller = async (input) => {
-    const path = options.path ?? [];
-    const procedure = await loadProcedure(options.procedure);
-    const context = await value(options.context);
-    const execute = async () => {
-      const validInput = (() => {
-        const schema = procedure.zz$p.contract.zz$cp.InputSchema;
-        if (!schema) {
-          return input;
-        }
-        try {
-          return schema.parse(input);
-        } catch (e) {
-          throw new ORPCError({
-            message: "Validation input failed",
-            code: "BAD_REQUEST",
-            cause: e
-          });
-        }
-      })();
-      const middlewares = procedure.zz$p.middlewares ?? [];
-      let currentMidIndex = 0;
-      let currentContext = context;
-      const next = async (nextOptions) => {
-        const mid = middlewares[currentMidIndex];
-        currentMidIndex += 1;
-        currentContext = mergeContext(currentContext, nextOptions.context);
-        if (mid) {
-          return await mid(validInput, currentContext, {
-            path,
-            procedure,
-            next,
-            output: (output3) => ({ output: output3, context: void 0 })
-          });
-        } else {
-          return {
-            output: await await procedure.zz$p.func(validInput, currentContext, {
-              path,
-              procedure
-            }),
-            context: currentContext
-          };
-        }
-      };
-      const output2 = (await next({})).output;
-      const validOutput = await (async () => {
-        const schema = procedure.zz$p.contract.zz$cp.OutputSchema;
-        if (!schema) {
-          return output2;
-        }
-        const result = await schema.safeParseAsync(output2);
-        if (result.error) {
-          throw new ORPCError({
-            message: "Validation output failed",
-            code: "INTERNAL_SERVER_ERROR",
-            cause: result.error
-          });
-        }
-        return result.data;
-      })();
-      return validOutput;
-    };
-    const output = await executeWithHooks({
-      hooks: options,
-      input,
-      context,
-      meta: {
-        path,
-        procedure
-      },
-      execute
-    });
-    return output;
-  };
-  return caller;
-}
-async function loadProcedure(procedure) {
-  let loadedProcedure;
-  if (isLazy(procedure)) {
-    loadedProcedure = (await loadLazy(procedure)).default;
-  } else {
-    loadedProcedure = procedure;
-  }
-  if (!isProcedure(loadedProcedure)) {
-    throw new ORPCError({
-      code: "NOT_FOUND",
-      message: "Not found",
-      cause: new Error(trim(`
-          This error should be caught by the typescript compiler.
-          But if you still see this error, it means that you trying to call a lazy router (expected to be a lazy procedure).
-        `))
-    });
-  }
-  return loadedProcedure;
-}
-
-// src/lazy.ts
-var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
-function createLazy(loader) {
-  return {
-    [LAZY_LOADER_SYMBOL]: loader
-  };
-}
-function loadLazy(lazy) {
-  return lazy[LAZY_LOADER_SYMBOL]();
-}
-function isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_LOADER_SYMBOL in item && typeof item[LAZY_LOADER_SYMBOL] === "function";
-}
-function createFlattenLazy(lazy) {
-  const flattenLoader = async () => {
-    let current = await loadLazy(lazy);
-    while (true) {
-      if (!isLazy(current.default)) {
-        break;
-      }
-      current = await loadLazy(current.default);
-    }
-    return current;
-  };
-  const flattenLazy = {
-    [LAZY_LOADER_SYMBOL]: flattenLoader
-  };
-  return flattenLazy;
-}
-function decorateLazy(lazy) {
-  const flattenLazy = createFlattenLazy(lazy);
-  const procedureCaller = createProcedureCaller({
-    procedure: flattenLazy,
-    context: void 0
-  });
-  Object.assign(procedureCaller, flattenLazy);
-  const recursive = new Proxy(procedureCaller, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      return decorateLazy(createLazy(async () => {
-        const current = await loadLazy(flattenLazy);
-        return { default: current.default[key] };
-      }));
-    }
-  });
-  return recursive;
-}
-
-export {
-  mergeContext,
-  decorateMiddleware,
-  LAZY_LOADER_SYMBOL,
-  createLazy,
-  loadLazy,
-  isLazy,
-  createFlattenLazy,
-  decorateLazy,
-  createProcedureCaller,
-  loadProcedure,
-  Procedure,
-  decorateProcedure,
-  isProcedure
-};
-//# sourceMappingURL=chunk-MZXEMHFS.js.map

package/dist/fetch.js

@@ -1,110 +0,0 @@
-import {
-  createProcedureCaller,
-  isLazy,
-  isProcedure
-} from "./chunk-MZXEMHFS.js";
-
-// src/fetch/handle.ts
-import { ORPCError } from "@orpc/shared/error";
-async function handleFetchRequest(options) {
-  for (const handler of options.handlers) {
-    const response = await handler(options);
-    if (response) {
-      return response;
-    }
-  }
-  const error = new ORPCError({ code: "NOT_FOUND", message: "Not found" });
-  return new Response(JSON.stringify(error.toJSON()), {
-    status: error.status,
-    headers: {
-      "Content-Type": "application/json"
-    }
-  });
-}
-
-// src/fetch/handler.ts
-import { ORPC_HEADER, ORPC_HEADER_VALUE } from "@orpc/contract";
-import { executeWithHooks, trim, value } from "@orpc/shared";
-import { ORPCError as ORPCError2 } from "@orpc/shared/error";
-import { ORPCDeserializer, ORPCSerializer } from "@orpc/transformer";
-var serializer = new ORPCSerializer();
-var deserializer = new ORPCDeserializer();
-function createORPCHandler() {
-  return async (options) => {
-    if (options.request.headers.get(ORPC_HEADER) !== ORPC_HEADER_VALUE) {
-      return void 0;
-    }
-    const context = await value(options.context);
-    const handler = async () => {
-      const url = new URL(options.request.url);
-      const pathname = `/${trim(url.pathname.replace(options.prefix ?? "", ""), "/")}`;
-      const match = resolveORPCRouter(options.router, pathname);
-      if (!match) {
-        throw new ORPCError2({ code: "NOT_FOUND", message: "Not found" });
-      }
-      const input = await deserializeRequest(options.request);
-      const caller = createProcedureCaller({
-        context,
-        procedure: match.procedure,
-        path: match.path
-      });
-      const output = await caller(input);
-      const { body, headers } = serializer.serialize(output);
-      return new Response(body, {
-        status: 200,
-        headers
-      });
-    };
-    try {
-      return await executeWithHooks({
-        hooks: options,
-        context,
-        execute: handler,
-        input: options.request,
-        meta: void 0
-      });
-    } catch (e) {
-      const error = e instanceof ORPCError2 ? e : new ORPCError2({
-        code: "INTERNAL_SERVER_ERROR",
-        message: "Internal server error",
-        cause: e
-      });
-      const { body, headers } = serializer.serialize(error.toJSON());
-      return new Response(body, {
-        status: error.status,
-        headers
-      });
-    }
-  };
-}
-function resolveORPCRouter(router, pathname) {
-  const path = trim(pathname, "/").split("/").map(decodeURIComponent);
-  let current = router;
-  for (const segment of path) {
-    if (typeof current !== "object" && typeof current !== "function" || !current) {
-      current = void 0;
-      break;
-    }
-    current = current[segment];
-  }
-  return isProcedure(current) || isLazy(current) ? {
-    procedure: current,
-    path
-  } : void 0;
-}
-async function deserializeRequest(request) {
-  try {
-    return await deserializer.deserialize(request);
-  } catch (e) {
-    throw new ORPCError2({
-      code: "BAD_REQUEST",
-      message: "Cannot parse request. Please check the request body and Content-Type header.",
-      cause: e
-    });
-  }
-}
-export {
-  createORPCHandler,
-  handleFetchRequest
-};
-//# sourceMappingURL=fetch.js.map