@zenstackhq/sdk 3.5.6 → 3.6.0

package/dist/index.mjs

@@ -0,0 +1,1148 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { BooleanLiteral, DataModel, DataSource, Enum, GeneratorDecl, NumberLiteral, StringLiteral, isArrayExpr, isBinaryExpr, isCollectionPredicateBinding, isDataField, isDataModel, isDataSource, isEnum, isEnumField, isGeneratorDecl, isInvocationExpr, isLiteralExpr, isMemberAccessExpr, isModel, isNullExpr, isProcedure, isReferenceExpr, isStringLiteral, isThisExpr, isTypeDef, isUnaryExpr } from "@zenstackhq/language/ast";
+import { getAllAttributes, getAllFields, getAttributeArg, getModelIdFields, getModelUniqueFields, getStringLiteral, isAuthInvocation, isDataFieldReference, isDelegateModel } from "@zenstackhq/language/utils";
+import { invariant, lowerCaseFirst } from "@zenstackhq/common-helpers";
+import { ZModelCodeGenerator } from "@zenstackhq/language";
+import { AstUtils } from "langium";
+import { match } from "ts-pattern";
+import fs from "node:fs";
+import path from "node:path";
+import * as ts from "typescript";
+//#region src/model-utils.ts
+var model_utils_exports = /* @__PURE__ */ __exportAll({
+	DELEGATE_AUX_RELATION_PREFIX: () => DELEGATE_AUX_RELATION_PREFIX,
+	getAttribute: () => getAttribute,
+	getAuthDecl: () => getAuthDecl,
+	getContainingModel: () => getContainingModel,
+	getDelegateOriginModel: () => getDelegateOriginModel,
+	getIdFields: () => getIdFields,
+	getOwnedFields: () => getOwnedFields,
+	hasAttribute: () => hasAttribute,
+	isDelegateModel: () => isDelegateModel$1,
+	isFromStdlib: () => isFromStdlib,
+	isIdField: () => isIdField,
+	isUniqueField: () => isUniqueField,
+	resolved: () => resolved
+});
+function isIdField(field, contextModel) {
+	if (hasAttribute(field, "@id")) return true;
+	const modelLevelIds = getModelIdFields(contextModel);
+	if (modelLevelIds.map((f) => f.name).includes(field.name)) return true;
+	const allFields = getAllFields(contextModel);
+	if (allFields.some((f) => hasAttribute(f, "@id")) || modelLevelIds.length > 0) return false;
+	const firstUniqueField = allFields.find((f) => hasAttribute(f, "@unique"));
+	if (firstUniqueField) return firstUniqueField.name === field.name;
+	if (getModelUniqueFields(contextModel).map((f) => f.name).includes(field.name)) return true;
+	return false;
+}
+function hasAttribute(decl, name) {
+	return !!getAttribute(decl, name);
+}
+function getAttribute(decl, name) {
+	return decl.attributes.find((attr) => attr.decl.$refText === name);
+}
+function isDelegateModel$1(node) {
+	return isDataModel(node) && hasAttribute(node, "@@delegate");
+}
+/**
+* Returns all fields that physically belong to a model's table: its directly declared
+* fields plus fields from its mixins (recursively).
+*/
+function getOwnedFields(model) {
+	const fields = [...model.fields];
+	for (const mixin of model.mixins) if (mixin.ref) fields.push(...getOwnedFields(mixin.ref));
+	return fields;
+}
+/**
+* Returns the name of the delegate base model that "owns" the given field in the context of
+* `contextModel`. This handles both direct fields of delegate models and mixin fields that
+* belong to a mixin used by a delegate base model.
+*/
+function getDelegateOriginModel(field, contextModel) {
+	let base = contextModel.baseModel?.ref;
+	while (base) {
+		if (isDelegateModel$1(base) && getOwnedFields(base).some((f) => f.name === field.name)) return base.name;
+		base = base.baseModel?.ref;
+	}
+}
+function isUniqueField(field) {
+	if (hasAttribute(field, "@unique")) return true;
+	const modelIds = getAttribute(field.$container, "@@unique");
+	if (modelIds && modelIds.args.some((arg) => isLiteralExpr(arg.value) && arg.value.value === field.name)) return true;
+	return false;
+}
+function isFromStdlib(node) {
+	const model = getContainingModel(node);
+	return !!model && !!model.$document && model.$document.uri.path.endsWith("stdlib.zmodel");
+}
+function getContainingModel(node) {
+	if (!node) return null;
+	return isModel(node) ? node : getContainingModel(node.$container);
+}
+function resolved(ref) {
+	if (!ref.ref) throw new Error(`Reference not resolved: ${ref.$refText}`);
+	return ref.ref;
+}
+function getAuthDecl(model) {
+	let found = model.declarations.find((d) => (isDataModel(d) || isTypeDef(d)) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
+	if (!found) found = model.declarations.find((d) => (isDataModel(d) || isTypeDef(d)) && d.name === "User");
+	return found;
+}
+function getIdFields(dm) {
+	return getAllFields(dm).filter((f) => isIdField(f, dm)).map((f) => f.name);
+}
+/**
+* Prefix for auxiliary relation fields generated for delegated models
+*/
+const DELEGATE_AUX_RELATION_PREFIX = "delegate_aux";
+//#endregion
+//#region src/prisma/indent-string.ts
+/**
+* Utility for indenting strings
+*/
+function indentString(string, count = 4) {
+	return string.replace(/^(?!\s*$)/gm, " ".repeat(count));
+}
+//#endregion
+//#region src/prisma/prisma-builder.ts
+/**
+* Prisma schema builder
+*/
+var PrismaModel = class {
+	datasources = [];
+	generators = [];
+	models = [];
+	enums = [];
+	addDataSource(name, fields = []) {
+		const ds = new DataSource$1(name, fields);
+		this.datasources.push(ds);
+		return ds;
+	}
+	addGenerator(name, fields) {
+		const generator = new Generator(name, fields);
+		this.generators.push(generator);
+		return generator;
+	}
+	addModel(name) {
+		const model = new Model$1(name, false);
+		this.models.push(model);
+		return model;
+	}
+	addView(name) {
+		const model = new Model$1(name, true);
+		this.models.push(model);
+		return model;
+	}
+	addEnum(name) {
+		const e = new Enum$1(name);
+		this.enums.push(e);
+		return e;
+	}
+	toString() {
+		return [
+			...this.datasources,
+			...this.generators,
+			...this.enums,
+			...this.models
+		].map((d) => d.toString()).join("\n\n");
+	}
+};
+var DataSource$1 = class {
+	constructor(name, fields = []) {
+		this.name = name;
+		this.fields = fields;
+	}
+	toString() {
+		return `datasource ${this.name} {\n` + this.fields.map((f) => indentString(`${f.name} = ${f.text}`)).join("\n") + `\n}`;
+	}
+};
+var Generator = class {
+	constructor(name, fields) {
+		this.name = name;
+		this.fields = fields;
+	}
+	toString() {
+		return `generator ${this.name} {\n` + this.fields.map((f) => indentString(`${f.name} = ${f.text}`)).join("\n") + `\n}`;
+	}
+};
+var DeclarationBase = class {
+	constructor(documentations = []) {
+		this.documentations = documentations;
+	}
+	addComment(name) {
+		this.documentations.push(name);
+		return name;
+	}
+	toString() {
+		return this.documentations.map((x) => `${x}\n`).join("");
+	}
+};
+var ContainerDeclaration = class extends DeclarationBase {
+	constructor(documentations = [], attributes = []) {
+		super(documentations);
+		this.attributes = attributes;
+	}
+};
+var FieldDeclaration = class extends DeclarationBase {
+	constructor(documentations = [], attributes = []) {
+		super(documentations);
+		this.attributes = attributes;
+	}
+};
+var Model$1 = class extends ContainerDeclaration {
+	fields = [];
+	constructor(name, isView, documentations = []) {
+		super(documentations);
+		this.name = name;
+		this.isView = isView;
+	}
+	addField(name, type, attributes = [], documentations = [], addToFront = false) {
+		const field = new ModelField(name, type, attributes, documentations);
+		if (addToFront) this.fields.unshift(field);
+		else this.fields.push(field);
+		return field;
+	}
+	addAttribute(name, args = []) {
+		const attr = new ContainerAttribute(name, args);
+		this.attributes.push(attr);
+		return attr;
+	}
+	toString() {
+		const result = [...this.fields];
+		if (this.attributes.length > 0) result.push("");
+		result.push(...this.attributes);
+		return super.toString() + `${this.isView ? "view" : "model"} ${this.name} {\n` + indentString(result.map((d) => d.toString()).join("\n")) + `\n}`;
+	}
+};
+var ModelFieldType = class {
+	constructor(type, array, optional) {
+		this.type = type;
+		this.array = array;
+		this.optional = optional;
+	}
+	toString() {
+		return `${this.type}${this.array ? "[]" : ""}${this.optional ? "?" : ""}`;
+	}
+};
+var ModelField = class extends FieldDeclaration {
+	constructor(name, type, attributes = [], documentations = []) {
+		super(documentations, attributes);
+		this.name = name;
+		this.type = type;
+	}
+	addAttribute(name, args = []) {
+		const attr = new FieldAttribute(name, args);
+		this.attributes.push(attr);
+		return attr;
+	}
+	toString() {
+		return super.toString() + `${this.name} ${this.type}` + (this.attributes.length > 0 ? " " + this.attributes.map((a) => a.toString()).join(" ") : "");
+	}
+};
+var FieldAttribute = class {
+	constructor(name, args = []) {
+		this.name = name;
+		this.args = args;
+	}
+	toString() {
+		return `${this.name}(` + this.args.map((a) => a.toString()).join(", ") + `)`;
+	}
+};
+var ContainerAttribute = class {
+	constructor(name, args = []) {
+		this.name = name;
+		this.args = args;
+	}
+	toString() {
+		return `${this.name}(` + this.args.map((a) => a.toString()).join(", ") + `)`;
+	}
+};
+var AttributeArg = class {
+	constructor(name, value) {
+		this.name = name;
+		this.value = value;
+	}
+	toString() {
+		return this.name ? `${this.name}: ${this.value}` : this.value.toString();
+	}
+};
+var AttributeArgValue = class {
+	constructor(type, value) {
+		this.type = type;
+		this.value = value;
+		switch (type) {
+			case "String":
+				if (typeof value !== "string") throw new Error("Value must be string");
+				break;
+			case "Number":
+				if (typeof value !== "number" && typeof value !== "string") throw new Error("Value must be number or string");
+				break;
+			case "Boolean":
+				if (typeof value !== "boolean") throw new Error("Value must be boolean");
+				break;
+			case "Array":
+				if (!Array.isArray(value)) throw new Error("Value must be array");
+				break;
+			case "FieldReference":
+				if (typeof value !== "string" && !(value instanceof FieldReference)) throw new Error("Value must be string or FieldReference");
+				break;
+			case "FunctionCall":
+				if (!(value instanceof FunctionCall)) throw new Error("Value must be FunctionCall");
+				break;
+		}
+	}
+	toString() {
+		switch (this.type) {
+			case "String": return JSON.stringify(this.value);
+			case "Number": return this.value.toString();
+			case "FieldReference": if (typeof this.value === "string") return this.value;
+			else {
+				const fr = this.value;
+				let r = fr.field;
+				if (fr.args.length > 0) r += "(" + fr.args.map((a) => a.toString()).join(",") + ")";
+				return r;
+			}
+			case "FunctionCall": return this.value.toString();
+			case "Boolean": return this.value ? "true" : "false";
+			case "Array": return "[" + this.value.map((v) => v.toString()).join(", ") + "]";
+			default: throw new Error(`Unknown attribute value type ${this.type}`);
+		}
+	}
+};
+var FieldReference = class {
+	constructor(field, args = []) {
+		this.field = field;
+		this.args = args;
+	}
+};
+var FieldReferenceArg = class {
+	constructor(name, value) {
+		this.name = name;
+		this.value = value;
+	}
+	toString() {
+		return `${this.name}: ${this.value}`;
+	}
+};
+var FunctionCall = class {
+	constructor(func, args = []) {
+		this.func = func;
+		this.args = args;
+	}
+	toString() {
+		return `${this.func}(` + this.args.map((a) => a.toString()).join(", ") + ")";
+	}
+};
+var FunctionCallArg = class {
+	constructor(value) {
+		this.value = value;
+	}
+	toString() {
+		return this.value;
+	}
+};
+var Enum$1 = class extends ContainerDeclaration {
+	fields = [];
+	constructor(name, documentations = []) {
+		super(documentations);
+		this.name = name;
+	}
+	addField(name, attributes = [], documentations = []) {
+		const field = new EnumField$1(name, attributes, documentations);
+		this.fields.push(field);
+		return field;
+	}
+	addAttribute(name, args = []) {
+		const attr = new ContainerAttribute(name, args);
+		this.attributes.push(attr);
+		return attr;
+	}
+	addComment(name) {
+		this.documentations.push(name);
+		return name;
+	}
+	toString() {
+		return super.toString() + `enum ${this.name} {\n` + indentString([...this.fields, ...this.attributes].map((d) => d.toString()).join("\n")) + "\n}";
+	}
+};
+var EnumField$1 = class extends DeclarationBase {
+	constructor(name, attributes = [], documentations = []) {
+		super(documentations);
+		this.name = name;
+		this.attributes = attributes;
+	}
+	addAttribute(name, args = []) {
+		const attr = new FieldAttribute(name, args);
+		this.attributes.push(attr);
+		return attr;
+	}
+	toString() {
+		return super.toString() + this.name + (this.attributes.length > 0 ? " " + this.attributes.map((a) => a.toString()).join(" ") : "");
+	}
+};
+//#endregion
+//#region src/prisma/prisma-schema-generator.ts
+const IDENTIFIER_NAME_MAX_LENGTH = 38;
+const NON_PRISMA_DATASOURCE_FIELDS = ["defaultSchema"];
+/**
+* Generates Prisma schema file
+*/
+var PrismaSchemaGenerator = class {
+	PRELUDE = `//////////////////////////////////////////////////////////////////////////////////////////////
+// DO NOT MODIFY THIS FILE                                                                  //
+// This file is automatically generated by ZenStack CLI and should not be manually updated. //
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+`;
+	shortNameMap = /* @__PURE__ */ new Map();
+	constructor(zmodel) {
+		this.zmodel = zmodel;
+	}
+	async generate() {
+		const prisma = new PrismaModel();
+		for (const decl of this.zmodel.declarations) switch (decl.$type) {
+			case DataSource:
+				this.generateDataSource(prisma, decl);
+				break;
+			case Enum:
+				this.generateEnum(prisma, decl);
+				break;
+			case DataModel:
+				this.generateModel(prisma, decl);
+				break;
+			case GeneratorDecl:
+				this.generateGenerator(prisma, decl);
+				break;
+		}
+		if (!this.zmodel.declarations.some(isGeneratorDecl)) this.generateDefaultGenerator(prisma);
+		return this.PRELUDE + prisma.toString();
+	}
+	generateDataSource(prisma, dataSource) {
+		const fields = dataSource.fields.filter((f) => !NON_PRISMA_DATASOURCE_FIELDS.includes(f.name)).map((f) => ({
+			name: f.name,
+			text: this.configExprToText(f.value)
+		}));
+		prisma.addDataSource(dataSource.name, fields);
+	}
+	configExprToText(expr) {
+		if (isLiteralExpr(expr)) return this.literalToText(expr);
+		else if (isInvocationExpr(expr)) return this.makeFunctionCall(expr).toString();
+		else return this.configArrayToText(expr);
+	}
+	configArrayToText(expr) {
+		return "[" + expr.items.map((item) => {
+			if (isLiteralExpr(item)) return this.literalToText(item);
+			else return item.name + (item.args.length > 0 ? "(" + item.args.map((arg) => this.configInvocationArgToText(arg)).join(", ") + ")" : "");
+		}).join(", ") + "]";
+	}
+	configInvocationArgToText(arg) {
+		return `${arg.name}: ${this.literalToText(arg.value)}`;
+	}
+	literalToText(expr) {
+		return JSON.stringify(expr.value);
+	}
+	generateGenerator(prisma, decl) {
+		prisma.addGenerator(decl.name, decl.fields.map((f) => ({
+			name: f.name,
+			text: this.configExprToText(f.value)
+		})));
+	}
+	generateDefaultGenerator(prisma) {
+		const gen = prisma.addGenerator("client", [{
+			name: "provider",
+			text: "\"prisma-client-js\""
+		}]);
+		const previewFeatures = [];
+		if (this.zmodel.declarations.find(isDataSource)?.fields.some((f) => f.name === "extensions")) previewFeatures.push("postgresqlExtensions");
+		if (this.zmodel.declarations.some((d) => isDataModel(d) && d.isView)) previewFeatures.push("views");
+		if (previewFeatures.length > 0) gen.fields.push({
+			name: "previewFeatures",
+			text: JSON.stringify(previewFeatures)
+		});
+	}
+	generateModel(prisma, decl) {
+		const model = decl.isView ? prisma.addView(decl.name) : prisma.addModel(decl.name);
+		const allFields = getAllFields(decl, true);
+		for (const field of allFields) {
+			if (hasAttribute(field, "@computed")) continue;
+			if (isIdField(field, decl) || !getDelegateOriginModel(field, decl)) this.generateModelField(model, field, decl);
+		}
+		const allAttributes = getAllAttributes(decl).filter((attr) => this.isPrismaAttribute(attr));
+		for (const attr of allAttributes) this.generateContainerAttribute(model, attr);
+		if (this.datasourceHasSchemasSetting(decl.$container) && !allAttributes.some((attr) => attr.decl.ref?.name === "@@schema")) model.addAttribute("@@schema", [new AttributeArg(void 0, new AttributeArgValue("String", this.getDefaultPostgresSchemaName(decl.$container)))]);
+		decl.comments.forEach((c) => model.addComment(c));
+		this.generateDelegateRelationForBase(model, decl);
+		this.generateDelegateRelationForConcrete(model, decl);
+	}
+	getDatasourceField(zmodel, fieldName) {
+		return zmodel.declarations.find(isDataSource)?.fields.find((f) => f.name === fieldName);
+	}
+	datasourceHasSchemasSetting(zmodel) {
+		return !!this.getDatasourceField(zmodel, "schemas");
+	}
+	getDefaultPostgresSchemaName(zmodel) {
+		return getStringLiteral(this.getDatasourceField(zmodel, "defaultSchema")?.value) ?? "public";
+	}
+	isPrismaAttribute(attr) {
+		if (!attr.decl.ref) return false;
+		return attr.decl.ref.attributes.some((a) => a.decl.ref?.name === "@@@prisma");
+	}
+	getUnsupportedFieldType(fieldType) {
+		if (fieldType.unsupported) {
+			const value = getStringLiteral(fieldType.unsupported.value);
+			if (value) return `Unsupported("${value}")`;
+			else return;
+		} else return;
+	}
+	generateModelField(model, field, contextModel, addToFront = false) {
+		let fieldType;
+		if (field.type.type) fieldType = field.type.type;
+		else if (field.type.reference?.ref) if (isTypeDef(field.type.reference.ref)) fieldType = "Json";
+		else fieldType = field.type.reference.ref.name;
+		else {
+			const unsupported = this.getUnsupportedFieldType(field.type);
+			if (unsupported) fieldType = unsupported;
+		}
+		if (!fieldType) throw new Error(`Field type is not resolved: ${field.$container.name}.${field.name}`);
+		const isArray = isTypeDef(field.type.reference?.ref) ? false : field.type.array;
+		const type = new ModelFieldType(fieldType, isArray, field.type.optional);
+		const attributes = field.attributes.filter((attr) => this.isPrismaAttribute(attr)).filter((attr) => !this.isDefaultWithAuthInvocation(attr)).filter((attr) => !(isIdField(field, contextModel) && getDelegateOriginModel(field, contextModel) && attr.decl.$refText === "@default")).map((attr) => this.makeFieldAttribute(attr));
+		const docs = [...field.comments];
+		return model.addField(field.name, type, attributes, docs, addToFront);
+	}
+	isDefaultWithAuthInvocation(attr) {
+		if (attr.decl.ref?.name !== "@default") return false;
+		const expr = attr.args[0]?.value;
+		if (!expr) return false;
+		return AstUtils.streamAst(expr).some(isAuthInvocation);
+	}
+	makeFieldAttribute(attr) {
+		const attrName = attr.decl.ref.name;
+		return new FieldAttribute(attrName, attr.args.map((arg) => this.makeAttributeArg(arg)));
+	}
+	makeAttributeArg(arg) {
+		return new AttributeArg(arg.name, this.makeAttributeArgValue(arg.value));
+	}
+	makeAttributeArgValue(node) {
+		if (isLiteralExpr(node)) return new AttributeArgValue(match(node.$type).with(StringLiteral, () => "String").with(NumberLiteral, () => "Number").with(BooleanLiteral, () => "Boolean").exhaustive(), node.value);
+		else if (isArrayExpr(node)) return new AttributeArgValue("Array", new Array(...node.items.map((item) => this.makeAttributeArgValue(item))));
+		else if (isReferenceExpr(node)) return new AttributeArgValue("FieldReference", new FieldReference(node.target.ref.name, node.args.map((arg) => new FieldReferenceArg(arg.name, this.exprToText(arg.value)))));
+		else if (isInvocationExpr(node)) return new AttributeArgValue("FunctionCall", this.makeFunctionCall(node));
+		else throw Error(`Unsupported attribute argument expression type: ${node.$type}`);
+	}
+	exprToText(expr) {
+		return new ZModelCodeGenerator({ quote: "double" }).generate(expr);
+	}
+	makeFunctionCall(node) {
+		return new FunctionCall(node.function.ref.name, node.args.map((arg) => {
+			return new FunctionCallArg(match(arg.value).when(isStringLiteral, (v) => `"${v.value}"`).when(isLiteralExpr, (v) => v.value.toString()).when(isNullExpr, () => "null").otherwise(() => {
+				throw new Error("Function call argument must be literal or null");
+			}));
+		}));
+	}
+	generateContainerAttribute(container, attr) {
+		const attrName = attr.decl.ref.name;
+		container.attributes.push(new ContainerAttribute(attrName, attr.args.map((arg) => this.makeAttributeArg(arg))));
+	}
+	generateEnum(prisma, decl) {
+		const _enum = prisma.addEnum(decl.name);
+		for (const field of decl.fields) this.generateEnumField(_enum, field);
+		const allAttributes = decl.attributes.filter((attr) => this.isPrismaAttribute(attr));
+		for (const attr of allAttributes) this.generateContainerAttribute(_enum, attr);
+		if (this.datasourceHasSchemasSetting(decl.$container) && !allAttributes.some((attr) => attr.decl.ref?.name === "@@schema")) _enum.addAttribute("@@schema", [new AttributeArg(void 0, new AttributeArgValue("String", this.getDefaultPostgresSchemaName(decl.$container)))]);
+		decl.comments.forEach((c) => _enum.addComment(c));
+	}
+	generateEnumField(_enum, field) {
+		const attributes = field.attributes.filter((attr) => this.isPrismaAttribute(attr)).map((attr) => this.makeFieldAttribute(attr));
+		const docs = [...field.comments];
+		_enum.addField(field.name, attributes, docs);
+	}
+	generateDelegateRelationForBase(model, decl) {
+		if (!isDelegateModel(decl)) return;
+		this.getConcreteModels(decl).forEach((concrete) => {
+			const auxName = this.truncate(`${DELEGATE_AUX_RELATION_PREFIX}_${lowerCaseFirst(concrete.name)}`);
+			model.addField(auxName, new ModelFieldType(concrete.name, false, true));
+		});
+	}
+	generateDelegateRelationForConcrete(model, concreteDecl) {
+		const base = concreteDecl.baseModel?.ref;
+		if (!base) return;
+		const idFields = getIdFields(base);
+		const relationField = this.truncate(`${DELEGATE_AUX_RELATION_PREFIX}_${lowerCaseFirst(base.name)}`);
+		model.addField(relationField, base.name, [new FieldAttribute("@relation", [
+			new AttributeArg("fields", new AttributeArgValue("Array", idFields.map((idField) => new AttributeArgValue("FieldReference", new FieldReference(idField))))),
+			new AttributeArg("references", new AttributeArgValue("Array", idFields.map((idField) => new AttributeArgValue("FieldReference", new FieldReference(idField))))),
+			new AttributeArg("onDelete", new AttributeArgValue("FieldReference", new FieldReference("Cascade"))),
+			new AttributeArg("onUpdate", new AttributeArgValue("FieldReference", new FieldReference("Cascade")))
+		])]);
+	}
+	getConcreteModels(dataModel) {
+		if (!isDelegateModel(dataModel)) return [];
+		return dataModel.$container.declarations.filter((d) => isDataModel(d) && d !== dataModel && d.baseModel?.ref === dataModel);
+	}
+	truncate(name) {
+		if (name.length <= IDENTIFIER_NAME_MAX_LENGTH) return name;
+		const existing = this.shortNameMap.get(name);
+		if (existing) return existing;
+		const baseName = name.slice(0, IDENTIFIER_NAME_MAX_LENGTH);
+		let index = 0;
+		let shortName = `${baseName}_${index}`;
+		while (true) {
+			if (!Array.from(this.shortNameMap.values()).find((v) => v === shortName)) {
+				this.shortNameMap.set(name, shortName);
+				break;
+			}
+			index++;
+			shortName = `${baseName}_${index}`;
+		}
+		return shortName;
+	}
+};
+//#endregion
+//#region src/ts-schema-generator.ts
+var TsSchemaGenerator = class {
+	usedExpressionUtils = false;
+	usedAttributeApplication = false;
+	usedFieldDefault = false;
+	async generate(model, options) {
+		fs.mkdirSync(options.outDir, { recursive: true });
+		this.generateSchema(model, options);
+		if (options.generateModelTypes !== false) this.generateModelsAndTypeDefs(model, options);
+		if (options.generateInputTypes !== false) this.generateInputTypes(model, options);
+	}
+	generateSchema(model, options) {
+		const targets = [];
+		if (!options.liteOnly) targets.push({
+			lite: false,
+			file: "schema.ts"
+		});
+		if (options.lite || options.liteOnly) targets.push({
+			lite: true,
+			file: "schema-lite.ts"
+		});
+		for (const { lite, file } of targets) {
+			this.usedExpressionUtils = false;
+			this.usedAttributeApplication = false;
+			this.usedFieldDefault = false;
+			const statements = [];
+			this.generateSchemaStatements(model, statements, lite);
+			this.generateBannerComments(statements);
+			const schemaOutputFile = path.join(options.outDir, file);
+			const sourceFile = ts.createSourceFile(schemaOutputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+			const result = ts.createPrinter().printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
+			fs.writeFileSync(schemaOutputFile, result);
+		}
+	}
+	generateSchemaStatements(model, statements, lite) {
+		const schemaClass = this.createSchemaClass(model, lite);
+		const schemaImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(void 0, void 0, ts.factory.createNamedImports([
+			ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("SchemaDef")),
+			...this.usedAttributeApplication ? [ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("AttributeApplication"))] : [],
+			...this.usedFieldDefault ? [ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("FieldDefault"))] : [],
+			...this.usedExpressionUtils ? [ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("ExpressionUtils"))] : []
+		])), ts.factory.createStringLiteral("@zenstackhq/schema"));
+		statements.push(schemaImportDecl);
+		statements.push(schemaClass);
+		const schemaDecl = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration("schema", void 0, void 0, ts.factory.createNewExpression(ts.factory.createIdentifier("SchemaType"), void 0, []))], ts.NodeFlags.Const));
+		statements.push(schemaDecl);
+	}
+	createExpressionUtilsCall(method, args) {
+		this.usedExpressionUtils = true;
+		return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("ExpressionUtils"), method), void 0, args || []);
+	}
+	createSchemaClass(model, lite) {
+		const members = [
+			ts.factory.createPropertyDeclaration(void 0, "provider", void 0, void 0, this.createAsConst(this.createProviderObject(model))),
+			ts.factory.createPropertyDeclaration(void 0, "models", void 0, void 0, this.createAsConst(this.createModelsObject(model, lite))),
+			...model.declarations.some(isTypeDef) ? [ts.factory.createPropertyDeclaration(void 0, "typeDefs", void 0, void 0, this.createAsConst(this.createTypeDefsObject(model, lite)))] : []
+		];
+		const enums = model.declarations.filter(isEnum);
+		if (enums.length > 0) members.push(ts.factory.createPropertyDeclaration(void 0, "enums", void 0, void 0, this.createAsConst(ts.factory.createObjectLiteralExpression(enums.map((e) => ts.factory.createPropertyAssignment(e.name, this.createEnumObject(e))), true))));
+		const authType = getAuthDecl(model);
+		if (authType) members.push(ts.factory.createPropertyDeclaration(void 0, "authType", void 0, void 0, this.createAsConst(this.createLiteralNode(authType.name))));
+		const procedures = model.declarations.filter(isProcedure);
+		if (procedures.length > 0) members.push(ts.factory.createPropertyDeclaration(void 0, "procedures", void 0, void 0, this.createAsConst(this.createProceduresObject(procedures))));
+		members.push(ts.factory.createPropertyDeclaration(void 0, "plugins", void 0, void 0, ts.factory.createObjectLiteralExpression([], true)));
+		return ts.factory.createClassDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], "SchemaType", void 0, [ts.factory.createHeritageClause(ts.SyntaxKind.ImplementsKeyword, [ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier("SchemaDef"), void 0)])], members);
+	}
+	createAsConst(expr) {
+		return ts.factory.createAsExpression(expr, ts.factory.createTypeReferenceNode("const"));
+	}
+	createAttributesTypeAssertion(expr) {
+		this.usedAttributeApplication = true;
+		return ts.factory.createAsExpression(expr, ts.factory.createTypeOperatorNode(ts.SyntaxKind.ReadonlyKeyword, ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode("AttributeApplication"))));
+	}
+	createDefaultTypeAssertion(expr) {
+		this.usedFieldDefault = true;
+		return ts.factory.createAsExpression(expr, ts.factory.createTypeReferenceNode("FieldDefault"));
+	}
+	createProviderObject(model) {
+		const dsProvider = this.getDataSourceProvider(model);
+		const defaultSchema = this.getDataSourceDefaultSchema(model);
+		return ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider)), ...defaultSchema ? [ts.factory.createPropertyAssignment("defaultSchema", ts.factory.createStringLiteral(defaultSchema))] : []], true);
+	}
+	createModelsObject(model, lite) {
+		return ts.factory.createObjectLiteralExpression(this.getAllDataModels(model).map((dm) => ts.factory.createPropertyAssignment(dm.name, this.createDataModelObject(dm, lite))), true);
+	}
+	getAllDataModels(model) {
+		return model.declarations.filter((d) => isDataModel(d) && !hasAttribute(d, "@@ignore"));
+	}
+	getAllTypeDefs(model) {
+		return model.declarations.filter((d) => isTypeDef(d) && !hasAttribute(d, "@@ignore"));
+	}
+	createTypeDefsObject(model, lite) {
+		return ts.factory.createObjectLiteralExpression(this.getAllTypeDefs(model).map((td) => ts.factory.createPropertyAssignment(td.name, this.createTypeDefObject(td, lite))), true);
+	}
+	createDataModelObject(dm, lite) {
+		const allFields = getAllFields(dm);
+		const allAttributes = lite ? [] : getAllAttributes(dm).filter((attr) => {
+			if (attr.decl.$refText === "@@delegate" && attr.$container !== dm) return false;
+			return true;
+		});
+		const subModels = this.getSubModels(dm);
+		const fields = [
+			ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(dm.name)),
+			...dm.baseModel ? [ts.factory.createPropertyAssignment("baseModel", ts.factory.createStringLiteral(dm.baseModel.$refText))] : [],
+			ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, dm, lite))), true)),
+			...allAttributes.length > 0 ? [ts.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(ts.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true)))] : [],
+			ts.factory.createPropertyAssignment("idFields", ts.factory.createArrayLiteralExpression(getIdFields(dm).map((idField) => ts.factory.createStringLiteral(idField)))),
+			ts.factory.createPropertyAssignment("uniqueFields", this.createUniqueFieldsObject(dm)),
+			...isDelegateModel$1(dm) ? [ts.factory.createPropertyAssignment("isDelegate", ts.factory.createTrue())] : [],
+			...subModels.length > 0 ? [ts.factory.createPropertyAssignment("subModels", ts.factory.createArrayLiteralExpression(subModels.map((subModel) => ts.factory.createStringLiteral(subModel))))] : [],
+			...dm.isView ? [ts.factory.createPropertyAssignment("isView", ts.factory.createTrue())] : []
+		];
+		const computedFields = allFields.filter((f) => hasAttribute(f, "@computed") && !getDelegateOriginModel(f, dm));
+		if (computedFields.length > 0) fields.push(ts.factory.createPropertyAssignment("computedFields", this.createComputedFieldsObject(computedFields)));
+		return ts.factory.createObjectLiteralExpression(fields, true);
+	}
+	getSubModels(dm) {
+		return dm.$container.declarations.filter(isDataModel).filter((d) => d.baseModel?.ref === dm).map((d) => d.name);
+	}
+	createTypeDefObject(td, lite) {
+		const allFields = getAllFields(td);
+		const allAttributes = getAllAttributes(td);
+		const fields = [
+			ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(td.name)),
+			ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, void 0, lite))), true)),
+			...allAttributes.length > 0 ? [ts.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(ts.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true)))] : []
+		];
+		return ts.factory.createObjectLiteralExpression(fields, true);
+	}
+	createComputedFieldsObject(fields) {
+		return ts.factory.createObjectLiteralExpression(fields.map((field) => ts.factory.createMethodDeclaration(void 0, void 0, field.name, void 0, void 0, [ts.factory.createParameterDeclaration(void 0, void 0, "_context", void 0, ts.factory.createTypeLiteralNode([ts.factory.createPropertySignature(void 0, "modelAlias", void 0, ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))]), void 0)], ts.factory.createTypeReferenceNode(this.mapFieldTypeToTSType(field.type)), ts.factory.createBlock([ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier("Error"), void 0, [ts.factory.createStringLiteral("This is a stub for computed field")]))], true))), true);
+	}
+	createUpdatedAtObject(ignoreArg) {
+		return ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment("ignore", ts.factory.createArrayLiteralExpression(ignoreArg.value.items.map((item) => ts.factory.createStringLiteral(item.target.$refText))))]);
+	}
+	mapFieldTypeToTSType(type) {
+		let result = match(type.type).with("String", () => "string").with("Boolean", () => "boolean").with("Int", () => "number").with("Float", () => "number").with("BigInt", () => "bigint").with("Decimal", () => "number").otherwise(() => "unknown");
+		if (type.array) result = `${result}[]`;
+		if (type.optional) result = `${result} | null`;
+		return result;
+	}
+	createDataFieldObject(field, contextModel, lite) {
+		const objectFields = [ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(field.name)), ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))];
+		if (contextModel && isIdField(field, contextModel)) objectFields.push(ts.factory.createPropertyAssignment("id", ts.factory.createTrue()));
+		if (isUniqueField(field)) objectFields.push(ts.factory.createPropertyAssignment("unique", ts.factory.createTrue()));
+		if (field.type.optional) objectFields.push(ts.factory.createPropertyAssignment("optional", ts.factory.createTrue()));
+		if (field.type.array) objectFields.push(ts.factory.createPropertyAssignment("array", ts.factory.createTrue()));
+		const updatedAtAttrib = getAttribute(field, "@updatedAt");
+		if (updatedAtAttrib) {
+			const ignoreArg = updatedAtAttrib.args.find((arg) => arg.$resolvedParam?.name === "ignore");
+			objectFields.push(ts.factory.createPropertyAssignment("updatedAt", ignoreArg ? this.createUpdatedAtObject(ignoreArg) : ts.factory.createTrue()));
+		}
+		if (hasAttribute(field, "@omit")) objectFields.push(ts.factory.createPropertyAssignment("omit", ts.factory.createTrue()));
+		if (contextModel && !isIdField(field, contextModel)) {
+			const delegateOrigin = getDelegateOriginModel(field, contextModel);
+			if (delegateOrigin) objectFields.push(ts.factory.createPropertyAssignment("originModel", ts.factory.createStringLiteral(delegateOrigin)));
+		}
+		if (this.isDiscriminatorField(field)) objectFields.push(ts.factory.createPropertyAssignment("isDiscriminator", ts.factory.createTrue()));
+		if (!lite && field.attributes.length > 0) objectFields.push(ts.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(ts.factory.createArrayLiteralExpression(field.attributes.map((attr) => this.createAttributeObject(attr))))));
+		const defaultValue = this.getFieldMappedDefault(field);
+		if (defaultValue !== void 0) {
+			let defaultExpr;
+			if (defaultValue === null) defaultExpr = this.createExpressionUtilsCall("_null");
+			else if (typeof defaultValue === "object" && !Array.isArray(defaultValue)) if ("call" in defaultValue) defaultExpr = this.createExpressionUtilsCall("call", [ts.factory.createStringLiteral(defaultValue.call), ...defaultValue.args.length > 0 ? [ts.factory.createArrayLiteralExpression(defaultValue.args.map((arg) => this.createExpressionUtilsCall("literal", [this.createLiteralNode(arg)])))] : []]);
+			else if ("authMember" in defaultValue) defaultExpr = this.createExpressionUtilsCall("member", [this.createExpressionUtilsCall("call", [ts.factory.createStringLiteral("auth")]), ts.factory.createArrayLiteralExpression(defaultValue.authMember.map((m) => ts.factory.createStringLiteral(m)))]);
+			else throw new Error(`Unsupported default value type for field ${field.name}`);
+			else if (Array.isArray(defaultValue)) defaultExpr = ts.factory.createArrayLiteralExpression(defaultValue.map((item) => this.createLiteralNode(item)));
+			else defaultExpr = this.createLiteralNode(defaultValue);
+			objectFields.push(ts.factory.createPropertyAssignment("default", this.createDefaultTypeAssertion(defaultExpr)));
+		}
+		if (hasAttribute(field, "@computed")) objectFields.push(ts.factory.createPropertyAssignment("computed", ts.factory.createTrue()));
+		if (isDataModel(field.type.reference?.ref)) objectFields.push(ts.factory.createPropertyAssignment("relation", this.createRelationObject(field, contextModel)));
+		const fkFor = this.getForeignKeyFor(field, contextModel);
+		if (fkFor && fkFor.length > 0) objectFields.push(ts.factory.createPropertyAssignment("foreignKeyFor", ts.factory.createAsExpression(ts.factory.createArrayLiteralExpression(fkFor.map((fk) => ts.factory.createStringLiteral(fk)), true), ts.factory.createTypeOperatorNode(ts.SyntaxKind.ReadonlyKeyword, ts.factory.createArrayTypeNode(ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))))));
+		return ts.factory.createObjectLiteralExpression(objectFields, true);
+	}
+	isDiscriminatorField(field) {
+		const origin = field.$container;
+		return getAttribute(origin, "@@delegate")?.args.some((arg) => arg.$resolvedParam?.name === "discriminator" && isDataFieldReference(arg.value) && arg.value.target.ref === field);
+	}
+	getDataSourceProvider(model) {
+		const dataSource = model.declarations.find(isDataSource);
+		invariant(dataSource, "No data source found in the model");
+		const providerExpr = dataSource.fields.find((f) => f.name === "provider")?.value;
+		invariant(isLiteralExpr(providerExpr) && typeof providerExpr.value === "string", "Provider must be a string literal");
+		return providerExpr.value;
+	}
+	getDataSourceDefaultSchema(model) {
+		const dataSource = model.declarations.find(isDataSource);
+		invariant(dataSource, "No data source found in the model");
+		const defaultSchemaExpr = dataSource.fields.find((f) => f.name === "defaultSchema")?.value;
+		if (!defaultSchemaExpr) return;
+		invariant(isLiteralExpr(defaultSchemaExpr) && typeof defaultSchemaExpr.value === "string", "Default schema must be a string literal");
+		return defaultSchemaExpr.value;
+	}
+	getFieldMappedDefault(field) {
+		const defaultAttr = getAttribute(field, "@default");
+		if (!defaultAttr) return;
+		const defaultValue = defaultAttr.args[0]?.value;
+		invariant(defaultValue, "Expected a default value");
+		return this.getMappedValue(defaultValue, field.type);
+	}
+	getMappedValue(expr, fieldType) {
+		if (isLiteralExpr(expr)) {
+			const lit = expr.value;
+			return fieldType.type === "Boolean" ? lit : [
+				"Int",
+				"Float",
+				"Decimal",
+				"BigInt"
+			].includes(fieldType.type) ? Number(lit) : lit;
+		} else if (isArrayExpr(expr)) return expr.items.map((item) => this.getMappedValue(item, fieldType));
+		else if (isReferenceExpr(expr) && isEnumField(expr.target.ref)) return expr.target.ref.name;
+		else if (isInvocationExpr(expr)) return {
+			call: expr.function.$refText,
+			args: expr.args.map((arg) => this.getLiteral(arg.value))
+		};
+		else if (this.isAuthMemberAccess(expr)) return { authMember: this.getMemberAccessChain(expr) };
+		else if (isNullExpr(expr)) return null;
+		else throw new Error(`Unsupported expression type: ${expr.$type}`);
+	}
+	getMemberAccessChain(expr) {
+		if (!isMemberAccessExpr(expr.operand)) return [expr.member.$refText];
+		else return [...this.getMemberAccessChain(expr.operand), expr.member.$refText];
+	}
+	isAuthMemberAccess(expr) {
+		if (isMemberAccessExpr(expr)) return this.isAuthInvocation(expr.operand) || this.isAuthMemberAccess(expr.operand);
+		else return false;
+	}
+	isAuthInvocation(expr) {
+		return isInvocationExpr(expr) && expr.function.$refText === "auth" && isFromStdlib(expr.function.ref);
+	}
+	createRelationObject(field, contextModel) {
+		const relationFields = [];
+		const oppositeRelation = this.getOppositeRelationField(field, contextModel);
+		if (oppositeRelation) relationFields.push(ts.factory.createPropertyAssignment("opposite", ts.factory.createStringLiteral(oppositeRelation.name)));
+		const relationName = this.getRelationName(field);
+		if (relationName) relationFields.push(ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(relationName)));
+		const relation = getAttribute(field, "@relation");
+		const fkFields = [];
+		if (relation) for (const arg of relation.args) {
+			const param = arg.$resolvedParam?.name;
+			if (param === "fields" || param === "references") {
+				const fieldNames = this.getReferenceNames(arg.value);
+				if (fieldNames) {
+					if (param === "fields") fkFields.push(...fieldNames);
+					relationFields.push(ts.factory.createPropertyAssignment(param, ts.factory.createArrayLiteralExpression(fieldNames.map((el) => ts.factory.createStringLiteral(el)))));
+				}
+			}
+			if (param === "onDelete" || param === "onUpdate") {
+				const action = arg.value.target.$refText;
+				relationFields.push(ts.factory.createPropertyAssignment(param, ts.factory.createStringLiteral(action)));
+			}
+		}
+		if (fkFields.length > 0) {
+			if (fkFields.every((fieldName) => {
+				const fieldDef = field.$container.fields.find((f) => f.name === fieldName);
+				return fieldDef && hasAttribute(fieldDef, "@default");
+			})) relationFields.push(ts.factory.createPropertyAssignment("hasDefault", ts.factory.createTrue()));
+		}
+		return ts.factory.createObjectLiteralExpression(relationFields);
+	}
+	getReferenceNames(expr) {
+		return isArrayExpr(expr) && expr.items.map((item) => item.target.$refText);
+	}
+	getForeignKeyFor(field, contextModel) {
+		if (!contextModel) return [];
+		const result = [];
+		for (const f of getAllFields(contextModel)) {
+			const relation = getAttribute(f, "@relation");
+			if (relation) {
+				for (const arg of relation.args) if (arg.name === "fields" && isArrayExpr(arg.value) && arg.value.items.some((el) => isReferenceExpr(el) && el.target.ref === field)) result.push(f.name);
+			}
+		}
+		return result;
+	}
+	getOppositeRelationField(field, contextModel) {
+		if (!field.type.reference?.ref || !isDataModel(field.type.reference?.ref) || !contextModel) return;
+		const sourceModel = isTypeDef(field.$container) ? contextModel : field.$container;
+		const targetModel = field.type.reference.ref;
+		const relationName = this.getRelationName(field);
+		for (const otherField of getAllFields(targetModel)) {
+			if (otherField === field) continue;
+			if (otherField.type.reference?.ref === sourceModel) if (relationName) {
+				if (this.getRelationName(otherField) === relationName) return otherField;
+			} else return otherField;
+		}
+	}
+	getRelationName(field) {
+		const relation = getAttribute(field, "@relation");
+		if (relation) {
+			const nameArg = relation.args.find((arg) => arg.$resolvedParam?.name === "name");
+			if (nameArg) {
+				invariant(isLiteralExpr(nameArg.value), "name must be a literal");
+				return nameArg.value.value;
+			}
+		}
+	}
+	createUniqueFieldsObject(dm) {
+		const properties = [];
+		const allFields = getAllFields(dm);
+		for (const field of allFields) if (hasAttribute(field, "@id") || hasAttribute(field, "@unique")) properties.push(ts.factory.createPropertyAssignment(field.name, ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))])));
+		const allAttributes = getAllAttributes(dm);
+		const seenKeys = /* @__PURE__ */ new Set();
+		for (const attr of allAttributes) if (attr.decl.$refText === "@@id" || attr.decl.$refText === "@@unique") {
+			const fieldsArg = getAttributeArg(attr, "fields");
+			if (!fieldsArg) continue;
+			const fieldNames = this.getReferenceNames(fieldsArg);
+			if (!fieldNames) continue;
+			if (fieldNames.length === 1) {
+				const fieldDef = allFields.find((f) => f.name === fieldNames[0]);
+				properties.push(ts.factory.createPropertyAssignment(fieldNames[0], ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))])));
+			} else {
+				const key = this.getCompoundUniqueKey(attr, fieldNames);
+				if (seenKeys.has(key)) continue;
+				seenKeys.add(key);
+				properties.push(ts.factory.createPropertyAssignment(key, ts.factory.createObjectLiteralExpression(fieldNames.map((field) => {
+					const fieldDef = allFields.find((f) => f.name === field);
+					return ts.factory.createPropertyAssignment(field, ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))]));
+				}))));
+			}
+		}
+		return ts.factory.createObjectLiteralExpression(properties, true);
+	}
+	getCompoundUniqueKey(attr, fieldNames) {
+		const nameArg = attr.args.find((arg) => arg.$resolvedParam?.name === "name");
+		if (nameArg && isLiteralExpr(nameArg.value)) return nameArg.value.value;
+		else return fieldNames.join("_");
+	}
+	generateFieldTypeLiteral(field) {
+		invariant(field.type.type || field.type.reference || field.type.unsupported, "Field type must be a primitive, reference, or Unsupported");
+		return field.type.type ? ts.factory.createStringLiteral(field.type.type) : field.type.reference ? ts.factory.createStringLiteral(field.type.reference.$refText) : ts.factory.createStringLiteral("Unsupported");
+	}
+	createEnumObject(e) {
+		return ts.factory.createObjectLiteralExpression([
+			ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(e.name)),
+			ts.factory.createPropertyAssignment("values", ts.factory.createObjectLiteralExpression(e.fields.map((f) => ts.factory.createPropertyAssignment(f.name, ts.factory.createStringLiteral(f.name))), true)),
+			...e.fields.some((f) => f.attributes.length > 0) ? [ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(e.fields.map((field) => ts.factory.createPropertyAssignment(field.name, ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(field.name)), ...field.attributes.length > 0 ? [ts.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(ts.factory.createArrayLiteralExpression(field.attributes?.map((attr) => this.createAttributeObject(attr)) ?? [], true)))] : []], true))), true))] : [],
+			...e.attributes.length > 0 ? [ts.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(ts.factory.createArrayLiteralExpression(e.attributes.map((attr) => this.createAttributeObject(attr)), true)))] : []
+		], true);
+	}
+	getLiteral(expr) {
+		if (!isLiteralExpr(expr)) throw new Error("Expected a literal expression");
+		switch (expr?.$type) {
+			case "StringLiteral":
+			case "BooleanLiteral": return expr.value;
+			case "NumberLiteral": return parseFloat(expr.value);
+			default: throw new Error("Unsupported literal type");
+		}
+	}
+	createLiteralNode(arg) {
+		return arg === null ? ts.factory.createNull() : typeof arg === "string" ? ts.factory.createStringLiteral(arg) : typeof arg === "number" ? this.createNumberLiteral(arg) : arg === true ? ts.factory.createTrue() : arg === false ? ts.factory.createFalse() : void 0;
+	}
+	createNumberLiteral(arg) {
+		return arg < 0 ? ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(-arg)) : ts.factory.createNumericLiteral(arg);
+	}
+	createProceduresObject(procedures) {
+		return ts.factory.createObjectLiteralExpression(procedures.map((proc) => ts.factory.createPropertyAssignment(proc.name, this.createProcedureObject(proc))), true);
+	}
+	createProcedureObject(proc) {
+		const params = ts.factory.createObjectLiteralExpression(proc.params.map((param) => ts.factory.createPropertyAssignment(param.name, ts.factory.createObjectLiteralExpression([
+			ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(param.name)),
+			...param.optional ? [ts.factory.createPropertyAssignment("optional", ts.factory.createTrue())] : [],
+			...param.type.array ? [ts.factory.createPropertyAssignment("array", ts.factory.createTrue())] : [],
+			ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(param.type.type ?? param.type.reference.$refText))
+		]))), true);
+		return ts.factory.createObjectLiteralExpression([
+			ts.factory.createPropertyAssignment("params", params),
+			ts.factory.createPropertyAssignment("returnType", ts.factory.createStringLiteral(proc.returnType.type ?? proc.returnType.reference.$refText)),
+			...proc.returnType.array ? [ts.factory.createPropertyAssignment("returnArray", ts.factory.createTrue())] : [],
+			...proc.mutation ? [ts.factory.createPropertyAssignment("mutation", ts.factory.createTrue())] : []
+		], true);
+	}
+	generateBannerComments(statements) {
+		ts.addSyntheticLeadingComment(statements[0], ts.SyntaxKind.SingleLineCommentTrivia, `////////////////////////////////////////////////////////////////////////////////////////////
+// DO NOT MODIFY THIS FILE                                                                  //
+// This file is automatically generated by ZenStack CLI and should not be manually updated. //
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+/* eslint-disable */
+
+`);
+	}
+	createAttributeObject(attr) {
+		return ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(attr.decl.$refText)), ...attr.args.length > 0 ? [ts.factory.createPropertyAssignment("args", ts.factory.createArrayLiteralExpression(attr.args.map((arg) => this.createAttributeArg(arg))))] : []]);
+	}
+	createAttributeArg(arg) {
+		return ts.factory.createObjectLiteralExpression([...arg.$resolvedParam?.name ? [ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(arg.$resolvedParam.name))] : [], ts.factory.createPropertyAssignment("value", this.createExpression(arg.value))]);
+	}
+	createExpression(value) {
+		return match(value).when(isLiteralExpr, (expr) => this.createLiteralExpression(expr.$type, expr.value)).when(isInvocationExpr, (expr) => this.createCallExpression(expr)).when(isReferenceExpr, (expr) => this.createRefExpression(expr)).when(isArrayExpr, (expr) => this.createArrayExpression(expr)).when(isUnaryExpr, (expr) => this.createUnaryExpression(expr)).when(isBinaryExpr, (expr) => this.createBinaryExpression(expr)).when(isMemberAccessExpr, (expr) => this.createMemberExpression(expr)).when(isNullExpr, () => this.createNullExpression()).when(isThisExpr, () => this.createThisExpression()).otherwise(() => {
+			throw new Error(`Unsupported attribute arg value: ${value.$type}`);
+		});
+	}
+	createThisExpression() {
+		return this.createExpressionUtilsCall("_this");
+	}
+	createMemberExpression(expr) {
+		const members = [];
+		let current = expr;
+		while (isMemberAccessExpr(current)) {
+			members.unshift(current.member.$refText);
+			current = current.operand;
+		}
+		const receiver = current;
+		const args = [this.createExpression(receiver), ts.factory.createArrayLiteralExpression(members.map((m) => ts.factory.createStringLiteral(m)))];
+		return this.createExpressionUtilsCall("member", args);
+	}
+	createNullExpression() {
+		return this.createExpressionUtilsCall("_null");
+	}
+	createBinaryExpression(expr) {
+		const args = [
+			this.createExpression(expr.left),
+			this.createLiteralNode(expr.operator),
+			this.createExpression(expr.right)
+		];
+		if (expr.binding) args.push(this.createLiteralNode(expr.binding.name));
+		return this.createExpressionUtilsCall("binary", args);
+	}
+	createUnaryExpression(expr) {
+		return this.createExpressionUtilsCall("unary", [this.createLiteralNode(expr.operator), this.createExpression(expr.operand)]);
+	}
+	createArrayExpression(expr) {
+		const arrayResolved = expr.$resolvedType?.decl;
+		const arrayType = typeof arrayResolved === "string" ? arrayResolved : arrayResolved?.name;
+		invariant(arrayType, "Array type must be resolved to a string or declaration");
+		return this.createExpressionUtilsCall("array", [this.createLiteralNode(arrayType), ts.factory.createArrayLiteralExpression(expr.items.map((item) => this.createExpression(item)))]);
+	}
+	createRefExpression(expr) {
+		const target = expr.target.ref;
+		return match(target).when(isDataField, () => this.createExpressionUtilsCall("field", [this.createLiteralNode(expr.target.$refText)])).when(isEnumField, () => this.createLiteralExpression("StringLiteral", expr.target.$refText)).when(isCollectionPredicateBinding, () => this.createExpressionUtilsCall("binding", [this.createLiteralNode(expr.target.$refText)])).otherwise(() => {
+			throw Error(`Unsupported reference type: ${expr.target.$refText}`);
+		});
+	}
+	createCallExpression(expr) {
+		return this.createExpressionUtilsCall("call", [ts.factory.createStringLiteral(expr.function.$refText), ...expr.args.length > 0 ? [ts.factory.createArrayLiteralExpression(expr.args.map((arg) => this.createExpression(arg.value)))] : []]);
+	}
+	createLiteralExpression(type, value) {
+		return match(type).with("BooleanLiteral", () => this.createExpressionUtilsCall("literal", [this.createLiteralNode(value)])).with("NumberLiteral", () => this.createExpressionUtilsCall("literal", [ts.factory.createIdentifier(value)])).with("StringLiteral", () => this.createExpressionUtilsCall("literal", [this.createLiteralNode(value)])).otherwise(() => {
+			throw new Error(`Unsupported literal type: ${type}`);
+		});
+	}
+	generateModelsAndTypeDefs(model, options) {
+		const statements = [];
+		statements.push(this.generateSchemaImport(model, true, true, !!(options.lite || options.liteOnly), options.importWithFileExtension));
+		statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports([ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(`ModelResult as $ModelResult`)), ...model.declarations.some(isTypeDef) ? [ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(`TypeDefResult as $TypeDefResult`))] : []])), ts.factory.createStringLiteral("@zenstackhq/orm")));
+		const dataModels = this.getAllDataModels(model);
+		for (const dm of dataModels) {
+			let modelType = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], dm.name, void 0, ts.factory.createTypeReferenceNode("$ModelResult", [ts.factory.createTypeReferenceNode("$Schema"), ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name))]));
+			if (dm.comments.length > 0) modelType = this.generateDocs(modelType, dm);
+			statements.push(modelType);
+		}
+		const typeDefs = this.getAllTypeDefs(model);
+		for (const td of typeDefs) {
+			let typeDef = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], td.name, void 0, ts.factory.createTypeReferenceNode("$TypeDefResult", [ts.factory.createTypeReferenceNode("$Schema"), ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(td.name))]));
+			if (td.comments.length > 0) typeDef = this.generateDocs(typeDef, td);
+			statements.push(typeDef);
+		}
+		const enums = model.declarations.filter(isEnum);
+		for (const e of enums) {
+			let enumDecl = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(e.name, void 0, void 0, ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("$schema"), ts.factory.createIdentifier("enums")), ts.factory.createIdentifier(e.name)), ts.factory.createIdentifier("values")))], ts.NodeFlags.Const));
+			if (e.comments.length > 0) enumDecl = this.generateDocs(enumDecl, e);
+			statements.push(enumDecl);
+			let typeAlias = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], e.name, void 0, ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeQueryNode(ts.factory.createIdentifier(e.name)), ts.factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, ts.factory.createTypeQueryNode(ts.factory.createIdentifier(e.name)))));
+			if (e.comments.length > 0) typeAlias = this.generateDocs(typeAlias, e);
+			statements.push(typeAlias);
+		}
+		this.generateBannerComments(statements);
+		const outputFile = path.join(options.outDir, "models.ts");
+		const sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+		const result = ts.createPrinter().printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
+		fs.writeFileSync(outputFile, result);
+	}
+	generateSchemaImport(model, schemaObject, schemaType, useLite, importWithFileExtension) {
+		const importSpecifiers = [];
+		if (schemaObject) {
+			if (model.declarations.some(isEnum)) importSpecifiers.push(ts.factory.createImportSpecifier(false, ts.factory.createIdentifier("schema"), ts.factory.createIdentifier("$schema")));
+		}
+		if (schemaType) importSpecifiers.push(ts.factory.createImportSpecifier(true, ts.factory.createIdentifier("SchemaType"), ts.factory.createIdentifier("$Schema")));
+		let importFrom = useLite ? "./schema-lite" : "./schema";
+		if (importWithFileExtension) importFrom += importWithFileExtension.startsWith(".") ? importWithFileExtension : `.${importWithFileExtension}`;
+		return ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports(importSpecifiers)), ts.factory.createStringLiteral(importFrom));
+	}
+	generateDocs(tsDecl, decl) {
+		return ts.addSyntheticLeadingComment(tsDecl, ts.SyntaxKind.MultiLineCommentTrivia, `*\n * ${decl.comments.map((c) => c.replace(/^\s*\/*\s*/, "")).join("\n * ")}\n `, true);
+	}
+	generateInputTypes(model, options) {
+		const dataModels = this.getAllDataModels(model);
+		const statements = [];
+		statements.push(this.generateSchemaImport(model, false, true, !!(options.lite || options.liteOnly), options.importWithFileExtension));
+		const inputTypes = [
+			"FindManyArgs",
+			"FindUniqueArgs",
+			"FindFirstArgs",
+			"ExistsArgs",
+			"CreateArgs",
+			"CreateManyArgs",
+			"CreateManyAndReturnArgs",
+			"UpdateArgs",
+			"UpdateManyArgs",
+			"UpdateManyAndReturnArgs",
+			"UpsertArgs",
+			"DeleteArgs",
+			"DeleteManyArgs",
+			"CountArgs",
+			"AggregateArgs",
+			"GroupByArgs",
+			"WhereInput",
+			"SelectInput",
+			"IncludeInput",
+			"OmitInput"
+		];
+		const inputTypeNameFixes = {
+			SelectInput: "Select",
+			IncludeInput: "Include",
+			OmitInput: "Omit"
+		};
+		statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports([...inputTypes.map((inputType) => ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(`${inputType} as $${inputType}`))), ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("QueryOptions as $QueryOptions"))])), ts.factory.createStringLiteral("@zenstackhq/orm")));
+		statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports([ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("SimplifiedPlainResult as $Result")), ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("SelectIncludeOmit as $SelectIncludeOmit"))])), ts.factory.createStringLiteral("@zenstackhq/orm")));
+		for (const dm of dataModels) {
+			for (const inputType of inputTypes) {
+				const exportName = inputTypeNameFixes[inputType] ? `${dm.name}${inputTypeNameFixes[inputType]}` : `${dm.name}${inputType}`;
+				statements.push(ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], exportName, void 0, ts.factory.createTypeReferenceNode(`$${inputType}`, [ts.factory.createTypeReferenceNode("$Schema"), ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name))])));
+			}
+			statements.push(ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], `${dm.name}GetPayload`, [ts.factory.createTypeParameterDeclaration(void 0, "Args", ts.factory.createTypeReferenceNode("$SelectIncludeOmit", [
+				ts.factory.createTypeReferenceNode("$Schema"),
+				ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),
+				ts.factory.createLiteralTypeNode(ts.factory.createTrue())
+			])), ts.factory.createTypeParameterDeclaration(void 0, "Options", ts.factory.createTypeReferenceNode("$QueryOptions", [ts.factory.createTypeReferenceNode("$Schema")]), ts.factory.createTypeReferenceNode("$QueryOptions", [ts.factory.createTypeReferenceNode("$Schema")]))], ts.factory.createTypeReferenceNode("$Result", [
+				ts.factory.createTypeReferenceNode("$Schema"),
+				ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),
+				ts.factory.createTypeReferenceNode("Args"),
+				ts.factory.createTypeReferenceNode("Options")
+			])));
+		}
+		this.generateBannerComments(statements);
+		const outputFile = path.join(options.outDir, "input.ts");
+		const sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+		const result = ts.createPrinter().printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
+		fs.writeFileSync(outputFile, result);
+	}
+};
+//#endregion
+export { model_utils_exports as ModelUtils, PrismaSchemaGenerator, TsSchemaGenerator };
+
+//# sourceMappingURL=index.mjs.map