@orpc/server 0.0.0-next.c6c659d → 0.0.0-next.ccd4e42

package/dist/chunk-6RSW63UJ.js

@@ -0,0 +1,136 @@
+import {
+  RPCCodec,
+  RPCMatcher,
+  StandardHandler
+} from "./chunk-JHLUGXCM.js";
+
+// src/adapters/fetch/utils.ts
+import { once } from "@orpc/shared";
+import cd from "content-disposition";
+function fetchHeadersToStandardHeaders(headers) {
+  const standardHeaders = {};
+  for (const [key, value] of headers) {
+    if (Array.isArray(standardHeaders[key])) {
+      standardHeaders[key].push(value);
+    } else if (standardHeaders[key] !== void 0) {
+      standardHeaders[key] = [standardHeaders[key], value];
+    } else {
+      standardHeaders[key] = value;
+    }
+  }
+  return standardHeaders;
+}
+async function fetchReToStandardBody(re) {
+  if (!re.body) {
+    return void 0;
+  }
+  const contentDisposition = re.headers.get("content-disposition");
+  const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
+  if (fileName) {
+    const blob2 = await re.blob();
+    return new File([blob2], fileName, {
+      type: blob2.type
+    });
+  }
+  const contentType = re.headers.get("content-type");
+  if (!contentType || contentType.startsWith("application/json")) {
+    const text = await re.text();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+  if (contentType.startsWith("multipart/form-data")) {
+    return await re.formData();
+  }
+  if (contentType.startsWith("application/x-www-form-urlencoded")) {
+    return new URLSearchParams(await re.text());
+  }
+  if (contentType.startsWith("text/")) {
+    return await re.text();
+  }
+  const blob = await re.blob();
+  return new File([blob], "blob", {
+    type: blob.type
+  });
+}
+function fetchRequestToStandardRequest(request) {
+  const url = new URL(request.url);
+  return {
+    raw: { request },
+    url,
+    signal: request.signal,
+    method: request.method,
+    body: once(() => {
+      return fetchReToStandardBody(request);
+    }),
+    get headers() {
+      const headers = fetchHeadersToStandardHeaders(request.headers);
+      Object.defineProperty(this, "headers", { value: headers, writable: true });
+      return headers;
+    },
+    set headers(value) {
+      Object.defineProperty(this, "headers", { value, writable: true });
+    }
+  };
+}
+function standardResponseToFetchHeaders(response) {
+  const fetchHeaders = new Headers();
+  for (const [key, value] of Object.entries(response.headers)) {
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        fetchHeaders.append(key, v);
+      }
+    } else if (value !== void 0) {
+      fetchHeaders.append(key, value);
+    }
+  }
+  if (response.body instanceof Blob && !fetchHeaders.has("content-disposition")) {
+    fetchHeaders.set("content-disposition", cd(response.body instanceof File ? response.body.name : "blob"));
+  } else if (!(response.body instanceof Blob) && !(response.body instanceof URLSearchParams) && !(response.body instanceof FormData) && response.body !== void 0 && !fetchHeaders.has("content-type")) {
+    fetchHeaders.set("content-type", "application/json");
+  }
+  return fetchHeaders;
+}
+function standardBodyToFetchBody(body) {
+  if (body instanceof Blob || body instanceof FormData || body instanceof URLSearchParams) {
+    return body;
+  }
+  return JSON.stringify(body);
+}
+function standardResponseToFetchResponse(response) {
+  return new Response(standardBodyToFetchBody(response.body), {
+    headers: standardResponseToFetchHeaders(response),
+    status: response.status
+  });
+}
+
+// src/adapters/fetch/rpc-handler.ts
+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 = fetchRequestToStandardRequest(request);
+    const result = await this.standardHandler.handle(standardRequest, ...rest);
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: standardResponseToFetchResponse(result.response)
+    };
+  }
+};
+
+export {
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  standardBodyToFetchBody,
+  standardResponseToFetchResponse,
+  RPCHandler
+};
+//# sourceMappingURL=chunk-6RSW63UJ.js.map

package/dist/chunk-JHLUGXCM.js

@@ -0,0 +1,294 @@
+import {
+  convertPathToHttpPath,
+  createContractedProcedure,
+  createProcedureClient,
+  eachContractProcedure,
+  getRouterChild,
+  isProcedure,
+  unlazy
+} from "./chunk-NOA3GBJQ.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.matcher.init(router);
+  }
+  async handle(request, ...[options]) {
+    try {
+      return await intercept(
+        this.options,
+        { request, context: options?.context ?? {} },
+        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-JHLUGXCM.js.map