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

package/dist/index.js

@@ -1,562 +0,0 @@
-import {
-  LAZY_LOADER_SYMBOL,
-  Procedure,
-  createORPCErrorConstructorMap,
-  createProcedureClient,
-  flatLazy,
-  getRouterChild,
-  isLazy,
-  isProcedure,
-  lazy,
-  mergeContext,
-  middlewareOutputFn,
-  unlazy
-} from "./chunk-OUPZ7QGV.js";
-
-// src/builder.ts
-import { ContractProcedure } from "@orpc/contract";
-
-// src/implementer-chainable.ts
-import { isContractProcedure } from "@orpc/contract";
-import { createCallableObject as createCallableObject2 } from "@orpc/shared";
-
-// src/middleware-decorated.ts
-function decorateMiddleware(middleware) {
-  const decorated = middleware;
-  decorated.mapInput = (mapInput) => {
-    const mapped = decorateMiddleware(
-      (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
-    );
-    return mapped;
-  };
-  decorated.concat = (concatMiddleware, mapInput) => {
-    const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
-    const concatted = decorateMiddleware((options, input, output, ...rest) => {
-      const next = async (nextOptions) => {
-        return mapped({ ...options, context: mergeContext(nextOptions.context, options.context) }, input, output, ...rest);
-      };
-      const merged = middleware({ ...options, next }, input, output, ...rest);
-      return merged;
-    });
-    return concatted;
-  };
-  return decorated;
-}
-
-// src/procedure-decorated.ts
-import { DecoratedContractProcedure } from "@orpc/contract";
-import { createCallableObject } from "@orpc/shared";
-var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
-  static decorate(procedure) {
-    if (procedure instanceof _DecoratedProcedure) {
-      return procedure;
-    }
-    return new _DecoratedProcedure(procedure["~orpc"]);
-  }
-  prefix(prefix) {
-    return new _DecoratedProcedure({
-      ...this["~orpc"],
-      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).prefix(prefix)
-    });
-  }
-  route(route) {
-    return new _DecoratedProcedure({
-      ...this["~orpc"],
-      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).route(route)
-    });
-  }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _DecoratedProcedure({
-      ...this["~orpc"],
-      postMiddlewares: [...this["~orpc"].postMiddlewares, middleware_]
-    });
-  }
-  unshiftTag(...tags) {
-    return new _DecoratedProcedure({
-      ...this["~orpc"],
-      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).unshiftTag(...tags)
-    });
-  }
-  unshiftMiddleware(...middlewares) {
-    const castedMiddlewares = middlewares;
-    if (this["~orpc"].preMiddlewares.length) {
-      let min = 0;
-      for (let i = 0; i < this["~orpc"].preMiddlewares.length; i++) {
-        const index = castedMiddlewares.indexOf(this["~orpc"].preMiddlewares[i], min);
-        if (index === -1) {
-          castedMiddlewares.push(...this["~orpc"].preMiddlewares.slice(i));
-          break;
-        }
-        min = index + 1;
-      }
-    }
-    return new _DecoratedProcedure({
-      ...this["~orpc"],
-      preMiddlewares: castedMiddlewares
-    });
-  }
-  /**
-   * Make this procedure callable (works like a function while still being a procedure).
-   * **Note**: this only takes effect when this method is called at the end of the chain.
-   */
-  callable(...rest) {
-    return createCallableObject(this, createProcedureClient(this, ...rest));
-  }
-  /**
-   * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
-   * **Note**: this only takes effect when this method is called at the end of the chain.
-   */
-  actionable(...rest) {
-    return this.callable(...rest);
-  }
-};
-
-// src/procedure-implementer.ts
-var ProcedureImplementer = class _ProcedureImplementer {
-  "~type" = "ProcedureImplementer";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  use(middleware, mapInput) {
-    const mappedMiddleware = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _ProcedureImplementer({
-      ...this["~orpc"],
-      postMiddlewares: [...this["~orpc"].postMiddlewares, mappedMiddleware]
-    });
-  }
-  handler(handler) {
-    return new DecoratedProcedure({
-      postMiddlewares: this["~orpc"].postMiddlewares,
-      preMiddlewares: this["~orpc"].preMiddlewares,
-      contract: this["~orpc"].contract,
-      handler
-    });
-  }
-};
-
-// src/hidden.ts
-var ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
-function setRouterContract(obj, contract) {
-  return new Proxy(obj, {
-    get(target, key) {
-      if (key === ROUTER_CONTRACT_SYMBOL) {
-        return contract;
-      }
-      return Reflect.get(target, key);
-    }
-  });
-}
-function getRouterContract(obj) {
-  return obj[ROUTER_CONTRACT_SYMBOL];
-}
-var LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
-function deepSetLazyRouterPrefix(router, prefix) {
-  return new Proxy(router, {
-    get(target, key) {
-      if (key !== LAZY_ROUTER_PREFIX_SYMBOL) {
-        const val = Reflect.get(target, key);
-        if (val && (typeof val === "object" || typeof val === "function")) {
-          return deepSetLazyRouterPrefix(val, prefix);
-        }
-        return val;
-      }
-      return prefix;
-    }
-  });
-}
-function getLazyRouterPrefix(obj) {
-  return obj[LAZY_ROUTER_PREFIX_SYMBOL];
-}
-
-// src/lazy-decorated.ts
-function decorateLazy(lazied) {
-  const flattenLazy = flatLazy(lazied);
-  const recursive = new Proxy(flattenLazy, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      const next = getRouterChild(flattenLazy, key);
-      return decorateLazy(next);
-    }
-  });
-  return recursive;
-}
-
-// src/router-builder.ts
-var RouterBuilder = class _RouterBuilder {
-  "~type" = "RouterBuilder";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-    if (def.prefix && def.prefix.includes("{")) {
-      throw new Error(`
-        Dynamic routing in prefix not supported yet.
-        Please remove "{" from "${def.prefix}".
-      `);
-    }
-  }
-  prefix(prefix) {
-    return new _RouterBuilder({
-      ...this["~orpc"],
-      prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
-    });
-  }
-  tag(...tags) {
-    return new _RouterBuilder({
-      ...this["~orpc"],
-      tags: [...this["~orpc"].tags ?? [], ...tags]
-    });
-  }
-  use(middleware) {
-    return new _RouterBuilder({
-      ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares, middleware]
-    });
-  }
-  router(router) {
-    const adapted = adapt(router, this["~orpc"]);
-    return adapted;
-  }
-  lazy(loader) {
-    const adapted = adapt(flatLazy(lazy(loader)), this["~orpc"]);
-    return adapted;
-  }
-};
-function adapt(item, options) {
-  if (isLazy(item)) {
-    const adaptedLazy = decorateLazy(lazy(async () => {
-      const routerOrProcedure = (await unlazy(item)).default;
-      const adapted2 = adapt(routerOrProcedure, options);
-      return { default: adapted2 };
-    }));
-    const lazyPrefix = getLazyRouterPrefix(item);
-    if (options.prefix || lazyPrefix) {
-      const prefixed = deepSetLazyRouterPrefix(adaptedLazy, `${options.prefix ?? ""}${lazyPrefix ?? ""}`);
-      return prefixed;
-    }
-    return adaptedLazy;
-  }
-  if (isProcedure(item)) {
-    let decorated = DecoratedProcedure.decorate(item);
-    if (options.tags?.length) {
-      decorated = decorated.unshiftTag(...options.tags);
-    }
-    if (options.prefix) {
-      decorated = decorated.prefix(options.prefix);
-    }
-    if (options.middlewares?.length) {
-      decorated = decorated.unshiftMiddleware(...options.middlewares);
-    }
-    return decorated;
-  }
-  const adapted = {};
-  for (const key in item) {
-    adapted[key] = adapt(item[key], options);
-  }
-  return adapted;
-}
-
-// src/router-implementer.ts
-var RouterImplementer = class _RouterImplementer {
-  "~type" = "RouterImplementer";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  use(middleware) {
-    return new _RouterImplementer({
-      ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
-    });
-  }
-  router(router) {
-    const adapted = new RouterBuilder(this["~orpc"]).router(router);
-    const contracted = setRouterContract(adapted, this["~orpc"].contract);
-    return contracted;
-  }
-  lazy(loader) {
-    const adapted = new RouterBuilder(this["~orpc"]).lazy(loader);
-    const contracted = setRouterContract(adapted, this["~orpc"].contract);
-    return contracted;
-  }
-};
-
-// src/implementer-chainable.ts
-function createChainableImplementer(contract, middlewares = []) {
-  if (isContractProcedure(contract)) {
-    const implementer = new ProcedureImplementer({
-      contract,
-      preMiddlewares: middlewares,
-      postMiddlewares: []
-    });
-    return implementer;
-  }
-  const chainable = {};
-  for (const key in contract) {
-    chainable[key] = createChainableImplementer(contract[key], middlewares);
-  }
-  const routerImplementer = new RouterImplementer({ contract, middlewares });
-  const merged = new Proxy(chainable, {
-    get(target, key) {
-      const next = Reflect.get(target, key);
-      const method = Reflect.get(routerImplementer, key);
-      if (typeof key !== "string" || typeof method !== "function") {
-        return next;
-      }
-      if (!next) {
-        return method.bind(routerImplementer);
-      }
-      return createCallableObject2(next, method.bind(routerImplementer));
-    }
-  });
-  return merged;
-}
-
-// src/procedure-builder.ts
-import {
-  DecoratedContractProcedure as DecoratedContractProcedure2
-} from "@orpc/contract";
-var ProcedureBuilder = class _ProcedureBuilder {
-  "~type" = "ProcedureBuilder";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  route(route) {
-    return new _ProcedureBuilder({
-      ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).route(route)
-    });
-  }
-  input(schema, example) {
-    return new _ProcedureBuilder({
-      ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).input(schema, example)
-    });
-  }
-  output(schema, example) {
-    return new _ProcedureBuilder({
-      ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).output(schema, example)
-    });
-  }
-  errors(errors) {
-    return new _ProcedureBuilder({
-      ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).errors(errors)
-    });
-  }
-  use(middleware, mapInput) {
-    if (!mapInput) {
-      return new ProcedureImplementer({
-        contract: this["~orpc"].contract,
-        preMiddlewares: this["~orpc"].middlewares,
-        postMiddlewares: []
-      }).use(middleware);
-    }
-    return new ProcedureImplementer({
-      contract: this["~orpc"].contract,
-      preMiddlewares: this["~orpc"].middlewares,
-      postMiddlewares: []
-    }).use(middleware, mapInput);
-  }
-  handler(handler) {
-    return new DecoratedProcedure({
-      preMiddlewares: this["~orpc"].middlewares,
-      postMiddlewares: [],
-      contract: this["~orpc"].contract,
-      handler
-    });
-  }
-};
-
-// src/builder.ts
-var Builder = class _Builder {
-  "~type" = "Builder";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  context() {
-    return new _Builder({
-      middlewares: []
-    });
-  }
-  use(middleware) {
-    return new _Builder({
-      ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares, middleware]
-    });
-  }
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
-  }
-  route(route) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        route,
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: void 0
-      })
-    });
-  }
-  input(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        OutputSchema: void 0,
-        InputSchema: schema,
-        inputExample: example,
-        errorMap: void 0
-      })
-    });
-  }
-  output(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: schema,
-        outputExample: example,
-        errorMap: void 0
-      })
-    });
-  }
-  errors(errors) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: errors
-      })
-    });
-  }
-  handler(handler) {
-    return new DecoratedProcedure({
-      preMiddlewares: this["~orpc"].middlewares,
-      postMiddlewares: [],
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: void 0
-      }),
-      handler
-    });
-  }
-  prefix(prefix) {
-    return new RouterBuilder({
-      middlewares: this["~orpc"].middlewares,
-      prefix
-    });
-  }
-  tag(...tags) {
-    return new RouterBuilder({
-      middlewares: this["~orpc"].middlewares,
-      tags
-    });
-  }
-  router(router) {
-    return new RouterBuilder(this["~orpc"]).router(router);
-  }
-  lazy(loader) {
-    return new RouterBuilder(this["~orpc"]).lazy(loader);
-  }
-  contract(contract) {
-    return createChainableImplementer(contract, this["~orpc"].middlewares);
-  }
-};
-
-// src/procedure-utils.ts
-function call(procedure, input, ...rest) {
-  return createProcedureClient(procedure, ...rest)(input);
-}
-
-// src/lazy-utils.ts
-function createLazyProcedureFormAnyLazy(lazied) {
-  const lazyProcedure = lazy(async () => {
-    const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
-    if (!isProcedure(maybeProcedure)) {
-      throw new Error(`
-            Expected a lazy<procedure> but got lazy<unknown>.
-            This should be caught by TypeScript compilation.
-            Please report this issue if this makes you feel uncomfortable.
-        `);
-    }
-    return { default: maybeProcedure };
-  });
-  return lazyProcedure;
-}
-
-// src/router-client.ts
-function createRouterClient(router, ...rest) {
-  if (isProcedure(router)) {
-    const caller = createProcedureClient(router, ...rest);
-    return caller;
-  }
-  const procedureCaller = isLazy(router) ? createProcedureClient(createLazyProcedureFormAnyLazy(router), ...rest) : {};
-  const recursive = new Proxy(procedureCaller, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      const next = getRouterChild(router, key);
-      if (!next) {
-        return Reflect.get(target, key);
-      }
-      const [options] = rest;
-      return createRouterClient(next, {
-        ...options,
-        path: [...options?.path ?? [], key]
-      });
-    }
-  });
-  return recursive;
-}
-
-// src/index.ts
-import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe } from "@orpc/contract";
-var os = new Builder({
-  middlewares: []
-});
-export {
-  Builder,
-  DecoratedProcedure,
-  LAZY_LOADER_SYMBOL,
-  ORPCError,
-  Procedure,
-  ProcedureBuilder,
-  ProcedureImplementer,
-  RouterBuilder,
-  RouterImplementer,
-  call,
-  configGlobal,
-  createChainableImplementer,
-  createORPCErrorConstructorMap,
-  createProcedureClient,
-  createRouterClient,
-  decorateLazy,
-  decorateMiddleware,
-  deepSetLazyRouterPrefix,
-  fallbackToGlobalConfig,
-  flatLazy,
-  getLazyRouterPrefix,
-  getRouterChild,
-  getRouterContract,
-  isDefinedError,
-  isLazy,
-  isProcedure,
-  lazy,
-  mergeContext,
-  middlewareOutputFn,
-  os,
-  safe,
-  setRouterContract,
-  unlazy
-};
-//# sourceMappingURL=index.js.map

