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

package/dist/utils.js

@@ -0,0 +1,1461 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils.ts
+import { invariant } from "@zenstackhq/common-helpers";
+import { AstUtils, URI } from "langium";
+import fs from "fs";
+import path from "path";
+
+// src/constants.ts
+var STD_LIB_MODULE_NAME = "stdlib.zmodel";
+
+// src/generated/ast.ts
+import * as langium from "langium";
+var AbstractDeclaration = "AbstractDeclaration";
+var ConfigExpr = "ConfigExpr";
+var Expression = "Expression";
+function isExpression(item) {
+  return reflection.isInstance(item, Expression);
+}
+__name(isExpression, "isExpression");
+var LiteralExpr = "LiteralExpr";
+function isLiteralExpr(item) {
+  return reflection.isInstance(item, LiteralExpr);
+}
+__name(isLiteralExpr, "isLiteralExpr");
+var MemberAccessTarget = "MemberAccessTarget";
+var ReferenceTarget = "ReferenceTarget";
+var TypeDeclaration = "TypeDeclaration";
+var Argument = "Argument";
+var ArrayExpr = "ArrayExpr";
+function isArrayExpr(item) {
+  return reflection.isInstance(item, ArrayExpr);
+}
+__name(isArrayExpr, "isArrayExpr");
+var Attribute = "Attribute";
+var AttributeArg = "AttributeArg";
+var AttributeParam = "AttributeParam";
+var AttributeParamType = "AttributeParamType";
+var BinaryExpr = "BinaryExpr";
+function isBinaryExpr(item) {
+  return reflection.isInstance(item, BinaryExpr);
+}
+__name(isBinaryExpr, "isBinaryExpr");
+var BooleanLiteral = "BooleanLiteral";
+var ConfigArrayExpr = "ConfigArrayExpr";
+function isConfigArrayExpr(item) {
+  return reflection.isInstance(item, ConfigArrayExpr);
+}
+__name(isConfigArrayExpr, "isConfigArrayExpr");
+var ConfigField = "ConfigField";
+var ConfigInvocationArg = "ConfigInvocationArg";
+var ConfigInvocationExpr = "ConfigInvocationExpr";
+var DataField = "DataField";
+function isDataField(item) {
+  return reflection.isInstance(item, DataField);
+}
+__name(isDataField, "isDataField");
+var DataFieldAttribute = "DataFieldAttribute";
+var DataFieldType = "DataFieldType";
+var DataModel = "DataModel";
+function isDataModel(item) {
+  return reflection.isInstance(item, DataModel);
+}
+__name(isDataModel, "isDataModel");
+var DataModelAttribute = "DataModelAttribute";
+var DataSource = "DataSource";
+var Enum = "Enum";
+var EnumField = "EnumField";
+function isEnumField(item) {
+  return reflection.isInstance(item, EnumField);
+}
+__name(isEnumField, "isEnumField");
+var FieldInitializer = "FieldInitializer";
+var FunctionDecl = "FunctionDecl";
+var FunctionParam = "FunctionParam";
+var FunctionParamType = "FunctionParamType";
+var GeneratorDecl = "GeneratorDecl";
+var InternalAttribute = "InternalAttribute";
+var InvocationExpr = "InvocationExpr";
+function isInvocationExpr(item) {
+  return reflection.isInstance(item, InvocationExpr);
+}
+__name(isInvocationExpr, "isInvocationExpr");
+var MemberAccessExpr = "MemberAccessExpr";
+function isMemberAccessExpr(item) {
+  return reflection.isInstance(item, MemberAccessExpr);
+}
+__name(isMemberAccessExpr, "isMemberAccessExpr");
+var Model = "Model";
+function isModel(item) {
+  return reflection.isInstance(item, Model);
+}
+__name(isModel, "isModel");
+var ModelImport = "ModelImport";
+var NullExpr = "NullExpr";
+var NumberLiteral = "NumberLiteral";
+var ObjectExpr = "ObjectExpr";
+function isObjectExpr(item) {
+  return reflection.isInstance(item, ObjectExpr);
+}
+__name(isObjectExpr, "isObjectExpr");
+var Plugin = "Plugin";
+var PluginField = "PluginField";
+var Procedure = "Procedure";
+var ProcedureParam = "ProcedureParam";
+var ReferenceArg = "ReferenceArg";
+var ReferenceExpr = "ReferenceExpr";
+function isReferenceExpr(item) {
+  return reflection.isInstance(item, ReferenceExpr);
+}
+__name(isReferenceExpr, "isReferenceExpr");
+var StringLiteral = "StringLiteral";
+function isStringLiteral(item) {
+  return reflection.isInstance(item, StringLiteral);
+}
+__name(isStringLiteral, "isStringLiteral");
+var ThisExpr = "ThisExpr";
+var TypeDef = "TypeDef";
+function isTypeDef(item) {
+  return reflection.isInstance(item, TypeDef);
+}
+__name(isTypeDef, "isTypeDef");
+var UnaryExpr = "UnaryExpr";
+var UnsupportedFieldType = "UnsupportedFieldType";
+var ZModelAstReflection = class extends langium.AbstractAstReflection {
+  static {
+    __name(this, "ZModelAstReflection");
+  }
+  getAllTypes() {
+    return [
+      AbstractDeclaration,
+      Argument,
+      ArrayExpr,
+      Attribute,
+      AttributeArg,
+      AttributeParam,
+      AttributeParamType,
+      BinaryExpr,
+      BooleanLiteral,
+      ConfigArrayExpr,
+      ConfigExpr,
+      ConfigField,
+      ConfigInvocationArg,
+      ConfigInvocationExpr,
+      DataField,
+      DataFieldAttribute,
+      DataFieldType,
+      DataModel,
+      DataModelAttribute,
+      DataSource,
+      Enum,
+      EnumField,
+      Expression,
+      FieldInitializer,
+      FunctionDecl,
+      FunctionParam,
+      FunctionParamType,
+      GeneratorDecl,
+      InternalAttribute,
+      InvocationExpr,
+      LiteralExpr,
+      MemberAccessExpr,
+      MemberAccessTarget,
+      Model,
+      ModelImport,
+      NullExpr,
+      NumberLiteral,
+      ObjectExpr,
+      Plugin,
+      PluginField,
+      Procedure,
+      ProcedureParam,
+      ReferenceArg,
+      ReferenceExpr,
+      ReferenceTarget,
+      StringLiteral,
+      ThisExpr,
+      TypeDeclaration,
+      TypeDef,
+      UnaryExpr,
+      UnsupportedFieldType
+    ];
+  }
+  computeIsSubtype(subtype, supertype) {
+    switch (subtype) {
+      case ArrayExpr:
+      case BinaryExpr:
+      case MemberAccessExpr:
+      case NullExpr:
+      case ObjectExpr:
+      case ReferenceExpr:
+      case ThisExpr:
+      case UnaryExpr: {
+        return this.isSubtype(Expression, supertype);
+      }
+      case Attribute:
+      case DataSource:
+      case FunctionDecl:
+      case GeneratorDecl:
+      case Plugin:
+      case Procedure: {
+        return this.isSubtype(AbstractDeclaration, supertype);
+      }
+      case BooleanLiteral:
+      case NumberLiteral:
+      case StringLiteral: {
+        return this.isSubtype(LiteralExpr, supertype);
+      }
+      case ConfigArrayExpr: {
+        return this.isSubtype(ConfigExpr, supertype);
+      }
+      case DataField: {
+        return this.isSubtype(MemberAccessTarget, supertype) || this.isSubtype(ReferenceTarget, supertype);
+      }
+      case DataModel:
+      case Enum:
+      case TypeDef: {
+        return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype);
+      }
+      case EnumField:
+      case FunctionParam: {
+        return this.isSubtype(ReferenceTarget, supertype);
+      }
+      case InvocationExpr:
+      case LiteralExpr: {
+        return this.isSubtype(ConfigExpr, supertype) || this.isSubtype(Expression, supertype);
+      }
+      default: {
+        return false;
+      }
+    }
+  }
+  getReferenceType(refInfo) {
+    const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
+    switch (referenceId) {
+      case "AttributeParamType:reference":
+      case "DataFieldType:reference":
+      case "FunctionParamType:reference": {
+        return TypeDeclaration;
+      }
+      case "DataFieldAttribute:decl":
+      case "DataModelAttribute:decl":
+      case "InternalAttribute:decl": {
+        return Attribute;
+      }
+      case "DataModel:baseModel": {
+        return DataModel;
+      }
+      case "DataModel:mixins":
+      case "TypeDef:mixins": {
+        return TypeDef;
+      }
+      case "InvocationExpr:function": {
+        return FunctionDecl;
+      }
+      case "MemberAccessExpr:member": {
+        return MemberAccessTarget;
+      }
+      case "ReferenceExpr:target": {
+        return ReferenceTarget;
+      }
+      default: {
+        throw new Error(`${referenceId} is not a valid reference id.`);
+      }
+    }
+  }
+  getTypeMetaData(type) {
+    switch (type) {
+      case Argument: {
+        return {
+          name: Argument,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ArrayExpr: {
+        return {
+          name: ArrayExpr,
+          properties: [
+            {
+              name: "items",
+              defaultValue: []
+            }
+          ]
+        };
+      }
+      case Attribute: {
+        return {
+          name: Attribute,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            },
+            {
+              name: "params",
+              defaultValue: []
+            }
+          ]
+        };
+      }
+      case AttributeArg: {
+        return {
+          name: AttributeArg,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case AttributeParam: {
+        return {
+          name: AttributeParam,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "default",
+              defaultValue: false
+            },
+            {
+              name: "name"
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case AttributeParamType: {
+        return {
+          name: AttributeParamType,
+          properties: [
+            {
+              name: "array",
+              defaultValue: false
+            },
+            {
+              name: "optional",
+              defaultValue: false
+            },
+            {
+              name: "reference"
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case BinaryExpr: {
+        return {
+          name: BinaryExpr,
+          properties: [
+            {
+              name: "left"
+            },
+            {
+              name: "operator"
+            },
+            {
+              name: "right"
+            }
+          ]
+        };
+      }
+      case BooleanLiteral: {
+        return {
+          name: BooleanLiteral,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ConfigArrayExpr: {
+        return {
+          name: ConfigArrayExpr,
+          properties: [
+            {
+              name: "items",
+              defaultValue: []
+            }
+          ]
+        };
+      }
+      case ConfigField: {
+        return {
+          name: ConfigField,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ConfigInvocationArg: {
+        return {
+          name: ConfigInvocationArg,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ConfigInvocationExpr: {
+        return {
+          name: ConfigInvocationExpr,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case DataField: {
+        return {
+          name: DataField,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case DataFieldAttribute: {
+        return {
+          name: DataFieldAttribute,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
+            },
+            {
+              name: "decl"
+            }
+          ]
+        };
+      }
+      case DataFieldType: {
+        return {
+          name: DataFieldType,
+          properties: [
+            {
+              name: "array",
+              defaultValue: false
+            },
+            {
+              name: "optional",
+              defaultValue: false
+            },
+            {
+              name: "reference"
+            },
+            {
+              name: "type"
+            },
+            {
+              name: "unsupported"
+            }
+          ]
+        };
+      }
+      case DataModel: {
+        return {
+          name: DataModel,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "baseModel"
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "isView",
+              defaultValue: false
+            },
+            {
+              name: "mixins",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case DataModelAttribute: {
+        return {
+          name: DataModelAttribute,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
+            },
+            {
+              name: "decl"
+            }
+          ]
+        };
+      }
+      case DataSource: {
+        return {
+          name: DataSource,
+          properties: [
+            {
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case Enum: {
+        return {
+          name: Enum,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case EnumField: {
+        return {
+          name: EnumField,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case FieldInitializer: {
+        return {
+          name: FieldInitializer,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case FunctionDecl: {
+        return {
+          name: FunctionDecl,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "expression"
+            },
+            {
+              name: "name"
+            },
+            {
+              name: "params",
+              defaultValue: []
+            },
+            {
+              name: "returnType"
+            }
+          ]
+        };
+      }
+      case FunctionParam: {
+        return {
+          name: FunctionParam,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "optional",
+              defaultValue: false
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case FunctionParamType: {
+        return {
+          name: FunctionParamType,
+          properties: [
+            {
+              name: "array",
+              defaultValue: false
+            },
+            {
+              name: "reference"
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case GeneratorDecl: {
+        return {
+          name: GeneratorDecl,
+          properties: [
+            {
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case InternalAttribute: {
+        return {
+          name: InternalAttribute,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
+            },
+            {
+              name: "decl"
+            }
+          ]
+        };
+      }
+      case InvocationExpr: {
+        return {
+          name: InvocationExpr,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
+            },
+            {
+              name: "function"
+            }
+          ]
+        };
+      }
+      case MemberAccessExpr: {
+        return {
+          name: MemberAccessExpr,
+          properties: [
+            {
+              name: "member"
+            },
+            {
+              name: "operand"
+            }
+          ]
+        };
+      }
+      case Model: {
+        return {
+          name: Model,
+          properties: [
+            {
+              name: "declarations",
+              defaultValue: []
+            },
+            {
+              name: "imports",
+              defaultValue: []
+            }
+          ]
+        };
+      }
+      case ModelImport: {
+        return {
+          name: ModelImport,
+          properties: [
+            {
+              name: "path"
+            }
+          ]
+        };
+      }
+      case NullExpr: {
+        return {
+          name: NullExpr,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case NumberLiteral: {
+        return {
+          name: NumberLiteral,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ObjectExpr: {
+        return {
+          name: ObjectExpr,
+          properties: [
+            {
+              name: "fields",
+              defaultValue: []
+            }
+          ]
+        };
+      }
+      case Plugin: {
+        return {
+          name: Plugin,
+          properties: [
+            {
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case PluginField: {
+        return {
+          name: PluginField,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case Procedure: {
+        return {
+          name: Procedure,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "mutation",
+              defaultValue: false
+            },
+            {
+              name: "name"
+            },
+            {
+              name: "params",
+              defaultValue: []
+            },
+            {
+              name: "returnType"
+            }
+          ]
+        };
+      }
+      case ProcedureParam: {
+        return {
+          name: ProcedureParam,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "optional",
+              defaultValue: false
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case ReferenceArg: {
+        return {
+          name: ReferenceArg,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ReferenceExpr: {
+        return {
+          name: ReferenceExpr,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
+            },
+            {
+              name: "target"
+            }
+          ]
+        };
+      }
+      case StringLiteral: {
+        return {
+          name: StringLiteral,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ThisExpr: {
+        return {
+          name: ThisExpr,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case TypeDef: {
+        return {
+          name: TypeDef,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "mixins",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case UnaryExpr: {
+        return {
+          name: UnaryExpr,
+          properties: [
+            {
+              name: "operand"
+            },
+            {
+              name: "operator"
+            }
+          ]
+        };
+      }
+      case UnsupportedFieldType: {
+        return {
+          name: UnsupportedFieldType,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      default: {
+        return {
+          name: type,
+          properties: []
+        };
+      }
+    }
+  }
+};
+var reflection = new ZModelAstReflection();
+
+// src/utils.ts
+function hasAttribute(decl, name) {
+  return !!getAttribute(decl, name);
+}
+__name(hasAttribute, "hasAttribute");
+function getAttribute(decl, name) {
+  return decl.attributes.find((attr) => attr.decl.$refText === name);
+}
+__name(getAttribute, "getAttribute");
+function isFromStdlib(node) {
+  const model = AstUtils.getContainerOfType(node, isModel);
+  return !!model && !!model.$document && model.$document.uri.path.endsWith(STD_LIB_MODULE_NAME);
+}
+__name(isFromStdlib, "isFromStdlib");
+function isAuthInvocation(node) {
+  return isInvocationExpr(node) && node.function.ref?.name === "auth" && isFromStdlib(node.function.ref);
+}
+__name(isAuthInvocation, "isAuthInvocation");
+function getStringLiteral(node) {
+  return isStringLiteral(node) ? node.value : void 0;
+}
+__name(getStringLiteral, "getStringLiteral");
+var isoDateTimeRegex = /^\d{4}(-\d\d(-\d\d(T\d\d:\d\d(:\d\d)?(\.\d+)?(([+-]\d\d:\d\d)|Z)?)?)?)?$/i;
+function typeAssignable(destType, sourceType, sourceExpr) {
+  if (destType === "DateTime" && sourceType === "String" && sourceExpr && isStringLiteral(sourceExpr)) {
+    const literal = getStringLiteral(sourceExpr);
+    if (literal && isoDateTimeRegex.test(literal)) {
+      sourceType = "DateTime";
+    }
+  }
+  switch (destType) {
+    case "Any":
+      return true;
+    case "Float":
+      return sourceType === "Any" || sourceType === "Int" || sourceType === "Float";
+    default:
+      return sourceType === "Any" || sourceType === destType;
+  }
+}
+__name(typeAssignable, "typeAssignable");
+function mapBuiltinTypeToExpressionType(type) {
+  switch (type) {
+    case "Any":
+    case "Boolean":
+    case "String":
+    case "DateTime":
+    case "Int":
+    case "Float":
+    case "Null":
+      return type;
+    case "BigInt":
+      return "Int";
+    case "Decimal":
+      return "Float";
+    case "Json":
+    case "Bytes":
+      return "Any";
+    case "Object":
+      return "Object";
+    case "Unsupported":
+      return "Unsupported";
+  }
+}
+__name(mapBuiltinTypeToExpressionType, "mapBuiltinTypeToExpressionType");
+function isAuthOrAuthMemberAccess(expr) {
+  return isAuthInvocation(expr) || isMemberAccessExpr(expr) && isAuthOrAuthMemberAccess(expr.operand);
+}
+__name(isAuthOrAuthMemberAccess, "isAuthOrAuthMemberAccess");
+function isEnumFieldReference(node) {
+  return isReferenceExpr(node) && isEnumField(node.target.ref);
+}
+__name(isEnumFieldReference, "isEnumFieldReference");
+function isDataFieldReference(node) {
+  return isReferenceExpr(node) && isDataField(node.target.ref);
+}
+__name(isDataFieldReference, "isDataFieldReference");
+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");
+}
+__name(isDelegateModel, "isDelegateModel");
+function resolved(ref) {
+  if (!ref.ref) {
+    throw new Error(`Reference not resolved: ${ref.$refText}`);
+  }
+  return ref.ref;
+}
+__name(resolved, "resolved");
+function getRecursiveBases(decl, includeDelegate = true, seen = /* @__PURE__ */ new Set()) {
+  const result = [];
+  if (seen.has(decl)) {
+    return result;
+  }
+  seen.add(decl);
+  decl.mixins.forEach((mixin) => {
+    const baseDecl = mixin.ref;
+    if (baseDecl) {
+      if (!includeDelegate && isDelegateModel(baseDecl)) {
+        return;
+      }
+      result.push(baseDecl);
+      result.push(...getRecursiveBases(baseDecl, includeDelegate, seen));
+    }
+  });
+  return result;
+}
+__name(getRecursiveBases, "getRecursiveBases");
+function getModelIdFields(model) {
+  const modelsToCheck = [
+    model,
+    ...getRecursiveBases(model)
+  ];
+  for (const modelToCheck of modelsToCheck) {
+    const allAttributes = getAllAttributes(modelToCheck);
+    const idAttr = allAttributes.find((attr) => attr.decl.$refText === "@@id");
+    if (!idAttr) {
+      continue;
+    }
+    const fieldsArg = idAttr.args.find((a) => a.$resolvedParam?.name === "fields");
+    if (!fieldsArg || !isArrayExpr(fieldsArg.value)) {
+      continue;
+    }
+    return fieldsArg.value.items.filter((item) => isReferenceExpr(item)).map((item) => resolved(item.target));
+  }
+  return [];
+}
+__name(getModelIdFields, "getModelIdFields");
+function getModelUniqueFields(model) {
+  const modelsToCheck = [
+    model,
+    ...getRecursiveBases(model)
+  ];
+  for (const modelToCheck of modelsToCheck) {
+    const allAttributes = getAllAttributes(modelToCheck);
+    const uniqueAttr = allAttributes.find((attr) => attr.decl.$refText === "@@unique");
+    if (!uniqueAttr) {
+      continue;
+    }
+    const fieldsArg = uniqueAttr.args.find((a) => a.$resolvedParam?.name === "fields");
+    if (!fieldsArg || !isArrayExpr(fieldsArg.value)) {
+      continue;
+    }
+    return fieldsArg.value.items.filter((item) => isReferenceExpr(item)).map((item) => resolved(item.target));
+  }
+  return [];
+}
+__name(getModelUniqueFields, "getModelUniqueFields");
+function getUniqueFields(model) {
+  const uniqueAttrs = model.attributes.filter((attr) => attr.decl.ref?.name === "@@unique" || attr.decl.ref?.name === "@@id");
+  return uniqueAttrs.map((uniqueAttr) => {
+    const fieldsArg = uniqueAttr.args.find((a) => a.$resolvedParam?.name === "fields");
+    if (!fieldsArg || !isArrayExpr(fieldsArg.value)) {
+      return [];
+    }
+    return fieldsArg.value.items.filter((item) => isReferenceExpr(item)).map((item) => resolved(item.target));
+  });
+}
+__name(getUniqueFields, "getUniqueFields");
+function findUpAst(node, predicate) {
+  let curr = node;
+  while (curr) {
+    if (predicate(curr)) {
+      return curr;
+    }
+    curr = curr.$container;
+  }
+  return void 0;
+}
+__name(findUpAst, "findUpAst");
+function getLiteral(expr) {
+  switch (expr?.$type) {
+    case "ObjectExpr":
+      return getObjectLiteral(expr);
+    case "StringLiteral":
+    case "BooleanLiteral":
+      return expr.value;
+    case "NumberLiteral":
+      return parseFloat(expr.value);
+    default:
+      return void 0;
+  }
+}
+__name(getLiteral, "getLiteral");
+function getObjectLiteral(expr) {
+  if (!expr || !isObjectExpr(expr)) {
+    return void 0;
+  }
+  const result = {};
+  for (const field of expr.fields) {
+    let fieldValue;
+    if (isLiteralExpr(field.value)) {
+      fieldValue = getLiteral(field.value);
+    } else if (isArrayExpr(field.value)) {
+      fieldValue = getLiteralArray(field.value);
+    } else if (isObjectExpr(field.value)) {
+      fieldValue = getObjectLiteral(field.value);
+    }
+    if (fieldValue === void 0) {
+      return void 0;
+    } else {
+      result[field.name] = fieldValue;
+    }
+  }
+  return result;
+}
+__name(getObjectLiteral, "getObjectLiteral");
+function getLiteralArray(expr) {
+  const arr = getArray(expr);
+  if (!arr) {
+    return void 0;
+  }
+  return arr.map((item) => isExpression(item) && getLiteral(item)).filter((v) => v !== void 0);
+}
+__name(getLiteralArray, "getLiteralArray");
+function getArray(expr) {
+  return isArrayExpr(expr) || isConfigArrayExpr(expr) ? expr.items : void 0;
+}
+__name(getArray, "getArray");
+function getAttributeArgLiteral(attr, name) {
+  for (const arg of attr.args) {
+    if (arg.$resolvedParam?.name === name) {
+      return getLiteral(arg.value);
+    }
+  }
+  return void 0;
+}
+__name(getAttributeArgLiteral, "getAttributeArgLiteral");
+function getFunctionExpressionContext(funcDecl) {
+  const funcAllowedContext = [];
+  const funcAttr = funcDecl.attributes.find((attr) => attr.decl.$refText === "@@@expressionContext");
+  if (funcAttr) {
+    const contextArg = funcAttr.args[0]?.value;
+    if (isArrayExpr(contextArg)) {
+      contextArg.items.forEach((item) => {
+        if (isEnumFieldReference(item)) {
+          funcAllowedContext.push(item.target.$refText);
+        }
+      });
+    }
+  }
+  return funcAllowedContext;
+}
+__name(getFunctionExpressionContext, "getFunctionExpressionContext");
+function getFieldReference(expr) {
+  if (isReferenceExpr(expr) && isDataField(expr.target.ref)) {
+    return expr.target.ref;
+  } else if (isMemberAccessExpr(expr) && isDataField(expr.member.ref)) {
+    return expr.member.ref;
+  } else {
+    return void 0;
+  }
+}
+__name(getFieldReference, "getFieldReference");
+function isCheckInvocation(node) {
+  return isInvocationExpr(node) && node.function.ref?.name === "check" && isFromStdlib(node.function.ref);
+}
+__name(isCheckInvocation, "isCheckInvocation");
+function resolveTransitiveImports(documents, model) {
+  return resolveTransitiveImportsInternal(documents, model);
+}
+__name(resolveTransitiveImports, "resolveTransitiveImports");
+function resolveTransitiveImportsInternal(documents, model, initialModel = model, visited = /* @__PURE__ */ new Set(), models = /* @__PURE__ */ new Set()) {
+  const doc = AstUtils.getDocument(model);
+  const initialDoc = AstUtils.getDocument(initialModel);
+  if (initialDoc.uri.fsPath.toLowerCase() !== doc.uri.fsPath.toLowerCase()) {
+    models.add(model);
+  }
+  const normalizedPath = doc.uri.fsPath.toLowerCase();
+  if (!visited.has(normalizedPath)) {
+    visited.add(normalizedPath);
+    for (const imp of model.imports) {
+      const importedModel = resolveImport(documents, imp);
+      if (importedModel) {
+        resolveTransitiveImportsInternal(documents, importedModel, initialModel, visited, models);
+      }
+    }
+  }
+  return Array.from(models);
+}
+__name(resolveTransitiveImportsInternal, "resolveTransitiveImportsInternal");
+function resolveImport(documents, imp) {
+  const resolvedUri = resolveImportUri(imp);
+  try {
+    if (resolvedUri) {
+      let resolvedDocument = documents.getDocument(resolvedUri);
+      if (!resolvedDocument) {
+        const content = fs.readFileSync(resolvedUri.fsPath, "utf-8");
+        resolvedDocument = documents.createDocument(resolvedUri, content);
+      }
+      const node = resolvedDocument.parseResult.value;
+      if (isModel(node)) {
+        return node;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+__name(resolveImport, "resolveImport");
+function resolveImportUri(imp) {
+  if (!imp.path) return void 0;
+  if (!imp.path.endsWith(".zmodel")) {
+    imp.path += ".zmodel";
+  }
+  if (!imp.path.startsWith(".") && // Respect relative paths
+  !path.isAbsolute(imp.path)) {
+    const contextPath = imp.$container.$document ? path.dirname(imp.$container.$document.uri.fsPath) : process.cwd();
+    imp.path = findNodeModulesFile(imp.path, contextPath) ?? imp.path;
+  }
+  const doc = AstUtils.getDocument(imp);
+  const dir = path.dirname(doc.uri.fsPath);
+  return URI.file(path.resolve(dir, imp.path));
+}
+__name(resolveImportUri, "resolveImportUri");
+function findNodeModulesFile(name, cwd = process.cwd()) {
+  if (!name) return void 0;
+  try {
+    const resolvedPath = __require.resolve(name, {
+      paths: [
+        cwd
+      ]
+    });
+    return resolvedPath;
+  } catch {
+    return void 0;
+  }
+}
+__name(findNodeModulesFile, "findNodeModulesFile");
+function getDataModelAndTypeDefs(model, includeIgnored = false) {
+  const r = model.declarations.filter((d) => isDataModel(d) || isTypeDef(d));
+  if (includeIgnored) {
+    return r;
+  } else {
+    return r.filter((model2) => !hasAttribute(model2, "@@ignore"));
+  }
+}
+__name(getDataModelAndTypeDefs, "getDataModelAndTypeDefs");
+function getAllDeclarationsIncludingImports(documents, model) {
+  const imports = resolveTransitiveImports(documents, model);
+  return model.declarations.concat(...imports.map((imp) => imp.declarations));
+}
+__name(getAllDeclarationsIncludingImports, "getAllDeclarationsIncludingImports");
+function getAuthDecl(decls) {
+  let authModel = decls.find((m) => hasAttribute(m, "@@auth"));
+  if (!authModel) {
+    authModel = decls.find((m) => m.name === "User");
+  }
+  return authModel;
+}
+__name(getAuthDecl, "getAuthDecl");
+function isFutureInvocation(node) {
+  return isInvocationExpr(node) && node.function.ref?.name === "future" && isFromStdlib(node.function.ref);
+}
+__name(isFutureInvocation, "isFutureInvocation");
+function isCollectionPredicate(node) {
+  return isBinaryExpr(node) && [
+    "?",
+    "!",
+    "^"
+  ].includes(node.operator);
+}
+__name(isCollectionPredicate, "isCollectionPredicate");
+function getAllLoadedDataModelsAndTypeDefs(langiumDocuments) {
+  return langiumDocuments.all.map((doc) => doc.parseResult.value).flatMap((model) => model.declarations.filter((d) => isDataModel(d) || isTypeDef(d))).toArray();
+}
+__name(getAllLoadedDataModelsAndTypeDefs, "getAllLoadedDataModelsAndTypeDefs");
+function getAllDataModelsIncludingImports(documents, model) {
+  return getAllDeclarationsIncludingImports(documents, model).filter(isDataModel);
+}
+__name(getAllDataModelsIncludingImports, "getAllDataModelsIncludingImports");
+function getAllLoadedAndReachableDataModelsAndTypeDefs(langiumDocuments, fromModel) {
+  const allDataModels = getAllLoadedDataModelsAndTypeDefs(langiumDocuments);
+  if (fromModel) {
+    const model = AstUtils.getContainerOfType(fromModel, isModel);
+    if (model) {
+      const transitiveDataModels = getAllDataModelsIncludingImports(langiumDocuments, model);
+      transitiveDataModels.forEach((dm) => {
+        if (!allDataModels.includes(dm)) {
+          allDataModels.push(dm);
+        }
+      });
+    }
+  }
+  return allDataModels;
+}
+__name(getAllLoadedAndReachableDataModelsAndTypeDefs, "getAllLoadedAndReachableDataModelsAndTypeDefs");
+function getContainingDataModel(node) {
+  let curr = node.$container;
+  while (curr) {
+    if (isDataModel(curr)) {
+      return curr;
+    }
+    curr = curr.$container;
+  }
+  return void 0;
+}
+__name(getContainingDataModel, "getContainingDataModel");
+function isMemberContainer(node) {
+  return isDataModel(node) || isTypeDef(node);
+}
+__name(isMemberContainer, "isMemberContainer");
+function getAllFields(decl, includeIgnored = false, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(decl)) {
+    return [];
+  }
+  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 (isDataModel(decl) && decl.baseModel) {
+    invariant(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
+    fields.push(...getAllFields(decl.baseModel.ref, includeIgnored, seen));
+  }
+  fields.push(...decl.fields.filter((f) => includeIgnored || !hasAttribute(f, "@ignore")));
+  return fields;
+}
+__name(getAllFields, "getAllFields");
+function getAllAttributes(decl, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(decl)) {
+    return [];
+  }
+  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 (isDataModel(decl) && decl.baseModel) {
+    invariant(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
+    attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+  }
+  attributes.push(...decl.attributes);
+  return attributes;
+}
+__name(getAllAttributes, "getAllAttributes");
+export {
+  findNodeModulesFile,
+  findUpAst,
+  getAllAttributes,
+  getAllDataModelsIncludingImports,
+  getAllDeclarationsIncludingImports,
+  getAllFields,
+  getAllLoadedAndReachableDataModelsAndTypeDefs,
+  getAllLoadedDataModelsAndTypeDefs,
+  getAttribute,
+  getAttributeArgLiteral,
+  getAuthDecl,
+  getContainingDataModel,
+  getDataModelAndTypeDefs,
+  getFieldReference,
+  getFunctionExpressionContext,
+  getLiteral,
+  getLiteralArray,
+  getModelIdFields,
+  getModelUniqueFields,
+  getObjectLiteral,
+  getRecursiveBases,
+  getStringLiteral,
+  getUniqueFields,
+  hasAttribute,
+  isAuthInvocation,
+  isAuthOrAuthMemberAccess,
+  isCheckInvocation,
+  isCollectionPredicate,
+  isDataFieldReference,
+  isDelegateModel,
+  isEnumFieldReference,
+  isFromStdlib,
+  isFutureExpr,
+  isFutureInvocation,
+  isMemberContainer,
+  isRelationshipField,
+  mapBuiltinTypeToExpressionType,
+  resolveImport,
+  resolveImportUri,
+  resolveTransitiveImports,
+  resolved,
+  typeAssignable
+};
+//# sourceMappingURL=utils.js.map