@orpc/openapi 0.34.0 → 0.35.1

package/dist/chunk-BHJYKXQL.js

@@ -0,0 +1,52 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/json-serializer.ts
+import { isPlainObject } from "@orpc/shared";
+var JSONSerializer = class {
+  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 (!isPlainObject(payload))
+      return payload;
+    return Object.keys(payload).reduce(
+      (carry, key) => {
+        const val = payload[key];
+        carry[key] = this.serialize(val);
+        return carry;
+      },
+      {}
+    );
+  }
+};
+
+// src/utils.ts
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+
+export {
+  __export,
+  JSONSerializer,
+  standardizeHTTPPath
+};
+//# sourceMappingURL=chunk-BHJYKXQL.js.map

package/dist/chunk-HQ34JZI7.js

@@ -0,0 +1,32 @@
+import {
+  OpenAPICodec,
+  OpenAPIMatcher
+} from "./chunk-M5HOHBLW.js";
+
+// src/adapters/fetch/openapi-handler.ts
+import { fetchRequestToStandardRequest, standardResponseToFetchResponse } from "@orpc/server/fetch";
+import { StandardHandler } from "@orpc/server/standard";
+var OpenAPIHandler = class {
+  standardHandler;
+  constructor(router, options) {
+    const matcher = options?.matcher ?? new OpenAPIMatcher(options);
+    const codec = options?.codec ?? new OpenAPICodec(options);
+    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 {
+  OpenAPIHandler
+};
+//# sourceMappingURL=chunk-HQ34JZI7.js.map

package/dist/chunk-M5HOHBLW.js

@@ -0,0 +1,432 @@
+import {
+  JSONSerializer,
+  __export,
+  standardizeHTTPPath
+} from "./chunk-BHJYKXQL.js";
+
+// src/adapters/standard/bracket-notation.ts
+var bracket_notation_exports = {};
+__export(bracket_notation_exports, {
+  deserialize: () => deserialize,
+  escapeSegment: () => escapeSegment,
+  parsePath: () => parsePath,
+  serialize: () => serialize,
+  stringifyPath: () => stringifyPath
+});
+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/adapters/standard/openapi-codec.ts
+import { fallbackContractConfig } from "@orpc/contract";
+import { isPlainObject as isPlainObject2, once } from "@orpc/shared";
+
+// src/adapters/standard/openapi-serializer.ts
+import { findDeepMatches } from "@orpc/shared";
+var OpenAPISerializer = class {
+  jsonSerializer;
+  constructor(options) {
+    this.jsonSerializer = options?.jsonSerializer ?? new JSONSerializer();
+  }
+  serialize(data) {
+    if (data instanceof Blob || data === void 0) {
+      return data;
+    }
+    const serializedJSON = this.jsonSerializer.serialize(data);
+    const { values: blobs } = findDeepMatches((v) => v instanceof Blob, serializedJSON);
+    if (blobs.length === 0) {
+      return serializedJSON;
+    }
+    const form = new FormData();
+    for (const [path, value] of serialize(serializedJSON)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        form.append(path, value.toString());
+      } else if (value instanceof Date) {
+        form.append(path, value.toISOString());
+      } else if (value instanceof Blob) {
+        form.append(path, value);
+      }
+    }
+    return form;
+  }
+  deserialize(serialized) {
+    if (serialized instanceof URLSearchParams || serialized instanceof FormData) {
+      return deserialize([...serialized.entries()]);
+    }
+    return serialized;
+  }
+};
+
+// src/adapters/standard/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/adapters/standard/openapi-codec.ts
+var OpenAPICodec = class {
+  serializer;
+  compositeSchemaCoercer;
+  constructor(options) {
+    this.serializer = options?.serializer ?? new OpenAPISerializer();
+    this.compositeSchemaCoercer = new CompositeSchemaCoercer(options?.schemaCoercers ?? []);
+  }
+  async decode(request, params, procedure) {
+    const inputStructure = fallbackContractConfig("defaultInputStructure", procedure["~orpc"].route.inputStructure);
+    if (inputStructure === "compact") {
+      const data = request.method === "GET" ? this.serializer.deserialize(request.url.searchParams) : this.serializer.deserialize(await request.body());
+      if (data === void 0) {
+        return this.compositeSchemaCoercer.coerce(procedure["~orpc"].inputSchema, params);
+      }
+      if (isPlainObject2(data)) {
+        return this.compositeSchemaCoercer.coerce(procedure["~orpc"].inputSchema, {
+          ...params,
+          ...data
+        });
+      }
+      return this.compositeSchemaCoercer.coerce(procedure["~orpc"].inputSchema, data);
+    }
+    const query = once(() => {
+      return this.serializer.deserialize(request.url.searchParams);
+    });
+    return this.compositeSchemaCoercer.coerce(procedure["~orpc"].inputSchema, {
+      params,
+      get query() {
+        return query();
+      },
+      headers: request.headers,
+      body: this.serializer.deserialize(await request.body())
+    });
+  }
+  encode(output, procedure) {
+    const successStatus = fallbackContractConfig("defaultSuccessStatus", procedure["~orpc"].route.successStatus);
+    const outputStructure = fallbackContractConfig("defaultOutputStructure", procedure["~orpc"].route.outputStructure);
+    if (outputStructure === "compact") {
+      return {
+        status: successStatus,
+        headers: {},
+        body: this.serializer.serialize(output)
+      };
+    }
+    if (!isPlainObject2(output)) {
+      throw new Error(
+        'Invalid output structure for "detailed" output. Expected format: { body: any, headers?: Record<string, string | string[] | undefined> }'
+      );
+    }
+    return {
+      status: successStatus,
+      headers: output.headers ?? {},
+      body: this.serializer.serialize(output.body)
+    };
+  }
+  encodeError(error) {
+    return {
+      status: error.status,
+      headers: {},
+      body: this.serializer.serialize(error.toJSON())
+    };
+  }
+};
+
+// src/adapters/standard/openapi-matcher.ts
+import { fallbackContractConfig as fallbackContractConfig2 } from "@orpc/contract";
+import { convertPathToHttpPath, createContractedProcedure, eachContractProcedure, getLazyRouterPrefix, getRouterChild, isProcedure, unlazy } from "@orpc/server";
+import { addRoute, createRouter, findRoute } from "rou3";
+var OpenAPIMatcher = class {
+  tree = createRouter();
+  ignoreUndefinedMethod;
+  constructor(options) {
+    this.ignoreUndefinedMethod = options?.ignoreUndefinedMethod ?? false;
+  }
+  pendingRouters = [];
+  init(router, path = []) {
+    const laziedOptions = eachContractProcedure({
+      router,
+      path
+    }, ({ path: path2, contract }) => {
+      if (!contract["~orpc"].route.method && this.ignoreUndefinedMethod) {
+        return;
+      }
+      const method = fallbackContractConfig2("defaultMethod", contract["~orpc"].route.method);
+      const httpPath = contract["~orpc"].route.path ? convertOpenAPIPathToRouterPath(contract["~orpc"].route.path) : convertPathToHttpPath(path2);
+      if (isProcedure(contract)) {
+        addRoute(this.tree, method, httpPath, {
+          path: path2,
+          contract,
+          procedure: contract,
+          // this mean dev not used contract-first so we can used contract as procedure directly
+          router
+        });
+      } else {
+        addRoute(this.tree, method, httpPath, {
+          path: path2,
+          contract,
+          procedure: void 0,
+          router
+        });
+      }
+    });
+    this.pendingRouters.push(...laziedOptions.map((option) => ({
+      ...option,
+      httpPathPrefix: convertPathToHttpPath(option.path),
+      laziedPrefix: getLazyRouterPrefix(option.lazied)
+    })));
+  }
+  async match(method, pathname) {
+    if (this.pendingRouters.length) {
+      const newPendingRouters = [];
+      for (const pendingRouter of this.pendingRouters) {
+        if (!pendingRouter.laziedPrefix || pathname.startsWith(pendingRouter.laziedPrefix) || 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 = findRoute(this.tree, method, pathname);
+    if (!match) {
+      return void 0;
+    }
+    if (!match.data.procedure) {
+      const { default: maybeProcedure } = await unlazy(getRouterChild(match.data.router, ...match.data.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${convertPathToHttpPath(match.data.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.data.procedure = createContractedProcedure(match.data.contract, maybeProcedure);
+    }
+    return {
+      path: match.data.path,
+      procedure: match.data.procedure,
+      params: match.params
+    };
+  }
+};
+function convertOpenAPIPathToRouterPath(path) {
+  return standardizeHTTPPath(path).replace(/\{([^}]+)\}/g, ":$1");
+}
+
+export {
+  bracket_notation_exports,
+  OpenAPISerializer,
+  CompositeSchemaCoercer,
+  OpenAPICodec,
+  OpenAPIMatcher
+};
+//# sourceMappingURL=chunk-M5HOHBLW.js.map

package/dist/fetch.js

@@ -1,34 +1,9 @@
 import {
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler
-} from "./chunk-VFGNQS5W.js";
-import {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
-} from "./chunk-SOVQ5ARD.js";
-import "./chunk-Q2LSK6YZ.js";
+  OpenAPIHandler
+} from "./chunk-HQ34JZI7.js";
+import "./chunk-M5HOHBLW.js";
+import "./chunk-BHJYKXQL.js";
 export {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
+  OpenAPIHandler
 };
 //# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -1,34 +1,9 @@
 import {
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler
-} from "./chunk-VFGNQS5W.js";
-import {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
-} from "./chunk-SOVQ5ARD.js";
-import "./chunk-Q2LSK6YZ.js";
+  OpenAPIHandler
+} from "./chunk-HQ34JZI7.js";
+import "./chunk-M5HOHBLW.js";
+import "./chunk-BHJYKXQL.js";
 export {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
+  OpenAPIHandler
 };
 //# sourceMappingURL=hono.js.map

package/dist/index.js

@@ -1,9 +1,7 @@
 import {
   JSONSerializer,
-  forEachAllContractProcedure,
-  forEachContractProcedure,
   standardizeHTTPPath
-} from "./chunk-Q2LSK6YZ.js";
+} from "./chunk-BHJYKXQL.js";
 
 // src/openapi.ts
 import { OpenApiBuilder } from "openapi3-ts/oas31";
@@ -37,6 +35,7 @@ var OpenAPIContentBuilder = class {
 
 // src/openapi-generator.ts
 import { fallbackContractConfig as fallbackContractConfig2, fallbackORPCErrorStatus } from "@orpc/contract";
+import { eachAllContractProcedure } from "@orpc/server";
 import { group } from "@orpc/shared";
 
 // src/openapi-error.ts
@@ -406,7 +405,10 @@ var OpenAPIGenerator = class {
       openapi: "3.1.1"
     });
     const rootTags = doc.tags?.map((tag) => tag.name) ?? [];
-    await forEachAllContractProcedure(router, ({ contract, path }) => {
+    await eachAllContractProcedure({
+      path: [],
+      router
+    }, ({ contract, path }) => {
       try {
         const def = contract["~orpc"];
         if (this.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
@@ -539,8 +541,6 @@ export {
   OpenAPIPathParser,
   OpenApiBuilder,
   SchemaUtils,
-  forEachAllContractProcedure,
-  forEachContractProcedure,
   standardizeHTTPPath
 };
 //# sourceMappingURL=index.js.map

package/dist/next.js

@@ -1,34 +1,9 @@
 import {
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler
-} from "./chunk-VFGNQS5W.js";
-import {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
-} from "./chunk-SOVQ5ARD.js";
-import "./chunk-Q2LSK6YZ.js";
+  OpenAPIHandler
+} from "./chunk-HQ34JZI7.js";
+import "./chunk-M5HOHBLW.js";
+import "./chunk-BHJYKXQL.js";
 export {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
+  OpenAPIHandler
 };
 //# sourceMappingURL=next.js.map