package/dist/next.js

@@ -1,36 +0,0 @@
-import "./chunk-WUOGVGWG.js";
-import {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports
-} from "./chunk-3EVCPLVI.js";
-import "./chunk-OUPZ7QGV.js";
-
-// src/adapters/next/serve.ts
-import { value } from "@orpc/shared";
-function serve(handler, ...[options]) {
-  const main = async (req) => {
-    const context = await value(options?.context, req);
-    const { matched, response } = await handler.handle(req, { ...options, context });
-    if (matched) {
-      return response;
-    }
-    return new Response(`Cannot find a matching procedure for ${req.url}`, { status: 404 });
-  };
-  return {
-    GET: main,
-    POST: main,
-    PUT: main,
-    PATCH: main,
-    DELETE: main
-  };
-}
-export {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports as SuperJSON,
-  serve
-};
-//# sourceMappingURL=next.js.map

package/dist/node.js

@@ -1,87 +0,0 @@
-import {
-  RPCHandler
-} from "./chunk-3EVCPLVI.js";
-import "./chunk-OUPZ7QGV.js";
-
-// src/adapters/node/request-listener.ts
-function createRequest(req, res) {
-  const controller = new AbortController();
-  res.on("close", () => {
-    controller.abort();
-  });
-  const method = req.method ?? "GET";
-  const headers = createHeaders(req);
-  const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
-  const host = headers.get("Host") ?? "localhost";
-  const url = new URL(req.originalUrl ?? req.url ?? "/", `${protocol}//${host}`);
-  const init = { method, headers, signal: controller.signal };
-  if (method !== "GET" && method !== "HEAD") {
-    init.body = new ReadableStream({
-      start(controller2) {
-        req.on("data", (chunk) => {
-          controller2.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
-        });
-        req.on("end", () => {
-          controller2.close();
-        });
-      }
-    });
-    init.duplex = "half";
-  }
-  return new Request(url, init);
-}
-function createHeaders(req) {
-  const headers = new Headers();
-  const rawHeaders = req.rawHeaders;
-  for (let i = 0; i < rawHeaders.length; i += 2) {
-    headers.append(rawHeaders[i], rawHeaders[i + 1]);
-  }
-  return headers;
-}
-async function sendResponse(res, response) {
-  const headers = {};
-  for (const [key, value] of response.headers) {
-    if (key in headers) {
-      if (Array.isArray(headers[key])) {
-        headers[key].push(value);
-      } else {
-        headers[key] = [headers[key], value];
-      }
-    } else {
-      headers[key] = value;
-    }
-  }
-  res.writeHead(response.status, headers);
-  if (response.body != null && res.req.method !== "HEAD") {
-    for await (const chunk of response.body) {
-      res.write(chunk);
-    }
-  }
-  res.end();
-}
-
-// src/adapters/node/orpc-handler.ts
-var RPCHandler2 = class {
-  orpcFetchHandler;
-  constructor(router, options) {
-    this.orpcFetchHandler = new RPCHandler(router, options);
-  }
-  async handle(req, res, ...[options]) {
-    const request = createRequest(req, res);
-    const castedOptions = options ?? {};
-    const result = await this.orpcFetchHandler.handle(request, castedOptions);
-    if (result.matched === false) {
-      return { matched: false };
-    }
-    await options?.beforeSend?.(result.response, castedOptions.context);
-    await sendResponse(res, result.response);
-    return { matched: true };
-  }
-};
-export {
-  RPCHandler2 as RPCHandler,
-  createHeaders,
-  createRequest,
-  sendResponse
-};
-//# sourceMappingURL=node.js.map

package/dist/src/adapters/fetch/index.d.ts

@@ -1,6 +0,0 @@
-export * from './orpc-handler';
-export * from './orpc-payload-codec';
-export * from './orpc-procedure-matcher';
-export * as SuperJSON from './super-json';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/fetch/orpc-handler.d.ts

@@ -1,20 +0,0 @@
-import type { Hooks } from '@orpc/shared';
-import type { Router } from '../../router';
-import type { Context } from '../../types';
-import type { FetchHandler, FetchHandleRest, FetchHandleResult } from './types';
-import { type PublicORPCPayloadCodec } from './orpc-payload-codec';
-import { type PublicORPCProcedureMatcher } from './orpc-procedure-matcher';
-export type RPCHandlerOptions<T extends Context> = Hooks<Request, FetchHandleResult, T, {
-    signal?: AbortSignal;
-}> & {
-    procedureMatcher?: PublicORPCProcedureMatcher;
-    payloadCodec?: PublicORPCPayloadCodec;
-};
-export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
-    private readonly options?;
-    private readonly procedureMatcher;
-    private readonly payloadCodec;
-    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>> | undefined);
-    handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult>;
-}
-//# sourceMappingURL=orpc-handler.d.ts.map