@zenstackhq/language 3.7.0-beta.1 → 3.7.1

package/dist/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_ast = require("./ast-Clidp86c.cjs");
 const require_ast$1 = require("./ast.cjs");
-const require_utils = require("./utils-CfXGZkv7.cjs");
+const require_utils = require("./utils-b3dJKmYr.cjs");
 let _zenstackhq_common_helpers = require("@zenstackhq/common-helpers");
 let langium = require("langium");
 let node_fs = require("node:fs");
@@ -4317,6 +4317,18 @@ var AttributeApplicationValidator = class {
 			});
 		} else accept("error", `Expected an array of field references`, { node: fields });
 	}
+	_checkFuzzy(attr, accept) {
+		const zmodel = langium.AstUtils.getContainerOfType(attr, require_ast.isModel);
+		if (!zmodel) return;
+		const provider = require_utils.getDataSourceProvider(zmodel);
+		if (provider && provider !== "postgresql") accept("error", `\`@fuzzy\` is only supported for the \`postgresql\` provider`, { node: attr });
+	}
+	_checkFullText(attr, accept) {
+		const zmodel = langium.AstUtils.getContainerOfType(attr, require_ast.isModel);
+		if (!zmodel) return;
+		const provider = require_utils.getDataSourceProvider(zmodel);
+		if (provider && provider !== "postgresql") accept("error", `\`@fullText\` is only supported for the \`postgresql\` provider`, { node: attr });
+	}
 	_checkSchema(attr, accept) {
 		const schemaName = require_utils.getStringLiteral(attr.args[0]?.value);
 		(0, _zenstackhq_common_helpers.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 = require_utils.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 (!require_utils.hasAttribute(dm, "@@delegate")) return;
+		const subModels = dm.$container.declarations.filter(require_ast.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 (require_ast.isStringLiteral(valueExpr)) return valueExpr.value;
+		if (require_utils.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 = require_utils.getAttribute(baseModel, "@@delegate");
+		const discriminatorArg = delegateAttr && require_utils.getAttributeArg(delegateAttr, "discriminator");
+		const discriminatorRef = discriminatorArg && require_ast.isReferenceExpr(discriminatorArg) ? discriminatorArg.target.ref : void 0;
+		if (!discriminatorRef || !require_ast.isDataField(discriminatorRef)) return;
+		const discriminatorType = discriminatorRef.type;
+		const discriminatorEnum = discriminatorType.reference?.ref;
+		if (require_utils.isEnumFieldReference(delegateMapValueExpr)) {
+			if (!require_ast.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 (require_ast.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
@@ -6884,7 +6960,7 @@ function validationAfterImportMerge(model) {
 	if (dataSources.length === 0) errors.push("Validation error: schema must have a datasource declaration");
 	else if (dataSources.length > 1) errors.push("Validation error: multiple datasource declarations are not allowed");
 	if (require_utils.getDataModelAndTypeDefs(model, true).filter((d) => require_utils.hasAttribute(d, "@@auth")).length > 1) errors.push("Validation error: Multiple `@@auth` declarations are not allowed");
-	const provider = getDataSourceProvider(model);
+	const provider = require_utils.getDataSourceProvider(model);
 	(0, _zenstackhq_common_helpers.invariant)(provider !== void 0, "Datasource provider should be defined at this point");
 	for (const decl of model.declarations.filter(require_ast.isDataModel)) {
 		const fields = require_utils.getAllFields(decl, true);
@@ -6912,13 +6988,6 @@ async function formatDocument(content) {
 	});
 	return langium.TextDocument.applyEdits(document.textDocument, edits);
 }
-function getDataSourceProvider(model) {
-	const dataSource = model.declarations.find(require_ast.isDataSource);
-	if (!dataSource) return;
-	const provider = dataSource?.fields.find((f) => f.name === "provider");
-	if (!provider) return;
-	return require_utils.getLiteral(provider.value);
-}
 //#endregion
 exports.ZModelCodeGenerator = ZModelCodeGenerator;
 exports.ZModelLanguageMetaData = ZModelLanguageMetaData;