@sdk-it/spec 0.31.0 → 0.31.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdk-it/spec",
-  "version": "0.31.0",
+  "version": "0.31.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -23,10 +23,11 @@
   },
   "files": [
     "dist",
-    "!**/*.tsbuildinfo"
+    "!**/*.tsbuildinfo",
+    "!**/*.test.*"
   ],
   "dependencies": {
-    "@sdk-it/core": "0.31.0",
+    "@sdk-it/core": "0.31.1",
     "openapi3-ts": "4.5.0",
     "pluralize": "^8.0.0",
     "stringcase": "^4.3.1",

package/dist/lib/find-polymorphic-varients.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=find-polymorphic-varients.test.d.ts.map

package/dist/lib/find-polymorphic-varients.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find-polymorphic-varients.test.d.ts","sourceRoot":"","sources":["../../src/lib/find-polymorphic-varients.test.ts"],"names":[],"mappings":""}

package/dist/lib/find-polymorphic-varients.test.js

@@ -1,615 +0,0 @@
-import { merge } from "lodash-es";
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import {
-  findPolymorphicVarients,
-  findVarients
-} from "./find-polymorphic-varients.ts";
-import { toIR } from "./ir.ts";
-function createSpec(openapi) {
-  return toIR(
-    {
-      spec: merge(
-        {
-          openapi: "3.1.0",
-          info: {
-            title: "Test API",
-            version: "1.0.0"
-          },
-          components: {
-            schemas: {},
-            securitySchemes: {}
-          },
-          paths: {}
-        },
-        openapi
-      )
-    },
-    true
-  );
-}
-describe("findVarients", () => {
-  describe("strings", () => {
-    it("names string type as text", () => {
-      const spec = createSpec();
-      const result = findVarients(spec, [{ type: "string" }]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "text",
-          position: 0,
-          type: "string"
-        }
-      ]);
-    });
-    it("names string based on format", () => {
-      const spec = createSpec();
-      const result = findVarients(spec, [
-        {
-          type: "string",
-          format: "date-time"
-        },
-        { type: "string" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "dateTime",
-          position: 0,
-          priority: 90,
-          type: "string"
-        },
-        {
-          name: "text",
-          position: 1,
-          type: "string"
-        }
-      ]);
-    });
-    it("names string based on const value", () => {
-      const spec = createSpec();
-      const result = findVarients(spec, [
-        { type: "string", const: "active" },
-        { type: "string", const: "" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "active",
-          position: 0,
-          priority: 100,
-          type: "string"
-        },
-        {
-          name: "empty",
-          position: 1,
-          priority: 99,
-          type: "string"
-        }
-      ]);
-    });
-    it.skip("names string based on enum values", () => {
-      const spec = createSpec();
-      const result = findVarients(spec, [
-        { type: "string", enum: ["pending", "completed", ""] }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "pending",
-          position: 0,
-          priority: 80,
-          type: "string"
-        },
-        {
-          name: "completed",
-          position: 0,
-          priority: 79,
-          type: "string"
-        },
-        {
-          name: "empty",
-          position: 0,
-          priority: 78,
-          type: "string"
-        }
-      ]);
-    });
-    it.skip("prioritizes const first", () => {
-      const spec = createSpec();
-      const result = findVarients(spec, [
-        { type: "string", format: "email" },
-        { type: "string", const: "fixed" },
-        { type: "string", enum: ["option1", "option2"] },
-        { type: "string" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "fixed",
-          position: 1,
-          priority: 99,
-          type: "string"
-        },
-        {
-          name: "email",
-          position: 0,
-          priority: 90,
-          type: "string"
-        },
-        {
-          name: "option1",
-          position: 2,
-          priority: 78,
-          type: "string"
-        },
-        {
-          name: "option2",
-          position: 2,
-          priority: 77,
-          type: "string"
-        },
-        {
-          name: "text",
-          position: 3,
-          type: "string"
-        }
-      ]);
-    });
-    it("handles format priority over enum", () => {
-      const spec = createSpec();
-      const result = findVarients(spec, [
-        { type: "string", format: "email", enum: ["user@example.com"] }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "email",
-          position: 0,
-          priority: 90,
-          type: "string"
-        }
-      ]);
-    });
-    it("handles const priority over enum", () => {
-      const spec = createSpec();
-      const result = findVarients(spec, [
-        { type: "string", const: "fixed", enum: ["option1", "option2"] }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "fixed",
-          position: 0,
-          priority: 100,
-          type: "string"
-        }
-      ]);
-    });
-    it("handles complex format names with camelCase conversion", () => {
-      const spec = createSpec();
-      const result = findVarients(spec, [
-        { type: "string", format: "date-time" },
-        { type: "string", format: "iso-8601" },
-        { type: "string", format: "binary" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "dateTime",
-          position: 0,
-          priority: 90,
-          type: "string"
-        },
-        {
-          name: "iso8601",
-          position: 1,
-          priority: 89,
-          type: "string"
-        },
-        {
-          name: "binary",
-          position: 2,
-          priority: 88,
-          type: "string"
-        }
-      ]);
-    });
-  });
-  describe("numbers", () => {
-    it("names number type as number", () => {
-      const spec = createSpec();
-      const result = findVarients(spec, [{ type: "number" }]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "number",
-          position: 0,
-          type: "number"
-        }
-      ]);
-    });
-    it("names integer type as integer", () => {
-      const spec = createSpec();
-      const result = findVarients(spec, [{ type: "integer" }]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "number",
-          position: 0,
-          type: "number"
-        }
-      ]);
-    });
-    it("names number based on format", () => {
-      const spec = createSpec();
-      const result = findVarients(spec, [
-        {
-          type: "number",
-          format: "float"
-        },
-        {
-          type: "number",
-          format: "double"
-        },
-        {
-          type: "integer",
-          format: "int64"
-        },
-        { type: "number" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "float",
-          position: 0,
-          priority: 90,
-          type: "number"
-        },
-        {
-          name: "double",
-          position: 1,
-          priority: 89,
-          type: "number"
-        },
-        {
-          name: "integer",
-          position: 2,
-          priority: 87,
-          type: "number"
-        },
-        {
-          name: "number",
-          position: 3,
-          type: "number"
-        }
-      ]);
-    });
-  });
-  describe("mixed types", () => {
-    it("handles mixed string and number types", () => {
-      const spec = createSpec();
-      const result = findVarients(spec, [
-        { type: "number" },
-        { type: "string" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "text",
-          position: 1,
-          type: "string"
-        },
-        {
-          name: "number",
-          position: 0,
-          type: "number"
-        }
-      ]);
-    });
-  });
-});
-describe("findPolymorphicVarients", () => {
-  describe("strings", () => {
-    it("returns single variant per position for multiple strings", () => {
-      const spec = createSpec();
-      const result = findPolymorphicVarients(spec, [
-        { type: "string", format: "date-time" },
-        { type: "string" },
-        { type: "string", const: "active" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "active",
-          position: 2,
-          priority: 98,
-          type: "string"
-        },
-        {
-          name: "dateTime",
-          position: 0,
-          priority: 90,
-          type: "string"
-        },
-        {
-          name: "text",
-          position: 1,
-          type: "string"
-        }
-      ]);
-    });
-    it.skip("returns first variant when multiple enums at same position", () => {
-      const spec = createSpec();
-      const result = findPolymorphicVarients(spec, [
-        { type: "string", enum: ["first", "second", "third"] }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "first",
-          position: 0,
-          priority: 80,
-          type: "string"
-        }
-      ]);
-    });
-    it.skip("selects first variant from multiple at same position", () => {
-      const spec = createSpec();
-      const result = findPolymorphicVarients(spec, [
-        { type: "string", enum: ["option1", "option2"] },
-        { type: "string", format: "email" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "email",
-          position: 1,
-          priority: 88,
-          type: "string"
-        },
-        {
-          name: "option1",
-          position: 0,
-          priority: 80,
-          type: "string"
-        }
-      ]);
-    });
-    it.skip("handles mixed types selecting one per position", () => {
-      const spec = createSpec();
-      const result = findPolymorphicVarients(spec, [
-        { type: "string", enum: ["a", "b"] },
-        { type: "number" },
-        { type: "string", const: "fixed" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "fixed",
-          position: 2,
-          priority: 98,
-          type: "string"
-        },
-        {
-          name: "a",
-          position: 0,
-          priority: 80,
-          type: "string"
-        },
-        {
-          name: "number",
-          position: 1,
-          type: "number"
-        }
-      ]);
-    });
-    it("handles plain strings mixed with formatted strings", () => {
-      const spec = createSpec();
-      const result = findPolymorphicVarients(spec, [
-        { type: "string" },
-        { type: "string", format: "password" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "password",
-          position: 1,
-          priority: 89,
-          type: "string"
-        },
-        {
-          name: "text",
-          position: 0,
-          type: "string"
-        }
-      ]);
-    });
-    it("ignore duplicates", () => {
-      const spec = createSpec();
-      const result = findPolymorphicVarients(spec, [
-        { type: "string" },
-        { type: "string", format: "password" },
-        { type: "string" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "password",
-          position: 1,
-          priority: 89,
-          type: "string"
-        },
-        {
-          name: "text",
-          position: 0,
-          type: "string"
-        }
-      ]);
-    });
-  });
-  describe("numbers", () => {
-    it("returns single variant per position for multiple numbers", () => {
-      const spec = createSpec();
-      const result = findPolymorphicVarients(spec, [
-        { type: "number", format: "float" },
-        { type: "integer" },
-        { type: "number", format: "double" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "float",
-          position: 0,
-          priority: 90,
-          type: "number"
-        },
-        {
-          name: "double",
-          position: 2,
-          priority: 89,
-          type: "number"
-        },
-        {
-          name: "number",
-          position: 1,
-          type: "number"
-        }
-      ]);
-    });
-    it("returns first variant when multiple number formats at same position", () => {
-      const spec = createSpec();
-      const result = findPolymorphicVarients(spec, [
-        { type: "number", format: "float" },
-        { type: "number", format: "double" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "float",
-          position: 0,
-          priority: 90,
-          type: "number"
-        },
-        {
-          name: "double",
-          position: 1,
-          priority: 89,
-          type: "number"
-        }
-      ]);
-    });
-    it("handles mixed number and integer types", () => {
-      const spec = createSpec();
-      const result = findPolymorphicVarients(spec, [
-        { type: "integer", format: "int64" },
-        { type: "number" },
-        { type: "integer" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "integer",
-          position: 0,
-          priority: 89,
-          type: "number"
-        },
-        {
-          name: "number",
-          position: 1,
-          type: "number"
-        },
-        {
-          name: "number",
-          position: 2,
-          type: "number"
-        }
-      ]);
-    });
-    it("handles plain numbers mixed with formatted numbers", () => {
-      const spec = createSpec();
-      const result = findPolymorphicVarients(spec, [
-        { type: "number" },
-        { type: "number", format: "float" },
-        { type: "number" }
-      ]);
-      assert.deepStrictEqual(result, [
-        {
-          name: "float",
-          position: 1,
-          priority: 89,
-          type: "number"
-        },
-        {
-          name: "number",
-          position: 0,
-          type: "number"
-        },
-        {
-          name: "number",
-          position: 2,
-          type: "number"
-        }
-      ]);
-    });
-  });
-  describe("arrays", () => {
-    it.only("complex", () => {
-      const spec = createSpec({
-        components: {
-          schemas: {
-            RouteConfig: {
-              anyOf: [
-                {
-                  type: "array",
-                  items: {
-                    anyOf: [
-                      {
-                        type: "string",
-                        enum: ["image", "video", "audio"]
-                      },
-                      {
-                        type: "string",
-                        enum: [
-                          "application/andrew-inset",
-                          "application/applixware"
-                        ]
-                      }
-                    ]
-                  }
-                },
-                {
-                  type: "object",
-                  additionalProperties: {
-                    type: "object",
-                    properties: {
-                      maxFileSize: {
-                        type: "string",
-                        description: "The maximum file size allowed for a given file type.",
-                        example: "4MB"
-                      },
-                      maxFileCount: {
-                        type: "number",
-                        description: "Maximum allowed files for a given file type.",
-                        example: 1
-                      },
-                      contentDisposition: {
-                        type: "string",
-                        enum: ["inline", "attachment"],
-                        default: "inline"
-                      },
-                      acl: {
-                        type: "string",
-                        enum: ["public-read", "private"]
-                      }
-                    }
-                  }
-                }
-              ]
-            }
-          }
-        }
-      });
-      const varients = findVarients(
-        spec,
-        spec.components.schemas.RouteConfig.anyOf ?? []
-      );
-      assert.deepStrictEqual(varients, [
-        {
-          name: "textList",
-          type: "array",
-          subtype: "string",
-          position: 0
-        },
-        {
-          static: true,
-          subtype: "string",
-          source: "public-read",
-          name: "public-read",
-          type: "object",
-          position: 1
-        }
-      ]);
-    });
-  });
-});
-//# sourceMappingURL=find-polymorphic-varients.test.js.map