@zenstackhq/language 3.1.1 → 3.2.1

package/dist/index.cjs

@@ -4057,7 +4057,8 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
             "terminal": {
               "$type": "Keyword",
               "value": "mutation"
-            }
+            },
+            "cardinality": "?"
           },
           {
             "$type": "Keyword",
@@ -4108,7 +4109,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
                     "terminal": {
                       "$type": "RuleCall",
                       "rule": {
-                        "$ref": "#/rules@47"
+                        "$ref": "#/rules@49"
                       },
                       "arguments": []
                     }
@@ -4286,6 +4287,10 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
             "$type": "Keyword",
             "value": "Any"
           },
+          {
+            "$type": "Keyword",
+            "value": "Void"
+          },
           {
             "$type": "Keyword",
             "value": "Unsupported"
@@ -4896,10 +4901,26 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
             "$type": "Keyword",
             "value": "Boolean"
           },
+          {
+            "$type": "Keyword",
+            "value": "BigInt"
+          },
+          {
+            "$type": "Keyword",
+            "value": "Decimal"
+          },
           {
             "$type": "Keyword",
             "value": "DateTime"
           },
+          {
+            "$type": "Keyword",
+            "value": "Json"
+          },
+          {
+            "$type": "Keyword",
+            "value": "Bytes"
+          },
           {
             "$type": "Keyword",
             "value": "Null"
@@ -4912,6 +4933,14 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
             "$type": "Keyword",
             "value": "Any"
           },
+          {
+            "$type": "Keyword",
+            "value": "Void"
+          },
+          {
+            "$type": "Keyword",
+            "value": "Undefined"
+          },
           {
             "$type": "Keyword",
             "value": "Unsupported"
@@ -5248,6 +5277,10 @@ function mapBuiltinTypeToExpressionType(type) {
     case "Int":
     case "Float":
     case "Null":
+    case "Object":
+    case "Unsupported":
+    case "Void":
+    case "Undefined":
       return type;
     case "BigInt":
       return "Int";
@@ -5256,10 +5289,6 @@ function mapBuiltinTypeToExpressionType(type) {
     case "Json":
     case "Bytes":
       return "Any";
-    case "Object":
-      return "Object";
-    case "Unsupported":
-      return "Unsupported";
   }
 }
 __name(mapBuiltinTypeToExpressionType, "mapBuiltinTypeToExpressionType");
@@ -5279,6 +5308,10 @@ function isRelationshipField(field) {
   return isDataModel(field.type.reference?.ref);
 }
 __name(isRelationshipField, "isRelationshipField");
+function isComputedField(field) {
+  return hasAttribute(field, "@computed");
+}
+__name(isComputedField, "isComputedField");
 function isDelegateModel(node) {
   return isDataModel(node) && hasAttribute(node, "@@delegate");
 }
@@ -5775,8 +5808,9 @@ var AttributeApplicationValidator = class {
           return;
         }
       }
