@zenstackhq/language 3.7.0-beta.1 → 3.7.1

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { $ as ZModelAstReflection, $t as isThisExpr, At as isFunctionParam, B as Plugin, Bt as isNullExpr, C as EnumField, Ct as isDataSource, D as FunctionParam, E as FunctionDecl, F as Model, Ft as isLiteralExpr, G as ReferenceExpr, I as ModelImport, It as isMemberAccessExpr, J as ThisExpr, Jt as isReferenceExpr, L as NullExpr, Mt as isGeneratorDecl, N as MemberAccessExpr, Nt as isInternalAttribute, O as FunctionParamType, Pt as isInvocationExpr, Qt as isStringLiteral, R as NumberLiteral, Rt as isModel, S as Enum, St as isDataModelAttribute, Tt as isEnumField, Ut as isPlugin, V as PluginField, Vt as isNumberLiteral, W as ReferenceArg, Wt as isPluginField, X as TypeDef, Z as UnaryExpr, _ as DataFieldAttribute, a as AttributeArg, at as isAttributeArg, b as DataModelAttribute, bt as isDataFieldType, c as BinaryExpr, d as ConfigArrayExpr, ft as isCollectionPredicateBinding, g as DataField, h as ConfigInvocationExpr, ht as isConfigField, i as Attribute, it as isAttribute, j as InvocationExpr, k as GeneratorDecl, kt as isFunctionDecl, l as BooleanLiteral, o as AttributeParam, p as ConfigField, pt as isConfigArrayExpr, q as StringLiteral, r as ArrayExpr, rt as isArrayExpr, s as AttributeParamType, tn as isTypeDef, tt as isAbstractDeclaration, ut as isBooleanLiteral, vt as isDataField, wt as isEnum, x as DataSource, xt as isDataModel, y as DataModel, yt as isDataFieldAttribute, z as ObjectExpr, zt as isModelImport } from "./ast-DEfhnj8j.mjs";
 import { BinaryExprOperatorPriority } from "./ast.mjs";
-import { A as isBeforeInvocation, B as mapBuiltinTypeToExpressionType, C as getPluginDocuments, D as hasAttribute, E as getUniqueFields, F as isDelegateModel, G as typeAssignable, H as resolveImportUri, I as isEnumFieldReference, J as IssueCodes, K as DB_PROVIDERS_SUPPORTING_LIST_TYPE, L as isFromStdlib, M as isCollectionPredicate, N as isComputedField, O as isAuthInvocation, P as isDataFieldReference, Q as SUPPORTED_PROVIDERS, R as isMemberContainer, T as getStringLiteral, U as resolveTransitiveImports, V as resolveImport, W as resolved, X as SCALAR_TYPES, Z as STD_LIB_MODULE_NAME, _ as getFunctionExpressionContext, a as getAllDeclarationsIncludingImports, b as getModelIdFields, f as getAuthDecl, h as getDocument, j as isCheckInvocation, k as isAuthOrAuthMemberAccess, l as getAttribute, m as getDataModelAndTypeDefs, n as findUpAst, o as getAllFields, p as getContainingDataModel, q as ExpressionContext, r as getAllAttributes, s as getAllLoadedAndReachableDataModelsAndTypeDefs, u as getAttributeArg, v as getLiteral, w as getRecursiveBases, x as getModelUniqueFields, z as isRelationshipField } from "./utils-BB6L7ug2.mjs";
+import { $ as SUPPORTED_PROVIDERS, A as isAuthOrAuthMemberAccess, B as isRelationshipField, D as getUniqueFields, E as getStringLiteral, F as isDataFieldReference, G as resolved, H as resolveImport, I as isDelegateModel, J as ExpressionContext, K as typeAssignable, L as isEnumFieldReference, M as isCheckInvocation, N as isCollectionPredicate, O as hasAttribute, P as isComputedField, Q as STD_LIB_MODULE_NAME, R as isFromStdlib, S as getModelUniqueFields, T as getRecursiveBases, U as resolveImportUri, V as mapBuiltinTypeToExpressionType, W as resolveTransitiveImports, Y as IssueCodes, Z as SCALAR_TYPES, a as getAllDeclarationsIncludingImports, f as getAuthDecl, g as getDocument, h as getDataSourceProvider, j as isBeforeInvocation, k as isAuthInvocation, l as getAttribute, m as getDataModelAndTypeDefs, n as findUpAst, o as getAllFields, p as getContainingDataModel, q as DB_PROVIDERS_SUPPORTING_LIST_TYPE, r as getAllAttributes, s as getAllLoadedAndReachableDataModelsAndTypeDefs, u as getAttributeArg, v as getFunctionExpressionContext, w as getPluginDocuments, x as getModelIdFields, y as getLiteral, z as isMemberContainer } from "./utils-CCU55PfR.mjs";
 import { createRequire } from "node:module";
 import { invariant } from "@zenstackhq/common-helpers";
 import { AstUtils, Cancellation, DefaultCommentProvider, DefaultDocumentBuilder, DefaultLinker, DefaultScopeComputation, DefaultScopeProvider, DefaultWorkspaceManager, DocumentState, EMPTY_SCOPE, JSDocDocumentationProvider, StreamScope, TextDocument, URI, UriUtils, inject, interruptAndCheck, isAstNode, loadGrammarFromJson } from "langium";
