{"version":3,"sources":["../src/index.ts","../src/model-utils.ts","../src/prisma/prisma-schema-generator.ts","../src/prisma/indent-string.ts","../src/prisma/prisma-builder.ts","../src/ts-schema-generator.ts"],"sourcesContent":["import * as ModelUtils from './model-utils';\nexport * from './cli-plugin';\nexport { PrismaSchemaGenerator } from './prisma/prisma-schema-generator';\nexport * from './ts-schema-generator';\nexport { ModelUtils };\n","import {\n    isDataModel,\n    isLiteralExpr,\n    isModel,\n    isTypeDef,\n    type AstNode,\n    type Attribute,\n    type AttributeParam,\n    type DataField,\n    type DataFieldAttribute,\n    type DataModel,\n    type DataModelAttribute,\n    type Enum,\n    type EnumField,\n    type FunctionDecl,\n    type Model,\n    type Reference,\n    type TypeDef,\n} from '@zenstackhq/language/ast';\n\nimport { getAllFields, getModelIdFields, getModelUniqueFields, type AttributeTarget } from '@zenstackhq/language/utils';\n\nexport function isIdField(field: DataField, contextModel: DataModel) {\n    // field-level @id attribute\n    if (hasAttribute(field, '@id')) {\n        return true;\n    }\n\n    // NOTE: we have to use name to match fields because the fields\n    // may be inherited from a base and have different identities\n\n    // model-level @@id attribute with a list of fields\n    const modelLevelIds = getModelIdFields(contextModel);\n    if (modelLevelIds.map((f) => f.name).includes(field.name)) {\n        return true;\n    }\n\n    const allFields = getAllFields(contextModel);\n    if (allFields.some((f) => hasAttribute(f, '@id')) || modelLevelIds.length > 0) {\n        // the model already has `@id` or `@@id` field, don't further check unique fields\n        return false;\n    }\n\n    // then, the first field with @unique can be used as id\n    const firstUniqueField = allFields.find((f) => hasAttribute(f, '@unique'));\n    if (firstUniqueField) {\n        return firstUniqueField.name === field.name;\n    }\n\n    // last, the first model level @@unique can be used as id\n    const modelLevelUnique = getModelUniqueFields(contextModel);\n    if (modelLevelUnique.map((f) => f.name).includes(field.name)) {\n        return true;\n    }\n\n    return false;\n}\n\nexport function hasAttribute(\n    decl: DataModel | TypeDef | DataField | Enum | EnumField | FunctionDecl | Attribute | AttributeParam,\n    name: string,\n) {\n    return !!getAttribute(decl, name);\n}\n\nexport function getAttribute(decl: AttributeTarget, name: string) {\n    return (decl.attributes as (DataModelAttribute | DataFieldAttribute)[]).find((attr) => attr.decl.$refText === name);\n}\n\nexport function isDelegateModel(node: AstNode) {\n    return isDataModel(node) && hasAttribute(node, '@@delegate');\n}\n\n/**\n * Returns all fields that physically belong to a model's table: its directly declared\n * fields plus fields from its mixins (recursively).\n */\nexport function getOwnedFields(model: DataModel | TypeDef): DataField[] {\n    const fields: DataField[] = [...model.fields];\n    for (const mixin of model.mixins) {\n        if (mixin.ref) {\n            fields.push(...getOwnedFields(mixin.ref));\n        }\n    }\n    return fields;\n}\n\n/**\n * Returns the name of the delegate base model that \"owns\" the given field in the context of\n * `contextModel`. This handles both direct fields of delegate models and mixin fields that\n * belong to a mixin used by a delegate base model.\n */\nexport function getDelegateOriginModel(field: DataField, contextModel: DataModel): string | undefined {\n    let base = contextModel.baseModel?.ref;\n    while (base) {\n        if (isDelegateModel(base) && getOwnedFields(base).some((f) => f.name === field.name)) {\n            return base.name;\n        }\n        base = base.baseModel?.ref;\n    }\n    return undefined;\n}\n\nexport function isUniqueField(field: DataField) {\n    if (hasAttribute(field, '@unique')) {\n        return true;\n    }\n    const modelIds = getAttribute(field.$container, '@@unique');\n    if (modelIds && modelIds.args.some((arg) => isLiteralExpr(arg.value) && arg.value.value === field.name)) {\n        return true;\n    }\n    return false;\n}\n\nexport function isFromStdlib(node: AstNode) {\n    const model = getContainingModel(node);\n    return !!model && !!model.$document && model.$document.uri.path.endsWith('stdlib.zmodel');\n}\n\nexport function getContainingModel(node: AstNode | undefined): Model | null {\n    if (!node) {\n        return null;\n    }\n    return isModel(node) ? node : getContainingModel(node.$container);\n}\n\nexport function resolved<T extends AstNode>(ref: Reference<T>): T {\n    if (!ref.ref) {\n        throw new Error(`Reference not resolved: ${ref.$refText}`);\n    }\n    return ref.ref;\n}\n\nexport function getAuthDecl(model: Model) {\n    let found = model.declarations.find(\n        (d) => (isDataModel(d) || isTypeDef(d)) && d.attributes.some((attr) => attr.decl.$refText === '@@auth'),\n    );\n    if (!found) {\n        found = model.declarations.find((d) => (isDataModel(d) || isTypeDef(d)) && d.name === 'User');\n    }\n    return found;\n}\n\nexport function getIdFields(dm: DataModel) {\n    return getAllFields(dm)\n        .filter((f) => isIdField(f, dm))\n        .map((f) => f.name);\n}\n\n/**\n * Prefix for auxiliary relation fields generated for delegated models\n */\nexport const DELEGATE_AUX_RELATION_PREFIX = 'delegate_aux';\n","import { lowerCaseFirst } from '@zenstackhq/common-helpers';\nimport { ZModelCodeGenerator } from '@zenstackhq/language';\nimport {\n    AttributeArg,\n    BooleanLiteral,\n    ConfigArrayExpr,\n    ConfigExpr,\n    ConfigInvocationArg,\n    DataField,\n    DataFieldAttribute,\n    DataFieldType,\n    DataModel,\n    DataModelAttribute,\n    DataSource,\n    Enum,\n    EnumField,\n    Expression,\n    GeneratorDecl,\n    InvocationExpr,\n    isArrayExpr,\n    isDataModel,\n    isDataSource,\n    isGeneratorDecl,\n    isInvocationExpr,\n    isLiteralExpr,\n    isNullExpr,\n    isReferenceExpr,\n    isStringLiteral,\n    isTypeDef,\n    LiteralExpr,\n    Model,\n    NumberLiteral,\n    StringLiteral,\n} from '@zenstackhq/language/ast';\nimport {\n    getAllAttributes,\n    getAllFields,\n    getStringLiteral,\n    isAuthInvocation,\n    isDelegateModel,\n} from '@zenstackhq/language/utils';\nimport { AstUtils } from 'langium';\nimport { match } from 'ts-pattern';\nimport { ModelUtils } from '..';\nimport { DELEGATE_AUX_RELATION_PREFIX, getDelegateOriginModel, getIdFields } from '../model-utils';\nimport {\n    AttributeArgValue,\n    ModelFieldType,\n    AttributeArg as PrismaAttributeArg,\n    AttributeArgValue as PrismaAttributeArgValue,\n    ContainerDeclaration as PrismaContainerDeclaration,\n    Model as PrismaDataModel,\n    Enum as PrismaEnum,\n    FieldAttribute as PrismaFieldAttribute,\n    FieldReference as PrismaFieldReference,\n    FieldReferenceArg as PrismaFieldReferenceArg,\n    FunctionCall as PrismaFunctionCall,\n    FunctionCallArg as PrismaFunctionCallArg,\n    PrismaModel,\n    ContainerAttribute as PrismaModelAttribute,\n    type SimpleField,\n} from './prisma-builder';\n\n// Some database providers like postgres and mysql have default limit to the length of identifiers\n// Here we use a conservative value that should work for most cases, and truncate names if needed\nconst IDENTIFIER_NAME_MAX_LENGTH = 50 - DELEGATE_AUX_RELATION_PREFIX.length;\n\n// Datasource fields that only exist in ZModel but not in Prisma schema\nconst NON_PRISMA_DATASOURCE_FIELDS = ['defaultSchema'];\n\n/**\n * Generates Prisma schema file\n */\nexport class PrismaSchemaGenerator {\n    private readonly PRELUDE = `//////////////////////////////////////////////////////////////////////////////////////////////\n// DO NOT MODIFY THIS FILE                                                                  //\n// This file is automatically generated by ZenStack CLI and should not be manually updated. //\n//////////////////////////////////////////////////////////////////////////////////////////////\n\n`;\n\n    // a mapping from full names to shortened names\n    private shortNameMap = new Map<string, string>();\n\n    constructor(private readonly zmodel: Model) {}\n\n    async generate() {\n        const prisma = new PrismaModel();\n\n        for (const decl of this.zmodel.declarations) {\n            switch (decl.$type) {\n                case DataSource:\n                    this.generateDataSource(prisma, decl as DataSource);\n                    break;\n\n                case Enum:\n                    this.generateEnum(prisma, decl as Enum);\n                    break;\n\n                case DataModel:\n                    this.generateModel(prisma, decl as DataModel);\n                    break;\n\n                case GeneratorDecl:\n                    this.generateGenerator(prisma, decl as GeneratorDecl);\n                    break;\n            }\n        }\n\n        if (!this.zmodel.declarations.some(isGeneratorDecl)) {\n            this.generateDefaultGenerator(prisma);\n        }\n\n        return this.PRELUDE + prisma.toString();\n    }\n\n    private generateDataSource(prisma: PrismaModel, dataSource: DataSource) {\n        const fields: SimpleField[] = dataSource.fields\n            .filter((f) => !NON_PRISMA_DATASOURCE_FIELDS.includes(f.name))\n            .map((f) => ({\n                name: f.name,\n                text: this.configExprToText(f.value),\n            }));\n        prisma.addDataSource(dataSource.name, fields);\n    }\n\n    private configExprToText(expr: ConfigExpr) {\n        if (isLiteralExpr(expr)) {\n            return this.literalToText(expr);\n        } else if (isInvocationExpr(expr)) {\n            const fc = this.makeFunctionCall(expr);\n            return fc.toString();\n        } else {\n            return this.configArrayToText(expr);\n        }\n    }\n\n    private configArrayToText(expr: ConfigArrayExpr) {\n        return (\n            '[' +\n            expr.items\n                .map((item) => {\n                    if (isLiteralExpr(item)) {\n                        return this.literalToText(item);\n                    } else {\n                        return (\n                            item.name +\n                            (item.args.length > 0\n                                ? '(' + item.args.map((arg) => this.configInvocationArgToText(arg)).join(', ') + ')'\n                                : '')\n                        );\n                    }\n                })\n                .join(', ') +\n            ']'\n        );\n    }\n\n    private configInvocationArgToText(arg: ConfigInvocationArg) {\n        return `${arg.name}: ${this.literalToText(arg.value)}`;\n    }\n\n    private literalToText(expr: LiteralExpr) {\n        return JSON.stringify(expr.value);\n    }\n\n    private generateGenerator(prisma: PrismaModel, decl: GeneratorDecl) {\n        prisma.addGenerator(\n            decl.name,\n            decl.fields.map((f) => ({\n                name: f.name,\n                text: this.configExprToText(f.value),\n            })),\n        );\n    }\n\n    private generateDefaultGenerator(prisma: PrismaModel) {\n        const gen = prisma.addGenerator('client', [{ name: 'provider', text: '\"prisma-client-js\"' }]);\n\n        const previewFeatures: string[] = [];\n\n        const dataSource = this.zmodel.declarations.find(isDataSource);\n        if (dataSource?.fields.some((f) => f.name === 'extensions')) {\n            previewFeatures.push('postgresqlExtensions');\n        }\n\n        if (this.zmodel.declarations.some((d) => isDataModel(d) && d.isView)) {\n            previewFeatures.push('views');\n        }\n\n        if (previewFeatures.length > 0) {\n            gen.fields.push({\n                name: 'previewFeatures',\n                text: JSON.stringify(previewFeatures),\n            });\n        }\n    }\n\n    private generateModel(prisma: PrismaModel, decl: DataModel) {\n        const model = decl.isView ? prisma.addView(decl.name) : prisma.addModel(decl.name);\n        const allFields = getAllFields(decl, true);\n        for (const field of allFields) {\n            if (ModelUtils.hasAttribute(field, '@computed')) {\n                continue; // skip computed fields\n            }\n            // exclude non-id fields inherited from delegate\n            if (ModelUtils.isIdField(field, decl) || !getDelegateOriginModel(field, decl)) {\n                this.generateModelField(model, field, decl);\n            }\n        }\n\n        const allAttributes = getAllAttributes(decl).filter((attr) => this.isPrismaAttribute(attr));\n\n        for (const attr of allAttributes) {\n            this.generateContainerAttribute(model, attr);\n        }\n\n        if (\n            this.datasourceHasSchemasSetting(decl.$container) &&\n            !allAttributes.some((attr) => attr.decl.ref?.name === '@@schema')\n        ) {\n            // if the datasource declared `schemas` and no @@schema attribute is defined, add a default one\n            model.addAttribute('@@schema', [\n                new PrismaAttributeArg(\n                    undefined,\n                    new PrismaAttributeArgValue('String', this.getDefaultPostgresSchemaName(decl.$container)),\n                ),\n            ]);\n        }\n\n        // user defined comments pass-through\n        decl.comments.forEach((c) => model.addComment(c));\n\n        // generate relation fields on base models linking to concrete models\n        this.generateDelegateRelationForBase(model, decl);\n\n        // generate reverse relation fields on concrete models\n        this.generateDelegateRelationForConcrete(model, decl);\n    }\n\n    private getDatasourceField(zmodel: Model, fieldName: string) {\n        const dataSource = zmodel.declarations.find(isDataSource);\n        return dataSource?.fields.find((f) => f.name === fieldName);\n    }\n\n    private datasourceHasSchemasSetting(zmodel: Model) {\n        return !!this.getDatasourceField(zmodel, 'schemas');\n    }\n\n    private getDefaultPostgresSchemaName(zmodel: Model) {\n        const defaultSchemaField = this.getDatasourceField(zmodel, 'defaultSchema');\n        return getStringLiteral(defaultSchemaField?.value) ?? 'public';\n    }\n\n    private isPrismaAttribute(attr: DataModelAttribute | DataFieldAttribute) {\n        if (!attr.decl.ref) {\n            return false;\n        }\n        return attr.decl.ref.attributes.some((a) => a.decl.ref?.name === '@@@prisma');\n    }\n\n    private getUnsupportedFieldType(fieldType: DataFieldType) {\n        if (fieldType.unsupported) {\n            const value = getStringLiteral(fieldType.unsupported.value);\n            if (value) {\n                return `Unsupported(\"${value}\")`;\n            } else {\n                return undefined;\n            }\n        } else {\n            return undefined;\n        }\n    }\n\n    private generateModelField(model: PrismaDataModel, field: DataField, contextModel: DataModel, addToFront = false) {\n        let fieldType: string | undefined;\n\n        if (field.type.type) {\n            // intrinsic type\n            fieldType = field.type.type;\n        } else if (field.type.reference?.ref) {\n            // model, enum, or type-def\n            if (isTypeDef(field.type.reference.ref)) {\n                fieldType = 'Json';\n            } else {\n                fieldType = field.type.reference.ref.name;\n            }\n        } else {\n            // Unsupported type\n            const unsupported = this.getUnsupportedFieldType(field.type);\n            if (unsupported) {\n                fieldType = unsupported;\n            }\n        }\n\n        if (!fieldType) {\n            throw new Error(`Field type is not resolved: ${field.$container.name}.${field.name}`);\n        }\n\n        const isArray =\n            // typed-JSON fields should be translated to scalar Json type\n            isTypeDef(field.type.reference?.ref) ? false : field.type.array;\n        const type = new ModelFieldType(fieldType, isArray, field.type.optional);\n\n        const attributes = field.attributes\n            .filter((attr) => this.isPrismaAttribute(attr))\n            // `@default` using `auth()` is handled outside Prisma\n            .filter((attr) => !this.isDefaultWithAuthInvocation(attr))\n            .filter(\n                (attr) =>\n                    // when building physical schema, exclude `@default` for id fields inherited from delegate base\n                    !(\n                        ModelUtils.isIdField(field, contextModel) &&\n                        getDelegateOriginModel(field, contextModel) &&\n                        attr.decl.$refText === '@default'\n                    ),\n            )\n            .map((attr) => this.makeFieldAttribute(attr));\n\n        const docs = [...field.comments];\n        const result = model.addField(field.name, type, attributes, docs, addToFront);\n        return result;\n    }\n\n    private isDefaultWithAuthInvocation(attr: DataFieldAttribute) {\n        if (attr.decl.ref?.name !== '@default') {\n            return false;\n        }\n\n        const expr = attr.args[0]?.value;\n        if (!expr) {\n            return false;\n        }\n\n        return AstUtils.streamAst(expr).some(isAuthInvocation);\n    }\n\n    private makeFieldAttribute(attr: DataFieldAttribute) {\n        const attrName = attr.decl.ref!.name;\n        return new PrismaFieldAttribute(\n            attrName,\n            attr.args.map((arg) => this.makeAttributeArg(arg)),\n        );\n    }\n\n    private makeAttributeArg(arg: AttributeArg): PrismaAttributeArg {\n        return new PrismaAttributeArg(arg.name, this.makeAttributeArgValue(arg.value));\n    }\n\n    private makeAttributeArgValue(node: Expression): PrismaAttributeArgValue {\n        if (isLiteralExpr(node)) {\n            const argType = match(node.$type)\n                .with(StringLiteral, () => 'String' as const)\n                .with(NumberLiteral, () => 'Number' as const)\n                .with(BooleanLiteral, () => 'Boolean' as const)\n                .exhaustive();\n            return new PrismaAttributeArgValue(argType, node.value);\n        } else if (isArrayExpr(node)) {\n            return new PrismaAttributeArgValue(\n                'Array',\n                new Array(...node.items.map((item) => this.makeAttributeArgValue(item))),\n            );\n        } else if (isReferenceExpr(node)) {\n            return new PrismaAttributeArgValue(\n                'FieldReference',\n                new PrismaFieldReference(\n                    node.target.ref!.name,\n                    node.args.map((arg) => new PrismaFieldReferenceArg(arg.name, this.exprToText(arg.value))),\n                ),\n            );\n        } else if (isInvocationExpr(node)) {\n            // invocation\n            return new PrismaAttributeArgValue('FunctionCall', this.makeFunctionCall(node));\n        } else {\n            throw Error(`Unsupported attribute argument expression type: ${node.$type}`);\n        }\n    }\n\n    private exprToText(expr: Expression) {\n        return new ZModelCodeGenerator({ quote: 'double' }).generate(expr);\n    }\n\n    makeFunctionCall(node: InvocationExpr): PrismaFunctionCall {\n        return new PrismaFunctionCall(\n            node.function.ref!.name,\n            node.args.map((arg) => {\n                const val = match(arg.value)\n                    .when(isStringLiteral, (v) => `\"${v.value}\"`)\n                    .when(isLiteralExpr, (v) => v.value.toString())\n                    .when(isNullExpr, () => 'null')\n                    .otherwise(() => {\n                        throw new Error('Function call argument must be literal or null');\n                    });\n\n                return new PrismaFunctionCallArg(val);\n            }),\n        );\n    }\n\n    private generateContainerAttribute(container: PrismaContainerDeclaration, attr: DataModelAttribute) {\n        const attrName = attr.decl.ref!.name;\n        container.attributes.push(\n            new PrismaModelAttribute(\n                attrName,\n                attr.args.map((arg) => this.makeAttributeArg(arg)),\n            ),\n        );\n    }\n\n    private generateEnum(prisma: PrismaModel, decl: Enum) {\n        const _enum = prisma.addEnum(decl.name);\n\n        for (const field of decl.fields) {\n            this.generateEnumField(_enum, field);\n        }\n\n        const allAttributes = decl.attributes.filter((attr) => this.isPrismaAttribute(attr));\n        for (const attr of allAttributes) {\n            this.generateContainerAttribute(_enum, attr);\n        }\n\n        if (\n            this.datasourceHasSchemasSetting(decl.$container) &&\n            !allAttributes.some((attr) => attr.decl.ref?.name === '@@schema')\n        ) {\n            // if the datasource declared `schemas` and no @@schema attribute is defined, add a default one\n            _enum.addAttribute('@@schema', [\n                new PrismaAttributeArg(\n                    undefined,\n                    new PrismaAttributeArgValue('String', this.getDefaultPostgresSchemaName(decl.$container)),\n                ),\n            ]);\n        }\n\n        // user defined comments pass-through\n        decl.comments.forEach((c) => _enum.addComment(c));\n    }\n\n    private generateEnumField(_enum: PrismaEnum, field: EnumField) {\n        const attributes = field.attributes\n            .filter((attr) => this.isPrismaAttribute(attr))\n            .map((attr) => this.makeFieldAttribute(attr));\n\n        const docs = [...field.comments];\n        _enum.addField(field.name, attributes, docs);\n    }\n\n    private generateDelegateRelationForBase(model: PrismaDataModel, decl: DataModel) {\n        if (!isDelegateModel(decl)) {\n            return;\n        }\n\n        // collect concrete models inheriting this model\n        const concreteModels = this.getConcreteModels(decl);\n\n        // generate an optional relation field in delegate base model to each concrete model\n        concreteModels.forEach((concrete) => {\n            const auxName = this.truncate(`${DELEGATE_AUX_RELATION_PREFIX}_${lowerCaseFirst(concrete.name)}`);\n            model.addField(auxName, new ModelFieldType(concrete.name, false, true));\n        });\n    }\n\n    private generateDelegateRelationForConcrete(model: PrismaDataModel, concreteDecl: DataModel) {\n        // generate a relation field for each delegated base model\n        const base = concreteDecl.baseModel?.ref;\n        if (!base) {\n            return;\n        }\n\n        const idFields = getIdFields(base);\n\n        // add relation fields\n        const relationField = this.truncate(`${DELEGATE_AUX_RELATION_PREFIX}_${lowerCaseFirst(base.name)}`);\n        model.addField(relationField, base.name, [\n            new PrismaFieldAttribute('@relation', [\n                new PrismaAttributeArg(\n                    'fields',\n                    new AttributeArgValue(\n                        'Array',\n                        idFields.map(\n                            (idField) => new AttributeArgValue('FieldReference', new PrismaFieldReference(idField)),\n                        ),\n                    ),\n                ),\n                new PrismaAttributeArg(\n                    'references',\n                    new AttributeArgValue(\n                        'Array',\n                        idFields.map(\n                            (idField) => new AttributeArgValue('FieldReference', new PrismaFieldReference(idField)),\n                        ),\n                    ),\n                ),\n                new PrismaAttributeArg(\n                    'onDelete',\n                    new AttributeArgValue('FieldReference', new PrismaFieldReference('Cascade')),\n                ),\n                new PrismaAttributeArg(\n                    'onUpdate',\n                    new AttributeArgValue('FieldReference', new PrismaFieldReference('Cascade')),\n                ),\n            ]),\n        ]);\n    }\n\n    private getConcreteModels(dataModel: DataModel): DataModel[] {\n        if (!isDelegateModel(dataModel)) {\n            return [];\n        }\n        return dataModel.$container.declarations.filter(\n            (d): d is DataModel => isDataModel(d) && d !== dataModel && d.baseModel?.ref === dataModel,\n        );\n    }\n\n    private truncate(name: string) {\n        if (name.length <= IDENTIFIER_NAME_MAX_LENGTH) {\n            return name;\n        }\n\n        const existing = this.shortNameMap.get(name);\n        if (existing) {\n            return existing;\n        }\n\n        const baseName = name.slice(0, IDENTIFIER_NAME_MAX_LENGTH);\n        let index = 0;\n        let shortName = `${baseName}_${index}`;\n\n        while (true) {\n            const conflict = Array.from(this.shortNameMap.values()).find((v) => v === shortName);\n            if (!conflict) {\n                this.shortNameMap.set(name, shortName);\n                break;\n            }\n\n            // try next index\n            index++;\n            shortName = `${baseName}_${index}`;\n        }\n\n        return shortName;\n    }\n}\n","// https://github.com/sindresorhus/indent-string\n\n/**\n * Utility for indenting strings\n */\nexport default function indentString(string: string, count = 4): string {\n    const indent = ' ';\n    return string.replace(/^(?!\\s*$)/gm, indent.repeat(count));\n}\n","import indentString from './indent-string';\n\n/**\n * Field used by datasource and generator declarations.\n */\nexport type SimpleField = { name: string; text: string };\n\n/**\n * Prisma schema builder\n */\nexport class PrismaModel {\n    private datasources: DataSource[] = [];\n    private generators: Generator[] = [];\n    private models: Model[] = [];\n    private enums: Enum[] = [];\n\n    addDataSource(name: string, fields: SimpleField[] = []): DataSource {\n        const ds = new DataSource(name, fields);\n        this.datasources.push(ds);\n        return ds;\n    }\n\n    addGenerator(name: string, fields: SimpleField[]): Generator {\n        const generator = new Generator(name, fields);\n        this.generators.push(generator);\n        return generator;\n    }\n\n    addModel(name: string): Model {\n        const model = new Model(name, false);\n        this.models.push(model);\n        return model;\n    }\n\n    addView(name: string): Model {\n        const model = new Model(name, true);\n        this.models.push(model);\n        return model;\n    }\n\n    addEnum(name: string): Enum {\n        const e = new Enum(name);\n        this.enums.push(e);\n        return e;\n    }\n\n    toString(): string {\n        return [...this.datasources, ...this.generators, ...this.enums, ...this.models]\n            .map((d) => d.toString())\n            .join('\\n\\n');\n    }\n}\n\nexport class DataSource {\n    constructor(\n        public name: string,\n        public fields: SimpleField[] = [],\n    ) {}\n\n    toString(): string {\n        return (\n            `datasource ${this.name} {\\n` +\n            this.fields.map((f) => indentString(`${f.name} = ${f.text}`)).join('\\n') +\n            `\\n}`\n        );\n    }\n}\n\nexport class Generator {\n    constructor(\n        public name: string,\n        public fields: SimpleField[],\n    ) {}\n\n    toString(): string {\n        return (\n            `generator ${this.name} {\\n` +\n            this.fields.map((f) => indentString(`${f.name} = ${f.text}`)).join('\\n') +\n            `\\n}`\n        );\n    }\n}\n\nexport class DeclarationBase {\n    constructor(public documentations: string[] = []) {}\n\n    addComment(name: string): string {\n        this.documentations.push(name);\n        return name;\n    }\n\n    toString(): string {\n        return this.documentations.map((x) => `${x}\\n`).join('');\n    }\n}\n\nexport class ContainerDeclaration extends DeclarationBase {\n    constructor(\n        documentations: string[] = [],\n        public attributes: (ContainerAttribute | PassThroughAttribute)[] = [],\n    ) {\n        super(documentations);\n    }\n}\n\nexport class FieldDeclaration extends DeclarationBase {\n    constructor(\n        documentations: string[] = [],\n        public attributes: (FieldAttribute | PassThroughAttribute)[] = [],\n    ) {\n        super(documentations);\n    }\n}\n\nexport class Model extends ContainerDeclaration {\n    public fields: ModelField[] = [];\n    constructor(\n        public name: string,\n        public isView: boolean,\n        documentations: string[] = [],\n    ) {\n        super(documentations);\n    }\n\n    addField(\n        name: string,\n        type: ModelFieldType | string,\n        attributes: (FieldAttribute | PassThroughAttribute)[] = [],\n        documentations: string[] = [],\n        addToFront = false,\n    ): ModelField {\n        const field = new ModelField(name, type, attributes, documentations);\n        if (addToFront) {\n            this.fields.unshift(field);\n        } else {\n            this.fields.push(field);\n        }\n        return field;\n    }\n\n    addAttribute(name: string, args: AttributeArg[] = []) {\n        const attr = new ContainerAttribute(name, args);\n        this.attributes.push(attr);\n        return attr;\n    }\n\n    override toString(): string {\n        const result: any[] = [...this.fields];\n\n        if (this.attributes.length > 0) {\n            // Add a blank line before the attributes\n            result.push('');\n        }\n\n        result.push(...this.attributes);\n\n        return (\n            super.toString() +\n            `${this.isView ? 'view' : 'model'} ${this.name} {\\n` +\n            indentString(result.map((d) => d.toString()).join('\\n')) +\n            `\\n}`\n        );\n    }\n}\n\nexport type ScalarTypes =\n    | 'String'\n    | 'Boolean'\n    | 'Int'\n    | 'BigInt'\n    | 'Float'\n    | 'Decimal'\n    | 'DateTime'\n    | 'Json'\n    | 'Bytes'\n    | 'Unsupported';\n\nexport class ModelFieldType {\n    constructor(\n        public type: ScalarTypes | string,\n        public array?: boolean,\n        public optional?: boolean,\n    ) {}\n\n    toString(): string {\n        return `${this.type}${this.array ? '[]' : ''}${this.optional ? '?' : ''}`;\n    }\n}\n\nexport class ModelField extends FieldDeclaration {\n    constructor(\n        public name: string,\n        public type: ModelFieldType | string,\n        attributes: (FieldAttribute | PassThroughAttribute)[] = [],\n        documentations: string[] = [],\n    ) {\n        super(documentations, attributes);\n    }\n\n    addAttribute(name: string, args: AttributeArg[] = []): FieldAttribute {\n        const attr = new FieldAttribute(name, args);\n        this.attributes.push(attr);\n        return attr;\n    }\n\n    override toString(): string {\n        return (\n            super.toString() +\n            `${this.name} ${this.type}` +\n            (this.attributes.length > 0 ? ' ' + this.attributes.map((a) => a.toString()).join(' ') : '')\n        );\n    }\n}\n\nexport class FieldAttribute {\n    constructor(\n        public name: string,\n        public args: AttributeArg[] = [],\n    ) {}\n\n    toString(): string {\n        return `${this.name}(` + this.args.map((a) => a.toString()).join(', ') + `)`;\n    }\n}\n\nexport class ContainerAttribute {\n    constructor(\n        public name: string,\n        public args: AttributeArg[] = [],\n    ) {}\n\n    toString(): string {\n        return `${this.name}(` + this.args.map((a) => a.toString()).join(', ') + `)`;\n    }\n}\n\n/**\n * Represents @@prisma.passthrough and @prisma.passthrough\n */\nexport class PassThroughAttribute {\n    constructor(public text: string) {}\n\n    toString(): string {\n        return this.text;\n    }\n}\n\nexport class AttributeArg {\n    constructor(\n        public name: string | undefined,\n        public value: AttributeArgValue,\n    ) {}\n\n    toString(): string {\n        return this.name ? `${this.name}: ${this.value}` : this.value.toString();\n    }\n}\n\nexport class AttributeArgValue {\n    constructor(\n        public type: 'String' | 'FieldReference' | 'Number' | 'Boolean' | 'Array' | 'FunctionCall',\n        public value: string | number | boolean | FieldReference | FunctionCall | AttributeArgValue[],\n    ) {\n        switch (type) {\n            case 'String':\n                if (typeof value !== 'string') throw new Error('Value must be string');\n                break;\n            case 'Number':\n                if (typeof value !== 'number' && typeof value !== 'string')\n                    throw new Error('Value must be number or string');\n                break;\n            case 'Boolean':\n                if (typeof value !== 'boolean') throw new Error('Value must be boolean');\n                break;\n            case 'Array':\n                if (!Array.isArray(value)) throw new Error('Value must be array');\n                break;\n            case 'FieldReference':\n                if (typeof value !== 'string' && !(value instanceof FieldReference))\n                    throw new Error('Value must be string or FieldReference');\n                break;\n            case 'FunctionCall':\n                if (!(value instanceof FunctionCall)) throw new Error('Value must be FunctionCall');\n                break;\n        }\n    }\n\n    toString(): string {\n        switch (this.type) {\n            case 'String':\n                // use JSON.stringify to escape quotes\n                return JSON.stringify(this.value);\n            case 'Number':\n                return this.value.toString();\n            case 'FieldReference': {\n                if (typeof this.value === 'string') {\n                    return this.value;\n                } else {\n                    const fr = this.value as FieldReference;\n                    let r = fr.field;\n                    if (fr.args.length > 0) {\n                        r += '(' + fr.args.map((a) => a.toString()).join(',') + ')';\n                    }\n                    return r;\n                }\n            }\n            case 'FunctionCall':\n                return this.value.toString();\n            case 'Boolean':\n                return this.value ? 'true' : 'false';\n            case 'Array':\n                return '[' + (this.value as AttributeArgValue[]).map((v) => v.toString()).join(', ') + ']';\n            default:\n                throw new Error(`Unknown attribute value type ${this.type}`);\n        }\n    }\n}\n\nexport class FieldReference {\n    constructor(\n        public field: string,\n        public args: FieldReferenceArg[] = [],\n    ) {}\n}\n\nexport class FieldReferenceArg {\n    constructor(\n        public name: string,\n        public value: string,\n    ) {}\n\n    toString(): string {\n        return `${this.name}: ${this.value}`;\n    }\n}\n\nexport class FunctionCall {\n    constructor(\n        public func: string,\n        public args: FunctionCallArg[] = [],\n    ) {}\n\n    toString(): string {\n        return `${this.func}` + '(' + this.args.map((a) => a.toString()).join(', ') + ')';\n    }\n}\n\nexport class FunctionCallArg {\n    constructor(public value: string) {}\n\n    toString(): string {\n        return this.value;\n    }\n}\n\nexport class Enum extends ContainerDeclaration {\n    public fields: EnumField[] = [];\n\n    constructor(\n        public name: string,\n        documentations: string[] = [],\n    ) {\n        super(documentations);\n    }\n    addField(\n        name: string,\n        attributes: (FieldAttribute | PassThroughAttribute)[] = [],\n        documentations: string[] = [],\n    ): EnumField {\n        const field = new EnumField(name, attributes, documentations);\n        this.fields.push(field);\n        return field;\n    }\n\n    addAttribute(name: string, args: AttributeArg[] = []) {\n        const attr = new ContainerAttribute(name, args);\n        this.attributes.push(attr);\n        return attr;\n    }\n\n    override addComment(name: string): string {\n        this.documentations.push(name);\n        return name;\n    }\n\n    override toString(): string {\n        return (\n            super.toString() +\n            `enum ${this.name} {\\n` +\n            indentString([...this.fields, ...this.attributes].map((d) => d.toString()).join('\\n')) +\n            '\\n}'\n        );\n    }\n}\n\nexport class EnumField extends DeclarationBase {\n    constructor(\n        public name: string,\n        public attributes: (FieldAttribute | PassThroughAttribute)[] = [],\n        documentations: string[] = [],\n    ) {\n        super(documentations);\n    }\n\n    addAttribute(name: string, args: AttributeArg[] = []): FieldAttribute {\n        const attr = new FieldAttribute(name, args);\n        this.attributes.push(attr);\n        return attr;\n    }\n\n    override toString(): string {\n        return (\n            super.toString() +\n            this.name +\n            (this.attributes.length > 0 ? ' ' + this.attributes.map((a) => a.toString()).join(' ') : '')\n        );\n    }\n}\n","import { invariant } from '@zenstackhq/common-helpers';\nimport {\n    ArrayExpr,\n    AttributeArg,\n    BinaryExpr,\n    DataField,\n    DataFieldAttribute,\n    DataFieldType,\n    DataModel,\n    DataModelAttribute,\n    Enum,\n    Expression,\n    InvocationExpr,\n    isArrayExpr,\n    isBinaryExpr,\n    isCollectionPredicateBinding,\n    isDataField,\n    isDataModel,\n    isDataSource,\n    isEnum,\n    isEnumField,\n    isInvocationExpr,\n    isLiteralExpr,\n    isMemberAccessExpr,\n    isNullExpr,\n    isProcedure,\n    isReferenceExpr,\n    isThisExpr,\n    isTypeDef,\n    isUnaryExpr,\n    LiteralExpr,\n    MemberAccessExpr,\n    Procedure,\n    ReferenceExpr,\n    TypeDef,\n    UnaryExpr,\n    type Model,\n} from '@zenstackhq/language/ast';\nimport { getAllAttributes, getAllFields, getAttributeArg, isDataFieldReference } from '@zenstackhq/language/utils';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport { match } from 'ts-pattern';\nimport * as ts from 'typescript';\nimport { ModelUtils } from '.';\nimport {\n    getAttribute,\n    getAuthDecl,\n    getDelegateOriginModel,\n    getIdFields,\n    hasAttribute,\n    isDelegateModel,\n    isIdField,\n    isUniqueField,\n} from './model-utils';\n\nexport type TsSchemaGeneratorOptions = {\n    outDir: string;\n    lite?: boolean;\n    liteOnly?: boolean;\n    importWithFileExtension?: string;\n    generateModelTypes?: boolean;\n    generateInputTypes?: boolean;\n};\n\nexport class TsSchemaGenerator {\n    private usedExpressionUtils = false;\n    private usedAttributeApplication = false;\n    private usedFieldDefault = false;\n\n    async generate(model: Model, options: TsSchemaGeneratorOptions) {\n        fs.mkdirSync(options.outDir, { recursive: true });\n\n        // the schema itself\n        this.generateSchema(model, options);\n\n        // the model types\n        if (options.generateModelTypes !== false) {\n            this.generateModelsAndTypeDefs(model, options);\n        }\n\n        // the input types\n        if (options.generateInputTypes !== false) {\n            this.generateInputTypes(model, options);\n        }\n    }\n\n    private generateSchema(model: Model, options: TsSchemaGeneratorOptions) {\n        const targets: { lite: boolean; file: string }[] = [];\n        if (!options.liteOnly) {\n            targets.push({ lite: false, file: 'schema.ts' });\n        }\n        if (options.lite || options.liteOnly) {\n            targets.push({ lite: true, file: 'schema-lite.ts' });\n        }\n\n        for (const { lite, file } of targets) {\n            // Reset per-target import flags so each target tracks its own usage\n            this.usedExpressionUtils = false;\n            this.usedAttributeApplication = false;\n            this.usedFieldDefault = false;\n\n            const statements: ts.Statement[] = [];\n            this.generateSchemaStatements(model, statements, lite);\n            this.generateBannerComments(statements);\n\n            const schemaOutputFile = path.join(options.outDir, file);\n            const sourceFile = ts.createSourceFile(\n                schemaOutputFile,\n                '',\n                ts.ScriptTarget.ESNext,\n                false,\n                ts.ScriptKind.TS,\n            );\n            const printer = ts.createPrinter();\n            const result = printer.printList(\n                ts.ListFormat.MultiLine,\n                ts.factory.createNodeArray(statements),\n                sourceFile,\n            );\n            fs.writeFileSync(schemaOutputFile, result);\n        }\n    }\n\n    private generateSchemaStatements(model: Model, statements: ts.Statement[], lite: boolean) {\n        // Generate schema content first to determine if ExpressionUtils is needed\n        const schemaClass = this.createSchemaClass(model, lite);\n\n        // Now generate the import declaration with the correct imports\n        // import { type SchemaDef, ExpressionUtils } from '@zenstackhq/schema';\n        const schemaImportDecl = ts.factory.createImportDeclaration(\n            undefined,\n            ts.factory.createImportClause(\n                undefined,\n                undefined,\n                ts.factory.createNamedImports([\n                    ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier('SchemaDef')),\n                    ...(this.usedAttributeApplication\n                        ? [\n                              ts.factory.createImportSpecifier(\n                                  true,\n                                  undefined,\n                                  ts.factory.createIdentifier('AttributeApplication'),\n                              ),\n                          ]\n                        : []),\n                    ...(this.usedFieldDefault\n                        ? [\n                              ts.factory.createImportSpecifier(\n                                  true,\n                                  undefined,\n                                  ts.factory.createIdentifier('FieldDefault'),\n                              ),\n                          ]\n                        : []),\n                    ...(this.usedExpressionUtils\n                        ? [\n                              ts.factory.createImportSpecifier(\n                                  false,\n                                  undefined,\n                                  ts.factory.createIdentifier('ExpressionUtils'),\n                              ),\n                          ]\n                        : []),\n                ]),\n            ),\n            ts.factory.createStringLiteral('@zenstackhq/schema'),\n        );\n        statements.push(schemaImportDecl);\n\n        statements.push(schemaClass);\n\n        // export const schema = new SchemaType();\n        const schemaDecl = ts.factory.createVariableStatement(\n            [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],\n            ts.factory.createVariableDeclarationList(\n                [\n                    ts.factory.createVariableDeclaration(\n                        'schema',\n                        undefined,\n                        undefined,\n                        ts.factory.createNewExpression(ts.factory.createIdentifier('SchemaType'), undefined, []),\n                    ),\n                ],\n                ts.NodeFlags.Const,\n            ),\n        );\n        statements.push(schemaDecl);\n    }\n\n    private createExpressionUtilsCall(method: string, args?: ts.Expression[]): ts.CallExpression {\n        this.usedExpressionUtils = true;\n        return ts.factory.createCallExpression(\n            ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('ExpressionUtils'), method),\n            undefined,\n            args || [],\n        );\n    }\n\n    private createSchemaClass(model: Model, lite: boolean) {\n        const members: ts.ClassElement[] = [\n            // provider\n            ts.factory.createPropertyDeclaration(\n                undefined,\n                'provider',\n                undefined,\n                undefined,\n                this.createAsConst(this.createProviderObject(model)),\n            ),\n\n            // models\n            ts.factory.createPropertyDeclaration(\n                undefined,\n                'models',\n                undefined,\n                undefined,\n                this.createAsConst(this.createModelsObject(model, lite)),\n            ),\n\n            // typeDefs\n            ...(model.declarations.some(isTypeDef)\n                ? [\n                      ts.factory.createPropertyDeclaration(\n                          undefined,\n                          'typeDefs',\n                          undefined,\n                          undefined,\n                          this.createAsConst(this.createTypeDefsObject(model, lite)),\n                      ),\n                  ]\n                : []),\n        ];\n\n        // enums\n        const enums = model.declarations.filter(isEnum);\n        if (enums.length > 0) {\n            members.push(\n                ts.factory.createPropertyDeclaration(\n                    undefined,\n                    'enums',\n                    undefined,\n                    undefined,\n                    this.createAsConst(\n                        ts.factory.createObjectLiteralExpression(\n                            enums.map((e) => ts.factory.createPropertyAssignment(e.name, this.createEnumObject(e))),\n                            true,\n                        ),\n                    ),\n                ),\n            );\n        }\n\n        // authType\n        const authType = getAuthDecl(model);\n        if (authType) {\n            members.push(\n                ts.factory.createPropertyDeclaration(\n                    undefined,\n                    'authType',\n                    undefined,\n                    undefined,\n                    this.createAsConst(this.createLiteralNode(authType.name)),\n                ),\n            );\n        }\n\n        // procedures\n        const procedures = model.declarations.filter(isProcedure);\n        if (procedures.length > 0) {\n            members.push(\n                ts.factory.createPropertyDeclaration(\n                    undefined,\n                    'procedures',\n                    undefined,\n                    undefined,\n                    this.createAsConst(this.createProceduresObject(procedures)),\n                ),\n            );\n        }\n\n        // plugins\n        members.push(\n            ts.factory.createPropertyDeclaration(\n                undefined,\n                'plugins',\n                undefined,\n                undefined,\n                ts.factory.createObjectLiteralExpression([], true),\n            ),\n        );\n\n        const schemaClass = ts.factory.createClassDeclaration(\n            [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],\n            'SchemaType',\n            undefined,\n            [\n                ts.factory.createHeritageClause(ts.SyntaxKind.ImplementsKeyword, [\n                    ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier('SchemaDef'), undefined),\n                ]),\n            ],\n            members,\n        );\n\n        return schemaClass;\n    }\n\n    private createAsConst(expr: ts.Expression) {\n        return ts.factory.createAsExpression(expr, ts.factory.createTypeReferenceNode('const'));\n    }\n\n    private createAttributesTypeAssertion(expr: ts.Expression): ts.Expression {\n        this.usedAttributeApplication = true;\n        return ts.factory.createAsExpression(\n            expr,\n            ts.factory.createTypeOperatorNode(\n                ts.SyntaxKind.ReadonlyKeyword,\n                ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode('AttributeApplication')),\n            ),\n        );\n    }\n\n    private createDefaultTypeAssertion(expr: ts.Expression): ts.Expression {\n        this.usedFieldDefault = true;\n        return ts.factory.createAsExpression(expr, ts.factory.createTypeReferenceNode('FieldDefault'));\n    }\n\n    private createProviderObject(model: Model): ts.Expression {\n        const dsProvider = this.getDataSourceProvider(model);\n        const defaultSchema = this.getDataSourceDefaultSchema(model);\n\n        return ts.factory.createObjectLiteralExpression(\n            [\n                ts.factory.createPropertyAssignment('type', ts.factory.createStringLiteral(dsProvider)),\n                ...(defaultSchema\n                    ? [\n                          ts.factory.createPropertyAssignment(\n                              'defaultSchema',\n                              ts.factory.createStringLiteral(defaultSchema),\n                          ),\n                      ]\n                    : []),\n            ],\n            true,\n        );\n    }\n\n    private createModelsObject(model: Model, lite: boolean): ts.Expression {\n        return ts.factory.createObjectLiteralExpression(\n            this.getAllDataModels(model).map((dm) =>\n                ts.factory.createPropertyAssignment(dm.name, this.createDataModelObject(dm, lite)),\n            ),\n            true,\n        );\n    }\n\n    private getAllDataModels(model: Model) {\n        return model.declarations.filter((d): d is DataModel => isDataModel(d) && !hasAttribute(d, '@@ignore'));\n    }\n\n    private getAllTypeDefs(model: Model) {\n        return model.declarations.filter((d): d is TypeDef => isTypeDef(d) && !hasAttribute(d, '@@ignore'));\n    }\n\n    private createTypeDefsObject(model: Model, lite: boolean): ts.Expression {\n        return ts.factory.createObjectLiteralExpression(\n            this.getAllTypeDefs(model).map((td) =>\n                ts.factory.createPropertyAssignment(td.name, this.createTypeDefObject(td, lite)),\n            ),\n            true,\n        );\n    }\n\n    private createDataModelObject(dm: DataModel, lite: boolean) {\n        const allFields = getAllFields(dm);\n        const allAttributes = lite\n            ? [] // in lite mode, skip all model-level attributes\n            : getAllAttributes(dm).filter((attr) => {\n                  // exclude `@@delegate` attribute from base model\n                  if (attr.decl.$refText === '@@delegate' && attr.$container !== dm) {\n                      return false;\n                  }\n                  return true;\n              });\n        const subModels = this.getSubModels(dm);\n\n        const fields: ts.PropertyAssignment[] = [\n            // name\n            ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral(dm.name)),\n\n            // baseModel\n            ...(dm.baseModel\n                ? [\n                      ts.factory.createPropertyAssignment(\n                          'baseModel',\n                          ts.factory.createStringLiteral(dm.baseModel.$refText),\n                      ),\n                  ]\n                : []),\n\n            // fields\n            ts.factory.createPropertyAssignment(\n                'fields',\n                ts.factory.createObjectLiteralExpression(\n                    allFields.map((field) =>\n                        ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, dm, lite)),\n                    ),\n                    true,\n                ),\n            ),\n\n            // attributes\n            ...(allAttributes.length > 0\n                ? [\n                      ts.factory.createPropertyAssignment(\n                          'attributes',\n                          this.createAttributesTypeAssertion(\n                              ts.factory.createArrayLiteralExpression(\n                                  allAttributes.map((attr) => this.createAttributeObject(attr)),\n                                  true,\n                              ),\n                          ),\n                      ),\n                  ]\n                : []),\n\n            // idFields\n            ts.factory.createPropertyAssignment(\n                'idFields',\n                ts.factory.createArrayLiteralExpression(\n                    getIdFields(dm).map((idField) => ts.factory.createStringLiteral(idField)),\n                ),\n            ),\n\n            // uniqueFields\n            ts.factory.createPropertyAssignment('uniqueFields', this.createUniqueFieldsObject(dm)),\n\n            // isDelegate\n            ...(isDelegateModel(dm)\n                ? [ts.factory.createPropertyAssignment('isDelegate', ts.factory.createTrue())]\n                : []),\n\n            // subModels\n            ...(subModels.length > 0\n                ? [\n                      ts.factory.createPropertyAssignment(\n                          'subModels',\n                          ts.factory.createArrayLiteralExpression(\n                              subModels.map((subModel) => ts.factory.createStringLiteral(subModel)),\n                          ),\n                      ),\n                  ]\n                : []),\n\n            ...(dm.isView ? [ts.factory.createPropertyAssignment('isView', ts.factory.createTrue())] : []),\n        ];\n\n        const computedFields = dm.fields.filter((f) => hasAttribute(f, '@computed'));\n\n        if (computedFields.length > 0) {\n            fields.push(\n                ts.factory.createPropertyAssignment('computedFields', this.createComputedFieldsObject(computedFields)),\n            );\n        }\n\n        return ts.factory.createObjectLiteralExpression(fields, true);\n    }\n\n    private getSubModels(dm: DataModel) {\n        return dm.$container.declarations\n            .filter(isDataModel)\n            .filter((d) => d.baseModel?.ref === dm)\n            .map((d) => d.name);\n    }\n\n    private createTypeDefObject(td: TypeDef, lite: boolean): ts.Expression {\n        const allFields = getAllFields(td);\n        const allAttributes = getAllAttributes(td);\n\n        const fields: ts.PropertyAssignment[] = [\n            // name\n            ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral(td.name)),\n\n            // fields\n            ts.factory.createPropertyAssignment(\n                'fields',\n                ts.factory.createObjectLiteralExpression(\n                    allFields.map((field) =>\n                        ts.factory.createPropertyAssignment(\n                            field.name,\n                            this.createDataFieldObject(field, undefined, lite),\n                        ),\n                    ),\n                    true,\n                ),\n            ),\n\n            // attributes\n            ...(allAttributes.length > 0\n                ? [\n                      ts.factory.createPropertyAssignment(\n                          'attributes',\n                          this.createAttributesTypeAssertion(\n                              ts.factory.createArrayLiteralExpression(\n                                  allAttributes.map((attr) => this.createAttributeObject(attr)),\n                                  true,\n                              ),\n                          ),\n                      ),\n                  ]\n                : []),\n        ];\n\n        return ts.factory.createObjectLiteralExpression(fields, true);\n    }\n\n    private createComputedFieldsObject(fields: DataField[]) {\n        return ts.factory.createObjectLiteralExpression(\n            fields.map((field) =>\n                ts.factory.createMethodDeclaration(\n                    undefined,\n                    undefined,\n                    field.name,\n                    undefined,\n                    undefined,\n                    [\n                        // parameter: `context: { modelAlias: string }`\n                        ts.factory.createParameterDeclaration(\n                            undefined,\n                            undefined,\n                            '_context',\n                            undefined,\n                            ts.factory.createTypeLiteralNode([\n                                ts.factory.createPropertySignature(\n                                    undefined,\n                                    'modelAlias',\n                                    undefined,\n                                    ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n                                ),\n                            ]),\n                            undefined,\n                        ),\n                    ],\n                    ts.factory.createTypeReferenceNode(this.mapFieldTypeToTSType(field.type)),\n                    ts.factory.createBlock(\n                        [\n                            ts.factory.createThrowStatement(\n                                ts.factory.createNewExpression(ts.factory.createIdentifier('Error'), undefined, [\n                                    ts.factory.createStringLiteral('This is a stub for computed field'),\n                                ]),\n                            ),\n                        ],\n                        true,\n                    ),\n                ),\n            ),\n            true,\n        );\n    }\n\n    private createUpdatedAtObject(ignoreArg: AttributeArg) {\n        return ts.factory.createObjectLiteralExpression([\n            ts.factory.createPropertyAssignment(\n                'ignore',\n                ts.factory.createArrayLiteralExpression(\n                    (ignoreArg.value as ArrayExpr).items.map((item) =>\n                        ts.factory.createStringLiteral((item as ReferenceExpr).target.$refText),\n                    ),\n                ),\n            ),\n        ]);\n    }\n\n    private mapFieldTypeToTSType(type: DataFieldType) {\n        let result = match(type.type)\n            .with('String', () => 'string')\n            .with('Boolean', () => 'boolean')\n            .with('Int', () => 'number')\n            .with('Float', () => 'number')\n            .with('BigInt', () => 'bigint')\n            .with('Decimal', () => 'number')\n            .otherwise(() => 'unknown');\n        if (type.array) {\n            result = `${result}[]`;\n        }\n        if (type.optional) {\n            result = `${result} | null`;\n        }\n        return result;\n    }\n\n    private createDataFieldObject(field: DataField, contextModel: DataModel | undefined, lite: boolean) {\n        const objectFields = [\n            // name\n            ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral(field.name)),\n            // type\n            ts.factory.createPropertyAssignment('type', this.generateFieldTypeLiteral(field)),\n        ];\n\n        if (contextModel && ModelUtils.isIdField(field, contextModel)) {\n            objectFields.push(ts.factory.createPropertyAssignment('id', ts.factory.createTrue()));\n        }\n\n        if (isUniqueField(field)) {\n            objectFields.push(ts.factory.createPropertyAssignment('unique', ts.factory.createTrue()));\n        }\n\n        if (field.type.optional) {\n            objectFields.push(ts.factory.createPropertyAssignment('optional', ts.factory.createTrue()));\n        }\n\n        if (field.type.array) {\n            objectFields.push(ts.factory.createPropertyAssignment('array', ts.factory.createTrue()));\n        }\n\n        const updatedAtAttrib = getAttribute(field, '@updatedAt') as DataFieldAttribute | undefined;\n        if (updatedAtAttrib) {\n            const ignoreArg = updatedAtAttrib.args.find((arg) => arg.$resolvedParam?.name === 'ignore');\n            objectFields.push(\n                ts.factory.createPropertyAssignment(\n                    'updatedAt',\n                    ignoreArg ? this.createUpdatedAtObject(ignoreArg) : ts.factory.createTrue(),\n                ),\n            );\n        }\n\n        if (hasAttribute(field, '@omit')) {\n            objectFields.push(ts.factory.createPropertyAssignment('omit', ts.factory.createTrue()));\n        }\n\n        // originModel\n        if (\n            contextModel &&\n            // id fields are duplicated in inherited models\n            !isIdField(field, contextModel)\n        ) {\n            const delegateOrigin = getDelegateOriginModel(field, contextModel);\n            if (delegateOrigin) {\n                objectFields.push(\n                    ts.factory.createPropertyAssignment('originModel', ts.factory.createStringLiteral(delegateOrigin)),\n                );\n            }\n        }\n\n        // discriminator\n        if (this.isDiscriminatorField(field)) {\n            objectFields.push(ts.factory.createPropertyAssignment('isDiscriminator', ts.factory.createTrue()));\n        }\n\n        // attributes, only when not in lite mode\n        if (!lite && field.attributes.length > 0) {\n            objectFields.push(\n                ts.factory.createPropertyAssignment(\n                    'attributes',\n                    this.createAttributesTypeAssertion(\n                        ts.factory.createArrayLiteralExpression(\n                            field.attributes.map((attr) => this.createAttributeObject(attr)),\n                        ),\n                    ),\n                ),\n            );\n        }\n\n        const defaultValue = this.getFieldMappedDefault(field);\n        if (defaultValue !== undefined) {\n            let defaultExpr: ts.Expression;\n            if (defaultValue === null) {\n                defaultExpr = this.createExpressionUtilsCall('_null');\n            } else if (typeof defaultValue === 'object' && !Array.isArray(defaultValue)) {\n                if ('call' in defaultValue) {\n                    defaultExpr = this.createExpressionUtilsCall('call', [\n                        ts.factory.createStringLiteral(defaultValue.call),\n                        ...(defaultValue.args.length > 0\n                            ? [\n                                  ts.factory.createArrayLiteralExpression(\n                                      defaultValue.args.map((arg) =>\n                                          this.createExpressionUtilsCall('literal', [\n                                              this.createLiteralNode(arg),\n                                          ]),\n                                      ),\n                                  ),\n                              ]\n                            : []),\n                    ]);\n                } else if ('authMember' in defaultValue) {\n                    defaultExpr = this.createExpressionUtilsCall('member', [\n                        this.createExpressionUtilsCall('call', [ts.factory.createStringLiteral('auth')]),\n                        ts.factory.createArrayLiteralExpression(\n                            defaultValue.authMember.map((m) => ts.factory.createStringLiteral(m)),\n                        ),\n                    ]);\n                } else {\n                    throw new Error(`Unsupported default value type for field ${field.name}`);\n                }\n            } else if (Array.isArray(defaultValue)) {\n                defaultExpr = ts.factory.createArrayLiteralExpression(\n                    defaultValue.map((item) => this.createLiteralNode(item as any)),\n                );\n            } else {\n                defaultExpr = this.createLiteralNode(defaultValue);\n            }\n            objectFields.push(\n                ts.factory.createPropertyAssignment('default', this.createDefaultTypeAssertion(defaultExpr)),\n            );\n        }\n\n        if (hasAttribute(field, '@computed')) {\n            objectFields.push(ts.factory.createPropertyAssignment('computed', ts.factory.createTrue()));\n        }\n\n        if (isDataModel(field.type.reference?.ref)) {\n            objectFields.push(ts.factory.createPropertyAssignment('relation', this.createRelationObject(field)));\n        }\n\n        const fkFor = this.getForeignKeyFor(field);\n        if (fkFor && fkFor.length > 0) {\n            objectFields.push(\n                ts.factory.createPropertyAssignment(\n                    'foreignKeyFor',\n                    ts.factory.createAsExpression(\n                        ts.factory.createArrayLiteralExpression(\n                            fkFor.map((fk) => ts.factory.createStringLiteral(fk)),\n                            true,\n                        ),\n                        ts.factory.createTypeOperatorNode(\n                            ts.SyntaxKind.ReadonlyKeyword,\n                            ts.factory.createArrayTypeNode(\n                                ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n                            ),\n                        ),\n                    ),\n                ),\n            );\n        }\n\n        return ts.factory.createObjectLiteralExpression(objectFields, true);\n    }\n\n    private isDiscriminatorField(field: DataField) {\n        const origin = field.$container;\n        return getAttribute(origin, '@@delegate')?.args.some(\n            (arg) =>\n                arg.$resolvedParam.name === 'discriminator' &&\n                isDataFieldReference(arg.value) &&\n                arg.value.target.ref === field,\n        );\n    }\n\n    private getDataSourceProvider(model: Model) {\n        const dataSource = model.declarations.find(isDataSource);\n        invariant(dataSource, 'No data source found in the model');\n\n        const providerExpr = dataSource.fields.find((f) => f.name === 'provider')?.value;\n        invariant(\n            isLiteralExpr(providerExpr) && typeof providerExpr.value === 'string',\n            'Provider must be a string literal',\n        );\n        return providerExpr.value as string;\n    }\n\n    private getDataSourceDefaultSchema(model: Model) {\n        const dataSource = model.declarations.find(isDataSource);\n        invariant(dataSource, 'No data source found in the model');\n\n        const defaultSchemaExpr = dataSource.fields.find((f) => f.name === 'defaultSchema')?.value;\n        if (!defaultSchemaExpr) {\n            return undefined;\n        }\n        invariant(\n            isLiteralExpr(defaultSchemaExpr) && typeof defaultSchemaExpr.value === 'string',\n            'Default schema must be a string literal',\n        );\n        return defaultSchemaExpr.value as string;\n    }\n\n    private getFieldMappedDefault(\n        field: DataField,\n    ):\n        | string\n        | number\n        | boolean\n        | unknown[]\n        | { call: string; args: any[] }\n        | { authMember: string[] }\n        | null\n        | undefined {\n        const defaultAttr = getAttribute(field, '@default');\n        if (!defaultAttr) {\n            return undefined;\n        }\n        const defaultValue = defaultAttr.args[0]?.value;\n        invariant(defaultValue, 'Expected a default value');\n        return this.getMappedValue(defaultValue, field.type);\n    }\n\n    private getMappedValue(\n        expr: Expression,\n        fieldType: DataFieldType,\n    ): string | number | boolean | unknown[] | { call: string; args: any[] } | { authMember: string[] } | null {\n        if (isLiteralExpr(expr)) {\n            const lit = (expr as LiteralExpr).value;\n            return fieldType.type === 'Boolean'\n                ? (lit as boolean)\n                : ['Int', 'Float', 'Decimal', 'BigInt'].includes(fieldType.type!)\n                  ? Number(lit)\n                  : lit;\n        } else if (isArrayExpr(expr)) {\n            return expr.items.map((item) => this.getMappedValue(item, fieldType));\n        } else if (isReferenceExpr(expr) && isEnumField(expr.target.ref)) {\n            return expr.target.ref.name;\n        } else if (isInvocationExpr(expr)) {\n            return {\n                call: expr.function.$refText,\n                args: expr.args.map((arg) => this.getLiteral(arg.value)),\n            };\n        } else if (this.isAuthMemberAccess(expr)) {\n            return {\n                authMember: this.getMemberAccessChain(expr),\n            };\n        } else if (isNullExpr(expr)) {\n            return null;\n        } else {\n            throw new Error(`Unsupported expression type: ${expr.$type}`);\n        }\n    }\n\n    private getMemberAccessChain(expr: MemberAccessExpr): string[] {\n        if (!isMemberAccessExpr(expr.operand)) {\n            return [expr.member.$refText];\n        } else {\n            return [...this.getMemberAccessChain(expr.operand), expr.member.$refText];\n        }\n    }\n\n    private isAuthMemberAccess(expr: Expression): expr is MemberAccessExpr {\n        if (isMemberAccessExpr(expr)) {\n            return this.isAuthInvocation(expr.operand) || this.isAuthMemberAccess(expr.operand);\n        } else {\n            return false;\n        }\n    }\n\n    private isAuthInvocation(expr: Expression) {\n        return (\n            isInvocationExpr(expr) && expr.function.$refText === 'auth' && ModelUtils.isFromStdlib(expr.function.ref!)\n        );\n    }\n\n    private createRelationObject(field: DataField) {\n        const relationFields: ts.PropertyAssignment[] = [];\n\n        const oppositeRelation = this.getOppositeRelationField(field);\n        if (oppositeRelation) {\n            relationFields.push(\n                ts.factory.createPropertyAssignment('opposite', ts.factory.createStringLiteral(oppositeRelation.name)),\n            );\n        }\n\n        const relationName = this.getRelationName(field);\n        if (relationName) {\n            relationFields.push(\n                ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral(relationName)),\n            );\n        }\n\n        const relation = getAttribute(field, '@relation');\n        const fkFields: string[] = [];\n        if (relation) {\n            for (const arg of relation.args) {\n                const param = arg.$resolvedParam.name;\n                if (param === 'fields' || param === 'references') {\n                    const fieldNames = this.getReferenceNames(arg.value);\n                    if (fieldNames) {\n                        if (param === 'fields') {\n                            fkFields.push(...fieldNames);\n                        }\n                        relationFields.push(\n                            ts.factory.createPropertyAssignment(\n                                param,\n                                ts.factory.createArrayLiteralExpression(\n                                    fieldNames.map((el) => ts.factory.createStringLiteral(el)),\n                                ),\n                            ),\n                        );\n                    }\n                }\n\n                if (param === 'onDelete' || param === 'onUpdate') {\n                    const action = (arg.value as ReferenceExpr).target.$refText;\n                    relationFields.push(\n                        ts.factory.createPropertyAssignment(param, ts.factory.createStringLiteral(action)),\n                    );\n                }\n            }\n        }\n\n        // check if all fk fields have default values\n        if (fkFields.length > 0) {\n            const allHaveDefault = fkFields.every((fieldName) => {\n                const fieldDef = field.$container.fields.find((f) => f.name === fieldName);\n                return fieldDef && hasAttribute(fieldDef, '@default');\n            });\n            if (allHaveDefault) {\n                relationFields.push(ts.factory.createPropertyAssignment('hasDefault', ts.factory.createTrue()));\n            }\n        }\n\n        return ts.factory.createObjectLiteralExpression(relationFields);\n    }\n\n    private getReferenceNames(expr: Expression) {\n        return isArrayExpr(expr) && expr.items.map((item) => (item as ReferenceExpr).target.$refText);\n    }\n\n    private getForeignKeyFor(field: DataField) {\n        const result: string[] = [];\n        for (const f of field.$container.fields) {\n            const relation = getAttribute(f, '@relation');\n            if (relation) {\n                for (const arg of relation.args) {\n                    if (\n                        arg.name === 'fields' &&\n                        isArrayExpr(arg.value) &&\n                        arg.value.items.some((el) => isReferenceExpr(el) && el.target.ref === field)\n                    ) {\n                        result.push(f.name);\n                    }\n                }\n            }\n        }\n        return result;\n    }\n\n    private getOppositeRelationField(field: DataField) {\n        if (!field.type.reference?.ref || !isDataModel(field.type.reference?.ref)) {\n            return undefined;\n        }\n\n        const sourceModel = field.$container as DataModel;\n        const targetModel = field.type.reference.ref as DataModel;\n        const relationName = this.getRelationName(field);\n        for (const otherField of targetModel.fields) {\n            if (otherField === field) {\n                // backlink field is never self\n                continue;\n            }\n            if (otherField.type.reference?.ref === sourceModel) {\n                if (relationName) {\n                    // if relation has a name, the opposite side must match\n                    const otherRelationName = this.getRelationName(otherField);\n                    if (otherRelationName === relationName) {\n                        return otherField;\n                    }\n                } else {\n                    return otherField;\n                }\n            }\n        }\n        return undefined;\n    }\n\n    private getRelationName(field: DataField) {\n        const relation = getAttribute(field, '@relation');\n        if (relation) {\n            const nameArg = relation.args.find((arg) => arg.$resolvedParam.name === 'name');\n            if (nameArg) {\n                invariant(isLiteralExpr(nameArg.value), 'name must be a literal');\n                return nameArg.value.value as string;\n            }\n        }\n        return undefined;\n    }\n\n    private createUniqueFieldsObject(dm: DataModel) {\n        const properties: ts.PropertyAssignment[] = [];\n\n        // field-level id and unique\n        const allFields = getAllFields(dm);\n        for (const field of allFields) {\n            if (hasAttribute(field, '@id') || hasAttribute(field, '@unique')) {\n                properties.push(\n                    ts.factory.createPropertyAssignment(\n                        field.name,\n                        ts.factory.createObjectLiteralExpression([\n                            ts.factory.createPropertyAssignment('type', this.generateFieldTypeLiteral(field)),\n                        ]),\n                    ),\n                );\n            }\n        }\n\n        // model-level id and unique\n        const allAttributes = getAllAttributes(dm);\n\n        // it's possible to have the same set of fields in both `@@id` and `@@unique`\n        // so we need to deduplicate them\n        const seenKeys = new Set<string>();\n        for (const attr of allAttributes) {\n            if (attr.decl.$refText === '@@id' || attr.decl.$refText === '@@unique') {\n                const fieldsArg = getAttributeArg(attr, 'fields');\n                if (!fieldsArg) {\n                    continue;\n                }\n                const fieldNames = this.getReferenceNames(fieldsArg);\n                if (!fieldNames) {\n                    continue;\n                }\n\n                if (fieldNames.length === 1) {\n                    // single-field unique\n                    const fieldDef = allFields.find((f) => f.name === fieldNames[0])!;\n                    properties.push(\n                        ts.factory.createPropertyAssignment(\n                            fieldNames[0]!,\n                            ts.factory.createObjectLiteralExpression([\n                                ts.factory.createPropertyAssignment('type', this.generateFieldTypeLiteral(fieldDef)),\n                            ]),\n                        ),\n                    );\n                } else {\n                    // multi-field unique\n                    const key = this.getCompoundUniqueKey(attr, fieldNames);\n                    if (seenKeys.has(key)) {\n                        continue;\n                    }\n                    seenKeys.add(key);\n                    properties.push(\n                        ts.factory.createPropertyAssignment(\n                            key,\n                            ts.factory.createObjectLiteralExpression(\n                                fieldNames.map((field) => {\n                                    const fieldDef = allFields.find((f) => f.name === field)!;\n                                    return ts.factory.createPropertyAssignment(\n                                        field,\n                                        ts.factory.createObjectLiteralExpression([\n                                            ts.factory.createPropertyAssignment(\n                                                'type',\n                                                this.generateFieldTypeLiteral(fieldDef),\n                                            ),\n                                        ]),\n                                    );\n                                }),\n                            ),\n                        ),\n                    );\n                }\n            }\n        }\n\n        return ts.factory.createObjectLiteralExpression(properties, true);\n    }\n\n    private getCompoundUniqueKey(attr: DataModelAttribute, fieldNames: string[]) {\n        const nameArg = attr.args.find((arg) => arg.$resolvedParam.name === 'name');\n        if (nameArg && isLiteralExpr(nameArg.value)) {\n            return nameArg.value.value as string;\n        } else {\n            return fieldNames.join('_');\n        }\n    }\n\n    private generateFieldTypeLiteral(field: DataField): ts.Expression {\n        invariant(\n            field.type.type || field.type.reference || field.type.unsupported,\n            'Field type must be a primitive, reference, or Unsupported',\n        );\n\n        return field.type.type\n            ? ts.factory.createStringLiteral(field.type.type)\n            : field.type.reference\n              ? ts.factory.createStringLiteral(field.type.reference.$refText)\n              : // `Unsupported` type\n                ts.factory.createStringLiteral('Unsupported');\n    }\n\n    private createEnumObject(e: Enum) {\n        return ts.factory.createObjectLiteralExpression(\n            [\n                ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral(e.name)),\n\n                ts.factory.createPropertyAssignment(\n                    'values',\n                    ts.factory.createObjectLiteralExpression(\n                        e.fields.map((f) =>\n                            ts.factory.createPropertyAssignment(f.name, ts.factory.createStringLiteral(f.name)),\n                        ),\n                        true,\n                    ),\n                ),\n\n                // only generate `fields` if there are attributes on the fields\n                ...(e.fields.some((f) => f.attributes.length > 0)\n                    ? [\n                          ts.factory.createPropertyAssignment(\n                              'fields',\n                              ts.factory.createObjectLiteralExpression(\n                                  e.fields.map((field) =>\n                                      ts.factory.createPropertyAssignment(\n                                          field.name,\n                                          ts.factory.createObjectLiteralExpression(\n                                              [\n                                                  ts.factory.createPropertyAssignment(\n                                                      'name',\n                                                      ts.factory.createStringLiteral(field.name),\n                                                  ),\n                                                  ...(field.attributes.length > 0\n                                                      ? [\n                                                            ts.factory.createPropertyAssignment(\n                                                                'attributes',\n                                                                this.createAttributesTypeAssertion(\n                                                                    ts.factory.createArrayLiteralExpression(\n                                                                        field.attributes?.map((attr) =>\n                                                                            this.createAttributeObject(attr),\n                                                                        ) ?? [],\n                                                                        true,\n                                                                    ),\n                                                                ),\n                                                            ),\n                                                        ]\n                                                      : []),\n                                              ],\n                                              true,\n                                          ),\n                                      ),\n                                  ),\n                                  true,\n                              ),\n                          ),\n                      ]\n                    : []),\n\n                ...(e.attributes.length > 0\n                    ? [\n                          ts.factory.createPropertyAssignment(\n                              'attributes',\n                              this.createAttributesTypeAssertion(\n                                  ts.factory.createArrayLiteralExpression(\n                                      e.attributes.map((attr) => this.createAttributeObject(attr)),\n                                      true,\n                                  ),\n                              ),\n                          ),\n                      ]\n                    : []),\n            ],\n            true,\n        );\n    }\n\n    private getLiteral(expr: Expression) {\n        if (!isLiteralExpr(expr)) {\n            throw new Error('Expected a literal expression');\n        }\n        switch (expr?.$type) {\n            case 'StringLiteral':\n            case 'BooleanLiteral':\n                return expr.value;\n            case 'NumberLiteral':\n                return parseFloat(expr.value);\n            default:\n                throw new Error('Unsupported literal type');\n        }\n    }\n\n    private createLiteralNode(arg: string | number | boolean | null): any {\n        return arg === null\n            ? ts.factory.createNull()\n            : typeof arg === 'string'\n              ? ts.factory.createStringLiteral(arg)\n              : typeof arg === 'number'\n                ? this.createNumberLiteral(arg)\n                : arg === true\n                  ? ts.factory.createTrue()\n                  : arg === false\n                    ? ts.factory.createFalse()\n                    : undefined;\n    }\n\n    private createNumberLiteral(arg: number) {\n        return arg < 0\n            ? ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(-arg))\n            : ts.factory.createNumericLiteral(arg);\n    }\n\n    private createProceduresObject(procedures: Procedure[]) {\n        return ts.factory.createObjectLiteralExpression(\n            procedures.map((proc) => ts.factory.createPropertyAssignment(proc.name, this.createProcedureObject(proc))),\n            true,\n        );\n    }\n\n    private createProcedureObject(proc: Procedure) {\n        const params = ts.factory.createObjectLiteralExpression(\n            proc.params.map((param) =>\n                ts.factory.createPropertyAssignment(\n                    param.name,\n                    ts.factory.createObjectLiteralExpression([\n                        ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral(param.name)),\n                        ...(param.optional\n                            ? [ts.factory.createPropertyAssignment('optional', ts.factory.createTrue())]\n                            : []),\n                        ...(param.type.array\n                            ? [ts.factory.createPropertyAssignment('array', ts.factory.createTrue())]\n                            : []),\n                        ts.factory.createPropertyAssignment(\n                            'type',\n                            ts.factory.createStringLiteral(param.type.type ?? param.type.reference!.$refText),\n                        ),\n                    ]),\n                ),\n            ),\n            true,\n        );\n\n        return ts.factory.createObjectLiteralExpression(\n            [\n                ts.factory.createPropertyAssignment('params', params),\n                ts.factory.createPropertyAssignment(\n                    'returnType',\n                    ts.factory.createStringLiteral(proc.returnType.type ?? proc.returnType.reference!.$refText),\n                ),\n                ...(proc.returnType.array\n                    ? [ts.factory.createPropertyAssignment('returnArray', ts.factory.createTrue())]\n                    : []),\n                ...(proc.mutation ? [ts.factory.createPropertyAssignment('mutation', ts.factory.createTrue())] : []),\n            ],\n            true,\n        );\n    }\n\n    private generateBannerComments(statements: ts.Statement[]) {\n        const banner = `////////////////////////////////////////////////////////////////////////////////////////////\n// DO NOT MODIFY THIS FILE                                                                  //\n// This file is automatically generated by ZenStack CLI and should not be manually updated. //\n//////////////////////////////////////////////////////////////////////////////////////////////\n\n/* eslint-disable */\n\n`;\n        ts.addSyntheticLeadingComment(statements[0]!, ts.SyntaxKind.SingleLineCommentTrivia, banner);\n    }\n\n    private createAttributeObject(attr: DataModelAttribute | DataFieldAttribute): ts.Expression {\n        return ts.factory.createObjectLiteralExpression([\n            ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral(attr.decl.$refText)),\n            ...(attr.args.length > 0\n                ? [\n                      ts.factory.createPropertyAssignment(\n                          'args',\n                          ts.factory.createArrayLiteralExpression(attr.args.map((arg) => this.createAttributeArg(arg))),\n                      ),\n                  ]\n                : []),\n        ]);\n    }\n\n    private createAttributeArg(arg: AttributeArg): ts.Expression {\n        return ts.factory.createObjectLiteralExpression([\n            // name\n            ...(arg.$resolvedParam?.name\n                ? [ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral(arg.$resolvedParam.name))]\n                : []),\n\n            // value\n            ts.factory.createPropertyAssignment('value', this.createExpression(arg.value)),\n        ]);\n    }\n\n    private createExpression(value: Expression): ts.Expression {\n        return match(value)\n            .when(isLiteralExpr, (expr) => this.createLiteralExpression(expr.$type, expr.value))\n            .when(isInvocationExpr, (expr) => this.createCallExpression(expr))\n            .when(isReferenceExpr, (expr) => this.createRefExpression(expr))\n            .when(isArrayExpr, (expr) => this.createArrayExpression(expr))\n            .when(isUnaryExpr, (expr) => this.createUnaryExpression(expr))\n            .when(isBinaryExpr, (expr) => this.createBinaryExpression(expr))\n            .when(isMemberAccessExpr, (expr) => this.createMemberExpression(expr))\n            .when(isNullExpr, () => this.createNullExpression())\n            .when(isThisExpr, () => this.createThisExpression())\n            .otherwise(() => {\n                throw new Error(`Unsupported attribute arg value: ${value.$type}`);\n            });\n    }\n\n    private createThisExpression() {\n        return this.createExpressionUtilsCall('_this');\n    }\n\n    private createMemberExpression(expr: MemberAccessExpr) {\n        const members: string[] = [];\n\n        // turn nested member access expression into a flat list of members\n        let current: Expression = expr;\n        while (isMemberAccessExpr(current)) {\n            members.unshift(current.member.$refText);\n            current = current.operand;\n        }\n        const receiver = current;\n\n        const args = [\n            this.createExpression(receiver),\n            ts.factory.createArrayLiteralExpression(members.map((m) => ts.factory.createStringLiteral(m))),\n        ];\n\n        return this.createExpressionUtilsCall('member', args);\n    }\n\n    private createNullExpression() {\n        return this.createExpressionUtilsCall('_null');\n    }\n\n    private createBinaryExpression(expr: BinaryExpr) {\n        const args = [\n            this.createExpression(expr.left),\n            this.createLiteralNode(expr.operator),\n            this.createExpression(expr.right),\n        ];\n\n        if (expr.binding) {\n            args.push(this.createLiteralNode(expr.binding.name));\n        }\n\n        return this.createExpressionUtilsCall('binary', args);\n    }\n\n    private createUnaryExpression(expr: UnaryExpr) {\n        return this.createExpressionUtilsCall('unary', [\n            this.createLiteralNode(expr.operator),\n            this.createExpression(expr.operand),\n        ]);\n    }\n\n    private createArrayExpression(expr: ArrayExpr): any {\n        const arrayResolved = expr.$resolvedType?.decl;\n        const arrayType = typeof arrayResolved === 'string' ? arrayResolved : arrayResolved?.name;\n        invariant(arrayType, 'Array type must be resolved to a string or declaration');\n        return this.createExpressionUtilsCall('array', [\n            this.createLiteralNode(arrayType),\n            ts.factory.createArrayLiteralExpression(expr.items.map((item) => this.createExpression(item))),\n        ]);\n    }\n\n    private createRefExpression(expr: ReferenceExpr): any {\n        const target = expr.target.ref;\n        return match(target)\n            .when(isDataField, () =>\n                this.createExpressionUtilsCall('field', [this.createLiteralNode(expr.target.$refText)]),\n            )\n            .when(isEnumField, () => this.createLiteralExpression('StringLiteral', expr.target.$refText))\n            .when(isCollectionPredicateBinding, () =>\n                this.createExpressionUtilsCall('binding', [this.createLiteralNode(expr.target.$refText)]),\n            )\n            .otherwise(() => {\n                throw Error(`Unsupported reference type: ${expr.target.$refText}`);\n            });\n    }\n\n    private createCallExpression(expr: InvocationExpr) {\n        return this.createExpressionUtilsCall('call', [\n            ts.factory.createStringLiteral(expr.function.$refText),\n            ...(expr.args.length > 0\n                ? [ts.factory.createArrayLiteralExpression(expr.args.map((arg) => this.createExpression(arg.value)))]\n                : []),\n        ]);\n    }\n\n    private createLiteralExpression(type: string, value: string | boolean) {\n        return match(type)\n            .with('BooleanLiteral', () => this.createExpressionUtilsCall('literal', [this.createLiteralNode(value)]))\n            .with('NumberLiteral', () =>\n                this.createExpressionUtilsCall('literal', [ts.factory.createIdentifier(value as string)]),\n            )\n            .with('StringLiteral', () => this.createExpressionUtilsCall('literal', [this.createLiteralNode(value)]))\n            .otherwise(() => {\n                throw new Error(`Unsupported literal type: ${type}`);\n            });\n    }\n\n    private generateModelsAndTypeDefs(model: Model, options: TsSchemaGeneratorOptions) {\n        const statements: ts.Statement[] = [];\n\n        // generate: import { schema as $schema, type SchemaType as $Schema } from './schema';\n        statements.push(\n            this.generateSchemaImport(\n                model,\n                true,\n                true,\n                !!(options.lite || options.liteOnly),\n                options.importWithFileExtension,\n            ),\n        );\n\n        // generate: import type { ModelResult as $ModelResult } from '@zenstackhq/orm';\n        statements.push(\n            ts.factory.createImportDeclaration(\n                undefined,\n                ts.factory.createImportClause(\n                    true,\n                    undefined,\n                    ts.factory.createNamedImports([\n                        ts.factory.createImportSpecifier(\n                            false,\n                            undefined,\n                            ts.factory.createIdentifier(`ModelResult as $ModelResult`),\n                        ),\n                        ...(model.declarations.some(isTypeDef)\n                            ? [\n                                  ts.factory.createImportSpecifier(\n                                      false,\n                                      undefined,\n                                      ts.factory.createIdentifier(`TypeDefResult as $TypeDefResult`),\n                                  ),\n                              ]\n                            : []),\n                    ]),\n                ),\n                ts.factory.createStringLiteral('@zenstackhq/orm'),\n            ),\n        );\n\n        // generate: export type Model = $ModelResult<Schema, 'Model'>;\n        const dataModels = this.getAllDataModels(model);\n        for (const dm of dataModels) {\n            let modelType = ts.factory.createTypeAliasDeclaration(\n                [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],\n                dm.name,\n                undefined,\n                ts.factory.createTypeReferenceNode('$ModelResult', [\n                    ts.factory.createTypeReferenceNode('$Schema'),\n                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),\n                ]),\n            );\n            if (dm.comments.length > 0) {\n                modelType = this.generateDocs(modelType, dm);\n            }\n            statements.push(modelType);\n        }\n\n        // generate: export type TypeDef = $TypeDefResult<Schema, 'TypeDef'>;\n        const typeDefs = this.getAllTypeDefs(model);\n        for (const td of typeDefs) {\n            let typeDef = ts.factory.createTypeAliasDeclaration(\n                [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],\n                td.name,\n                undefined,\n                ts.factory.createTypeReferenceNode('$TypeDefResult', [\n                    ts.factory.createTypeReferenceNode('$Schema'),\n                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(td.name)),\n                ]),\n            );\n            if (td.comments.length > 0) {\n                typeDef = this.generateDocs(typeDef, td);\n            }\n            statements.push(typeDef);\n        }\n\n        // generate: export const Enum = $schema.enums.Enum['values'];\n        const enums = model.declarations.filter(isEnum);\n        for (const e of enums) {\n            let enumDecl = ts.factory.createVariableStatement(\n                [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],\n                ts.factory.createVariableDeclarationList(\n                    [\n                        ts.factory.createVariableDeclaration(\n                            e.name,\n                            undefined,\n                            undefined,\n                            ts.factory.createPropertyAccessExpression(\n                                ts.factory.createPropertyAccessExpression(\n                                    ts.factory.createPropertyAccessExpression(\n                                        ts.factory.createIdentifier('$schema'),\n                                        ts.factory.createIdentifier('enums'),\n                                    ),\n                                    ts.factory.createIdentifier(e.name),\n                                ),\n                                ts.factory.createIdentifier('values'),\n                            ),\n                        ),\n                    ],\n                    ts.NodeFlags.Const,\n                ),\n            );\n            if (e.comments.length > 0) {\n                enumDecl = this.generateDocs(enumDecl, e);\n            }\n            statements.push(enumDecl);\n\n            // generate: export type Enum = (typeof Enum)[keyof typeof Enum];\n            let typeAlias = ts.factory.createTypeAliasDeclaration(\n                [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],\n                e.name,\n                undefined,\n                ts.factory.createIndexedAccessTypeNode(\n                    ts.factory.createTypeQueryNode(ts.factory.createIdentifier(e.name)),\n                    ts.factory.createTypeOperatorNode(\n                        ts.SyntaxKind.KeyOfKeyword,\n                        ts.factory.createTypeQueryNode(ts.factory.createIdentifier(e.name)),\n                    ),\n                ),\n            );\n            if (e.comments.length > 0) {\n                typeAlias = this.generateDocs(typeAlias, e);\n            }\n            statements.push(typeAlias);\n        }\n\n        this.generateBannerComments(statements);\n\n        // write to file\n        const outputFile = path.join(options.outDir, 'models.ts');\n        const sourceFile = ts.createSourceFile(outputFile, '', ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);\n        const printer = ts.createPrinter();\n        const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);\n        fs.writeFileSync(outputFile, result);\n    }\n\n    private generateSchemaImport(\n        model: Model,\n        schemaObject: boolean,\n        schemaType: boolean,\n        useLite: boolean,\n        importWithFileExtension: string | undefined,\n    ) {\n        const importSpecifiers = [];\n\n        if (schemaObject) {\n            if (model.declarations.some(isEnum)) {\n                // enums require referencing the schema object\n                importSpecifiers.push(\n                    ts.factory.createImportSpecifier(\n                        false,\n                        ts.factory.createIdentifier('schema'),\n                        ts.factory.createIdentifier('$schema'),\n                    ),\n                );\n            }\n        }\n\n        if (schemaType) {\n            importSpecifiers.push(\n                ts.factory.createImportSpecifier(\n                    true,\n                    ts.factory.createIdentifier('SchemaType'),\n                    ts.factory.createIdentifier('$Schema'),\n                ),\n            );\n        }\n\n        let importFrom = useLite ? './schema-lite' : './schema';\n        if (importWithFileExtension) {\n            importFrom += importWithFileExtension.startsWith('.')\n                ? importWithFileExtension\n                : `.${importWithFileExtension}`;\n        }\n\n        // import { schema as $schema, type SchemaType as $Schema } from './schema';\n        return ts.factory.createImportDeclaration(\n            undefined,\n            ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(importSpecifiers)),\n            ts.factory.createStringLiteral(importFrom),\n        );\n    }\n\n    private generateDocs<T extends ts.TypeAliasDeclaration | ts.VariableStatement>(\n        tsDecl: T,\n        decl: DataModel | TypeDef | Enum,\n    ): T {\n        return ts.addSyntheticLeadingComment(\n            tsDecl,\n            ts.SyntaxKind.MultiLineCommentTrivia,\n            `*\\n * ${decl.comments.map((c) => c.replace(/^\\s*\\/*\\s*/, '')).join('\\n * ')}\\n `,\n            true,\n        );\n    }\n\n    private generateInputTypes(model: Model, options: TsSchemaGeneratorOptions) {\n        const dataModels = this.getAllDataModels(model);\n        const statements: ts.Statement[] = [];\n\n        // generate: import { SchemaType as $Schema } from './schema';\n        statements.push(\n            this.generateSchemaImport(\n                model,\n                false,\n                true,\n                !!(options.lite || options.liteOnly),\n                options.importWithFileExtension,\n            ),\n        );\n\n        // generate: import { CreateArgs as $CreateArgs, ... } from '@zenstackhq/orm';\n        const inputTypes = [\n            'FindManyArgs',\n            'FindUniqueArgs',\n            'FindFirstArgs',\n            'ExistsArgs',\n            'CreateArgs',\n            'CreateManyArgs',\n            'CreateManyAndReturnArgs',\n            'UpdateArgs',\n            'UpdateManyArgs',\n            'UpdateManyAndReturnArgs',\n            'UpsertArgs',\n            'DeleteArgs',\n            'DeleteManyArgs',\n            'CountArgs',\n            'AggregateArgs',\n            'GroupByArgs',\n            'WhereInput',\n            'SelectInput',\n            'IncludeInput',\n            'OmitInput',\n        ];\n\n        const inputTypeNameFixes = {\n            SelectInput: 'Select',\n            IncludeInput: 'Include',\n            OmitInput: 'Omit',\n        };\n\n        // generate: import { CreateArgs as $CreateArgs, ... } from '@zenstackhq/orm';\n        statements.push(\n            ts.factory.createImportDeclaration(\n                undefined,\n                ts.factory.createImportClause(\n                    true,\n                    undefined,\n                    ts.factory.createNamedImports([\n                        ...inputTypes.map((inputType) =>\n                            ts.factory.createImportSpecifier(\n                                false,\n                                undefined,\n                                ts.factory.createIdentifier(`${inputType} as $${inputType}`),\n                            ),\n                        ),\n                        ts.factory.createImportSpecifier(\n                            false,\n                            undefined,\n                            ts.factory.createIdentifier('QueryOptions as $QueryOptions'),\n                        ),\n                    ]),\n                ),\n                ts.factory.createStringLiteral('@zenstackhq/orm'),\n            ),\n        );\n\n        // generate: import { type SelectIncludeOmit as $SelectIncludeOmit, type SimplifiedPlainResult as $Result } from '@zenstackhq/orm';\n        statements.push(\n            ts.factory.createImportDeclaration(\n                undefined,\n                ts.factory.createImportClause(\n                    true,\n                    undefined,\n                    ts.factory.createNamedImports([\n                        ts.factory.createImportSpecifier(\n                            false,\n                            undefined,\n                            ts.factory.createIdentifier('SimplifiedPlainResult as $Result'),\n                        ),\n                        ts.factory.createImportSpecifier(\n                            false,\n                            undefined,\n                            ts.factory.createIdentifier('SelectIncludeOmit as $SelectIncludeOmit'),\n                        ),\n                    ]),\n                ),\n                ts.factory.createStringLiteral('@zenstackhq/orm'),\n            ),\n        );\n\n        for (const dm of dataModels) {\n            // generate: export type ModelCreateArgs = $CreateArgs<Schema, Model>;\n            for (const inputType of inputTypes) {\n                const exportName = inputTypeNameFixes[inputType as keyof typeof inputTypeNameFixes]\n                    ? `${dm.name}${inputTypeNameFixes[inputType as keyof typeof inputTypeNameFixes]}`\n                    : `${dm.name}${inputType}`;\n                statements.push(\n                    ts.factory.createTypeAliasDeclaration(\n                        [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],\n                        exportName,\n                        undefined,\n                        ts.factory.createTypeReferenceNode(`$${inputType}`, [\n                            ts.factory.createTypeReferenceNode('$Schema'),\n                            ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),\n                        ]),\n                    ),\n                );\n            }\n\n            // generate: export type ModelGetPayload<Args extends $SelectIncludeOmit<Schema, Model, true>, Options extends $QueryOptions<Schema>> = $Result<Schema, Model, Args, Options>;\n            statements.push(\n                ts.factory.createTypeAliasDeclaration(\n                    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],\n                    `${dm.name}GetPayload`,\n                    [\n                        ts.factory.createTypeParameterDeclaration(\n                            undefined,\n                            'Args',\n                            ts.factory.createTypeReferenceNode('$SelectIncludeOmit', [\n                                ts.factory.createTypeReferenceNode('$Schema'),\n                                ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),\n                                ts.factory.createLiteralTypeNode(ts.factory.createTrue()),\n                            ]),\n                        ),\n                        ts.factory.createTypeParameterDeclaration(\n                            undefined,\n                            'Options',\n                            ts.factory.createTypeReferenceNode('$QueryOptions', [\n                                ts.factory.createTypeReferenceNode('$Schema'),\n                            ]),\n                            ts.factory.createTypeReferenceNode('$QueryOptions', [\n                                ts.factory.createTypeReferenceNode('$Schema'),\n                            ]),\n                        ),\n                    ],\n                    ts.factory.createTypeReferenceNode('$Result', [\n                        ts.factory.createTypeReferenceNode('$Schema'),\n                        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),\n                        ts.factory.createTypeReferenceNode('Args'),\n                        ts.factory.createTypeReferenceNode('Options'),\n                    ]),\n                ),\n            );\n        }\n\n        this.generateBannerComments(statements);\n\n        // write to file\n        const outputFile = path.join(options.outDir, 'input.ts');\n        const sourceFile = ts.createSourceFile(outputFile, '', ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);\n        const printer = ts.createPrinter();\n        const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);\n        fs.writeFileSync(outputFile, result);\n    }\n}\n"],"mappings":"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","names":["isIdField","field","contextModel","hasAttribute","modelLevelIds","getModelIdFields","map","f","name","includes","allFields","getAllFields","some","length","firstUniqueField","find","modelLevelUnique","getModelUniqueFields","decl","getAttribute","attributes","attr","$refText","isDelegateModel","node","isDataModel","getOwnedFields","model","fields","mixin","mixins","ref","push","getDelegateOriginModel","base","baseModel","undefined","isUniqueField","modelIds","$container","args","arg","isLiteralExpr","value","isFromStdlib","getContainingModel","$document","uri","path","endsWith","isModel","resolved","Error","getAuthDecl","found","declarations","d","isTypeDef","getIdFields","dm","filter","DELEGATE_AUX_RELATION_PREFIX","import_ast","import_utils","string","count","indent","replace","repeat","indentString","PrismaModel","datasources","generators","models","enums","addDataSource","name","fields","ds","DataSource","push","addGenerator","generator","Generator","addModel","model","Model","addView","addEnum","e","Enum","toString","map","d","join","f","indentString","text","DeclarationBase","documentations","addComment","x","ContainerDeclaration","attributes","FieldDeclaration","isView","addField","type","addToFront","field","ModelField","unshift","addAttribute","args","attr","ContainerAttribute","result","length","ModelFieldType","array","optional","FieldAttribute","a","AttributeArg","name","value","toString","AttributeArgValue","type","Error","Array","isArray","FieldReference","FunctionCall","JSON","stringify","fr","r","field","args","length","map","a","join","v","FieldReferenceArg","func","FunctionCallArg","Enum","ContainerDeclaration","fields","documentations","addField","attributes","EnumField","push","addAttribute","attr","ContainerAttribute","addComment","indentString","d","DeclarationBase","FieldAttribute","IDENTIFIER_NAME_MAX_LENGTH","DELEGATE_AUX_RELATION_PREFIX","length","NON_PRISMA_DATASOURCE_FIELDS","PrismaSchemaGenerator","PRELUDE","shortNameMap","Map","zmodel","generate","prisma","PrismaModel","decl","declarations","$type","DataSource","generateDataSource","Enum","generateEnum","DataModel","generateModel","GeneratorDecl","generateGenerator","some","isGeneratorDecl","generateDefaultGenerator","toString","dataSource","fields","filter","f","includes","name","map","text","configExprToText","value","addDataSource","expr","isLiteralExpr","literalToText","isInvocationExpr","fc","makeFunctionCall","configArrayToText","items","item","args","arg","configInvocationArgToText","join","JSON","stringify","addGenerator","gen","previewFeatures","find","isDataSource","push","d","isDataModel","isView","model","addView","addModel","allFields","getAllFields","field","ModelUtils","hasAttribute","isIdField","getDelegateOriginModel","generateModelField","allAttributes","getAllAttributes","attr","isPrismaAttribute","generateContainerAttribute","datasourceHasSchemasSetting","$container","ref","addAttribute","PrismaAttributeArg","undefined","PrismaAttributeArgValue","getDefaultPostgresSchemaName","comments","forEach","c","addComment","generateDelegateRelationForBase","generateDelegateRelationForConcrete","getDatasourceField","fieldName","defaultSchemaField","getStringLiteral","attributes","a","getUnsupportedFieldType","fieldType","unsupported","contextModel","addToFront","type","reference","isTypeDef","Error","isArray","array","ModelFieldType","optional","isDefaultWithAuthInvocation","$refText","makeFieldAttribute","docs","result","addField","AstUtils","streamAst","isAuthInvocation","attrName","PrismaFieldAttribute","makeAttributeArg","makeAttributeArgValue","node","argType","match","with","StringLiteral","NumberLiteral","BooleanLiteral","exhaustive","isArrayExpr","Array","isReferenceExpr","PrismaFieldReference","target","PrismaFieldReferenceArg","exprToText","ZModelCodeGenerator","quote","PrismaFunctionCall","function","val","when","isStringLiteral","v","isNullExpr","otherwise","PrismaFunctionCallArg","container","PrismaModelAttribute","_enum","addEnum","generateEnumField","isDelegateModel","concreteModels","getConcreteModels","concrete","auxName","truncate","lowerCaseFirst","concreteDecl","base","baseModel","idFields","getIdFields","relationField","AttributeArgValue","idField","dataModel","existing","get","baseName","slice","index","shortName","conflict","from","values","set","import_common_helpers","import_ast","import_utils","import_ts_pattern","TsSchemaGenerator","usedExpressionUtils","usedAttributeApplication","usedFieldDefault","generate","model","options","fs","mkdirSync","outDir","recursive","generateSchema","generateModelTypes","generateModelsAndTypeDefs","generateInputTypes","targets","liteOnly","push","lite","file","statements","generateSchemaStatements","generateBannerComments","schemaOutputFile","path","join","sourceFile","createSourceFile","ScriptTarget","ESNext","ScriptKind","TS","printer","createPrinter","result","printList","ListFormat","MultiLine","factory","createNodeArray","writeFileSync","schemaClass","createSchemaClass","schemaImportDecl","createImportDeclaration","undefined","createImportClause","createNamedImports","createImportSpecifier","createIdentifier","createStringLiteral","schemaDecl","createVariableStatement","createModifier","SyntaxKind","ExportKeyword","createVariableDeclarationList","createVariableDeclaration","createNewExpression","NodeFlags","Const","createExpressionUtilsCall","method","args","createCallExpression","createPropertyAccessExpression","members","createPropertyDeclaration","createAsConst","createProviderObject","createModelsObject","declarations","some","isTypeDef","createTypeDefsObject","enums","filter","isEnum","length","createObjectLiteralExpression","map","e","createPropertyAssignment","name","createEnumObject","authType","getAuthDecl","createLiteralNode","procedures","isProcedure","createProceduresObject","createClassDeclaration","createHeritageClause","ImplementsKeyword","createExpressionWithTypeArguments","expr","createAsExpression","createTypeReferenceNode","createAttributesTypeAssertion","createTypeOperatorNode","ReadonlyKeyword","createArrayTypeNode","createDefaultTypeAssertion","dsProvider","getDataSourceProvider","defaultSchema","getDataSourceDefaultSchema","getAllDataModels","dm","createDataModelObject","d","isDataModel","hasAttribute","getAllTypeDefs","td","createTypeDefObject","allFields","getAllFields","allAttributes","getAllAttributes","attr","decl","$refText","$container","subModels","getSubModels","fields","baseModel","field","createDataFieldObject","createArrayLiteralExpression","createAttributeObject","getIdFields","idField","createUniqueFieldsObject","isDelegateModel","createTrue","subModel","isView","computedFields","f","createComputedFieldsObject","ref","createMethodDeclaration","createParameterDeclaration","createTypeLiteralNode","createPropertySignature","createKeywordTypeNode","StringKeyword","mapFieldTypeToTSType","type","createBlock","createThrowStatement","createUpdatedAtObject","ignoreArg","value","items","item","target","match","with","otherwise","array","optional","contextModel","objectFields","generateFieldTypeLiteral","ModelUtils","isIdField","isUniqueField","updatedAtAttrib","getAttribute","find","arg","$resolvedParam","delegateOrigin","getDelegateOriginModel","isDiscriminatorField","attributes","defaultValue","getFieldMappedDefault","defaultExpr","Array","isArray","call","authMember","m","Error","reference","createRelationObject","fkFor","getForeignKeyFor","fk","origin","isDataFieldReference","dataSource","isDataSource","invariant","providerExpr","isLiteralExpr","defaultSchemaExpr","defaultAttr","getMappedValue","fieldType","lit","includes","Number","isArrayExpr","isReferenceExpr","isEnumField","isInvocationExpr","function","getLiteral","isAuthMemberAccess","getMemberAccessChain","isNullExpr","$type","isMemberAccessExpr","operand","member","isAuthInvocation","isFromStdlib","relationFields","oppositeRelation","getOppositeRelationField","relationName","getRelationName","relation","fkFields","param","fieldNames","getReferenceNames","el","action","allHaveDefault","every","fieldName","fieldDef","sourceModel","targetModel","otherField","otherRelationName","nameArg","properties","seenKeys","Set","fieldsArg","getAttributeArg","key","getCompoundUniqueKey","has","add","unsupported","parseFloat","createNull","createNumberLiteral","createFalse","createPrefixUnaryExpression","MinusToken","createNumericLiteral","proc","createProcedureObject","params","returnType","mutation","banner","ts","addSyntheticLeadingComment","SingleLineCommentTrivia","createAttributeArg","createExpression","when","createLiteralExpression","createRefExpression","createArrayExpression","isUnaryExpr","createUnaryExpression","isBinaryExpr","createBinaryExpression","createMemberExpression","createNullExpression","isThisExpr","createThisExpression","current","unshift","receiver","left","operator","right","binding","arrayResolved","$resolvedType","arrayType","isDataField","isCollectionPredicateBinding","generateSchemaImport","importWithFileExtension","dataModels","modelType","createTypeAliasDeclaration","createLiteralTypeNode","comments","generateDocs","typeDefs","typeDef","enumDecl","typeAlias","createIndexedAccessTypeNode","createTypeQueryNode","KeyOfKeyword","outputFile","schemaObject","schemaType","useLite","importSpecifiers","importFrom","startsWith","tsDecl","MultiLineCommentTrivia","c","replace","inputTypes","inputTypeNameFixes","SelectInput","IncludeInput","OmitInput","inputType","exportName","createTypeParameterDeclaration"]}