@zenstackhq/language 3.5.6 → 3.6.0

package/dist/utils-CfXGZkv7.cjs

@@ -0,0 +1,842 @@
+const require_ast = require("./ast-Clidp86c.cjs");
+let langium = require("langium");
+let node_fs = require("node:fs");
+node_fs = require_ast.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_ast.__toESM(node_path, 1);
+let node_url = require("node:url");
+let node_module = require("node:module");
+//#region src/constants.ts
+/**
+* Supported db providers
+*/
+const SUPPORTED_PROVIDERS = [
+	"sqlite",
+	"postgresql",
+	"mysql"
+];
+/**
+* All scalar types
+*/
+const SCALAR_TYPES = [
+	"String",
+	"Int",
+	"Float",
+	"Decimal",
+	"BigInt",
+	"Boolean",
+	"Bytes",
+	"DateTime"
+];
+/**
+* Name of standard library module
+*/
+const STD_LIB_MODULE_NAME = "stdlib.zmodel";
+/**
+* Name of module contributed by plugins
+*/
+const PLUGIN_MODULE_NAME = "plugin.zmodel";
+/**
+* Validation issues
+*/
+let IssueCodes = /* @__PURE__ */ function(IssueCodes) {
+	IssueCodes["MissingOppositeRelation"] = "miss-opposite-relation";
+	return IssueCodes;
+}({});
+/**
+* Expression context
+*/
+let ExpressionContext = /* @__PURE__ */ function(ExpressionContext) {
+	ExpressionContext["DefaultValue"] = "DefaultValue";
+	ExpressionContext["AccessPolicy"] = "AccessPolicy";
+	ExpressionContext["ValidationRule"] = "ValidationRule";
+	ExpressionContext["Index"] = "Index";
+	return ExpressionContext;
+}({});
+/**
+* Database providers that support list field types.
+*/
+const DB_PROVIDERS_SUPPORTING_LIST_TYPE = ["postgresql"];
+//#endregion
+//#region src/utils.ts
+function hasAttribute(decl, name) {
+	return !!getAttribute(decl, name);
+}
+function getAttribute(decl, name) {
+	return decl.attributes.find((attr) => attr.decl.$refText === name);
+}
+function isFromStdlib(node) {
+	const model = langium.AstUtils.getContainerOfType(node, require_ast.isModel);
+	return !!model && !!model.$document && model.$document.uri.path.endsWith("stdlib.zmodel");
+}
+function isAuthInvocation(node) {
+	return require_ast.isInvocationExpr(node) && node.function.ref?.name === "auth" && isFromStdlib(node.function.ref);
+}
+/**
+* Try getting string value from a potential string literal expression
+*/
+function getStringLiteral(node) {
+	return require_ast.isStringLiteral(node) ? node.value : void 0;
+}
+const isoDateTimeRegex = /^\d{4}(-\d\d(-\d\d(T\d\d:\d\d(:\d\d)?(\.\d+)?(([+-]\d\d:\d\d)|Z)?)?)?)?$/i;
+/**
+* Determines if the given sourceType is assignable to a destination of destType
+*/
+function typeAssignable(destType, sourceType, sourceExpr) {
+	if (destType === "DateTime" && sourceType === "String" && sourceExpr && require_ast.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;
+	}
+}
+/**
+* Maps a ZModel builtin type to expression type
+*/
+function mapBuiltinTypeToExpressionType(type) {
+	switch (type) {
+		case "Any":
+		case "Boolean":
+		case "String":
+		case "DateTime":
+		case "Int":
+		case "Float":
+		case "Null":
+		case "Object":
+		case "Unsupported":
+		case "Void":
+		case "Undefined": return type;
+		case "BigInt": return "Int";
+		case "Decimal": return "Float";
+		case "Json":
+		case "Bytes": return "Any";
+	}
+}
+/**
+* Determines if the given expression is an invocation of `auth` or a member access on the result of an `auth` invocation (e.g. `auth().role`).
+*/
+function isAuthOrAuthMemberAccess(expr) {
+	return isAuthInvocation(expr) || require_ast.isMemberAccessExpr(expr) && isAuthOrAuthMemberAccess(expr.operand);
+}
+/**
+* Determines if the given expression is a reference to an enum field.
+*/
+function isEnumFieldReference(node) {
+	return require_ast.isReferenceExpr(node) && require_ast.isEnumField(node.target.ref);
+}
+/**
+* Determines if the given expression is a reference to a data field.
+*/
+function isDataFieldReference(node) {
+	return require_ast.isReferenceExpr(node) && require_ast.isDataField(node.target.ref);
+}
+/**
+* Returns if the given field is a relation field.
+*/
+function isRelationshipField(field) {
+	return require_ast.isDataModel(field.type.reference?.ref);
+}
+/**
+* Returns if the given field is a computed field.
+*/
+function isComputedField(field) {
+	return hasAttribute(field, "@computed");
+}
+/**
+* Determines if the given data model is a delegate model (i.e. marked with `@@delegate` attribute).
+*/
+function isDelegateModel(node) {
+	return require_ast.isDataModel(node) && hasAttribute(node, "@@delegate");
+}
+/**
+* Resolves the given reference and returns the target AST node. Throws an error if the reference is not resolved.
+*/
+function resolved(ref) {
+	if (!ref.ref) throw new Error(`Reference not resolved: ${ref.$refText}`);
+	return ref.ref;
+}
+/**
+* Gets all base models and mixins of a data model or type def, recursively.
+*/
+function getRecursiveBases(decl, includeDelegate = true, documents, seen = /* @__PURE__ */ new Set()) {
+	const result = [];
+	if (seen.has(decl)) return result;
+	seen.add(decl);
+	[...decl.mixins, ...require_ast.isDataModel(decl) && decl.baseModel ? [decl.baseModel] : []].forEach((base) => {
+		let baseDecl;
+		if (base.ref && (require_ast.isTypeDef(base.ref) || require_ast.isDataModel(base.ref))) baseDecl = base.ref;
+		else baseDecl = (documents ? getAllDeclarationsIncludingImports(documents, decl.$container) : decl.$container.declarations).find((d) => (require_ast.isTypeDef(d) || require_ast.isDataModel(d)) && d.name === base.$refText);
+		if (baseDecl) {
+			if (!includeDelegate && isDelegateModel(baseDecl)) return;
+			result.push(baseDecl);
+			result.push(...getRecursiveBases(baseDecl, includeDelegate, documents, seen));
+		}
+	});
+	return result;
+}
+/**
+* Gets `@@id` fields declared at the data model level (including search in base models)
+*/
+function getModelIdFields(model) {
+	const modelsToCheck = [model, ...getRecursiveBases(model)];
+	for (const modelToCheck of modelsToCheck) {
+		const idAttr = getAllAttributes(modelToCheck).find((attr) => attr.decl.$refText === "@@id");
+		if (!idAttr) continue;
+		const fieldsArg = idAttr.args.find((a) => a.$resolvedParam?.name === "fields");
+		if (!fieldsArg || !require_ast.isArrayExpr(fieldsArg.value)) continue;
+		return fieldsArg.value.items.filter((item) => require_ast.isReferenceExpr(item)).map((item) => resolved(item.target));
+	}
+	return [];
+}
+/**
+* Gets `@@unique` fields declared at the data model level (including search in base models)
+*/
+function getModelUniqueFields(model) {
+	const modelsToCheck = [model, ...getRecursiveBases(model)];
+	for (const modelToCheck of modelsToCheck) {
+		const uniqueAttr = getAllAttributes(modelToCheck).find((attr) => attr.decl.$refText === "@@unique");
+		if (!uniqueAttr) continue;
+		const fieldsArg = uniqueAttr.args.find((a) => a.$resolvedParam?.name === "fields");
+		if (!fieldsArg || !require_ast.isArrayExpr(fieldsArg.value)) continue;
+		return fieldsArg.value.items.filter((item) => require_ast.isReferenceExpr(item)).map((item) => resolved(item.target));
+	}
+	return [];
+}
+/**
+* Gets lists of unique fields declared at the data model level
+*
+* TODO: merge this with {@link getModelUniqueFields}
+*/
+function getUniqueFields(model) {
+	return model.attributes.filter((attr) => attr.decl.ref?.name === "@@unique" || attr.decl.ref?.name === "@@id").map((uniqueAttr) => {
+		const fieldsArg = uniqueAttr.args.find((a) => a.$resolvedParam?.name === "fields");
+		if (!fieldsArg || !require_ast.isArrayExpr(fieldsArg.value)) return [];
+		return fieldsArg.value.items.filter((item) => require_ast.isReferenceExpr(item)).map((item) => resolved(item.target));
+	});
+}
+/**
+* Finds the first ancestor of the given AST node that satisfies the given predicate function. Returns `undefined` if no such ancestor is found.
+*/
+function findUpAst(node, predicate) {
+	let curr = node;
+	while (curr) {
+		if (predicate(curr)) return curr;
+		curr = curr.$container;
+	}
+}
+/**
+* Tries to get the literal value from the given expression. Returns `undefined` if the expression is not a literal or if the literal value cannot be determined.
+*/
+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;
+	}
+}
+/**
+* Tries to get an object literal from the given expression. Returns `undefined` if the expression is not an object literal or if any of the field values cannot be determined.
+*/
+function getObjectLiteral(expr) {
+	if (!expr || !require_ast.isObjectExpr(expr)) return;
+	const result = {};
+	for (const field of expr.fields) {
+		let fieldValue;
+		if (require_ast.isLiteralExpr(field.value)) fieldValue = getLiteral(field.value);
+		else if (require_ast.isArrayExpr(field.value)) fieldValue = getLiteralArray(field.value);
+		else if (require_ast.isObjectExpr(field.value)) fieldValue = getObjectLiteral(field.value);
+		if (fieldValue === void 0) return;
+		else result[field.name] = fieldValue;
+	}
+	return result;
+}
+function getLiteralArray(expr) {
+	const arr = getArray(expr);
+	if (!arr) return;
+	return arr.map((item) => require_ast.isExpression(item) && getLiteral(item)).filter((v) => v !== void 0);
+}
+function getArray(expr) {
+	return require_ast.isArrayExpr(expr) || require_ast.isConfigArrayExpr(expr) ? expr.items : void 0;
+}
+/**
+* Gets the value of the argument with the given name from the given attribute. Returns `undefined` if no such argument is found or if the argument value cannot be determined.
+*/
+function getAttributeArg(attr, name) {
+	return attr.args.find((arg) => arg.$resolvedParam?.name === name)?.value;
+}
+/**
+* Gets the literal value of the argument with the given name from the given attribute. Returns `undefined` if no such argument is found or if the argument value cannot be determined or is not a literal.
+*/
+function getAttributeArgLiteral(attr, name) {
+	for (const arg of attr.args) if (arg.$resolvedParam?.name === name) return getLiteral(arg.value);
+}
+/**
+* Gets the allowed expression contexts for the given function declaration by looking for `@@expressionContext` attribute.
+* Returns an empty array if no such attribute is found or if the attribute value cannot be determined.
+*/
+function getFunctionExpressionContext(funcDecl) {
+	const funcAllowedContext = [];
+	const funcAttr = funcDecl.attributes.find((attr) => attr.decl.$refText === "@@@expressionContext");
+	if (funcAttr) {
+		const contextArg = funcAttr.args[0]?.value;
+		if (require_ast.isArrayExpr(contextArg)) contextArg.items.forEach((item) => {
+			if (isEnumFieldReference(item)) funcAllowedContext.push(item.target.$refText);
+		});
+	}
+	return funcAllowedContext;
+}
+/**
+* Gets the data field referenced by the given expression, if any. Returns `undefined` if the expression is not a reference to a data field.
+*/
+function getFieldReference(expr) {
+	if (require_ast.isReferenceExpr(expr) && require_ast.isDataField(expr.target.ref)) return expr.target.ref;
+	else if (require_ast.isMemberAccessExpr(expr) && require_ast.isDataField(expr.member.ref)) return expr.member.ref;
+	else return;
+}
+function isCheckInvocation(node) {
+	return require_ast.isInvocationExpr(node) && node.function.ref?.name === "check";
+}
+/**
+* Resolves the transitive imports of the given model and returns the list of imported models. The given model itself is not included in the result.
+*/
+function resolveTransitiveImports(documents, model) {
+	return resolveTransitiveImportsInternal(documents, model);
+}
+function resolveTransitiveImportsInternal(documents, model, initialModel = model, visited = /* @__PURE__ */ new Set(), models = /* @__PURE__ */ new Set()) {
+	const doc = langium.AstUtils.getDocument(model);
+	if (langium.AstUtils.getDocument(initialModel).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);
+}
+/**
+* Resolves the given import and returns the imported model. Returns `undefined`
+* if the import cannot be resolved.
+*/
+function resolveImport(documents, imp) {
+	const resolvedUri = resolveImportUri(imp);
+	try {
+		if (resolvedUri) {
+			let resolvedDocument = documents.getDocument(resolvedUri);
+			if (!resolvedDocument) {
+				const content = node_fs.default.readFileSync(resolvedUri.fsPath, "utf-8");
+				resolvedDocument = documents.createDocument(resolvedUri, content);
+			}
+			const node = resolvedDocument.parseResult.value;
+			if (require_ast.isModel(node)) return node;
+		}
+	} catch {}
+}
+/**
+* Resolves the given import and returns the URI of the imported model.
+* Returns `undefined` if the import cannot be resolved.
+*/
+function resolveImportUri(imp) {
+	if (!imp.path) return;
+	const doc = langium.AstUtils.getDocument(imp);
+	const dir = node_path.default.dirname(doc.uri.fsPath);
+	const importPath = imp.path.endsWith(".zmodel") ? imp.path : `${imp.path}.zmodel`;
+	return langium.URI.file(node_path.default.resolve(dir, importPath));
+}
+/**
+* Gets data models and type defs in the ZModel schema.
+*/
+function getDataModelAndTypeDefs(model, includeIgnored = false) {
+	const r = model.declarations.filter((d) => require_ast.isDataModel(d) || require_ast.isTypeDef(d));
+	if (includeIgnored) return r;
+	else return r.filter((model) => !hasAttribute(model, "@@ignore"));
+}
+/**
+* Gets all declarations of the given model and its transitive imports.
+*/
+function getAllDeclarationsIncludingImports(documents, model) {
+	const imports = resolveTransitiveImports(documents, model);
+	return model.declarations.concat(...imports.map((imp) => imp.declarations));
+}
+/**
+* Gets the model used for auth context, by looking for a model with `@@auth` attribute or a model named `User`.
+* Returns `undefined` if no such model is found.
+*/
+function getAuthDecl(decls) {
+	let authModel = decls.find((d) => hasAttribute(d, "@@auth"));
+	if (!authModel) authModel = decls.find((d) => d.name === "User");
+	return authModel;
+}
+function isBeforeInvocation(node) {
+	return require_ast.isInvocationExpr(node) && node.function.ref?.name === "before";
+}
+/**
+* Determines if the given AST node is a collection predicate.
+*/
+function isCollectionPredicate(node) {
+	return require_ast.isBinaryExpr(node) && [
+		"?",
+		"!",
+		"^"
+	].includes(node.operator);
+}
+/**
+* Gets all data models and type defs from the given documents registry.
+*/
+function getAllLoadedDataModelsAndTypeDefs(langiumDocuments) {
+	return langiumDocuments.all.map((doc) => doc.parseResult.value).flatMap((model) => model.declarations.filter((d) => require_ast.isDataModel(d) || require_ast.isTypeDef(d))).toArray();
+}
+/**
+* Gets all data models from the given documents registry and the transitive imports of the given model.
+*/
+function getAllDataModelsIncludingImports(documents, model) {
+	return getAllDeclarationsIncludingImports(documents, model).filter(require_ast.isDataModel);
+}
+/**
+* Gets all data models and type defs from the given documents registry and the transitive imports
+* of the given model. If `fromModel` is not provided, returns all loaded data models and type defs.
+*/
+function getAllLoadedAndReachableDataModelsAndTypeDefs(langiumDocuments, fromModel) {
+	const allDataModels = getAllLoadedDataModelsAndTypeDefs(langiumDocuments);
+	if (fromModel) {
+		const model = langium.AstUtils.getContainerOfType(fromModel, require_ast.isModel);
+		if (model) getAllDataModelsIncludingImports(langiumDocuments, model).forEach((dm) => {
+			if (!allDataModels.includes(dm)) allDataModels.push(dm);
+		});
+	}
+	return allDataModels;
+}
+/**
+* Gets the containing data model of the given AST node, if any.
+* Returns `undefined` if the node is not contained in a data model.
+*/
+function getContainingDataModel(node) {
+	let curr = node.$container;
+	while (curr) {
+		if (require_ast.isDataModel(curr)) return curr;
+		curr = curr.$container;
+	}
+}
+/**
+* Determines if the given AST node can contain members.
+*/
+function isMemberContainer(node) {
+	return require_ast.isDataModel(node) || require_ast.isTypeDef(node);
+}
+/**
+* Gets all fields of a data model or type def, including inherited fields from base models and mixins.
+*/
+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) if (mixin.ref) fields.push(...getAllFields(mixin.ref, includeIgnored, seen));
+	if (require_ast.isDataModel(decl) && decl.baseModel) {
+		if (decl.baseModel.ref) fields.push(...getAllFields(decl.baseModel.ref, includeIgnored, seen));
+	}
+	fields.push(...decl.fields.filter((f) => includeIgnored || !hasAttribute(f, "@ignore")));
+	return fields;
+}
+/**
+* Gets all attributes of a data model or type def, including inherited attributes
+* from base models and mixins.
+*/
+function getAllAttributes(decl, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(decl)) return [];
+	seen.add(decl);
+	const attributes = [];
+	for (const mixin of decl.mixins) if (mixin.ref) attributes.push(...getAllAttributes(mixin.ref, seen));
+	if (require_ast.isDataModel(decl) && decl.baseModel) {
+		if (decl.baseModel.ref) {
+			const attrs = getAllAttributes(decl.baseModel.ref, seen).filter((attr) => !isNonInheritableAttribute(attr));
+			attributes.push(...attrs);
+		}
+	}
+	attributes.push(...decl.attributes);
+	return attributes;
+}
+function isNonInheritableAttribute(attr) {
+	const attrName = attr.decl.ref?.name ?? attr.decl.$refText;
+	return [
+		"@@map",
+		"@@unique",
+		"@@index"
+	].includes(attrName);
+}
+/**
+* Retrieve the document in which the given AST node is contained. A reference to the document is
+* usually held by the root node of the AST.
+*
+* @throws an error if the node is not contained in a document.
+*/
+function getDocument(node) {
+	const result = findRootNode(node).$document;
+	if (!result) throw new Error("AST node has no document.");
+	return result;
+}
+/**
+* Gets the list of plugin documents from the given model.
+*/
+function getPluginDocuments(model, schemaPath) {
+	const result = [];
+	for (const decl of model.declarations.filter(require_ast.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 = node_path.default.resolve(node_path.default.dirname(schemaPath), provider);
+		if (node_fs.default.existsSync(providerPath)) {
+			if (node_fs.default.statSync(providerPath).isDirectory()) providerPath = node_path.default.join(providerPath, "index.js");
+			pluginModelFile = node_path.default.resolve(node_path.default.dirname(providerPath), PLUGIN_MODULE_NAME);
+			if (!node_fs.default.existsSync(pluginModelFile)) pluginModelFile = findUp([PLUGIN_MODULE_NAME], node_path.default.dirname(providerPath));
+		}
+		if (!pluginModelFile) {
+			if (typeof {}.resolve === "function") try {
+				pluginModelFile = (0, node_url.fileURLToPath)({}.resolve(`${provider}/${PLUGIN_MODULE_NAME}`));
+			} catch {}
+		}
+		if (!pluginModelFile) try {
+			pluginModelFile = (0, node_module.createRequire)((0, node_url.pathToFileURL)(schemaPath)).resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+		} catch {}
+		if (pluginModelFile && node_fs.default.existsSync(pluginModelFile)) result.push(pluginModelFile);
+	}
+	return result;
+}
+function findUp(names, cwd = process.cwd(), multiple = false, result = []) {
+	if (!names.some((name) => !!name)) return;
+	const target = names.find((name) => node_fs.default.existsSync(node_path.default.join(cwd, name)));
+	if (multiple === false && target) return node_path.default.join(cwd, target);
+	if (target) result.push(node_path.default.join(cwd, target));
+	const up = node_path.default.resolve(cwd, "..");
+	if (up === cwd) return multiple && result.length > 0 ? result : void 0;
+	return findUp(names, up, multiple, result);
+}
+/**
+* Returns the root node of the given AST node by following the `$container` references.
+*/
+function findRootNode(node) {
+	while (node.$container) node = node.$container;
+	return node;
+}
+//#endregion
+Object.defineProperty(exports, "DB_PROVIDERS_SUPPORTING_LIST_TYPE", {
+	enumerable: true,
+	get: function() {
+		return DB_PROVIDERS_SUPPORTING_LIST_TYPE;
+	}
+});
+Object.defineProperty(exports, "ExpressionContext", {
+	enumerable: true,
+	get: function() {
+		return ExpressionContext;
+	}
+});
+Object.defineProperty(exports, "IssueCodes", {
+	enumerable: true,
+	get: function() {
+		return IssueCodes;
+	}
+});
+Object.defineProperty(exports, "PLUGIN_MODULE_NAME", {
+	enumerable: true,
+	get: function() {
+		return PLUGIN_MODULE_NAME;
+	}
+});
+Object.defineProperty(exports, "SCALAR_TYPES", {
+	enumerable: true,
+	get: function() {
+		return SCALAR_TYPES;
+	}
+});
+Object.defineProperty(exports, "STD_LIB_MODULE_NAME", {
+	enumerable: true,
+	get: function() {
+		return STD_LIB_MODULE_NAME;
+	}
+});
+Object.defineProperty(exports, "SUPPORTED_PROVIDERS", {
+	enumerable: true,
+	get: function() {
+		return SUPPORTED_PROVIDERS;
+	}
+});
+Object.defineProperty(exports, "findRootNode", {
+	enumerable: true,
+	get: function() {
+		return findRootNode;
+	}
+});
+Object.defineProperty(exports, "findUpAst", {
+	enumerable: true,
+	get: function() {
+		return findUpAst;
+	}
+});
+Object.defineProperty(exports, "getAllAttributes", {
+	enumerable: true,
+	get: function() {
+		return getAllAttributes;
+	}
+});
+Object.defineProperty(exports, "getAllDataModelsIncludingImports", {
+	enumerable: true,
+	get: function() {
+		return getAllDataModelsIncludingImports;
+	}
+});
+Object.defineProperty(exports, "getAllDeclarationsIncludingImports", {
+	enumerable: true,
+	get: function() {
+		return getAllDeclarationsIncludingImports;
+	}
+});
+Object.defineProperty(exports, "getAllFields", {
+	enumerable: true,
+	get: function() {
+		return getAllFields;
+	}
+});
+Object.defineProperty(exports, "getAllLoadedAndReachableDataModelsAndTypeDefs", {
+	enumerable: true,
+	get: function() {
+		return getAllLoadedAndReachableDataModelsAndTypeDefs;
+	}
+});
+Object.defineProperty(exports, "getAllLoadedDataModelsAndTypeDefs", {
+	enumerable: true,
+	get: function() {
+		return getAllLoadedDataModelsAndTypeDefs;
+	}
+});
+Object.defineProperty(exports, "getAttribute", {
+	enumerable: true,
+	get: function() {
+		return getAttribute;
+	}
+});
+Object.defineProperty(exports, "getAttributeArg", {
+	enumerable: true,
+	get: function() {
+		return getAttributeArg;
+	}
+});
+Object.defineProperty(exports, "getAttributeArgLiteral", {
+	enumerable: true,
+	get: function() {
+		return getAttributeArgLiteral;
+	}
+});
+Object.defineProperty(exports, "getAuthDecl", {
+	enumerable: true,
+	get: function() {
+		return getAuthDecl;
+	}
+});
+Object.defineProperty(exports, "getContainingDataModel", {
+	enumerable: true,
+	get: function() {
+		return getContainingDataModel;
+	}
+});
+Object.defineProperty(exports, "getDataModelAndTypeDefs", {
+	enumerable: true,
+	get: function() {
+		return getDataModelAndTypeDefs;
+	}
+});
+Object.defineProperty(exports, "getDocument", {
+	enumerable: true,
+	get: function() {
+		return getDocument;
+	}
+});
+Object.defineProperty(exports, "getFieldReference", {
+	enumerable: true,
+	get: function() {
+		return getFieldReference;
+	}
+});
+Object.defineProperty(exports, "getFunctionExpressionContext", {
+	enumerable: true,
+	get: function() {
+		return getFunctionExpressionContext;
+	}
+});
+Object.defineProperty(exports, "getLiteral", {
+	enumerable: true,
+	get: function() {
+		return getLiteral;
+	}
+});
+Object.defineProperty(exports, "getLiteralArray", {
+	enumerable: true,
+	get: function() {
+		return getLiteralArray;
+	}
+});
+Object.defineProperty(exports, "getModelIdFields", {
+	enumerable: true,
+	get: function() {
+		return getModelIdFields;
+	}
+});
+Object.defineProperty(exports, "getModelUniqueFields", {
+	enumerable: true,
+	get: function() {
+		return getModelUniqueFields;
+	}
+});
+Object.defineProperty(exports, "getObjectLiteral", {
+	enumerable: true,
+	get: function() {
+		return getObjectLiteral;
+	}
+});
+Object.defineProperty(exports, "getPluginDocuments", {
+	enumerable: true,
+	get: function() {
+		return getPluginDocuments;
+	}
+});
+Object.defineProperty(exports, "getRecursiveBases", {
+	enumerable: true,
+	get: function() {
+		return getRecursiveBases;
+	}
+});
+Object.defineProperty(exports, "getStringLiteral", {
+	enumerable: true,
+	get: function() {
+		return getStringLiteral;
+	}
+});
+Object.defineProperty(exports, "getUniqueFields", {
+	enumerable: true,
+	get: function() {
+		return getUniqueFields;
+	}
+});
+Object.defineProperty(exports, "hasAttribute", {
+	enumerable: true,
+	get: function() {
+		return hasAttribute;
+	}
+});
+Object.defineProperty(exports, "isAuthInvocation", {
+	enumerable: true,
+	get: function() {
+		return isAuthInvocation;
+	}
+});
+Object.defineProperty(exports, "isAuthOrAuthMemberAccess", {
+	enumerable: true,
+	get: function() {
+		return isAuthOrAuthMemberAccess;
+	}
+});
+Object.defineProperty(exports, "isBeforeInvocation", {
+	enumerable: true,
+	get: function() {
+		return isBeforeInvocation;
+	}
+});
+Object.defineProperty(exports, "isCheckInvocation", {
+	enumerable: true,
+	get: function() {
+		return isCheckInvocation;
+	}
+});
+Object.defineProperty(exports, "isCollectionPredicate", {
+	enumerable: true,
+	get: function() {
+		return isCollectionPredicate;
+	}
+});
+Object.defineProperty(exports, "isComputedField", {
+	enumerable: true,
+	get: function() {
+		return isComputedField;
+	}
+});
+Object.defineProperty(exports, "isDataFieldReference", {
+	enumerable: true,
+	get: function() {
+		return isDataFieldReference;
+	}
+});
+Object.defineProperty(exports, "isDelegateModel", {
+	enumerable: true,
+	get: function() {
+		return isDelegateModel;
+	}
+});
+Object.defineProperty(exports, "isEnumFieldReference", {
+	enumerable: true,
+	get: function() {
+		return isEnumFieldReference;
+	}
+});
+Object.defineProperty(exports, "isFromStdlib", {
+	enumerable: true,
+	get: function() {
+		return isFromStdlib;
+	}
+});
+Object.defineProperty(exports, "isMemberContainer", {
+	enumerable: true,
+	get: function() {
+		return isMemberContainer;
+	}
+});
+Object.defineProperty(exports, "isRelationshipField", {
+	enumerable: true,
+	get: function() {
+		return isRelationshipField;
+	}
+});
+Object.defineProperty(exports, "mapBuiltinTypeToExpressionType", {
+	enumerable: true,
+	get: function() {
+		return mapBuiltinTypeToExpressionType;
+	}
+});
+Object.defineProperty(exports, "resolveImport", {
+	enumerable: true,
+	get: function() {
+		return resolveImport;
+	}
+});
+Object.defineProperty(exports, "resolveImportUri", {
+	enumerable: true,
+	get: function() {
+		return resolveImportUri;
+	}
+});
+Object.defineProperty(exports, "resolveTransitiveImports", {
+	enumerable: true,
+	get: function() {
+		return resolveTransitiveImports;
+	}
+});
+Object.defineProperty(exports, "resolved", {
+	enumerable: true,
+	get: function() {
+		return resolved;
+	}
+});
+Object.defineProperty(exports, "typeAssignable", {
+	enumerable: true,
+	get: function() {
+		return typeAssignable;
+	}
+});
+
+//# sourceMappingURL=utils-CfXGZkv7.cjs.map