@alt-stack/zod-openapi 1.0.1

package/src/types/array.spec.ts

@@ -0,0 +1,222 @@
+import { describe, it, expect } from "vitest";
+import { convertOpenAPIArrayToZod } from "./array";
+import type { AnySchema } from "./types";
+
+describe("convertOpenAPIArrayToZod", () => {
+  const mockConvertSchema = (schema: AnySchema): string => {
+    if (schema.type === "string") return "z.string()";
+    if (schema.type === "number") return "z.number()";
+    if (schema.type === "boolean") return "z.boolean()";
+    return "z.unknown()";
+  };
+
+  describe("array without items", () => {
+    it("should convert array schema without items definition", () => {
+      const result = convertOpenAPIArrayToZod(
+        { type: "array" },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.unknown())");
+    });
+
+    it("should convert array without items but with constraints", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          minItems: 1,
+          maxItems: 10,
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.unknown()).min(1).max(10)");
+    });
+  });
+
+  describe("array with items", () => {
+    it("should convert array with string items", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "string" },
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.string())");
+    });
+
+    it("should convert array with number items", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "number" },
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.number())");
+    });
+
+    it("should convert array with boolean items", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "boolean" },
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.boolean())");
+    });
+
+    it("should convert array with unknown items when items type is unrecognized", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "unknown-type" },
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.unknown())");
+    });
+  });
+
+  describe("array with minItems constraint", () => {
+    it("should apply minItems constraint", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "string" },
+          minItems: 1,
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.string()).min(1)");
+    });
+
+    it("should handle minItems of 0", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "string" },
+          minItems: 0,
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.string()).min(0)");
+    });
+
+    it("should handle large minItems value", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "number" },
+          minItems: 100,
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.number()).min(100)");
+    });
+  });
+
+  describe("array with maxItems constraint", () => {
+    it("should apply maxItems constraint", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "string" },
+          maxItems: 10,
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.string()).max(10)");
+    });
+
+    it("should handle maxItems of 0", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "string" },
+          maxItems: 0,
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.string()).max(0)");
+    });
+
+    it("should handle large maxItems value", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "number" },
+          maxItems: 1000,
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.number()).max(1000)");
+    });
+  });
+
+  describe("array with both minItems and maxItems", () => {
+    it("should apply both minItems and maxItems constraints", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "string" },
+          minItems: 1,
+          maxItems: 10,
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.string()).min(1).max(10)");
+    });
+
+    it("should maintain order: array, min, max", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "number" },
+          maxItems: 100,
+          minItems: 5,
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.number()).min(5).max(100)");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle items as null", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: null,
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.unknown())");
+    });
+
+    it("should handle items as primitive value", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: "invalid",
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.unknown())");
+    });
+
+    it("should not apply constraints when undefined", () => {
+      const result = convertOpenAPIArrayToZod(
+        {
+          type: "array",
+          items: { type: "string" },
+          minItems: undefined,
+          maxItems: undefined,
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.array(z.string())");
+    });
+  });
+});
+

package/src/types/array.ts

@@ -0,0 +1,29 @@
+import type { AnySchema } from "./types";
+
+export function convertOpenAPIArrayToZod(
+  schema: {
+    type: "array";
+    items?: any;
+    minItems?: number;
+    maxItems?: number;
+  },
+  convertSchema: (schema: AnySchema) => string,
+): string {
+  const item = schema.items;
+
+  let itemZodString = "z.unknown()";
+  if (item && typeof item === "object") {
+    itemZodString = convertSchema(item);
+  }
+
+  let result = `z.array(${itemZodString})`;
+
+  if (typeof schema.minItems === "number") {
+    result += `.min(${schema.minItems})`;
+  }
+  if (typeof schema.maxItems === "number") {
+    result += `.max(${schema.maxItems})`;
+  }
+
+  return result;
+}

