zudoku 0.41.2 → 0.41.3

package/lib/zudoku.plugin-openapi.js

@@ -3,7 +3,7 @@ import "lucide-react";
 import "./chunk-KNED5TY2-BUPjb3LQ.js";
 import "./hook-pPrHCB6G.js";
 import "./ui/Button.js";
-import { U as a, o as e } from "./index-pAogBEk7.js";
+import { U as a, o as e } from "./index-Dk7l9To6.js";
 export {
   a as UNTAGGED_PATH,
   e as openApiPlugin

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zudoku",
-  "version": "0.41.2",
+  "version": "0.41.3",
   "type": "module",
   "homepage": "https://zudoku.dev",
   "repository": {

package/src/lib/oas/parser/index.ts

@@ -1,6 +1,7 @@
 import { GraphQLError } from "graphql/error/index.js";
 import { OpenAPIV3, type OpenAPIV3_1 } from "openapi-types";
 import { dereference, type JSONSchema } from "./dereference/index.js";
+import { upgradeSchema } from "./upgrade/index.js";
 
 // Must be an interface (not a type) to allow merging with OpenAPI types with index signatures
 interface WithRef {
@@ -94,10 +95,8 @@ export const validate = async (schemaInput: unknown) => {
     throw new GraphQLError("OpenAPI version is not defined");
   }
 
-  const { upgrade } = await import("@scalar/openapi-parser");
-
   const dereferenced = await dereference(schema);
-  const upgraded = upgrade(dereferenced);
+  const upgraded = upgradeSchema(dereferenced);
 
-  return upgraded.specification;
+  return upgraded;
 };

package/src/lib/oas/parser/upgrade/index.ts

@@ -0,0 +1,103 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { type RecordAny, traverse } from "../../../util/traverse.js";
+import type { OpenAPIDocument } from "../index.js";
+/**
+ * Upgrade from OpenAPI 3.0.x to 3.1.0
+ *
+ * Taken from https://github.com/scalar/openapi-parser/blob/main/packages/openapi-parser/src/utils/upgradeFromThreeToThreeOne.ts
+ * https://www.openapis.org/blog/2021/02/16/migrating-from-openapi-3-0-to-3-1-0
+ */
+
+export const upgradeSchema = (schema: RecordAny): OpenAPIDocument => {
+  if (schema.openapi?.startsWith("3.0")) {
+    schema.openapi = "3.1.0";
+  }
+
+  schema = traverse(schema, (sub) => {
+    if (typeof sub.type !== "undefined" && sub.nullable === true) {
+      sub.type = ["null", sub.type];
+      delete sub.nullable;
+    }
+
+    return sub;
+  });
+
+  schema = traverse(schema, (sub) => {
+    if (sub.exclusiveMinimum === true) {
+      sub.exclusiveMinimum = sub.minimum;
+      delete sub.minimum;
+    } else if (sub.exclusiveMinimum === false) {
+      delete sub.exclusiveMinimum;
+    }
+
+    if (sub.exclusiveMaximum === true) {
+      sub.exclusiveMaximum = sub.maximum;
+      delete sub.maximum;
+    } else if (sub.exclusiveMaximum === false) {
+      delete sub.exclusiveMaximum;
+    }
+
+    return sub;
+  });
+
+  schema = traverse(schema, (sub) => {
+    // may be null or undefined
+    if (sub.example) {
+      const isExampleObject =
+        typeof sub.example === "object" &&
+        (sub.example.summary !== undefined ||
+          sub.example.description !== undefined ||
+          sub.example.value !== undefined ||
+          sub.example.externalValue !== undefined);
+
+      const exampleValue = isExampleObject
+        ? sub.example
+        : { value: sub.example };
+
+      if (!sub.examples) {
+        sub.examples = { default: exampleValue };
+      } else {
+        sub.examples = {
+          default: exampleValue,
+          ...sub.examples,
+        };
+      }
+      delete sub.example;
+    }
+    return sub;
+  });
+
+  schema = traverse(schema, (sub) => {
+    if (sub.type === "object" && sub.properties !== undefined) {
+      for (const [, value] of Object.entries(sub.properties)) {
+        const v = (value ?? {}) as RecordAny;
+        if (v.type === "string" && v.format === "binary") {
+          v.contentEncoding = "application/octet-stream";
+          delete v.format;
+        }
+      }
+    }
+    return sub;
+  });
+
+  schema = traverse(schema, (sub) => {
+    if (sub.type === "string" && sub.format === "binary") {
+      return undefined as any;
+    }
+
+    return sub;
+  });
+
+  schema = traverse(schema, (sub) => {
+    if (sub.type === "string" && sub.format === "base64") {
+      return {
+        type: "string",
+        contentEncoding: "base64",
+      };
+    }
+
+    return sub;
+  });
+
+  return schema as OpenAPIDocument;
+};