@orpc/server 0.0.0-next.b825e0c → 0.0.0-next.ba53a01

package/dist/chunk-PYUF3JOC.js

@@ -1,308 +0,0 @@
-import {
-  convertPathToHttpPath,
-  createContractedProcedure,
-  createProcedureClient,
-  eachContractProcedure,
-  getRouterChild,
-  isProcedure,
-  unlazy
-} from "./chunk-OEPDHGQ4.js";
-import {
-  CompositePlugin
-} from "./chunk-Q2XV45Q4.js";
-
-// src/adapters/standard/handler.ts
-import { toORPCError } from "@orpc/contract";
-import { intercept, trim } from "@orpc/shared";
-var StandardHandler = class {
-  constructor(router, matcher, codec, options = {}) {
-    this.matcher = matcher;
-    this.codec = codec;
-    this.options = options;
-    this.plugin = new CompositePlugin(options?.plugins);
-    this.plugin.init(this.options);
-    this.matcher.init(router);
-  }
-  plugin;
-  handle(request, ...[options]) {
-    const handleOptions = options ?? {};
-    handleOptions.context ??= {};
-    return intercept(
-      this.options.interceptorsRoot ?? [],
-      { request, ...handleOptions },
-      async (interceptorRootOptions) => {
-        try {
-          return await intercept(
-            this.options.interceptors ?? [],
-            interceptorRootOptions,
-            async ({ request: request2, context }) => {
-              const method = request2.method;
-              const url = request2.url;
-              const pathname = `/${trim(url.pathname.replace(options?.prefix ?? "", ""), "/")}`;
-              const match = await this.matcher.match(method, pathname);
-              if (!match) {
-                return { matched: false, response: void 0 };
-              }
-              const client = createProcedureClient(match.procedure, {
-                context,
-                path: match.path
-              });
-              const input = await this.codec.decode(request2, match.params, match.procedure);
-              const output = await client(input, { signal: request2.signal });
-              const response = this.codec.encode(output, match.procedure);
-              return {
-                matched: true,
-                response
-              };
-            }
-          );
-        } catch (e) {
-          const error = toORPCError(e);
-          const response = this.codec.encodeError(error);
-          return {
-            matched: true,
-            response
-          };
-        }
-      }
-    );
-  }
-};
-
-// src/adapters/standard/rpc-serializer.ts
-import { findDeepMatches, isPlainObject, set } from "@orpc/shared";
-var RPCSerializer = class {
-  serialize(data) {
-    if (data instanceof Blob) {
-      return data;
-    }
-    const serializedJSON = serializeRPCJson(data);
-    const { maps, values: blobs } = findDeepMatches((v) => v instanceof Blob, serializedJSON.json);
-    if (blobs.length === 0) {
-      return serializedJSON;
-    }
-    const form = new FormData();
-    form.set("data", JSON.stringify(serializedJSON));
-    form.set("maps", JSON.stringify(maps));
-    for (const i in blobs) {
-      form.set(i, blobs[i]);
-    }
-    return form;
-  }
-  deserialize(serialized) {
-    if (serialized instanceof Blob) {
-      return serialized;
-    }
-    if (!(serialized instanceof FormData)) {
-      return deserializeRPCJson(serialized);
-    }
-    const data = JSON.parse(serialized.get("data"));
-    const maps = JSON.parse(serialized.get("maps"));
-    for (const i in maps) {
-      data.json = set(data.json, maps[i], serialized.get(i));
-    }
-    return deserializeRPCJson(data);
-  }
-};
-function serializeRPCJson(value, segments = [], meta = []) {
-  if (typeof value === "bigint") {
-    meta.push(["bigint", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (value instanceof Date) {
-    meta.push(["date", segments]);
-    const data = Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
-    return { json: data, meta };
-  }
-  if (Number.isNaN(value)) {
-    meta.push(["nan", segments]);
-    return { json: "NaN", meta };
-  }
-  if (value instanceof RegExp) {
-    meta.push(["regexp", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (value instanceof URL) {
-    meta.push(["url", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (isPlainObject(value)) {
-    const json = {};
-    for (const k in value) {
-      json[k] = serializeRPCJson(value[k], [...segments, k], meta).json;
-    }
-    return { json, meta };
-  }
-  if (Array.isArray(value)) {
-    const json = value.map((v, i) => {
-      if (v === void 0) {
-        meta.push(["undefined", [...segments, i]]);
-        return null;
-      }
-      return serializeRPCJson(v, [...segments, i], meta).json;
-    });
-    return { json, meta };
-  }
-  if (value instanceof Set) {
-    const result = serializeRPCJson(Array.from(value), segments, meta);
-    meta.push(["set", segments]);
-    return result;
-  }
-  if (value instanceof Map) {
-    const result = serializeRPCJson(Array.from(value.entries()), segments, meta);
-    meta.push(["map", segments]);
-    return result;
-  }
-  return { json: value, meta };
-}
-function deserializeRPCJson({
-  json,
-  meta
-}) {
-  if (meta.length === 0) {
-    return json;
-  }
-  const ref = { data: json };
-  for (const [type, segments] of meta) {
-    let currentRef = ref;
-    let preSegment = "data";
-    for (let i = 0; i < segments.length; i++) {
-      currentRef = currentRef[preSegment];
-      preSegment = segments[i];
-    }
-    switch (type) {
-      case "nan":
-        currentRef[preSegment] = Number.NaN;
-        break;
-      case "bigint":
-        currentRef[preSegment] = BigInt(currentRef[preSegment]);
-        break;
-      case "date":
-        currentRef[preSegment] = new Date(currentRef[preSegment]);
-        break;
-      case "regexp": {
-        const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
-        currentRef[preSegment] = new RegExp(pattern, flags);
-        break;
-      }
-      case "url":
-        currentRef[preSegment] = new URL(currentRef[preSegment]);
-        break;
-      case "undefined":
-        currentRef[preSegment] = void 0;
-        break;
-      case "map":
-        currentRef[preSegment] = new Map(currentRef[preSegment]);
-        break;
-      case "set":
-        currentRef[preSegment] = new Set(currentRef[preSegment]);
-        break;
-      /* v8 ignore next 3 */
-      default: {
-        const _expected = type;
-      }
-    }
-  }
-  return ref.data;
-}
-
-// src/adapters/standard/rpc-codec.ts
-var RPCCodec = class {
-  serializer;
-  constructor(options = {}) {
-    this.serializer = options.serializer ?? new RPCSerializer();
-  }
-  async decode(request, _params, _procedure) {
-    const serialized = request.method === "GET" ? JSON.parse(request.url.searchParams.getAll("data").at(-1)) : await request.body();
-    return this.serializer.deserialize(serialized);
-  }
-  encode(output, _procedure) {
-    return {
-      status: 200,
-      headers: {},
-      body: this.serializer.serialize(output)
-    };
-  }
-  encodeError(error) {
-    return {
-      status: error.status,
-      headers: {},
-      body: this.serializer.serialize(error.toJSON())
-    };
-  }
-};
-
-// src/adapters/standard/rpc-matcher.ts
-var RPCMatcher = class {
-  tree = {};
-  pendingRouters = [];
-  init(router, path = []) {
-    const laziedOptions = eachContractProcedure({
-      router,
-      path
-    }, ({ path: path2, contract }) => {
-      const httpPath = convertPathToHttpPath(path2);
-      if (isProcedure(contract)) {
-        this.tree[httpPath] = {
-          path: path2,
-          contract,
-          procedure: contract,
-          // this mean dev not used contract-first so we can used contract as procedure directly
-          router
-        };
-      } else {
-        this.tree[httpPath] = {
-          path: path2,
-          contract,
-          procedure: void 0,
-          router
-        };
-      }
-    });
-    this.pendingRouters.push(...laziedOptions.map((option) => ({
-      ...option,
-      httpPathPrefix: convertPathToHttpPath(option.path)
-    })));
-  }
-  async match(_method, pathname) {
-    if (this.pendingRouters.length) {
-      const newPendingRouters = [];
-      for (const pendingRouter of this.pendingRouters) {
-        if (pathname.startsWith(pendingRouter.httpPathPrefix)) {
-          const { default: router } = await unlazy(pendingRouter.lazied);
-          this.init(router, pendingRouter.path);
-        } else {
-          newPendingRouters.push(pendingRouter);
-        }
-      }
-      this.pendingRouters = newPendingRouters;
-    }
-    const match = this.tree[pathname];
-    if (!match) {
-      return void 0;
-    }
-    if (!match.procedure) {
-      const { default: maybeProcedure } = await unlazy(getRouterChild(match.router, ...match.path));
-      if (!isProcedure(maybeProcedure)) {
-        throw new Error(`
-          [Contract-First] Missing or invalid implementation for procedure at path: ${convertPathToHttpPath(match.path)}.
-          Ensure that the procedure is correctly defined and matches the expected contract.
-        `);
-      }
-      match.procedure = createContractedProcedure(match.contract, maybeProcedure);
-    }
-    return {
-      path: match.path,
-      procedure: match.procedure
-    };
-  }
-};
-
-export {
-  StandardHandler,
-  RPCSerializer,
-  serializeRPCJson,
-  RPCCodec,
-  RPCMatcher
-};
-//# sourceMappingURL=chunk-PYUF3JOC.js.map

package/dist/fetch.js

@@ -1,18 +0,0 @@
-import {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
-} from "./chunk-IWQZNJGN.js";
-import "./chunk-PYUF3JOC.js";
-import "./chunk-OEPDHGQ4.js";
-import "./chunk-Q2XV45Q4.js";
-export {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
-};
-//# sourceMappingURL=fetch.js.map

package/dist/next.js

@@ -1,39 +0,0 @@
-import {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
-} from "./chunk-IWQZNJGN.js";
-import "./chunk-PYUF3JOC.js";
-import "./chunk-OEPDHGQ4.js";
-import "./chunk-Q2XV45Q4.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 {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  serve,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
-};
-//# sourceMappingURL=next.js.map

package/dist/node.js

@@ -1,175 +0,0 @@
-import {
-  RPCCodec,
-  RPCMatcher,
-  StandardHandler
-} from "./chunk-PYUF3JOC.js";
-import "./chunk-OEPDHGQ4.js";
-import "./chunk-Q2XV45Q4.js";
-
-// src/adapters/node/utils.ts
-import { Buffer, File } from "node:buffer";
-import { Readable } from "node:stream";
-import { once } from "@orpc/shared";
-import cd from "content-disposition";
-function nodeHttpToStandardRequest(req, res) {
-  const method = req.method ?? "GET";
-  const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
-  const host = req.headers.host ?? "localhost";
-  const url = new URL(req.originalUrl ?? req.url ?? "/", `${protocol}//${host}`);
-  return {
-    raw: { request: req, response: res },
-    method,
-    url,
-    headers: req.headers,
-    body: once(() => {
-      return nodeHttpRequestToStandardBody(req);
-    }),
-    get signal() {
-      const signal = nodeHttpResponseToAbortSignal(res);
-      Object.defineProperty(this, "signal", { value: signal, writable: true });
-      return signal;
-    },
-    set signal(value) {
-      Object.defineProperty(this, "signal", { value, writable: true });
-    }
-  };
-}
-function nodeHttpResponseSendStandardResponse(res, standardResponse) {
-  return new Promise((resolve, reject) => {
-    res.on("error", reject);
-    res.on("finish", resolve);
-    if (standardResponse.body === void 0) {
-      res.writeHead(standardResponse.status, standardResponse.headers);
-      res.end();
-      return;
-    }
-    if (standardResponse.body instanceof Blob) {
-      const resHeaders = {
-        ...standardResponse.headers,
-        "content-type": standardResponse.body.type,
-        "content-length": standardResponse.body.size.toString()
-      };
-      if (!standardResponse.headers["content-disposition"] && standardResponse.body instanceof Blob) {
-        resHeaders["content-disposition"] = cd(standardResponse.body instanceof File ? standardResponse.body.name : "blob");
-      }
-      res.writeHead(standardResponse.status, resHeaders);
-      Readable.fromWeb(
-        standardResponse.body.stream()
-        // Conflict between types=node and lib=dom so we need to cast it
-      ).pipe(res);
-      return;
-    }
-    if (standardResponse.body instanceof FormData) {
-      const response = new Response(standardResponse.body);
-      res.writeHead(standardResponse.status, {
-        ...standardResponse.headers,
-        "content-type": response.headers.get("content-type")
-      });
-      Readable.fromWeb(
-        response.body
-        // Conflict between types=node and lib=dom so we need to cast it
-      ).pipe(res);
-      return;
-    }
-    if (standardResponse.body instanceof URLSearchParams) {
-      res.writeHead(standardResponse.status, {
-        ...standardResponse.headers,
-        "content-type": "application/x-www-form-urlencoded"
-      });
-      const string2 = standardResponse.body.toString();
-      res.end(string2);
-      return;
-    }
-    res.writeHead(standardResponse.status, {
-      ...standardResponse.headers,
-      "content-type": "application/json"
-    });
-    const string = JSON.stringify(standardResponse.body);
-    res.end(string);
-  });
-}
-async function nodeHttpRequestToStandardBody(req) {
-  const method = req.method ?? "GET";
-  if (method === "GET" || method === "HEAD") {
-    return void 0;
-  }
-  const contentDisposition = req.headers["content-disposition"];
-  const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
-  const contentType = req.headers["content-type"];
-  if (fileName) {
-    return await streamToFile(req, fileName, contentType || "application/octet-stream");
-  }
-  if (!contentType || contentType.startsWith("application/json")) {
-    const text = await streamToString(req);
-    if (!text) {
-      return void 0;
-    }
-    return JSON.parse(text);
-  }
-  if (contentType.startsWith("multipart/form-data")) {
-    return await streamToFormData(req, contentType);
-  }
-  if (contentType.startsWith("application/x-www-form-urlencoded")) {
-    const text = await streamToString(req);
-    return new URLSearchParams(text);
-  }
-  if (contentType.startsWith("text/")) {
-    return await streamToString(req);
-  }
-  return streamToFile(req, "blob", contentType);
-}
-function streamToFormData(stream, contentType) {
-  const response = new Response(stream, {
-    // Conflict between types=node and lib=dom so we need to cast it
-    headers: {
-      "content-type": contentType
-    }
-  });
-  return response.formData();
-}
-async function streamToString(stream) {
-  let string = "";
-  for await (const chunk of stream) {
-    string += chunk.toString();
-  }
-  return string;
-}
-async function streamToFile(stream, fileName, contentType) {
-  const chunks = [];
-  for await (const chunk of stream) {
-    chunks.push(chunk);
-  }
-  return new File([Buffer.concat(chunks)], fileName, { type: contentType });
-}
-function nodeHttpResponseToAbortSignal(res) {
-  const controller = new AbortController();
-  res.on("close", () => {
-    controller.abort();
-  });
-  return controller.signal;
-}
-
-// src/adapters/node/rpc-handler.ts
-var RPCHandler = class {
-  standardHandler;
-  constructor(router, options) {
-    const codec = options?.codec ?? new RPCCodec();
-    const matcher = options?.matcher ?? new RPCMatcher();
-    this.standardHandler = new StandardHandler(router, matcher, codec, options);
-  }
-  async handle(req, res, ...rest) {
-    const standardRequest = nodeHttpToStandardRequest(req, res);
-    const result = await this.standardHandler.handle(standardRequest, ...rest);
-    if (!result.matched) {
-      return { matched: false };
-    }
-    await nodeHttpResponseSendStandardResponse(res, result.response);
-    return { matched: true };
-  }
-};
-export {
-  RPCHandler,
-  nodeHttpResponseSendStandardResponse,
-  nodeHttpToStandardRequest
-};
-//# sourceMappingURL=node.js.map

package/dist/plugins.js

@@ -1,11 +0,0 @@
-import {
-  CORSPlugin,
-  CompositePlugin,
-  ResponseHeadersPlugin
-} from "./chunk-Q2XV45Q4.js";
-export {
-  CORSPlugin,
-  CompositePlugin,
-  ResponseHeadersPlugin
-};
-//# sourceMappingURL=plugins.js.map

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

@@ -1,4 +0,0 @@
-export * from './rpc-handler';
-export * from './types';
-export * from './utils';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,10 +0,0 @@
-import type { Context } from '../../context';
-import type { Router } from '../../router';
-import type { RPCHandlerOptions, StandardHandleRest } from '../standard';
-import type { FetchHandler, FetchHandleResult } from './types';
-export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
-    private readonly standardHandler;
-    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
-    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
-}
-//# sourceMappingURL=rpc-handler.d.ts.map

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

@@ -1,13 +0,0 @@
-import type { Context } from '../../context';
-import type { StandardHandleRest } from '../standard';
-export type FetchHandleResult = {
-    matched: true;
-    response: Response;
-} | {
-    matched: false;
-    response: undefined;
-};
-export interface FetchHandler<T extends Context> {
-    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
-}
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,6 +0,0 @@
-import type { StandardBody, StandardRequest, StandardResponse } from '../standard';
-export declare function fetchReToStandardBody(re: Request | Response): Promise<StandardBody>;
-export declare function fetchRequestToStandardRequest(request: Request): StandardRequest;
-export declare function standardBodyToFetchBody(body: StandardBody): Blob | FormData | URLSearchParams | string | undefined;
-export declare function standardResponseToFetchResponse(response: StandardResponse): Response;
-//# sourceMappingURL=utils.d.ts.map

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

@@ -1,3 +0,0 @@
-export * from '../fetch';
-export * from './middleware';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/hono/middleware.d.ts

@@ -1,13 +0,0 @@
-import type { Context as HonoContext, MiddlewareHandler } from 'hono';
-import type { Context } from '../../context';
-import type { FetchHandler } from '../fetch';
-import type { StandardHandleOptions } from '../standard';
-import { type Value } from '@orpc/shared';
-export type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<T, [HonoContext]>;
-} : {
-    context: Value<T, [HonoContext]>;
-});
-export type CreateMiddlewareRest<T extends Context> = [options: CreateMiddlewareOptions<T>] | (Record<never, never> extends T ? [] : never);
-export declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: CreateMiddlewareRest<T>): MiddlewareHandler;
-//# sourceMappingURL=middleware.d.ts.map

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

@@ -1,3 +0,0 @@
-export * from '../fetch';
-export * from './serve';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/next/serve.d.ts

@@ -1,20 +0,0 @@
-import type { NextRequest } from 'next/server';
-import type { Context } from '../../context';
-import type { FetchHandler } from '../fetch';
-import type { StandardHandleOptions } from '../standard';
-import { type Value } from '@orpc/shared';
-export type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<T, [NextRequest]>;
-} : {
-    context: Value<T, [NextRequest]>;
-});
-export type ServeRest<T extends Context> = [options: ServeOptions<T>] | (Record<never, never> extends T ? [] : never);
-export interface ServeResult {
-    GET(req: NextRequest): Promise<Response>;
-    POST(req: NextRequest): Promise<Response>;
-    PUT(req: NextRequest): Promise<Response>;
-    PATCH(req: NextRequest): Promise<Response>;
-    DELETE(req: NextRequest): Promise<Response>;
-}
-export declare function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: ServeRest<T>): ServeResult;
-//# sourceMappingURL=serve.d.ts.map

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

@@ -1,4 +0,0 @@
-export * from './rpc-handler';
-export * from './types';
-export * from './utils';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/node/rpc-handler.d.ts

@@ -1,10 +0,0 @@
-import type { Context } from '../../context';
-import type { Router } from '../../router';
-import type { RPCHandlerOptions, StandardHandleRest } from '../standard';
-import type { NodeHttpHandler, NodeHttpHandleResult, NodeHttpRequest, NodeHttpResponse } from './types';
-export declare class RPCHandler<T extends Context> implements NodeHttpHandler<T> {
-    private readonly standardHandler;
-    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
-    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
-}
-//# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/node/types.d.ts

@@ -1,21 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
-import type { Context } from '../../context';
-import type { StandardHandleRest } from '../standard';
-export type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
-    /**
-     * Replace `req.url` with `req.originalUrl` when `req.originalUrl` is available.
-     * This is useful for `express.js` middleware.
-     */
-    originalUrl?: string;
-};
-export type NodeHttpResponse = ServerResponse | Http2ServerResponse;
-export type NodeHttpHandleResult = {
-    matched: true;
-} | {
-    matched: false;
-};
-export interface NodeHttpHandler<T extends Context> {
-    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/node/utils.d.ts

@@ -1,5 +0,0 @@
-import type { StandardRequest, StandardResponse } from '../standard';
-import type { NodeHttpRequest, NodeHttpResponse } from './types';
-export declare function nodeHttpToStandardRequest(req: NodeHttpRequest, res: NodeHttpResponse): StandardRequest;
-export declare function nodeHttpResponseSendStandardResponse(res: NodeHttpResponse, standardResponse: StandardResponse): Promise<void>;
-//# sourceMappingURL=utils.d.ts.map