@copilotkit/shared/dist/utils/json-schema.test.js

<div align="center"> <a href="https://copilotkit.ai" target="_blank"> <img src="https://github.com/copilotkit/copilotkit/raw/main/assets/banner.png" alt="CopilotKit Logo"> </a>

"use strict";

// src/utils/json-schema.test.ts
var import_zod2 = require("zod");

// src/utils/json-schema.ts
var import_zod = require("zod");
function convertJsonSchemaToZodSchema(jsonSchema, required) {
  if (jsonSchema.type === "object") {
    const spec = {};
    if (!jsonSchema.properties || !Object.keys(jsonSchema.properties).length) {
      return !required ? import_zod.z.object(spec).optional() : import_zod.z.object(spec);
    }
    for (const [key, value] of Object.entries(jsonSchema.properties)) {
      spec[key] = convertJsonSchemaToZodSchema(
        value,
        jsonSchema.required ? jsonSchema.required.includes(key) : false
      );
    }
    let schema = import_zod.z.object(spec).describe(jsonSchema.description);
    return required ? schema : schema.optional();
  } else if (jsonSchema.type === "string") {
    let schema = import_zod.z.string().describe(jsonSchema.description);
    return required ? schema : schema.optional();
  } else if (jsonSchema.type === "number") {
    let schema = import_zod.z.number().describe(jsonSchema.description);
    return required ? schema : schema.optional();
  } else if (jsonSchema.type === "boolean") {
    let schema = import_zod.z.boolean().describe(jsonSchema.description);
    return required ? schema : schema.optional();
  } else if (jsonSchema.type === "array") {
    let itemSchema = convertJsonSchemaToZodSchema(jsonSchema.items, true);
    let schema = import_zod.z.array(itemSchema).describe(jsonSchema.description);
    return required ? schema : schema.optional();
  }
  throw new Error("Invalid JSON schema");
}

// src/utils/json-schema.test.ts
var import_zod_to_json_schema = require("zod-to-json-schema");
describe("convertJsonSchemaToZodSchema", () => {
  it("should convert a simple JSON schema to a Zod schema", () => {
    const jsonSchema = {
      type: "object",
      properties: {
        name: { type: "string" },
        age: { type: "number" }
      },
      required: ["name", "age"]
    };
    const expectedSchema = import_zod2.z.object({
      name: import_zod2.z.string(),
      age: import_zod2.z.number()
    });
    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
    const resultSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(result);
    const expectedSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(expectedSchema);
    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
  });
  it("should convert a JSON schema with nested objects to a Zod schema", () => {
    const jsonSchema = {
      type: "object",
      properties: {
        name: { type: "string" },
        address: {
          type: "object",
          properties: {
            street: { type: "string" },
            city: { type: "string" }
          },
          required: ["street", "city"]
        }
      },
      required: ["name", "address"]
    };
    const expectedSchema = import_zod2.z.object({
      name: import_zod2.z.string(),
      address: import_zod2.z.object({
        street: import_zod2.z.string(),
        city: import_zod2.z.string()
      })
    });
    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
    const resultSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(result);
    const expectedSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(expectedSchema);
    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
  });
  it("should convert a JSON schema with arrays to a Zod schema", () => {
    const jsonSchema = {
      type: "object",
      properties: {
        names: {
          type: "array",
          items: { type: "string" }
        }
      },
      required: ["names"]
    };
    const expectedSchema = import_zod2.z.object({
      names: import_zod2.z.array(import_zod2.z.string())
    });
    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
    const resultSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(result);
    const expectedSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(expectedSchema);
    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
  });
  it("should convert a JSON schema with optional properties to a Zod schema", () => {
    const jsonSchema = {
      type: "object",
      properties: {
        name: { type: "string" },
        age: { type: "number", required: false }
      }
    };
    const expectedSchema = import_zod2.z.object({
      name: import_zod2.z.string().optional(),
      age: import_zod2.z.number().optional()
    }).optional();
    const result = convertJsonSchemaToZodSchema(jsonSchema, false);
    console.log(convertJsonSchemaToZodSchema(jsonSchema, false));
    const resultSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(result);
    const expectedSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(expectedSchema);
    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
  });
  it("should convert a JSON schema with different types to a Zod schema", () => {
    const jsonSchema = {
      type: "object",
      properties: {
        name: { type: "string" },
        age: { type: "number" },
        isAdmin: { type: "boolean" }
      },
      required: ["name", "age", "isAdmin"]
    };
    const expectedSchema = import_zod2.z.object({
      name: import_zod2.z.string(),
      age: import_zod2.z.number(),
      isAdmin: import_zod2.z.boolean()
    });
    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
    const resultSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(result);
    const expectedSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(expectedSchema);
    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
  });
  it("should handle edge case where JSON schema has no properties", () => {
    const jsonSchema = {
      type: "object"
    };
    const expectedSchema = import_zod2.z.object({});
    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
    const resultSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(result);
    const expectedSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(expectedSchema);
    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
  });
  it("should handle edge case where JSON schema has no required properties", () => {
    const jsonSchema = {
      type: "object",
      properties: {
        name: { type: "string" },
        age: { type: "number" }
      }
    };
    const expectedSchema = import_zod2.z.object({
      name: import_zod2.z.string().optional(),
      age: import_zod2.z.number().optional()
    }).optional();
    const result = convertJsonSchemaToZodSchema(jsonSchema, false);
    const resultSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(result);
    const expectedSchemaJson = (0, import_zod_to_json_schema.zodToJsonSchema)(expectedSchema);
    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
  });
});
//# sourceMappingURL=json-schema.test.js.map