gemini-zod/dist/index.js

Gemini AI Schema to Zod Adapter

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.toGeminiSchema = toGeminiSchema;
exports.toZodSchema = toZodSchema;
const util_1 = require("./util");
function decorateGeminiSchema(geminiSchema, zodSchema) {
    if (geminiSchema.nullable === undefined) {
        geminiSchema.nullable = zodSchema.isOptional();
    }
    if (zodSchema.description) {
        geminiSchema.description = zodSchema.description;
    }
    return geminiSchema;
}
function decorateZodSchema(z, geminiSchema) {
    if (geminiSchema.nullable) {
        z = z.nullable();
    }
    if (geminiSchema.description) {
        z = z.describe(geminiSchema.description);
    }
    return z;
}
function toGeminiSchema(zodSchema) {
    const zodType = (0, util_1.getZodType)(zodSchema);
    switch (zodType) {
        case 'ZodArray':
            return decorateGeminiSchema({
                type: util_1.SchemaType.ARRAY,
                items: toGeminiSchema(zodSchema.element),
            }, zodSchema);
        case 'ZodObject':
            const properties = {};
            const required = [];
            Object.entries(zodSchema.shape).forEach(([key, value]) => {
                properties[key] = toGeminiSchema(value);
                if ((0, util_1.getZodType)(value) !== 'ZodOptional') {
                    required.push(key);
                }
            });
            return decorateGeminiSchema({
                type: util_1.SchemaType.OBJECT,
                properties,
                required: required.length > 0 ? required : undefined,
            }, zodSchema);
        case 'ZodString':
            return decorateGeminiSchema({
                type: util_1.SchemaType.STRING,
            }, zodSchema);
        case 'ZodNumber':
            return decorateGeminiSchema({
                type: util_1.SchemaType.NUMBER,
            }, zodSchema);
        case 'ZodBoolean':
            return decorateGeminiSchema({
                type: util_1.SchemaType.BOOLEAN,
            }, zodSchema);
        case 'ZodEnum':
            return decorateGeminiSchema({
                type: util_1.SchemaType.STRING,
                enum: zodSchema._def.values,
            }, zodSchema);
        case 'ZodDefault':
        case 'ZodNullable':
        case 'ZodOptional':
            const innerSchema = toGeminiSchema(zodSchema._def.innerType);
            return decorateGeminiSchema({
                ...innerSchema,
                nullable: true,
            }, zodSchema);
        case 'ZodLiteral':
            return decorateGeminiSchema({
                type: util_1.SchemaType.STRING,
                enum: [zodSchema._def.value],
            }, zodSchema);
        default:
            return decorateGeminiSchema({
                type: util_1.SchemaType.OBJECT,
                nullable: true,
            }, zodSchema);
    }
}
function toZodSchema(geminiSchema) {
    const z = require('zod'); // Dynamically import zod to avoid bundling it
    switch (geminiSchema.type) {
        case util_1.SchemaType.ARRAY:
            return decorateZodSchema(z.array(toZodSchema(geminiSchema.items)), geminiSchema);
        case util_1.SchemaType.OBJECT:
            const shape = {};
            Object.entries(geminiSchema.properties).forEach(([key, value]) => {
                let fieldSchema = toZodSchema(value);
                if (!geminiSchema.required || !geminiSchema.required.includes(key)) {
                    fieldSchema = fieldSchema.optional();
                }
                shape[key] = fieldSchema;
            });
            return decorateZodSchema(z.object(shape), geminiSchema);
        case util_1.SchemaType.STRING:
            return decorateZodSchema(z.string(), geminiSchema);
        case util_1.SchemaType.NUMBER:
        case util_1.SchemaType.INTEGER:
            return decorateZodSchema(z.number(), geminiSchema);
        case util_1.SchemaType.BOOLEAN:
            return decorateZodSchema(z.boolean(), geminiSchema);
        default:
            return decorateZodSchema(z.any(), geminiSchema);
    }
}
//# sourceMappingURL=index.js.map