@zenstackhq/sdk 3.0.0-beta.3 → 3.0.0-beta.30

package/dist/index.js

@@ -20,7 +20,7 @@ __export(model_utils_exports, {
   isUniqueField: () => isUniqueField,
   resolved: () => resolved
 });
-import { isDataModel, isLiteralExpr, isModel } from "@zenstackhq/language/ast";
+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")) {
@@ -88,9 +88,9 @@ 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");
+    found = model.declarations.find((d) => (isDataModel(d) || isTypeDef(d)) && d.name === "User");
   }
   return found;
 }
@@ -103,8 +103,9 @@ var DELEGATE_AUX_RELATION_PREFIX = "delegate_aux";
 
 // src/prisma/prisma-schema-generator.ts
 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 { ZModelCodeGenerator } from "@zenstackhq/language";
+import { BooleanLiteral, DataModel, DataSource as DataSource2, Enum as Enum2, GeneratorDecl, isArrayExpr, isDataModel as isDataModel2, isDataSource, isGeneratorDecl, isInvocationExpr, isLiteralExpr as isLiteralExpr2, isNullExpr, isReferenceExpr, isStringLiteral, isTypeDef as isTypeDef2, NumberLiteral, StringLiteral } from "@zenstackhq/language/ast";
+import { getAllAttributes, getAllFields as getAllFields2, getStringLiteral, isAuthInvocation, isDelegateModel as isDelegateModel2 } from "@zenstackhq/language/utils";
 import { AstUtils } from "langium";
 import { match } from "ts-pattern";
 
@@ -500,6 +501,9 @@ var EnumField = class extends DeclarationBase {
 
 // src/prisma/prisma-schema-generator.ts
 var IDENTIFIER_NAME_MAX_LENGTH = 50 - DELEGATE_AUX_RELATION_PREFIX.length;
+var NON_PRISMA_DATASOURCE_FIELDS = [
+  "defaultSchema"
+];
 var PrismaSchemaGenerator = class {
   static {
     __name(this, "PrismaSchemaGenerator");
@@ -534,10 +538,13 @@ var PrismaSchemaGenerator = class {
           break;
       }
     }
+    if (!this.zmodel.declarations.some(isGeneratorDecl)) {
+      this.generateDefaultGenerator(prisma);
+    }
     return this.PRELUDE + prisma.toString();
   }
   generateDataSource(prisma, dataSource) {
-    const fields = dataSource.fields.map((f) => ({
+    const fields = dataSource.fields.filter((f) => !NON_PRISMA_DATASOURCE_FIELDS.includes(f.name)).map((f) => ({
       name: f.name,
       text: this.configExprToText(f.value)
     }));
@@ -574,6 +581,21 @@ var PrismaSchemaGenerator = class {
       text: this.configExprToText(f.value)
     })));
   }
+  generateDefaultGenerator(prisma) {
+    const gen = prisma.addGenerator("client", [
+      {
+        name: "provider",
+        text: '"prisma-client-js"'
+      }
+    ]);
+    const dataSource = this.zmodel.declarations.find(isDataSource);
+    if (dataSource?.fields.some((f) => f.name === "extensions")) {
+      gen.fields.push({
+        name: "previewFeatures",
+        text: '["postgresqlExtensions"]'
+      });
+    }
+  }
   generateModel(prisma, decl) {
     const model = decl.isView ? prisma.addView(decl.name) : prisma.addModel(decl.name);
     const allFields = getAllFields2(decl, true);
@@ -585,14 +607,30 @@ var PrismaSchemaGenerator = class {
         this.generateModelField(model, field, decl);
       }
     }
-    const allAttributes = getAllAttributes(decl);
-    for (const attr of allAttributes.filter((attr2) => this.isPrismaAttribute(attr2))) {
+    const allAttributes = getAllAttributes(decl).filter((attr) => this.isPrismaAttribute(attr));
+    for (const attr of allAttributes) {
       this.generateContainerAttribute(model, attr);
     }
+    if (this.datasourceHasSchemasSetting(decl.$container) && !allAttributes.some((attr) => attr.decl.ref?.name === "@@schema")) {
+      model.addAttribute("@@schema", [
+        new AttributeArg(void 0, new AttributeArgValue("String", this.getDefaultPostgresSchemaName(decl.$container)))
+      ]);
+    }
     decl.comments.forEach((c) => model.addComment(c));
     this.generateDelegateRelationForBase(model, decl);
     this.generateDelegateRelationForConcrete(model, decl);
   }
+  getDatasourceField(zmodel, fieldName) {
+    const dataSource = zmodel.declarations.find(isDataSource);
+    return dataSource?.fields.find((f) => f.name === fieldName);
+  }
+  datasourceHasSchemasSetting(zmodel) {
+    return !!this.getDatasourceField(zmodel, "schemas");
+  }
+  getDefaultPostgresSchemaName(zmodel) {
+    const defaultSchemaField = this.getDatasourceField(zmodel, "defaultSchema");
+    return getStringLiteral(defaultSchemaField?.value) ?? "public";
+  }
   isPrismaAttribute(attr) {
     if (!attr.decl.ref) {
       return false;
@@ -601,7 +639,7 @@ var PrismaSchemaGenerator = class {
   }
   getUnsupportedFieldType(fieldType) {
     if (fieldType.unsupported) {
-      const value = this.getStringLiteral(fieldType.unsupported.value);
+      const value = getStringLiteral(fieldType.unsupported.value);
       if (value) {
         return `Unsupported("${value}")`;
       } else {
@@ -611,15 +649,12 @@ var PrismaSchemaGenerator = class {
       return void 0;
     }
   }
-  getStringLiteral(node) {
-    return isStringLiteral(node) ? node.value : void 0;
-  }
   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;
@@ -635,10 +670,10 @@ 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, contextModel) && this.isInheritedFromDelegate(field, contextModel) && attr.decl.$refText === "@default")
     )).map((attr) => this.makeFieldAttribute(attr));
@@ -648,7 +683,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;
     }
