@zenstackhq/sdk 3.0.0-alpha.12 → 3.0.0-alpha.14

package/dist/index.cjs

@@ -41,12 +41,11 @@ module.exports = __toCommonJS(src_exports);
 // 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,
@@ -55,23 +54,24 @@ __export(model_utils_exports, {
   resolved: () => resolved
 });
 var import_ast = require("@zenstackhq/language/ast");
-function isIdField(field) {
+var import_utils = require("@zenstackhq/language/utils");
+function isIdField(field, contextModel) {
   if (hasAttribute(field, "@id")) {
     return true;
   }
-  const model = field.$container;
-  const modelLevelIds = getModelIdFields(model);
+  const modelLevelIds = (0, import_utils.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 = (0, import_utils.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 = (0, import_utils.getModelUniqueFields)(contextModel);
   if (modelLevelUnique.map((f) => f.name).includes(field.name)) {
     return true;
   }
@@ -86,67 +86,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 || !(0, import_ast.isArrayExpr)(fieldsArg.value)) {
-      continue;
-    }
-    return fieldsArg.value.items.filter((item) => (0, import_ast.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 || !(0, import_ast.isArrayExpr)(fieldsArg.value)) {
-      continue;
-    }
-    return fieldsArg.value.items.filter((item) => (0, import_ast.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 (0, import_ast.isDataModel)(node) && hasAttribute(node, "@@delegate");
 }
@@ -189,9 +128,16 @@ function getAuthDecl(model) {
   return found;
 }
 __name(getAuthDecl, "getAuthDecl");
+function getIdFields(dm) {
+  return (0, import_utils.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
+var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_ast2 = require("@zenstackhq/language/ast");
+var import_utils2 = require("@zenstackhq/language/utils");
 var import_langium = require("langium");
 var import_ts_pattern = require("ts-pattern");
 
@@ -586,6 +532,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");
@@ -597,6 +544,8 @@ var PrismaSchemaGenerator = class {
 //////////////////////////////////////////////////////////////////////////////////////////////
 
 `;
+  // a mapping from full names to shortened names
+  shortNameMap = /* @__PURE__ */ new Map();
   constructor(zmodel) {
     this.zmodel = zmodel;
   }
@@ -660,16 +609,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 = (0, import_utils2.getAllFields)(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 = (0, import_utils2.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) {
@@ -692,7 +647,7 @@ var PrismaSchemaGenerator = class {
   getStringLiteral(node) {
     return (0, import_ast2.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;
@@ -718,7 +673,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
@@ -740,16 +695,8 @@ var PrismaSchemaGenerator = class {
     const model = import_langium.AstUtils.getContainerOfType(node, import_ast2.isModel);
     return !!model && !!model.$document && model.$document.uri.path.endsWith("plugin.zmodel");
   }
-  setDummyDefault(result, field) {
-    const dummyDefaultValue = (0, import_ts_pattern.match)(field.type.type).with("String", () => new AttributeArgValue("String", "")).with(import_ts_pattern.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;
@@ -806,12 +753,67 @@ var PrismaSchemaGenerator = class {
     ];
     _enum.addField(field.name, attributes, docs);
   }
+  generateDelegateRelationForBase(model, decl) {
+    if (!(0, import_utils2.isDelegateModel)(decl)) {
+      return;
+    }
+    const concreteModels = this.getConcreteModels(decl);
+    concreteModels.forEach((concrete) => {
+      const auxName = this.truncate(`${DELEGATE_AUX_RELATION_PREFIX}_${(0, import_common_helpers.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}_${(0, import_common_helpers.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 (!(0, import_utils2.isDelegateModel)(dataModel)) {
+      return [];
+    }
+    return dataModel.$container.declarations.filter((d) => (0, import_ast2.isDataModel)(d) && d !== dataModel && d.baseModel?.ref === dataModel);
+  }
+  truncate(name) {
+    if (name.length <= IDENTIFIER_NAME_MAX_LENGTH) {
+      return name;
+    }
+    const existing = this.shortNameMap.get(name);
+    if (existing) {
+      return existing;
+    }
+    const baseName = name.slice(0, IDENTIFIER_NAME_MAX_LENGTH);
+    let index = 0;
+    let shortName = `${baseName}_${index}`;
+    while (true) {
+      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
-var import_common_helpers = require("@zenstackhq/common-helpers");
+var import_common_helpers2 = require("@zenstackhq/common-helpers");
 var import_language = require("@zenstackhq/language");
 var import_ast3 = require("@zenstackhq/language/ast");
+var import_utils3 = require("@zenstackhq/language/utils");
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
 var import_ts_pattern2 = require("ts-pattern");
@@ -830,7 +832,7 @@ var TsSchemaGenerator = class {
       recursive: true
     });
     this.generateSchema(model, outputDir);
-    this.generateModels(model, outputDir);
+    this.generateModelsAndTypeDefs(model, outputDir);
     this.generateInputTypes(model, outputDir);
   }
   generateSchema(model, outputDir) {
@@ -869,7 +871,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(import_ast3.isTypeDef) ? [
+        ts.factory.createPropertyAssignment("typeDefs", this.createTypeDefsObject(model))
+      ] : []
     ];
     const enums = model.declarations.filter(import_ast3.isEnum);
     if (enums.length > 0) {
@@ -895,18 +901,43 @@ var TsSchemaGenerator = class {
   createModelsObject(model) {
     return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => (0, import_ast3.isDataModel)(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) => (0, import_ast3.isTypeDef)(d)).map((td) => ts.factory.createPropertyAssignment(td.name, this.createTypeDefObject(td))), true);
+  }
   createDataModelObject(dm) {
+    const allFields = (0, import_utils3.getAllFields)(dm);
+    const allAttributes = (0, import_utils3.getAllAttributes)(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) {
@@ -914,6 +945,24 @@ var TsSchemaGenerator = class {
     }
     return ts.factory.createObjectLiteralExpression(fields, true);
   }
+  getSubModels(dm) {
+    return dm.$container.declarations.filter(import_ast3.isDataModel).filter((d) => d.baseModel?.ref === dm).map((d) => d.name);
+  }
+  createTypeDefObject(td) {
+    const allFields = (0, import_utils3.getAllFields)(td);
+    const allAttributes = (0, import_utils3.getAllAttributes)(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.createTypeReferenceNode(this.mapFieldTypeToTSType(field.type))
@@ -933,11 +982,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)) {
@@ -952,6 +1004,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)))));
     }
@@ -995,14 +1054,18 @@ 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" && (0, import_utils3.isDataFieldReference)(arg.value) && arg.value.target.ref === field);
+  }
   getDataSourceProvider(model) {
     const dataSource = model.declarations.find(import_ast3.isDataSource);
-    (0, import_common_helpers.invariant)(dataSource, "No data source found in the model");
+    (0, import_common_helpers2.invariant)(dataSource, "No data source found in the model");
     const providerExpr = dataSource.fields.find((f) => f.name === "provider")?.value;
-    (0, import_common_helpers.invariant)((0, import_ast3.isLiteralExpr)(providerExpr), "Provider must be a literal");
+    (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(providerExpr), "Provider must be a literal");
     const type = providerExpr.value;
     const urlExpr = dataSource.fields.find((f) => f.name === "url")?.value;
-    (0, import_common_helpers.invariant)((0, import_ast3.isLiteralExpr)(urlExpr) || (0, import_ast3.isInvocationExpr)(urlExpr), "URL must be a literal or env function");
+    (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(urlExpr) || (0, import_ast3.isInvocationExpr)(urlExpr), "URL must be a literal or env function");
     if ((0, import_ast3.isLiteralExpr)(urlExpr)) {
       return {
         type,
@@ -1010,8 +1073,8 @@ var TsSchemaGenerator = class {
         env: void 0
       };
     } else if ((0, import_ast3.isInvocationExpr)(urlExpr)) {
-      (0, import_common_helpers.invariant)(urlExpr.function.$refText === "env", 'only "env" function is supported');
-      (0, import_common_helpers.invariant)(urlExpr.args.length === 1, "env function must have one argument");
+      (0, import_common_helpers2.invariant)(urlExpr.function.$refText === "env", 'only "env" function is supported');
+      (0, import_common_helpers2.invariant)(urlExpr.args.length === 1, "env function must have one argument");
       return {
         type,
         env: urlExpr.args[0].value.value,
@@ -1027,7 +1090,7 @@ var TsSchemaGenerator = class {
       return void 0;
     }
     const defaultValue = defaultAttr.args[0]?.value;
-    (0, import_common_helpers.invariant)(defaultValue, "Expected a default value");
+    (0, import_common_helpers2.invariant)(defaultValue, "Expected a default value");
     return this.getMappedValue(defaultValue, field.type);
   }
   getMappedValue(expr, fieldType) {
@@ -1152,33 +1215,32 @@ var TsSchemaGenerator = class {
     if (relation) {
       const nameArg = relation.args.find((arg) => arg.$resolvedParam.name === "name");
       if (nameArg) {
-        (0, import_common_helpers.invariant)((0, import_ast3.isLiteralExpr)(nameArg.value), "name must be a literal");
+        (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(nameArg.value), "name must be a literal");
         return nameArg.value.value;
       }
     }
     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 = (0, import_utils3.getAllFields)(dm);
+    for (const field of allFields) {
       if (hasAttribute(field, "@id") || hasAttribute(field, "@unique")) {
         properties.push(ts.factory.createPropertyAssignment(field.name, ts.factory.createObjectLiteralExpression([
           ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))
         ])));
       }
     }
+    const allAttributes = (0, import_utils3.getAllAttributes)(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))
           ])));
@@ -1189,7 +1251,7 @@ var TsSchemaGenerator = class {
           }
           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", this.generateFieldTypeLiteral(fieldDef))
             ]));
