@orpc/server 0.0.0-next.ef3ba82 → 0.0.0-next.f107a0e

package/dist/chunk-CVLK2PBB.js

@@ -1,189 +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 { value } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-import { OpenAPIDeserializer } from "@orpc/transformer";
-function createProcedureCaller(options) {
-  const path = options.path ?? [];
-  const procedure = options.procedure;
-  const caller = async (input) => {
-    const input_ = (() => {
-      if (!(input instanceof FormData)) {
-        return input;
-      }
-      const transformer = new OpenAPIDeserializer({
-        schema: procedure.zz$p.contract.zz$cp.InputSchema
-      });
-      return transformer.deserializeAsFormData(input);
-    })();
-    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 = await value(options.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: (output2) => ({ output: output2, context: void 0 })
-        });
-      } else {
-        return {
-          output: await await procedure.zz$p.func(validInput, currentContext, {
-            path,
-            procedure
-          }),
-          context: currentContext
-        };
-      }
-    };
-    const output = (await next({})).output;
-    const validOutput = await (async () => {
-      const schema = procedure.zz$p.contract.zz$cp.OutputSchema;
-      if (!schema) {
-        return output;
-      }
-      const result = await schema.safeParseAsync(output);
-      if (result.error) {
-        throw new ORPCError({
-          message: "Validation output failed",
-          code: "INTERNAL_SERVER_ERROR",
-          cause: result.error
-        });
-      }
-      return result.data;
-    })();
-    return validOutput;
-  };
-  return caller;
-}
-
-// 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";
-}
-
-export {
-  mergeContext,
-  decorateMiddleware,
-  createProcedureCaller,
-  Procedure,
-  decorateProcedure,
-  isProcedure
-};

package/dist/fetch.js

@@ -1,105 +0,0 @@
-import {
-  createProcedureCaller,
-  isProcedure
-} from "./chunk-CVLK2PBB.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 { 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 options.hooks?.(
-        context,
-        { next: handler, response: (response) => response }
-      ) ?? await handler();
-    } 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" || current === null) && typeof current !== "function") {
-      current = void 0;
-      break;
-    }
-    current = current[segment];
-  }
-  return isProcedure(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
-};

package/dist/index.js

