@zenstackhq/language 3.0.0-beta.9 → 3.1.0

package/dist/index.js

@@ -7,16 +7,19 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/index.ts
-import { isAstNode, URI as URI3 } from "langium";
-import { NodeFileSystem } from "langium/node";
-import fs3 from "fs";
-import path3 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+// src/document.ts
+import { isAstNode, TextDocument, URI as URI4 } from "langium";
+import fs4 from "fs";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/generated/ast.ts
 import * as langium from "langium";
 var AbstractDeclaration = "AbstractDeclaration";
+function isAbstractDeclaration(item) {
+  return reflection.isInstance(item, AbstractDeclaration);
+}
+__name(isAbstractDeclaration, "isAbstractDeclaration");
 var ConfigExpr = "ConfigExpr";
 var Expression = "Expression";
 function isExpression(item) {
@@ -43,6 +46,10 @@ function isAttribute(item) {
 }
 __name(isAttribute, "isAttribute");
 var AttributeArg = "AttributeArg";
+function isAttributeArg(item) {
+  return reflection.isInstance(item, AttributeArg);
+}
+__name(isAttributeArg, "isAttributeArg");
 var AttributeParam = "AttributeParam";
 var AttributeParamType = "AttributeParamType";
 var BinaryExpr = "BinaryExpr";
@@ -61,6 +68,10 @@ function isConfigArrayExpr(item) {
 }
 __name(isConfigArrayExpr, "isConfigArrayExpr");
 var ConfigField = "ConfigField";
+function isConfigField(item) {
+  return reflection.isInstance(item, ConfigField);
+}
+__name(isConfigField, "isConfigField");
 var ConfigInvocationArg = "ConfigInvocationArg";
 var ConfigInvocationExpr = "ConfigInvocationExpr";
 var DataField = "DataField";
@@ -105,10 +116,22 @@ function isEnumField(item) {
 __name(isEnumField, "isEnumField");
 var FieldInitializer = "FieldInitializer";
 var FunctionDecl = "FunctionDecl";
+function isFunctionDecl(item) {
+  return reflection.isInstance(item, FunctionDecl);
+}
+__name(isFunctionDecl, "isFunctionDecl");
 var FunctionParam = "FunctionParam";
 var FunctionParamType = "FunctionParamType";
 var GeneratorDecl = "GeneratorDecl";
+function isGeneratorDecl(item) {
+  return reflection.isInstance(item, GeneratorDecl);
+}
+__name(isGeneratorDecl, "isGeneratorDecl");
 var InternalAttribute = "InternalAttribute";
+function isInternalAttribute(item) {
+  return reflection.isInstance(item, InternalAttribute);
+}
+__name(isInternalAttribute, "isInternalAttribute");
 var InvocationExpr = "InvocationExpr";
 function isInvocationExpr(item) {
   return reflection.isInstance(item, InvocationExpr);
@@ -125,6 +148,10 @@ function isModel(item) {
 }
 __name(isModel, "isModel");
 var ModelImport = "ModelImport";
+function isModelImport(item) {
+  return reflection.isInstance(item, ModelImport);
+}
+__name(isModelImport, "isModelImport");
 var NullExpr = "NullExpr";
 function isNullExpr(item) {
   return reflection.isInstance(item, NullExpr);
@@ -146,6 +173,10 @@ function isPlugin(item) {
 }
 __name(isPlugin, "isPlugin");
 var PluginField = "PluginField";
+function isPluginField(item) {
+  return reflection.isInstance(item, PluginField);
+}
+__name(isPluginField, "isPluginField");
 var Procedure = "Procedure";
 var ProcedureParam = "ProcedureParam";
 var ReferenceArg = "ReferenceArg";
@@ -1012,6 +1043,26 @@ var ZModelAstReflection = class extends langium.AbstractAstReflection {
 };
 var reflection = new ZModelAstReflection();
 
+// src/ast.ts
+var BinaryExprOperatorPriority = {
+  //LogicalExpr
+  "||": 1,
+  "&&": 1,
+  //EqualityExpr
+  "==": 2,
+  "!=": 2,
+  //ComparisonExpr
+  ">": 3,
+  "<": 3,
+  ">=": 3,
+  "<=": 3,
+  in: 4,
+  //CollectionPredicateExpr
+  "^": 5,
+  "?": 5,
+  "!": 5
+};
+
 // src/constants.ts
 var SUPPORTED_PROVIDERS = [
   "sqlite",
@@ -1042,8 +1093,11 @@ var ExpressionContext = /* @__PURE__ */ function(ExpressionContext2) {
 }({});
 
 // src/module.ts
-import { inject } from "langium";
+import { DocumentState as DocumentState2, inject, URI as URI3 } from "langium";
 import { createDefaultModule, createDefaultSharedModule } from "langium/lsp";
+import { NodeFileSystem } from "langium/node";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/generated/grammar.ts
 import { loadGrammarFromJson } from "langium";
@@ -5104,14 +5158,12 @@ var ZModelGeneratedModule = {
   parser: {}
 };
 
-// src/validators/attribute-application-validator.ts
-import { AstUtils as AstUtils2 } from "langium";
-import pluralize from "pluralize";
-
 // src/utils.ts
 import { AstUtils, URI } from "langium";
 import fs from "fs";
+import { createRequire } from "module";
 import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 function hasAttribute(decl, name) {
   return !!getAttribute(decl, name);
 }
@@ -5215,7 +5267,7 @@ function getRecursiveBases(decl, includeDelegate = true, seen = /* @__PURE__ */
     ] : []
   ];
   bases.forEach((base) => {
-    const baseDecl = decl.$container.declarations.find((d) => isTypeDef(d) || isDataModel(d) && d.name === base.$refText);
+    const baseDecl = decl.$container.declarations.find((d) => (isTypeDef(d) || isDataModel(d)) && d.name === base.$refText);
     if (baseDecl) {
       if (!includeDelegate && isDelegateModel(baseDecl)) {
         return;
@@ -5338,6 +5390,10 @@ function getArray(expr) {
   return isArrayExpr(expr) || isConfigArrayExpr(expr) ? expr.items : void 0;
 }
 __name(getArray, "getArray");
+function getAttributeArg(attr, name) {
+  return attr.args.find((arg) => arg.$resolvedParam?.name === name)?.value;
+}
+__name(getAttributeArg, "getAttributeArg");
 function getFunctionExpressionContext(funcDecl) {
   const funcAllowedContext = [];
   const funcAttr = funcDecl.attributes.find((attr) => attr.decl.$refText === "@@@expressionContext");
@@ -5425,15 +5481,15 @@ function getAllDeclarationsIncludingImports(documents, model) {
 }
 __name(getAllDeclarationsIncludingImports, "getAllDeclarationsIncludingImports");
 function getAuthDecl(decls) {
-  let authModel = decls.find((m) => hasAttribute(m, "@@auth"));
+  let authModel = decls.find((d) => hasAttribute(d, "@@auth"));
   if (!authModel) {
-    authModel = decls.find((m) => m.name === "User");
+    authModel = decls.find((d) => d.name === "User");
   }
   return authModel;
 }
 __name(getAuthDecl, "getAuthDecl");
 function isBeforeInvocation(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "before" && isFromStdlib(node.function.ref);
+  return isInvocationExpr(node) && node.function.ref?.name === "before";
 }
 __name(isBeforeInvocation, "isBeforeInvocation");
 function isCollectionPredicate(node) {
@@ -5516,13 +5572,23 @@ function getAllAttributes(decl, seen = /* @__PURE__ */ new Set()) {
   }
   if (isDataModel(decl) && decl.baseModel) {
     if (decl.baseModel.ref) {
-      attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+      const attrs = getAllAttributes(decl.baseModel.ref, seen).filter((attr) => !isNonInheritableAttribute(attr));
+      attributes.push(...attrs);
     }
   }
   attributes.push(...decl.attributes);
   return attributes;
 }
 __name(getAllAttributes, "getAllAttributes");
+function isNonInheritableAttribute(attr) {
+  const attrName = attr.decl.ref?.name ?? attr.decl.$refText;
+  return [
+    "@@map",
+    "@@unique",
+    "@@index"
+  ].includes(attrName);
+}
+__name(isNonInheritableAttribute, "isNonInheritableAttribute");
 function getDocument(node) {
   const rootNode = findRootNode(node);
   const result = rootNode.$document;
@@ -5532,6 +5598,71 @@ function getDocument(node) {
   return result;
 }
 __name(getDocument, "getDocument");
+function getPluginDocuments(model, schemaPath) {
+  const result = [];
+  for (const decl of model.declarations.filter(isPlugin)) {
+    const providerField = decl.fields.find((f) => f.name === "provider");
+    if (!providerField) {
+      continue;
+    }
+    const provider = getLiteral(providerField.value);
+    if (!provider) {
+      continue;
+    }
+    let pluginModelFile;
+    let providerPath = path.resolve(path.dirname(schemaPath), provider);
+    if (fs.existsSync(providerPath)) {
+      if (fs.statSync(providerPath).isDirectory()) {
+        providerPath = path.join(providerPath, "index.js");
+      }
+      pluginModelFile = path.resolve(path.dirname(providerPath), PLUGIN_MODULE_NAME);
+      if (!fs.existsSync(pluginModelFile)) {
+        pluginModelFile = findUp([
+          PLUGIN_MODULE_NAME
+        ], path.dirname(providerPath));
+      }
+    }
+    if (!pluginModelFile) {
+      if (typeof import.meta.resolve === "function") {
+        try {
+          const resolvedUrl = import.meta.resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+          pluginModelFile = fileURLToPath(resolvedUrl);
+        } catch {
+        }
+      }
+    }
+    if (!pluginModelFile) {
+      try {
+        const require2 = createRequire(pathToFileURL(schemaPath));
+        pluginModelFile = require2.resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+      } catch {
+      }
+    }
+    if (pluginModelFile && fs.existsSync(pluginModelFile)) {
+      result.push(pluginModelFile);
+    }
+  }
+  return result;
+}
+__name(getPluginDocuments, "getPluginDocuments");
+function findUp(names, cwd = process.cwd(), multiple = false, result = []) {
+  if (!names.some((name) => !!name)) {
+    return void 0;
+  }
+  const target = names.find((name) => fs.existsSync(path.join(cwd, name)));
+  if (multiple === false && target) {
+    return path.join(cwd, target);
+  }
+  if (target) {
+    result.push(path.join(cwd, target));
+  }
+  const up = path.resolve(cwd, "..");
+  if (up === cwd) {
+    return multiple && result.length > 0 ? result : void 0;
+  }
+  return findUp(names, up, multiple, result);
+}
+__name(findUp, "findUp");
 function findRootNode(node) {
   while (node.$container) {
     node = node.$container;
@@ -5541,6 +5672,9 @@ function findRootNode(node) {
 __name(findRootNode, "findRootNode");
 
 // src/validators/attribute-application-validator.ts
+import { invariant } from "@zenstackhq/common-helpers";
+import { AstUtils as AstUtils2 } from "langium";
+import pluralize from "pluralize";
 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);
@@ -5758,8 +5892,23 @@ var AttributeApplicationValidator = class {
       });
     }
   }
-  _checkUnique(attr, accept) {
-    const fields = attr.args[0]?.value;
+  _checkId(attr, accept) {
+    const dm = getContainingDataModel(attr);
+    if (dm?.isView) {
+      accept("error", `\`@id\` is not allowed for views`, {
+        node: attr
+      });
+    }
+  }
+  _checkConstraint(attr, accept) {
+    const dm = getContainingDataModel(attr);
+    if (dm?.isView && (attr.decl.$refText === "@@id" || attr.decl.$refText === "@@index")) {
+      accept("error", `\`${attr.decl.$refText}\` is not allowed for views`, {
+        node: attr
+      });
+    }
+    const fields = getAttributeArg(attr, "fields");
+    const attrName = attr.decl.ref?.name;
     if (!fields) {
       accept("error", `expects an array of field references`, {
         node: attr.args[0]
@@ -5768,7 +5917,7 @@ var AttributeApplicationValidator = class {
     }
     if (isArrayExpr(fields)) {
       if (fields.items.length === 0) {
-        accept("error", `\`@@unique\` expects at least one field reference`, {
+        accept("error", `\`${attrName}\` expects at least one field reference`, {
           node: fields
         });
         return;
@@ -5787,7 +5936,7 @@ var AttributeApplicationValidator = class {
           return;
         }
         if (item.target.ref.$container !== attr.$container && isDelegateModel(item.target.ref.$container)) {
-          accept("error", `Cannot use fields inherited from a polymorphic base model in \`@@unique\``, {
+          accept("error", `Cannot use fields inherited from a polymorphic base model in \`${attrName}\``, {
             node: item
           });
         }
@@ -5798,6 +5947,24 @@ var AttributeApplicationValidator = class {
       });
     }
   }
+  _checkSchema(attr, accept) {
+    const schemaName = getStringLiteral(attr.args[0]?.value);
+    invariant(schemaName, `@@schema expects a string literal`);
+    const zmodel = AstUtils2.getContainerOfType(attr, isModel);
+    const datasource = zmodel.declarations.find(isDataSource);
+    if (datasource) {
+      let found = false;
+      const schemas = datasource.fields.find((f) => f.name === "schemas");
+      if (schemas && isConfigArrayExpr(schemas.value)) {
+        found = schemas.value.items.some((item) => isLiteralExpr(item) && item.value === schemaName);
+      }
+      if (!found) {
+        accept("error", `Schema "${schemaName}" is not defined in the datasource`, {
+          node: attr
+        });
+      }
+    }
+  }
   validatePolicyKinds(kind, candidates, attr, accept) {
     const items = kind.split(",").map((x) => x.trim());
     items.forEach((item) => {
@@ -5840,15 +6007,34 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], AttributeApplicationValidator.prototype, "_checkValidate", null);
 _ts_decorate([
-  check("@@unique"),
+  check("@id"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AttributeApplication === "undefined" ? Object : AttributeApplication,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], AttributeApplicationValidator.prototype, "_checkId", null);
+_ts_decorate([
   check("@@id"),
+  check("@@index"),
+  check("@@unique"),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     typeof AttributeApplication === "undefined" ? Object : AttributeApplication,
     typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
   ]),
   _ts_metadata("design:returntype", void 0)
-], AttributeApplicationValidator.prototype, "_checkUnique", null);
+], AttributeApplicationValidator.prototype, "_checkConstraint", null);
+_ts_decorate([
+  check("@@schema"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AttributeApplication === "undefined" ? Object : AttributeApplication,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], AttributeApplicationValidator.prototype, "_checkSchema", null);
 function assignableToAttributeParam(arg, param, attr) {
   const argResolvedType = arg.$resolvedType;
   if (!argResolvedType) {
@@ -5982,7 +6168,7 @@ var AttributeValidator = class {
 };
 
 // src/validators/datamodel-validator.ts
-import { invariant } from "@zenstackhq/common-helpers";
+import { invariant as invariant2 } from "@zenstackhq/common-helpers";
 import { AstUtils as AstUtils3 } from "langium";
 
 // src/validators/common.ts
@@ -6029,7 +6215,7 @@ var DataModelValidator = class {
     const uniqueFields = allFields.filter((f) => f.attributes.find((attr) => attr.decl.ref?.name === "@unique"));
     const modelLevelIds = getModelIdFields(dm);
     const modelUniqueFields = getModelUniqueFields(dm);
-    if (idFields.length === 0 && modelLevelIds.length === 0 && uniqueFields.length === 0 && modelUniqueFields.length === 0) {
+    if (!dm.isView && idFields.length === 0 && modelLevelIds.length === 0 && uniqueFields.length === 0 && modelUniqueFields.length === 0) {
       accept("error", "Model must have at least one unique criteria. Either mark a single field with `@id`, `@unique` or add a multi field criterion with `@@id([])` or `@@unique([])` to the model.", {
         node: dm
       });
@@ -6223,7 +6409,7 @@ var DataModelValidator = class {
     if (!thisRelation.valid) {
       return;
     }
-    if (this.isFieldInheritedFromDelegateModel(field)) {
+    if (this.isFieldInheritedFromDelegateModel(field, contextModel)) {
       return;
     }
     if (this.isSelfRelation(field)) {
@@ -6346,14 +6532,14 @@ var DataModelValidator = class {
     }
   }
   // checks if the given field is inherited directly or indirectly from a delegate model
-  isFieldInheritedFromDelegateModel(field) {
-    return isDelegateModel(field.$container);
+  isFieldInheritedFromDelegateModel(field, contextModel) {
+    return field.$container !== contextModel && isDelegateModel(field.$container);
   }
   validateInherits(model, accept) {
     if (!model.baseModel) {
       return;
     }
-    invariant(model.baseModel.ref, "baseModel must be resolved");
+    invariant2(model.baseModel.ref, "baseModel must be resolved");
     if (!isDelegateModel(model.baseModel.ref)) {
       accept("error", `Model ${model.baseModel.$refText} cannot be extended because it's not a delegate model`, {
         node: model,
@@ -6375,7 +6561,7 @@ var DataModelValidator = class {
       }
       seen.push(current);
       if (current.baseModel) {
-        invariant(current.baseModel.ref, "baseModel must be resolved");
+        invariant2(current.baseModel.ref, "baseModel must be resolved");
         todo.push(current.baseModel.ref);
       }
     }
@@ -6406,7 +6592,6 @@ var DataSourceValidator = class {
     validateDuplicatedDeclarations(ds, ds.fields, accept);
     this.validateProvider(ds, accept);
     this.validateUrl(ds, accept);
-    this.validateRelationMode(ds, accept);
   }
   validateProvider(ds, accept) {
     const provider = ds.fields.find((f) => f.name === "provider");
@@ -6416,16 +6601,61 @@ var DataSourceValidator = class {
       });
       return;
     }
-    const value = getStringLiteral(provider.value);
-    if (!value) {
+    const providerValue = getStringLiteral(provider.value);
+    if (!providerValue) {
       accept("error", '"provider" must be set to a string literal', {
         node: provider.value
       });
-    } else if (!SUPPORTED_PROVIDERS.includes(value)) {
-      accept("error", `Provider "${value}" is not supported. Choose from ${SUPPORTED_PROVIDERS.map((p) => '"' + p + '"').join(" | ")}.`, {
+    } else if (!SUPPORTED_PROVIDERS.includes(providerValue)) {
+      accept("error", `Provider "${providerValue}" is not supported. Choose from ${SUPPORTED_PROVIDERS.map((p) => '"' + p + '"').join(" | ")}.`, {
         node: provider.value
       });
     }
+    const defaultSchemaField = ds.fields.find((f) => f.name === "defaultSchema");
+    let defaultSchemaValue;
+    if (defaultSchemaField) {
+      if (providerValue !== "postgresql") {
+        accept("error", '"defaultSchema" is only supported for "postgresql" provider', {
+          node: defaultSchemaField
+        });
+      }
+      defaultSchemaValue = getStringLiteral(defaultSchemaField.value);
+      if (!defaultSchemaValue) {
+        accept("error", '"defaultSchema" must be a string literal', {
+          node: defaultSchemaField.value
+        });
+      }
+    }
+    const schemasField = ds.fields.find((f) => f.name === "schemas");
+    if (schemasField) {
+      if (providerValue !== "postgresql") {
+        accept("error", '"schemas" is only supported for "postgresql" provider', {
+          node: schemasField
+        });
+      }
+      const schemasValue = schemasField.value;
+      if (!isConfigArrayExpr(schemasValue) || !schemasValue.items.every((e) => isLiteralExpr(e) && typeof getStringLiteral(e) === "string")) {
+        accept("error", '"schemas" must be an array of string literals', {
+          node: schemasField
+        });
+      } else {
+        const schemasArray = schemasValue.items.map((e) => getStringLiteral(e));
+        if (defaultSchemaValue) {
+          if (!schemasArray.includes(defaultSchemaValue)) {
+            accept("error", `"${defaultSchemaValue}" must be included in the "schemas" array`, {
+              node: schemasField
+            });
+          }
+        } else {
+          const hasImplicitPublicSchema = ds.$container.declarations.some((d) => (isDataModel(d) || isEnum(d)) && !d.attributes.some((a) => a.decl.$refText === "@@schema"));
+          if (hasImplicitPublicSchema && !schemasArray.includes("public")) {
+            accept("error", `"public" must be included in the "schemas" array`, {
+              node: schemasField
+            });
+          }
+        }
+      }
+    }
   }
   validateUrl(ds, accept) {
     const urlField = ds.fields.find((f) => f.name === "url");
@@ -6439,20 +6669,6 @@ var DataSourceValidator = class {
       });
     }
   }
-  validateRelationMode(ds, accept) {
-    const field = ds.fields.find((f) => f.name === "relationMode");
-    if (field) {
-      const val = getStringLiteral(field.value);
-      if (!val || ![
-        "foreignKeys",
-        "prisma"
-      ].includes(val)) {
-        accept("error", '"relationMode" must be set to "foreignKeys" or "prisma"', {
-          node: field.value
-        });
-      }
-    }
-  }
 };
 
 // src/validators/enum-validator.ts
@@ -6511,6 +6727,9 @@ var ExpressionValidator = class {
       case "BinaryExpr":
         this.validateBinaryExpr(expr, accept);
         break;
+      case "UnaryExpr":
+        this.validateUnaryExpr(expr, accept);
+        break;
     }
   }
   validateMemberAccessExpr(expr, accept) {
@@ -6652,6 +6871,13 @@ var ExpressionValidator = class {
         break;
     }
   }
+  validateUnaryExpr(expr, accept) {
+    if (expr.operand.$resolvedType && expr.operand.$resolvedType.decl !== "Boolean") {
+      accept("error", `operand of "${expr.operator}" must be of Boolean type`, {
+        node: expr.operand
+      });
+    }
+  }
   validateCollectionPredicate(expr, accept) {
     if (!expr.$resolvedType) {
       accept("error", "collection predicate can only be used on an array of model type", {
@@ -6721,44 +6947,56 @@ var FunctionInvocationValidator = class {
       });
       return;
     }
-    if (!this.validateArgs(funcDecl, expr.args, accept)) {
+    if (!this.validateArgs(funcDecl, expr, accept)) {
       return;
     }
-    if (isFromStdlib(funcDecl)) {
-      let curr = expr.$container;
-      let containerAttribute;
-      while (curr) {
-        if (isDataModelAttribute(curr) || isDataFieldAttribute(curr)) {
-          containerAttribute = curr;
-          break;
-        }
-        curr = curr.$container;
+    let curr = expr.$container;
+    let containerAttribute;
+    while (curr) {
+      if (isDataModelAttribute(curr) || isDataFieldAttribute(curr)) {
+        containerAttribute = curr;
+        break;
       }
-      const exprContext = this.getExpressionContext(containerAttribute);
-      const funcAllowedContext = getFunctionExpressionContext(funcDecl);
-      if (exprContext && !funcAllowedContext.includes(exprContext)) {
-        accept("error", `function "${funcDecl.name}" is not allowed in the current context: ${exprContext}`, {
-          node: expr
+      curr = curr.$container;
+    }
+    const exprContext = this.getExpressionContext(containerAttribute);
+    const funcAllowedContext = getFunctionExpressionContext(funcDecl);
+    if (exprContext && !funcAllowedContext.includes(exprContext)) {
+      accept("error", `function "${funcDecl.name}" is not allowed in the current context: ${exprContext}`, {
+        node: expr
+      });
+      return;
+    }
+    const allCasing = [
+      "original",
+      "upper",
+      "lower",
+      "capitalize",
+      "uncapitalize"
+    ];
+    if ([
+      "currentModel",
+      "currentOperation"
+    ].includes(funcDecl.name)) {
+      const arg = getLiteral(expr.args[0]?.value);
+      if (arg && !allCasing.includes(arg)) {
+        accept("error", `argument must be one of: ${allCasing.map((c) => '"' + c + '"').join(", ")}`, {
+          node: expr.args[0]
         });
-        return;
       }
-      const allCasing = [
-        "original",
-        "upper",
-        "lower",
-        "capitalize",
-        "uncapitalize"
-      ];
-      if ([
-        "currentModel",
-        "currentOperation"
-      ].includes(funcDecl.name)) {
-        const arg = getLiteral(expr.args[0]?.value);
-        if (arg && !allCasing.includes(arg)) {
-          accept("error", `argument must be one of: ${allCasing.map((c) => '"' + c + '"').join(", ")}`, {
-            node: expr.args[0]
-          });
-        }
+    }
+    if ([
+      "uuid",
+      "ulid",
+      "cuid",
+      "nanoid"
+    ].includes(funcDecl.name)) {
+      const formatParamIdx = funcDecl.params.findIndex((param) => param.name === "format");
+      const formatArg = getLiteral(expr.args[formatParamIdx]?.value);
+      if (formatArg !== void 0 && !/(?<!\\)%s/g.test(formatArg)) {
+        accept("error", 'argument must include "%s"', {
+          node: expr.args[formatParamIdx]
+        });
       }
     }
     const checker = invocationCheckers.get(expr.function.$refText);
@@ -6778,18 +7016,18 @@ var FunctionInvocationValidator = class {
   isValidationAttribute(attr) {
     return !!attr.decl.ref?.attributes.some((attr2) => attr2.decl.$refText === "@@@validation");
   }
-  validateArgs(funcDecl, args, accept) {
+  validateArgs(funcDecl, expr, accept) {
     let success = true;
     for (let i = 0; i < funcDecl.params.length; i++) {
       const param = funcDecl.params[i];
       if (!param) {
         continue;
       }
-      const arg = args[i];
+      const arg = expr.args[i];
       if (!arg) {
         if (!param.optional) {
           accept("error", `missing argument for parameter "${param.name}"`, {
-            node: funcDecl
+            node: expr
           });
           success = false;
         }
@@ -6838,6 +7076,46 @@ var FunctionInvocationValidator = class {
     }
     return true;
   }
+  _checkUuid(expr, accept) {
+    const versionArg = expr.args[0]?.value;
+    if (versionArg) {
+      const version = getLiteral(versionArg);
+      if (version !== void 0 && version !== 4 && version !== 7) {
+        accept("error", "first argument must be 4 or 7", {
+          node: expr.args[0]
+        });
+      }
+    }
+  }
+  _checkCuid(expr, accept) {
+    const versionArg = expr.args[0]?.value;
+    if (versionArg) {
+      const version = getLiteral(versionArg);
+      if (version !== void 0 && version !== 1 && version !== 2) {
+        accept("error", "first argument must be 1 or 2", {
+          node: expr.args[0]
+        });
+      }
+    }
+  }
+  _checkNanoid(expr, accept) {
+    const lengthArg = expr.args[0]?.value;
+    if (lengthArg) {
+      const length = getLiteral(lengthArg);
+      if (length !== void 0 && length <= 0) {
+        accept("error", "first argument must be a positive number", {
+          node: expr.args[0]
+        });
+      }
+    }
+  }
+  _checkAuth(expr, accept) {
+    if (!expr.$resolvedType) {
+      accept("error", 'cannot resolve `auth()` - make sure you have a model or type with `@auth` attribute or named "User"', {
+        node: expr
+      });
+    }
+  }
   _checkLength(expr, accept) {
     const msg = "argument must be a string or list field";
     const fieldArg = expr.args[0].value;
@@ -6947,6 +7225,42 @@ var FunctionInvocationValidator = class {
     }
   }
 };
+_ts_decorate2([
+  func("uuid"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], FunctionInvocationValidator.prototype, "_checkUuid", null);
+_ts_decorate2([
+  func("cuid"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], FunctionInvocationValidator.prototype, "_checkCuid", null);
+_ts_decorate2([
+  func("nanoid"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], FunctionInvocationValidator.prototype, "_checkNanoid", null);
+_ts_decorate2([
+  func("auth"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], FunctionInvocationValidator.prototype, "_checkAuth", null);
 _ts_decorate2([
   func("length"),
   _ts_metadata2("design:type", Function),
@@ -7055,6 +7369,7 @@ function registerValidationChecks(services) {
   const checks = {
     Model: validator.checkModel,
     DataSource: validator.checkDataSource,
+    GeneratorDecl: validator.checkGenerator,
     DataModel: validator.checkDataModel,
     TypeDef: validator.checkTypeDef,
     Enum: validator.checkEnum,
@@ -7080,6 +7395,11 @@ var ZModelValidator = class {
   checkDataSource(node, accept) {
     new DataSourceValidator().validate(node, accept);
   }
+  checkGenerator(node, accept) {
+    accept("warning", '"generator" is not used by ZenStack and should be removed.', {
+      node
+    });
+  }
   checkDataModel(node, accept) {
     new DataModelValidator().validate(node, accept);
   }
@@ -7103,6 +7423,873 @@ var ZModelValidator = class {
   }
 };
 
+// src/zmodel-comment-provider.ts
+import { DefaultCommentProvider } from "langium";
+import { match as match2 } from "ts-pattern";
+var ZModelCommentProvider = class extends DefaultCommentProvider {
+  static {
+    __name(this, "ZModelCommentProvider");
+  }
+  getComment(node) {
+    let comment = super.getComment(node);
+    if (!comment) {
+      comment = match2(node).when(isDataModel, (d) => `/**
+ * Model *${d.name}*
+ */`).when(isTypeDef, (d) => `/**
+ * Type *${d.name}*
+ */`).when(isEnum, (e) => `/**
+ * Enum *${e.name}*
+ */`).when(isEnumField, (f) => `/**
+ * Value of enum *${f.$container?.name}*
+ */`).when(isDataField, (f) => `/**
+ * Field of *${f.$container?.name}*
+ */`).when(isFunctionDecl, (f) => `/**
+ * Function *${f.name}*
+ */`).otherwise(() => "");
+    }
+    return comment;
+  }
+};
+
+// src/zmodel-completion-provider.ts
+import { DefaultCompletionProvider } from "langium/lsp";
+import fs2 from "fs";
+import { P as P2, match as match3 } from "ts-pattern";
+import { CompletionItemKind } from "vscode-languageserver";
+
+// src/zmodel-code-generator.ts
+function _ts_decorate3(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_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_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.$refText).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 `${ast.decl.$refText}${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 isCollectionPredicate2 = this.isCollectionPredicateOperator(operator);
+    const rightExpr = this.generate(ast.right);
+    const { left: isLeftParenthesis, right: isRightParenthesis } = this.isParenthesesNeededForBinaryExpr(ast);
+    return `${isLeftParenthesis ? "(" : ""}${this.generate(ast.left)}${isLeftParenthesis ? ")" : ""}${isCollectionPredicate2 ? "" : this.binaryExprSpace}${operator}${isCollectionPredicate2 ? "" : this.binaryExprSpace}${isRightParenthesis ? "(" : ""}${isCollectionPredicate2 ? `[${rightExpr}]` : rightExpr}${isRightParenthesis ? ")" : ""}`;
+  }
+  _generateReferenceExpr(ast) {
+    const args = ast.args.length ? `(${ast.args.map((x) => this.generate(x)).join(", ")})` : "";
+    return `${ast.target.$refText}${args}`;
+  }
+  _generateReferenceArg(ast) {
+    return `${ast.name}:${this.generate(ast.value)}`;
+  }
+  _generateMemberExpr(ast) {
+    return `${this.generate(ast.operand)}.${ast.member.$refText}`;
+  }
+  _generateInvocationExpr(ast) {
+    return `${ast.function.$refText}(${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 isCollectionPredicate2 = this.isCollectionPredicateOperator(operator);
+    const currentPriority = BinaryExprOperatorPriority[operator];
+    if (ast.left.$type === BinaryExpr && BinaryExprOperatorPriority[ast.left["operator"]] < currentPriority) {
+      result.left = true;
+    }
+    if (!isCollectionPredicate2 && ast.right.$type === BinaryExpr && BinaryExprOperatorPriority[ast.right["operator"]] <= currentPriority) {
+      result.right = true;
+    }
+    return result;
+  }
+  isCollectionPredicateOperator(op) {
+    return [
+      "?",
+      "!",
+      "^"
+    ].includes(op);
+  }
+};
+_ts_decorate3([
+  gen(Model),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Model === "undefined" ? Object : Model
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateModel", null);
+_ts_decorate3([
+  gen(DataSource),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataSource === "undefined" ? Object : DataSource
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataSource", null);
+_ts_decorate3([
+  gen(Enum),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Enum === "undefined" ? Object : Enum
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateEnum", null);
+_ts_decorate3([
+  gen(EnumField),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof EnumField === "undefined" ? Object : EnumField
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateEnumField", null);
+_ts_decorate3([
+  gen(GeneratorDecl),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof GeneratorDecl === "undefined" ? Object : GeneratorDecl
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateGenerator", null);
+_ts_decorate3([
+  gen(ConfigField),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ConfigField === "undefined" ? Object : ConfigField
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigField", null);
+_ts_decorate3([
+  gen(ConfigArrayExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ConfigArrayExpr === "undefined" ? Object : ConfigArrayExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigArrayExpr", null);
+_ts_decorate3([
+  gen(ConfigInvocationExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ConfigInvocationExpr === "undefined" ? Object : ConfigInvocationExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigInvocationExpr", null);
+_ts_decorate3([
+  gen(Plugin),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Plugin === "undefined" ? Object : Plugin
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generatePlugin", null);
+_ts_decorate3([
+  gen(PluginField),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof PluginField === "undefined" ? Object : PluginField
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generatePluginField", null);
+_ts_decorate3([
+  gen(DataModel),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataModel === "undefined" ? Object : DataModel
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModel", null);
+_ts_decorate3([
+  gen(DataField),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataField === "undefined" ? Object : DataField
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataField", null);
+_ts_decorate3([
+  gen(DataModelAttribute),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataModelAttribute === "undefined" ? Object : DataModelAttribute
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModelAttribute", null);
+_ts_decorate3([
+  gen(DataFieldAttribute),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataFieldAttribute === "undefined" ? Object : DataFieldAttribute
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataFieldAttribute", null);
+_ts_decorate3([
+  gen(AttributeArg),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof AttributeArg === "undefined" ? Object : AttributeArg
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeArg", null);
+_ts_decorate3([
+  gen(ObjectExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ObjectExpr === "undefined" ? Object : ObjectExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateObjectExpr", null);
+_ts_decorate3([
+  gen(ArrayExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ArrayExpr === "undefined" ? Object : ArrayExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateArrayExpr", null);
+_ts_decorate3([
+  gen(StringLiteral),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof LiteralExpr === "undefined" ? Object : LiteralExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateLiteralExpr", null);
+_ts_decorate3([
+  gen(NumberLiteral),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof NumberLiteral === "undefined" ? Object : NumberLiteral
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateNumberLiteral", null);
+_ts_decorate3([
+  gen(BooleanLiteral),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof BooleanLiteral === "undefined" ? Object : BooleanLiteral
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateBooleanLiteral", null);
+_ts_decorate3([
+  gen(UnaryExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof UnaryExpr === "undefined" ? Object : UnaryExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateUnaryExpr", null);
+_ts_decorate3([
+  gen(BinaryExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof BinaryExpr === "undefined" ? Object : BinaryExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateBinaryExpr", null);
+_ts_decorate3([
+  gen(ReferenceExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ReferenceExpr === "undefined" ? Object : ReferenceExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateReferenceExpr", null);
+_ts_decorate3([
+  gen(ReferenceArg),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ReferenceArg === "undefined" ? Object : ReferenceArg
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateReferenceArg", null);
+_ts_decorate3([
+  gen(MemberAccessExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof MemberAccessExpr === "undefined" ? Object : MemberAccessExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateMemberExpr", null);
+_ts_decorate3([
+  gen(InvocationExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateInvocationExpr", null);
+_ts_decorate3([
+  gen(NullExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateNullExpr", null);
+_ts_decorate3([
+  gen(ThisExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateThisExpr", null);
+_ts_decorate3([
+  gen(Attribute),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Attribute === "undefined" ? Object : Attribute
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttribute", null);
+_ts_decorate3([
+  gen(AttributeParam),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof AttributeParam === "undefined" ? Object : AttributeParam
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeParam", null);
+_ts_decorate3([
+  gen(AttributeParamType),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof AttributeParamType === "undefined" ? Object : AttributeParamType
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeParamType", null);
+_ts_decorate3([
+  gen(FunctionDecl),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof FunctionDecl === "undefined" ? Object : FunctionDecl
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionDecl", null);
+_ts_decorate3([
+  gen(FunctionParam),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof FunctionParam === "undefined" ? Object : FunctionParam
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionParam", null);
+_ts_decorate3([
+  gen(FunctionParamType),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof FunctionParamType === "undefined" ? Object : FunctionParamType
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionParamType", null);
+_ts_decorate3([
+  gen(TypeDef),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof TypeDef === "undefined" ? Object : TypeDef
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateTypeDef", null);
+
+// src/zmodel-completion-provider.ts
+var ZModelCompletionProvider = class extends DefaultCompletionProvider {
+  static {
+    __name(this, "ZModelCompletionProvider");
+  }
+  services;
+  constructor(services) {
+    super(services), this.services = services;
+  }
+  completionOptions = {
+    triggerCharacters: [
+      "@",
+      "(",
+      ",",
+      "."
+    ]
+  };
+  async getCompletion(document, params) {
+    try {
+      return await super.getCompletion(document, params);
+    } catch (e) {
+      console.error("Completion error:", e.message);
+      return void 0;
+    }
+  }
+  completionFor(context, next, acceptor) {
+    if (isDataModelAttribute(context.node) || isDataFieldAttribute(context.node)) {
+      const completions = this.getCompletionFromHint(context.node);
+      if (completions) {
+        completions.forEach((c) => acceptor(context, c));
+        return;
+      }
+    }
+    return super.completionFor(context, next, acceptor);
+  }
+  getCompletionFromHint(contextNode) {
+    const unfilledParams = this.getUnfilledAttributeParams(contextNode);
+    const nextParam = unfilledParams[0];
+    if (!nextParam) {
+      return void 0;
+    }
+    const hintAttr = getAttribute(nextParam, "@@@completionHint");
+    if (hintAttr) {
+      const hint = hintAttr.args[0];
+      if (hint?.value) {
+        if (isArrayExpr(hint.value)) {
+          return hint.value.items.map((item) => {
+            return {
+              label: `${item.value}`,
+              kind: CompletionItemKind.Value,
+              detail: "Parameter",
+              sortText: "0"
+            };
+          });
+        }
+      }
+    }
+    return void 0;
+  }
+  // TODO: this doesn't work when the file contains parse errors
+  getUnfilledAttributeParams(contextNode) {
+    try {
+      const params = contextNode.decl.ref?.params;
+      if (params) {
+        const args = contextNode.args;
+        let unfilledParams = [
+          ...params
+        ];
+        args.forEach((arg) => {
+          if (arg.name) {
+            unfilledParams = unfilledParams.filter((p) => p.name !== arg.name);
+          } else {
+            unfilledParams.shift();
+          }
+        });
+        return unfilledParams;
+      }
+    } catch {
+    }
+    return [];
+  }
+  completionForCrossReference(context, crossRef, acceptor) {
+    if (crossRef.property === "member" && !isMemberAccessExpr(context.node)) {
+      return;
+    }
+    const customAcceptor = /* @__PURE__ */ __name((context2, item) => {
+      if (item.insertText?.startsWith("@@@") || item.label?.startsWith("@@@")) {
+        return;
+      }
+      if ("nodeDescription" in item) {
+        const node = this.getAstNode(item.nodeDescription);
+        if (!node) {
+          return;
+        }
+        if ((isEnum(node) || isEnumField(node)) && isFromStdlib(node)) {
+          return;
+        }
+        if ((isDataModelAttribute(context2.node) || isDataFieldAttribute(context2.node)) && !this.filterAttributeApplicationCompletion(context2.node, node)) {
+          return;
+        }
+      }
+      acceptor(context2, item);
+    }, "customAcceptor");
+    return super.completionForCrossReference(context, crossRef, customAcceptor);
+  }
+  completionForKeyword(context, keyword, acceptor) {
+    const customAcceptor = /* @__PURE__ */ __name((context2, item) => {
+      if (!this.filterKeywordForContext(context2, keyword.value)) {
+        return;
+      }
+      acceptor(context2, item);
+    }, "customAcceptor");
+    return super.completionForKeyword(context, keyword, customAcceptor);
+  }
+  filterKeywordForContext(context, keyword) {
+    if (isInvocationExpr(context.node)) {
+      return [
+        "true",
+        "false",
+        "null",
+        "this"
+      ].includes(keyword);
+    } else if (isDataModelAttribute(context.node) || isDataFieldAttribute(context.node)) {
+      const exprContext = this.getAttributeContextType(context.node);
+      if (exprContext === "DefaultValue") {
+        return [
+          "true",
+          "false",
+          "null"
+        ].includes(keyword);
+      } else {
+        return [
+          "true",
+          "false",
+          "null",
+          "this"
+        ].includes(keyword);
+      }
+    } else {
+      return true;
+    }
+  }
+  filterAttributeApplicationCompletion(contextNode, node) {
+    const attrContextType = this.getAttributeContextType(contextNode);
+    if (isFunctionDecl(node) && attrContextType) {
+      const funcExprContextAttr = getAttribute(node, "@@@expressionContext");
+      if (funcExprContextAttr && funcExprContextAttr.args[0]) {
+        const arg = funcExprContextAttr.args[0];
+        if (isArrayExpr(arg.value)) {
+          return arg.value.items.some((item) => isEnumFieldReference(item) && item.target.$refText === attrContextType);
+        }
+      }
+      return false;
+    }
+    if (isDataField(node)) {
+      return attrContextType !== "DefaultValue";
+    }
+    return true;
+  }
+  getAttributeContextType(node) {
+    return match3(node.decl.$refText).with("@default", () => "DefaultValue").with(P2.union("@@allow", "@allow", "@@deny", "@deny"), () => "AccessPolicy").with("@@validate", () => "ValidationRule").otherwise(() => void 0);
+  }
+  createReferenceCompletionItem(nodeDescription) {
+    const node = this.getAstNode(nodeDescription);
+    const documentation = this.getNodeDocumentation(node);
+    return match3(node).when(isDataModel, () => ({
+      nodeDescription,
+      kind: CompletionItemKind.Class,
+      detail: "Model",
+      sortText: "1",
+      documentation
+    })).when(isTypeDef, () => ({
+      nodeDescription,
+      kind: CompletionItemKind.Class,
+      detail: "Type",
+      sortText: "1",
+      documentation
+    })).when(isDataField, () => ({
+      nodeDescription,
+      kind: CompletionItemKind.Field,
+      detail: "Field",
+      sortText: "0",
+      documentation
+    })).when(isEnum, () => ({
+      nodeDescription,
+      kind: CompletionItemKind.Class,
+      detail: "Enum",
+      sortText: "1",
+      documentation
+    })).when(isEnumField, (d) => {
+      const container = d.$container;
+      return {
+        nodeDescription,
+        kind: CompletionItemKind.Enum,
+        detail: `Value of enum "${container.name}"`,
+        sortText: "1",
+        documentation
+      };
+    }).when(isFunctionDecl, () => ({
+      nodeDescription,
+      insertText: this.getFunctionInsertText(nodeDescription),
+      kind: CompletionItemKind.Function,
+      detail: "Function",
+      sortText: "1",
+      documentation
+    })).when(isAttribute, () => ({
+      nodeDescription,
+      insertText: this.getAttributeInsertText(nodeDescription),
+      kind: CompletionItemKind.Property,
+      detail: "Attribute",
+      sortText: "1",
+      documentation
+    })).otherwise(() => ({
+      nodeDescription,
+      kind: CompletionItemKind.Reference,
+      detail: nodeDescription.type,
+      sortText: "2",
+      documentation
+    }));
+  }
+  getFunctionInsertText(nodeDescription) {
+    const node = this.getAstNode(nodeDescription);
+    if (isFunctionDecl(node)) {
+      if (node.params.some((p) => !p.optional)) {
+        return nodeDescription.name;
+      }
+    }
+    return `${nodeDescription.name}()`;
+  }
+  getAttributeInsertText(nodeDescription) {
+    const node = this.getAstNode(nodeDescription);
+    if (isAttribute(node)) {
+      if (node.name === "@relation") {
+        return `${nodeDescription.name}(fields: [], references: [])`;
+      }
+    }
+    return nodeDescription.name;
+  }
+  getAstNode(nodeDescription) {
+    let node = nodeDescription.node;
+    if (!node) {
+      const doc = this.getOrCreateDocumentSync(nodeDescription);
+      if (!doc) {
+        return void 0;
+      }
+      node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, nodeDescription.path);
+      if (!node) {
+        return void 0;
+      }
+    }
+    return node;
+  }
+  getOrCreateDocumentSync(nodeDescription) {
+    let doc = this.services.shared.workspace.LangiumDocuments.getDocument(nodeDescription.documentUri);
+    if (!doc) {
+      try {
+        const content = fs2.readFileSync(nodeDescription.documentUri.fsPath, "utf-8");
+        doc = this.services.shared.workspace.LangiumDocuments.createDocument(nodeDescription.documentUri, content);
+      } catch {
+        console.warn("Failed to read or create document:", nodeDescription.documentUri);
+        return void 0;
+      }
+    }
+    return doc;
+  }
+  getNodeDocumentation(node) {
+    if (!node) {
+      return void 0;
+    }
+    const md = this.commentsToMarkdown(node);
+    return {
+      kind: "markdown",
+      value: md
+    };
+  }
+  commentsToMarkdown(node) {
+    const md = this.services.documentation.DocumentationProvider.getDocumentation(node) ?? "";
+    const zModelGenerator = new ZModelCodeGenerator();
+    const docs = [];
+    try {
+      match3(node).when(isAttribute, (attr) => {
+        docs.push("```prisma", zModelGenerator.generate(attr), "```");
+      }).when(isFunctionDecl, (func2) => {
+        docs.push("```ts", zModelGenerator.generate(func2), "```");
+      }).when(isDataModel, (model) => {
+        docs.push("```prisma", `model ${model.name} { ... }`, "```");
+      }).when(isEnum, (enumDecl) => {
+        docs.push("```prisma", zModelGenerator.generate(enumDecl), "```");
+      }).when(isDataField, (field) => {
+        docs.push(`${field.name}: ${field.type.type ?? field.type.reference?.$refText}`);
+      }).otherwise((ast) => {
+        const name = ast.name;
+        if (name) {
+          docs.push(name);
+        }
+      });
+    } catch {
+    }
+    if (md) {
+      docs.push("___", md);
+    }
+    return docs.join("\n");
+  }
+};
+
+// src/zmodel-definition.ts
+import { DefaultDefinitionProvider } from "langium/lsp";
+import { LocationLink, Range } from "vscode-languageserver";
+var ZModelDefinitionProvider = class extends DefaultDefinitionProvider {
+  static {
+    __name(this, "ZModelDefinitionProvider");
+  }
+  documents;
+  constructor(services) {
+    super(services);
+    this.documents = services.shared.workspace.LangiumDocuments;
+  }
+  collectLocationLinks(sourceCstNode, _params) {
+    if (isModelImport(sourceCstNode.astNode)) {
+      const importedModel = resolveImport(this.documents, sourceCstNode.astNode);
+      if (importedModel?.$document) {
+        const targetObject = importedModel;
+        const selectionRange = this.nameProvider.getNameNode(targetObject)?.range ?? Range.create(0, 0, 0, 0);
+        const previewRange = targetObject.$cstNode?.range ?? Range.create(0, 0, 0, 0);
+        return [
+          LocationLink.create(importedModel.$document.uri.toString(), previewRange, selectionRange, sourceCstNode.range)
+        ];
+      }
+      return void 0;
+    }
+    return super.collectLocationLinks(sourceCstNode, _params);
+  }
+};
+
 // src/zmodel-document-builder.ts
 import { DefaultDocumentBuilder } from "langium";
 var ZModelDocumentBuilder = class extends DefaultDocumentBuilder {
@@ -7132,9 +8319,114 @@ var ZModelDocumentBuilder = class extends DefaultDocumentBuilder {
   }
 };
 
+// src/zmodel-documentation-provider.ts
+import { JSDocDocumentationProvider } from "langium";
+var ZModelDocumentationProvider = class extends JSDocDocumentationProvider {
+  static {
+    __name(this, "ZModelDocumentationProvider");
+  }
+  getDocumentation(node) {
+    if ("comments" in node && Array.isArray(node.comments) && node.comments.length > 0) {
+      return node.comments.map((c) => c.replace(/^[/]*\s*/, "")).join("\n");
+    }
+    return super.getDocumentation(node);
+  }
+};
+
+// src/zmodel-formatter.ts
+import { AbstractFormatter, Formatting } from "langium/lsp";
+var ZModelFormatter = class extends AbstractFormatter {
+  static {
+    __name(this, "ZModelFormatter");
+  }
+  formatOptions;
+  configurationProvider;
+  constructor(services) {
+    super();
+    this.configurationProvider = services.shared.workspace.ConfigurationProvider;
+  }
+  format(node) {
+    const formatter = this.getNodeFormatter(node);
+    if (isDataField(node)) {
+      if (isDataModel(node.$container) || isTypeDef(node.$container)) {
+        const dataModel = node.$container;
+        const compareFn = /* @__PURE__ */ __name((a, b) => b - a, "compareFn");
+        const maxNameLength = dataModel.fields.map((x) => x.name.length).sort(compareFn)[0] ?? 0;
+        const maxTypeLength = dataModel.fields.map(this.getFieldTypeLength).sort(compareFn)[0] ?? 0;
+        formatter.property("type").prepend(Formatting.spaces(maxNameLength - node.name.length + 1));
+        if (node.attributes.length > 0) {
+          formatter.node(node.attributes[0]).prepend(Formatting.spaces(maxTypeLength - this.getFieldTypeLength(node) + 1));
+          formatter.nodes(...node.attributes.slice(1)).prepend(Formatting.oneSpace());
+        }
+      } else {
+        formatter.property("type").prepend(Formatting.oneSpace());
+        if (node.attributes.length > 0) {
+          formatter.properties("attributes").prepend(Formatting.oneSpace());
+        }
+      }
+    } else if (isDataFieldAttribute(node)) {
+      formatter.keyword("(").surround(Formatting.noSpace());
+      formatter.keyword(")").prepend(Formatting.noSpace());
+      formatter.keyword(",").append(Formatting.oneSpace());
+      if (node.args.length > 1) {
+        formatter.nodes(...node.args.slice(1)).prepend(Formatting.oneSpace());
+      }
+    } else if (isAttributeArg(node)) {
+      formatter.keyword(":").prepend(Formatting.noSpace());
+      formatter.keyword(":").append(Formatting.oneSpace());
+    } else if (isAbstractDeclaration(node)) {
+      const bracesOpen = formatter.keyword("{");
+      const bracesClose = formatter.keyword("}");
+      formatter.interior(bracesOpen, bracesClose).prepend(Formatting.indent({
+        allowMore: true
+      }));
+      bracesOpen.prepend(Formatting.oneSpace());
+      bracesClose.prepend(Formatting.newLine());
+    } else if (isModel(node)) {
+      const model = node;
+      const nodes = formatter.nodes(...model.declarations);
+      nodes.prepend(Formatting.noIndent());
+    }
+  }
+  formatDocument(document, params) {
+    this.formatOptions = params.options;
+    this.configurationProvider.getConfiguration(ZModelLanguageMetaData.languageId, "format").then((config) => {
+      if (config) {
+      }
+    });
+    return super.formatDocument(document, params);
+  }
+  getFormatOptions() {
+    return this.formatOptions;
+  }
+  getIndent() {
+    return 1;
+  }
+  getFieldTypeLength(field) {
+    let length;
+    if (field.type.type) {
+      length = field.type.type.length;
+    } else if (field.type.reference) {
+      length = field.type.reference.$refText.length;
+    } else if (isDataField(field) && field.type.unsupported) {
+      const name = `Unsupported("${field.type.unsupported.value.value}")`;
+      length = name.length;
+    } else {
+      length = 1;
+    }
+    if (field.type.optional) {
+      length += 1;
+    }
+    if (field.type.array) {
+      length += 2;
+    }
+    return length;
+  }
+};
+
 // src/zmodel-linker.ts
 import { AstUtils as AstUtils6, Cancellation, DefaultLinker, DocumentState, interruptAndCheck } from "langium";
-import { match as match2 } from "ts-pattern";
+import { match as match4 } from "ts-pattern";
 var ZModelLinker = class extends DefaultLinker {
   static {
     __name(this, "ZModelLinker");
@@ -7323,7 +8615,7 @@ var ZModelLinker = class extends DefaultLinker {
     }
   }
   resolveLiteral(node) {
-    const type = match2(node).when(isStringLiteral, () => "String").when(isBooleanLiteral, () => "Boolean").when(isNumberLiteral, () => "Int").exhaustive();
+    const type = match4(node).when(isStringLiteral, () => "String").when(isBooleanLiteral, () => "Boolean").when(isNumberLiteral, () => "Int").exhaustive();
     if (type) {
       this.resolveToBuiltinTypeOrDecl(node, type);
     }
@@ -7491,7 +8783,7 @@ var ZModelLinker = class extends DefaultLinker {
 
 // src/zmodel-scope.ts
 import { AstUtils as AstUtils7, DefaultScopeComputation, DefaultScopeProvider, EMPTY_SCOPE, StreamScope, UriUtils, interruptAndCheck as interruptAndCheck2 } from "langium";
-import { match as match3 } from "ts-pattern";
+import { match as match5 } from "ts-pattern";
 var ZModelScopeComputation = class extends DefaultScopeComputation {
   static {
     __name(this, "ZModelScopeComputation");
@@ -7564,11 +8856,8 @@ var ZModelScopeProvider = class extends DefaultScopeProvider {
     const referenceType = this.reflection.getReferenceType(context);
     const globalScope = this.getGlobalScope(referenceType, context);
     const node = context.container;
-    const allowTypeDefScope = (
-      // isAuthOrAuthMemberAccess(node.operand) ||
-      !!AstUtils7.getContainerOfType(node, isTypeDef)
-    );
-    return match3(node.operand).when(isReferenceExpr, (operand) => {
+    const allowTypeDefScope = isAuthOrAuthMemberAccess(node.operand) || !!AstUtils7.getContainerOfType(node, isTypeDef);
+    return match5(node.operand).when(isReferenceExpr, (operand) => {
       const ref = operand.target.ref;
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
@@ -7596,8 +8885,8 @@ var ZModelScopeProvider = class extends DefaultScopeProvider {
     const referenceType = this.reflection.getReferenceType(context);
     const globalScope = this.getGlobalScope(referenceType, context);
     const collection = collectionPredicate.left;
-    const allowTypeDefScope = false;
-    return match3(collection).when(isReferenceExpr, (expr) => {
+    const allowTypeDefScope = isAuthOrAuthMemberAccess(collection);
+    return match5(collection).when(isReferenceExpr, (expr) => {
       const ref = expr.target.ref;
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
@@ -7659,11 +8948,95 @@ function getCollectionPredicateContext(node) {
 }
 __name(getCollectionPredicateContext, "getCollectionPredicateContext");
 
+// src/zmodel-semantic.ts
+import { AbstractSemanticTokenProvider } from "langium/lsp";
+import { SemanticTokenTypes } from "vscode-languageserver";
+var ZModelSemanticTokenProvider = class extends AbstractSemanticTokenProvider {
+  static {
+    __name(this, "ZModelSemanticTokenProvider");
+  }
+  highlightElement(node, acceptor) {
+    if (isDataModel(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.type
+      });
+      acceptor({
+        node,
+        property: "mixins",
+        type: SemanticTokenTypes.type
+      });
+      acceptor({
+        node,
+        property: "baseModel",
+        type: SemanticTokenTypes.type
+      });
+    } else if (isDataSource(node) || isGeneratorDecl(node) || isPlugin(node) || isEnum(node) || isTypeDef(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.type
+      });
+    } else if (isDataField(node) || isConfigField(node) || isAttributeArg(node) || isPluginField(node) || isEnumField(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.variable
+      });
+    } else if (isDataFieldType(node)) {
+      if (node.type) {
+        acceptor({
+          node,
+          property: "type",
+          type: SemanticTokenTypes.type
+        });
+      } else {
+        acceptor({
+          node,
+          property: "reference",
+          type: SemanticTokenTypes.macro
+        });
+      }
+    } else if (isDataModelAttribute(node) || isDataFieldAttribute(node) || isInternalAttribute(node)) {
+      acceptor({
+        node,
+        property: "decl",
+        type: SemanticTokenTypes.function
+      });
+    } else if (isInvocationExpr(node)) {
+      acceptor({
+        node,
+        property: "function",
+        type: SemanticTokenTypes.function
+      });
+    } else if (isFunctionDecl(node) || isAttribute(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.function
+      });
+    } else if (isReferenceExpr(node)) {
+      acceptor({
+        node,
+        property: "target",
+        type: SemanticTokenTypes.variable
+      });
+    } else if (isMemberAccessExpr(node)) {
+      acceptor({
+        node,
+        property: "member",
+        type: SemanticTokenTypes.property
+      });
+    }
+  }
+};
+
 // src/zmodel-workspace-manager.ts
-import { DefaultWorkspaceManager, URI as URI2, UriUtils as UriUtils2 } from "langium";
-import fs2 from "fs";
+import { DefaultWorkspaceManager, URI as URI2 } from "langium";
+import fs3 from "fs";
 import path2 from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var ZModelWorkspaceManager = class extends DefaultWorkspaceManager {
   static {
     __name(this, "ZModelWorkspaceManager");
@@ -7687,7 +9060,7 @@ var ZModelWorkspaceManager = class extends DefaultWorkspaceManager {
         });
         const languagePackageDir = path2.dirname(languagePackagePath);
         const candidateStdlibPath = path2.join(languagePackageDir, "res", STD_LIB_MODULE_NAME);
-        if (fs2.existsSync(candidateStdlibPath)) {
+        if (fs3.existsSync(candidateStdlibPath)) {
           installedStdlibPath = candidateStdlibPath;
           console.log(`Found installed zenstack package stdlib at: ${installedStdlibPath}`);
           break;
@@ -7699,73 +9072,12 @@ var ZModelWorkspaceManager = class extends DefaultWorkspaceManager {
     if (installedStdlibPath) {
       stdLibPath = installedStdlibPath;
     } else {
-      const _dirname = typeof __dirname !== "undefined" ? __dirname : path2.dirname(fileURLToPath(import.meta.url));
+      const _dirname = typeof __dirname !== "undefined" ? __dirname : path2.dirname(fileURLToPath2(import.meta.url));
       stdLibPath = path2.join(_dirname, "../res", STD_LIB_MODULE_NAME);
       console.log(`Using bundled stdlib in extension:`, stdLibPath);
     }
     const stdlib = await this.documentFactory.fromUri(URI2.file(stdLibPath));
     collector(stdlib);
-    const documents = this.langiumDocuments.all;
-    const pluginModels = /* @__PURE__ */ new Set();
-    documents.forEach((doc) => {
-      const parsed = doc.parseResult.value;
-      parsed.declarations.forEach((decl) => {
-        if (isPlugin(decl)) {
-          const providerField = decl.fields.find((f) => f.name === "provider");
-          if (providerField) {
-            const provider = getLiteral(providerField.value);
-            if (provider) {
-              pluginModels.add(provider);
-            }
-          }
-        }
-      });
-    });
-    if (pluginModels.size > 0) {
-      console.log(`Used plugin modules: ${Array.from(pluginModels)}`);
-      const pendingPluginModules = new Set(pluginModels);
-      await Promise.all(folders.map((wf) => [
-        wf,
-        this.getRootFolder(wf)
-      ]).map(async (entry) => this.loadPluginModels(...entry, pendingPluginModules, collector)));
-    }
-  }
-  async loadPluginModels(workspaceFolder, folderPath, pendingPluginModels, collector) {
-    const content = (await this.fileSystemProvider.readDirectory(folderPath)).sort((a, b) => {
-      if (a.isDirectory && b.isDirectory) {
-        const aName = UriUtils2.basename(a.uri);
-        if (aName === "node_modules") {
-          return -1;
-        } else {
-          return 1;
-        }
-      } else {
-        return 0;
-      }
-    });
-    for (const entry of content) {
-      if (entry.isDirectory) {
-        const name = UriUtils2.basename(entry.uri);
-        if (name === "node_modules") {
-          for (const plugin of Array.from(pendingPluginModels)) {
-            const path4 = UriUtils2.joinPath(entry.uri, plugin, PLUGIN_MODULE_NAME);
-            try {
-              await this.fileSystemProvider.readFile(path4);
-              const document = await this.langiumDocuments.getOrCreateDocument(path4);
-              collector(document);
-              console.log(`Adding plugin document from ${path4.path}`);
-              pendingPluginModels.delete(plugin);
-              if (pendingPluginModels.size === 0) {
-                return;
-              }
-            } catch {
-            }
-          }
-        } else {
-          await this.loadPluginModels(workspaceFolder, entry.uri, pendingPluginModels, collector);
-        }
-      }
-    }
   }
 };
 
@@ -7778,6 +9090,16 @@ var ZModelLanguageModule = {
   },
   validation: {
     ZModelValidator: /* @__PURE__ */ __name((services) => new ZModelValidator(services), "ZModelValidator")
+  },
+  lsp: {
+    Formatter: /* @__PURE__ */ __name((services) => new ZModelFormatter(services), "Formatter"),
+    DefinitionProvider: /* @__PURE__ */ __name((services) => new ZModelDefinitionProvider(services), "DefinitionProvider"),
+    CompletionProvider: /* @__PURE__ */ __name((services) => new ZModelCompletionProvider(services), "CompletionProvider"),
+    SemanticTokenProvider: /* @__PURE__ */ __name((services) => new ZModelSemanticTokenProvider(services), "SemanticTokenProvider")
+  },
+  documentation: {
+    CommentProvider: /* @__PURE__ */ __name((services) => new ZModelCommentProvider(services), "CommentProvider"),
+    DocumentationProvider: /* @__PURE__ */ __name((services) => new ZModelDocumentationProvider(services), "DocumentationProvider")
   }
 };
 var ZModelSharedModule = {
@@ -7786,7 +9108,7 @@ var ZModelSharedModule = {
     WorkspaceManager: /* @__PURE__ */ __name((services) => new ZModelWorkspaceManager(services), "WorkspaceManager")
   }
 };
-function createZModelLanguageServices(context) {
+function createZModelLanguageServices(context, logToConsole = false) {
   const shared = inject(createDefaultSharedModule(context), ZModelGeneratedSharedModule, ZModelSharedModule);
   const ZModelLanguage = inject(createDefaultModule({
     shared
@@ -7796,30 +9118,47 @@ function createZModelLanguageServices(context) {
   if (!context.connection) {
     shared.workspace.ConfigurationProvider.initialized({});
   }
+  shared.workspace.DocumentBuilder.onBuildPhase(DocumentState2.Parsed, async (documents) => {
+    for (const doc of documents) {
+      if (doc.parseResult.lexerErrors.length > 0 || doc.parseResult.parserErrors.length > 0) {
+        continue;
+      }
+      if (doc.uri.scheme !== "file") {
+        continue;
+      }
+      const schemaPath = fileURLToPath3(doc.uri.toString());
+      const pluginSchemas = getPluginDocuments(doc.parseResult.value, schemaPath);
+      for (const plugin of pluginSchemas) {
+        const pluginDocUri = URI3.file(path3.resolve(plugin));
+        let pluginDoc = shared.workspace.LangiumDocuments.getDocument(pluginDocUri);
+        if (!pluginDoc) {
+          pluginDoc = await shared.workspace.LangiumDocuments.getOrCreateDocument(pluginDocUri);
+          if (pluginDoc) {
+            shared.workspace.IndexManager.updateContent(pluginDoc);
+            if (logToConsole) {
+              console.log(`Loaded plugin model: ${plugin}`);
+            }
+          }
+        }
+      }
+    }
+  });
   return {
     shared,
     ZModelLanguage
   };
 }
 __name(createZModelLanguageServices, "createZModelLanguageServices");
-
-// src/index.ts
-function createZModelServices() {
-  return createZModelLanguageServices(NodeFileSystem);
+function createZModelServices(logToConsole = false) {
+  return createZModelLanguageServices(NodeFileSystem, logToConsole);
 }
 __name(createZModelServices, "createZModelServices");
-var DocumentLoadError = class extends Error {
-  static {
-    __name(this, "DocumentLoadError");
-  }
-  constructor(message) {
-    super(message);
-  }
-};
+
+// src/document.ts
 async function loadDocument(fileName, additionalModelFiles = []) {
-  const { ZModelLanguage: services } = createZModelServices();
+  const { ZModelLanguage: services } = createZModelServices(false);
   const extensions = services.LanguageMetaData.fileExtensions;
-  if (!extensions.includes(path3.extname(fileName))) {
+  if (!extensions.includes(path4.extname(fileName))) {
     return {
       success: false,
       errors: [
@@ -7828,7 +9167,7 @@ async function loadDocument(fileName, additionalModelFiles = []) {
       warnings: []
     };
   }
-  if (!fs3.existsSync(fileName)) {
+  if (!fs4.existsSync(fileName)) {
     return {
       success: false,
       errors: [
@@ -7837,19 +9176,19 @@ async function loadDocument(fileName, additionalModelFiles = []) {
       warnings: []
     };
   }
-  const _dirname = typeof __dirname !== "undefined" ? __dirname : path3.dirname(fileURLToPath2(import.meta.url));
-  const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(path3.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
-  const pluginDocs = await Promise.all(additionalModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(file)))));
+  const _dirname = typeof __dirname !== "undefined" ? __dirname : path4.dirname(fileURLToPath4(import.meta.url));
+  const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI4.file(path4.resolve(path4.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
   const langiumDocuments = services.shared.workspace.LangiumDocuments;
-  const document = await langiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(fileName)));
+  const document = await langiumDocuments.getOrCreateDocument(URI4.file(path4.resolve(fileName)));
   const importedURIs = await loadImports(document, langiumDocuments);
   const importedDocuments = [];
   for (const uri of importedURIs) {
     importedDocuments.push(await langiumDocuments.getOrCreateDocument(uri));
   }
+  const additionalDocs = await Promise.all(additionalModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI4.file(path4.resolve(file)))));
   await services.shared.workspace.DocumentBuilder.build([
     stdLib,
-    ...pluginDocs,
+    ...additionalDocs,
     document,
     ...importedDocuments
   ], {
@@ -7867,7 +9206,7 @@ async function loadDocument(fileName, additionalModelFiles = []) {
   const warnings = [];
   if (diagnostics.length > 0) {
     for (const { doc, diag } of diagnostics) {
-      const message = `${path3.relative(process.cwd(), doc.uri.fsPath)}:${diag.range.start.line + 1}:${diag.range.start.character + 1} - ${diag.message}`;
+      const message = `${path4.relative(process.cwd(), doc.uri.fsPath)}:${diag.range.start.line + 1}:${diag.range.start.character + 1} - ${diag.message}`;
       if (diag.severity === 1) {
         errors.push(message);
       } else {
@@ -7916,7 +9255,7 @@ async function loadImports(document, documents, uris = /* @__PURE__ */ new Set()
       }
     }
   }
-  return Array.from(uris).filter((x) => uriString != x).map((e) => URI3.parse(e));
+  return Array.from(uris).filter((x) => uriString != x).map((e) => URI4.parse(e));
 }
 __name(loadImports, "loadImports");
 function mergeImportsDeclarations(documents, model) {
@@ -7965,13 +9304,33 @@ function validationAfterImportMerge(model) {
   return errors;
 }
 __name(validationAfterImportMerge, "validationAfterImportMerge");
+async function formatDocument(content) {
+  const services = createZModelServices().ZModelLanguage;
+  const langiumDocuments = services.shared.workspace.LangiumDocuments;
+  const document = langiumDocuments.createDocument(URI4.parse("memory://schema.zmodel"), content);
+  const formatter = services.lsp.Formatter;
+  const identifier = {
+    uri: document.uri.toString()
+  };
+  const options = formatter.getFormatOptions() ?? {
+    insertSpaces: true,
+    tabSize: 4
+  };
+  const edits = await formatter.formatDocument(document, {
+    options,
+    textDocument: identifier
+  });
+  return TextDocument.applyEdits(document.textDocument, edits);
+}
+__name(formatDocument, "formatDocument");
 export {
-  DocumentLoadError,
+  ZModelCodeGenerator,
   ZModelLanguageMetaData,
   ZModelLanguageModule,
   ZModelSharedModule,
   createZModelLanguageServices,
   createZModelServices,
+  formatDocument,
   loadDocument
 };
 //# sourceMappingURL=index.js.map