-      if (!assignableToAttributeParam(arg, paramDecl, attr)) {
-        accept("error", `Value is not assignable to parameter`, {
+      const argAssignable = assignableToAttributeParam(arg, paramDecl, attr);
+      if (!argAssignable.result) {
+        accept("error", argAssignable.error, {
           node: arg
         });
         return;
@@ -5900,24 +5934,27 @@ var AttributeApplicationValidator = class {
       });
       return;
     }
-    const kindItems = this.validatePolicyKinds(kind, [
+    this.validatePolicyKinds(kind, [
       "read",
       "update",
       "all"
     ], attr, accept);
     const expr = attr.args[1]?.value;
     if (expr && import_langium3.AstUtils.streamAst(expr).some((node) => isBeforeInvocation(node))) {
-      accept("error", `"before()" is not allowed in field-level policy rules`, {
+      accept("error", `"before()" is not allowed in field-level policies`, {
         node: expr
       });
     }
-    if (kindItems.includes("update") || kindItems.includes("all")) {
-      const field = attr.$container;
-      if (isRelationshipField(field)) {
-        accept("error", `Field-level policy rules with "update" or "all" kind are not allowed for relation fields. Put rules on foreign-key fields instead.`, {
-          node: attr
-        });
-      }
+    const field = attr.$container;
+    if (isRelationshipField(field)) {
+      accept("error", `Field-level policies are not allowed for relation fields.`, {
+        node: attr
+      });
+    }
+    if (isComputedField(field)) {
+      accept("error", `Field-level policies are not allowed for computed fields.`, {
+        node: attr
+      });
     }
   }
   _checkValidate(attr, accept) {
@@ -6072,37 +6109,86 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], AttributeApplicationValidator.prototype, "_checkSchema", null);
 function assignableToAttributeParam(arg, param, attr) {
+  const genericError = {
+    result: false,
+    error: "invalid argument type"
+  };
+  const success = {
+    result: true
+  };
   const argResolvedType = arg.$resolvedType;
   if (!argResolvedType) {
-    return false;
+    return {
+      result: false,
+      error: "unable to resolve argument type"
+    };
   }
   let dstType = param.type.type;
   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";
+      const dstIsJson = attr.$container.type.type === "Json" || hasAttribute(attr.$container, "@json");
+      if (dstIsJson && attr.decl.ref?.name === "@default") {
+        if (attr.$container.type.array && attr.$container.type.type === "Json") {
+          if (isArrayExpr(arg.value) && arg.value.items.every((item) => isLiteralJsonString(item))) {
+            return success;
+          } else {
+            return {
+              result: false,
+              error: "expected an array of JSON string literals"
+            };
+          }
+        } else {
+          if (isLiteralJsonString(arg.value)) {
+            return success;
+          } else {
+            return {
+              result: false,
+              error: "expected a JSON string literal"
+            };
+          }
+        }
       }
       dstIsArray = attr.$container.type.array;
     }
   }
   const dstRef = param.type.reference;
   if (dstType === "Any" && !dstIsArray) {
-    return true;
+    return success;
   }
   if (argResolvedType.decl === "Any") {
     if (!argResolvedType.array) {
-      return true;
+      return success;
     } else {
-      return argResolvedType.array === dstIsArray;
+      if (argResolvedType.array === dstIsArray) {
+        return success;
+      } else {
+        return {
+          result: false,
+          error: `expected ${dstIsArray ? "array" : "non-array"}`
+        };
+      }
     }
   }
   if (dstType === "FieldReference" || dstType === "TransitiveFieldReference") {
     if (dstIsArray) {
-      return isArrayExpr(arg.value) && !arg.value.items.find((item) => !isReferenceExpr(item) || !isDataField(item.target.ref));
+      if (isArrayExpr(arg.value) && !arg.value.items.some((item) => !isReferenceExpr(item) || !isDataField(item.target.ref))) {
+        return success;
+      } else {
+        return {
+          result: false,
+          error: "expected an array of field references"
+        };
+      }
     } else {
-      return isReferenceExpr(arg.value) && isDataField(arg.value.target.ref);
+      if (isReferenceExpr(arg.value) && isDataField(arg.value.target.ref)) {
+        return success;
+      } else {
+        return {
+          result: false,
+          error: "expected a field reference"
+        };
+      }
     }
   }
   if (isEnum(argResolvedType.decl)) {
@@ -6111,15 +6197,24 @@ function assignableToAttributeParam(arg, param, attr) {
       attrArgDeclType = resolved(attr.$container.type.reference);
       dstIsArray = attr.$container.type.array;
     }
-    return attrArgDeclType === argResolvedType.decl && dstIsArray === argResolvedType.array;
+    if (attrArgDeclType !== argResolvedType.decl) {
+      return genericError;
+    }
+    if (dstIsArray !== argResolvedType.array) {
+      return {
+        result: false,
+        error: `expected ${dstIsArray ? "array" : "non-array"}`
+      };
+    }
+    return success;
   } else if (dstType) {
     if (typeof argResolvedType?.decl !== "string") {
-      return false;
+      return genericError;
     }
     if (dstType === "ContextType") {
       if (isDataField(attr.$container)) {
         if (!attr.$container?.type?.type) {
-          return false;
+          return genericError;
         }
         dstType = mapBuiltinTypeToExpressionType(attr.$container.type.type);
         dstIsArray = attr.$container.type.array;
@@ -6127,9 +6222,17 @@ function assignableToAttributeParam(arg, param, attr) {
         dstType = "Any";
       }
     }
-    return typeAssignable(dstType, argResolvedType.decl, arg.value) && dstIsArray === argResolvedType.array;
+    if (typeAssignable(dstType, argResolvedType.decl, arg.value) && dstIsArray === argResolvedType.array) {
+      return success;
+    } else {
+      return genericError;
+    }
   } else {
-    return (dstRef?.ref === argResolvedType.decl || dstType === "Any") && dstIsArray === argResolvedType.array;
+    if ((dstRef?.ref === argResolvedType.decl || dstType === "Any") && dstIsArray === argResolvedType.array) {
+      return success;
+    } else {
+      return genericError;
+    }
   }
 }
 __name(assignableToAttributeParam, "assignableToAttributeParam");
@@ -6192,6 +6295,18 @@ function validateAttributeApplication(attr, accept, contextDataModel) {
   new AttributeApplicationValidator().validate(attr, accept, contextDataModel);
 }
 __name(validateAttributeApplication, "validateAttributeApplication");
+function isLiteralJsonString(value) {
+  if (!isStringLiteral(value)) {
+    return false;
+  }
+  try {
+    JSON.parse(value.value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isLiteralJsonString, "isLiteralJsonString");
 
 // src/validators/attribute-validator.ts
 var AttributeValidator = class {
@@ -6213,7 +6328,7 @@ function validateDuplicatedDeclarations(container, decls, accept) {
     group[decl.name] = group[decl.name] ?? [];
     group[decl.name].push(decl);
     return group;
-  }, {});
+  }, /* @__PURE__ */ Object.create(null));
   for (const [name, decls2] of Object.entries(groupByName)) {
     if (decls2.length > 1) {
       let errorField = decls2[1];
@@ -7096,7 +7211,9 @@ var FunctionInvocationValidator = class {
       return true;
     }
     if (typeof argResolvedType.decl === "string") {
-      if (!typeAssignable(dstType, argResolvedType.decl, arg.value) || dstIsArray !== argResolvedType.array) {
+      const dstScalarType = mapBuiltinTypeToExpressionType(dstType);
+      const srcScalarType = mapBuiltinTypeToExpressionType(argResolvedType.decl);
+      if (!typeAssignable(dstScalarType, srcScalarType, arg.value) || dstIsArray !== argResolvedType.array) {
         accept("error", `argument is not assignable to parameter`, {
           node: arg
         });
@@ -7325,6 +7442,30 @@ _ts_decorate2([
   _ts_metadata2("design:returntype", void 0)
 ], FunctionInvocationValidator.prototype, "_checkCheck", null);
 
+// src/validators/procedure-validator.ts
+var RESERVED_PROCEDURE_NAMES = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+var ProcedureValidator = class {
+  static {
+    __name(this, "ProcedureValidator");
+  }
+  validate(proc, accept) {
+    this.validateName(proc, accept);
+    proc.attributes.forEach((attr) => validateAttributeApplication(attr, accept));
+  }
+  validateName(proc, accept) {
+    if (RESERVED_PROCEDURE_NAMES.has(proc.name)) {
+      accept("error", `Procedure name "${proc.name}" is reserved`, {
+        node: proc,
+        property: "name"
+      });
+    }
+  }
+};
+
 // src/validators/schema-validator.ts
 var SchemaValidator = class {
   static {
@@ -7412,7 +7553,8 @@ function registerValidationChecks(services) {
     Attribute: validator.checkAttribute,
     Expression: validator.checkExpression,
     InvocationExpr: validator.checkFunctionInvocation,
-    FunctionDecl: validator.checkFunctionDecl
+    FunctionDecl: validator.checkFunctionDecl,
+    Procedure: validator.checkProcedure
   };
   registry.register(checks, validator);
 }
@@ -7457,6 +7599,9 @@ var ZModelValidator = class {
   checkFunctionDecl(node, accept) {
     new FunctionDeclValidator().validate(node, accept);
   }
+  checkProcedure(node, accept) {
+    new ProcedureValidator().validate(node, accept);
+  }
 };
 
 // src/zmodel-comment-provider.ts