@zenstackhq/sdk 3.0.0-alpha.2 → 3.0.0-alpha.20

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 } 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");
 }
@@ -156,11 +95,18 @@ function getAuthDecl(model) {
   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, isModel as isModel2, isNullExpr, isReferenceExpr, isStringLiteral, isTypeDef, NumberLiteral, StringLiteral } from "@zenstackhq/language/ast";
+import { getAllAttributes, getAllFields as getAllFields2, 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) {
@@ -285,9 +231,9 @@ var Model = class extends ContainerDeclaration {
   }
   name;
   isView;
-  fields;
+  fields = [];
   constructor(name, isView, documentations = []) {
-    super(documentations), this.name = name, this.isView = isView, this.fields = [];
+    super(documentations), this.name = name, this.isView = isView;
   }
   addField(name, type, attributes = [], documentations = [], addToFront = false) {
     const field = new ModelField(name, type, attributes, documentations);
@@ -507,9 +453,9 @@ var Enum = class extends ContainerDeclaration {
     __name(this, "Enum");
   }
   name;
-  fields;
+  fields = [];
   constructor(name, documentations = []) {
-    super(documentations), this.name = name, this.fields = [];
+    super(documentations), this.name = name;
   }
   addField(name, attributes = [], documentations = []) {
     const field = new EnumField(name, attributes, documentations);
@@ -553,20 +499,22 @@ 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");
   }
   zmodel;
-  PRELUDE;
-  constructor(zmodel) {
-    this.zmodel = zmodel;
-    this.PRELUDE = `//////////////////////////////////////////////////////////////////////////////////////////////
+  PRELUDE = `//////////////////////////////////////////////////////////////////////////////////////////////
 // DO NOT MODIFY THIS FILE                                                                  //
 // This file is automatically generated by ZenStack CLI and should not be manually updated. //
 //////////////////////////////////////////////////////////////////////////////////////////////
 
 `;
+  // a mapping from full names to shortened names
+  shortNameMap = /* @__PURE__ */ new Map();
+  constructor(zmodel) {
+    this.zmodel = zmodel;
   }
   async generate() {
     const prisma = new PrismaModel();
@@ -628,16 +576,22 @@ 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.generateContainerAttribute(model, attr);
     }
     decl.comments.forEach((c) => model.addComment(c));
+    this.generateDelegateRelationForBase(model, decl);
+    this.generateDelegateRelationForConcrete(model, decl);
   }
   isPrismaAttribute(attr) {
     if (!attr.decl.ref) {
@@ -660,7 +614,7 @@ 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;
@@ -686,7 +640,7 @@ var PrismaSchemaGenerator = class {
     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) => (
       // 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
@@ -708,16 +662,8 @@ var PrismaSchemaGenerator = class {
     const model = AstUtils.getContainerOfType(node, isModel2);
     return !!model && !!model.$document && model.$document.uri.path.endsWith("plugin.zmodel");
   }
-  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;
@@ -730,9 +676,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));
@@ -774,43 +720,100 @@ 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 fs from "node:fs";
-import path from "node:path";
-import invariant from "tiny-invariant";
+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 isTypeDef2, 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";
 import * as ts from "typescript";
 var TsSchemaGenerator = class {
   static {
     __name(this, "TsSchemaGenerator");
   }
-  async generate(schemaFile, pluginModelFiles, outputFile) {
+  async generate(schemaFile, pluginModelFiles, outputDir) {
     const loaded = await loadDocument(schemaFile, pluginModelFiles);
     if (!loaded.success) {
       throw new Error(`Error loading schema:${loaded.errors.join("\n")}`);
     }
-    const { model, warnings } = loaded;
+    const { model } = loaded;
+    fs.mkdirSync(outputDir, {
+      recursive: true
+    });
+    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 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 ? [
@@ -819,27 +822,6 @@ var TsSchemaGenerator = class {
       ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("ExpressionUtils"))
     ])), ts.factory.createStringLiteral("@zenstackhq/runtime/schema"));
     statements.push(runtimeImportDecl);
-    const { type: providerType } = this.getDataSourceProvider(model);
-    switch (providerType) {
-      case "sqlite": {
-        const pathImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, ts.factory.createIdentifier("path"), void 0), ts.factory.createStringLiteral("node:path"));
-        statements.push(pathImportDecl);
-        const urlImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, ts.factory.createIdentifier("url"), void 0), ts.factory.createStringLiteral("node:url"));
-        statements.push(urlImportDecl);
-        const dialectConfigImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
-          ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("toDialectConfig"))
-        ])), ts.factory.createStringLiteral("@zenstackhq/runtime/utils/sqlite-utils"));
-        statements.push(dialectConfigImportDecl);
-        break;
-      }
-      case "postgresql": {
-        const dialectConfigImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
-          ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("toDialectConfig"))
-        ])), ts.factory.createStringLiteral("@zenstackhq/runtime/utils/pg-utils"));
-        statements.push(dialectConfigImportDecl);
-        break;
-      }
-    }
     const declaration = ts.factory.createVariableStatement([
       ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
     ], ts.factory.createVariableDeclarationList([
@@ -856,7 +838,11 @@ var TsSchemaGenerator = class {
       // 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(isTypeDef2) ? [
+        ts.factory.createPropertyAssignment("typeDefs", this.createTypeDefsObject(model))
+      ] : []
     ];
     const enums = model.declarations.filter(isEnum);
     if (enums.length > 0) {
@@ -876,25 +862,49 @@ var TsSchemaGenerator = class {
   createProviderObject(model) {
     const dsProvider = this.getDataSourceProvider(model);
     return ts.factory.createObjectLiteralExpression([
-      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider.type)),
-      ts.factory.createPropertyAssignment("dialectConfigProvider", this.createDialectConfigProvider(dsProvider))
+      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider.type))
     ], 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) => isTypeDef2(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))))
+      ] : []
     ];
     const computedFields = dm.fields.filter((f) => hasAttribute(f, "@computed"));
     if (computedFields.length > 0) {
@@ -902,23 +912,51 @@ 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", [
-      ts.factory.createKeywordTypeNode(this.mapTypeToTSSyntaxKeyword(field.type.type))
+      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);
   }
-  mapTypeToTSSyntaxKeyword(type) {
-    return match2(type).with("String", () => ts.SyntaxKind.StringKeyword).with("Boolean", () => ts.SyntaxKind.BooleanKeyword).with("Int", () => ts.SyntaxKind.NumberKeyword).with("Float", () => ts.SyntaxKind.NumberKeyword).with("BigInt", () => ts.SyntaxKind.BigIntKeyword).with("Decimal", () => ts.SyntaxKind.NumberKeyword).otherwise(() => ts.SyntaxKind.UnknownKeyword);
+  mapFieldTypeToTSType(type) {
+    let result = match2(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;
   }
-  createDataModelFieldObject(field) {
+  createDataFieldObject(field, contextModel) {
     const objectFields = [
-      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(field.type.type ?? field.type.reference.$refText))
+      // 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)) {
@@ -933,12 +971,19 @@ 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)))));
     }
-    const defaultValue = this.getMappedDefault(field);
+    const defaultValue = this.getFieldMappedDefault(field);
     if (defaultValue !== void 0) {
-      if (typeof defaultValue === "object") {
+      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, [
             ts.factory.createStringLiteral(defaultValue.call),
@@ -957,13 +1002,17 @@ var TsSchemaGenerator = class {
           throw new Error(`Unsupported default value type for field ${field.name}`);
         }
       } else {
-        objectFields.push(ts.factory.createPropertyAssignment("default", typeof defaultValue === "string" ? ts.factory.createStringLiteral(defaultValue) : typeof defaultValue === "number" ? ts.factory.createNumericLiteral(defaultValue) : defaultValue === true ? ts.factory.createTrue() : ts.factory.createFalse()));
+        if (Array.isArray(defaultValue)) {
+          objectFields.push(ts.factory.createPropertyAssignment("default", ts.factory.createArrayLiteralExpression(defaultValue.map((item) => this.createLiteralNode(item)))));
+        } else {
+          objectFields.push(ts.factory.createPropertyAssignment("default", this.createLiteralNode(defaultValue)));
+        }
       }
     }
     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);
@@ -972,60 +1021,53 @@ 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
+    };
   }
-  getMappedDefault(field) {
+  getFieldMappedDefault(field) {
     const defaultAttr = getAttribute(field, "@default");
     if (!defaultAttr) {
       return void 0;
     }
     const defaultValue = defaultAttr.args[0]?.value;
     invariant(defaultValue, "Expected a default value");
-    if (isLiteralExpr3(defaultValue)) {
-      const lit = defaultValue.value;
-      return field.type.type === "Boolean" ? lit : [
+    return this.getMappedValue(defaultValue, field.type);
+  }
+  getMappedValue(expr, fieldType) {
+    if (isLiteralExpr3(expr)) {
+      const lit = expr.value;
+      return fieldType.type === "Boolean" ? lit : [
         "Int",
         "Float",
         "Decimal",
         "BigInt"
-      ].includes(field.type.type) ? Number(lit) : lit;
-    } else if (isReferenceExpr3(defaultValue) && isEnumField(defaultValue.target.ref)) {
-      return defaultValue.target.ref.name;
-    } else if (isInvocationExpr2(defaultValue)) {
+      ].includes(fieldType.type) ? Number(lit) : lit;
+    } else if (isArrayExpr2(expr)) {
+      return expr.items.map((item) => this.getMappedValue(item, fieldType));
+    } else if (isReferenceExpr2(expr) && isEnumField(expr.target.ref)) {
+      return expr.target.ref.name;
+    } else if (isInvocationExpr2(expr)) {
       return {
-        call: defaultValue.function.$refText,
-        args: defaultValue.args.map((arg) => this.getLiteral(arg.value))
+        call: expr.function.$refText,
+        args: expr.args.map((arg) => this.getLiteral(arg.value))
       };
-    } else if (this.isAuthMemberAccess(defaultValue)) {
+    } else if (this.isAuthMemberAccess(expr)) {
       return {
-        authMember: this.getMemberAccessChain(defaultValue)
+        authMember: this.getMemberAccessChain(expr)
       };
     } else {
-      throw new Error(`Unsupported default value type for field ${field.name}`);
+      throw new Error(`Unsupported default value type for ${expr.$type}`);
     }
   }
   getMemberAccessChain(expr) {
@@ -1079,7 +1121,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 = [];
@@ -1087,7 +1129,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);
           }
         }
@@ -1096,7 +1138,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;
@@ -1130,34 +1172,39 @@ 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", ts.factory.createStringLiteral(field.type.type))
+          ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))
         ])));
       }
     }
-    for (const attr of dm.attributes) {
+    const allAttributes = getAllAttributes2(dm);
+    const seenKeys = /* @__PURE__ */ new Set();
+    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", ts.factory.createStringLiteral(fieldDef.type.type))
+            ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))
           ])));
         } else {
+          const key = fieldNames.join("_");
+          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);
+            const fieldDef = allFields.find((f) => f.name === field);
             return ts.factory.createPropertyAssignment(field, ts.factory.createObjectLiteralExpression([
-              ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(fieldDef.type.type))
+              ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))
             ]));
           }))));
         }
@@ -1165,6 +1212,10 @@ var TsSchemaGenerator = class {
     }
     return ts.factory.createObjectLiteralExpression(properties, true);
   }
+  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(e.fields.map((field) => ts.factory.createPropertyAssignment(field.name, ts.factory.createStringLiteral(field.name))), true);
   }
@@ -1185,44 +1236,6 @@ var TsSchemaGenerator = class {
   createLiteralNode(arg) {
     return arg === null ? ts.factory.createNull() : typeof arg === "string" ? ts.factory.createStringLiteral(arg) : typeof arg === "number" ? ts.factory.createNumericLiteral(arg) : arg === true ? ts.factory.createTrue() : arg === false ? ts.factory.createFalse() : void 0;
   }
-  createDialectConfigProvider(dsProvider) {
-    const type = dsProvider.type;
-    let urlExpr;
-    if (dsProvider.env !== void 0) {
-      urlExpr = ts.factory.createIdentifier(`process.env['${dsProvider.env}']`);
-    } else {
-      urlExpr = ts.factory.createStringLiteral(dsProvider.url);
-      if (type === "sqlite") {
-        let parsedUrl;
-        try {
-          parsedUrl = new URL(dsProvider.url);
-        } catch {
-        }
-        if (parsedUrl) {
-          if (parsedUrl.protocol !== "file:") {
-            throw new Error("Invalid SQLite URL: only file protocol is supported");
-          }
-          urlExpr = ts.factory.createStringLiteral(dsProvider.url.replace(/^file:/, ""));
-        }
-      }
-    }
-    return match2(type).with("sqlite", () => {
-      return ts.factory.createFunctionExpression(void 0, void 0, void 0, void 0, void 0, void 0, ts.factory.createBlock([
-        ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("toDialectConfig"), void 0, [
-          urlExpr,
-          ts.factory.createIdentifier(`typeof __dirname !== 'undefined' ? __dirname : path.dirname(url.fileURLToPath(import.meta.url))`)
-        ]))
-      ], true));
-    }).with("postgresql", () => {
-      return ts.factory.createFunctionExpression(void 0, void 0, void 0, void 0, void 0, void 0, ts.factory.createBlock([
-        ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("toDialectConfig"), void 0, [
-          urlExpr
-        ]))
-      ], true));
-    }).otherwise(() => {
-      throw new Error(`Unsupported provider: ${type}`);
-    });
-  }
   createProceduresObject(procedures) {
     return ts.factory.createObjectLiteralExpression(procedures.map((proc) => ts.factory.createPropertyAssignment(proc.name, this.createProcedureObject(proc))), true);
   }
@@ -1257,6 +1270,8 @@ var TsSchemaGenerator = class {
 // This file is automatically generated by ZenStack CLI and should not be manually updated. //
 //////////////////////////////////////////////////////////////////////////////////////////////
 
+/* eslint-disable */
+
 `;
     ts.addSyntheticLeadingComment(statements[0], ts.SyntaxKind.SingleLineCommentTrivia, banner);
   }
@@ -1279,7 +1294,7 @@ 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}`);
     });
   }
@@ -1322,7 +1337,7 @@ var TsSchemaGenerator = class {
     ]);
   }
   createRefExpression(expr) {
-    if (isDataModelField(expr.target.ref)) {
+    if (isDataField(expr.target.ref)) {
       return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.field"), void 0, [
         this.createLiteralNode(expr.target.$refText)
       ]);
@@ -1351,10 +1366,154 @@ var TsSchemaGenerator = class {
       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(isTypeDef2) ? [
+        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(isTypeDef2);
+    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);
@@ -1442,21 +1601,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) {
@@ -1540,9 +1699,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);
   }
@@ -1668,13 +1824,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),
@@ -1684,13 +1840,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),
@@ -1855,14 +2011,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,