{"version":3,"file":"index.cjs","names":["ExpressionUtils","z","Decimal","z","SchemaAccessor","Decimal","ExpressionUtils"],"sources":["../src/error.ts","../src/utils.ts","../src/factory.ts"],"sourcesContent":["/**\n * Error representing failures in Zod schema building.\n */\nexport class SchemaFactoryError extends Error {\n    constructor(message: string) {\n        super(message);\n    }\n}\n","import {\n    ExpressionUtils,\n    type AttributeApplication,\n    type BinaryExpression,\n    type CallExpression,\n    type Expression,\n    type FieldExpression,\n    type MemberExpression,\n    type UnaryExpression,\n} from '@zenstackhq/schema';\nimport Decimal from 'decimal.js';\nimport { z } from 'zod';\nimport { SchemaFactoryError } from './error';\n\n// z.string()[mapped]\nconst stringFuncZodMap = {\n    isEmail: 'email',\n    isUrl: 'url',\n    isPhone: 'e164',\n    isDate: 'date',\n    isTime: 'time',\n    isDateTime: 'datetime',\n} as const;\n\nfunction getArgValue<T extends string | number | boolean>(expr: Expression | undefined): T | undefined {\n    if (!expr || !ExpressionUtils.isLiteral(expr)) {\n        return undefined;\n    }\n    return expr.value as T;\n}\n\nexport function addStringValidation(\n    schema: z.ZodString,\n    attributes: readonly AttributeApplication[] | undefined,\n): z.ZodSchema {\n    if (!attributes || attributes.length === 0) {\n        return schema;\n    }\n\n    let result = schema;\n    for (const attr of attributes) {\n        switch (attr.name) {\n            case '@length': {\n                const min = getArgValue<number>(attr.args?.find((a) => a.name === 'min')?.value);\n                if (min !== undefined) {\n                    result = result.min(min);\n                }\n                const max = getArgValue<number>(attr.args?.find((a) => a.name === 'max')?.value);\n                if (max !== undefined) {\n                    result = result.max(max);\n                }\n                break;\n            }\n            case '@startsWith': {\n                const value = getArgValue<string>(attr.args?.[0]?.value);\n                if (value !== undefined) {\n                    result = result.startsWith(value);\n                }\n                break;\n            }\n            case '@endsWith': {\n                const value = getArgValue<string>(attr.args?.[0]?.value);\n                if (value !== undefined) {\n                    result = result.endsWith(value);\n                }\n                break;\n            }\n            case '@contains': {\n                const value = getArgValue<string>(attr.args?.[0]?.value);\n                if (value !== undefined) {\n                    result = result.includes(value);\n                }\n                break;\n            }\n            case '@regex': {\n                const pattern = getArgValue<string>(attr.args?.[0]?.value);\n                if (pattern !== undefined) {\n                    result = result.regex(new RegExp(pattern));\n                }\n                break;\n            }\n            case '@email':\n                result = result.email();\n                break;\n            case '@phone':\n                result = result.e164();\n                break;\n            case '@date':\n                result = result.date();\n                break;\n            case '@time': {\n                const precision = getArgValue<number>(attr.args?.[0]?.value);\n                result = result.time({ precision });\n                break;\n            }\n            case '@datetime':\n                result = result.datetime();\n                break;\n            case '@url':\n                result = result.url();\n                break;\n            case '@trim':\n                result = result.trim();\n                break;\n            case '@lower':\n                result = result.toLowerCase();\n                break;\n            case '@upper':\n                result = result.toUpperCase();\n                break;\n        }\n    }\n    return result;\n}\n\nexport function addNumberValidation(\n    schema: z.ZodNumber,\n    attributes: readonly AttributeApplication[] | undefined,\n): z.ZodSchema {\n    if (!attributes || attributes.length === 0) {\n        return schema;\n    }\n\n    let result = schema;\n    for (const attr of attributes) {\n        const val = getArgValue<number>(attr.args?.[0]?.value);\n        if (val === undefined) {\n            continue;\n        }\n        switch (attr.name) {\n            case '@gt':\n                result = result.gt(val);\n                break;\n            case '@gte':\n                result = result.gte(val);\n                break;\n            case '@lt':\n                result = result.lt(val);\n                break;\n            case '@lte':\n                result = result.lte(val);\n                break;\n        }\n    }\n    return result;\n}\n\nexport function addBigIntValidation(\n    schema: z.ZodBigInt,\n    attributes: readonly AttributeApplication[] | undefined,\n): z.ZodSchema {\n    if (!attributes || attributes.length === 0) {\n        return schema;\n    }\n\n    let result = schema;\n    for (const attr of attributes) {\n        const val = getArgValue<number>(attr.args?.[0]?.value);\n        if (val === undefined) {\n            continue;\n        }\n\n        switch (attr.name) {\n            case '@gt':\n                result = result.gt(BigInt(val));\n                break;\n            case '@gte':\n                result = result.gte(BigInt(val));\n                break;\n            case '@lt':\n                result = result.lt(BigInt(val));\n                break;\n            case '@lte':\n                result = result.lte(BigInt(val));\n                break;\n        }\n    }\n    return result;\n}\n\nexport function addDecimalValidation(\n    schema: z.ZodType<Decimal> | z.ZodString,\n    attributes: readonly AttributeApplication[] | undefined,\n    addExtraValidation: boolean,\n): z.ZodSchema {\n    let result: z.ZodSchema = schema;\n\n    // parse string to Decimal\n    if (schema instanceof z.ZodString) {\n        result = schema\n            .superRefine((v, ctx) => {\n                try {\n                    new Decimal(v);\n                } catch (err) {\n                    ctx.addIssue({\n                        code: 'custom',\n                        message: `Invalid decimal: ${err}`,\n                    });\n                }\n            })\n            .transform((val) => new Decimal(val));\n    }\n\n    // add validations\n\n    function refine(schema: z.ZodSchema, op: 'gt' | 'gte' | 'lt' | 'lte', value: number) {\n        return schema.superRefine((v, ctx) => {\n            const base = z.number();\n            const { error } = base[op](value).safeParse((v as Decimal).toNumber());\n            error?.issues.forEach((issue) => {\n                if (op === 'gt' || op === 'gte') {\n                    ctx.addIssue({\n                        code: 'too_small',\n                        origin: 'number',\n                        minimum: value,\n                        type: 'decimal',\n                        inclusive: op === 'gte',\n                        message: issue.message,\n                    });\n                } else {\n                    ctx.addIssue({\n                        code: 'too_big',\n                        origin: 'number',\n                        maximum: value,\n                        type: 'decimal',\n                        inclusive: op === 'lte',\n                        message: issue.message,\n                    });\n                }\n            });\n        });\n    }\n\n    if (attributes && addExtraValidation) {\n        for (const attr of attributes) {\n            const val = getArgValue<number>(attr.args?.[0]?.value);\n            if (val === undefined) {\n                continue;\n            }\n\n            switch (attr.name) {\n                case '@gt':\n                    result = refine(result, 'gt', val);\n                    break;\n                case '@gte':\n                    result = refine(result, 'gte', val);\n                    break;\n                case '@lt':\n                    result = refine(result, 'lt', val);\n                    break;\n                case '@lte':\n                    result = refine(result, 'lte', val);\n                    break;\n            }\n        }\n    }\n\n    return result;\n}\n\nexport function addListValidation(\n    schema: z.ZodArray<any>,\n    attributes: readonly AttributeApplication[] | undefined,\n): z.ZodSchema {\n    if (!attributes || attributes.length === 0) {\n        return schema;\n    }\n\n    let result = schema;\n    for (const attr of attributes) {\n        if (attr.name === '@length') {\n            const min = getArgValue<number>(attr.args?.find((a) => a.name === 'min')?.value);\n            if (min !== undefined) {\n                result = result.min(min);\n            }\n            const max = getArgValue<number>(attr.args?.find((a) => a.name === 'max')?.value);\n            if (max !== undefined) {\n                result = result.max(max);\n            }\n        }\n    }\n    return result;\n}\n\n/**\n * Recursively collects all field names referenced by `kind: 'field'` nodes\n * inside an expression tree.\n */\nexport function collectFieldRefs(expr: Expression): Set<string> {\n    const refs = new Set<string>();\n    function walk(e: Expression): void {\n        switch (e.kind) {\n            case 'field':\n                refs.add(e.field);\n                break;\n            case 'unary':\n                walk(e.operand);\n                break;\n            case 'binary':\n                walk(e.left);\n                walk(e.right);\n                break;\n            case 'call':\n                e.args?.forEach(walk);\n                break;\n            case 'array':\n                e.items.forEach(walk);\n                break;\n            case 'member':\n                walk(e.receiver);\n                break;\n            // literal / null / this / binding — no field refs\n        }\n    }\n    walk(expr);\n    return refs;\n}\n\n/**\n * Applies `@@validate` rules from `attributes` to `schema` as Zod refinements.\n *\n * When `presentFields` is provided, only rules whose every field reference is\n * present in the set are applied. Rules that reference a field absent from the\n * set are silently skipped — they cannot be evaluated correctly against a\n * partial payload (e.g. when `select` or `omit` has been used).\n *\n * Omit `presentFields` (or pass `undefined`) to apply all rules\n * unconditionally, which is the correct behaviour for full-model schemas.\n *\n * Note: `@@validate` conditions are restricted by the ZModel compiler to\n * scalar fields of the same model only — relation fields are a compile error.\n * A flat field-name set is therefore sufficient.\n */\nexport function addCustomValidation(\n    schema: z.ZodSchema,\n    attributes: readonly AttributeApplication[] | undefined,\n    presentFields?: ReadonlySet<string>,\n): z.ZodSchema {\n    const attrs = attributes?.filter((a) => a.name === '@@validate');\n    if (!attrs || attrs.length === 0) {\n        return schema;\n    }\n\n    let result = schema;\n    for (const attr of attrs) {\n        const expr = attr.args?.[0]?.value;\n        if (!expr) {\n            continue;\n        }\n\n        // Skip rules that reference a field absent from the partial shape.\n        if (presentFields !== undefined) {\n            const refs = collectFieldRefs(expr);\n            if ([...refs].some((ref) => !presentFields.has(ref))) {\n                continue;\n            }\n        }\n\n        const message = getArgValue<string>(attr.args?.[1]?.value);\n        const pathExpr = attr.args?.[2]?.value;\n        let path: string[] | undefined = undefined;\n        if (pathExpr && ExpressionUtils.isArray(pathExpr)) {\n            path = pathExpr.items.map((e) => ExpressionUtils.getLiteralValue(e) as string);\n        }\n        result = applyValidation(result, expr, message, path);\n    }\n    return result;\n}\n\nfunction applyValidation(\n    schema: z.ZodSchema,\n    expr: Expression,\n    message: string | undefined,\n    path: string[] | undefined,\n) {\n    const options: Parameters<typeof schema.refine>[1] = {};\n    if (message) {\n        options.error = message;\n    }\n    if (path) {\n        options.path = path;\n    }\n    return schema.refine((data) => Boolean(evalExpression(data, expr)), options);\n}\n\nfunction evalExpression(data: any, expr: Expression): unknown {\n    switch (expr.kind) {\n        case 'literal':\n            return expr.value;\n        case 'array':\n            return expr.items.map((item) => evalExpression(data, item));\n        case 'field':\n            return evalField(data, expr);\n        case 'member':\n            return evalMember(data, expr);\n        case 'unary':\n            return evalUnary(data, expr);\n        case 'binary':\n            return evalBinary(data, expr);\n        case 'call':\n            return evalCall(data, expr);\n        case 'this':\n            return data ?? null;\n        case 'null':\n            return null;\n        case 'binding':\n            throw new SchemaFactoryError('Binding expression is not supported in validation expressions');\n    }\n}\n\n/**\n * Sentinel value returned by `evalField` when a field key is entirely absent\n * from the data object (as opposed to being present with a `null` value).\n * Used by comparison operators to skip @@validate rules against missing\n * optional fields (e.g. when `optionality: 'all'` produces a partial payload).\n */\nconst ABSENT = Symbol('absent');\n\nfunction evalField(data: any, e: FieldExpression) {\n    if (data == null || !(e.field in data)) {\n        return ABSENT;\n    }\n    // Coerce undefined to null so downstream code only needs to handle null.\n    return data[e.field] ?? null;\n}\n\nfunction evalUnary(data: any, expr: UnaryExpression) {\n    const operand = evalExpression(data, expr.operand);\n    switch (expr.op) {\n        case '!':\n            return !operand;\n        default:\n            throw new SchemaFactoryError(`Unsupported unary operator: ${expr.op}`);\n    }\n}\n\nfunction evalBinary(data: any, expr: BinaryExpression) {\n    const left = evalExpression(data, expr.left);\n    const right = evalExpression(data, expr.right);\n    switch (expr.op) {\n        case '&&':\n            return Boolean(left) && Boolean(right);\n        case '||':\n            return Boolean(left) || Boolean(right);\n        case '==':\n            // Treat ABSENT the same as null for equality checks — an absent\n            // optional field and an explicit null are semantically equivalent.\n            return (left === ABSENT ? null : left) == (right === ABSENT ? null : right);\n        case '!=':\n            return (left === ABSENT ? null : left) != (right === ABSENT ? null : right);\n        case '<':\n        case '<=':\n        case '>':\n        case '>=':\n            // If either operand is the ABSENT sentinel (field not present in the\n            // partial payload), skip the comparison by returning true so that\n            // @@validate rules are not incorrectly triggered against missing\n            // optional fields (e.g. when optionality: 'all' produces a partial\n            // object or a field is omitted/not-selected).\n            if (left === ABSENT || right === ABSENT) return true;\n            return expr.op === '<'\n                ? (left as any) < (right as any)\n                : expr.op === '<='\n                  ? (left as any) <= (right as any)\n                  : expr.op === '>'\n                    ? (left as any) > (right as any)\n                    : (left as any) >= (right as any);\n        case '?':\n            if (!Array.isArray(left)) {\n                return false;\n            }\n            return left.some((item) => item === right);\n        case '!':\n            if (!Array.isArray(left)) {\n                return false;\n            }\n            return left.every((item) => item === right);\n        case '^':\n            if (!Array.isArray(left)) {\n                return false;\n            }\n            return !left.some((item) => item === right);\n        case 'in':\n            if (!Array.isArray(right)) {\n                return false;\n            }\n            return right.includes(left);\n        default:\n            throw new SchemaFactoryError(`Unsupported binary operator: ${expr.op}`);\n    }\n}\n\nfunction evalMember(data: any, expr: MemberExpression) {\n    let result: any = evalExpression(data, expr.receiver);\n    for (const member of expr.members) {\n        if (!result || typeof result !== 'object') {\n            return undefined;\n        }\n        result = result[member];\n    }\n    return result ?? null;\n}\n\nfunction evalCall(data: any, expr: CallExpression) {\n    const f = expr.function;\n    const fieldArg = expr.args?.[0] ? evalExpression(data, expr.args[0]) : undefined;\n\n    switch (f) {\n        // string functions\n        case 'length': {\n            if (fieldArg === undefined || fieldArg === null || fieldArg === ABSENT) {\n                return false;\n            }\n            invariant(\n                typeof fieldArg === 'string' || Array.isArray(fieldArg),\n                `\"${f}\" first argument must be a string or a list`,\n            );\n            return fieldArg.length;\n        }\n        case 'startsWith':\n        case 'endsWith':\n        case 'contains': {\n            if (fieldArg === undefined || fieldArg === null || fieldArg === ABSENT) {\n                return false;\n            }\n            invariant(typeof fieldArg === 'string', `\"${f}\" first argument must be a string`);\n            invariant(expr.args?.[1], `\"${f}\" requires a search argument`);\n\n            const search = getArgValue<string>(expr.args?.[1])!;\n            const caseInsensitive = getArgValue<boolean>(expr.args?.[2]) ?? false;\n\n            const applyStringOp = (x: string, y: string) => {\n                switch (f) {\n                    case 'startsWith':\n                        return x.startsWith(y);\n                    case 'endsWith':\n                        return x.endsWith(y);\n                    case 'contains':\n                        return x.includes(y);\n                }\n            };\n            return caseInsensitive\n                ? applyStringOp(fieldArg.toLowerCase(), search.toLowerCase())\n                : applyStringOp(fieldArg, search);\n        }\n        case 'regex': {\n            if (fieldArg === undefined || fieldArg === null || fieldArg === ABSENT) {\n                return false;\n            }\n            invariant(typeof fieldArg === 'string', `\"${f}\" first argument must be a string`);\n            const pattern = getArgValue<string>(expr.args?.[1])!;\n            invariant(pattern !== undefined, `\"${f}\" requires a pattern argument`);\n            return new RegExp(pattern).test(fieldArg);\n        }\n        case 'isEmail':\n        case 'isUrl':\n        case 'isPhone':\n        case 'isDate':\n        case 'isTime':\n        case 'isDateTime': {\n            if (fieldArg === undefined || fieldArg === null || fieldArg === ABSENT) {\n                return false;\n            }\n            invariant(typeof fieldArg === 'string', `\"${f}\" first argument must be a string`);\n            if (f === 'isTime') {\n                const precision = getArgValue<number>(expr.args?.[1]);\n                invariant((precision === null || precision == undefined) || typeof precision === 'number', `\"isTime\" optional second argument must be a number`);\n                return z.iso.time({ precision }).safeParse(fieldArg).success;\n            }\n            const fn = stringFuncZodMap[f];\n            return z.string()[fn]().safeParse(fieldArg).success;\n        }\n        // list functions\n        case 'has':\n        case 'hasEvery':\n        case 'hasSome': {\n            invariant(expr.args?.[1], `${f} requires a search argument`);\n            if (fieldArg === undefined || fieldArg === null || fieldArg === ABSENT) {\n                return false;\n            }\n            invariant(Array.isArray(fieldArg), `\"${f}\" first argument must be an array field`);\n\n            const search = evalExpression(data, expr.args?.[1])!;\n            if (f === 'has') {\n                return fieldArg.some((item) => item === search);\n            } else if (f === 'hasEvery') {\n                invariant(Array.isArray(search), 'hasEvery second argument must be an array');\n                return search.every((v) => fieldArg.some((item) => item === v));\n            } else {\n                invariant(Array.isArray(search), 'hasSome second argument must be an array');\n                return search.some((v) => fieldArg.some((item) => item === v));\n            }\n        }\n        case 'isEmpty': {\n            if (fieldArg === undefined || fieldArg === null || fieldArg === ABSENT) {\n                return false;\n            }\n            invariant(Array.isArray(fieldArg), `\"${f}\" first argument must be an array field`);\n            return fieldArg.length === 0;\n        }\n        default:\n            throw new SchemaFactoryError(`Unsupported function \"${f}\"`);\n    }\n}\n\nfunction invariant(condition: unknown, message?: string): asserts condition {\n    if (!condition) {\n        throw new SchemaFactoryError(message ?? 'Invariant failed');\n    }\n}\n","import {\n    ExpressionUtils,\n    SchemaAccessor,\n    type AttributeApplication,\n    type FieldDef,\n    type GetEnum,\n    type GetEnums,\n    type GetModels,\n    type GetTypeDefs,\n    type SchemaDef,\n} from '@zenstackhq/schema';\nimport Decimal from 'decimal.js';\nimport z from 'zod';\nimport { SchemaFactoryError } from './error';\nimport type {\n    GetModelCreateFieldsShape,\n    GetModelFieldsShape,\n    GetModelSchemaShapeWithOptions,\n    GetModelUpdateFieldsShape,\n    GetTypeDefFieldsShape,\n    ModelSchemaOptions,\n} from './types';\nimport {\n    addBigIntValidation,\n    addCustomValidation,\n    addDecimalValidation,\n    addNumberValidation,\n    addStringValidation,\n} from './utils';\n\nexport function createSchemaFactory<Schema extends SchemaDef>(schema: Schema) {\n    return new SchemaFactory(schema);\n}\n\n/** Internal untyped representation of the options object used at runtime. */\ntype RawOptions = {\n    select?: Record<string, true | RawOptions>;\n    include?: Record<string, true | RawOptions>;\n    omit?: Record<string, true>;\n    optionality?: 'all' | 'defaults';\n};\n\n/**\n * Recursive Zod schema that validates a `RawOptions` object at runtime,\n * enforcing the same mutual-exclusion rules that the TypeScript union type\n * enforces at compile time:\n *  - `select` and `include` cannot be used together.\n *  - `select` and `omit` cannot be used together.\n * Nested relation options are validated with the same rules.\n */\nconst rawOptionsSchema: z.ZodType<RawOptions> = z.lazy(() =>\n    z\n        .strictObject({\n            select: z.record(z.string(), z.union([z.literal(true), rawOptionsSchema])).optional(),\n            include: z.record(z.string(), z.union([z.literal(true), rawOptionsSchema])).optional(),\n            omit: z.record(z.string(), z.literal(true)).optional(),\n            optionality: z.enum(['all', 'defaults']).optional(),\n        })\n        .superRefine((val, ctx) => {\n            if (val.select && val.include) {\n                ctx.addIssue({\n                    code: 'custom',\n                    message: '`select` and `include` cannot be used together',\n                });\n            }\n            if (val.select && val.omit) {\n                ctx.addIssue({\n                    code: 'custom',\n                    message: '`select` and `omit` cannot be used together',\n                });\n            }\n        }),\n);\n\nclass SchemaFactory<Schema extends SchemaDef> {\n    private readonly schema: SchemaAccessor<Schema>;\n\n    constructor(_schema: Schema) {\n        this.schema = new SchemaAccessor(_schema);\n    }\n\n    makeModelSchema<Model extends GetModels<Schema>>(\n        model: Model,\n    ): z.ZodObject<GetModelFieldsShape<Schema, Model>, z.core.$strict>;\n\n    makeModelSchema<Model extends GetModels<Schema>, Options extends ModelSchemaOptions<Schema, Model>>(\n        model: Model,\n        options: Options,\n    ): z.ZodObject<GetModelSchemaShapeWithOptions<Schema, Model, Options>, z.core.$strict>;\n\n    makeModelSchema<Model extends GetModels<Schema>, Options extends ModelSchemaOptions<Schema, Model>>(\n        model: Model,\n        options?: Options,\n    ): z.ZodObject<Record<string, z.ZodType>, z.core.$strict> {\n        const modelDef = this.schema.requireModel(model);\n\n        if (!options) {\n            // ── No-options path: scalar fields only (relations excluded by default) ──\n            const fields: Record<string, z.ZodType> = {};\n\n            for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {\n                // Relation fields are excluded by default — use `include` or `select`\n                // to opt in, mirroring ORM behaviour and avoiding infinite\n                // nesting for circular relations.\n                if (fieldDef.relation) continue;\n\n                fields[fieldName] = this.applyDescription(this.makeScalarFieldSchema(fieldDef), fieldDef.attributes);\n            }\n\n            const shape = z.strictObject(fields);\n            return this.applyDescription(\n                addCustomValidation(shape, modelDef.attributes),\n                modelDef.attributes,\n            ) as unknown as z.ZodObject<GetModelFieldsShape<Schema, Model>, z.core.$strict>;\n        }\n\n        // ── Options path ─────────────────────────────────────────────────────\n        const rawOptions = rawOptionsSchema.parse(options);\n        const fields = this.buildFieldsWithOptions(model as string, rawOptions);\n        const optionalizedFields = this.applyOptionality(fields, model as string, rawOptions.optionality);\n        const shape = z.strictObject(optionalizedFields);\n        // @@validate conditions only reference scalar fields of the same model\n        // (the ZModel compiler rejects relation fields). When `select` or `omit`\n        // produces a partial shape some of those scalar fields may be absent;\n        // we skip any rule that references a missing field so it can't produce\n        // a false negative against a partial payload.\n        const presentFields = this.buildPresentFields(model as string, rawOptions);\n        const withValidation = addCustomValidation(shape, modelDef.attributes, presentFields);\n        return this.applyDescription(withValidation, modelDef.attributes) as unknown as z.ZodObject<\n            GetModelSchemaShapeWithOptions<Schema, Model, Options>,\n            z.core.$strict\n        >;\n    }\n\n    /**\n     * @deprecated Use `makeModelSchema(model, { optionality: 'defaults' })` instead.\n     */\n    makeModelCreateSchema<Model extends GetModels<Schema>>(\n        model: Model,\n    ): z.ZodObject<GetModelCreateFieldsShape<Schema, Model>, z.core.$strict> {\n        const modelDef = this.schema.requireModel(model);\n        const fields: Record<string, z.ZodType> = {};\n\n        for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {\n            // exclude relation, computed, delegate discriminator fields\n            if (fieldDef.relation || fieldDef.computed || fieldDef.isDiscriminator) {\n                continue;\n            }\n\n            let fieldSchema = this.makeScalarFieldSchema(fieldDef);\n            if (fieldDef.optional || fieldDef.default !== undefined || fieldDef.updatedAt) {\n                fieldSchema = fieldSchema.optional();\n            }\n            fields[fieldName] = this.applyDescription(fieldSchema, fieldDef.attributes);\n        }\n\n        const shape = z.strictObject(fields);\n        return this.applyDescription(\n            addCustomValidation(shape, modelDef.attributes),\n            modelDef.attributes,\n        ) as unknown as z.ZodObject<GetModelCreateFieldsShape<Schema, Model>, z.core.$strict>;\n    }\n\n    /**\n     * @deprecated Use `makeModelSchema(model, { optionality: 'all' })` instead.\n     */\n    makeModelUpdateSchema<Model extends GetModels<Schema>>(\n        model: Model,\n    ): z.ZodObject<GetModelUpdateFieldsShape<Schema, Model>, z.core.$strict> {\n        const modelDef = this.schema.requireModel(model);\n        const fields: Record<string, z.ZodType> = {};\n\n        for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {\n            // exclude relation, computed, delegate discriminator fields\n            if (fieldDef.relation || fieldDef.computed || fieldDef.isDiscriminator) {\n                continue;\n            }\n\n            let fieldSchema = this.makeScalarFieldSchema(fieldDef);\n            fieldSchema = fieldSchema.optional();\n            fields[fieldName] = this.applyDescription(fieldSchema, fieldDef.attributes);\n        }\n\n        const shape = z.strictObject(fields);\n        return this.applyDescription(\n            addCustomValidation(shape, modelDef.attributes),\n            modelDef.attributes,\n        ) as unknown as z.ZodObject<GetModelUpdateFieldsShape<Schema, Model>, z.core.$strict>;\n    }\n\n    // -------------------------------------------------------------------------\n    // Options-aware field building\n    // -------------------------------------------------------------------------\n\n    /**\n     * Applies the `optionality` option to a fields map.\n     *\n     * - `\"all\"`      — wraps every field in `z.ZodOptional`.\n     * - `\"defaults\"` — only wraps fields that have a `@default` attribute or\n     *                  are `@updatedAt` in `z.ZodOptional`. Fields that are\n     *                  already optional (nullable optional) retain their shape;\n     *                  we just add the outer optional layer.\n     * - `undefined`  — returns the fields map unchanged.\n     */\n    private applyOptionality(\n        fields: Record<string, z.ZodType>,\n        model: string,\n        optionality: 'all' | 'defaults' | undefined,\n    ): Record<string, z.ZodType> {\n        if (!optionality) return fields;\n\n        const modelDef = this.schema.requireModel(model);\n        const result: Record<string, z.ZodType> = {};\n\n        for (const [fieldName, fieldSchema] of Object.entries(fields)) {\n            if (optionality === 'all') {\n                result[fieldName] = this.wrapOptionalPreservingMeta(fieldSchema);\n            } else {\n                // optionality === 'defaults'\n                const fieldDef = modelDef.fields[fieldName];\n                const hasDefault =\n                    fieldDef && (fieldDef.default !== undefined || fieldDef.updatedAt || fieldDef.optional);\n                result[fieldName] = hasDefault ? this.wrapOptionalPreservingMeta(fieldSchema) : fieldSchema;\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * Internal loose options shape used at runtime (we've already validated the\n     * type-level constraints via the overload signatures).\n     */\n    private buildFieldsWithOptions(model: string, options: RawOptions): Record<string, z.ZodType> {\n        const { select, include, omit } = options;\n        const modelDef = this.schema.requireModel(model);\n        const fields: Record<string, z.ZodType> = {};\n\n        if (select) {\n            // ── select branch ────────────────────────────────────────────────\n            // Only include fields that are explicitly listed (value is always `true` or nested options).\n            for (const [key, value] of Object.entries(select)) {\n                const fieldDef = modelDef.fields[key];\n                if (!fieldDef) {\n                    throw new SchemaFactoryError(`Field \"${key}\" does not exist on model \"${model}\"`);\n                }\n\n                if (fieldDef.relation) {\n                    const subOptions = typeof value === 'object' ? (value as RawOptions) : undefined;\n                    const relSchema = this.makeRelationFieldSchema(fieldDef, subOptions);\n                    fields[key] = this.applyDescription(\n                        this.applyCardinality(relSchema, fieldDef).optional(),\n                        fieldDef.attributes,\n                    );\n                } else {\n                    if (typeof value === 'object') {\n                        throw new SchemaFactoryError(\n                            `Field \"${key}\" on model \"${model}\" is a scalar field and cannot have nested options`,\n                        );\n                    }\n                    fields[key] = this.applyDescription(this.makeScalarFieldSchema(fieldDef), fieldDef.attributes);\n                }\n            }\n        } else {\n            // ── include + omit branch ────────────────────────────────────────\n            // Validate omit keys up-front.\n            if (omit) {\n                for (const key of Object.keys(omit)) {\n                    const fieldDef = modelDef.fields[key];\n                    if (!fieldDef) {\n                        throw new SchemaFactoryError(`Field \"${key}\" does not exist on model \"${model}\"`);\n                    }\n                    if (fieldDef.relation) {\n                        throw new SchemaFactoryError(\n                            `Field \"${key}\" on model \"${model}\" is a relation field and cannot be used in \"omit\"`,\n                        );\n                    }\n                }\n            }\n\n            // Start with all scalar fields, applying omit exclusions.\n            for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {\n                if (fieldDef.relation) continue;\n\n                if (omit?.[fieldName] === true) continue;\n                fields[fieldName] = this.applyDescription(this.makeScalarFieldSchema(fieldDef), fieldDef.attributes);\n            }\n\n            // Validate include keys and add relation fields.\n            if (include) {\n                for (const [key, value] of Object.entries(include)) {\n                    const fieldDef = modelDef.fields[key];\n                    if (!fieldDef) {\n                        throw new SchemaFactoryError(`Field \"${key}\" does not exist on model \"${model}\"`);\n                    }\n                    if (!fieldDef.relation) {\n                        throw new SchemaFactoryError(\n                            `Field \"${key}\" on model \"${model}\" is not a relation field and cannot be used in \"include\"`,\n                        );\n                    }\n\n                    const subOptions = typeof value === 'object' ? (value as RawOptions) : undefined;\n                    const relSchema = this.makeRelationFieldSchema(fieldDef, subOptions);\n                    fields[key] = this.applyDescription(\n                        this.applyCardinality(relSchema, fieldDef).optional(),\n                        fieldDef.attributes,\n                    );\n                }\n            }\n        }\n\n        return fields;\n    }\n\n    /**\n     * Returns the set of scalar field names that will be present in the\n     * resulting schema after applying `options`. Used by `addCustomValidation`\n     * to skip `@@validate` rules that reference an absent field.\n     *\n     * Only scalar fields matter here because `@@validate` conditions are\n     * restricted by the ZModel compiler to scalar fields of the same model.\n     */\n    private buildPresentFields(model: string, options: RawOptions): ReadonlySet<string> {\n        const { select, omit } = options;\n        const modelDef = this.schema.requireModel(model);\n        const fields = new Set<string>();\n\n        if (select) {\n            // Only scalar fields explicitly selected (value is always `true` or nested options).\n            for (const key of Object.keys(select)) {\n                const fieldDef = modelDef.fields[key];\n                if (fieldDef && !fieldDef.relation) {\n                    fields.add(key);\n                }\n            }\n        } else {\n            // All scalar fields minus explicitly omitted ones.\n            for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {\n                if (fieldDef.relation) continue;\n                if (omit?.[fieldName] === true) continue;\n                fields.add(fieldName);\n            }\n        }\n\n        return fields;\n    }\n\n    /**\n     * Build the inner Zod schema for a relation field, optionally with nested\n     * query options.  Does NOT apply cardinality/optional wrappers — the caller\n     * does that.\n     */\n    private makeRelationFieldSchema(fieldDef: FieldDef, subOptions?: RawOptions): z.ZodType {\n        const relatedModelName = fieldDef.type as GetModels<Schema>;\n        if (subOptions) {\n            // Recurse: build the related model's schema with its own options.\n            return this.makeModelSchema(relatedModelName, subOptions as ModelSchemaOptions<Schema, GetModels<Schema>>);\n        }\n        // No sub-options: use a lazy reference to the default schema so that\n        // circular models don't cause infinite recursion at build time.\n        return z.lazy(() => this.makeModelSchema(relatedModelName));\n    }\n\n    private makeScalarFieldSchema(fieldDef: FieldDef): z.ZodType {\n        const { type, attributes } = fieldDef;\n\n        // enum\n        const enumDef = this.schema.getEnum(type);\n        if (enumDef) {\n            return this.applyCardinality(this.makeEnumSchema(type as GetEnums<Schema>), fieldDef);\n        }\n\n        // typedef\n        const typedefDef = this.schema.getTypeDef(type);\n        if (typedefDef) {\n            return this.applyCardinality(this.makeTypeSchema(type as GetTypeDefs<Schema>), fieldDef);\n        }\n\n        let base: z.ZodType;\n        switch (type) {\n            case 'String':\n                base = addStringValidation(z.string(), attributes);\n                break;\n            case 'Int':\n                base = addNumberValidation(z.number().int(), attributes);\n                break;\n            case 'Float':\n                base = addNumberValidation(z.number(), attributes);\n                break;\n            case 'Boolean':\n                base = z.boolean();\n                break;\n            case 'BigInt':\n                base = addBigIntValidation(z.bigint(), attributes);\n                break;\n            case 'Decimal':\n                base = z.union([\n                    addNumberValidation(z.number(), attributes) as z.ZodNumber,\n                    addDecimalValidation(z.string(), attributes, true) as z.ZodString,\n                    addDecimalValidation(z.instanceof(Decimal), attributes, true),\n                ]);\n                break;\n            case 'DateTime':\n                base = z.union([z.date(), z.iso.datetime()]);\n                break;\n            case 'Bytes':\n                base = z.instanceof(Uint8Array);\n                break;\n            case 'Json':\n                base = this.makeJsonSchema();\n                break;\n            case 'Unsupported':\n                base = z.unknown();\n                break;\n            default: {\n                const _exhaustive: never = type as never;\n                throw new SchemaFactoryError(`Unsupported field type: ${_exhaustive}`);\n            }\n        }\n\n        return this.applyCardinality(base, fieldDef);\n    }\n\n    private makeJsonSchema(): z.ZodType {\n        return z.union([\n            z.string(),\n            z.number(),\n            z.boolean(),\n            z.null(),\n            z.array(z.lazy(() => this.makeJsonSchema())),\n            z.object({}).catchall(z.lazy(() => this.makeJsonSchema())),\n        ]);\n    }\n\n    /**\n     * Wraps a schema with `.optional()` and copies any `description` from its\n     * metadata onto the resulting `ZodOptional`, so that callers inspecting\n     * `.meta()?.description` on shape fields still find the value after\n     * optionality has been applied.\n     */\n    private wrapOptionalPreservingMeta(schema: z.ZodType): z.ZodType {\n        const optional = schema.optional();\n        const description = schema.meta()?.description as string | undefined;\n        if (description) {\n            return optional.meta({ description });\n        }\n        return optional;\n    }\n\n    private applyCardinality(schema: z.ZodType, fieldDef: FieldDef): z.ZodType {\n        let result = schema;\n        if (fieldDef.array) {\n            result = result.array();\n        }\n        if (fieldDef.optional) {\n            result = result.nullable().optional();\n        }\n        return result;\n    }\n\n    makeTypeSchema<Type extends GetTypeDefs<Schema>>(\n        type: Type,\n    ): z.ZodObject<GetTypeDefFieldsShape<Schema, Type>, z.core.$strict> {\n        const typeDef = this.schema.requireTypeDef(type);\n        const fields: Record<string, z.ZodType> = {};\n\n        for (const [fieldName, fieldDef] of Object.entries(typeDef.fields)) {\n            fields[fieldName] = this.applyDescription(this.makeScalarFieldSchema(fieldDef), fieldDef.attributes);\n        }\n\n        const shape = z.strictObject(fields);\n        return this.applyDescription(\n            addCustomValidation(shape, typeDef.attributes),\n            typeDef.attributes,\n        ) as unknown as z.ZodObject<GetTypeDefFieldsShape<Schema, Type>, z.core.$strict>;\n    }\n\n    makeEnumSchema<Enum extends GetEnums<Schema>>(\n        _enum: Enum,\n    ): z.ZodEnum<{ [Key in keyof GetEnum<Schema, Enum>]: GetEnum<Schema, Enum>[Key] }> {\n        const enumDef = this.schema.requireEnum(_enum);\n        const schema = z.enum(Object.keys(enumDef.values) as [string, ...string[]]);\n        return this.applyDescription(schema, enumDef.attributes) as unknown as z.ZodEnum<{\n            [Key in keyof GetEnum<Schema, Enum>]: GetEnum<Schema, Enum>[Key];\n        }>;\n    }\n\n    private getMetaDescription(attributes: readonly AttributeApplication[] | undefined): string | undefined {\n        if (!attributes) return undefined;\n        for (const attr of attributes) {\n            if (attr.name !== '@meta' && attr.name !== '@@meta') continue;\n            const nameExpr = attr.args?.[0]?.value;\n            if (!nameExpr || ExpressionUtils.getLiteralValue(nameExpr) !== 'description') continue;\n            const valueExpr = attr.args?.[1]?.value;\n            if (valueExpr) {\n                return ExpressionUtils.getLiteralValue(valueExpr) as string | undefined;\n            }\n        }\n        return undefined;\n    }\n\n    private applyDescription<T extends z.ZodType>(\n        schema: T,\n        attributes: readonly AttributeApplication[] | undefined,\n    ): T {\n        const description = this.getMetaDescription(attributes);\n        if (description) {\n            return schema.meta({ description }) as T;\n        }\n        return schema;\n    }\n}\n"],"mappings":"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"}