@tambo-ai/react 0.69.0 → 0.70.0

package/dist/schema/zod.test.js

@@ -1,663 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const z3 = __importStar(require("zod/v3"));
-const z4 = __importStar(require("zod/v4"));
-const zod_1 = require("./zod");
-// Test helper: assumes `value` is JSON-serializable (plain objects/arrays/primitives).
-// Conservative helper: returns true if any object in the tree has an own `key`
-// property at any depth. This lets us assert against JSON Schema `$ref` keys
-// structurally (not via incidental substrings in string values).
-function hasKeyDeep(value, key) {
-    const seen = new Set();
-    function isPlainObject(v) {
-        if (!v || typeof v !== "object" || Array.isArray(v))
-            return false;
-        const proto = Object.getPrototypeOf(v);
-        return proto === Object.prototype || proto === null;
-    }
-    function visit(node) {
-        if (!node || typeof node !== "object")
-            return false;
-        if (seen.has(node))
-            return false;
-        seen.add(node);
-        if (Array.isArray(node)) {
-            return node.some(visit);
-        }
-        if (!isPlainObject(node))
-            return false;
-        if (Object.prototype.hasOwnProperty.call(node, key))
-            return true;
-        return Object.values(node).some(visit);
-    }
-    return visit(value);
-}
-function resolveJsonPointer(doc, pointer) {
-    if (!pointer.startsWith("#"))
-        return undefined;
-    if (pointer === "#")
-        return doc;
-    if (!pointer.startsWith("#/"))
-        return undefined;
-    return pointer
-        .slice(2)
-        .split("/")
-        .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"))
-        .reduce((current, segment) => {
-        if (!current || typeof current !== "object")
-            return undefined;
-        if (Array.isArray(current)) {
-            const index = Number(segment);
-            if (!Number.isInteger(index))
-                return undefined;
-            return current[index];
-        }
-        return current[segment];
-    }, doc);
-}
-function createRecursiveZod4NodeSchema() {
-    // Placeholder schema so we can self-reference via `z4.lazy` without
-    // fighting ESLint `prefer-const`.
-    let nodeSchema = z4.any();
-    nodeSchema = z4.object({ next: z4.lazy(() => nodeSchema).optional() });
-    return nodeSchema;
-}
-describe("zod schema utilities", () => {
-    describe("isZod3Schema", () => {
-        it("returns true for Zod 3 schemas", () => {
-            const schema = z3.object({ name: z3.string() });
-            expect((0, zod_1.isZod3Schema)(schema)).toBe(true);
-            expect((0, zod_1.isZod4Schema)(schema)).toBe(false);
-        });
-        it("returns true for Zod 4 schemas (they also have _def)", () => {
-            // Note: Zod 4 schemas have both _def and _zod, so isZod3Schema returns true.
-            // This is fine because handleZodSchemaToJson checks isZod4Schema first.
-            const schema = z4.object({ name: z4.string() });
-            expect((0, zod_1.isZod4Schema)(schema)).toBe(true);
-            expect((0, zod_1.isZod3Schema)(schema)).toBe(false);
-        });
-        it("returns false for non-Zod values", () => {
-            expect((0, zod_1.isZod3Schema)({})).toBe(false);
-            expect((0, zod_1.isZod3Schema)(null)).toBe(false);
-            expect((0, zod_1.isZod3Schema)("string")).toBe(false);
-        });
-    });
-    describe("isZod4Schema", () => {
-        it("returns true for Zod 4 schemas", () => {
-            const schema = z4.object({ name: z4.string() });
-            expect((0, zod_1.isZod4Schema)(schema)).toBe(true);
-        });
-        it("returns false for Zod 3 schemas", () => {
-            const schema = z3.object({ name: z3.string() });
-            expect((0, zod_1.isZod4Schema)(schema)).toBe(false);
-        });
-        it("returns false for non-Zod values", () => {
-            expect((0, zod_1.isZod4Schema)({})).toBe(false);
-            expect((0, zod_1.isZod4Schema)(null)).toBe(false);
-            expect((0, zod_1.isZod4Schema)("string")).toBe(false);
-        });
-    });
-    describe("isZodSchema", () => {
-        it("returns true for Zod 3 schemas", () => {
-            expect((0, zod_1.isZodSchema)(z3.string())).toBe(true);
-            expect((0, zod_1.isZodSchema)(z3.object({ a: z3.string() }))).toBe(true);
-        });
-        it("returns true for Zod 4 schemas", () => {
-            expect((0, zod_1.isZodSchema)(z4.string())).toBe(true);
-            expect((0, zod_1.isZodSchema)(z4.object({ a: z4.string() }))).toBe(true);
-        });
-        it("returns false for non-objects", () => {
-            expect((0, zod_1.isZodSchema)(null)).toBe(false);
-            expect((0, zod_1.isZodSchema)(undefined)).toBe(false);
-            expect((0, zod_1.isZodSchema)("string")).toBe(false);
-            expect((0, zod_1.isZodSchema)(123)).toBe(false);
-        });
-        it("returns false for objects without ~standard", () => {
-            expect((0, zod_1.isZodSchema)({})).toBe(false);
-            expect((0, zod_1.isZodSchema)({ foo: "bar" })).toBe(false);
-        });
-        it("returns false for objects with invalid ~standard", () => {
-            expect((0, zod_1.isZodSchema)({ "~standard": null })).toBe(false);
-            expect((0, zod_1.isZodSchema)({ "~standard": "not-object" })).toBe(false);
-            expect((0, zod_1.isZodSchema)({ "~standard": {} })).toBe(false);
-            expect((0, zod_1.isZodSchema)({ "~standard": { vendor: "not-zod" } })).toBe(false);
-        });
-    });
-    describe("isZodFunctionSchema", () => {
-        it("returns true for Zod 3 function schemas", () => {
-            const schema = z3.function().args(z3.string()).returns(z3.void());
-            expect((0, zod_1.isZodFunctionSchema)(schema)).toBe(true);
-            expect((0, zod_1.isZod3FunctionSchema)(schema)).toBe(true);
-            expect((0, zod_1.isZod4FunctionSchema)(schema)).toBe(false);
-        });
-        it("returns true for Zod 4 function schemas", () => {
-            const schema = z4.function({
-                input: z4.tuple([z4.string()]),
-                output: z4.void(),
-            });
-            expect((0, zod_1.isZodFunctionSchema)(schema)).toBe(true);
-            expect((0, zod_1.isZod3FunctionSchema)(schema)).toBe(false);
-            expect((0, zod_1.isZod4FunctionSchema)(schema)).toBe(true);
-        });
-        it("returns false for non-function Zod schemas", () => {
-            expect((0, zod_1.isZodFunctionSchema)(z3.string())).toBe(false);
-            expect((0, zod_1.isZodFunctionSchema)(z3.object({ a: z3.string() }))).toBe(false);
-            expect((0, zod_1.isZodFunctionSchema)(z4.string())).toBe(false);
-            expect((0, zod_1.isZodFunctionSchema)(z4.object({ a: z4.string() }))).toBe(false);
-        });
-        it("returns false for non-Zod values", () => {
-            expect((0, zod_1.isZodFunctionSchema)(null)).toBe(false);
-            expect((0, zod_1.isZodFunctionSchema)({})).toBe(false);
-            expect((0, zod_1.isZodFunctionSchema)("function")).toBe(false);
-        });
-    });
-    describe("handleZodSchemaToJson", () => {
-        describe("basic conversion", () => {
-            it("converts Zod 3 schema to JSON Schema", () => {
-                const schema = z3.object({
-                    name: z3.string(),
-                    age: z3.number(),
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(schema);
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        name: { type: "string" },
-                        age: { type: "number" },
-                    },
-                });
-            });
-            it("converts Zod 4 schema to JSON Schema", () => {
-                const schema = z4.object({
-                    name: z4.string(),
-                    age: z4.number(),
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(schema);
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        name: { type: "string" },
-                        age: { type: "number" },
-                    },
-                });
-            });
-        });
-        describe("reused schemas - no $ref references", () => {
-            it("inlines reused Zod 3 schemas without any $ref in output", () => {
-                // Define a shared schema that will be reused
-                const dataSchema = z3.object({
-                    name: z3.string(),
-                    value: z3.number(),
-                });
-                // Use the same schema in multiple places
-                const props = z3.object({
-                    data: z3.array(dataSchema),
-                    historicalData: z3.array(dataSchema),
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(props);
-                // Ensure there are no JSON Schema `$ref` keys anywhere in the produced schema.
-                expect(hasKeyDeep(result, "$ref")).toBe(false);
-                // Both arrays should have the full schema inline
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        data: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    name: { type: "string" },
-                                    value: { type: "number" },
-                                },
-                            },
-                        },
-                        historicalData: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    name: { type: "string" },
-                                    value: { type: "number" },
-                                },
-                            },
-                        },
-                    },
-                });
-            });
-            it("inlines reused Zod 4 schemas without any $ref in output", () => {
-                // Define a shared schema that will be reused
-                const dataSchema = z4.object({
-                    name: z4.string(),
-                    value: z4.number(),
-                });
-                // Use the same schema in multiple places
-                const props = z4.object({
-                    data: z4.array(dataSchema),
-                    historicalData: z4.array(dataSchema),
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(props);
-                expect(hasKeyDeep(result, "$ref")).toBe(false);
-                // Both arrays should have the full schema inline
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        data: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    name: { type: "string" },
-                                    value: { type: "number" },
-                                },
-                            },
-                        },
-                        historicalData: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    name: { type: "string" },
-                                    value: { type: "number" },
-                                },
-                            },
-                        },
-                    },
-                });
-            });
-            it("handles deeply nested reused Zod 3 schemas without any $ref", () => {
-                const addressSchema = z3.object({
-                    street: z3.string(),
-                    city: z3.string(),
-                });
-                const personSchema = z3.object({
-                    name: z3.string(),
-                    homeAddress: addressSchema,
-                    workAddress: addressSchema,
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(personSchema);
-                expect(hasKeyDeep(result, "$ref")).toBe(false);
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        name: { type: "string" },
-                        homeAddress: {
-                            type: "object",
-                            properties: {
-                                street: { type: "string" },
-                                city: { type: "string" },
-                            },
-                        },
-                        workAddress: {
-                            type: "object",
-                            properties: {
-                                street: { type: "string" },
-                                city: { type: "string" },
-                            },
-                        },
-                    },
-                });
-            });
-            it("handles deeply nested reused Zod 4 schemas without any $ref", () => {
-                const addressSchema = z4.object({
-                    street: z4.string(),
-                    city: z4.string(),
-                });
-                const personSchema = z4.object({
-                    name: z4.string(),
-                    homeAddress: addressSchema,
-                    workAddress: addressSchema,
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(personSchema);
-                expect(hasKeyDeep(result, "$ref")).toBe(false);
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        name: { type: "string" },
-                        homeAddress: {
-                            type: "object",
-                            properties: {
-                                street: { type: "string" },
-                                city: { type: "string" },
-                            },
-                        },
-                        workAddress: {
-                            type: "object",
-                            properties: {
-                                street: { type: "string" },
-                                city: { type: "string" },
-                            },
-                        },
-                    },
-                });
-            });
-            it("handles triple-nested reused Zod 4 schemas without any $ref", () => {
-                const pointSchema = z4.object({
-                    x: z4.number(),
-                    y: z4.number(),
-                });
-                const lineSchema = z4.object({
-                    start: pointSchema,
-                    end: pointSchema,
-                });
-                const shapeSchema = z4.object({
-                    outline: z4.array(lineSchema),
-                    boundingBox: z4.object({
-                        topLeft: pointSchema,
-                        bottomRight: pointSchema,
-                    }),
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(shapeSchema);
-                expect(result).toMatchInlineSnapshot(`
-          {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "additionalProperties": false,
-            "properties": {
-              "boundingBox": {
-                "additionalProperties": false,
-                "properties": {
-                  "bottomRight": {
-                    "additionalProperties": false,
-                    "properties": {
-                      "x": {
-                        "type": "number",
-                      },
-                      "y": {
-                        "type": "number",
-                      },
-                    },
-                    "required": [
-                      "x",
-                      "y",
-                    ],
-                    "type": "object",
-                  },
-                  "topLeft": {
-                    "additionalProperties": false,
-                    "properties": {
-                      "x": {
-                        "type": "number",
-                      },
-                      "y": {
-                        "type": "number",
-                      },
-                    },
-                    "required": [
-                      "x",
-                      "y",
-                    ],
-                    "type": "object",
-                  },
-                },
-                "required": [
-                  "topLeft",
-                  "bottomRight",
-                ],
-                "type": "object",
-              },
-              "outline": {
-                "items": {
-                  "additionalProperties": false,
-                  "properties": {
-                    "end": {
-                      "additionalProperties": false,
-                      "properties": {
-                        "x": {
-                          "type": "number",
-                        },
-                        "y": {
-                          "type": "number",
-                        },
-                      },
-                      "required": [
-                        "x",
-                        "y",
-                      ],
-                      "type": "object",
-                    },
-                    "start": {
-                      "additionalProperties": false,
-                      "properties": {
-                        "x": {
-                          "type": "number",
-                        },
-                        "y": {
-                          "type": "number",
-                        },
-                      },
-                      "required": [
-                        "x",
-                        "y",
-                      ],
-                      "type": "object",
-                    },
-                  },
-                  "required": [
-                    "start",
-                    "end",
-                  ],
-                  "type": "object",
-                },
-                "type": "array",
-              },
-            },
-            "required": [
-              "outline",
-              "boundingBox",
-            ],
-            "type": "object",
-          }
-        `);
-                expect(hasKeyDeep(result, "$ref")).toBe(false);
-            });
-        });
-        describe("recursive schemas", () => {
-            it("represents Zod 4 recursive schemas using $ref", () => {
-                const nodeSchema = createRecursiveZod4NodeSchema();
-                const result = (0, zod_1.handleZodSchemaToJson)(nodeSchema);
-                const schema = result;
-                const properties = schema.properties;
-                const next = properties?.next;
-                const ref = next?.$ref;
-                expect(hasKeyDeep(result, "$ref")).toBe(true);
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        next: {
-                            $ref: expect.stringMatching(/^#(\/.*)?$/),
-                        },
-                    },
-                });
-                expect(ref).toEqual(expect.stringMatching(/^#(\/.*)?$/));
-                const resolved = typeof ref === "string" ? resolveJsonPointer(result, ref) : undefined;
-                expect(resolved).toBe(result);
-                expect(resolved).toMatchObject({
-                    type: "object",
-                });
-            });
-        });
-        describe("complex schemas", () => {
-            it("handles optional fields in Zod 3", () => {
-                const schema = z3.object({
-                    required: z3.string(),
-                    optional: z3.string().optional(),
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(schema);
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        required: { type: "string" },
-                        optional: { type: "string" },
-                    },
-                    required: ["required"],
-                });
-            });
-            it("handles optional fields in Zod 4", () => {
-                const schema = z4.object({
-                    required: z4.string(),
-                    optional: z4.string().optional(),
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(schema);
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        required: { type: "string" },
-                        optional: { type: "string" },
-                    },
-                    required: ["required"],
-                });
-            });
-            it("handles enums in Zod 3", () => {
-                const schema = z3.object({
-                    status: z3.enum(["active", "inactive", "pending"]),
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(schema);
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        status: {
-                            type: "string",
-                            enum: ["active", "inactive", "pending"],
-                        },
-                    },
-                });
-            });
-            it("handles enums in Zod 4", () => {
-                const schema = z4.object({
-                    status: z4.enum(["active", "inactive", "pending"]),
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(schema);
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        status: {
-                            type: "string",
-                            enum: ["active", "inactive", "pending"],
-                        },
-                    },
-                });
-            });
-            it("handles descriptions in Zod 3", () => {
-                const schema = z3.object({
-                    name: z3.string().describe("The user name"),
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(schema);
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        name: {
-                            type: "string",
-                            description: "The user name",
-                        },
-                    },
-                });
-            });
-            it("handles descriptions in Zod 4", () => {
-                const schema = z4.object({
-                    name: z4.string().describe("The user name"),
-                });
-                const result = (0, zod_1.handleZodSchemaToJson)(schema);
-                expect(result).toMatchObject({
-                    type: "object",
-                    properties: {
-                        name: {
-                            type: "string",
-                            description: "The user name",
-                        },
-                    },
-                });
-            });
-        });
-    });
-    describe("getZodFunctionArgs", () => {
-        it("extracts args from Zod 3 function schema", () => {
-            const schema = z3
-                .function()
-                .args(z3.string(), z3.number())
-                .returns(z3.boolean());
-            const args = (0, zod_1.getZodFunctionArgs)(schema);
-            expect(args).toBeDefined();
-            // Zod 3 args is a ZodTuple - check the _def property exists
-            expect(args._def.typeName).toBe("ZodTuple");
-        });
-        it("extracts args from Zod 4 function schema", () => {
-            const schema = z4.function({
-                input: z4.tuple([z4.string(), z4.number()]),
-                output: z4.boolean(),
-            });
-            const args = (0, zod_1.getZodFunctionArgs)(schema);
-            expect(args).toBeDefined();
-            // Zod 4 args is accessed via .def.input - it's the tuple schema
-            expect(args).toHaveProperty("def");
-        });
-        it("throws for non-function schemas", () => {
-            expect(() => (0, zod_1.getZodFunctionArgs)(z3.string())).toThrow("Unable to determine parameters from zod function schema");
-            expect(() => (0, zod_1.getZodFunctionArgs)(z4.string())).toThrow("Unable to determine parameters from zod function schema");
-        });
-        it("throws for non-Zod values", () => {
-            expect(() => (0, zod_1.getZodFunctionArgs)({})).toThrow("Unable to determine parameters from zod function schema");
-        });
-    });
-    describe("getZodFunctionReturns", () => {
-        it("extracts returns from Zod 3 function schema", () => {
-            const schema = z3
-                .function()
-                .args(z3.string())
-                .returns(z3.object({ result: z3.boolean() }));
-            const returns = (0, zod_1.getZodFunctionReturns)(schema);
-            expect(returns).toBeDefined();
-            // Cast to access _def property on Zod 3 schema
-            expect(returns._def.typeName).toBe("ZodObject");
-        });
-        it("extracts returns from Zod 4 function schema", () => {
-            const schema = z4.function({
-                input: z4.tuple([z4.string()]),
-                output: z4.object({ result: z4.boolean() }),
-            });
-            const returns = (0, zod_1.getZodFunctionReturns)(schema);
-            expect(returns).toBeDefined();
-            // Zod 4 returns is accessed via .def.output - it's the object schema
-            expect(returns).toHaveProperty("def");
-        });
-        it("throws for non-function schemas", () => {
-            expect(() => (0, zod_1.getZodFunctionReturns)(z3.string())).toThrow("Unable to determine return type from zod function schema");
-            expect(() => (0, zod_1.getZodFunctionReturns)(z4.string())).toThrow("Unable to determine return type from zod function schema");
-        });
-        it("throws for non-Zod values", () => {
-            expect(() => (0, zod_1.getZodFunctionReturns)({})).toThrow("Unable to determine return type from zod function schema");
-        });
-    });
-});
-//# sourceMappingURL=zod.test.js.map