@zenstackhq/plugin-policy 3.5.2 → 3.5.4

package/dist/index.cjs

@@ -78,6 +78,10 @@ var ExpressionEvaluator = class {
   evaluateCall(expr2, context) {
     if (expr2.function === "auth") {
       return context.auth;
+    } else if (expr2.function === "currentModel") {
+      return context.thisType;
+    } else if (expr2.function === "currentOperation") {
+      return context.operation;
     } else {
       throw new Error(`Unsupported call expression function: ${expr2.function}`);
     }
@@ -421,7 +425,10 @@ var ExpressionTransformer = class {
     } else if (this.isNullNode(left)) {
       return this.transformNullCheck(right, expr2.op);
     } else {
-      return import_kysely2.BinaryOperationNode.create(left, this.transformOperator(op), right);
+      const leftFieldDef = this.getFieldDefFromFieldRef(normalizedLeft, context);
+      const rightFieldDef = this.getFieldDefFromFieldRef(normalizedRight, context);
+      const sqlOp = op === "==" ? "=" : op;
+      return this.dialect.buildComparison(new import_kysely2.ExpressionWrapper(left), leftFieldDef, sqlOp, new import_kysely2.ExpressionWrapper(right), rightFieldDef).toOperationNode();
     }
   }
   transformNullCheck(expr2, operator) {
@@ -447,17 +454,17 @@ var ExpressionTransformer = class {
       };
     }
     let normalizedLeft = expr2.left;
-    if (this.isRelationField(expr2.left, context.modelOrType)) {
+    if (this.isRelationField(expr2.left, context)) {
       (0, import_common_helpers2.invariant)(import_schema3.ExpressionUtils.isNull(expr2.right), "only null comparison is supported for relation field");
-      const leftRelDef = this.getFieldDefFromFieldRef(expr2.left, context.modelOrType);
+      const leftRelDef = this.getFieldDefFromFieldRef(expr2.left, context);
       (0, import_common_helpers2.invariant)(leftRelDef, "failed to get relation field definition");
       const idFields = import_orm3.QueryUtils.requireIdFields(this.schema, leftRelDef.type);
       normalizedLeft = this.makeOrAppendMember(normalizedLeft, idFields[0]);
     }
     let normalizedRight = expr2.right;
-    if (this.isRelationField(expr2.right, context.modelOrType)) {
+    if (this.isRelationField(expr2.right, context)) {
       (0, import_common_helpers2.invariant)(import_schema3.ExpressionUtils.isNull(expr2.left), "only null comparison is supported for relation field");
-      const rightRelDef = this.getFieldDefFromFieldRef(expr2.right, context.modelOrType);
+      const rightRelDef = this.getFieldDefFromFieldRef(expr2.right, context);
       (0, import_common_helpers2.invariant)(rightRelDef, "failed to get relation field definition");
       const idFields = import_orm3.QueryUtils.requireIdFields(this.schema, rightRelDef.type);
       normalizedRight = this.makeOrAppendMember(normalizedRight, idFields[0]);
@@ -475,7 +482,9 @@ var ExpressionTransformer = class {
       const receiver = evaluator.evaluate(expr2.left, {
         thisValue: context.contextValue,
         auth: this.auth,
-        bindingScope: this.getEvaluationBindingScope(context.bindingScope)
+        bindingScope: this.getEvaluationBindingScope(context.bindingScope),
+        operation: context.operation,
+        thisType: context.thisType
       });
       const baseType = this.isAuthMember(expr2.left) ? this.authType : context.modelOrType;
       const memberType = this.getMemberType(baseType, expr2.left);
@@ -486,7 +495,7 @@ var ExpressionTransformer = class {
     }
     (0, import_common_helpers2.invariant)(import_schema3.ExpressionUtils.isField(expr2.left) || import_schema3.ExpressionUtils.isMember(expr2.left), "left operand must be field or member access");
     let newContextModel;
-    const fieldDef = this.getFieldDefFromFieldRef(expr2.left, context.modelOrType);
+    const fieldDef = this.getFieldDefFromFieldRef(expr2.left, context);
     if (fieldDef) {
       (0, import_common_helpers2.invariant)(fieldDef.relation, `field is not a relation: ${JSON.stringify(expr2.left)}`);
       newContextModel = fieldDef.type;
@@ -543,7 +552,9 @@ var ExpressionTransformer = class {
       const value = new ExpressionEvaluator().evaluate(expr2, {
         auth: this.auth,
         thisValue: context.contextValue,
-        bindingScope: this.getEvaluationBindingScope(context.bindingScope)
+        bindingScope: this.getEvaluationBindingScope(context.bindingScope),
+        operation: context.operation,
+        thisType: context.thisType
       });
       return this.transformValue(value, "Boolean");
     } else {
@@ -646,10 +657,6 @@ var ExpressionTransformer = class {
     (0, import_common_helpers2.invariant)(expr2.op === "!", 'only "!" operator is supported');
     return logicalNot(this.dialect, this.transform(expr2.operand, context));
   }
-  transformOperator(op) {
-    const mappedOp = (0, import_ts_pattern2.match)(op).with("==", () => "=").otherwise(() => op);
-    return import_kysely2.OperatorNode.create(mappedOp);
-  }
   _call(expr2, context) {
     const result = this.transformCall(expr2, context);
     return result.toOperationNode();
@@ -920,15 +927,26 @@ var ExpressionTransformer = class {
       return conditions.reduce((acc, condition) => import_schema3.ExpressionUtils.binary(acc, "&&", condition));
     }
   }
-  isRelationField(expr2, model) {
-    const fieldDef = this.getFieldDefFromFieldRef(expr2, model);
+  isRelationField(expr2, context) {
+    const fieldDef = this.getFieldDefFromFieldRef(expr2, context);
     return !!fieldDef?.relation;
   }
-  getFieldDefFromFieldRef(expr2, model) {
+  getFieldDefFromFieldRef(expr2, context) {
+    const model = import_schema3.ExpressionUtils.isMember(expr2) && import_schema3.ExpressionUtils.isThis(expr2.receiver) ? context.thisType : context.modelOrType;
     if (import_schema3.ExpressionUtils.isField(expr2)) {
       return import_orm3.QueryUtils.getField(this.schema, model, expr2.field);
     } else if (import_schema3.ExpressionUtils.isMember(expr2) && expr2.members.length === 1 && import_schema3.ExpressionUtils.isThis(expr2.receiver)) {
       return import_orm3.QueryUtils.getField(this.schema, model, expr2.members[0]);
+    } else if (import_schema3.ExpressionUtils.isMember(expr2) && import_schema3.ExpressionUtils.isField(expr2.receiver)) {
+      const receiverDef = import_orm3.QueryUtils.getField(this.schema, model, expr2.receiver.field);
+      if (!receiverDef?.relation) return void 0;
+      let currModel = receiverDef.type;
+      for (let i = 0; i < expr2.members.length - 1; i++) {
+        const hopDef = import_orm3.QueryUtils.getField(this.schema, currModel, expr2.members[i]);
+        if (!hopDef?.relation) return void 0;
+        currModel = hopDef.type;
+      }
+      return import_orm3.QueryUtils.getField(this.schema, currModel, expr2.members[expr2.members.length - 1]);
     } else {
       return void 0;
     }