@zenstackhq/language 3.0.0-beta.7 → 3.0.0-beta.9

package/dist/index.cjs

@@ -5223,10 +5223,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");
 }
@@ -5244,8 +5240,14 @@ function getRecursiveBases(decl, includeDelegate = true, seen = /* @__PURE__ */
     return result;
   }
   seen.add(decl);
-  decl.mixins.forEach((mixin) => {
-    const baseDecl = decl.$container.declarations.find((d) => isTypeDef(d) && d.name === mixin.$refText);
+  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;
@@ -5462,10 +5464,10 @@ function getAuthDecl(decls) {
   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" && isFromStdlib(node.function.ref);
 }
-__name(isFutureInvocation, "isFutureInvocation");
+__name(isBeforeInvocation, "isBeforeInvocation");
 function isCollectionPredicate(node) {
   return isBinaryExpr(node) && [
     "?",
@@ -5697,12 +5699,21 @@ var AttributeApplicationValidator = class {
       "create",
       "read",
       "update",
+      "post-update",
       "delete",
       "all"
     ], 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 = import_langium3.AstUtils.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 = import_langium3.AstUtils.getContainerOfType(expr, isDataModel);
@@ -5757,8 +5768,8 @@ var AttributeApplicationValidator = class {
       "all"
     ], attr, accept);
     const expr = attr.args[1]?.value;
-    if (expr && import_langium3.AstUtils.streamAst(expr).some((node) => isFutureExpr(node))) {
-      accept("error", `"future()" is not allowed in field-level policy rules`, {
+    if (expr && import_langium3.AstUtils.streamAst(expr).some((node) => isBeforeInvocation(node))) {
+      accept("error", `"before()" is not allowed in field-level policy rules`, {
         node: expr
       });
     }
@@ -5879,6 +5890,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;
     }
   }
@@ -5970,6 +5985,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;
     }
@@ -6519,11 +6537,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": {
@@ -6738,7 +6766,7 @@ var FunctionInvocationValidator = class {
         }
         curr = curr.$container;
       }
-      const exprContext = (0, import_ts_pattern.match)(containerAttribute?.decl.$refText).with("@default", () => ExpressionContext.DefaultValue).with(import_ts_pattern.P.union("@@allow", "@@deny", "@allow", "@deny"), () => ExpressionContext.AccessPolicy).with("@@validate", () => ExpressionContext.ValidationRule).with("@@index", () => ExpressionContext.Index).otherwise(() => void 0);
+      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}`, {
@@ -6770,6 +6798,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 (0, import_ts_pattern.match)(containerAttribute?.decl.$refText).with("@default", () => ExpressionContext.DefaultValue).with(import_ts_pattern.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++) {
@@ -6830,6 +6870,43 @@ 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;
@@ -6902,6 +6979,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),
@@ -7046,18 +7141,26 @@ var ZModelDocumentBuilder = class extends import_langium7.DefaultDocumentBuilder
   static {
     __name(this, "ZModelDocumentBuilder");
   }
-  buildDocuments(documents, options, cancelToken) {
-    return super.buildDocuments(documents, {
-      ...options,
-      validation: (
-        // force overriding validation options
-        options.validation === false || options.validation === void 0 ? options.validation : {
-          stopAfterLexingErrors: true,
-          stopAfterParsingErrors: true,
-          stopAfterLinkingErrors: true
-        }
-      )
-    }, cancelToken);
+  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
+    };
   }
 };
 
@@ -7084,21 +7187,19 @@ var ZModelLinker = class extends import_langium8.DefaultLinker {
     }
     document.state = import_langium8.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;
     }
-    const reference = container[property];
-    this.doLink({
-      reference,
-      container,
-      property
-    }, document);
+    if (this.resolveFromScopeProviders(refInfo.reference, document, extraScopes)) {
+      return;
+    }
+    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) {
@@ -7227,7 +7328,11 @@ var ZModelLinker = class extends import_langium8.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;
@@ -7240,7 +7345,7 @@ var ZModelLinker = class extends import_langium8.DefaultLinker {
             nullable: true
           };
         }
-      } else if (isFutureExpr(node)) {
+      } else if (isBeforeInvocation(node)) {
         node.$resolvedType = {
           decl: getContainingDataModel(node)
         };
@@ -7304,7 +7409,7 @@ var ZModelLinker = class extends import_langium8.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) {
@@ -7318,7 +7423,7 @@ var ZModelLinker = class extends import_langium8.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) {
@@ -7370,13 +7475,9 @@ var ZModelLinker = class extends import_langium8.DefaultLinker {
     this.resolveDefault(node, document, scopes);
   }
   resolveDefault(node, document, extraScopes) {
-    for (const [property, value] of Object.entries(node)) {
-      if (!property.startsWith("$")) {
-        if ((0, import_langium8.isReference)(value)) {
-          this.linkReference(node, property, document, extraScopes);
-        }
-      }
-    }
+    import_langium8.AstUtils.streamReferences(node).forEach((ref) => {
+      this.linkReference(ref, document, extraScopes);
+    });
     for (const child of import_langium8.AstUtils.streamContents(node)) {
       this.resolve(child, document, extraScopes);
     }
@@ -7446,7 +7547,7 @@ var ZModelScopeComputation = class extends import_langium9.DefaultScopeComputati
   }
   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) {
@@ -7517,7 +7618,7 @@ var ZModelScopeProvider = class extends import_langium9.DefaultScopeProvider {
       if (isAuthInvocation(operand)) {
         return this.createScopeForAuth(node, globalScope);
       }
-      if (isFutureInvocation(operand)) {
+      if (isBeforeInvocation(operand)) {
         return this.createScopeForContainingModel(node, globalScope);
       }
       return import_langium9.EMPTY_SCOPE;
@@ -7749,7 +7850,7 @@ var DocumentLoadError = class extends Error {
     super(message);
   }
 };
-async function loadDocument(fileName, pluginModelFiles = []) {
+async function loadDocument(fileName, additionalModelFiles = []) {
   const { ZModelLanguage: services } = createZModelServices();
   const extensions = services.LanguageMetaData.fileExtensions;
   if (!extensions.includes(import_node_path2.default.extname(fileName))) {
@@ -7772,7 +7873,7 @@ async function loadDocument(fileName, pluginModelFiles = []) {
   }
   const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path2.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
   const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium12.URI.file(import_node_path2.default.resolve(import_node_path2.default.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
-  const pluginDocs = await Promise.all(pluginModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium12.URI.file(import_node_path2.default.resolve(file)))));
+  const pluginDocs = await Promise.all(additionalModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium12.URI.file(import_node_path2.default.resolve(file)))));
   const langiumDocuments = services.shared.workspace.LangiumDocuments;
   const document = await langiumDocuments.getOrCreateDocument(import_langium12.URI.file(import_node_path2.default.resolve(fileName)));
   const importedURIs = await loadImports(document, langiumDocuments);
@@ -7786,7 +7887,11 @@ async function loadDocument(fileName, pluginModelFiles = []) {
     document,
     ...importedDocuments
   ], {
-    validation: true
+    validation: {
+      stopAfterLexingErrors: true,
+      stopAfterParsingErrors: true,
+      stopAfterLinkingErrors: true
+    }
   });
   const diagnostics = langiumDocuments.all.flatMap((doc) => (doc.diagnostics ?? []).map((diag) => ({
     doc,