@orpc/openapi 0.17.0 → 0.18.0

package/dist/chunk-UPDKQRQG.js

@@ -0,0 +1,665 @@
+// src/fetch/bracket-notation.ts
+import { isPlainObject } from "@orpc/shared";
+function serialize(payload, parentKey = "") {
+  if (!Array.isArray(payload) && !isPlainObject(payload))
+    return [["", payload]];
+  const result = [];
+  function helper(value, path) {
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        helper(item, [...path, String(index)]);
+      });
+    } else if (isPlainObject(value)) {
+      for (const [key, val] of Object.entries(value)) {
+        helper(val, [...path, key]);
+      }
+    } else {
+      result.push([stringifyPath(path), value]);
+    }
+  }
+  helper(payload, parentKey ? [parentKey] : []);
+  return result;
+}
+function deserialize(entities) {
+  if (entities.length === 0) {
+    return void 0;
+  }
+  const isRootArray = entities.every(([path]) => path === "");
+  const result = isRootArray ? [] : {};
+  const arrayPushPaths = /* @__PURE__ */ new Set();
+  for (const [path, _] of entities) {
+    const segments = parsePath(path);
+    const base = segments.slice(0, -1).join(".");
+    const last = segments[segments.length - 1];
+    if (last === "") {
+      arrayPushPaths.add(base);
+    } else {
+      arrayPushPaths.delete(base);
+    }
+  }
+  function setValue(obj, segments, value, fullPath) {
+    const [first, ...rest_] = segments;
+    if (Array.isArray(obj) && first === "") {
+      ;
+      obj.push(value);
+      return;
+    }
+    const objAsRecord = obj;
+    if (rest_.length === 0) {
+      objAsRecord[first] = value;
+      return;
+    }
+    const rest = rest_;
+    if (rest[0] === "") {
+      const pathToCheck = segments.slice(0, -1).join(".");
+      if (rest.length === 1 && arrayPushPaths.has(pathToCheck)) {
+        if (!(first in objAsRecord)) {
+          objAsRecord[first] = [];
+        }
+        if (Array.isArray(objAsRecord[first])) {
+          ;
+          objAsRecord[first].push(value);
+          return;
+        }
+      }
+      if (!(first in objAsRecord)) {
+        objAsRecord[first] = {};
+      }
+      const target = objAsRecord[first];
+      target[""] = value;
+      return;
+    }
+    if (!(first in objAsRecord)) {
+      objAsRecord[first] = {};
+    }
+    setValue(
+      objAsRecord[first],
+      rest,
+      value,
+      fullPath
+    );
+  }
+  for (const [path, value] of entities) {
+    const segments = parsePath(path);
+    setValue(result, segments, value, path);
+  }
+  return result;
+}
+function escapeSegment(segment) {
+  return segment.replace(/[\\[\]]/g, (match) => {
+    switch (match) {
+      case "\\":
+        return "\\\\";
+      case "[":
+        return "\\[";
+      case "]":
+        return "\\]";
+      default:
+        return match;
+    }
+  });
+}
+function stringifyPath(path) {
+  const [first, ...rest] = path;
+  const firstSegment = escapeSegment(first);
+  const base = first === "" ? "" : firstSegment;
+  return rest.reduce(
+    (result, segment) => `${result}[${escapeSegment(segment)}]`,
+    base
+  );
+}
+function parsePath(path) {
+  if (path === "")
+    return [""];
+  const result = [];
+  let currentSegment = "";
+  let inBracket = false;
+  let bracketContent = "";
+  let backslashCount = 0;
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i];
+    if (char === "\\") {
+      backslashCount++;
+      continue;
+    }
+    if (backslashCount > 0) {
+      const literalBackslashes = "\\".repeat(Math.floor(backslashCount / 2));
+      if (char === "[" || char === "]") {
+        if (backslashCount % 2 === 1) {
+          if (inBracket) {
+            bracketContent += literalBackslashes + char;
+          } else {
+            currentSegment += literalBackslashes + char;
+          }
+        } else {
+          if (inBracket) {
+            bracketContent += literalBackslashes;
+          } else {
+            currentSegment += literalBackslashes;
+          }
+          if (char === "[" && !inBracket) {
+            if (currentSegment !== "" || result.length === 0) {
+              result.push(currentSegment);
+            }
+            inBracket = true;
+            bracketContent = "";
+            currentSegment = "";
+          } else if (char === "]" && inBracket) {
+            result.push(bracketContent);
+            inBracket = false;
+            bracketContent = "";
+          } else {
+            if (inBracket) {
+              bracketContent += char;
+            } else {
+              currentSegment += char;
+            }
+          }
+        }
+      } else {
+        const allBackslashes = "\\".repeat(backslashCount);
+        if (inBracket) {
+          bracketContent += allBackslashes + char;
+        } else {
+          currentSegment += allBackslashes + char;
+        }
+      }
+      backslashCount = 0;
+      continue;
+    }
+    if (char === "[" && !inBracket) {
+      if (currentSegment !== "" || result.length === 0) {
+        result.push(currentSegment);
+      }
+      inBracket = true;
+      bracketContent = "";
+      currentSegment = "";
+      continue;
+    }
+    if (char === "]" && inBracket) {
+      result.push(bracketContent);
+      inBracket = false;
+      bracketContent = "";
+      continue;
+    }
+    if (inBracket) {
+      bracketContent += char;
+    } else {
+      currentSegment += char;
+    }
+  }
+  if (backslashCount > 0) {
+    const remainingBackslashes = "\\".repeat(backslashCount);
+    if (inBracket) {
+      bracketContent += remainingBackslashes;
+    } else {
+      currentSegment += remainingBackslashes;
+    }
+  }
+  if (inBracket) {
+    if (currentSegment !== "" || result.length === 0) {
+      result.push(currentSegment);
+    }
+    result.push(`[${bracketContent}`);
+  } else if (currentSegment !== "" || result.length === 0) {
+    result.push(currentSegment);
+  }
+  return result;
+}
+
+// src/fetch/input-builder-full.ts
+var InputBuilderFull = class {
+  build(params, query, headers, body) {
+    return {
+      params,
+      query,
+      headers,
+      body
+    };
+  }
+};
+
+// src/fetch/input-builder-simple.ts
+import { isPlainObject as isPlainObject2 } from "@orpc/shared";
+var InputBuilderSimple = class {
+  build(params, payload) {
+    if (Object.keys(params).length === 0) {
+      return payload;
+    }
+    if (!isPlainObject2(payload)) {
+      return params;
+    }
+    return {
+      ...params,
+      ...payload
+    };
+  }
+};
+
+// src/fetch/openapi-handler.ts
+import { createProcedureClient, ORPCError as ORPCError2 } from "@orpc/server";
+import { executeWithHooks, ORPC_HANDLER_HEADER, trim } from "@orpc/shared";
+
+// src/fetch/openapi-payload-codec.ts
+import { ORPCError } from "@orpc/server";
+import { findDeepMatches, isPlainObject as isPlainObject3 } from "@orpc/shared";
+import cd from "content-disposition";
+import { safeParse } from "fast-content-type-parse";
+import wcmatch from "wildcard-match";
+var OpenAPIPayloadCodec = class {
+  encode(payload, accept) {
+    const typeMatchers = (accept?.split(",").map(safeParse) ?? [{ type: "*/*" }]).map(({ type }) => wcmatch(type));
+    if (payload instanceof Blob) {
+      const contentType = payload.type || "application/octet-stream";
+      if (typeMatchers.some((isMatch) => isMatch(contentType))) {
+        const headers = new Headers({
+          "Content-Type": contentType
+        });
+        if (payload instanceof File && payload.name) {
+          headers.append("Content-Disposition", cd(payload.name));
+        }
+        return {
+          body: payload,
+          headers
+        };
+      }
+    }
+    const handledPayload = this.serialize(payload);
+    const hasBlobs = findDeepMatches((v) => v instanceof Blob, handledPayload).values.length > 0;
+    const isExpectedMultipartFormData = typeMatchers.some(
+      (isMatch) => isMatch("multipart/form-data")
+    );
+    if (hasBlobs && isExpectedMultipartFormData) {
+      return this.encodeAsFormData(handledPayload);
+    }
+    if (typeMatchers.some((isMatch) => isMatch("application/json"))) {
+      return this.encodeAsJSON(handledPayload);
+    }
+    if (typeMatchers.some(
+      (isMatch) => isMatch("application/x-www-form-urlencoded")
+    )) {
+      return this.encodeAsURLSearchParams(handledPayload);
+    }
+    if (isExpectedMultipartFormData) {
+      return this.encodeAsFormData(handledPayload);
+    }
+    throw new ORPCError({
+      code: "NOT_ACCEPTABLE",
+      message: `Unsupported content-type: ${accept}`
+    });
+  }
+  encodeAsJSON(payload) {
+    if (payload === void 0) {
+      return {
+        body: void 0,
+        headers: new Headers({
+          "content-type": "application/json"
+        })
+      };
+    }
+    return {
+      body: JSON.stringify(payload),
+      headers: new Headers({
+        "content-type": "application/json"
+      })
+    };
+  }
+  encodeAsFormData(payload) {
+    const form = new FormData();
+    for (const [path, value] of serialize(payload)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        form.append(path, value.toString());
+      } else if (value === null) {
+        form.append(path, "null");
+      } else if (value instanceof Date) {
+        form.append(
+          path,
+          Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString()
+        );
+      } else if (value instanceof Blob) {
+        form.append(path, value);
+      }
+    }
+    return {
+      body: form
+    };
+  }
+  encodeAsURLSearchParams(payload) {
+    const params = new URLSearchParams();
+    for (const [path, value] of serialize(payload)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        params.append(path, value.toString());
+      } else if (value === null) {
+        params.append(path, "null");
+      } else if (value instanceof Date) {
+        params.append(
+          path,
+          Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString()
+        );
+      }
+    }
+    return {
+      body: params.toString(),
+      headers: new Headers({
+        "content-type": "application/x-www-form-urlencoded"
+      })
+    };
+  }
+  serialize(payload) {
+    if (payload instanceof Set)
+      return this.serialize([...payload]);
+    if (payload instanceof Map)
+      return this.serialize([...payload.entries()]);
+    if (Array.isArray(payload)) {
+      return payload.map((v) => v === void 0 ? "undefined" : this.serialize(v));
+    }
+    if (Number.isNaN(payload))
+      return "NaN";
+    if (typeof payload === "bigint")
+      return payload.toString();
+    if (payload instanceof Date && Number.isNaN(payload.getTime())) {
+      return "Invalid Date";
+    }
+    if (payload instanceof RegExp)
+      return payload.toString();
+    if (payload instanceof URL)
+      return payload.toString();
+    if (!isPlainObject3(payload))
+      return payload;
+    return Object.keys(payload).reduce(
+      (carry, key) => {
+        const val = payload[key];
+        carry[key] = this.serialize(val);
+        return carry;
+      },
+      {}
+    );
+  }
+  async decode(re) {
+    if (re instanceof Headers || re instanceof URLSearchParams || re instanceof FormData) {
+      return deserialize([...re.entries()]);
+    }
+    const contentType = re.headers.get("content-type");
+    const contentDisposition = re.headers.get("content-disposition");
+    const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
+    if (fileName) {
+      const blob2 = await re.blob();
+      const file = new File([blob2], fileName, {
+        type: blob2.type
+      });
+      return file;
+    }
+    if (!contentType || contentType.startsWith("application/json")) {
+      if (!re.body) {
+        return void 0;
+      }
+      return await re.json();
+    }
+    if (contentType.startsWith("application/x-www-form-urlencoded")) {
+      const params = new URLSearchParams(await re.text());
+      return this.decode(params);
+    }
+    if (contentType.startsWith("text/")) {
+      const text = await re.text();
+      return text;
+    }
+    if (contentType.startsWith("multipart/form-data")) {
+      const form = await re.formData();
+      return this.decode(form);
+    }
+    const blob = await re.blob();
+    return new File([blob], "blob", {
+      type: blob.type
+    });
+  }
+};
+
+// src/fetch/openapi-procedure-matcher.ts
+import { getLazyRouterPrefix, getRouterChild, isProcedure as isProcedure2, unlazy } from "@orpc/server";
+import { mapValues } from "@orpc/shared";
+
+// src/utils.ts
+import { isContractProcedure } from "@orpc/contract";
+import { getRouterContract, isLazy, isProcedure } from "@orpc/server";
+function forEachContractProcedure(options, callback, result = [], isCurrentRouterContract = false) {
+  const hiddenContract = getRouterContract(options.router);
+  if (!isCurrentRouterContract && hiddenContract) {
+    return forEachContractProcedure(
+      {
+        path: options.path,
+        router: hiddenContract
+      },
+      callback,
+      result,
+      true
+    );
+  }
+  if (isLazy(options.router)) {
+    result.push({
+      router: options.router,
+      path: options.path
+    });
+  } else if (isProcedure(options.router)) {
+    callback({
+      contract: options.router["~orpc"].contract,
+      path: options.path
+    });
+  } else if (isContractProcedure(options.router)) {
+    callback({
+      contract: options.router,
+      path: options.path
+    });
+  } else {
+    for (const key in options.router) {
+      forEachContractProcedure(
+        {
+          router: options.router[key],
+          path: [...options.path, key]
+        },
+        callback,
+        result
+      );
+    }
+  }
+  return result;
+}
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+
+// src/fetch/openapi-procedure-matcher.ts
+var OpenAPIProcedureMatcher = class {
+  constructor(hono, router) {
+    this.hono = hono;
+    this.router = router;
+    this.pendingRouters = [{ path: [], router }];
+  }
+  pendingRouters;
+  async match(method, pathname) {
+    await this.handlePendingRouters(pathname);
+    const [matches, paramStash] = this.hono.match(method, pathname);
+    const [match] = matches.sort((a, b) => {
+      const slashCountA = a[0][0].split("/").length;
+      const slashCountB = b[0][0].split("/").length;
+      if (slashCountA !== slashCountB) {
+        return slashCountB - slashCountA;
+      }
+      const paramsCountA = Object.keys(a[1]).length;
+      const paramsCountB = Object.keys(b[1]).length;
+      return paramsCountA - paramsCountB;
+    });
+    if (!match) {
+      return void 0;
+    }
+    const path = match[0][1];
+    const params = paramStash ? mapValues(
+      match[1],
+      // if paramStash is defined, then match[1] is ParamIndexMap
+      (v) => paramStash[v]
+    ) : match[1];
+    const { default: maybeProcedure } = await unlazy(getRouterChild(this.router, ...path));
+    if (!isProcedure2(maybeProcedure)) {
+      return void 0;
+    }
+    return {
+      path,
+      procedure: maybeProcedure,
+      params: { ...params }
+      // normalize params from hono
+    };
+  }
+  add(path, router) {
+    const lazies = forEachContractProcedure({ path, router }, ({ path: path2, contract }) => {
+      const method = contract["~orpc"].route?.method ?? "POST";
+      const httpPath = contract["~orpc"].route?.path ? this.convertOpenAPIPathToRouterPath(contract["~orpc"].route?.path) : `/${path2.map(encodeURIComponent).join("/")}`;
+      this.hono.add(method, httpPath, [httpPath, path2]);
+    });
+    this.pendingRouters.push(...lazies);
+  }
+  async handlePendingRouters(pathname) {
+    const newPendingLazyRouters = [];
+    for (const item of this.pendingRouters) {
+      const lazyPrefix = getLazyRouterPrefix(item.router);
+      if (lazyPrefix && !pathname.startsWith(lazyPrefix) && !pathname.startsWith(`/${item.path.map(encodeURIComponent).join("/")}`)) {
+        newPendingLazyRouters.push(item);
+        continue;
+      }
+      const { default: router } = await unlazy(item.router);
+      this.add(item.path, router);
+    }
+    this.pendingRouters = newPendingLazyRouters;
+  }
+  convertOpenAPIPathToRouterPath(path) {
+    return standardizeHTTPPath(path).replace(/\{([^}]+)\}/g, ":$1");
+  }
+};
+
+// src/fetch/schema-coercer.ts
+var CompositeSchemaCoercer = class {
+  constructor(coercers) {
+    this.coercers = coercers;
+  }
+  coerce(schema, value) {
+    let current = value;
+    for (const coercer of this.coercers) {
+      current = coercer.coerce(schema, current);
+    }
+    return current;
+  }
+};
+
+// src/fetch/openapi-handler.ts
+var OpenAPIHandler = class {
+  constructor(hono, router, options) {
+    this.options = options;
+    this.procedureMatcher = options?.procedureMatcher ?? new OpenAPIProcedureMatcher(hono, router);
+    this.payloadCodec = options?.payloadCodec ?? new OpenAPIPayloadCodec();
+    this.inputBuilderSimple = options?.inputBuilderSimple ?? new InputBuilderSimple();
+    this.inputBuilderFull = options?.inputBuilderFull ?? new InputBuilderFull();
+    this.compositeSchemaCoercer = new CompositeSchemaCoercer(options?.schemaCoercers ?? []);
+  }
+  procedureMatcher;
+  payloadCodec;
+  inputBuilderSimple;
+  inputBuilderFull;
+  compositeSchemaCoercer;
+  condition(request) {
+    return request.headers.get(ORPC_HANDLER_HEADER) === null;
+  }
+  async fetch(request, ...[options]) {
+    const context = options?.context;
+    const headers = request.headers;
+    const accept = headers.get("Accept") || void 0;
+    const execute = async () => {
+      const url = new URL(request.url);
+      const pathname = `/${trim(url.pathname.replace(options?.prefix ?? "", ""), "/")}`;
+      const query = url.searchParams;
+      const customMethod = request.method === "POST" ? query.get("method")?.toUpperCase() : void 0;
+      const method = customMethod || request.method;
+      const match = await this.procedureMatcher.match(method, pathname);
+      if (!match) {
+        throw new ORPCError2({ code: "NOT_FOUND", message: "Not found" });
+      }
+      const decodedPayload = request.method === "GET" ? await this.payloadCodec.decode(query) : await this.payloadCodec.decode(request);
+      const input = this.inputBuilderSimple.build(match.params, decodedPayload);
+      const coercedInput = this.compositeSchemaCoercer.coerce(match.procedure["~orpc"].contract["~orpc"].InputSchema, input);
+      const client = createProcedureClient({
+        context,
+        procedure: match.procedure,
+        path: match.path
+      });
+      const output = await client(coercedInput, { signal: options?.signal });
+      const { body, headers: headers2 } = this.payloadCodec.encode(output);
+      return new Response(body, { headers: headers2 });
+    };
+    try {
+      return await executeWithHooks({
+        context,
+        execute,
+        input: request,
+        hooks: this.options,
+        meta: {
+          signal: options?.signal
+        }
+      });
+    } catch (e) {
+      const error = this.convertToORPCError(e);
+      try {
+        const { body, headers: headers2 } = this.payloadCodec.encode(error.toJSON(), accept);
+        return new Response(body, {
+          status: error.status,
+          headers: headers2
+        });
+      } catch (e2) {
+        const error2 = this.convertToORPCError(e2);
+        const { body, headers: headers2 } = this.payloadCodec.encode(error2.toJSON());
+        return new Response(body, {
+          status: error2.status,
+          headers: headers2
+        });
+      }
+    }
+  }
+  convertToORPCError(e) {
+    return e instanceof ORPCError2 ? e : new ORPCError2({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Internal server error",
+      cause: e
+    });
+  }
+};
+
+// src/fetch/openapi-handler-server.ts
+import { TrieRouter } from "hono/router/trie-router";
+var OpenAPIServerHandler = class extends OpenAPIHandler {
+  constructor(router, options) {
+    super(new TrieRouter(), router, options);
+  }
+};
+
+// src/fetch/openapi-handler-serverless.ts
+import { LinearRouter } from "hono/router/linear-router";
+var OpenAPIServerlessHandler = class extends OpenAPIHandler {
+  constructor(router, options) {
+    super(new LinearRouter(), router, options);
+  }
+};
+
+export {
+  serialize,
+  deserialize,
+  escapeSegment,
+  stringifyPath,
+  parsePath,
+  InputBuilderFull,
+  InputBuilderSimple,
+  OpenAPIPayloadCodec,
+  forEachContractProcedure,
+  standardizeHTTPPath,
+  OpenAPIProcedureMatcher,
+  CompositeSchemaCoercer,
+  OpenAPIHandler,
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+};
+//# sourceMappingURL=chunk-UPDKQRQG.js.map