@orpc/server 0.0.0-next.e361acd → 0.0.0-next.e565b64

package/dist/chunk-FN62GL22.js

@@ -1,182 +0,0 @@
-// src/utils.ts
-function mergeContext(a, b) {
-  if (!a)
-    return b;
-  if (!b)
-    return a;
-  return {
-    ...a,
-    ...b
-  };
-}
-
-// src/procedure.ts
-import { isContractProcedure } from "@orpc/contract";
-var Procedure = class {
-  "~type" = "Procedure";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-};
-function isProcedure(item) {
-  if (item instanceof Procedure) {
-    return true;
-  }
-  return (typeof item === "object" || typeof item === "function") && item !== null && "~type" in item && item["~type"] === "Procedure" && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "contract" in item["~orpc"] && isContractProcedure(item["~orpc"].contract) && "func" in item["~orpc"] && typeof item["~orpc"].func === "function";
-}
-
-// src/lazy.ts
-var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
-function lazy(loader) {
-  return {
-    [LAZY_LOADER_SYMBOL]: loader
-  };
-}
-function isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_LOADER_SYMBOL in item && typeof item[LAZY_LOADER_SYMBOL] === "function";
-}
-function unlazy(lazied) {
-  return isLazy(lazied) ? lazied[LAZY_LOADER_SYMBOL]() : Promise.resolve({ default: lazied });
-}
-function flatLazy(lazied) {
-  const flattenLoader = async () => {
-    let current = await unlazy(lazied);
-    while (true) {
-      if (!isLazy(current.default)) {
-        break;
-      }
-      current = await unlazy(current.default);
-    }
-    return current;
-  };
-  return lazy(flattenLoader);
-}
-
-// src/procedure-client.ts
-import { executeWithHooks, value } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-function createProcedureClient(options) {
-  return async (...[input, callerOptions]) => {
-    const path = options.path ?? [];
-    const { default: procedure } = await unlazy(options.procedure);
-    const context = await value(options.context);
-    const meta = {
-      path,
-      procedure,
-      signal: callerOptions?.signal
-    };
-    const executeWithValidation = async () => {
-      const validInput = await validateInput(procedure, input);
-      const output = await executeMiddlewareChain(
-        procedure,
-        validInput,
-        context,
-        meta
-      );
-      return validateOutput(procedure, output);
-    };
-    return executeWithHooks({
-      hooks: options,
-      input,
-      context,
-      meta,
-      execute: executeWithValidation
-    });
-  };
-}
-async function validateInput(procedure, input) {
-  const schema = procedure["~orpc"].contract["~orpc"].InputSchema;
-  if (!schema)
-    return input;
-  const result = await schema["~standard"].validate(input);
-  if (result.issues) {
-    throw new ORPCError({
-      message: "Input validation failed",
-      code: "BAD_REQUEST",
-      issues: result.issues
-    });
-  }
-  return result.value;
-}
-async function validateOutput(procedure, output) {
-  const schema = procedure["~orpc"].contract["~orpc"].OutputSchema;
-  if (!schema)
-    return output;
-  const result = await schema["~standard"].validate(output);
-  if (result.issues) {
-    throw new ORPCError({
-      message: "Output validation failed",
-      code: "INTERNAL_SERVER_ERROR",
-      issues: result.issues
-    });
-  }
-  return result.value;
-}
-async function executeMiddlewareChain(procedure, input, context, meta) {
-  const middlewares = procedure["~orpc"].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(input, currentContext, {
-        ...meta,
-        next,
-        output: (output) => ({ output, context: void 0 })
-      });
-    }
-    const result = {
-      output: await procedure["~orpc"].func(input, currentContext, meta),
-      context: currentContext
-    };
-    return result;
-  };
-  return (await next({})).output;
-}
-
-// src/router.ts
-function getRouterChild(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);
-    const newLazy = lazy(async () => {
-      const unwrapped = await unlazy(lazied);
-      if (!unwrapped.default) {
-        return unwrapped;
-      }
-      const next = getRouterChild(unwrapped.default, ...rest);
-      return { default: next };
-    });
-    return flatLazy(newLazy);
-  }
-  return current;
-}
-
-export {
-  mergeContext,
-  Procedure,
-  isProcedure,
-  LAZY_LOADER_SYMBOL,
-  lazy,
-  isLazy,
-  unlazy,
-  flatLazy,
-  createProcedureClient,
-  getRouterChild
-};
-//# sourceMappingURL=chunk-FN62GL22.js.map

package/dist/fetch.js

@@ -1,112 +0,0 @@
-import {
-  createProcedureClient,
-  getRouterChild,
-  isProcedure,
-  unlazy
-} from "./chunk-FN62GL22.js";
-
-// src/fetch/handle-request.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/orpc-handler.ts
-import { executeWithHooks, ORPC_PROTOCOL_HEADER, ORPC_PROTOCOL_VALUE, 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_PROTOCOL_HEADER)?.includes(ORPC_PROTOCOL_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 = await resolveRouterMatch(options.router, pathname);
-      if (!match) {
-        throw new ORPCError2({ code: "NOT_FOUND", message: "Not found" });
-      }
-      const input = await parseRequestInput(options.request);
-      const caller = createProcedureClient({
-        context,
-        procedure: match.procedure,
-        path: match.path
-      });
-      const output = await caller(input, { signal: options.signal });
-      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: {
-          signal: options.signal
-        }
-      });
-    } catch (error) {
-      return handleErrorResponse(error);
-    }
-  };
-}
-async function resolveRouterMatch(router, pathname) {
-  const pathSegments = trim(pathname, "/").split("/").map(decodeURIComponent);
-  const match = getRouterChild(router, ...pathSegments);
-  const { default: maybeProcedure } = await unlazy(match);
-  if (!isProcedure(maybeProcedure)) {
-    return void 0;
-  }
-  return {
-    procedure: maybeProcedure,
-    path: pathSegments
-  };
-}
-async function parseRequestInput(request) {
-  try {
-    return await deserializer.deserialize(request);
-  } catch (error) {
-    throw new ORPCError2({
-      code: "BAD_REQUEST",
-      message: "Cannot parse request. Please check the request body and Content-Type header.",
-      cause: error
-    });
-  }
-}
-function handleErrorResponse(error) {
-  const orpcError = error instanceof ORPCError2 ? error : new ORPCError2({
-    code: "INTERNAL_SERVER_ERROR",
-    message: "Internal server error",
-    cause: error
-  });
-  const { body, headers } = serializer.serialize(orpcError.toJSON());
-  return new Response(body, {
-    status: orpcError.status,
-    headers
-  });
-}
-export {
-  createORPCHandler,
-  handleFetchRequest
-};
-//# sourceMappingURL=fetch.js.map