@@ -656,11 +691,7 @@ 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);
   }
   isInheritedFromDelegate(field, contextModel) {
     return field.$container !== contextModel && model_utils_exports.isDelegateModel(field.$container);
@@ -708,9 +739,15 @@ var PrismaSchemaGenerator = class {
     for (const field of decl.fields) {
       this.generateEnumField(_enum, field);
     }
-    for (const attr of decl.attributes.filter((attr2) => this.isPrismaAttribute(attr2))) {
+    const allAttributes = decl.attributes.filter((attr) => this.isPrismaAttribute(attr));
+    for (const attr of allAttributes) {
       this.generateContainerAttribute(_enum, attr);
     }
+    if (this.datasourceHasSchemasSetting(decl.$container) && !allAttributes.some((attr) => attr.decl.ref?.name === "@@schema")) {
+      _enum.addAttribute("@@schema", [
+        new AttributeArg(void 0, new AttributeArgValue("String", this.getDefaultPostgresSchemaName(decl.$container)))
+      ]);
+    }
     decl.comments.forEach((c) => _enum.addComment(c));
   }
   generateEnumField(_enum, field) {
@@ -778,8 +815,8 @@ var PrismaSchemaGenerator = class {
 
 // src/ts-schema-generator.ts
 import { invariant } from "@zenstackhq/common-helpers";
-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 { isArrayExpr as isArrayExpr2, isBinaryExpr, isDataField, isDataModel as isDataModel3, isDataSource as isDataSource2, 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, getAttributeArg, isDataFieldReference } from "@zenstackhq/language/utils";
 import fs from "fs";
 import path from "path";
 import { match as match2 } from "ts-pattern";
@@ -788,86 +825,127 @@ var TsSchemaGenerator = class {
   static {
     __name(this, "TsSchemaGenerator");
   }
-  async generate(model, outputDir) {
-    fs.mkdirSync(outputDir, {
+  usedExpressionUtils = false;
+  async generate(model, options) {
+    fs.mkdirSync(options.outDir, {
       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 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.writeFileSync(schemaOutputFile, result);
+    this.usedExpressionUtils = false;
+    this.generateSchema(model, options);
+    this.generateModelsAndTypeDefs(model, options);
+    this.generateInputTypes(model, options);
+  }
+  generateSchema(model, options) {
+    const targets = [];
+    if (!options.liteOnly) {
+      targets.push({
+        lite: false,
+        file: "schema.ts"
+      });
+    }
+    if (options.lite || options.liteOnly) {
+      targets.push({
+        lite: true,
+        file: "schema-lite.ts"
+      });
+    }
+    for (const { lite, file } of targets) {
+      const statements = [];
+      this.generateSchemaStatements(model, statements, lite);
+      this.generateBannerComments(statements);
+      const schemaOutputFile = path.join(options.outDir, file);
+      const sourceFile = ts.createSourceFile(schemaOutputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+      const printer = ts.createPrinter();
+      const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
+      fs.writeFileSync(schemaOutputFile, result);
+    }
   }
-  generateSchemaStatements(model, statements) {
+  generateSchemaStatements(model, statements, lite) {
     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([
+    const schemaClass = this.createSchemaClass(model, lite);
+    const runtimeImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(void 0, void 0, ts.factory.createNamedImports([
       ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("SchemaDef")),
       ...hasComputedFields ? [
         ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("OperandExpression"))
       ] : [],
-      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("ExpressionUtils"))
-    ])), ts.factory.createStringLiteral("@zenstackhq/runtime/schema"));
+      ...this.usedExpressionUtils ? [
+        ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("ExpressionUtils"))
+      ] : []
+    ])), ts.factory.createStringLiteral("@zenstackhq/orm/schema"));
     statements.push(runtimeImportDecl);
-    const declaration = ts.factory.createVariableStatement([
+    statements.push(schemaClass);
+    const schemaDecl = ts.factory.createVariableStatement([
       ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
     ], ts.factory.createVariableDeclarationList([
-      ts.factory.createVariableDeclaration("schema", void 0, void 0, ts.factory.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.createNewExpression(ts.factory.createIdentifier("SchemaType"), void 0, []))
     ], ts.NodeFlags.Const));
-    statements.push(declaration);
-    const typeDeclaration = ts.factory.createTypeAliasDeclaration([
-      ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
-    ], "SchemaType", void 0, ts.factory.createTypeReferenceNode("typeof schema"));
-    statements.push(typeDeclaration);
+    statements.push(schemaDecl);
+  }
+  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 = [
+  createSchemaClass(model, lite) {
+    const members = [
       // provider
-      ts.factory.createPropertyAssignment("provider", this.createProviderObject(model)),
+      ts.factory.createPropertyDeclaration(void 0, "provider", void 0, void 0, this.createAsConst(this.createProviderObject(model))),
       // models
-      ts.factory.createPropertyAssignment("models", this.createModelsObject(model)),
+      ts.factory.createPropertyDeclaration(void 0, "models", void 0, void 0, this.createAsConst(this.createModelsObject(model, lite))),
       // typeDefs
-      ...model.declarations.some(isTypeDef2) ? [
-        ts.factory.createPropertyAssignment("typeDefs", this.createTypeDefsObject(model))
+      ...model.declarations.some(isTypeDef3) ? [
+        ts.factory.createPropertyDeclaration(void 0, "typeDefs", void 0, void 0, this.createAsConst(this.createTypeDefsObject(model, lite)))
       ] : []
     ];
     const enums = model.declarations.filter(isEnum);
     if (enums.length > 0) {
-      properties.push(ts.factory.createPropertyAssignment("enums", ts.factory.createObjectLiteralExpression(enums.map((e) => ts.factory.createPropertyAssignment(e.name, this.createEnumObject(e))), true)));
+      members.push(ts.factory.createPropertyDeclaration(void 0, "enums", void 0, void 0, this.createAsConst(ts.factory.createObjectLiteralExpression(enums.map((e) => ts.factory.createPropertyAssignment(e.name, this.createEnumObject(e))), true))));
     }
     const authType = getAuthDecl(model);
     if (authType) {
-      properties.push(ts.factory.createPropertyAssignment("authType", this.createLiteralNode(authType.name)));
+      members.push(ts.factory.createPropertyDeclaration(void 0, "authType", void 0, void 0, this.createAsConst(this.createLiteralNode(authType.name))));
     }
     const procedures = model.declarations.filter(isProcedure);
     if (procedures.length > 0) {
-      properties.push(ts.factory.createPropertyAssignment("procedures", this.createProceduresObject(procedures)));
+      members.push(ts.factory.createPropertyDeclaration(void 0, "procedures", void 0, void 0, this.createAsConst(this.createProceduresObject(procedures))));
     }
-    properties.push(ts.factory.createPropertyAssignment("plugins", ts.factory.createObjectLiteralExpression([], true)));
-    return ts.factory.createObjectLiteralExpression(properties, true);
+    members.push(ts.factory.createPropertyDeclaration(void 0, "plugins", void 0, void 0, ts.factory.createObjectLiteralExpression([], true)));
+    const schemaClass = ts.factory.createClassDeclaration([
+      ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+    ], "SchemaType", void 0, [
+      ts.factory.createHeritageClause(ts.SyntaxKind.ImplementsKeyword, [
+        ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier("SchemaDef"), void 0)
+      ])
+    ], members);
+    return schemaClass;
+  }
+  createAsConst(expr) {
+    return ts.factory.createAsExpression(expr, ts.factory.createTypeReferenceNode("const"));
   }
   createProviderObject(model) {
     const dsProvider = this.getDataSourceProvider(model);
+    const defaultSchema = this.getDataSourceDefaultSchema(model);
     return ts.factory.createObjectLiteralExpression([
-      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider.type))
+      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider)),
+      ...defaultSchema ? [
+        ts.factory.createPropertyAssignment("defaultSchema", ts.factory.createStringLiteral(defaultSchema))
+      ] : []
     ], true);
   }
-  createModelsObject(model) {
-    return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => isDataModel3(d) && !hasAttribute(d, "@@ignore")).map((dm) => ts.factory.createPropertyAssignment(dm.name, this.createDataModelObject(dm))), true);
+  createModelsObject(model, lite) {
+    return ts.factory.createObjectLiteralExpression(this.getAllDataModels(model).map((dm) => ts.factory.createPropertyAssignment(dm.name, this.createDataModelObject(dm, lite))), true);
+  }
+  getAllDataModels(model) {
+    return model.declarations.filter((d) => isDataModel3(d) && !hasAttribute(d, "@@ignore"));
   }
-  createTypeDefsObject(model) {
-    return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => isTypeDef2(d)).map((td) => ts.factory.createPropertyAssignment(td.name, this.createTypeDefObject(td))), true);
+  getAllTypeDefs(model) {
+    return model.declarations.filter((d) => isTypeDef3(d) && !hasAttribute(d, "@@ignore"));
   }
-  createDataModelObject(dm) {
+  createTypeDefsObject(model, lite) {
+    return ts.factory.createObjectLiteralExpression(this.getAllTypeDefs(model).map((td) => ts.factory.createPropertyAssignment(td.name, this.createTypeDefObject(td, lite))), true);
+  }
+  createDataModelObject(dm, lite) {
     const allFields = getAllFields3(dm);
-    const allAttributes = getAllAttributes2(dm).filter((attr) => {
+    const allAttributes = lite ? [] : getAllAttributes2(dm).filter((attr) => {
       if (attr.decl.$refText === "@@delegate" && attr.$container !== dm) {
         return false;
       }
@@ -882,7 +960,7 @@ var TsSchemaGenerator = class {
         ts.factory.createPropertyAssignment("baseModel", ts.factory.createStringLiteral(dm.baseModel.$refText))
       ] : [],
       // fields
-      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, dm))), true)),
+      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, dm, lite))), true)),
       // attributes
       ...allAttributes.length > 0 ? [
         ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true))
