@orpc/openapi 0.0.0-next.68378b4 → 0.0.0-next.69674a7

package/dist/shared/{openapi.C_biOx82.mjs → openapi.CJTe38Ya.mjs}

@@ -1,8 +1,8 @@
 import { fallbackContractConfig } from '@orpc/contract';
 import { isObject } from '@orpc/shared';
-import { eachContractProcedure, convertPathToHttpPath, isProcedure, getLazyRouterPrefix, unlazy, getRouterChild, createContractedProcedure } from '@orpc/server';
+import { traverseContractProcedures, toHttpPath, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@orpc/server';
 import { createRouter, addRoute, findRoute } from 'rou3';
-import { s as standardizeHTTPPath } from './openapi.BHG_gu5Z.mjs';
+import { s as standardizeHTTPPath } from './openapi.DZzpQAb-.mjs';
 
 class OpenAPICodec {
   constructor(serializer) {
@@ -70,16 +70,20 @@ class OpenAPICodec {
   }
 }
 
+function toRou3Pattern(path) {
+  return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/**:$1").replace(/\/\{([^}]+)\}/g, "/:$1");
+}
+function decodeParams(params) {
+  return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, decodeURIComponent(value)]));
+}
+
 class OpenAPIMatcher {
   tree = createRouter();
   pendingRouters = [];
   init(router, path = []) {
-    const laziedOptions = eachContractProcedure({
-      router,
-      path
-    }, ({ path: path2, contract }) => {
+    const laziedOptions = traverseContractProcedures({ router, path }, ({ path: path2, contract }) => {
       const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route.method);
-      const httpPath = contract["~orpc"].route.path ? toRou3Pattern(contract["~orpc"].route.path) : convertPathToHttpPath(path2);
+      const httpPath = toRou3Pattern(contract["~orpc"].route.path ?? toHttpPath(path2));
       if (isProcedure(contract)) {
         addRoute(this.tree, method, httpPath, {
           path: path2,
@@ -99,8 +103,8 @@ class OpenAPIMatcher {
     });
     this.pendingRouters.push(...laziedOptions.map((option) => ({
       ...option,
-      httpPathPrefix: convertPathToHttpPath(option.path),
-      laziedPrefix: getLazyRouterPrefix(option.lazied)
+      httpPathPrefix: toHttpPath(option.path),
+      laziedPrefix: getLazyMeta(option.router).prefix
     })));
   }
   async match(method, pathname) {
@@ -108,7 +112,7 @@ class OpenAPIMatcher {
       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);
+          const { default: router } = await unlazy(pendingRouter.router);
           this.init(router, pendingRouter.path);
         } else {
           newPendingRouters.push(pendingRouter);
@@ -121,14 +125,14 @@ class OpenAPIMatcher {
       return void 0;
     }
     if (!match.data.procedure) {
-      const { default: maybeProcedure } = await unlazy(getRouterChild(match.data.router, ...match.data.path));
+      const { default: maybeProcedure } = await unlazy(getRouter(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)}.
+          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.data.path)}.
           Ensure that the procedure is correctly defined and matches the expected contract.
         `);
       }
-      match.data.procedure = createContractedProcedure(match.data.contract, maybeProcedure);
+      match.data.procedure = createContractedProcedure(maybeProcedure, match.data.contract);
     }
     return {
       path: match.data.path,
@@ -137,11 +141,5 @@ class OpenAPIMatcher {
     };
   }
 }
-function toRou3Pattern(path) {
-  return standardizeHTTPPath(path).replace(/\{\+([^}]+)\}/g, "**:$1").replace(/\{([^}]+)\}/g, ":$1");
-}
-function decodeParams(params) {
-  return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, decodeURIComponent(value)]));
-}
 
-export { OpenAPICodec as O, OpenAPIMatcher as a };
+export { OpenAPICodec as O, OpenAPIMatcher as a, decodeParams as d, toRou3Pattern as t };

package/dist/shared/{openapi.B6uueFtN.mjs → openapi.CbzTVvGL.mjs}

@@ -1,7 +1,9 @@
 import { OpenAPISerializer } from '@orpc/openapi-client/standard';
 import { StandardHandler } from '@orpc/server/standard';
 import { toStandardLazyRequest, toFetchResponse } from '@orpc/standard-server-fetch';
-import { a as OpenAPIMatcher, O as OpenAPICodec } from './openapi.C_biOx82.mjs';
+import { a as OpenAPIMatcher, O as OpenAPICodec } from './openapi.CJTe38Ya.mjs';
+import '@orpc/shared';
+import 'json-schema-typed/draft-2020-12';
 
 class OpenAPIHandler {
   standardHandler;

package/dist/shared/openapi.DZzpQAb-.mjs

@@ -0,0 +1,231 @@
+import { isObject, findDeepMatches } from '@orpc/shared';
+import 'json-schema-typed/draft-2020-12';
+
+const LOGIC_KEYWORDS = [
+  "$dynamicRef",
+  "$ref",
+  "additionalItems",
+  "additionalProperties",
+  "allOf",
+  "anyOf",
+  "const",
+  "contains",
+  "contentEncoding",
+  "contentMediaType",
+  "contentSchema",
+  "dependencies",
+  "dependentRequired",
+  "dependentSchemas",
+  "else",
+  "enum",
+  "exclusiveMaximum",
+  "exclusiveMinimum",
+  "format",
+  "if",
+  "items",
+  "maxContains",
+  "maximum",
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "minContains",
+  "minimum",
+  "minItems",
+  "minLength",
+  "minProperties",
+  "multipleOf",
+  "not",
+  "oneOf",
+  "pattern",
+  "patternProperties",
+  "prefixItems",
+  "properties",
+  "propertyNames",
+  "required",
+  "then",
+  "type",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+  "uniqueItems"
+];
+
+function isFileSchema(schema) {
+  return isObject(schema) && schema.type === "string" && typeof schema.contentMediaType === "string";
+}
+function isObjectSchema(schema) {
+  return isObject(schema) && schema.type === "object";
+}
+function isAnySchema(schema) {
+  if (schema === true) {
+    return true;
+  }
+  if (Object.keys(schema).every((k) => !LOGIC_KEYWORDS.includes(k))) {
+    return true;
+  }
+  return false;
+}
+function separateObjectSchema(schema, separatedProperties) {
+  if (Object.keys(schema).some((k) => k !== "type" && k !== "properties" && k !== "required" && LOGIC_KEYWORDS.includes(k))) {
+    return [{ type: "object" }, schema];
+  }
+  const matched = { ...schema };
+  const rest = { ...schema };
+  matched.properties = schema.properties && Object.entries(schema.properties).filter(([key]) => separatedProperties.includes(key)).reduce((acc, [key, value]) => {
+    acc[key] = value;
+    return acc;
+  }, {});
+  matched.required = schema.required?.filter((key) => separatedProperties.includes(key));
+  matched.examples = schema.examples?.map((example) => {
+    if (!isObject(example)) {
+      return example;
+    }
+    return Object.entries(example).reduce((acc, [key, value]) => {
+      if (separatedProperties.includes(key)) {
+        acc[key] = value;
+      }
+      return acc;
+    }, {});
+  });
+  rest.properties = schema.properties && Object.entries(schema.properties).filter(([key]) => !separatedProperties.includes(key)).reduce((acc, [key, value]) => {
+    acc[key] = value;
+    return acc;
+  }, {});
+  rest.required = schema.required?.filter((key) => !separatedProperties.includes(key));
+  rest.examples = schema.examples?.map((example) => {
+    if (!isObject(example)) {
+      return example;
+    }
+    return Object.entries(example).reduce((acc, [key, value]) => {
+      if (!separatedProperties.includes(key)) {
+        acc[key] = value;
+      }
+      return acc;
+    }, {});
+  });
+  return [matched, rest];
+}
+function filterSchemaBranches(schema, check, matches = []) {
+  if (check(schema)) {
+    matches.push(schema);
+    return [matches, void 0];
+  }
+  if (isObject(schema)) {
+    for (const keyword of ["anyOf", "oneOf"]) {
+      if (schema[keyword] && Object.keys(schema).every(
+        (k) => k === keyword || !LOGIC_KEYWORDS.includes(k)
+      )) {
+        const rest = schema[keyword].map((s) => filterSchemaBranches(s, check, matches)[1]).filter((v) => !!v);
+        if (rest.length === 1 && typeof rest[0] === "object") {
+          return [matches, { ...schema, [keyword]: void 0, ...rest[0] }];
+        }
+        return [matches, { ...schema, [keyword]: rest }];
+      }
+    }
+  }
+  return [matches, schema];
+}
+
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function toOpenAPIPath(path) {
+  return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/{$1}");
+}
+function toOpenAPIMethod(method) {
+  return method.toLocaleLowerCase();
+}
+function getDynamicParams(path) {
+  return path ? standardizeHTTPPath(path).match(/\/\{([^}]+)\}/g)?.map((v) => v.match(/\{\+?([^}]+)\}/)[1]) : void 0;
+}
+function toOpenAPIContent(schema) {
+  const content = {};
+  const [matches, restSchema] = filterSchemaBranches(schema, isFileSchema);
+  for (const file of matches) {
+    content[file.contentMediaType] = {
+      schema: toOpenAPISchema(file)
+    };
+  }
+  if (restSchema !== void 0) {
+    content["application/json"] = {
+      schema: toOpenAPISchema(restSchema)
+    };
+    const isStillHasFileSchema = findDeepMatches((v) => isObject(v) && isFileSchema(v), restSchema).values.length > 0;
+    if (isStillHasFileSchema) {
+      content["multipart/form-data"] = {
+        schema: toOpenAPISchema(restSchema)
+      };
+    }
+  }
+  return content;
+}
+function toOpenAPIEventIteratorContent([yieldsRequired, yieldsSchema], [returnsRequired, returnsSchema]) {
+  return {
+    "text/event-stream": {
+      schema: toOpenAPISchema({
+        oneOf: [
+          {
+            type: "object",
+            properties: {
+              event: { const: "message" },
+              data: yieldsSchema,
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: yieldsRequired ? ["event", "data"] : ["event"]
+          },
+          {
+            type: "object",
+            properties: {
+              event: { const: "done" },
+              data: returnsSchema,
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: returnsRequired ? ["event", "data"] : ["event"]
+          },
+          {
+            type: "object",
+            properties: {
+              event: { const: "error" },
+              data: {},
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: ["event"]
+          }
+        ]
+      })
+    }
+  };
+}
+function toOpenAPIParameters(schema, parameterIn) {
+  const parameters = [];
+  for (const key in schema.properties) {
+    const keySchema = schema.properties[key];
+    parameters.push({
+      name: key,
+      in: parameterIn,
+      required: schema.required?.includes(key),
+      style: parameterIn === "query" ? "deepObject" : void 0,
+      explode: parameterIn === "query" ? true : void 0,
+      schema: toOpenAPISchema(keySchema)
+    });
+  }
+  return parameters;
+}
+function checkParamsSchema(schema, params) {
+  const properties = Object.keys(schema.properties ?? {});
+  const required = schema.required ?? [];
+  if (properties.length !== params.length || properties.some((v) => !params.includes(v))) {
+    return false;
+  }
+  if (required.length !== params.length || required.some((v) => !params.includes(v))) {
+    return false;
+  }
+  return true;
+}
+function toOpenAPISchema(schema) {
+  return schema === true ? {} : schema === false ? { not: {} } : schema;
+}
+
+export { LOGIC_KEYWORDS as L, toOpenAPIPath as a, toOpenAPIEventIteratorContent as b, isObjectSchema as c, separateObjectSchema as d, checkParamsSchema as e, toOpenAPIParameters as f, getDynamicParams as g, toOpenAPIContent as h, isAnySchema as i, toOpenAPISchema as j, isFileSchema as k, filterSchemaBranches as l, standardizeHTTPPath as s, toOpenAPIMethod as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.0.0-next.68378b4",
+  "version": "0.0.0-next.69674a7",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -50,19 +50,19 @@
   ],
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "openapi3-ts": "^4.4.0",
+    "openapi-types": "^12.1.3",
     "rou3": "^0.5.1",
-    "@orpc/client": "0.0.0-next.68378b4",
-    "@orpc/openapi-client": "0.0.0-next.68378b4",
-    "@orpc/contract": "0.0.0-next.68378b4",
-    "@orpc/server": "0.0.0-next.68378b4",
-    "@orpc/shared": "0.0.0-next.68378b4",
-    "@orpc/standard-server": "0.0.0-next.68378b4",
-    "@orpc/standard-server-fetch": "0.0.0-next.68378b4",
-    "@orpc/standard-server-node": "0.0.0-next.68378b4"
+    "@orpc/client": "0.0.0-next.69674a7",
+    "@orpc/contract": "0.0.0-next.69674a7",
+    "@orpc/openapi-client": "0.0.0-next.69674a7",
+    "@orpc/server": "0.0.0-next.69674a7",
+    "@orpc/shared": "0.0.0-next.69674a7",
+    "@orpc/standard-server": "0.0.0-next.69674a7",
+    "@orpc/standard-server-fetch": "0.0.0-next.69674a7",
+    "@orpc/standard-server-node": "0.0.0-next.69674a7"
   },
   "devDependencies": {
-    "zod": "^3.24.1"
+    "zod": "^3.24.2"
   },
   "scripts": {
     "build": "unbuild",

package/dist/shared/openapi.BHG_gu5Z.mjs

@@ -1,8 +0,0 @@
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-function toOpenAPI31RoutePattern(path) {
-  return standardizeHTTPPath(path).replace(/\{\+([^}]+)\}/g, "{$1}");
-}
-
-export { standardizeHTTPPath as s, toOpenAPI31RoutePattern as t };