zenstack 1.0.0-alpha.23 → 1.0.0-alpha.25

package/plugins/access-policy/expression-writer.js

@@ -1,323 +1,332 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExpressionWriter = void 0;
-var _ast = require("@zenstackhq/language/ast");
-var _sdk = require("@zenstackhq/sdk");
-var _astUtils = require("../../utils/ast-utils");
-var _typescriptExpressionTransformer = _interopRequireDefault(require("./typescript-expression-transformer"));
-var _utils = require("./utils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const ast_1 = require("@zenstackhq/language/ast");
+const sdk_1 = require("@zenstackhq/sdk");
+const ast_utils_1 = require("../../utils/ast-utils");
+const typescript_expression_transformer_1 = __importDefault(require("./typescript-expression-transformer"));
+const utils_1 = require("./utils");
 /**
  * Utility for writing ZModel expression as Prisma query argument objects into a ts-morph writer
  */
 class ExpressionWriter {
-  /**
-   * Constructs a new ExpressionWriter
-   *
-   * @param isPostGuard indicates if we're writing for post-update conditions
-   */
-  constructor(writer, isPostGuard = false) {
-    this.writer = writer;
-    this.isPostGuard = isPostGuard;
-    this.plainExprBuilder = new _typescriptExpressionTransformer.default(this.isPostGuard);
-  }
-
-  /**
-   * Writes the given ZModel expression.
-   */
-  write(expr) {
-    const _write = () => {
-      switch (expr.$type) {
-        case _ast.LiteralExpr:
-          this.writeLiteral(expr);
-          break;
-        case _ast.UnaryExpr:
-          this.writeUnary(expr);
-          break;
-        case _ast.BinaryExpr:
-          this.writeBinary(expr);
-          break;
-        case _ast.ReferenceExpr:
-          this.writeReference(expr);
-          break;
-        case _ast.MemberAccessExpr:
-          this.writeMemberAccess(expr);
-          break;
-        default:
-          throw new Error(`Not implemented: ${expr.$type}`);
-      }
-    };
-    this.block(_write);
-  }
-  writeReference(expr) {
-    if ((0, _ast.isEnumField)(expr.target.ref)) {
-      throw new Error('We should never get here');
-    } else {
-      var _expr$target$ref;
-      this.writer.write(`${(_expr$target$ref = expr.target.ref) === null || _expr$target$ref === void 0 ? void 0 : _expr$target$ref.name}: true`);
+    /**
+     * Constructs a new ExpressionWriter
+     *
+     * @param isPostGuard indicates if we're writing for post-update conditions
+     */
+    constructor(writer, isPostGuard = false) {
+        this.writer = writer;
+        this.isPostGuard = isPostGuard;
+        this.plainExprBuilder = new typescript_expression_transformer_1.default(this.isPostGuard);
     }
-  }
-  writeMemberAccess(expr) {
-    this.writeFieldCondition(expr.operand, () => {
-      this.block(() => {
-        var _expr$member$ref;
-        this.writer.write(`${(_expr$member$ref = expr.member.ref) === null || _expr$member$ref === void 0 ? void 0 : _expr$member$ref.name}: true`);
-      });
-    }, 'is');
-  }
-  writeExprList(exprs) {
-    this.writer.write('[');
-    for (let i = 0; i < exprs.length; i++) {
-      this.write(exprs[i]);
-      if (i !== exprs.length - 1) {
-        this.writer.write(',');
-      }
+    /**
+     * Writes the given ZModel expression.
+     */
+    write(expr) {
+        const _write = () => {
+            switch (expr.$type) {
+                case ast_1.LiteralExpr:
+                    this.writeLiteral(expr);
+                    break;
+                case ast_1.UnaryExpr:
+                    this.writeUnary(expr);
+                    break;
+                case ast_1.BinaryExpr:
+                    this.writeBinary(expr);
+                    break;
+                case ast_1.ReferenceExpr:
+                    this.writeReference(expr);
+                    break;
+                case ast_1.MemberAccessExpr:
+                    this.writeMemberAccess(expr);
+                    break;
+                default:
+                    throw new Error(`Not implemented: ${expr.$type}`);
+            }
+        };
+        this.block(_write);
     }
-    this.writer.write(']');
-  }
-  writeBinary(expr) {
-    switch (expr.operator) {
-      case '&&':
-      case '||':
-        this.writeLogical(expr, expr.operator);
-        break;
-      case '==':
-      case '!=':
-      case '>':
-      case '>=':
-      case '<':
-      case '<=':
-        this.writeComparison(expr, expr.operator);
-        break;
-      case '?':
-      case '!':
-      case '^':
-        this.writeCollectionPredicate(expr, expr.operator);
-        break;
+    writeReference(expr) {
+        var _a;
+        if ((0, ast_1.isEnumField)(expr.target.ref)) {
+            throw new Error('We should never get here');
+        }
+        else {
+            this.writer.write(`${(_a = expr.target.ref) === null || _a === void 0 ? void 0 : _a.name}: true`);
+        }
     }
-  }
-  writeCollectionPredicate(expr, operator) {
-    this.writeFieldCondition(expr.left, () => {
-      this.write(expr.right);
-    }, operator === '?' ? 'some' : operator === '!' ? 'every' : 'none');
-  }
-  isFieldAccess(expr) {
-    if ((0, _ast.isThisExpr)(expr)) {
-      return true;
+    writeMemberAccess(expr) {
+        this.writeFieldCondition(expr.operand, () => {
+            this.block(() => {
+                var _a;
+                this.writer.write(`${(_a = expr.member.ref) === null || _a === void 0 ? void 0 : _a.name}: true`);
+            });
+        }, 'is');
     }
-    if ((0, _ast.isMemberAccessExpr)(expr)) {
-      if ((0, _utils.isFutureExpr)(expr.operand) && this.isPostGuard) {
-        // when writing for post-update, future().field.x is a field access
-        return true;
-      } else {
-        return this.isFieldAccess(expr.operand);
-      }
+    writeExprList(exprs) {
+        this.writer.write('[');
+        for (let i = 0; i < exprs.length; i++) {
+            this.write(exprs[i]);
+            if (i !== exprs.length - 1) {
+                this.writer.write(',');
+            }
+        }
+        this.writer.write(']');
     }
-    if ((0, _ast.isReferenceExpr)(expr) && (0, _ast.isDataModelField)(expr.target.ref) && !this.isPostGuard) {
-      return true;
+    writeBinary(expr) {
+        switch (expr.operator) {
+            case '&&':
+            case '||':
+                this.writeLogical(expr, expr.operator);
+                break;
+            case '==':
+            case '!=':
+            case '>':
+            case '>=':
+            case '<':
+            case '<=':
+                this.writeComparison(expr, expr.operator);
+                break;
+            case '?':
+            case '!':
+            case '^':
+                this.writeCollectionPredicate(expr, expr.operator);
+                break;
+        }
     }
-    return false;
-  }
-  guard(write) {
-    this.writer.write(`${_sdk.GUARD_FIELD_NAME}: `);
-    write();
-  }
-  plain(expr) {
-    this.writer.write(this.plainExprBuilder.transform(expr));
-  }
-  writeComparison(expr, operator) {
-    const leftIsFieldAccess = this.isFieldAccess(expr.left);
-    const rightIsFieldAccess = this.isFieldAccess(expr.right);
-    if (leftIsFieldAccess && rightIsFieldAccess) {
-      throw new _sdk.PluginError(`Comparison between fields are not supported yet`);
+    writeCollectionPredicate(expr, operator) {
+        this.writeFieldCondition(expr.left, () => {
+            this.write(expr.right);
+        }, operator === '?' ? 'some' : operator === '!' ? 'every' : 'none');
     }
-    if (!leftIsFieldAccess && !rightIsFieldAccess) {
-      // compile down to a plain expression
-      this.guard(() => {
-        this.plain(expr.left);
-        this.writer.write(' ' + operator + ' ');
-        this.plain(expr.right);
-      });
-      return;
+    isFieldAccess(expr) {
+        if ((0, ast_1.isThisExpr)(expr)) {
+            return true;
+        }
+        if ((0, ast_1.isMemberAccessExpr)(expr)) {
+            if ((0, utils_1.isFutureExpr)(expr.operand) && this.isPostGuard) {
+                // when writing for post-update, future().field.x is a field access
+                return true;
+            }
+            else {
+                return this.isFieldAccess(expr.operand);
+            }
+        }
+        if ((0, ast_1.isReferenceExpr)(expr) && (0, ast_1.isDataModelField)(expr.target.ref) && !this.isPostGuard) {
+            return true;
+        }
+        return false;
     }
-    let fieldAccess;
-    let operand;
-    if (leftIsFieldAccess) {
-      fieldAccess = expr.left;
-      operand = expr.right;
-    } else {
-      fieldAccess = expr.right;
-      operand = expr.left;
-      operator = this.negateOperator(operator);
+    guard(write) {
+        this.writer.write(`${sdk_1.GUARD_FIELD_NAME}: `);
+        write();
     }
-    if ((0, _ast.isMemberAccessExpr)(fieldAccess) && (0, _utils.isFutureExpr)(fieldAccess.operand)) {
-      // future().field should be treated as the "field" directly, so we
-      // strip 'future().' and synthesize a reference expr
-      fieldAccess = {
-        $type: _ast.ReferenceExpr,
-        $container: fieldAccess.$container,
-        target: fieldAccess.member,
-        $resolvedType: fieldAccess.$resolvedType
-      };
+    plain(expr) {
+        this.writer.write(this.plainExprBuilder.transform(expr));
     }
-    this.writeFieldCondition(fieldAccess, () => {
-      this.block(() => {
-        const dataModel = this.isModelTyped(fieldAccess);
-        if (dataModel) {
-          const idField = (0, _astUtils.getIdField)(dataModel);
-          if (!idField) {
-            throw new _sdk.PluginError(`Data model ${dataModel.name} does not have an id field`);
-          }
-          // comparing with an object, conver to "id" comparison instead
-          this.writer.write(`${idField.name}: `);
-          this.block(() => {
-            this.writeOperator(operator, () => {
-              this.plain(operand);
-              this.writer.write(`?.${idField.name}`);
+    writeComparison(expr, operator) {
+        const leftIsFieldAccess = this.isFieldAccess(expr.left);
+        const rightIsFieldAccess = this.isFieldAccess(expr.right);
+        if (leftIsFieldAccess && rightIsFieldAccess) {
+            throw new sdk_1.PluginError(`Comparison between fields are not supported yet`);
+        }
+        if (!leftIsFieldAccess && !rightIsFieldAccess) {
+            // compile down to a plain expression
+            this.guard(() => {
+                this.plain(expr.left);
+                this.writer.write(' ' + operator + ' ');
+                this.plain(expr.right);
             });
-          });
-        } else {
-          this.writeOperator(operator, () => {
-            this.plain(operand);
-          });
+            return;
         }
-      },
-      // "this" expression is compiled away (to .id access), so we should
-      // avoid generating a new layer
-      !(0, _ast.isThisExpr)(fieldAccess));
-    }, 'is');
-  }
-  writeOperator(operator, writeOperand) {
-    if (operator === '!=') {
-      // wrap a 'not'
-      this.writer.write('not: ');
-      this.block(() => {
-        this.writeOperator('==', writeOperand);
-      });
-    } else {
-      this.writer.write(`${this.mapOperator(operator)}: `);
-      writeOperand();
-    }
-  }
-  writeFieldCondition(fieldAccess, writeCondition, relationOp) {
-    let selector;
-    let operand;
-    if ((0, _ast.isThisExpr)(fieldAccess)) {
-      // pass on
-      writeCondition();
-      return;
-    } else if ((0, _ast.isReferenceExpr)(fieldAccess)) {
-      var _fieldAccess$target$r;
-      selector = (_fieldAccess$target$r = fieldAccess.target.ref) === null || _fieldAccess$target$r === void 0 ? void 0 : _fieldAccess$target$r.name;
-    } else if ((0, _ast.isMemberAccessExpr)(fieldAccess)) {
-      if ((0, _utils.isFutureExpr)(fieldAccess.operand)) {
-        var _fieldAccess$member$r;
-        // future().field should be treated as the "field"
-        selector = (_fieldAccess$member$r = fieldAccess.member.ref) === null || _fieldAccess$member$r === void 0 ? void 0 : _fieldAccess$member$r.name;
-      } else {
-        var _fieldAccess$member$r2;
-        selector = (_fieldAccess$member$r2 = fieldAccess.member.ref) === null || _fieldAccess$member$r2 === void 0 ? void 0 : _fieldAccess$member$r2.name;
-        operand = fieldAccess.operand;
-      }
-    } else {
-      throw new _sdk.PluginError(`Unsupported expression type: ${fieldAccess.$type}`);
+        let fieldAccess;
+        let operand;
+        if (leftIsFieldAccess) {
+            fieldAccess = expr.left;
+            operand = expr.right;
+        }
+        else {
+            fieldAccess = expr.right;
+            operand = expr.left;
+            operator = this.negateOperator(operator);
+        }
+        if ((0, ast_1.isMemberAccessExpr)(fieldAccess) && (0, utils_1.isFutureExpr)(fieldAccess.operand)) {
+            // future().field should be treated as the "field" directly, so we
+            // strip 'future().' and synthesize a reference expr
+            fieldAccess = {
+                $type: ast_1.ReferenceExpr,
+                $container: fieldAccess.$container,
+                target: fieldAccess.member,
+                $resolvedType: fieldAccess.$resolvedType,
+            };
+        }
+        this.writeFieldCondition(fieldAccess, () => {
+            this.block(() => {
+                const dataModel = this.isModelTyped(fieldAccess);
+                if (dataModel) {
+                    const idField = (0, ast_utils_1.getIdField)(dataModel);
+                    if (!idField) {
+                        throw new sdk_1.PluginError(`Data model ${dataModel.name} does not have an id field`);
+                    }
+                    // comparing with an object, conver to "id" comparison instead
+                    this.writer.write(`${idField.name}: `);
+                    this.block(() => {
+                        this.writeOperator(operator, () => {
+                            this.plain(operand);
+                            this.writer.write(`?.${idField.name}`);
+                        });
+                    });
+                }
+                else {
+                    this.writeOperator(operator, () => {
+                        this.plain(operand);
+                    });
+                }
+            }, 
+            // "this" expression is compiled away (to .id access), so we should
+            // avoid generating a new layer
+            !(0, ast_1.isThisExpr)(fieldAccess));
+        }, 'is');
     }
-    if (!selector) {
-      throw new _sdk.PluginError(`Failed to write FieldAccess expression`);
+    writeOperator(operator, writeOperand) {
+        if (operator === '!=') {
+            // wrap a 'not'
+            this.writer.write('not: ');
+            this.block(() => {
+                this.writeOperator('==', writeOperand);
+            });
+        }
+        else {
+            this.writer.write(`${this.mapOperator(operator)}: `);
+            writeOperand();
+        }
     }
-    if (operand) {
-      // member access expression
-      this.writeFieldCondition(operand, () => {
-        this.block(() => {
-          this.writer.write(selector + ': ');
-          if (this.isModelTyped(fieldAccess)) {
-            // expression is resolved to a model, generate relation query
+    writeFieldCondition(fieldAccess, writeCondition, relationOp) {
+        var _a, _b, _c;
+        let selector;
+        let operand;
+        if ((0, ast_1.isThisExpr)(fieldAccess)) {
+            // pass on
+            writeCondition();
+            return;
+        }
+        else if ((0, ast_1.isReferenceExpr)(fieldAccess)) {
+            selector = (_a = fieldAccess.target.ref) === null || _a === void 0 ? void 0 : _a.name;
+        }
+        else if ((0, ast_1.isMemberAccessExpr)(fieldAccess)) {
+            if ((0, utils_1.isFutureExpr)(fieldAccess.operand)) {
+                // future().field should be treated as the "field"
+                selector = (_b = fieldAccess.member.ref) === null || _b === void 0 ? void 0 : _b.name;
+            }
+            else {
+                selector = (_c = fieldAccess.member.ref) === null || _c === void 0 ? void 0 : _c.name;
+                operand = fieldAccess.operand;
+            }
+        }
+        else {
+            throw new sdk_1.PluginError(`Unsupported expression type: ${fieldAccess.$type}`);
+        }
+        if (!selector) {
+            throw new sdk_1.PluginError(`Failed to write FieldAccess expression`);
+        }
+        if (operand) {
+            // member access expression
+            this.writeFieldCondition(operand, () => {
+                this.block(() => {
+                    this.writer.write(selector + ': ');
+                    if (this.isModelTyped(fieldAccess)) {
+                        // expression is resolved to a model, generate relation query
+                        this.block(() => {
+                            this.writer.write(`${relationOp}: `);
+                            writeCondition();
+                        });
+                    }
+                    else {
+                        // generate plain query
+                        writeCondition();
+                    }
+                }, 
+                // if operand is "this", it doesn't really generate a new layer of query,
+                // so we should avoid generating a new block
+                !(0, ast_1.isThisExpr)(operand));
+            }, 'is');
+        }
+        else if (this.isModelTyped(fieldAccess)) {
+            // reference resolved to a model, generate relation query
+            this.writer.write(selector + ': ');
             this.block(() => {
-              this.writer.write(`${relationOp}: `);
-              writeCondition();
+                this.writer.write(`${relationOp}: `);
+                writeCondition();
             });
-          } else {
-            // generate plain query
+        }
+        else {
+            // generate a plain query
+            this.writer.write(selector + ': ');
             writeCondition();
-          }
-        },
-        // if operand is "this", it doesn't really generate a new layer of query,
-        // so we should avoid generating a new block
-        !(0, _ast.isThisExpr)(operand));
-      }, 'is');
-    } else if (this.isModelTyped(fieldAccess)) {
-      // reference resolved to a model, generate relation query
-      this.writer.write(selector + ': ');
-      this.block(() => {
-        this.writer.write(`${relationOp}: `);
-        writeCondition();
-      });
-    } else {
-      // generate a plain query
-      this.writer.write(selector + ': ');
-      writeCondition();
+        }
     }
-  }
-  block(write, condition = true) {
-    if (condition) {
-      this.writer.inlineBlock(write);
-    } else {
-      write();
+    block(write, condition = true) {
+        if (condition) {
+            this.writer.inlineBlock(write);
+        }
+        else {
+            write();
+        }
     }
-  }
-  isModelTyped(expr) {
-    var _expr$$resolvedType, _expr$$resolvedType2;
-    return (0, _ast.isDataModel)((_expr$$resolvedType = expr.$resolvedType) === null || _expr$$resolvedType === void 0 ? void 0 : _expr$$resolvedType.decl) ? (_expr$$resolvedType2 = expr.$resolvedType) === null || _expr$$resolvedType2 === void 0 ? void 0 : _expr$$resolvedType2.decl : undefined;
-  }
-  mapOperator(operator) {
-    switch (operator) {
-      case '==':
-        return 'equals';
-      case '!=':
-        throw new Error('Operation != should have been compiled away');
-      case '>':
-        return 'gt';
-      case '>=':
-        return 'gte';
-      case '<':
-        return 'lt';
-      case '<=':
-        return 'lte';
+    isModelTyped(expr) {
+        var _a, _b;
+        return (0, ast_1.isDataModel)((_a = expr.$resolvedType) === null || _a === void 0 ? void 0 : _a.decl) ? (_b = expr.$resolvedType) === null || _b === void 0 ? void 0 : _b.decl : undefined;
+    }
+    mapOperator(operator) {
+        switch (operator) {
+            case '==':
+                return 'equals';
+            case '!=':
+                throw new Error('Operation != should have been compiled away');
+            case '>':
+                return 'gt';
+            case '>=':
+                return 'gte';
+            case '<':
+                return 'lt';
+            case '<=':
+                return 'lte';
+        }
     }
-  }
-  negateOperator(operator) {
-    switch (operator) {
-      case '>':
-        return '<=';
-      case '<':
-        return '>=';
-      case '>=':
-        return '<';
-      case '<=':
-        return '>';
-      default:
-        return operator;
+    negateOperator(operator) {
+        switch (operator) {
+            case '>':
+                return '<=';
+            case '<':
+                return '>=';
+            case '>=':
+                return '<';
+            case '<=':
+                return '>';
+            default:
+                return operator;
+        }
+    }
+    writeLogical(expr, operator) {
+        this.writer.write(`${operator === '&&' ? 'AND' : 'OR'}: `);
+        this.writeExprList([expr.left, expr.right]);
+    }
+    writeUnary(expr) {
+        if (expr.operator !== '!') {
+            throw new sdk_1.PluginError(`Unary operator "${expr.operator}" is not supported`);
+        }
+        this.writer.write('NOT: ');
+        this.write(expr.operand);
     }
-  }
-  writeLogical(expr, operator) {
-    this.writer.write(`${operator === '&&' ? 'AND' : 'OR'}: `);
-    this.writeExprList([expr.left, expr.right]);
-  }
-  writeUnary(expr) {
-    if (expr.operator !== '!') {
-      throw new _sdk.PluginError(`Unary operator "${expr.operator}" is not supported`);
+    writeLiteral(expr) {
+        this.guard(() => {
+            this.plain(expr);
+        });
     }
-    this.writer.write('NOT: ');
-    this.write(expr.operand);
-  }
-  writeLiteral(expr) {
-    this.guard(() => {
-      this.plain(expr);
-    });
-  }
 }
 exports.ExpressionWriter = ExpressionWriter;
 //# sourceMappingURL=expression-writer.js.map