@@ -4317,6 +4317,18 @@ var AttributeApplicationValidator = class {
 			});
 		} else accept("error", `Expected an array of field references`, { node: fields });
 	}
+	_checkFuzzy(attr, accept) {
+		const zmodel = AstUtils.getContainerOfType(attr, isModel);
+		if (!zmodel) return;
+		const provider = getDataSourceProvider(zmodel);
+		if (provider && provider !== "postgresql") accept("error", `\`@fuzzy\` is only supported for the \`postgresql\` provider`, { node: attr });
+	}
+	_checkFullText(attr, accept) {
+		const zmodel = AstUtils.getContainerOfType(attr, isModel);
+		if (!zmodel) return;
+		const provider = getDataSourceProvider(zmodel);
+		if (provider && provider !== "postgresql") accept("error", `\`@fullText\` is only supported for the \`postgresql\` provider`, { node: attr });
+	}
 	_checkSchema(attr, accept) {
 		const schemaName = getStringLiteral(attr.args[0]?.value);
 		invariant(schemaName, `@@schema expects a string literal`);
@@ -4370,6 +4382,18 @@ __decorate([
 	__decorateMetadata("design:paramtypes", [Object, Object]),
 	__decorateMetadata("design:returntype", void 0)
 ], AttributeApplicationValidator.prototype, "_checkConstraint", null);
+__decorate([
+	check("@fuzzy"),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Object, Object]),
+	__decorateMetadata("design:returntype", void 0)
+], AttributeApplicationValidator.prototype, "_checkFuzzy", null);
+__decorate([
+	check("@fullText"),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Object, Object]),
+	__decorateMetadata("design:returntype", void 0)
+], AttributeApplicationValidator.prototype, "_checkFullText", null);
 __decorate([
 	check("@@schema"),
 	__decorateMetadata("design:type", Function),
@@ -4553,6 +4577,7 @@ var DataModelValidator = class {
 		this.validateFields(dm, accept);
 		if (dm.mixins.length > 0) this.validateMixins(dm, accept);
 		this.validateInherits(dm, accept);
+		this.validateDelegateMap(dm, accept);
 	}
 	validateFields(dm, accept) {
 		const allFields = getAllFields(dm);
@@ -4783,6 +4808,57 @@ var DataModelValidator = class {
 			todo.push(...current.mixins.map((mixin) => mixin.ref));
 		}
 	}
+	validateDelegateMap(dm, accept) {
+		const delegateMapAttrs = dm.attributes.filter((attr) => attr.decl.$refText === "@@delegateMap");
+		if (delegateMapAttrs.length > 1) accept("error", "Model can include at most one @@delegateMap attribute", { node: delegateMapAttrs[1] });
+		const delegateMapAttr = delegateMapAttrs[0];
+		if (delegateMapAttr) {
+			if (!dm.baseModel) accept("error", "`@@delegateMap` can only be used on models that extend a delegate base model", { node: delegateMapAttr });
+			else if (dm.baseModel.ref) this.validateDelegateMapValue(dm.baseModel.ref, delegateMapAttr, accept);
+		}
+		if (!hasAttribute(dm, "@@delegate")) return;
+		const subModels = dm.$container.declarations.filter(isDataModel).filter((model) => model.baseModel?.ref === dm);
+		if (subModels.length === 0) return;
+		const seen = /* @__PURE__ */ new Map();
+		subModels.forEach((model) => {
+			const value = this.getDelegateMapRawValue(model) ?? model.name;
+			const existing = seen.get(value);
+			if (existing) accept("error", `Duplicate @@delegateMap value "${value}" on models "${existing.name}" and "${model.name}"`, { node: model });
+			else seen.set(value, model);
+		});
+	}
+	getDelegateMapRawValue(dm) {
+		const valueExpr = dm.attributes.find((attr) => attr.decl.$refText === "@@delegateMap")?.args[0]?.value;
+		if (!valueExpr) return;
+		if (isStringLiteral(valueExpr)) return valueExpr.value;
+		if (isEnumFieldReference(valueExpr)) return valueExpr.target.ref?.name;
+	}
+	validateDelegateMapValue(baseModel, attr, accept) {
+		const delegateMapValueExpr = attr.args[0]?.value;
+		if (!delegateMapValueExpr) {
+			accept("error", "`@@delegateMap` expects a value", { node: attr });
+			return;
+		}
+		const delegateAttr = getAttribute(baseModel, "@@delegate");
+		const discriminatorArg = delegateAttr && getAttributeArg(delegateAttr, "discriminator");
+		const discriminatorRef = discriminatorArg && isReferenceExpr(discriminatorArg) ? discriminatorArg.target.ref : void 0;
+		if (!discriminatorRef || !isDataField(discriminatorRef)) return;
+		const discriminatorType = discriminatorRef.type;
+		const discriminatorEnum = discriminatorType.reference?.ref;
+		if (isEnumFieldReference(delegateMapValueExpr)) {
+			if (!isEnum(discriminatorEnum)) {
+				accept("error", "`@@delegateMap` enum value cannot be used when the discriminator field is String", { node: delegateMapValueExpr });
+				return;
+			}
+			if (delegateMapValueExpr.target.ref?.$container !== discriminatorEnum) accept("error", "`@@delegateMap` enum value must come from the discriminator enum type", { node: delegateMapValueExpr });
+			return;
+		}
+		if (isStringLiteral(delegateMapValueExpr)) {
+			if (discriminatorType.type !== "String") accept("error", "`@@delegateMap` string value must match a String discriminator field", { node: delegateMapValueExpr });
+			return;
+		}
+		accept("error", "`@@delegateMap` expects a string literal or enum value", { node: delegateMapValueExpr });
+	}
 };
 //#endregion
 //#region src/validators/datasource-validator.ts
@@ -6912,13 +6988,6 @@ async function formatDocument(content) {
 	});
 	return TextDocument.applyEdits(document.textDocument, edits);
 }
-function getDataSourceProvider(model) {
-	const dataSource = model.declarations.find(isDataSource);
-	if (!dataSource) return;
-	const provider = dataSource?.fields.find((f) => f.name === "provider");
-	if (!provider) return;
-	return getLiteral(provider.value);
-}
 //#endregion
 export { ZModelCodeGenerator, ZModelLanguageMetaData, ZModelLanguageModule, ZModelSharedModule, createZModelLanguageServices, createZModelServices, formatDocument, loadDocument };