@@ -1,393 +0,0 @@
-import {
-  Procedure,
-  createProcedureCaller,
-  decorateMiddleware,
-  decorateProcedure,
-  isProcedure,
-  mergeContext
-} from "./chunk-CVLK2PBB.js";
-
-// src/builder.ts
-import {
-  ContractProcedure,
-  isContractProcedure as isContractProcedure2
-} from "@orpc/contract";
-
-// src/procedure-builder.ts
-import {
-  DecoratedContractProcedure
-} from "@orpc/contract";
-
-// src/procedure-implementer.ts
-var ProcedureImplementer = class _ProcedureImplementer {
-  constructor(zz$pi) {
-    this.zz$pi = zz$pi;
-  }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _ProcedureImplementer({
-      ...this.zz$pi,
-      middlewares: [...this.zz$pi.middlewares ?? [], middleware_]
-    });
-  }
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$pi.middlewares,
-        contract: this.zz$pi.contract,
-        func
-      }
-    });
-  }
-};
-
-// src/procedure-builder.ts
-var ProcedureBuilder = class _ProcedureBuilder {
-  constructor(zz$pb) {
-    this.zz$pb = zz$pb;
-  }
-  /**
-   * Self chainable
-   */
-  route(opts) {
-    return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).route(
-        opts
-      )
-    });
-  }
-  input(schema, example) {
-    return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).input(
-        schema,
-        example
-      )
-    });
-  }
-  output(schema, example) {
-    return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).output(
-        schema,
-        example
-      )
-    });
-  }
-  use(middleware, mapInput) {
-    if (!mapInput) {
-      return new ProcedureImplementer({
-        contract: this.zz$pb.contract,
-        middlewares: this.zz$pb.middlewares
-      }).use(middleware);
-    }
-    return new ProcedureImplementer({
-      contract: this.zz$pb.contract,
-      middlewares: this.zz$pb.middlewares
-    }).use(middleware, mapInput);
-  }
-  /**
-   * Convert to Procedure
-   */
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$pb.middlewares,
-        contract: this.zz$pb.contract,
-        func
-      }
-    });
-  }
-};
-
-// src/router-builder.ts
-import { DecoratedContractProcedure as DecoratedContractProcedure2 } from "@orpc/contract";
-var RouterBuilder = class _RouterBuilder {
-  constructor(zz$rb) {
-    this.zz$rb = zz$rb;
-  }
-  prefix(prefix) {
-    return new _RouterBuilder({
-      ...this.zz$rb,
-      prefix: `${this.zz$rb.prefix ?? ""}${prefix}`
-    });
-  }
-  tags(...tags) {
-    if (!tags.length)
-      return this;
-    return new _RouterBuilder({
-      ...this.zz$rb,
-      tags: [...this.zz$rb.tags ?? [], ...tags]
-    });
-  }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _RouterBuilder({
-      ...this.zz$rb,
-      middlewares: [...this.zz$rb.middlewares || [], middleware_]
-    });
-  }
-  router(router) {
-    const handled = {};
-    for (const key in router) {
-      const item = router[key];
-      if (isProcedure(item)) {
-        const builderMiddlewares = this.zz$rb.middlewares ?? [];
-        const itemMiddlewares = item.zz$p.middlewares ?? [];
-        const middlewares = [
-          ...builderMiddlewares,
-          ...itemMiddlewares.filter(
-            (item2) => !builderMiddlewares.includes(item2)
-          )
-        ];
-        const contract = DecoratedContractProcedure2.decorate(
-          item.zz$p.contract
-        ).addTags(...this.zz$rb.tags ?? []);
-        handled[key] = decorateProcedure({
-          zz$p: {
-            ...item.zz$p,
-            contract: this.zz$rb.prefix ? contract.prefix(this.zz$rb.prefix) : contract,
-            middlewares
-          }
-        });
-      } else {
-        handled[key] = this.router(item);
-      }
-    }
-    return handled;
-  }
-};
-
-// src/router-implementer.ts
-import {
-  isContractProcedure
-} from "@orpc/contract";
-var RouterImplementer = class {
-  constructor(zz$ri) {
-    this.zz$ri = zz$ri;
-  }
-  router(router) {
-    assertRouterImplementation(this.zz$ri.contract, router);
-    return router;
-  }
-};
-function chainRouterImplementer(contract, middlewares) {
-  const result = {};
-  for (const key in contract) {
-    const item = contract[key];
-    if (isContractProcedure(item)) {
-      result[key] = new ProcedureImplementer({
-        contract: item,
-        middlewares
-      });
-    } else {
-      result[key] = chainRouterImplementer(item, middlewares);
-    }
-  }
-  const implementer = new RouterImplementer({ contract });
-  return Object.assign(implementer, result);
-}
-function assertRouterImplementation(contract, router, path = []) {
-  for (const key in contract) {
-    const currentPath = [...path, key];
-    const contractItem = contract[key];
-    const routerItem = router[key];
-    if (!routerItem) {
-      throw new Error(
-        `Missing implementation for procedure at [${currentPath.join(".")}]`
-      );
-    }
-    if (isContractProcedure(contractItem)) {
-      if (isProcedure(routerItem)) {
-        if (routerItem.zz$p.contract !== contractItem) {
-          throw new Error(
-            `Mismatch implementation for procedure at [${currentPath.join(".")}]`
-          );
-        }
-      } else {
-        throw new Error(
-          `Mismatch implementation for procedure at [${currentPath.join(".")}]`
-        );
-      }
-    } else {
-      assertRouterImplementation(
-        contractItem,
-        routerItem,
-        currentPath
-      );
-    }
-  }
-}
-
-// src/builder.ts
-var Builder = class _Builder {
-  constructor(zz$b = {}) {
-    this.zz$b = zz$b;
-  }
-  /**
-   * Self chainable
-   */
-  context() {
-    return this;
-  }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _Builder({
-      ...this.zz$b,
-      middlewares: [...this.zz$b.middlewares || [], middleware_]
-    });
-  }
-  /**
-   * Convert to ContractProcedureBuilder
-   */
-  route(opts) {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        ...opts,
-        InputSchema: void 0,
-        OutputSchema: void 0
-      })
-    });
-  }
-  input(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        OutputSchema: void 0,
-        InputSchema: schema,
-        inputExample: example
-      })
-    });
-  }
-  output(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: schema,
-        outputExample: example
-      })
-    });
-  }
-  /**
-   * Convert to Procedure
-   */
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$b.middlewares,
-        contract: new ContractProcedure({
-          InputSchema: void 0,
-          OutputSchema: void 0
-        }),
-        func
-      }
-    });
-  }
-  /**
-   * Convert to ProcedureImplementer | RouterBuilder
-   */
-  contract(contract) {
-    if (isContractProcedure2(contract)) {
-      return new ProcedureImplementer({
-        contract,
-        middlewares: this.zz$b.middlewares
-      });
-    }
-    return chainRouterImplementer(
-      contract,
-      this.zz$b.middlewares
-    );
-  }
-  /**
-   * Create ExtendedMiddleware
-   */
-  // TODO: TOutput always any, infer not work at all, because TOutput used inside middleware params,
-  // solution (maybe): create new generic for .output() method
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
-  }
-  prefix(prefix) {
-    return new RouterBuilder({
-      ...this.zz$b,
-      prefix
-    });
-  }
-  tags(...tags) {
-    return new RouterBuilder({
-      ...this.zz$b,
-      tags
-    });
-  }
-  /**
-   * Create DecoratedRouter
-   */
-  router(router) {
-    return new RouterBuilder(this.zz$b).router(router);
-  }
-};
-
-// src/router.ts
-import {
-  isContractProcedure as isContractProcedure3
-} from "@orpc/contract";
-function toContractRouter(router) {
-  const contract = {};
-  for (const key in router) {
-    const item = router[key];
-    if (isContractProcedure3(item)) {
-      contract[key] = item;
-    } else if (isProcedure(item)) {
-      contract[key] = item.zz$p.contract;
-    } else {
-      contract[key] = toContractRouter(item);
-    }
-  }
-  return contract;
-}
-
-// src/router-caller.ts
-function createRouterCaller(options) {
-  const caller = {};
-  for (const key in options.router) {
-    const path = [...options.basePath ?? [], key];
-    const item = options.router[key];
-    if (isProcedure(item)) {
-      caller[key] = createProcedureCaller({
-        procedure: item,
-        context: options.context,
-        path
-      });
-    } else {
-      caller[key] = createRouterCaller({
-        router: item,
-        context: options.context,
-        basePath: path
-      });
-    }
-  }
-  return caller;
-}
-
-// src/index.ts
-export * from "@orpc/shared/error";
-var os = new Builder();
-export {
-  Builder,
-  Procedure,
-  ProcedureBuilder,
-  ProcedureImplementer,
-  RouterImplementer,
-  assertRouterImplementation,
-  chainRouterImplementer,
-  createProcedureCaller,
-  createRouterCaller,
-  decorateMiddleware,
-  decorateProcedure,
-  isProcedure,
-  mergeContext,
-  os,
-  toContractRouter
-};