@orpc/server 0.0.0-next.bc564a6 → 0.0.0-next.bf323bf

package/dist/chunk-6TBBWYQ3.js

@@ -0,0 +1,351 @@
+import {
+  convertPathToHttpPath,
+  createContractedProcedure,
+  createProcedureClient,
+  eachContractProcedure,
+  getRouterChild,
+  isProcedure,
+  unlazy
+} from "./chunk-RDEUEBK3.js";
+import {
+  CompositePlugin
+} from "./chunk-XI6WGCB3.js";
+
+// src/adapters/standard/handler.ts
+import { ORPCError, 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]) {
+    return intercept(
+      this.options.interceptorsRoot ?? [],
+      {
+        request,
+        ...options,
+        context: options?.context ?? {}
+        // context is optional only when all fields are optional so we can safely force it to have a context
+      },
+      async (interceptorOptions) => {
+        let isDecoding = false;
+        try {
+          return await intercept(
+            this.options.interceptors ?? [],
+            interceptorOptions,
+            async (interceptorOptions2) => {
+              const method = interceptorOptions2.request.method;
+              const url = interceptorOptions2.request.url;
+              const pathname = `/${trim(url.pathname.replace(interceptorOptions2.prefix ?? "", ""), "/")}`;
+              const match = await this.matcher.match(method, pathname);
+              if (!match) {
+                return { matched: false, response: void 0 };
+              }
+              const clientOptions = {
+                context: interceptorOptions2.context,
+                path: match.path
+              };
+              this.plugin.beforeCreateProcedureClient(clientOptions, interceptorOptions2);
+              const client = createProcedureClient(match.procedure, clientOptions);
+              isDecoding = true;
+              const input = await this.codec.decode(request, match.params, match.procedure);
+              isDecoding = false;
+              const lastEventId = Array.isArray(request.headers["last-event-id"]) ? request.headers["last-event-id"].at(-1) : request.headers["last-event-id"];
+              const output = await client(input, { signal: request.signal, lastEventId });
+              const response = this.codec.encode(output, match.procedure);
+              return {
+                matched: true,
+                response
+              };
+            }
+          );
+        } catch (e) {
+          const error = isDecoding ? new ORPCError("BAD_REQUEST", {
+            message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+            cause: e
+          }) : toORPCError(e);
+          const response = this.codec.encodeError(error);
+          return {
+            matched: true,
+            response
+          };
+        }
+      }
+    );
+  }
+};
+
+// src/adapters/standard/rpc-serializer.ts
+import { mapEventIterator, ORPCError as ORPCError2, toORPCError as toORPCError2 } from "@orpc/contract";
+import { ErrorEvent, isAsyncIteratorObject } from "@orpc/server-standard";
+import { findDeepMatches, isObject, set } from "@orpc/shared";
+var RPCSerializer = class {
+  serialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => serializeRPCJson(value),
+        error: async (e) => {
+          if (e instanceof ErrorEvent) {
+            return new ErrorEvent({
+              data: serializeRPCJson(e.data),
+              cause: e
+            });
+          }
+          return new ErrorEvent({
+            data: serializeRPCJson(toORPCError2(e).toJSON()),
+            cause: e
+          });
+        }
+      });
+    }
+    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 (isAsyncIteratorObject(serialized)) {
+      return mapEventIterator(serialized, {
+        value: async (value) => deserializeRPCJson(value),
+        error: async (e) => {
+          if (!(e instanceof ErrorEvent)) {
+            return e;
+          }
+          const deserialized = deserializeRPCJson(e.data);
+          if (ORPCError2.isValidJSON(deserialized)) {
+            return ORPCError2.fromJSON(deserialized, { cause: e });
+          }
+          return new ErrorEvent({
+            data: deserialized,
+            cause: e
+          });
+        }
+      });
+    }
+    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 (isObject(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-6TBBWYQ3.js.map

package/dist/{chunk-KK4SDLC7.js → chunk-RDEUEBK3.js}

@@ -1,9 +1,3 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
 // src/lazy.ts
 var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
 function lazy(loader) {
@@ -69,30 +63,29 @@ function middlewareOutputFn(output) {
 
 // src/procedure-client.ts
 import { createORPCErrorConstructorMap, ORPCError, validateORPCError, ValidationError } from "@orpc/contract";
-import { executeWithHooks, toError, value } from "@orpc/shared";
+import { intercept, 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 clientContext = callerOptions?.context ?? {};
+    const context = await value(options?.context ?? {}, clientContext);
     const errors = createORPCErrorConstructorMap(procedure["~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;
+      return await intercept(
+        options?.interceptors ?? [],
+        {
+          context,
+          input,
+          // input only optional when it undefinable so we can safely cast it
+          errors,
+          path,
+          procedure,
+          signal: callerOptions?.signal,
+          lastEventId: callerOptions?.lastEventId
+        },
+        (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
+      );
     } catch (e) {
       if (!(e instanceof ORPCError)) {
         throw toError(e);
@@ -296,8 +289,70 @@ function createAccessibleLazyRouter(lazied) {
   return recursive;
 }
 
+// src/utils.ts
+import { isContractProcedure as isContractProcedure2 } from "@orpc/contract";
+function eachContractProcedure(options, callback, laziedOptions = []) {
+  const hiddenContract = getRouterContract(options.router);
+  if (hiddenContract) {
+    return eachContractProcedure(
+      {
+        router: hiddenContract,
+        path: options.path
+      },
+      callback,
+      laziedOptions
+    );
+  }
+  if (isLazy(options.router)) {
+    laziedOptions.push({
+      lazied: options.router,
+      path: options.path
+    });
+  } else if (isContractProcedure2(options.router)) {
+    callback({
+      contract: options.router,
+      path: options.path
+    });
+  } else {
+    for (const key in options.router) {
+      eachContractProcedure(
+        {
+          router: options.router[key],
+          path: [...options.path, key]
+        },
+        callback,
+        laziedOptions
+      );
+    }
+  }
+  return laziedOptions;
+}
+async function eachAllContractProcedure(options, callback) {
+  const pending = [options];
+  for (const item of pending) {
+    const lazies = eachContractProcedure(item, callback);
+    for (const lazy2 of lazies) {
+      const { default: router } = await unlazy(lazy2.lazied);
+      pending.push({
+        path: lazy2.path,
+        router
+      });
+    }
+  }
+}
+function convertPathToHttpPath(path) {
+  return `/${path.map(encodeURIComponent).join("/")}`;
+}
+function createContractedProcedure(contract, procedure) {
+  return new Procedure({
+    ...procedure["~orpc"],
+    errorMap: contract["~orpc"].errorMap,
+    route: contract["~orpc"].route,
+    meta: contract["~orpc"].meta
+  });
+}
+
 export {
-  __export,
   LAZY_LOADER_SYMBOL,
   lazy,
   isLazy,
@@ -315,6 +370,10 @@ export {
   getLazyRouterPrefix,
   createAccessibleLazyRouter,
   adaptRouter,
-  getRouterChild
+  getRouterChild,
+  eachContractProcedure,
+  eachAllContractProcedure,
+  convertPathToHttpPath,
+  createContractedProcedure
 };
-//# sourceMappingURL=chunk-KK4SDLC7.js.map
+//# sourceMappingURL=chunk-RDEUEBK3.js.map

package/dist/chunk-SVWPMCP4.js

@@ -0,0 +1,32 @@
+import {
+  RPCCodec,
+  RPCMatcher,
+  StandardHandler
+} from "./chunk-6TBBWYQ3.js";
+
+// src/adapters/fetch/rpc-handler.ts
+import { toFetchResponse, toStandardRequest } from "@orpc/server-standard-fetch";
+var RPCHandler = class {
+  standardHandler;
+  constructor(router, options) {
+    const matcher = options?.matcher ?? new RPCMatcher();
+    const codec = options?.codec ?? new RPCCodec();
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
+  }
+  async handle(request, ...rest) {
+    const standardRequest = toStandardRequest(request);
+    const result = await this.standardHandler.handle(standardRequest, ...rest);
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response)
+    };
+  }
+};
+
+export {
+  RPCHandler
+};
+//# sourceMappingURL=chunk-SVWPMCP4.js.map

package/dist/chunk-XI6WGCB3.js

@@ -0,0 +1,125 @@
+// src/plugins/base.ts
+var CompositePlugin = class {
+  constructor(plugins = []) {
+    this.plugins = plugins;
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
+  beforeCreateProcedureClient(clientOptions, interceptorOptions) {
+    for (const plugin of this.plugins) {
+      plugin.beforeCreateProcedureClient?.(clientOptions, interceptorOptions);
+    }
+  }
+};
+
+// src/plugins/cors.ts
+import { value } from "@orpc/shared";
+var CORSPlugin = class {
+  options;
+  constructor(options) {
+    const defaults = {
+      origin: (origin) => origin,
+      allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
+    };
+    this.options = {
+      ...defaults,
+      ...options
+    };
+  }
+  init(options) {
+    options.interceptorsRoot ??= [];
+    options.interceptorsRoot.unshift(async (interceptorOptions) => {
+      if (interceptorOptions.request.method === "OPTIONS") {
+        const resHeaders = {};
+        if (this.options.maxAge !== void 0) {
+          resHeaders["access-control-max-age"] = this.options.maxAge.toString();
+        }
+        if (this.options.allowMethods?.length) {
+          resHeaders["access-control-allow-methods"] = this.options.allowMethods.join(",");
+        }
+        const allowHeaders = this.options.allowHeaders ?? interceptorOptions.request.headers["access-control-request-headers"];
+        if (Array.isArray(allowHeaders) && allowHeaders.length) {
+          resHeaders["access-control-allow-headers"] = allowHeaders.join(",");
+        } else if (typeof allowHeaders === "string") {
+          resHeaders["access-control-allow-headers"] = allowHeaders;
+        }
+        return {
+          matched: true,
+          response: {
+            status: 204,
+            headers: resHeaders,
+            body: void 0
+          }
+        };
+      }
+      return interceptorOptions.next();
+    });
+    options.interceptorsRoot.unshift(async (interceptorOptions) => {
+      const result = await interceptorOptions.next();
+      if (!result.matched) {
+        return result;
+      }
+      const origin = Array.isArray(interceptorOptions.request.headers.origin) ? interceptorOptions.request.headers.origin.join(",") : interceptorOptions.request.headers.origin || "";
+      const allowedOrigin = await value(this.options.origin, origin, interceptorOptions);
+      const allowedOriginArr = Array.isArray(allowedOrigin) ? allowedOrigin : [allowedOrigin];
+      if (allowedOriginArr.includes("*")) {
+        result.response.headers["access-control-allow-origin"] = "*";
+      } else {
+        if (allowedOriginArr.includes(origin)) {
+          result.response.headers["access-control-allow-origin"] = origin;
+        }
+        result.response.headers.vary = interceptorOptions.request.headers.vary ?? "origin";
+      }
+      const allowedTimingOrigin = await value(this.options.timingOrigin, origin, interceptorOptions);
+      const allowedTimingOriginArr = Array.isArray(allowedTimingOrigin) ? allowedTimingOrigin : [allowedTimingOrigin];
+      if (allowedTimingOriginArr.includes("*")) {
+        result.response.headers["timing-allow-origin"] = "*";
+      } else if (allowedTimingOriginArr.includes(origin)) {
+        result.response.headers["timing-allow-origin"] = origin;
+      }
+      if (this.options.credentials) {
+        result.response.headers["access-control-allow-credentials"] = "true";
+      }
+      if (this.options.exposeHeaders?.length) {
+        result.response.headers["access-control-expose-headers"] = this.options.exposeHeaders.join(",");
+      }
+      return result;
+    });
+  }
+};
+
+// src/plugins/response-headers.ts
+var ResponseHeadersPlugin = class {
+  init(options) {
+    options.interceptorsRoot ??= [];
+    options.interceptorsRoot.push(async (interceptorOptions) => {
+      const headers = new Headers();
+      interceptorOptions.context.resHeaders = headers;
+      const result = await interceptorOptions.next();
+      if (!result.matched) {
+        return result;
+      }
+      const responseHeaders = result.response.headers;
+      for (const [key, value2] of headers) {
+        if (Array.isArray(responseHeaders[key])) {
+          responseHeaders[key].push(value2);
+        } else if (responseHeaders[key] !== void 0) {
+          responseHeaders[key] = [responseHeaders[key], value2];
+        } else {
+          responseHeaders[key] = value2;
+        }
+      }
+      return result;
+    });
+  }
+};
+
+export {
+  CompositePlugin,
+  CORSPlugin,
+  ResponseHeadersPlugin
+};
+//# sourceMappingURL=chunk-XI6WGCB3.js.map

package/dist/fetch.js

@@ -1,15 +1,10 @@
-import "./chunk-WUOGVGWG.js";
 import {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports
-} from "./chunk-ESTRJAOX.js";
-import "./chunk-KK4SDLC7.js";
+  RPCHandler
+} from "./chunk-SVWPMCP4.js";
+import "./chunk-6TBBWYQ3.js";
+import "./chunk-RDEUEBK3.js";
+import "./chunk-XI6WGCB3.js";
 export {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports as SuperJSON
+  RPCHandler
 };
 //# sourceMappingURL=fetch.js.map