@zenstackhq/language 3.0.0-beta.2 → 3.0.0-beta.21

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, 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,15 +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 { invariant } from "@zenstackhq/common-helpers";
 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);
 }
@@ -5192,10 +5243,6 @@ function isRelationshipField(field) {
   return isDataModel(field.type.reference?.ref);
 }
 __name(isRelationshipField, "isRelationshipField");
-function isFutureExpr(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "future" && isFromStdlib(node.function.ref);
-}
-__name(isFutureExpr, "isFutureExpr");
 function isDelegateModel(node) {
   return isDataModel(node) && hasAttribute(node, "@@delegate");
 }
@@ -5213,8 +5260,14 @@ function getRecursiveBases(decl, includeDelegate = true, seen = /* @__PURE__ */
     return result;
   }
   seen.add(decl);
-  decl.mixins.forEach((mixin) => {
-    const baseDecl = mixin.ref;
+  const bases = [
+    ...decl.mixins,
+    ...isDataModel(decl) && decl.baseModel ? [
+      decl.baseModel
+    ] : []
+  ];
+  bases.forEach((base) => {
+    const baseDecl = decl.$container.declarations.find((d) => (isTypeDef(d) || isDataModel(d)) && d.name === base.$refText);
     if (baseDecl) {
       if (!includeDelegate && isDelegateModel(baseDecl)) {
         return;
@@ -5337,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");
@@ -5354,7 +5411,7 @@ function getFunctionExpressionContext(funcDecl) {
 }
 __name(getFunctionExpressionContext, "getFunctionExpressionContext");
 function isCheckInvocation(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "check" && isFromStdlib(node.function.ref);
+  return isInvocationExpr(node) && node.function.ref?.name === "check";
 }
 __name(isCheckInvocation, "isCheckInvocation");
 function resolveTransitiveImports(documents, model) {
@@ -5424,17 +5481,17 @@ 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 isFutureInvocation(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "future" && isFromStdlib(node.function.ref);
+function isBeforeInvocation(node) {
+  return isInvocationExpr(node) && node.function.ref?.name === "before";
 }
-__name(isFutureInvocation, "isFutureInvocation");
+__name(isBeforeInvocation, "isBeforeInvocation");
 function isCollectionPredicate(node) {
   return isBinaryExpr(node) && [
     "?",
@@ -5489,12 +5546,14 @@ function getAllFields(decl, includeIgnored = false, seen = /* @__PURE__ */ new S
   seen.add(decl);
   const fields = [];
   for (const mixin of decl.mixins) {
-    invariant(mixin.ref, `Mixin ${mixin.$refText} is not resolved`);
-    fields.push(...getAllFields(mixin.ref, includeIgnored, seen));
+    if (mixin.ref) {
+      fields.push(...getAllFields(mixin.ref, includeIgnored, seen));
+    }
   }
   if (isDataModel(decl) && decl.baseModel) {
-    invariant(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
-    fields.push(...getAllFields(decl.baseModel.ref, includeIgnored, seen));
+    if (decl.baseModel.ref) {
+      fields.push(...getAllFields(decl.baseModel.ref, includeIgnored, seen));
+    }
   }
   fields.push(...decl.fields.filter((f) => includeIgnored || !hasAttribute(f, "@ignore")));
   return fields;
@@ -5507,12 +5566,14 @@ function getAllAttributes(decl, seen = /* @__PURE__ */ new Set()) {
   seen.add(decl);
   const attributes = [];
   for (const mixin of decl.mixins) {
-    invariant(mixin.ref, `Mixin ${mixin.$refText} is not resolved`);
-    attributes.push(...getAllAttributes(mixin.ref, seen));
+    if (mixin.ref) {
+      attributes.push(...getAllAttributes(mixin.ref, seen));
+    }
   }
   if (isDataModel(decl) && decl.baseModel) {
-    invariant(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
-    attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+    if (decl.baseModel.ref) {
+      attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+    }
   }
   attributes.push(...decl.attributes);
   return attributes;
@@ -5527,6 +5588,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;
@@ -5536,6 +5662,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);
@@ -5649,6 +5778,7 @@ var AttributeApplicationValidator = class {
       });
     }
   }
+  // TODO: design a way to let plugin register validation
   _checkModelLevelPolicy(attr, accept) {
     const kind = getStringLiteral(attr.args[0]?.value);
     if (!kind) {
@@ -5661,11 +5791,61 @@ var AttributeApplicationValidator = class {
       "create",
       "read",
       "update",
+      "post-update",
       "delete",
       "all"
     ], attr, accept);
-    this.rejectEncryptedFields(attr, accept);
+    if ((kind === "create" || kind === "all") && attr.args[1]?.value) {
+      this.rejectNonOwnedRelationInExpression(attr.args[1].value, accept);
+    }
+    if (kind !== "post-update" && attr.args[1]?.value) {
+      const beforeCall = AstUtils2.streamAst(attr.args[1]?.value).find(isBeforeInvocation);
+      if (beforeCall) {
+        accept("error", `"before()" is only allowed in "post-update" policy rules`, {
+          node: beforeCall
+        });
+      }
+    }
   }
+  rejectNonOwnedRelationInExpression(expr, accept) {
+    const contextModel = AstUtils2.getContainerOfType(expr, isDataModel);
+    if (!contextModel) {
+      return;
+    }
+    if (AstUtils2.streamAst(expr).some((node) => {
+      if (!isDataFieldReference(node)) {
+        return false;
+      }
+      if (node.target.ref?.$container !== contextModel) {
+        return false;
+      }
+      const field = node.target.ref;
+      if (!isRelationshipField(field)) {
+        return false;
+      }
+      if (isAuthOrAuthMemberAccess(node)) {
+        return false;
+      }
+      const startNode = isCollectionPredicate(node.$container) && node.$container.left === node ? node.$container : node;
+      const collectionPredicate = AstUtils2.getContainerOfType(startNode.$container, isCollectionPredicate);
+      if (collectionPredicate && isAuthOrAuthMemberAccess(collectionPredicate.left)) {
+        return false;
+      }
+      const relationAttr = field.attributes.find((attr) => attr.decl.ref?.name === "@relation");
+      if (!relationAttr) {
+        return true;
+      }
+      if (!relationAttr.args.some((arg) => arg.name === "fields")) {
+        return true;
+      }
+      return false;
+    })) {
+      accept("error", `non-owned relation fields are not allowed in "create" rules`, {
+        node: expr
+      });
+    }
+  }
+  // TODO: design a way to let plugin register validation
   _checkFieldLevelPolicy(attr, accept) {
     const kind = getStringLiteral(attr.args[0]?.value);
     if (!kind) {
@@ -5680,8 +5860,8 @@ var AttributeApplicationValidator = class {
       "all"
     ], attr, accept);
     const expr = attr.args[1]?.value;
-    if (expr && AstUtils2.streamAst(expr).some((node) => isFutureExpr(node))) {
-      accept("error", `"future()" is not allowed in field-level policy rules`, {
+    if (expr && AstUtils2.streamAst(expr).some((node) => isBeforeInvocation(node))) {
+      accept("error", `"before()" is not allowed in field-level policy rules`, {
         node: expr
       });
     }
@@ -5693,7 +5873,6 @@ var AttributeApplicationValidator = class {
         });
       }
     }
-    this.rejectEncryptedFields(attr, accept);
   }
   _checkValidate(attr, accept) {
     const condition = attr.args[0]?.value;
@@ -5703,8 +5882,9 @@ var AttributeApplicationValidator = class {
       });
     }
   }
-  _checkUnique(attr, accept) {
-    const fields = attr.args[0]?.value;
+  _checkConstraint(attr, accept) {
+    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]
@@ -5713,7 +5893,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;
@@ -5732,7 +5912,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
           });
         }
@@ -5743,14 +5923,23 @@ var AttributeApplicationValidator = class {
       });
     }
   }
-  rejectEncryptedFields(attr, accept) {
-    AstUtils2.streamAllContents(attr).forEach((node) => {
-      if (isDataFieldReference(node) && hasAttribute(node.target.ref, "@encrypted")) {
-        accept("error", `Encrypted fields cannot be used in policy rules`, {
-          node
+  _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());
@@ -5794,15 +5983,25 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], AttributeApplicationValidator.prototype, "_checkValidate", null);
 _ts_decorate([
-  check("@@unique"),
   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, "_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, "_checkUnique", null);
+], AttributeApplicationValidator.prototype, "_checkSchema", null);
 function assignableToAttributeParam(arg, param, attr) {
   const argResolvedType = arg.$resolvedType;
   if (!argResolvedType) {
@@ -5812,6 +6011,10 @@ function assignableToAttributeParam(arg, param, attr) {
   let dstIsArray = param.type.array;
   if (dstType === "ContextType") {
     if (isDataField(attr.$container)) {
+      const dstIsTypedJson = hasAttribute(attr.$container, "@json");
+      if (dstIsTypedJson && attr.decl.ref?.name === "@default") {
+        return argResolvedType.decl === "String";
+      }
       dstIsArray = attr.$container.type.array;
     }
   }
@@ -5903,6 +6106,9 @@ function isValidAttributeTarget(attrDecl, targetDecl) {
       case "TypeDefField":
         allowed = allowed || isTypeDef(targetDecl.type.reference?.ref);
         break;
+      case "ListField":
+        allowed = allowed || !isDataModel(targetDecl.type.reference?.ref) && targetDecl.type.array;
+        break;
       default:
         break;
     }
@@ -6353,7 +6559,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");
@@ -6363,16 +6568,52 @@ 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 if (
+        // validate `defaultSchema` is included in `schemas`
+        defaultSchemaValue && !schemasValue.items.some((e) => getStringLiteral(e) === defaultSchemaValue)
+      ) {
+        accept("error", `"${defaultSchemaValue}" must be included in the "schemas" array`, {
+          node: schemasField
+        });
+      }
+    }
   }
   validateUrl(ds, accept) {
     const urlField = ds.fields.find((f) => f.name === "url");
@@ -6386,20 +6627,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
@@ -6452,11 +6679,21 @@ var ExpressionValidator = class {
       }
     }
     switch (expr.$type) {
+      case "MemberAccessExpr":
+        this.validateMemberAccessExpr(expr, accept);
+        break;
       case "BinaryExpr":
         this.validateBinaryExpr(expr, accept);
         break;
     }
   }
+  validateMemberAccessExpr(expr, accept) {
+    if (isBeforeInvocation(expr.operand) && isDataModel(expr.$resolvedType?.decl)) {
+      accept("error", "relation fields cannot be accessed from `before()`", {
+        node: expr
+      });
+    }
+  }
   validateBinaryExpr(expr, accept) {
     switch (expr.operator) {
       case "in": {
@@ -6509,23 +6746,25 @@ var ExpressionValidator = class {
             "Any"
           ];
         }
-        if (typeof expr.left.$resolvedType?.decl !== "string" || !supportedShapes.includes(expr.left.$resolvedType.decl)) {
+        const leftResolvedDecl = expr.left.$resolvedType?.decl;
+        const rightResolvedDecl = expr.right.$resolvedType?.decl;
+        if (leftResolvedDecl && (typeof leftResolvedDecl !== "string" || !supportedShapes.includes(leftResolvedDecl))) {
           accept("error", `invalid operand type for "${expr.operator}" operator`, {
             node: expr.left
           });
           return;
         }
-        if (typeof expr.right.$resolvedType?.decl !== "string" || !supportedShapes.includes(expr.right.$resolvedType.decl)) {
+        if (rightResolvedDecl && (typeof rightResolvedDecl !== "string" || !supportedShapes.includes(rightResolvedDecl))) {
           accept("error", `invalid operand type for "${expr.operator}" operator`, {
             node: expr.right
           });
           return;
         }
-        if (expr.left.$resolvedType.decl === "DateTime" && expr.right.$resolvedType.decl !== "DateTime") {
+        if (leftResolvedDecl === "DateTime" && rightResolvedDecl && rightResolvedDecl !== "DateTime") {
           accept("error", "incompatible operand types", {
             node: expr
           });
-        } else if (expr.right.$resolvedType.decl === "DateTime" && expr.left.$resolvedType.decl !== "DateTime") {
+        } else if (rightResolvedDecl === "DateTime" && leftResolvedDecl && leftResolvedDecl !== "DateTime") {
           accept("error", "incompatible operand types", {
             node: expr
           });
@@ -6565,11 +6804,11 @@ var ExpressionValidator = class {
             });
           }
           if (isDataFieldReference(expr.left) && (isThisExpr(expr.right) || isDataFieldReference(expr.right))) {
-            accept("error", "comparison between model-typed fields are not supported", {
+            accept("error", "comparison between models is not supported", {
               node: expr
             });
           } else if (isDataFieldReference(expr.right) && (isThisExpr(expr.left) || isDataFieldReference(expr.left))) {
-            accept("error", "comparison between model-typed fields are not supported", {
+            accept("error", "comparison between models is not supported", {
               node: expr
             });
           }
@@ -6659,41 +6898,39 @@ var FunctionInvocationValidator = class {
     if (!this.validateArgs(funcDecl, expr.args, 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 = match(containerAttribute?.decl.$refText).with("@default", () => ExpressionContext.DefaultValue).with(P.union("@@allow", "@@deny", "@allow", "@deny"), () => ExpressionContext.AccessPolicy).with("@@validate", () => ExpressionContext.ValidationRule).with("@@index", () => ExpressionContext.Index).otherwise(() => void 0);
-      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]
-          });
-        }
       }
     }
     const checker = invocationCheckers.get(expr.function.$refText);
@@ -6701,6 +6938,18 @@ var FunctionInvocationValidator = class {
       checker.value.call(this, expr, accept);
     }
   }
+  getExpressionContext(containerAttribute) {
+    if (!containerAttribute) {
+      return void 0;
+    }
+    if (this.isValidationAttribute(containerAttribute)) {
+      return ExpressionContext.ValidationRule;
+    }
+    return match(containerAttribute?.decl.$refText).with("@default", () => ExpressionContext.DefaultValue).with(P.union("@@allow", "@@deny", "@allow", "@deny"), () => ExpressionContext.AccessPolicy).with("@@index", () => ExpressionContext.Index).otherwise(() => void 0);
+  }
+  isValidationAttribute(attr) {
+    return !!attr.decl.ref?.attributes.some((attr2) => attr2.decl.$refText === "@@@validation");
+  }
   validateArgs(funcDecl, args, accept) {
     let success = true;
     for (let i = 0; i < funcDecl.params.length; i++) {
@@ -6761,6 +7010,44 @@ var FunctionInvocationValidator = class {
     }
     return true;
   }
+  _checkLength(expr, accept) {
+    const msg = "argument must be a string or list field";
+    const fieldArg = expr.args[0].value;
+    if (!isDataFieldReference(fieldArg)) {
+      accept("error", msg, {
+        node: expr.args[0]
+      });
+      return;
+    }
+    if (isDataModel(fieldArg.$resolvedType?.decl)) {
+      accept("error", msg, {
+        node: expr.args[0]
+      });
+      return;
+    }
+    if (!fieldArg.$resolvedType?.array && fieldArg.$resolvedType?.decl !== "String") {
+      accept("error", msg, {
+        node: expr.args[0]
+      });
+    }
+  }
+  _checkRegex(expr, accept) {
+    const regex = expr.args[1]?.value;
+    if (!isStringLiteral(regex)) {
+      accept("error", "second argument must be a string literal", {
+        node: expr.args[1]
+      });
+      return;
+    }
+    try {
+      new RegExp(regex.value);
+    } catch (e) {
+      accept("error", "invalid regular expression: " + e.message, {
+        node: expr.args[1]
+      });
+    }
+  }
+  // TODO: move this to policy plugin
   _checkCheck(expr, accept) {
     let valid = true;
     const fieldArg = expr.args[0].value;
@@ -6832,6 +7119,24 @@ var FunctionInvocationValidator = class {
     }
   }
 };
+_ts_decorate2([
+  func("length"),
+  _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, "_checkLength", null);
+_ts_decorate2([
+  func("regex"),
+  _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, "_checkRegex", null);
 _ts_decorate2([
   func("check"),
   _ts_metadata2("design:type", Function),
@@ -6941,50 +7246,1039 @@ var ZModelValidator = class {
   constructor(services) {
     this.services = services;
   }
-  shouldCheck(node) {
-    let doc;
-    let currNode = node;
-    while (currNode) {
-      if (currNode.$document) {
-        doc = currNode.$document;
-        break;
-      }
-      currNode = currNode.$container;
-    }
-    return doc?.parseResult.lexerErrors.length === 0 && doc?.parseResult.parserErrors.length === 0;
-  }
   checkModel(node, accept) {
-    this.shouldCheck(node) && new SchemaValidator(this.services.shared.workspace.LangiumDocuments).validate(node, accept);
+    new SchemaValidator(this.services.shared.workspace.LangiumDocuments).validate(node, accept);
   }
   checkDataSource(node, accept) {
-    this.shouldCheck(node) && new DataSourceValidator().validate(node, accept);
+    new DataSourceValidator().validate(node, accept);
   }
   checkDataModel(node, accept) {
-    this.shouldCheck(node) && new DataModelValidator().validate(node, accept);
+    new DataModelValidator().validate(node, accept);
   }
   checkTypeDef(node, accept) {
-    this.shouldCheck(node) && new TypeDefValidator().validate(node, accept);
+    new TypeDefValidator().validate(node, accept);
   }
   checkEnum(node, accept) {
-    this.shouldCheck(node) && new EnumValidator().validate(node, accept);
+    new EnumValidator().validate(node, accept);
   }
   checkAttribute(node, accept) {
-    this.shouldCheck(node) && new AttributeValidator().validate(node, accept);
+    new AttributeValidator().validate(node, accept);
   }
   checkExpression(node, accept) {
-    this.shouldCheck(node) && new ExpressionValidator().validate(node, accept);
+    new ExpressionValidator().validate(node, accept);
   }
   checkFunctionInvocation(node, accept) {
-    this.shouldCheck(node) && new FunctionInvocationValidator().validate(node, accept);
+    new FunctionInvocationValidator().validate(node, accept);
   }
   checkFunctionDecl(node, accept) {
-    this.shouldCheck(node) && new FunctionDeclValidator().validate(node, accept);
+    new FunctionDeclValidator().validate(node, accept);
   }
 };
 
-// src/zmodel-linker.ts
-import { AstUtils as AstUtils6, Cancellation, DefaultLinker, DocumentState, interruptAndCheck, isReference } from "langium";
+// 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.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 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.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 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 {
+  static {
+    __name(this, "ZModelDocumentBuilder");
+  }
+  constructor(services) {
+    super(services);
+    let validationOptions = this.updateBuildOptions.validation;
+    const stopFlags = {
+      stopAfterLinkingErrors: true,
+      stopAfterLexingErrors: true,
+      stopAfterParsingErrors: true
+    };
+    if (validationOptions === true) {
+      validationOptions = stopFlags;
+    } else if (typeof validationOptions === "object") {
+      validationOptions = {
+        ...validationOptions,
+        ...stopFlags
+      };
+    }
+    this.updateBuildOptions = {
+      ...this.updateBuildOptions,
+      validation: validationOptions
+    };
+  }
+};
+
+// 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 match4 } from "ts-pattern";
 var ZModelLinker = class extends DefaultLinker {
   static {
     __name(this, "ZModelLinker");
@@ -7005,21 +8299,19 @@ var ZModelLinker = class extends DefaultLinker {
     }
     document.state = DocumentState.Linked;
   }
-  linkReference(container, property, document, extraScopes) {
-    if (this.resolveFromScopeProviders(container, property, document, extraScopes)) {
+  linkReference(refInfo, document, extraScopes) {
+    const defaultRef = refInfo.reference;
+    if (defaultRef._ref) {
+      return;
+    }
+    if (this.resolveFromScopeProviders(refInfo.reference, document, extraScopes)) {
       return;
     }
-    const reference = container[property];
-    this.doLink({
-      reference,
-      container,
-      property
-    }, document);
+    this.doLink(refInfo, document);
   }
   //#endregion
   //#region Expression type resolving
-  resolveFromScopeProviders(node, property, document, providers) {
-    const reference = node[property];
+  resolveFromScopeProviders(reference, document, providers) {
     for (const provider of providers) {
       const target = provider(reference.$refText);
       if (target) {
@@ -7148,7 +8440,11 @@ var ZModelLinker = class extends DefaultLinker {
     }
   }
   resolveInvocation(node, document, extraScopes) {
-    this.linkReference(node, "function", document, extraScopes);
+    this.linkReference({
+      reference: node.function,
+      container: node,
+      property: "function"
+    }, document, extraScopes);
     node.args.forEach((arg) => this.resolve(arg, document, extraScopes));
     if (node.function.ref) {
       const funcDecl = node.function.ref;
@@ -7161,7 +8457,7 @@ var ZModelLinker = class extends DefaultLinker {
             nullable: true
           };
         }
-      } else if (isFutureExpr(node)) {
+      } else if (isBeforeInvocation(node)) {
         node.$resolvedType = {
           decl: getContainingDataModel(node)
         };
@@ -7171,7 +8467,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);
     }
@@ -7225,7 +8521,7 @@ var ZModelLinker = class extends DefaultLinker {
         if (isArrayExpr(node.value)) {
           node.value.items.forEach((item) => {
             if (isReferenceExpr(item)) {
-              const resolved2 = this.resolveFromScopeProviders(item, "target", document, [
+              const resolved2 = this.resolveFromScopeProviders(item.target, document, [
                 scopeProvider
               ]);
               if (resolved2) {
@@ -7239,7 +8535,7 @@ var ZModelLinker = class extends DefaultLinker {
             this.resolveToBuiltinTypeOrDecl(node.value, node.value.items[0].$resolvedType.decl, true);
           }
         } else if (isReferenceExpr(node.value)) {
-          const resolved2 = this.resolveFromScopeProviders(node.value, "target", document, [
+          const resolved2 = this.resolveFromScopeProviders(node.value.target, document, [
             scopeProvider
           ]);
           if (resolved2) {
@@ -7291,13 +8587,9 @@ var ZModelLinker = class extends DefaultLinker {
     this.resolveDefault(node, document, scopes);
   }
   resolveDefault(node, document, extraScopes) {
-    for (const [property, value] of Object.entries(node)) {
-      if (!property.startsWith("$")) {
-        if (isReference(value)) {
-          this.linkReference(node, property, document, extraScopes);
-        }
-      }
-    }
+    AstUtils6.streamReferences(node).forEach((ref) => {
+      this.linkReference(ref, document, extraScopes);
+    });
     for (const child of AstUtils6.streamContents(node)) {
       this.resolve(child, document, extraScopes);
     }
@@ -7343,7 +8635,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");
@@ -7367,7 +8659,7 @@ var ZModelScopeComputation = class extends DefaultScopeComputation {
   }
   processNode(node, document, scopes) {
     super.processNode(node, document, scopes);
-    if (isDataModel(node)) {
+    if (isDataModel(node) || isTypeDef(node)) {
       const bases = getRecursiveBases(node);
       for (const base of bases) {
         for (const field of base.fields) {
@@ -7420,7 +8712,7 @@ var ZModelScopeProvider = class extends DefaultScopeProvider {
       // isAuthOrAuthMemberAccess(node.operand) ||
       !!AstUtils7.getContainerOfType(node, isTypeDef)
     );
-    return match3(node.operand).when(isReferenceExpr, (operand) => {
+    return match5(node.operand).when(isReferenceExpr, (operand) => {
       const ref = operand.target.ref;
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
@@ -7438,7 +8730,7 @@ var ZModelScopeProvider = class extends DefaultScopeProvider {
       if (isAuthInvocation(operand)) {
         return this.createScopeForAuth(node, globalScope);
       }
-      if (isFutureInvocation(operand)) {
+      if (isBeforeInvocation(operand)) {
         return this.createScopeForContainingModel(node, globalScope);
       }
       return EMPTY_SCOPE;
@@ -7449,7 +8741,7 @@ var ZModelScopeProvider = class extends DefaultScopeProvider {
     const globalScope = this.getGlobalScope(referenceType, context);
     const collection = collectionPredicate.left;
     const allowTypeDefScope = false;
-    return match3(collection).when(isReferenceExpr, (expr) => {
+    return match5(collection).when(isReferenceExpr, (expr) => {
       const ref = expr.target.ref;
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
@@ -7511,11 +8803,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");
@@ -7539,7 +8915,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;
@@ -7551,73 +8927,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);
-        }
-      }
-    }
   }
 };
 
@@ -7630,14 +8945,25 @@ 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 = {
   workspace: {
+    DocumentBuilder: /* @__PURE__ */ __name((services) => new ZModelDocumentBuilder(services), "DocumentBuilder"),
     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
@@ -7647,30 +8973,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);
-  }
-};
-async function loadDocument(fileName, pluginModelFiles = []) {
-  const { ZModelLanguage: services } = createZModelServices();
+
+// src/document.ts
+async function loadDocument(fileName, additionalModelFiles = []) {
+  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: [
@@ -7679,7 +9022,7 @@ async function loadDocument(fileName, pluginModelFiles = []) {
       warnings: []
     };
   }
-  if (!fs3.existsSync(fileName)) {
+  if (!fs4.existsSync(fileName)) {
     return {
       success: false,
       errors: [
@@ -7688,23 +9031,27 @@ async function loadDocument(fileName, pluginModelFiles = []) {
       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(pluginModelFiles.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
   ], {
-    validation: true
+    validation: {
+      stopAfterLexingErrors: true,
+      stopAfterParsingErrors: true,
+      stopAfterLinkingErrors: true
+    }
   });
   const diagnostics = langiumDocuments.all.flatMap((doc) => (doc.diagnostics ?? []).map((diag) => ({
     doc,
@@ -7714,7 +9061,7 @@ async function loadDocument(fileName, pluginModelFiles = []) {
   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 {
@@ -7763,7 +9110,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) {
@@ -7813,7 +9160,7 @@ function validationAfterImportMerge(model) {
 }
 __name(validationAfterImportMerge, "validationAfterImportMerge");
 export {
-  DocumentLoadError,
+  ZModelCodeGenerator,
   ZModelLanguageMetaData,
   ZModelLanguageModule,
   ZModelSharedModule,