@@ -898,6 +976,9 @@ var TsSchemaGenerator = class {
       // 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"));
@@ -909,14 +990,14 @@ var TsSchemaGenerator = class {
   getSubModels(dm) {
     return dm.$container.declarations.filter(isDataModel3).filter((d) => d.baseModel?.ref === dm).map((d) => d.name);
   }
-  createTypeDefObject(td) {
+  createTypeDefObject(td, lite) {
     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)),
+      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, void 0, lite))), true)),
       // attributes
       ...allAttributes.length > 0 ? [
         ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true))
@@ -926,9 +1007,9 @@ var TsSchemaGenerator = class {
   }
   createComputedFieldsObject(fields) {
     return ts.factory.createObjectLiteralExpression(fields.map((field) => ts.factory.createMethodDeclaration(void 0, void 0, field.name, void 0, void 0, [
-      // parameter: `context: { currentModel: string }`
+      // parameter: `context: { modelAlias: string }`
       ts.factory.createParameterDeclaration(void 0, void 0, "_context", void 0, ts.factory.createTypeLiteralNode([
-        ts.factory.createPropertySignature(void 0, "currentModel", void 0, ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))
+        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))
@@ -948,7 +1029,7 @@ var TsSchemaGenerator = class {
     }
     return result;
   }
-  createDataFieldObject(field, contextModel) {
+  createDataFieldObject(field, contextModel, lite) {
     const objectFields = [
       // name
       ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(field.name)),
@@ -970,6 +1051,9 @@ var TsSchemaGenerator = class {
     if (hasAttribute(field, "@updatedAt")) {
       objectFields.push(ts.factory.createPropertyAssignment("updatedAt", ts.factory.createTrue()));
     }
+    if (hasAttribute(field, "@omit")) {
+      objectFields.push(ts.factory.createPropertyAssignment("omit", 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)));
@@ -977,22 +1061,24 @@ var TsSchemaGenerator = class {
     if (this.isDiscriminatorField(field)) {
       objectFields.push(ts.factory.createPropertyAssignment("isDiscriminator", ts.factory.createTrue()));
     }
-    if (field.attributes.length > 0) {
+    if (!lite && field.attributes.length > 0) {
       objectFields.push(ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(field.attributes.map((attr) => this.createAttributeObject(attr)))));
     }
     const defaultValue = this.getFieldMappedDefault(field);
     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)))
@@ -1025,14 +1111,21 @@ var TsSchemaGenerator = class {
     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);
+    const dataSource = model.declarations.find(isDataSource2);
     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;
-    return {
-      type
-    };
+    invariant(isLiteralExpr3(providerExpr) && typeof providerExpr.value === "string", "Provider must be a string literal");
+    return providerExpr.value;
+  }
+  getDataSourceDefaultSchema(model) {
+    const dataSource = model.declarations.find(isDataSource2);
+    invariant(dataSource, "No data source found in the model");
+    const defaultSchemaExpr = dataSource.fields.find((f) => f.name === "defaultSchema")?.value;
+    if (!defaultSchemaExpr) {
+      return void 0;
+    }
+    invariant(isLiteralExpr3(defaultSchemaExpr) && typeof defaultSchemaExpr.value === "string", "Default schema must be a string literal");
+    return defaultSchemaExpr.value;
   }
   getFieldMappedDefault(field) {
     const defaultAttr = getAttribute(field, "@default");
@@ -1102,12 +1195,16 @@ var TsSchemaGenerator = class {
       relationFields.push(ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(relationName)));
     }
     const relation = getAttribute(field, "@relation");
+    const fkFields = [];
     if (relation) {
       for (const arg of relation.args) {
         const param = arg.$resolvedParam.name;
         if (param === "fields" || param === "references") {
           const fieldNames = this.getReferenceNames(arg.value);
           if (fieldNames) {
+            if (param === "fields") {
+              fkFields.push(...fieldNames);
+            }
             relationFields.push(ts.factory.createPropertyAssignment(param, ts.factory.createArrayLiteralExpression(fieldNames.map((el) => ts.factory.createStringLiteral(el)))));
           }
         }
@@ -1117,6 +1214,15 @@ var TsSchemaGenerator = class {
         }
       }
     }
+    if (fkFields.length > 0) {
+      const allHaveDefault = fkFields.every((fieldName) => {
+        const fieldDef = field.$container.fields.find((f) => f.name === fieldName);
+        return fieldDef && hasAttribute(fieldDef, "@default");
+      });
+      if (allHaveDefault) {
+        relationFields.push(ts.factory.createPropertyAssignment("hasDefault", ts.factory.createTrue()));
+      }
+    }
     return ts.factory.createObjectLiteralExpression(relationFields);
   }
   getReferenceNames(expr) {
@@ -1185,7 +1291,11 @@ var TsSchemaGenerator = class {
     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);
+        const fieldsArg = getAttributeArg(attr, "fields");
+        if (!fieldsArg) {
+          continue;
+        }
+        const fieldNames = this.getReferenceNames(fieldsArg);
         if (!fieldNames) {
           continue;
         }
@@ -1224,7 +1334,21 @@ var TsSchemaGenerator = class {
     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);
+    return ts.factory.createObjectLiteralExpression([
+      ts.factory.createPropertyAssignment("values", ts.factory.createObjectLiteralExpression(e.fields.map((f) => ts.factory.createPropertyAssignment(f.name, ts.factory.createStringLiteral(f.name))), true)),
+      // only generate `fields` if there are attributes on the fields
+      ...e.fields.some((f) => f.attributes.length > 0) ? [
+        ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(e.fields.map((field) => ts.factory.createPropertyAssignment(field.name, ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(field.name)),
+          ...field.attributes.length > 0 ? [
+            ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(field.attributes?.map((attr) => this.createAttributeObject(attr)) ?? [], true))
+          ] : []
+        ], true))), true))
+      ] : [],
+      ...e.attributes.length > 0 ? [
+        ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(e.attributes.map((attr) => this.createAttributeObject(attr)), true))
+      ] : []
+    ], true);
   }
   getLiteral(expr) {
     if (!isLiteralExpr3(expr)) {
@@ -1241,7 +1365,10 @@ 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;
+    return arg === null ? ts.factory.createNull() : typeof arg === "string" ? ts.factory.createStringLiteral(arg) : typeof arg === "number" ? this.createNumberLiteral(arg) : arg === true ? ts.factory.createTrue() : arg === false ? ts.factory.createFalse() : void 0;
+  }
+  createNumberLiteral(arg) {
+    return arg < 0 ? ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(-arg)) : ts.factory.createNumericLiteral(arg);
   }
   createProceduresObject(procedures) {
     return ts.factory.createObjectLiteralExpression(procedures.map((proc) => ts.factory.createPropertyAssignment(proc.name, this.createProcedureObject(proc))), true);
@@ -1306,7 +1433,7 @@ var TsSchemaGenerator = class {
     });
   }
   createThisExpression() {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils._this"), void 0, []);
+    return this.createExpressionUtilsCall("_this");
   }
   createMemberExpression(expr) {
     const members = [];
@@ -1320,32 +1447,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 (isDataField(expr.target.ref)) {
-      return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.field"), void 0, [
+      return this.createExpressionUtilsCall("field", [
         this.createLiteralNode(expr.target.$refText)
       ]);
     } else if (isEnumField(expr.target.ref)) {
@@ -1355,7 +1482,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)))
@@ -1363,26 +1490,26 @@ 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) {
+  generateModelsAndTypeDefs(model, options) {
     const statements = [];
-    statements.push(this.generateSchemaImport(model, true, true));
+    statements.push(this.generateSchemaImport(model, true, true, !!(options.lite || options.liteOnly), options.importWithFileExtension));
     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) ? [
+      ...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);
+    ])), ts.factory.createStringLiteral("@zenstackhq/orm")));
+    const dataModels = this.getAllDataModels(model);
     for (const dm of dataModels) {
       let modelType = ts.factory.createTypeAliasDeclaration([
         ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
@@ -1395,7 +1522,7 @@ var TsSchemaGenerator = class {
       }
       statements.push(modelType);
     }
-    const typeDefs = model.declarations.filter(isTypeDef2);
+    const typeDefs = this.getAllTypeDefs(model);
     for (const td of typeDefs) {
       let typeDef = ts.factory.createTypeAliasDeclaration([
         ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
@@ -1413,7 +1540,7 @@ var TsSchemaGenerator = class {
       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.factory.createVariableDeclaration(e.name, void 0, void 0, ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("$schema"), ts.factory.createIdentifier("enums")), ts.factory.createIdentifier(e.name)), ts.factory.createIdentifier("values")))
       ], ts.NodeFlags.Const));
       if (e.comments.length > 0) {
         enumDecl = this.generateDocs(enumDecl, e);
@@ -1428,13 +1555,13 @@ var TsSchemaGenerator = class {
       statements.push(typeAlias);
     }
     this.generateBannerComments(statements);
-    const outputFile = path.join(outputDir, "models.ts");
+    const outputFile = path.join(options.outDir, "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) {
+  generateSchemaImport(model, schemaObject, schemaType, useLite, importWithFileExtension) {
     const importSpecifiers = [];
     if (schemaObject) {
       if (model.declarations.some(isEnum)) {
@@ -1444,17 +1571,21 @@ var TsSchemaGenerator = class {
     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"));
+    let importFrom = useLite ? "./schema-lite" : "./schema";
+    if (importWithFileExtension) {
+      importFrom += importWithFileExtension.startsWith(".") ? importWithFileExtension : `.${importWithFileExtension}`;
+    }
+    return ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports(importSpecifiers)), ts.factory.createStringLiteral(importFrom));
   }
   generateDocs(tsDecl, decl) {
     return ts.addSyntheticLeadingComment(tsDecl, ts.SyntaxKind.MultiLineCommentTrivia, `*
  * ${decl.comments.map((c) => c.replace(/^\s*\/*\s*/, "")).join("\n * ")}
  `, true);
   }
-  generateInputTypes(model, outputDir) {
-    const dataModels = model.declarations.filter(isDataModel3);
+  generateInputTypes(model, options) {
+    const dataModels = this.getAllDataModels(model);
     const statements = [];
-    statements.push(this.generateSchemaImport(model, false, true));
+    statements.push(this.generateSchemaImport(model, false, true, !!(options.lite || options.liteOnly), options.importWithFileExtension));
     const inputTypes = [
       "FindManyArgs",
       "FindUniqueArgs",
@@ -1481,11 +1612,14 @@ var TsSchemaGenerator = class {
       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")),
+      ...inputTypes.map((inputType) => ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(`${inputType} as $${inputType}`))),
+      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("QueryOptions as $QueryOptions"))
+    ])), ts.factory.createStringLiteral("@zenstackhq/orm")));
+    statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports([
+      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("SimplifiedPlainResult as $Result")),
       ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("SelectIncludeOmit as $SelectIncludeOmit"))