package/src/types/boolean.spec.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from "vitest";
+import { convertOpenAPIBooleanToZod } from "./boolean";
+
+describe("convertOpenAPIBooleanToZod", () => {
+  it("should convert a boolean schema", () => {
+    const result = convertOpenAPIBooleanToZod({ type: "boolean" });
+    expect(result).toBe("z.boolean()");
+  });
+
+  it("should always return the same result regardless of input", () => {
+    const result1 = convertOpenAPIBooleanToZod({ type: "boolean" });
+    const result2 = convertOpenAPIBooleanToZod({ type: "boolean" });
+    expect(result1).toBe("z.boolean()");
+    expect(result2).toBe("z.boolean()");
+    expect(result1).toBe(result2);
+  });
+});
+

package/src/types/boolean.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert an OpenAPI v3 boolean schema to a Zod schema string
+ */
+export function convertOpenAPIBooleanToZod(_: { type: "boolean" }): string {
+  return "z.boolean()";
+}

package/src/types/intersection.spec.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from "vitest";
+import { convertOpenAPIIntersectionToZod } from "./intersection";
+import type { AnySchema } from "./types";
+
+describe("convertOpenAPIIntersectionToZod", () => {
+  const mockConvertSchema = (schema: AnySchema): string => {
+    if (schema.type === "string") return "z.string()";
+    if (schema.type === "number") return "z.number()";
+    if (schema.type === "boolean") return "z.boolean()";
+    return "z.unknown()";
+  };
+
+  describe("intersection with two types", () => {
+    it("should convert intersection of string and number", () => {
+      const result = convertOpenAPIIntersectionToZod(
+        {
+          allOf: [{ type: "string" }, { type: "number" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.intersection(z.string(), z.number())");
+    });
+
+    it("should convert intersection of string and boolean", () => {
+      const result = convertOpenAPIIntersectionToZod(
+        {
+          allOf: [{ type: "string" }, { type: "boolean" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.intersection(z.string(), z.boolean())");
+    });
+  });
+
+  describe("intersection with multiple types", () => {
+    it("should convert intersection of three types", () => {
+      const result = convertOpenAPIIntersectionToZod(
+        {
+          allOf: [{ type: "string" }, { type: "number" }, { type: "boolean" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe(
+        "z.intersection(z.string(), z.number(), z.boolean())",
+      );
+    });
+
+    it("should convert intersection of multiple same types", () => {
+      const result = convertOpenAPIIntersectionToZod(
+        {
+          allOf: [{ type: "string" }, { type: "string" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.intersection(z.string(), z.string())");
+    });
+  });
+
+  describe("intersection with single type", () => {
+    it("should return single schema without intersection wrapper", () => {
+      const result = convertOpenAPIIntersectionToZod(
+        {
+          allOf: [{ type: "string" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.string()");
+    });
+  });
+
+  describe("empty intersection", () => {
+    it("should return z.unknown() for empty allOf array", () => {
+      const result = convertOpenAPIIntersectionToZod(
+        {
+          allOf: [],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.unknown()");
+    });
+  });
+
+  describe("intersection with unknown types", () => {
+    it("should convert intersection containing unknown types", () => {
+      const result = convertOpenAPIIntersectionToZod(
+        {
+          allOf: [{ type: "string" }, { type: "unknown-type" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.intersection(z.string(), z.unknown())");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should preserve order of intersection members", () => {
+      const result = convertOpenAPIIntersectionToZod(
+        {
+          allOf: [{ type: "boolean" }, { type: "number" }, { type: "string" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe(
+        "z.intersection(z.boolean(), z.number(), z.string())",
+      );
+    });
+  });
+});

package/src/types/intersection.ts

@@ -0,0 +1,14 @@
+import type { AnySchema } from "./types";
+
+export function convertOpenAPIIntersectionToZod(
+  schema: { allOf: AnySchema[] },
+  convertSchema: (schema: AnySchema) => string,
+): string {
+  const items = schema.allOf.map((item) => convertSchema(item));
+
+  if (schema.allOf.length === 0) return "z.unknown()";
+  if (schema.allOf.length === 1) return convertSchema(schema.allOf[0]!);
+
+  return `z.intersection(${items.join(", ")})`;
+}
+

package/src/types/number.spec.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect } from "vitest";
+import { convertOpenAPINumberToZod } from "./number";
+
+describe("convertOpenAPINumberToZod", () => {
+  describe("number type", () => {
+    it("should convert a basic number schema", () => {
+      const result = convertOpenAPINumberToZod({ type: "number" });
+      expect(result).toBe("z.number()");
+    });
+
+    it("should convert number with minimum constraint", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "number",
+        minimum: 0,
+      });
+      expect(result).toBe("z.number().min(0)");
+    });
+
+    it("should convert number with maximum constraint", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "number",
+        maximum: 100,
+      });
+      expect(result).toBe("z.number().max(100)");
+    });
+
+    it("should convert number with both minimum and maximum constraints", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "number",
+        minimum: 0,
+        maximum: 100,
+      });
+      expect(result).toBe("z.number().min(0).max(100)");
+    });
+
+    it("should handle negative minimum", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "number",
+        minimum: -10,
+      });
+      expect(result).toBe("z.number().min(-10)");
+    });
+
+    it("should handle negative maximum", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "number",
+        maximum: -5,
+      });
+      expect(result).toBe("z.number().max(-5)");
+    });
+
+    it("should handle decimal minimum and maximum", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "number",
+        minimum: 0.5,
+        maximum: 99.99,
+      });
+      expect(result).toBe("z.number().min(0.5).max(99.99)");
+    });
+
+    it("should not apply constraints when undefined", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "number",
+        minimum: undefined,
+        maximum: undefined,
+      });
+      expect(result).toBe("z.number()");
+    });
+  });
+
+  describe("integer type", () => {
+    it("should convert a basic integer schema", () => {
+      const result = convertOpenAPINumberToZod({ type: "integer" });
+      expect(result).toBe("z.number().int()");
+    });
+
+    it("should convert integer with minimum constraint", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "integer",
+        minimum: 1,
+      });
+      expect(result).toBe("z.number().int().min(1)");
+    });
+
+    it("should convert integer with maximum constraint", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "integer",
+        maximum: 10,
+      });
+      expect(result).toBe("z.number().int().max(10)");
+    });
+
+    it("should convert integer with both minimum and maximum constraints", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "integer",
+        minimum: 1,
+        maximum: 10,
+      });
+      expect(result).toBe("z.number().int().min(1).max(10)");
+    });
+
+    it("should handle zero as minimum", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "integer",
+        minimum: 0,
+      });
+      expect(result).toBe("z.number().int().min(0)");
+    });
+
+    it("should handle zero as maximum", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "integer",
+        maximum: 0,
+      });
+      expect(result).toBe("z.number().int().max(0)");
+    });
+
+    it("should maintain order: int(), min(), max()", () => {
+      const result = convertOpenAPINumberToZod({
+        type: "integer",
+        maximum: 100,
+        minimum: 0,
+      });
+      expect(result).toBe("z.number().int().min(0).max(100)");
+    });
+  });
+});

package/src/types/number.ts

@@ -0,0 +1,20 @@
+/**
+ * Convert an OpenAPI v3 number/integer schema to a Zod schema string
+ */
+export function convertOpenAPINumberToZod(schema: {
+  type: "number" | "integer";
+  minimum?: number;
+  maximum?: number;
+}): string {
+  let result = "z.number()";
+  if (schema.type === "integer") {
+    result += ".int()";
+  }
+  if (typeof schema.minimum === "number") {
+    result += `.min(${schema.minimum})`;
+  }
+  if (typeof schema.maximum === "number") {
+    result += `.max(${schema.maximum})`;
+  }
+  return result;
+}