@zenstackhq/sdk 3.0.0-alpha.9 → 3.0.0-beta.10

package/dist/index.js

@@ -8,12 +8,11 @@ var __export = (target, all) => {
 // src/model-utils.ts
 var model_utils_exports = {};
 __export(model_utils_exports, {
+  DELEGATE_AUX_RELATION_PREFIX: () => DELEGATE_AUX_RELATION_PREFIX,
   getAttribute: () => getAttribute,
   getAuthDecl: () => getAuthDecl,
   getContainingModel: () => getContainingModel,
-  getModelIdFields: () => getModelIdFields,
-  getModelUniqueFields: () => getModelUniqueFields,
-  getRecursiveBases: () => getRecursiveBases,
+  getIdFields: () => getIdFields,
   hasAttribute: () => hasAttribute,
   isDelegateModel: () => isDelegateModel,
   isFromStdlib: () => isFromStdlib,
@@ -21,24 +20,25 @@ __export(model_utils_exports, {
   isUniqueField: () => isUniqueField,
   resolved: () => resolved
 });
-import { isArrayExpr, isDataModel, isLiteralExpr, isModel, isReferenceExpr } from "@zenstackhq/language/ast";
-function isIdField(field) {
+import { isDataModel, isLiteralExpr, isModel, isTypeDef } from "@zenstackhq/language/ast";
+import { getAllFields, getModelIdFields, getModelUniqueFields } from "@zenstackhq/language/utils";
+function isIdField(field, contextModel) {
   if (hasAttribute(field, "@id")) {
     return true;
   }
-  const model = field.$container;
-  const modelLevelIds = getModelIdFields(model);
+  const modelLevelIds = getModelIdFields(contextModel);
   if (modelLevelIds.map((f) => f.name).includes(field.name)) {
     return true;
   }
-  if (model.fields.some((f) => hasAttribute(f, "@id")) || modelLevelIds.length > 0) {
+  const allFields = getAllFields(contextModel);
+  if (allFields.some((f) => hasAttribute(f, "@id")) || modelLevelIds.length > 0) {
     return false;
   }
-  const firstUniqueField = model.fields.find((f) => hasAttribute(f, "@unique"));
+  const firstUniqueField = allFields.find((f) => hasAttribute(f, "@unique"));
   if (firstUniqueField) {
     return firstUniqueField.name === field.name;
   }
-  const modelLevelUnique = getModelUniqueFields(model);
+  const modelLevelUnique = getModelUniqueFields(contextModel);
   if (modelLevelUnique.map((f) => f.name).includes(field.name)) {
     return true;
   }
@@ -53,67 +53,6 @@ function getAttribute(decl, name) {
   return decl.attributes.find((attr) => attr.decl.$refText === name);
 }
 __name(getAttribute, "getAttribute");
-function getModelIdFields(model) {
-  const modelsToCheck = model.$baseMerged ? [
-    model
-  ] : [
-    model,
-    ...getRecursiveBases(model)
-  ];
-  for (const modelToCheck of modelsToCheck) {
-    const idAttr = modelToCheck.attributes.find((attr) => attr.decl.$refText === "@@id");
-    if (!idAttr) {
-      continue;
-    }
-    const fieldsArg = idAttr.args.find((a) => a.$resolvedParam?.name === "fields");
-    if (!fieldsArg || !isArrayExpr(fieldsArg.value)) {
-      continue;
-    }
-    return fieldsArg.value.items.filter((item) => isReferenceExpr(item)).map((item) => item.target.ref);
-  }
-  return [];
-}
-__name(getModelIdFields, "getModelIdFields");
-function getModelUniqueFields(model) {
-  const modelsToCheck = model.$baseMerged ? [
-    model
-  ] : [
-    model,
-    ...getRecursiveBases(model)
-  ];
-  for (const modelToCheck of modelsToCheck) {
-    const uniqueAttr = modelToCheck.attributes.find((attr) => attr.decl.$refText === "@@unique");
-    if (!uniqueAttr) {
-      continue;
-    }
-    const fieldsArg = uniqueAttr.args.find((a) => a.$resolvedParam?.name === "fields");
-    if (!fieldsArg || !isArrayExpr(fieldsArg.value)) {
-      continue;
-    }
-    return fieldsArg.value.items.filter((item) => isReferenceExpr(item)).map((item) => item.target.ref);
-  }
-  return [];
-}
-__name(getModelUniqueFields, "getModelUniqueFields");
-function getRecursiveBases(dataModel, includeDelegate = true, seen = /* @__PURE__ */ new Set()) {
-  const result = [];
-  if (seen.has(dataModel)) {
-    return result;
-  }
-  seen.add(dataModel);
-  dataModel.superTypes.forEach((superType) => {
-    const baseDecl = superType.ref;
-    if (baseDecl) {
-      if (!includeDelegate && isDelegateModel(baseDecl)) {
-        return;
-      }
-      result.push(baseDecl);
-      result.push(...getRecursiveBases(baseDecl, includeDelegate, seen));
-    }
-  });
-  return result;
-}
-__name(getRecursiveBases, "getRecursiveBases");
 function isDelegateModel(node) {
   return isDataModel(node) && hasAttribute(node, "@@delegate");
 }
@@ -149,18 +88,25 @@ function resolved(ref) {
 }
 __name(resolved, "resolved");
 function getAuthDecl(model) {
-  let found = model.declarations.find((d) => isDataModel(d) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
+  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) && d.name === "User");
   }
   return found;
 }
 __name(getAuthDecl, "getAuthDecl");
+function getIdFields(dm) {
+  return getAllFields(dm).filter((f) => isIdField(f, dm)).map((f) => f.name);
+}
+__name(getIdFields, "getIdFields");
+var DELEGATE_AUX_RELATION_PREFIX = "delegate_aux";
 
 // src/prisma/prisma-schema-generator.ts
-import { BooleanLiteral, DataModel, DataSource as DataSource2, Enum as Enum2, GeneratorDecl, isArrayExpr as isArrayExpr2, isInvocationExpr, isLiteralExpr as isLiteralExpr2, isModel as isModel2, isNullExpr, isReferenceExpr as isReferenceExpr2, isStringLiteral, isTypeDef, NumberLiteral, StringLiteral } from "@zenstackhq/language/ast";
+import { lowerCaseFirst } from "@zenstackhq/common-helpers";
+import { BooleanLiteral, DataModel, DataSource as DataSource2, Enum as Enum2, GeneratorDecl, isArrayExpr, isDataModel as isDataModel2, isInvocationExpr, isLiteralExpr as isLiteralExpr2, isNullExpr, isReferenceExpr, isStringLiteral, isTypeDef as isTypeDef2, NumberLiteral, StringLiteral } from "@zenstackhq/language/ast";
+import { getAllAttributes, getAllFields as getAllFields2, isAuthInvocation, isDelegateModel as isDelegateModel2 } from "@zenstackhq/language/utils";
 import { AstUtils } from "langium";
-import { match, P } from "ts-pattern";
+import { match } from "ts-pattern";
 
 // src/prisma/indent-string.ts
 function indentString(string, count = 4) {
@@ -553,6 +499,7 @@ var EnumField = class extends DeclarationBase {
 };
 
 // src/prisma/prisma-schema-generator.ts
+var IDENTIFIER_NAME_MAX_LENGTH = 50 - DELEGATE_AUX_RELATION_PREFIX.length;
 var PrismaSchemaGenerator = class {
   static {
     __name(this, "PrismaSchemaGenerator");
@@ -564,6 +511,8 @@ var PrismaSchemaGenerator = class {
 //////////////////////////////////////////////////////////////////////////////////////////////
 
 `;
+  // a mapping from full names to shortened names
+  shortNameMap = /* @__PURE__ */ new Map();
   constructor(zmodel) {
     this.zmodel = zmodel;
   }
@@ -627,16 +576,29 @@ var PrismaSchemaGenerator = class {
   }
   generateModel(prisma, decl) {
     const model = decl.isView ? prisma.addView(decl.name) : prisma.addModel(decl.name);
-    for (const field of decl.fields) {
+    const allFields = getAllFields2(decl, true);
+    for (const field of allFields) {
       if (model_utils_exports.hasAttribute(field, "@computed")) {
         continue;
       }
-      this.generateModelField(model, field);
+      if (model_utils_exports.isIdField(field, decl) || !this.isInheritedFromDelegate(field, decl)) {
+        this.generateModelField(model, field, decl);
+      }
     }
-    for (const attr of decl.attributes.filter((attr2) => this.isPrismaAttribute(attr2))) {
+    const allAttributes = getAllAttributes(decl);
+    for (const attr of allAttributes.filter((attr2) => this.isPrismaAttribute(attr2) && !this.isInheritedMapAttribute(attr2, decl))) {
       this.generateContainerAttribute(model, attr);
     }
     decl.comments.forEach((c) => model.addComment(c));
+    this.generateDelegateRelationForBase(model, decl);
+    this.generateDelegateRelationForConcrete(model, decl);
+  }
+  isInheritedMapAttribute(attr, contextModel) {
+    if (attr.$container === contextModel) {
+      return false;
+    }
+    const attrName = attr.decl.ref?.name ?? attr.decl.$refText;
+    return attrName === "@@map";
   }
   isPrismaAttribute(attr) {
     if (!attr.decl.ref) {
@@ -659,12 +621,12 @@ var PrismaSchemaGenerator = class {
   getStringLiteral(node) {
     return isStringLiteral(node) ? node.value : void 0;
   }
-  generateModelField(model, field, addToFront = false) {
+  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)) {
+      if (isTypeDef2(field.type.reference.ref)) {
         fieldType = "Json";
       } else {
         fieldType = field.type.reference.ref.name;
@@ -680,12 +642,12 @@ var PrismaSchemaGenerator = class {
     }
     const isArray = (
       // typed-JSON fields should be translated to scalar Json type
-      isTypeDef(field.type.reference?.ref) ? false : field.type.array
+      isTypeDef2(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.isDefaultWithPluginInvocation(attr)).filter((attr) => (
+    const attributes = field.attributes.filter((attr) => this.isPrismaAttribute(attr)).filter((attr) => !this.isDefaultWithAuthInvocation(attr)).filter((attr) => (
       // when building physical schema, exclude `@default` for id fields inherited from delegate base
-      !(model_utils_exports.isIdField(field) && this.isInheritedFromDelegate(field) && attr.decl.$refText === "@default")
+      !(model_utils_exports.isIdField(field, contextModel) && this.isInheritedFromDelegate(field, contextModel) && attr.decl.$refText === "@default")
     )).map((attr) => this.makeFieldAttribute(attr));
     const docs = [
       ...field.comments
@@ -693,7 +655,7 @@ var PrismaSchemaGenerator = class {
     const result = model.addField(field.name, type, attributes, docs, addToFront);
     return result;
   }
-  isDefaultWithPluginInvocation(attr) {
+  isDefaultWithAuthInvocation(attr) {
     if (attr.decl.ref?.name !== "@default") {
       return false;
     }
@@ -701,22 +663,10 @@ var PrismaSchemaGenerator = class {
     if (!expr) {
       return false;
     }
-    return AstUtils.streamAst(expr).some((node) => isInvocationExpr(node) && this.isFromPlugin(node.function.ref));
-  }
-  isFromPlugin(node) {
-    const model = AstUtils.getContainerOfType(node, isModel2);
-    return !!model && !!model.$document && model.$document.uri.path.endsWith("plugin.zmodel");
+    return AstUtils.streamAst(expr).some(isAuthInvocation);
   }
-  setDummyDefault(result, field) {
-    const dummyDefaultValue = match(field.type.type).with("String", () => new AttributeArgValue("String", "")).with(P.union("Int", "BigInt", "Float", "Decimal"), () => new AttributeArgValue("Number", "0")).with("Boolean", () => new AttributeArgValue("Boolean", "false")).with("DateTime", () => new AttributeArgValue("FunctionCall", new FunctionCall("now"))).with("Json", () => new AttributeArgValue("String", "{}")).with("Bytes", () => new AttributeArgValue("String", "")).otherwise(() => {
-      throw new Error(`Unsupported field type with default value: ${field.type.type}`);
-    });
-    result.attributes.push(new FieldAttribute("@default", [
-      new AttributeArg(void 0, dummyDefaultValue)
-    ]));
-  }
-  isInheritedFromDelegate(field) {
-    return field.$inheritedFrom && model_utils_exports.isDelegateModel(field.$inheritedFrom);
+  isInheritedFromDelegate(field, contextModel) {
+    return field.$container !== contextModel && model_utils_exports.isDelegateModel(field.$container);
   }
   makeFieldAttribute(attr) {
     const attrName = attr.decl.ref.name;
@@ -729,9 +679,9 @@ var PrismaSchemaGenerator = class {
     if (isLiteralExpr2(node)) {
       const argType = match(node.$type).with(StringLiteral, () => "String").with(NumberLiteral, () => "Number").with(BooleanLiteral, () => "Boolean").exhaustive();
       return new AttributeArgValue(argType, node.value);
-    } else if (isArrayExpr2(node)) {
+    } else if (isArrayExpr(node)) {
       return new AttributeArgValue("Array", new Array(...node.items.map((item) => this.makeAttributeArgValue(item))));
-    } else if (isReferenceExpr2(node)) {
+    } 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));
@@ -773,12 +723,66 @@ var PrismaSchemaGenerator = class {
     ];
     _enum.addField(field.name, attributes, docs);
   }
+  generateDelegateRelationForBase(model, decl) {
+    if (!isDelegateModel2(decl)) {
+      return;
+    }
+    const concreteModels = this.getConcreteModels(decl);
+    concreteModels.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 (!isDelegateModel2(dataModel)) {
+      return [];
+    }
+    return dataModel.$container.declarations.filter((d) => isDataModel2(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) {
+      const conflict = Array.from(this.shortNameMap.values()).find((v) => v === shortName);
+      if (!conflict) {
+        this.shortNameMap.set(name, shortName);
+        break;
+      }
+      index++;
+      shortName = `${baseName}_${index}`;
+    }
+    return shortName;
+  }
 };
 
 // src/ts-schema-generator.ts
 import { invariant } from "@zenstackhq/common-helpers";
-import { loadDocument } from "@zenstackhq/language";
-import { isArrayExpr as isArrayExpr3, isBinaryExpr, isDataModel as isDataModel2, isDataModelField, isDataSource, isEnum, isEnumField, isInvocationExpr as isInvocationExpr2, isLiteralExpr as isLiteralExpr3, isMemberAccessExpr, isNullExpr as isNullExpr2, isProcedure, isReferenceExpr as isReferenceExpr3, isThisExpr, isUnaryExpr } from "@zenstackhq/language/ast";
+import { isArrayExpr as isArrayExpr2, isBinaryExpr, isDataField, isDataModel as isDataModel3, isDataSource, isEnum, isEnumField, isInvocationExpr as isInvocationExpr2, isLiteralExpr as isLiteralExpr3, isMemberAccessExpr, isNullExpr as isNullExpr2, isProcedure, isReferenceExpr as isReferenceExpr2, isThisExpr, isTypeDef as isTypeDef3, isUnaryExpr } from "@zenstackhq/language/ast";
+import { getAllAttributes as getAllAttributes2, getAllFields as getAllFields3, isDataFieldReference } from "@zenstackhq/language/utils";
 import fs from "fs";
 import path from "path";
 import { match as match2 } from "ts-pattern";
@@ -787,41 +791,43 @@ var TsSchemaGenerator = class {
   static {
     __name(this, "TsSchemaGenerator");
   }
-  async generate(schemaFile, pluginModelFiles, outputFile) {
-    const loaded = await loadDocument(schemaFile, pluginModelFiles);
-    if (!loaded.success) {
-      throw new Error(`Error loading schema:${loaded.errors.join("\n")}`);
-    }
-    const { model, warnings } = loaded;
+  usedExpressionUtils = false;
+  async generate(model, outputDir) {
+    fs.mkdirSync(outputDir, {
+      recursive: true
+    });
+    this.usedExpressionUtils = false;
+    this.generateSchema(model, outputDir);
+    this.generateModelsAndTypeDefs(model, outputDir);
+    this.generateInputTypes(model, outputDir);
+  }
+  generateSchema(model, outputDir) {
     const statements = [];
     this.generateSchemaStatements(model, statements);
     this.generateBannerComments(statements);
-    const sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+    const schemaOutputFile = path.join(outputDir, "schema.ts");
+    const sourceFile = ts.createSourceFile(schemaOutputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
     const printer = ts.createPrinter();
     const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
-    fs.mkdirSync(path.dirname(outputFile), {
-      recursive: true
-    });
-    fs.writeFileSync(outputFile, result);
-    return {
-      model,
-      warnings
-    };
+    fs.writeFileSync(schemaOutputFile, result);
   }
   generateSchemaStatements(model, statements) {
-    const hasComputedFields = model.declarations.some((d) => isDataModel2(d) && d.fields.some((f) => hasAttribute(f, "@computed")));
+    const hasComputedFields = model.declarations.some((d) => isDataModel3(d) && d.fields.some((f) => hasAttribute(f, "@computed")));
+    const schemaObject = this.createSchemaObject(model);
     const runtimeImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
       ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("SchemaDef")),
       ...hasComputedFields ? [
         ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("OperandExpression"))
       ] : [],
-      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("ExpressionUtils"))
+      ...this.usedExpressionUtils ? [
+        ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("ExpressionUtils"))
+      ] : []
     ])), ts.factory.createStringLiteral("@zenstackhq/runtime/schema"));
     statements.push(runtimeImportDecl);
     const declaration = ts.factory.createVariableStatement([
       ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
     ], ts.factory.createVariableDeclarationList([
-      ts.factory.createVariableDeclaration("schema", void 0, void 0, ts.factory.createSatisfiesExpression(ts.factory.createAsExpression(this.createSchemaObject(model), ts.factory.createTypeReferenceNode("const")), ts.factory.createTypeReferenceNode("SchemaDef")))
+      ts.factory.createVariableDeclaration("schema", void 0, void 0, ts.factory.createSatisfiesExpression(ts.factory.createAsExpression(schemaObject, ts.factory.createTypeReferenceNode("const")), ts.factory.createTypeReferenceNode("SchemaDef")))
     ], ts.NodeFlags.Const));
     statements.push(declaration);
     const typeDeclaration = ts.factory.createTypeAliasDeclaration([
@@ -829,12 +835,20 @@ var TsSchemaGenerator = class {
     ], "SchemaType", void 0, ts.factory.createTypeReferenceNode("typeof schema"));
     statements.push(typeDeclaration);
   }
+  createExpressionUtilsCall(method, args) {
+    this.usedExpressionUtils = true;
+    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("ExpressionUtils"), method), void 0, args || []);
+  }
   createSchemaObject(model) {
     const properties = [
       // provider
       ts.factory.createPropertyAssignment("provider", this.createProviderObject(model)),
       // models
-      ts.factory.createPropertyAssignment("models", this.createModelsObject(model))
+      ts.factory.createPropertyAssignment("models", this.createModelsObject(model)),
+      // typeDefs
+      ...model.declarations.some(isTypeDef3) ? [
+        ts.factory.createPropertyAssignment("typeDefs", this.createTypeDefsObject(model))
+      ] : []
     ];
     const enums = model.declarations.filter(isEnum);
     if (enums.length > 0) {
@@ -858,20 +872,48 @@ var TsSchemaGenerator = class {
     ], true);
   }
   createModelsObject(model) {
-    return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => isDataModel2(d) && !hasAttribute(d, "@@ignore")).map((dm) => ts.factory.createPropertyAssignment(dm.name, this.createDataModelObject(dm))), true);
+    return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => isDataModel3(d) && !hasAttribute(d, "@@ignore")).map((dm) => ts.factory.createPropertyAssignment(dm.name, this.createDataModelObject(dm))), true);
+  }
+  createTypeDefsObject(model) {
+    return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => isTypeDef3(d)).map((td) => ts.factory.createPropertyAssignment(td.name, this.createTypeDefObject(td))), true);
   }
   createDataModelObject(dm) {
+    const allFields = getAllFields3(dm);
+    const allAttributes = getAllAttributes2(dm).filter((attr) => {
+      if (attr.decl.$refText === "@@delegate" && attr.$container !== dm) {
+        return false;
+      }
+      return true;
+    });
+    const subModels = this.getSubModels(dm);
     const fields = [
+      // name
+      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(dm.name)),
+      // baseModel
+      ...dm.baseModel ? [
+        ts.factory.createPropertyAssignment("baseModel", ts.factory.createStringLiteral(dm.baseModel.$refText))
+      ] : [],
       // fields
-      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(dm.fields.filter((field) => !hasAttribute(field, "@ignore")).map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataModelFieldObject(field))), true)),
+      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, dm))), true)),
       // attributes
-      ...dm.attributes.length > 0 ? [
-        ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(dm.attributes.map((attr) => this.createAttributeObject(attr)), true))
+      ...allAttributes.length > 0 ? [
+        ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true))
       ] : [],
       // idFields
-      ts.factory.createPropertyAssignment("idFields", ts.factory.createArrayLiteralExpression(this.getIdFields(dm).map((idField) => ts.factory.createStringLiteral(idField)))),
+      ts.factory.createPropertyAssignment("idFields", ts.factory.createArrayLiteralExpression(getIdFields(dm).map((idField) => ts.factory.createStringLiteral(idField)))),
       // uniqueFields
-      ts.factory.createPropertyAssignment("uniqueFields", this.createUniqueFieldsObject(dm))
+      ts.factory.createPropertyAssignment("uniqueFields", this.createUniqueFieldsObject(dm)),
+      // isDelegate
+      ...isDelegateModel(dm) ? [
+        ts.factory.createPropertyAssignment("isDelegate", ts.factory.createTrue())
+      ] : [],
+      // subModels
+      ...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 = dm.fields.filter((f) => hasAttribute(f, "@computed"));
     if (computedFields.length > 0) {
@@ -879,8 +921,31 @@ var TsSchemaGenerator = class {
     }
     return ts.factory.createObjectLiteralExpression(fields, true);
   }
+  getSubModels(dm) {
+    return dm.$container.declarations.filter(isDataModel3).filter((d) => d.baseModel?.ref === dm).map((d) => d.name);
+  }
+  createTypeDefObject(td) {
+    const allFields = getAllFields3(td);
+    const allAttributes = getAllAttributes2(td);
+    const fields = [
+      // name
+      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(td.name)),
+      // fields
+      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, void 0))), true)),
+      // attributes
+      ...allAttributes.length > 0 ? [
+        ts.factory.createPropertyAssignment("attributes", 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.createTypeReferenceNode("OperandExpression", [
+    return ts.factory.createObjectLiteralExpression(fields.map((field) => ts.factory.createMethodDeclaration(void 0, void 0, field.name, void 0, void 0, [
+      // parameter: `context: { modelAlias: string }`
+      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("OperandExpression", [
       ts.factory.createTypeReferenceNode(this.mapFieldTypeToTSType(field.type))
     ]), ts.factory.createBlock([
       ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier("Error"), void 0, [
@@ -898,11 +963,14 @@ var TsSchemaGenerator = class {
     }
     return result;
   }
-  createDataModelFieldObject(field) {
+  createDataFieldObject(field, contextModel) {
     const objectFields = [
+      // name
+      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(field.name)),
+      // type
       ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))
     ];
-    if (isIdField(field)) {
+    if (contextModel && model_utils_exports.isIdField(field, contextModel)) {
       objectFields.push(ts.factory.createPropertyAssignment("id", ts.factory.createTrue()));
     }
     if (isUniqueField(field)) {
@@ -917,6 +985,13 @@ var TsSchemaGenerator = class {
     if (hasAttribute(field, "@updatedAt")) {
       objectFields.push(ts.factory.createPropertyAssignment("updatedAt", ts.factory.createTrue()));
     }
+    if (contextModel && // id fields are duplicated in inherited models
+    !isIdField(field, contextModel) && field.$container !== contextModel && isDelegateModel(field.$container)) {
+      objectFields.push(ts.factory.createPropertyAssignment("originModel", ts.factory.createStringLiteral(field.$container.name)));
+    }
+    if (this.isDiscriminatorField(field)) {
+      objectFields.push(ts.factory.createPropertyAssignment("isDiscriminator", ts.factory.createTrue()));
+    }
     if (field.attributes.length > 0) {
       objectFields.push(ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(field.attributes.map((attr) => this.createAttributeObject(attr)))));
     }
@@ -924,15 +999,17 @@ var TsSchemaGenerator = class {
     if (defaultValue !== void 0) {
       if (typeof defaultValue === "object" && !Array.isArray(defaultValue)) {
         if ("call" in defaultValue) {
-          objectFields.push(ts.factory.createPropertyAssignment("default", ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.call"), void 0, [
+          objectFields.push(ts.factory.createPropertyAssignment("default", this.createExpressionUtilsCall("call", [
             ts.factory.createStringLiteral(defaultValue.call),
             ...defaultValue.args.length > 0 ? [
-              ts.factory.createArrayLiteralExpression(defaultValue.args.map((arg) => this.createLiteralNode(arg)))
+              ts.factory.createArrayLiteralExpression(defaultValue.args.map((arg) => this.createExpressionUtilsCall("literal", [
+                this.createLiteralNode(arg)
+              ])))
             ] : []
           ])));
         } else if ("authMember" in defaultValue) {
-          objectFields.push(ts.factory.createPropertyAssignment("default", ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.member"), void 0, [
-            ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.call"), void 0, [
+          objectFields.push(ts.factory.createPropertyAssignment("default", this.createExpressionUtilsCall("member", [
+            this.createExpressionUtilsCall("call", [
               ts.factory.createStringLiteral("auth")
             ]),
             ts.factory.createArrayLiteralExpression(defaultValue.authMember.map((m) => ts.factory.createStringLiteral(m)))
@@ -951,7 +1028,7 @@ var TsSchemaGenerator = class {
     if (hasAttribute(field, "@computed")) {
       objectFields.push(ts.factory.createPropertyAssignment("computed", ts.factory.createTrue()));
     }
-    if (isDataModel2(field.type.reference?.ref)) {
+    if (isDataModel3(field.type.reference?.ref)) {
       objectFields.push(ts.factory.createPropertyAssignment("relation", this.createRelationObject(field)));
     }
     const fkFor = this.getForeignKeyFor(field);
@@ -960,31 +1037,19 @@ var TsSchemaGenerator = class {
     }
     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(isLiteralExpr3(providerExpr), "Provider must be a literal");
     const type = providerExpr.value;
-    const urlExpr = dataSource.fields.find((f) => f.name === "url")?.value;
-    invariant(isLiteralExpr3(urlExpr) || isInvocationExpr2(urlExpr), "URL must be a literal or env function");
-    if (isLiteralExpr3(urlExpr)) {
-      return {
-        type,
-        url: urlExpr.value,
-        env: void 0
-      };
-    } else if (isInvocationExpr2(urlExpr)) {
-      invariant(urlExpr.function.$refText === "env", 'only "env" function is supported');
-      invariant(urlExpr.args.length === 1, "env function must have one argument");
-      return {
-        type,
-        env: urlExpr.args[0].value.value,
-        url: void 0
-      };
-    } else {
-      throw new Error("Unsupported URL type");
-    }
+    return {
+      type
+    };
   }
   getFieldMappedDefault(field) {
     const defaultAttr = getAttribute(field, "@default");
@@ -1004,9 +1069,9 @@ var TsSchemaGenerator = class {
         "Decimal",
         "BigInt"
       ].includes(fieldType.type) ? Number(lit) : lit;
-    } else if (isArrayExpr3(expr)) {
+    } else if (isArrayExpr2(expr)) {
       return expr.items.map((item) => this.getMappedValue(item, fieldType));
-    } else if (isReferenceExpr3(expr) && isEnumField(expr.target.ref)) {
+    } else if (isReferenceExpr2(expr) && isEnumField(expr.target.ref)) {
       return expr.target.ref.name;
     } else if (isInvocationExpr2(expr)) {
       return {
@@ -1072,7 +1137,7 @@ var TsSchemaGenerator = class {
     return ts.factory.createObjectLiteralExpression(relationFields);
   }
   getReferenceNames(expr) {
-    return isArrayExpr3(expr) && expr.items.map((item) => item.target.$refText);
+    return isArrayExpr2(expr) && expr.items.map((item) => item.target.$refText);
   }
   getForeignKeyFor(field) {
     const result = [];
@@ -1080,7 +1145,7 @@ var TsSchemaGenerator = class {
       const relation = getAttribute(f, "@relation");
       if (relation) {
         for (const arg of relation.args) {
-          if (arg.name === "fields" && isArrayExpr3(arg.value) && arg.value.items.some((el) => isReferenceExpr3(el) && el.target.ref === field)) {
+          if (arg.name === "fields" && isArrayExpr2(arg.value) && arg.value.items.some((el) => isReferenceExpr2(el) && el.target.ref === field)) {
             result.push(f.name);
           }
         }
@@ -1089,7 +1154,7 @@ var TsSchemaGenerator = class {
     return result;
   }
   getOppositeRelationField(field) {
-    if (!field.type.reference?.ref || !isDataModel2(field.type.reference?.ref)) {
+    if (!field.type.reference?.ref || !isDataModel3(field.type.reference?.ref)) {
       return void 0;
     }
     const sourceModel = field.$container;
@@ -1123,38 +1188,37 @@ var TsSchemaGenerator = class {
     }
     return void 0;
   }
-  getIdFields(dm) {
-    return dm.fields.filter(isIdField).map((f) => f.name);
-  }
   createUniqueFieldsObject(dm) {
     const properties = [];
-    for (const field of dm.fields) {
+    const allFields = getAllFields3(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 = getAllAttributes2(dm);
     const seenKeys = /* @__PURE__ */ new Set();
-    for (const attr of dm.attributes) {
+    for (const attr of allAttributes) {
       if (attr.decl.$refText === "@@id" || attr.decl.$refText === "@@unique") {
         const fieldNames = this.getReferenceNames(attr.args[0].value);
         if (!fieldNames) {
           continue;
         }
         if (fieldNames.length === 1) {
-          const fieldDef = dm.fields.find((f) => f.name === fieldNames[0]);
+          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 = fieldNames.join("_");
+          const key = this.getCompoundUniqueKey(attr, fieldNames);
           if (seenKeys.has(key)) {
             continue;
           }
           seenKeys.add(key);
-          properties.push(ts.factory.createPropertyAssignment(fieldNames.join("_"), ts.factory.createObjectLiteralExpression(fieldNames.map((field) => {
-            const fieldDef = dm.fields.find((f) => f.name === field);
+          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))
             ]));
@@ -1164,6 +1228,14 @@ var TsSchemaGenerator = class {
     }
     return ts.factory.createObjectLiteralExpression(properties, true);
   }
+  getCompoundUniqueKey(attr, fieldNames) {
+    const nameArg = attr.args.find((arg) => arg.$resolvedParam.name === "name");
+    if (nameArg && isLiteralExpr3(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");
@@ -1246,12 +1318,12 @@ var TsSchemaGenerator = class {
     ]);
   }
   createExpression(value) {
-    return match2(value).when(isLiteralExpr3, (expr) => this.createLiteralExpression(expr.$type, expr.value)).when(isInvocationExpr2, (expr) => this.createCallExpression(expr)).when(isReferenceExpr3, (expr) => this.createRefExpression(expr)).when(isArrayExpr3, (expr) => this.createArrayExpression(expr)).when(isUnaryExpr, (expr) => this.createUnaryExpression(expr)).when(isBinaryExpr, (expr) => this.createBinaryExpression(expr)).when(isMemberAccessExpr, (expr) => this.createMemberExpression(expr)).when(isNullExpr2, () => this.createNullExpression()).when(isThisExpr, () => this.createThisExpression()).otherwise(() => {
+    return match2(value).when(isLiteralExpr3, (expr) => this.createLiteralExpression(expr.$type, expr.value)).when(isInvocationExpr2, (expr) => this.createCallExpression(expr)).when(isReferenceExpr2, (expr) => this.createRefExpression(expr)).when(isArrayExpr2, (expr) => this.createArrayExpression(expr)).when(isUnaryExpr, (expr) => this.createUnaryExpression(expr)).when(isBinaryExpr, (expr) => this.createBinaryExpression(expr)).when(isMemberAccessExpr, (expr) => this.createMemberExpression(expr)).when(isNullExpr2, () => this.createNullExpression()).when(isThisExpr, () => this.createThisExpression()).otherwise(() => {
       throw new Error(`Unsupported attribute arg value: ${value.$type}`);
     });
   }
   createThisExpression() {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils._this"), void 0, []);
+    return this.createExpressionUtilsCall("_this");
   }
   createMemberExpression(expr) {
     const members = [];
@@ -1265,32 +1337,32 @@ var TsSchemaGenerator = class {
       this.createExpression(receiver),
       ts.factory.createArrayLiteralExpression(members.map((m) => ts.factory.createStringLiteral(m)))
     ];
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.member"), void 0, args);
+    return this.createExpressionUtilsCall("member", args);
   }
   createNullExpression() {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils._null"), void 0, []);
+    return this.createExpressionUtilsCall("_null");
   }
   createBinaryExpression(expr) {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.binary"), void 0, [
+    return this.createExpressionUtilsCall("binary", [
       this.createExpression(expr.left),
       this.createLiteralNode(expr.operator),
       this.createExpression(expr.right)
     ]);
   }
   createUnaryExpression(expr) {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.unary"), void 0, [
+    return this.createExpressionUtilsCall("unary", [
       this.createLiteralNode(expr.operator),
       this.createExpression(expr.operand)
     ]);
   }
   createArrayExpression(expr) {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.array"), void 0, [
+    return this.createExpressionUtilsCall("array", [
       ts.factory.createArrayLiteralExpression(expr.items.map((item) => this.createExpression(item)))
     ]);
   }
   createRefExpression(expr) {
-    if (isDataModelField(expr.target.ref)) {
-      return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.field"), void 0, [
+    if (isDataField(expr.target.ref)) {
+      return this.createExpressionUtilsCall("field", [
         this.createLiteralNode(expr.target.$refText)
       ]);
     } else if (isEnumField(expr.target.ref)) {
@@ -1300,7 +1372,7 @@ var TsSchemaGenerator = class {
     }
   }
   createCallExpression(expr) {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.call"), void 0, [
+    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)))
@@ -1308,20 +1380,164 @@ var TsSchemaGenerator = class {
     ]);
   }
   createLiteralExpression(type, value) {
-    return match2(type).with("BooleanLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+    return match2(type).with("BooleanLiteral", () => this.createExpressionUtilsCall("literal", [
       this.createLiteralNode(value)
-    ])).with("NumberLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+    ])).with("NumberLiteral", () => this.createExpressionUtilsCall("literal", [
       ts.factory.createIdentifier(value)
-    ])).with("StringLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+    ])).with("StringLiteral", () => this.createExpressionUtilsCall("literal", [
       this.createLiteralNode(value)
     ])).otherwise(() => {
       throw new Error(`Unsupported literal type: ${type}`);
     });
   }
+  generateModelsAndTypeDefs(model, outputDir) {
+    const statements = [];
+    statements.push(this.generateSchemaImport(model, true, true));
+    statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
+      ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier(`ModelResult as $ModelResult`)),
+      ...model.declarations.some(isTypeDef3) ? [
+        ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier(`TypeDefResult as $TypeDefResult`))
+      ] : []
+    ])), ts.factory.createStringLiteral("@zenstackhq/runtime")));
+    const dataModels = model.declarations.filter(isDataModel3);
+    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 = model.declarations.filter(isTypeDef3);
+    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.createIdentifier("$schema"), ts.factory.createIdentifier("enums")), ts.factory.createIdentifier(e.name)))
+      ], 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(outputDir, "models.ts");
+    const sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+    const printer = ts.createPrinter();
+    const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
+    fs.writeFileSync(outputFile, result);
+  }
+  generateSchemaImport(model, schemaObject, schemaType) {
+    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")));
+    }
+    return ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports(importSpecifiers)), ts.factory.createStringLiteral("./schema"));
+  }
+  generateDocs(tsDecl, decl) {
+    return ts.addSyntheticLeadingComment(tsDecl, ts.SyntaxKind.MultiLineCommentTrivia, `*
+ * ${decl.comments.map((c) => c.replace(/^\s*\/*\s*/, "")).join("\n * ")}
+ `, true);
+  }
+  generateInputTypes(model, outputDir) {
+    const dataModels = model.declarations.filter(isDataModel3);
+    const statements = [];
+    statements.push(this.generateSchemaImport(model, false, true));
+    const inputTypes = [
+      "FindManyArgs",
+      "FindUniqueArgs",
+      "FindFirstArgs",
+      "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.createStringLiteral("@zenstackhq/runtime")));
+    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("SimplifiedModelResult as $SimplifiedModelResult")),
+      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("SelectIncludeOmit as $SelectIncludeOmit"))
+    ])), ts.factory.createStringLiteral("@zenstackhq/runtime")));
+    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.createTypeReferenceNode("$SimplifiedModelResult", [
+        ts.factory.createTypeReferenceNode("$Schema"),
+        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),
+        ts.factory.createTypeReferenceNode("Args")
+      ])));
+    }
+    this.generateBannerComments(statements);
+    const outputFile = path.join(outputDir, "input.ts");
+    const sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+    const printer = ts.createPrinter();
+    const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
+    fs.writeFileSync(outputFile, result);
+  }
 };
 
 // src/zmodel-code-generator.ts
-import { ArrayExpr, Attribute, AttributeArg as AttributeArg2, AttributeParam, AttributeParamType, BinaryExpr, BinaryExprOperatorPriority, BooleanLiteral as BooleanLiteral2, ConfigArrayExpr, ConfigField, ConfigInvocationExpr, DataModel as DataModel2, DataModelAttribute, DataModelField, DataModelFieldAttribute, DataSource as DataSource3, Enum as Enum3, EnumField as EnumField2, FunctionDecl, FunctionParam, FunctionParamType, GeneratorDecl as GeneratorDecl2, InvocationExpr, LiteralExpr, MemberAccessExpr, Model as Model2, NullExpr, NumberLiteral as NumberLiteral2, ObjectExpr, Plugin, PluginField, ReferenceArg, ReferenceExpr, StringLiteral as StringLiteral2, ThisExpr, TypeDef, TypeDefField, UnaryExpr } from "@zenstackhq/language/ast";
+import { ArrayExpr, Attribute, AttributeArg as AttributeArg2, AttributeParam, AttributeParamType, BinaryExpr, BinaryExprOperatorPriority, BooleanLiteral as BooleanLiteral2, ConfigArrayExpr, ConfigField, ConfigInvocationExpr, DataField, DataFieldAttribute, DataModel as DataModel2, DataModelAttribute, DataSource as DataSource3, Enum as Enum3, EnumField as EnumField2, FunctionDecl, FunctionParam, FunctionParamType, GeneratorDecl as GeneratorDecl2, InvocationExpr, LiteralExpr, MemberAccessExpr, Model as Model2, NullExpr, NumberLiteral as NumberLiteral2, ObjectExpr, Plugin, PluginField, ReferenceArg, ReferenceExpr, StringLiteral as StringLiteral2, ThisExpr, TypeDef, UnaryExpr } from "@zenstackhq/language/ast";
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1409,21 +1625,21 @@ ${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
     return `${ast.name} = ${this.generate(ast.value)}`;
   }
   _generateDataModel(ast) {
-    return `${ast.isAbstract ? "abstract " : ""}${ast.isView ? "view" : "model"} ${ast.name}${ast.superTypes.length > 0 ? " extends " + ast.superTypes.map((x) => x.ref?.name).join(", ") : ""} {
+    return `${ast.isView ? "view" : "model"} ${ast.name}${ast.mixins.length > 0 ? " mixes " + ast.mixins.map((x) => x.ref?.name).join(", ") : ""} {
 ${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}${ast.attributes.length > 0 ? "\n\n" + ast.attributes.map((x) => this.indent + this.generate(x)).join("\n") : ""}
 }`;
   }
-  _generateDataModelField(ast) {
+  _generateDataField(ast) {
     return `${ast.name} ${this.fieldType(ast.type)}${ast.attributes.length > 0 ? " " + ast.attributes.map((x) => this.generate(x)).join(" ") : ""}`;
   }
   fieldType(type) {
-    const baseType = type.type ? type.type : type.$type == "DataModelFieldType" && type.unsupported ? "Unsupported(" + this.generate(type.unsupported.value) + ")" : type.reference?.$refText;
+    const baseType = type.type ? type.type : type.$type == "DataFieldType" && type.unsupported ? "Unsupported(" + this.generate(type.unsupported.value) + ")" : type.reference?.$refText;
     return `${baseType}${type.array ? "[]" : ""}${type.optional ? "?" : ""}`;
   }
   _generateDataModelAttribute(ast) {
     return this.attribute(ast);
   }
-  _generateDataModelFieldAttribute(ast) {
+  _generateDataFieldAttribute(ast) {
     return this.attribute(ast);
   }
   attribute(ast) {
@@ -1507,9 +1723,6 @@ ${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}${ast.attribu
 ${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}${ast.attributes.length > 0 ? "\n\n" + ast.attributes.map((x) => this.indent + this.generate(x)).join("\n") : ""}
 }`;
   }
-  _generateTypeDefField(ast) {
-    return `${ast.name} ${this.fieldType(ast.type)}${ast.attributes.length > 0 ? " " + ast.attributes.map((x) => this.generate(x)).join(" ") : ""}`;
-  }
   argument(ast) {
     return this.generate(ast.value);
   }
@@ -1635,13 +1848,13 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], ZModelCodeGenerator.prototype, "_generateDataModel", null);
 _ts_decorate([
-  gen(DataModelField),
+  gen(DataField),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof DataModelField === "undefined" ? Object : DataModelField
+    typeof DataField === "undefined" ? Object : DataField
   ]),
   _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataModelField", null);
+], ZModelCodeGenerator.prototype, "_generateDataField", null);
 _ts_decorate([
   gen(DataModelAttribute),
   _ts_metadata("design:type", Function),
@@ -1651,13 +1864,13 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], ZModelCodeGenerator.prototype, "_generateDataModelAttribute", null);
 _ts_decorate([
-  gen(DataModelFieldAttribute),
+  gen(DataFieldAttribute),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof DataModelFieldAttribute === "undefined" ? Object : DataModelFieldAttribute
+    typeof DataFieldAttribute === "undefined" ? Object : DataFieldAttribute
   ]),
   _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataModelFieldAttribute", null);
+], ZModelCodeGenerator.prototype, "_generateDataFieldAttribute", null);
 _ts_decorate([
   gen(AttributeArg2),
   _ts_metadata("design:type", Function),
@@ -1822,14 +2035,6 @@ _ts_decorate([
   ]),
   _ts_metadata("design:returntype", void 0)
 ], ZModelCodeGenerator.prototype, "_generateTypeDef", null);
-_ts_decorate([
-  gen(TypeDefField),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof TypeDefField === "undefined" ? Object : TypeDefField
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateTypeDefField", null);
 export {
   model_utils_exports as ModelUtils,
   PrismaSchemaGenerator,