-    ])), ts.factory.createStringLiteral("@zenstackhq/runtime")));
+    ])), ts.factory.createStringLiteral("@zenstackhq/orm")));
     for (const dm of dataModels) {
       for (const inputType of inputTypes) {
         const exportName = inputTypeNameFixes[inputType] ? `${dm.name}${inputTypeNameFixes[inputType]}` : `${dm.name}${inputType}`;
@@ -1503,525 +1637,30 @@ var TsSchemaGenerator = class {
           ts.factory.createTypeReferenceNode("$Schema"),
           ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),
           ts.factory.createLiteralTypeNode(ts.factory.createTrue())
+        ])),
+        ts.factory.createTypeParameterDeclaration(void 0, "Options", ts.factory.createTypeReferenceNode("$QueryOptions", [
+          ts.factory.createTypeReferenceNode("$Schema")
+        ]), ts.factory.createTypeReferenceNode("$QueryOptions", [
+          ts.factory.createTypeReferenceNode("$Schema")
         ]))
-      ], ts.factory.createTypeReferenceNode("$SimplifiedModelResult", [
+      ], ts.factory.createTypeReferenceNode("$Result", [
         ts.factory.createTypeReferenceNode("$Schema"),
         ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),
-        ts.factory.createTypeReferenceNode("Args")
+        ts.factory.createTypeReferenceNode("Args"),
+        ts.factory.createTypeReferenceNode("Options")
       ])));
     }
     this.generateBannerComments(statements);
