fix tests

Author: Azzerty23

packages/schema/src/language-server/validator/attribute-application-validator.ts

@@ -270,16 +270,6 @@ function assignableToAttributeParam(arg: AttributeArg, param: AttributeParam, at
     let dstType = param.type.type;
     let dstIsArray = param.type.array;
 
-    if (isAliasDecl(arg.$resolvedType?.decl)) {
-        if (dstType === 'ContextType') {
-            // TODO: what is context type? Passed to true to avoid error, to be fixed later
-            return true;
-        }
-        const aliasExpression = arg.$resolvedType.decl.expression;
-        const mappedType = mappedRawExpressionTypeToResolvedShape(aliasExpression.$type);
-        return dstType === mappedType;
-    }
-
     if (dstType === 'ContextType') {
         // ContextType is inferred from the attribute's container's type
         if (isDataModelField(attr.$container)) {
@@ -310,6 +300,16 @@ function assignableToAttributeParam(arg: AttributeArg, param: AttributeParam, at
         }
     }
 
+    // alias expression is compared to corresponding expression resolved shape
+    if (isAliasDecl(arg.$resolvedType?.decl)) {
+        // TODO: what is context type? Passed to true to avoid error, to be fixed later
+        if (dstType === 'ContextType') return true;
+
+        const alias = arg.$resolvedType.decl;
+        const mappedAliasResolvedType = mappedRawExpressionTypeToResolvedShape(alias.expression.$type);
+        return dstType === mappedAliasResolvedType || dstType === 'Any' || mappedAliasResolvedType === 'Any';
+    }
+
     // destination is field reference or transitive field reference, check if
     // argument is reference or array or reference
     if (dstType === 'FieldReference' || dstType === 'TransitiveFieldReference') {

tests/integration/tests/plugins/policy.test.ts

@@ -111,7 +111,7 @@ model M {
         ).toEqual(expect.objectContaining({ AND: [{ AND: [] }, { value: { gt: 10 } }] }));
     });
 
-    it('alias expressions', async () => {
+    it('simple alias expressions', async () => {
         const { policy } = await loadSchema(
             `
             alias allowAll() {
@@ -171,4 +171,54 @@ model M {
             )
         ).toEqual({ AND: [{ authorId: { equals: 'u2' } }, { published: true }] });
     });
+
+    it('complex alias expressions', async () => {
+        const model = `
+        alias currentUserId() {
+            auth().id
+        }
+
+        alias complexAlias() {
+            auth().cart.tasks?[id == 123] && value >10 && currentUserId() != null
+        }
+
+         model User {
+            id Int @id @default(autoincrement())
+            cart Cart?
+          }
+          
+          model Cart {
+            id Int @id @default(autoincrement())
+            tasks Task[]
+            user User @relation(fields: [userId], references: [id])
+            userId Int @unique
+          }
+          
+          model Task {
+            id Int @id @default(autoincrement())
+            cart Cart @relation(fields: [cartId], references: [id])
+            cartId Int
+            value Int
+            @@allow('read', complexAlias())
+          }
+                `;
+
+        const { policy } = await loadSchema(model, {
+            compile: false,
+            generateNoCompile: true,
+            output: 'out/',
+        });
+
+        expect(
+            (policy.policy.task.modelLevel.read.guard as Function)({ user: { cart: { tasks: [{ id: 1 }] } } })
+        ).toEqual(
+            expect.objectContaining({
+                AND: [{ AND: [{ OR: [] }, { value: { gt: 10 } }] }, { OR: [] }],
+            })
+        );
+
+        expect(
+            (policy.policy.task.modelLevel.read.guard as Function)({ user: { cart: { tasks: [{ id: 123 }] } } })
+        ).toEqual(expect.objectContaining({ AND: [{ AND: [{ AND: [] }, { value: { gt: 10 } }] }, { OR: [] }] }));
+    });
 });