@orpc/server 0.0.0-next.cba521d → 0.0.0-next.cc8802c

package/dist/chunk-OUPZ7QGV.js

@@ -1,245 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// 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) && "handler" in item["~orpc"] && typeof item["~orpc"].handler === "function";
-}
-
-// src/error.ts
-import { ORPCError } from "@orpc/contract";
-function createORPCErrorConstructorMap(errors) {
-  const constructors = {};
-  if (!errors) {
-    return constructors;
-  }
-  for (const code in errors) {
-    const config = errors[code];
-    if (!config) {
-      continue;
-    }
-    const constructor = (...[options]) => {
-      return new ORPCError({
-        code,
-        defined: true,
-        status: config.status,
-        message: options?.message ?? config.message,
-        data: options?.data,
-        cause: options?.cause
-      });
-    };
-    constructors[code] = constructor;
-  }
-  return constructors;
-}
-
-// 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/middleware.ts
-function middlewareOutputFn(output) {
-  return { output, context: void 0 };
-}
-
-// src/procedure-client.ts
-import { ORPCError as ORPCError2, validateORPCError, ValidationError } from "@orpc/contract";
-import { executeWithHooks, toError, value } from "@orpc/shared";
-function createProcedureClient(lazyableProcedure, ...[options]) {
-  return async (...[input, callerOptions]) => {
-    const path = options?.path ?? [];
-    const { default: procedure } = await unlazy(lazyableProcedure);
-    const context = await value(options?.context, callerOptions?.context);
-    const errors = createORPCErrorConstructorMap(procedure["~orpc"].contract["~orpc"].errorMap);
-    const executeOptions = {
-      input,
-      context,
-      errors,
-      path,
-      procedure,
-      signal: callerOptions?.signal
-    };
-    try {
-      const output = await executeWithHooks({
-        hooks: options,
-        input,
-        context,
-        meta: executeOptions,
-        execute: () => executeProcedureInternal(procedure, executeOptions)
-      });
-      return output;
-    } catch (e) {
-      if (!(e instanceof ORPCError2)) {
-        throw toError(e);
-      }
-      const validated = await validateORPCError(procedure["~orpc"].contract["~orpc"].errorMap, e);
-      throw validated;
-    }
-  };
-}
-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 ORPCError2({
-      message: "Input validation failed",
-      code: "BAD_REQUEST",
-      data: {
-        issues: result.issues
-      },
-      cause: new ValidationError({ message: "Input validation failed", 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 ORPCError2({
-      message: "Output validation failed",
-      code: "INTERNAL_SERVER_ERROR",
-      cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
-    });
-  }
-  return result.value;
-}
-function executeMiddlewareChain(middlewares, opt, input) {
-  let currentIndex = 0;
-  let currentContext = opt.context;
-  const executeMiddlewareChain2 = async (nextOptions) => {
-    const mid = middlewares[currentIndex];
-    currentIndex += 1;
-    currentContext = mergeContext(currentContext, nextOptions.context);
-    if (mid) {
-      return await mid({ ...opt, context: currentContext, next: executeMiddlewareChain2 }, input, middlewareOutputFn);
-    }
-    return opt.next({ context: currentContext });
-  };
-  return executeMiddlewareChain2({});
-}
-async function executeProcedureInternal(procedure, options) {
-  const executeHandler = async (context, input) => {
-    return await procedure["~orpc"].handler({ ...options, context, input });
-  };
-  const executePostMiddlewares = async (context, input) => {
-    const validatedInput = await validateInput(procedure, input);
-    const result2 = await executeMiddlewareChain(procedure["~orpc"].postMiddlewares, {
-      ...options,
-      context,
-      next: async ({ context: context2 }) => {
-        return middlewareOutputFn(
-          await executeHandler(context2, validatedInput)
-        );
-      }
-    }, validatedInput);
-    const validatedOutput = await validateOutput(procedure, result2.output);
-    return { ...result2, output: validatedOutput };
-  };
-  const result = await executeMiddlewareChain(procedure["~orpc"].preMiddlewares, {
-    ...options,
-    context: options.context,
-    next: ({ context }) => executePostMiddlewares(context, options.input)
-  }, options.input);
-  return result.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 {
-  __export,
-  mergeContext,
-  Procedure,
-  isProcedure,
-  createORPCErrorConstructorMap,
-  LAZY_LOADER_SYMBOL,
-  lazy,
-  isLazy,
-  unlazy,
-  flatLazy,
-  middlewareOutputFn,
-  createProcedureClient,
-  getRouterChild
-};
-//# sourceMappingURL=chunk-OUPZ7QGV.js.map

package/dist/chunk-WUOGVGWG.js

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-WUOGVGWG.js.map

package/dist/fetch.js

@@ -1,15 +0,0 @@
-import "./chunk-WUOGVGWG.js";
-import {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports
-} from "./chunk-3EVCPLVI.js";
-import "./chunk-OUPZ7QGV.js";
-export {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports as SuperJSON
-};
-//# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -1,30 +0,0 @@
-import "./chunk-WUOGVGWG.js";
-import {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports
-} from "./chunk-3EVCPLVI.js";
-import "./chunk-OUPZ7QGV.js";
-
-// src/adapters/hono/middleware.ts
-import { value } from "@orpc/shared";
-function createMiddleware(handler, ...[options]) {
-  return async (c, next) => {
-    const context = await value(options?.context, c);
-    const { matched, response } = await handler.handle(c.req.raw, { ...options, context });
-    if (matched) {
-      c.res = response;
-      return;
-    }
-    await next();
-  };
-}
-export {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports as SuperJSON,
-  createMiddleware
-};
-//# sourceMappingURL=hono.js.map