@@ -1200,7 +1262,7 @@ var TsSchemaGenerator = class {
     return ts.factory.createObjectLiteralExpression(properties, true);
   }
   generateFieldTypeLiteral(field) {
-    (0, import_common_helpers.invariant)(field.type.type || field.type.reference || field.type.unsupported, "Field type must be a primitive, reference, or Unsupported");
+    (0, import_common_helpers2.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) {
@@ -1324,7 +1386,7 @@ var TsSchemaGenerator = class {
     ]);
   }
   createRefExpression(expr) {
-    if ((0, import_ast3.isDataModelField)(expr.target.ref)) {
+    if ((0, import_ast3.isDataField)(expr.target.ref)) {
       return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.field"), void 0, [
         this.createLiteralNode(expr.target.$refText)
       ]);
@@ -1353,11 +1415,14 @@ var TsSchemaGenerator = class {
       throw new Error(`Unsupported literal type: ${type}`);
     });
   }
-  generateModels(model, outputDir) {
+  generateModelsAndTypeDefs(model, outputDir) {
     const statements = [];
-    statements.push(this.generateSchemaTypeImport(true, true));
+    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`))
+      ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier(`ModelResult as $ModelResult`)),
+      ...model.declarations.some(import_ast3.isTypeDef) ? [
+        ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier(`TypeDefResult as $TypeDefResult`))
+      ] : []
     ])), ts.factory.createStringLiteral("@zenstackhq/runtime")));
     const dataModels = model.declarations.filter(import_ast3.isDataModel);
     for (const dm of dataModels) {
@@ -1372,6 +1437,19 @@ var TsSchemaGenerator = class {
       }
       statements.push(modelType);
     }
+    const typeDefs = model.declarations.filter(import_ast3.isTypeDef);
+    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(import_ast3.isEnum);
     for (const e of enums) {
       let enumDecl = ts.factory.createVariableStatement([
@@ -1398,10 +1476,12 @@ var TsSchemaGenerator = class {
     const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
     import_node_fs.default.writeFileSync(outputFile, result);
   }
-  generateSchemaTypeImport(schemaObject, schemaType) {
+  generateSchemaImport(model, schemaObject, schemaType) {
     const importSpecifiers = [];
     if (schemaObject) {
-      importSpecifiers.push(ts.factory.createImportSpecifier(false, ts.factory.createIdentifier("schema"), ts.factory.createIdentifier("$schema")));
+      if (model.declarations.some(import_ast3.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")));
@@ -1416,7 +1496,7 @@ var TsSchemaGenerator = class {
   generateInputTypes(model, outputDir) {
     const dataModels = model.declarations.filter(import_ast3.isDataModel);
     const statements = [];
-    statements.push(this.generateSchemaTypeImport(false, true));
+    statements.push(this.generateSchemaImport(model, false, true));
     const inputTypes = [
       "FindManyArgs",
       "FindUniqueArgs",
@@ -1570,21 +1650,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) {
@@ -1668,9 +1748,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);
   }
@@ -1796,13 +1873,13 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], ZModelCodeGenerator.prototype, "_generateDataModel", null);
 _ts_decorate([
-  gen(import_ast4.DataModelField),
+  gen(import_ast4.DataField),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof import_ast4.DataModelField === "undefined" ? Object : import_ast4.DataModelField
+    typeof import_ast4.DataField === "undefined" ? Object : import_ast4.DataField
   ]),
   _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataModelField", null);
+], ZModelCodeGenerator.prototype, "_generateDataField", null);
 _ts_decorate([
   gen(import_ast4.DataModelAttribute),
   _ts_metadata("design:type", Function),
@@ -1812,13 +1889,13 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], ZModelCodeGenerator.prototype, "_generateDataModelAttribute", null);
 _ts_decorate([
-  gen(import_ast4.DataModelFieldAttribute),
+  gen(import_ast4.DataFieldAttribute),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof import_ast4.DataModelFieldAttribute === "undefined" ? Object : import_ast4.DataModelFieldAttribute
+    typeof import_ast4.DataFieldAttribute === "undefined" ? Object : import_ast4.DataFieldAttribute
   ]),
   _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataModelFieldAttribute", null);
+], ZModelCodeGenerator.prototype, "_generateDataFieldAttribute", null);
 _ts_decorate([
   gen(import_ast4.AttributeArg),
   _ts_metadata("design:type", Function),
@@ -1983,14 +2060,6 @@ _ts_decorate([
   ]),
   _ts_metadata("design:returntype", void 0)
 ], ZModelCodeGenerator.prototype, "_generateTypeDef", null);
-_ts_decorate([
-  gen(import_ast4.TypeDefField),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.TypeDefField === "undefined" ? Object : import_ast4.TypeDefField
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateTypeDefField", null);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ModelUtils,