@alt-stack/zod-openapi 1.0.1

package/src/types/string.spec.ts

@@ -0,0 +1,431 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { z } from "zod";
+import { convertOpenAPIStringToZod } from "./string";
+import {
+  registerZodSchemaToOpenApiSchema,
+  clearZodSchemaToOpenApiSchemaRegistry,
+} from "../registry";
+
+describe("convertOpenAPIStringToZod", () => {
+  beforeEach(() => {
+    clearZodSchemaToOpenApiSchemaRegistry();
+  });
+
+  afterEach(() => {
+    clearZodSchemaToOpenApiSchemaRegistry();
+  });
+
+  describe("basic string conversion", () => {
+    it("should convert a basic string schema with no constraints", () => {
+      const result = convertOpenAPIStringToZod({ type: "string" });
+      expect(result).toBe("z.string()");
+    });
+  });
+
+  describe("enum handling", () => {
+    it("should convert string enum with single value", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        enum: ["value1"],
+      });
+      expect(result).toBe("z.enum(['value1'])");
+    });
+
+    it("should convert string enum with multiple values", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        enum: ["red", "green", "blue"],
+      });
+      expect(result).toBe("z.enum(['red', 'green', 'blue'])");
+    });
+
+    it("should prioritize enum over other constraints", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        enum: ["value1", "value2"],
+        minLength: 5,
+        maxLength: 10,
+        pattern: ".*",
+        format: "email",
+      });
+      expect(result).toBe("z.enum(['value1', 'value2'])");
+    });
+
+    it("should handle enum with special characters", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        enum: ["hello world", "test@example.com"],
+      });
+      expect(result).toBe("z.enum(['hello world', 'test@example.com'])");
+    });
+  });
+
+  describe("format handling - built-in formats", () => {
+    it("should convert email format", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "email",
+      });
+      expect(result).toBe("z.string().email()");
+    });
+
+    it("should convert url format", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "url",
+      });
+      expect(result).toBe("z.string().url()");
+    });
+
+    it("should convert uri format to url", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "uri",
+      });
+      expect(result).toBe("z.string().url()");
+    });
+
+    it("should convert uuid format", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "uuid",
+      });
+      expect(result).toBe("z.string().uuid()");
+    });
+
+    it("should convert color-hex format", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "color-hex",
+      });
+      expect(result).toBe("z.string().regex(/^[a-fA-F0-9]{6}$/)");
+    });
+
+    it("should ignore unknown format", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        // @ts-expect-error - testing with unsupported format
+        format: "unsupported-format",
+      });
+      expect(result).toBe("z.string()");
+    });
+  });
+
+  describe("format handling - custom registered schemas", () => {
+    it("should use custom registered schema for format", () => {
+      const customSchema = z.string().min(10);
+      registerZodSchemaToOpenApiSchema(customSchema, {
+        schemaExportedVariableName: "customEmailSchema",
+        type: "string",
+        format: "email",
+      });
+
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "email",
+      });
+      expect(result).toBe("customEmailSchema");
+    });
+
+    it("should ignore other constraints when using custom registered schema", () => {
+      const customSchema = z.string().min(10);
+      registerZodSchemaToOpenApiSchema(customSchema, {
+        schemaExportedVariableName: "customUuidSchema",
+        type: "string",
+        format: "uuid",
+      });
+
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "uuid",
+        minLength: 5,
+        maxLength: 50,
+        pattern: ".*",
+      });
+      expect(result).toBe("customUuidSchema");
+    });
+
+    it("should use custom registered schema with multiple formats", () => {
+      const customSchema = z.string();
+      registerZodSchemaToOpenApiSchema(customSchema, {
+        schemaExportedVariableName: "customDateSchema",
+        type: "string",
+        formats: ["date", "iso-date"],
+      });
+
+      const result1 = convertOpenAPIStringToZod({
+        type: "string",
+        format: "date",
+      });
+      expect(result1).toBe("customDateSchema");
+
+      const result2 = convertOpenAPIStringToZod({
+        type: "string",
+        format: "iso-date",
+      });
+      expect(result2).toBe("customDateSchema");
+    });
+  });
+
+  describe("length constraints", () => {
+    it("should apply minLength constraint", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        minLength: 5,
+      });
+      expect(result).toBe("z.string().min(5)");
+    });
+
+    it("should apply maxLength constraint", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        maxLength: 10,
+      });
+      expect(result).toBe("z.string().max(10)");
+    });
+
+    it("should apply both minLength and maxLength constraints", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        minLength: 5,
+        maxLength: 10,
+      });
+      expect(result).toBe("z.string().min(5).max(10)");
+    });
+
+    it("should handle minLength of 0", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        minLength: 0,
+      });
+      expect(result).toBe("z.string().min(0)");
+    });
+
+    it("should not apply minLength when undefined", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        minLength: undefined,
+      });
+      expect(result).toBe("z.string()");
+    });
+  });
+
+  describe("pattern constraints", () => {
+    it("should apply pattern constraint", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        pattern: "^[A-Z]+$",
+      });
+      expect(result).toBe("z.string().regex(/^[A-Z]+$/)");
+    });
+
+    it("should handle complex regex pattern", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        pattern: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
+      });
+      expect(result).toBe(
+        "z.string().regex(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$/)",
+      );
+    });
+
+    it("should not apply pattern when undefined", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        pattern: undefined,
+      });
+      expect(result).toBe("z.string()");
+    });
+  });
+
+  describe("combined constraints", () => {
+    it("should combine format and length constraints", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "email",
+        minLength: 5,
+        maxLength: 100,
+      });
+      expect(result).toBe("z.string().email().min(5).max(100)");
+    });
+
+    it("should combine format and pattern constraints", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "uuid",
+        pattern: "^[a-f0-9-]+$",
+      });
+      expect(result).toBe("z.string().uuid().regex(/^[a-f0-9-]+$/)");
+    });
+
+    it("should combine all constraints", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "email",
+        minLength: 10,
+        maxLength: 50,
+        pattern: ".*@example\\.com$",
+      });
+      expect(result).toBe(
+        "z.string().email().min(10).max(50).regex(/.*@example\\.com$/)",
+      );
+    });
+
+    it("should combine length and pattern without format", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        minLength: 3,
+        maxLength: 20,
+        pattern: "^[a-z]+$",
+      });
+      expect(result).toBe("z.string().min(3).max(20).regex(/^[a-z]+$/)");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle empty enum array", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        enum: [],
+      });
+      expect(result).toBe("z.enum([])");
+    });
+
+    it("should handle format with empty string", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        // @ts-expect-error - testing with empty format
+        format: "",
+      });
+      expect(result).toBe("z.string()");
+    });
+
+    it("should handle pattern with empty string", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        pattern: "",
+      });
+      expect(result).toBe("z.string().regex(//)");
+    });
+
+    it("should maintain order: format, minLength, maxLength, pattern", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        pattern: "^test$",
+        maxLength: 20,
+        minLength: 5,
+        format: "url",
+      });
+      expect(result).toBe("z.string().url().min(5).max(20).regex(/^test$/)");
+    });
+
+    it("should handle only maxLength without minLength", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "email",
+        maxLength: 100,
+      });
+      expect(result).toBe("z.string().email().max(100)");
+    });
+
+    it("should handle only pattern without other constraints", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        pattern: "\\d{3}-\\d{4}",
+      });
+      expect(result).toBe("z.string().regex(/\\d{3}-\\d{4}/)");
+    });
+  });
+
+  describe("format with supported but not built-in modifiers", () => {
+    it("should handle date format without built-in modifier", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "date",
+      });
+      expect(result).toBe("z.string()");
+    });
+
+    it("should handle date-time format without built-in modifier", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "date-time",
+      });
+      expect(result).toBe("z.string()");
+    });
+
+    it("should handle objectid format without built-in modifier", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "objectid",
+      });
+      expect(result).toBe("z.string()");
+    });
+
+    it("should apply constraints to supported formats without built-in modifiers", () => {
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "date",
+        minLength: 10,
+        maxLength: 10,
+      });
+      expect(result).toBe("z.string().min(10).max(10)");
+    });
+  });
+
+  describe("integration with registry", () => {
+    it("should clear registry between tests", () => {
+      const customSchema1 = z.string().min(5);
+      registerZodSchemaToOpenApiSchema(customSchema1, {
+        schemaExportedVariableName: "schema1",
+        type: "string",
+        format: "email",
+      });
+
+      clearZodSchemaToOpenApiSchemaRegistry();
+
+      const result = convertOpenAPIStringToZod({
+        type: "string",
+        format: "email",
+      });
+      // Should use built-in email format, not custom schema
+      expect(result).toBe("z.string().email()");
+    });
+
+    it("should handle multiple schemas registered for different formats", () => {
+      const emailSchema = z.string().email();
+      const uuidSchema = z.string().uuid();
+
+      registerZodSchemaToOpenApiSchema(emailSchema, {
+        schemaExportedVariableName: "customEmailSchema",
+        type: "string",
+        format: "email",
+      });
+
+      registerZodSchemaToOpenApiSchema(uuidSchema, {
+        schemaExportedVariableName: "customUuidSchema",
+        type: "string",
+        format: "uuid",
+      });
+
+      const emailResult = convertOpenAPIStringToZod({
+        type: "string",
+        format: "email",
+      });
+      expect(emailResult).toBe("customEmailSchema");
+
+      const uuidResult = convertOpenAPIStringToZod({
+        type: "string",
+        format: "uuid",
+      });
+      expect(uuidResult).toBe("customUuidSchema");
+
+      // Unregistered format should use built-in
+      const urlResult = convertOpenAPIStringToZod({
+        type: "string",
+        format: "url",
+      });
+      expect(urlResult).toBe("z.string().url()");
+    });
+  });
+});