-    const outputFile = path.join(outputDir, "input.ts");
+    const outputFile = path.join(options.outDir, "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, 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);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata, "_ts_metadata");
-var generationHandlers = /* @__PURE__ */ new Map();
-function gen(name) {
-  return function(_target, _propertyKey, descriptor) {
-    if (!generationHandlers.get(name)) {
-      generationHandlers.set(name, descriptor);
-    }
-    return descriptor;
-  };
-}
-__name(gen, "gen");
-var ZModelCodeGenerator = class {
-  static {
-    __name(this, "ZModelCodeGenerator");
-  }
-  options;
-  constructor(options) {
-    this.options = {
-      binaryExprNumberOfSpaces: options?.binaryExprNumberOfSpaces ?? 1,
-      unaryExprNumberOfSpaces: options?.unaryExprNumberOfSpaces ?? 0,
-      indent: options?.indent ?? 4,
-      quote: options?.quote ?? "single"
-    };
-  }
-  /**
-   * Generates ZModel source code from AST.
-   */
-  generate(ast) {
-    const handler = generationHandlers.get(ast.$type);
-    if (!handler) {
-      throw new Error(`No generation handler found for ${ast.$type}`);
-    }
-    return handler.value.call(this, ast);
-  }
-  _generateModel(ast) {
-    return ast.declarations.map((d) => this.generate(d)).join("\n\n");
-  }
-  _generateDataSource(ast) {
-    return `datasource ${ast.name} {
-${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
-}`;
-  }
-  _generateEnum(ast) {
-    return `enum ${ast.name} {
-${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
-}`;
-  }
-  _generateEnumField(ast) {
-    return `${ast.name}${ast.attributes.length > 0 ? " " + ast.attributes.map((x) => this.generate(x)).join(" ") : ""}`;
-  }
-  _generateGenerator(ast) {
-    return `generator ${ast.name} {
-${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
-}`;
-  }
-  _generateConfigField(ast) {
-    return `${ast.name} = ${this.generate(ast.value)}`;
-  }
-  _generateConfigArrayExpr(ast) {
-    return `[${ast.items.map((x) => this.generate(x)).join(", ")}]`;
-  }
-  _generateConfigInvocationExpr(ast) {
-    if (ast.args.length === 0) {
-      return ast.name;
-    } else {
-      return `${ast.name}(${ast.args.map((x) => (x.name ? x.name + ": " : "") + this.generate(x.value)).join(", ")})`;
-    }
-  }
-  _generatePlugin(ast) {
-    return `plugin ${ast.name} {
-${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
-}`;
-  }
-  _generatePluginField(ast) {
-    return `${ast.name} = ${this.generate(ast.value)}`;
-  }
-  _generateDataModel(ast) {
-    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") : ""}
-}`;
-  }
-  _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 == "DataFieldType" && type.unsupported ? "Unsupported(" + this.generate(type.unsupported.value) + ")" : type.reference?.$refText;
-    return `${baseType}${type.array ? "[]" : ""}${type.optional ? "?" : ""}`;
-  }
-  _generateDataModelAttribute(ast) {
-    return this.attribute(ast);
-  }
-  _generateDataFieldAttribute(ast) {
-    return this.attribute(ast);
-  }
-  attribute(ast) {
-    const args = ast.args.length ? `(${ast.args.map((x) => this.generate(x)).join(", ")})` : "";
-    return `${resolved(ast.decl).name}${args}`;
-  }
-  _generateAttributeArg(ast) {
-    if (ast.name) {
-      return `${ast.name}: ${this.generate(ast.value)}`;
-    } else {
-      return this.generate(ast.value);
-    }
-  }
-  _generateObjectExpr(ast) {
-    return `{ ${ast.fields.map((field) => this.objectField(field)).join(", ")} }`;
-  }
-  objectField(field) {
-    return `${field.name}: ${this.generate(field.value)}`;
-  }
-  _generateArrayExpr(ast) {
-    return `[${ast.items.map((item) => this.generate(item)).join(", ")}]`;
-  }
-  _generateLiteralExpr(ast) {
-    return this.options.quote === "single" ? `'${ast.value}'` : `"${ast.value}"`;
-  }
-  _generateNumberLiteral(ast) {
-    return ast.value.toString();
-  }
-  _generateBooleanLiteral(ast) {
-    return ast.value.toString();
-  }
-  _generateUnaryExpr(ast) {
-    return `${ast.operator}${this.unaryExprSpace}${this.generate(ast.operand)}`;
-  }
-  _generateBinaryExpr(ast) {
-    const operator = ast.operator;
-    const isCollectionPredicate = this.isCollectionPredicateOperator(operator);
-    const rightExpr = this.generate(ast.right);
-    const { left: isLeftParenthesis, right: isRightParenthesis } = this.isParenthesesNeededForBinaryExpr(ast);
-    return `${isLeftParenthesis ? "(" : ""}${this.generate(ast.left)}${isLeftParenthesis ? ")" : ""}${isCollectionPredicate ? "" : this.binaryExprSpace}${operator}${isCollectionPredicate ? "" : this.binaryExprSpace}${isRightParenthesis ? "(" : ""}${isCollectionPredicate ? `[${rightExpr}]` : rightExpr}${isRightParenthesis ? ")" : ""}`;
-  }
-  _generateReferenceExpr(ast) {
-    const args = ast.args.length ? `(${ast.args.map((x) => this.generate(x)).join(", ")})` : "";
-    return `${ast.target.ref?.name}${args}`;
-  }
-  _generateReferenceArg(ast) {
-    return `${ast.name}:${this.generate(ast.value)}`;
-  }
-  _generateMemberExpr(ast) {
-    return `${this.generate(ast.operand)}.${ast.member.ref?.name}`;
-  }
-  _generateInvocationExpr(ast) {
-    return `${ast.function.ref?.name}(${ast.args.map((x) => this.argument(x)).join(", ")})`;
-  }
-  _generateNullExpr() {
-    return "null";
-  }
-  _generateThisExpr() {
-    return "this";
-  }
-  _generateAttribute(ast) {
-    return `attribute ${ast.name}(${ast.params.map((x) => this.generate(x)).join(", ")})`;
-  }
-  _generateAttributeParam(ast) {
-    return `${ast.default ? "_ " : ""}${ast.name}: ${this.generate(ast.type)}`;
-  }
-  _generateAttributeParamType(ast) {
-    return `${ast.type ?? ast.reference?.$refText}${ast.array ? "[]" : ""}${ast.optional ? "?" : ""}`;
-  }
-  _generateFunctionDecl(ast) {
-    return `function ${ast.name}(${ast.params.map((x) => this.generate(x)).join(", ")}) ${ast.returnType ? ": " + this.generate(ast.returnType) : ""} {}`;
-  }
-  _generateFunctionParam(ast) {
-    return `${ast.name}: ${this.generate(ast.type)}`;
-  }
-  _generateFunctionParamType(ast) {
-    return `${ast.type ?? ast.reference?.$refText}${ast.array ? "[]" : ""}`;
-  }
-  _generateTypeDef(ast) {
-    return `type ${ast.name} {
-${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") : ""}
-}`;
-  }
-  argument(ast) {
-    return this.generate(ast.value);
-  }
-  get binaryExprSpace() {
-    return " ".repeat(this.options.binaryExprNumberOfSpaces);
-  }
-  get unaryExprSpace() {
-    return " ".repeat(this.options.unaryExprNumberOfSpaces);
-  }
-  get indent() {
-    return " ".repeat(this.options.indent);
-  }
-  isParenthesesNeededForBinaryExpr(ast) {
-    const result = {
-      left: false,
-      right: false
-    };
-    const operator = ast.operator;
-    const isCollectionPredicate = this.isCollectionPredicateOperator(operator);
-    const currentPriority = BinaryExprOperatorPriority[operator];
-    if (ast.left.$type === BinaryExpr && BinaryExprOperatorPriority[ast.left["operator"]] < currentPriority) {
-      result.left = true;
-    }
-    if (!isCollectionPredicate && ast.right.$type === BinaryExpr && BinaryExprOperatorPriority[ast.right["operator"]] <= currentPriority) {
-      result.right = true;
-    }
-    return result;
-  }
-  isCollectionPredicateOperator(op) {
-    return [
-      "?",
-      "!",
-      "^"
-    ].includes(op);
-  }
-};
-_ts_decorate([
-  gen(Model2),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof Model2 === "undefined" ? Object : Model2
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateModel", null);
-_ts_decorate([
-  gen(DataSource3),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof DataSource3 === "undefined" ? Object : DataSource3
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataSource", null);
-_ts_decorate([
-  gen(Enum3),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof Enum3 === "undefined" ? Object : Enum3
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateEnum", null);
-_ts_decorate([
-  gen(EnumField2),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof EnumField2 === "undefined" ? Object : EnumField2
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateEnumField", null);
-_ts_decorate([
-  gen(GeneratorDecl2),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof GeneratorDecl2 === "undefined" ? Object : GeneratorDecl2
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateGenerator", null);
-_ts_decorate([
-  gen(ConfigField),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof ConfigField === "undefined" ? Object : ConfigField
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateConfigField", null);
-_ts_decorate([
-  gen(ConfigArrayExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof ConfigArrayExpr === "undefined" ? Object : ConfigArrayExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateConfigArrayExpr", null);
-_ts_decorate([
-  gen(ConfigInvocationExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof ConfigInvocationExpr === "undefined" ? Object : ConfigInvocationExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateConfigInvocationExpr", null);
-_ts_decorate([
-  gen(Plugin),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof Plugin === "undefined" ? Object : Plugin
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generatePlugin", null);
-_ts_decorate([
-  gen(PluginField),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof PluginField === "undefined" ? Object : PluginField
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generatePluginField", null);
-_ts_decorate([
-  gen(DataModel2),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof DataModel2 === "undefined" ? Object : DataModel2
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataModel", null);
-_ts_decorate([
-  gen(DataField),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof DataField === "undefined" ? Object : DataField
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataField", null);
-_ts_decorate([
-  gen(DataModelAttribute),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof DataModelAttribute === "undefined" ? Object : DataModelAttribute
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataModelAttribute", null);
-_ts_decorate([
-  gen(DataFieldAttribute),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof DataFieldAttribute === "undefined" ? Object : DataFieldAttribute
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataFieldAttribute", null);
-_ts_decorate([
-  gen(AttributeArg2),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof AttributeArg2 === "undefined" ? Object : AttributeArg2
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateAttributeArg", null);
-_ts_decorate([
-  gen(ObjectExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof ObjectExpr === "undefined" ? Object : ObjectExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateObjectExpr", null);
-_ts_decorate([
-  gen(ArrayExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof ArrayExpr === "undefined" ? Object : ArrayExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateArrayExpr", null);
-_ts_decorate([
-  gen(StringLiteral2),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof LiteralExpr === "undefined" ? Object : LiteralExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateLiteralExpr", null);
-_ts_decorate([
-  gen(NumberLiteral2),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof NumberLiteral2 === "undefined" ? Object : NumberLiteral2
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateNumberLiteral", null);
-_ts_decorate([
-  gen(BooleanLiteral2),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof BooleanLiteral2 === "undefined" ? Object : BooleanLiteral2
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateBooleanLiteral", null);
-_ts_decorate([
-  gen(UnaryExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof UnaryExpr === "undefined" ? Object : UnaryExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateUnaryExpr", null);
-_ts_decorate([
-  gen(BinaryExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof BinaryExpr === "undefined" ? Object : BinaryExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateBinaryExpr", null);
-_ts_decorate([
-  gen(ReferenceExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof ReferenceExpr === "undefined" ? Object : ReferenceExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateReferenceExpr", null);
-_ts_decorate([
-  gen(ReferenceArg),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof ReferenceArg === "undefined" ? Object : ReferenceArg
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateReferenceArg", null);
-_ts_decorate([
-  gen(MemberAccessExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof MemberAccessExpr === "undefined" ? Object : MemberAccessExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateMemberExpr", null);
-_ts_decorate([
-  gen(InvocationExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof InvocationExpr === "undefined" ? Object : InvocationExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateInvocationExpr", null);
-_ts_decorate([
-  gen(NullExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", []),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateNullExpr", null);
-_ts_decorate([
-  gen(ThisExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", []),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateThisExpr", null);
-_ts_decorate([
-  gen(Attribute),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof Attribute === "undefined" ? Object : Attribute
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateAttribute", null);
-_ts_decorate([
-  gen(AttributeParam),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof AttributeParam === "undefined" ? Object : AttributeParam
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateAttributeParam", null);
-_ts_decorate([
-  gen(AttributeParamType),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof AttributeParamType === "undefined" ? Object : AttributeParamType
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateAttributeParamType", null);
-_ts_decorate([
-  gen(FunctionDecl),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof FunctionDecl === "undefined" ? Object : FunctionDecl
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateFunctionDecl", null);
-_ts_decorate([
-  gen(FunctionParam),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof FunctionParam === "undefined" ? Object : FunctionParam
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateFunctionParam", null);
-_ts_decorate([
-  gen(FunctionParamType),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof FunctionParamType === "undefined" ? Object : FunctionParamType
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateFunctionParamType", null);
-_ts_decorate([
-  gen(TypeDef),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof TypeDef === "undefined" ? Object : TypeDef
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateTypeDef", null);
 export {
   model_utils_exports as ModelUtils,
   PrismaSchemaGenerator,
-  TsSchemaGenerator,
-  ZModelCodeGenerator
+  TsSchemaGenerator
 };
 //# sourceMappingURL=index.js.map