@zenstackhq/language 3.2.0 → 3.2.1

package/dist/index.js

@@ -5772,8 +5772,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;
@@ -6072,37 +6073,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 +6161,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 +6186,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 +6259,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 {