package/src/types/string.ts

@@ -0,0 +1,75 @@
+import {
+  getSchemaExportedVariableNameForStringFormat,
+  SUPPORTED_STRING_FORMATS,
+} from "../registry";
+
+/**
+ * Convert an OpenAPI v3 string schema to a Zod schema string
+ */
+export function convertOpenAPIStringToZod(schema: {
+  type: "string";
+  format?: typeof SUPPORTED_STRING_FORMATS;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  enum?: string[];
+}): string {
+  // Handle enum values
+  if (schema.enum) {
+    return `z.enum([${schema.enum.map((value) => `'${value}'`).join(", ")}])`;
+  }
+
+  // Check for custom registered format schemas
+  if (schema.format && SUPPORTED_STRING_FORMATS.includes(schema.format)) {
+    const customSchemaName = getSchemaExportedVariableNameForStringFormat(
+      schema.format,
+    );
+
+    // Use custom schema if registered (ignores other constraints)
+    if (customSchemaName) {
+      return customSchemaName;
+    }
+  }
+
+  // Build string schema with format modifiers
+  let zodSchema = "z.string()";
+
+  if (schema.format) {
+    zodSchema += getFormatModifier(schema.format);
+  }
+
+  // Apply length constraints
+  if (typeof schema.minLength === "number") {
+    zodSchema += `.min(${schema.minLength})`;
+  }
+
+  if (typeof schema.maxLength === "number") {
+    zodSchema += `.max(${schema.maxLength})`;
+  }
+
+  // Apply pattern constraint
+  if (typeof schema.pattern === "string") {
+    zodSchema += `.regex(/${schema.pattern}/)`;
+  }
+
+  return zodSchema;
+}
+
+/**
+ * Get the Zod modifier for built-in string formats
+ */
+function getFormatModifier(format: string): string {
+  switch (format) {
+    case "email":
+      return ".email()";
+    case "url":
+    case "uri":
+      return ".url()";
+    case "uuid":
+      return ".uuid()";
+    case "color-hex":
+      return ".regex(/^[a-fA-F0-9]{6}$/)";
+    default:
+      return "";
+  }
+}

