From aa9599e3fbd2b069a935428c804df4bf4ab8d2de Mon Sep 17 00:00:00 2001 From: Utkarsh patwa Date: Thu, 19 Nov 2026 15:13:08 +0530 Subject: [PATCH 1/2] Emit typed wire schemas for Zod Set and Map (#451) Zod `z.set()` and `z.map()` previously fell through to `any` in `getZodSchemaAsTypeScript`. This change: - Emits `T[]` for `z.set()` as the JSON-compatible wire schema. - Emits `[K, V][]` for `z.map()` as the key-value tuple array wire schema. - Adds test coverage for `z.set()` and `z.map()` in `test/zod.test.ts`, including union elements. Closes #451 Signed-off-by: Utkarsh patwa --- typescript/src/zod/validate.ts | 18 ++++++++++++++++++ typescript/test/zod.test.ts | 28 ++++++++++++++++++++++++++++ 2 files changed, 46 insertions(+) diff --git a/typescript/src/zod/validate.ts b/typescript/src/zod/validate.ts index fff47237..21e57026 100644 --- a/typescript/src/zod/validate.ts +++ b/typescript/src/zod/validate.ts @@ -163,6 +163,10 @@ export function getZodSchemaAsTypeScript(schema: Record): str return append("unknown"); case "array": return appendArrayType(type); + case "set": + return appendSetType(type); + case "map": + return appendMapType(type); case "object": return appendObjectType(type); case "union": { // covers both z.union() and z.discriminatedUnion() — Zod v4 merged discriminated unions into the regular union type kind ("ZodDiscriminatedUnion" in v3); both have an `options` array @@ -198,6 +202,20 @@ export function getZodSchemaAsTypeScript(schema: Record): str append("[]"); } + function appendSetType(setType: z.ZodType) { + appendType((setType._zod.def as z.core.$ZodSetDef).valueType as z.ZodType, TypePrecedence.Object); + append("[]"); + } + + function appendMapType(mapType: z.ZodType) { + const mapDef = mapType._zod.def as z.core.$ZodMapDef; + append("["); + appendType(mapDef.keyType as z.ZodType); + append(", "); + appendType(mapDef.valueType as z.ZodType); + append("][]"); + } + function appendObjectType(objectType: z.ZodType) { append("{"); appendNewLine(); diff --git a/typescript/test/zod.test.ts b/typescript/test/zod.test.ts index 8db3e2ae..21bbf9f5 100644 --- a/typescript/test/zod.test.ts +++ b/typescript/test/zod.test.ts @@ -150,6 +150,34 @@ describe("getZodSchemaAsTypeScript", () => { }); + // ----------------------------------------------------------------------- + // Set & Map + // ----------------------------------------------------------------------- + + describe("z.set()", () => { + + it("produces an array wire representation for sets", () => { + assert.match(schemaOf("T", z.set(z.string())), /type T = string\[\];/); + }); + + it("parenthesizes a union element type in a set", () => { + assert.match(schemaOf("T", z.set(z.union([z.string(), z.number()]))), /type T = \(string \| number\)\[\];/); + }); + + }); + + describe("z.map()", () => { + + it("produces a key-value tuple array wire representation for maps", () => { + assert.match(schemaOf("T", z.map(z.string(), z.number())), /type T = \[string, number\]\[\];/); + }); + + it("supports union key and value types in maps", () => { + assert.match(schemaOf("T", z.map(z.union([z.string(), z.number()]), z.boolean())), /type T = \[string \| number, boolean\]\[\];/); + }); + + }); + // ----------------------------------------------------------------------- // Object — emitted as interface // ----------------------------------------------------------------------- From f2bc01e245d45d7ad9b840b78769dd7c62c5bd8c Mon Sep 17 00:00:00 2001 From: Utkarsh patwa Date: Thu, 19 Nov 2026 15:27:08 +0530 Subject: [PATCH 2/2] refactor(zod): preserve collection types for bare Set/Map and add transform regression tests Signed-off-by: Utkarsh patwa --- typescript/src/zod/validate.ts | 9 +++-- typescript/test/zod.test.ts | 68 ++++++++++++++++++++++++++++++---- 2 files changed, 66 insertions(+), 11 deletions(-) diff --git a/typescript/src/zod/validate.ts b/typescript/src/zod/validate.ts index 21e57026..42302286 100644 --- a/typescript/src/zod/validate.ts +++ b/typescript/src/zod/validate.ts @@ -203,17 +203,18 @@ export function getZodSchemaAsTypeScript(schema: Record): str } function appendSetType(setType: z.ZodType) { - appendType((setType._zod.def as z.core.$ZodSetDef).valueType as z.ZodType, TypePrecedence.Object); - append("[]"); + append("Set<"); + appendType((setType._zod.def as z.core.$ZodSetDef).valueType as z.ZodType); + append(">"); } function appendMapType(mapType: z.ZodType) { const mapDef = mapType._zod.def as z.core.$ZodMapDef; - append("["); + append("Map<"); appendType(mapDef.keyType as z.ZodType); append(", "); appendType(mapDef.valueType as z.ZodType); - append("][]"); + append(">"); } function appendObjectType(objectType: z.ZodType) { diff --git a/typescript/test/zod.test.ts b/typescript/test/zod.test.ts index 21bbf9f5..dfdab375 100644 --- a/typescript/test/zod.test.ts +++ b/typescript/test/zod.test.ts @@ -156,24 +156,24 @@ describe("getZodSchemaAsTypeScript", () => { describe("z.set()", () => { - it("produces an array wire representation for sets", () => { - assert.match(schemaOf("T", z.set(z.string())), /type T = string\[\];/); + it("produces Set representation for sets", () => { + assert.match(schemaOf("T", z.set(z.string())), /type T = Set;/); }); - it("parenthesizes a union element type in a set", () => { - assert.match(schemaOf("T", z.set(z.union([z.string(), z.number()]))), /type T = \(string \| number\)\[\];/); + it("supports union element type in a set", () => { + assert.match(schemaOf("T", z.set(z.union([z.string(), z.number()]))), /type T = Set;/); }); }); describe("z.map()", () => { - it("produces a key-value tuple array wire representation for maps", () => { - assert.match(schemaOf("T", z.map(z.string(), z.number())), /type T = \[string, number\]\[\];/); + it("produces Map representation for maps", () => { + assert.match(schemaOf("T", z.map(z.string(), z.number())), /type T = Map;/); }); it("supports union key and value types in maps", () => { - assert.match(schemaOf("T", z.map(z.union([z.string(), z.number()]), z.boolean())), /type T = \[string \| number, boolean\]\[\];/); + assert.match(schemaOf("T", z.map(z.union([z.string(), z.number()]), z.boolean())), /type T = Map;/); }); }); @@ -535,6 +535,60 @@ describe("getZodSchemaAsTypeScript", () => { assert.ok(!invalidResult.success, "expected invalid date-time validation to fail"); }); + it("preserves explicit array-to-Set and tuple-array-to-Map transforms during validation and translation", async () => { + const CollectionSchema = { + Collections: z.object({ + tags: z.array(z.string()).transform(items => new Set(items)), + entries: z.array(z.tuple([z.string(), z.number()])).transform(tuples => new Map(tuples)), + }), + }; + const validator = createZodJsonValidator(CollectionSchema, "Collections"); + const schemaText = validator.getSchemaText(); + assert.match(schemaText, /tags: string\[\];/); + assert.match(schemaText, /entries: \[string, number\]\[\];/); + + // Validation with JSON array inputs produces Set and Map instances + const valid = validator.validate({ + tags: ["apple", "banana", "apple"], + entries: [["first", 1], ["second", 2]], + }); + assert.ok(valid.success, "expected validation to succeed"); + assert.ok(valid.data.tags instanceof Set); + assert.equal(valid.data.tags.size, 2); + assert.ok(valid.data.tags.has("apple")); + assert.ok(valid.data.tags.has("banana")); + assert.ok(valid.data.entries instanceof Map); + assert.equal(valid.data.entries.get("first"), 1); + assert.equal(valid.data.entries.get("second"), 2); + + // Rejects invalid array elements + const invalid = validator.validate({ + tags: [123], + entries: [["first", 1]], + }); + assert.ok(!invalid.success, "expected invalid collection element to fail validation"); + + // Full translation path with stubbed language model + const mockModel = { + async complete() { + return { + success: true as const, + data: JSON.stringify({ + tags: ["alpha", "beta"], + entries: [["count", 42]], + }), + }; + }, + }; + const translator = createJsonTranslator(mockModel, validator); + const translationResult = await translator.translate("Provide sample collections"); + assert.ok(translationResult.success, "expected translation to succeed"); + assert.ok(translationResult.data.tags instanceof Set); + assert.ok(translationResult.data.tags.has("alpha")); + assert.ok(translationResult.data.entries instanceof Map); + assert.equal(translationResult.data.entries.get("count"), 42); + }); + }); // -----------------------------------------------------------------------