@orpc/openapi 0.45.1 → 0.47.0

package/dist/shared/openapi.C015V43J.mjs

@@ -0,0 +1,31 @@
+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.DFXD6scT.mjs';
+import '@orpc/shared';
+import 'json-schema-typed/draft-2020-12';
+
+class OpenAPIHandler {
+  standardHandler;
+  constructor(router, options = {}) {
+    const serializer = new OpenAPISerializer();
+    const matcher = new OpenAPIMatcher();
+    const codec = new OpenAPICodec(serializer);
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
+  }
+  async handle(request, ...[
+    options = {}
+  ]) {
+    const standardRequest = toStandardLazyRequest(request);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response, options)
+    };
+  }
+}
+
+export { OpenAPIHandler as O };

package/dist/shared/{openapi.CDsfPHgw.mjs → openapi.DFXD6scT.mjs}

@@ -1,12 +1,11 @@
 import { fallbackContractConfig } from '@orpc/contract';
-import { OpenAPISerializer } from '@orpc/openapi-client/standard';
 import { isObject } from '@orpc/shared';
 import { eachContractProcedure, convertPathToHttpPath, isProcedure, getLazyRouterPrefix, unlazy, getRouterChild, 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 = new OpenAPISerializer()) {
+  constructor(serializer) {
     this.serializer = serializer;
   }
   async decode(request, params, procedure) {
@@ -71,6 +70,13 @@ 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 = [];
@@ -138,11 +144,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.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.45.1",
+  "version": "0.47.0",
   "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.45.1",
-    "@orpc/server": "0.45.1",
-    "@orpc/contract": "0.45.1",
-    "@orpc/openapi-client": "0.45.1",
-    "@orpc/shared": "0.45.1",
-    "@orpc/standard-server": "0.45.1",
-    "@orpc/standard-server-fetch": "0.45.1",
-    "@orpc/standard-server-node": "0.45.1"
+    "@orpc/client": "0.47.0",
+    "@orpc/openapi-client": "0.47.0",
+    "@orpc/server": "0.47.0",
+    "@orpc/contract": "0.47.0",
+    "@orpc/standard-server-node": "0.47.0",
+    "@orpc/shared": "0.47.0",
+    "@orpc/standard-server-fetch": "0.47.0",
+    "@orpc/standard-server": "0.47.0"
   },
   "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 };

package/dist/shared/openapi.D0VMNR6V.mjs

@@ -1,25 +0,0 @@
-import { StandardHandler } from '@orpc/server/standard';
-import { toStandardRequest, toFetchResponse } from '@orpc/standard-server-fetch';
-import { a as OpenAPIMatcher, O as OpenAPICodec } from './openapi.CDsfPHgw.mjs';
-
-class OpenAPIHandler {
-  standardHandler;
-  constructor(router, options) {
-    const matcher = options?.matcher ?? new OpenAPIMatcher();
-    const codec = options?.codec ?? new OpenAPICodec();
-    this.standardHandler = new StandardHandler(router, matcher, codec, options);
-  }
-  async handle(request, ...[options]) {
-    const standardRequest = toStandardRequest(request);
-    const result = await this.standardHandler.handle(standardRequest, options);
-    if (!result.matched) {
-      return result;
-    }
-    return {
-      matched: true,
-      response: toFetchResponse(result.response, options)
-    };
-  }
-}
-
-export { OpenAPIHandler as O };

package/dist/shared/openapi.Dz_6xooR.d.mts

@@ -1,7 +0,0 @@
-import { Context } from '@orpc/server';
-import { RPCHandlerOptions } from '@orpc/server/standard';
-
-interface OpenAPIHandlerOptions<T extends Context> extends RPCHandlerOptions<T> {
-}
-
-export type { OpenAPIHandlerOptions as O };

package/dist/shared/openapi.Dz_6xooR.d.ts

@@ -1,7 +0,0 @@
-import { Context } from '@orpc/server';
-import { RPCHandlerOptions } from '@orpc/server/standard';
-
-interface OpenAPIHandlerOptions<T extends Context> extends RPCHandlerOptions<T> {
-}
-
-export type { OpenAPIHandlerOptions as O };