package/src/types/types.ts

@@ -0,0 +1,10 @@
+export type AnySchema = Record<string, any>;
+
+export type OpenAPIObjectSchema = {
+  type: "object";
+  properties?: Record<string, AnySchema>;
+  required?: string[];
+  additionalProperties?: boolean | AnySchema;
+  maxProperties?: number;
+  minProperties?: number;
+};

package/src/types/union.spec.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect } from "vitest";
+import { convertOpenAPIUnionToZod } from "./union";
+import type { AnySchema } from "./types";
+
+describe("convertOpenAPIUnionToZod", () => {
+  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("union with two types", () => {
+    it("should convert union of string and number", () => {
+      const result = convertOpenAPIUnionToZod(
+        {
+          oneOf: [{ type: "string" }, { type: "number" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.union([z.string(), z.number()])");
+    });
+
+    it("should convert union of string and boolean", () => {
+      const result = convertOpenAPIUnionToZod(
+        {
+          oneOf: [{ type: "string" }, { type: "boolean" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.union([z.string(), z.boolean()])");
+    });
+
+    it("should convert union of number and boolean", () => {
+      const result = convertOpenAPIUnionToZod(
+        {
+          oneOf: [{ type: "number" }, { type: "boolean" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.union([z.number(), z.boolean()])");
+    });
+  });
+
+  describe("union with multiple types", () => {
+    it("should convert union of three types", () => {
+      const result = convertOpenAPIUnionToZod(
+        {
+          oneOf: [
+            { type: "string" },
+            { type: "number" },
+            { type: "boolean" },
+          ],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe(
+        "z.union([z.string(), z.number(), z.boolean()])",
+      );
+    });
+
+    it("should convert union of multiple same types", () => {
+      const result = convertOpenAPIUnionToZod(
+        {
+          oneOf: [{ type: "string" }, { type: "string" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.union([z.string(), z.string()])");
+    });
+  });
+
+  describe("union with single type", () => {
+    it("should convert union with single type", () => {
+      const result = convertOpenAPIUnionToZod(
+        {
+          oneOf: [{ type: "string" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.union([z.string()])");
+    });
+  });
+
+  describe("union with unknown types", () => {
+    it("should convert union containing unknown types", () => {
+      const result = convertOpenAPIUnionToZod(
+        {
+          oneOf: [{ type: "string" }, { type: "unknown-type" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.union([z.string(), z.unknown()])");
+    });
+
+    it("should convert union of all unknown types", () => {
+      const result = convertOpenAPIUnionToZod(
+        {
+          oneOf: [{ type: "unknown1" }, { type: "unknown2" }],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.union([z.unknown(), z.unknown()])");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle empty oneOf array", () => {
+      const result = convertOpenAPIUnionToZod(
+        {
+          oneOf: [],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe("z.union([])");
+    });
+
+    it("should preserve order of union members", () => {
+      const result = convertOpenAPIUnionToZod(
+        {
+          oneOf: [
+            { type: "boolean" },
+            { type: "number" },
+            { type: "string" },
+          ],
+        },
+        mockConvertSchema,
+      );
+      expect(result).toBe(
+        "z.union([z.boolean(), z.number(), z.string()])",
+      );
+    });
+  });
+});
+

package/src/types/union.ts

@@ -0,0 +1,10 @@
+import type { AnySchema } from "./types";
+
+export function convertOpenAPIUnionToZod(
+  schema: { oneOf: AnySchema[] },
+  convertSchema: (schema: AnySchema) => string,
+): string {
+  const items = schema.oneOf.map((item) => convertSchema(item));
+  return `z.union([${items.join(", ")}])`;
+}
+

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "../typescript-config/base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+
+

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+});
+

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+  },
+});