zenstack 0.6.0-pre.8 → 1.0.0-alpha.19

package/language-server/zmodel-workspace-manager.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _langium = require("langium");
+var _path = _interopRequireDefault(require("path"));
+var _vscodeUri = require("vscode-uri");
+var _constants = require("./constants");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Custom Langium WorkspaceManager implementation which automatically loads stdlib.zmodel
+ */
+class ZModelWorkspaceManager extends _langium.DefaultWorkspaceManager {
+  async loadAdditionalDocuments(_folders, _collector) {
+    await super.loadAdditionalDocuments(_folders, _collector);
+    const stdLibUri = _vscodeUri.URI.file(_path.default.join(__dirname, '../res', _constants.STD_LIB_MODULE_NAME));
+    console.log(`Adding stdlib document from ${stdLibUri}`);
+    const stdlib = this.langiumDocuments.getOrCreateDocument(stdLibUri);
+    _collector(stdlib);
+  }
+}
+exports.default = ZModelWorkspaceManager;
+//# sourceMappingURL=zmodel-workspace-manager.js.map

package/language-server/zmodel-workspace-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zmodel-workspace-manager.js","names":["ZModelWorkspaceManager","DefaultWorkspaceManager","loadAdditionalDocuments","_folders","_collector","stdLibUri","URI","file","path","join","__dirname","STD_LIB_MODULE_NAME","console","log","stdlib","langiumDocuments","getOrCreateDocument"],"sources":["../../src/language-server/zmodel-workspace-manager.ts"],"sourcesContent":["import { DefaultWorkspaceManager, LangiumDocument } from 'langium';\nimport path from 'path';\nimport { WorkspaceFolder } from 'vscode-languageserver';\nimport { URI } from 'vscode-uri';\nimport { STD_LIB_MODULE_NAME } from './constants';\n\n/**\n * Custom Langium WorkspaceManager implementation which automatically loads stdlib.zmodel\n */\nexport default class ZModelWorkspaceManager extends DefaultWorkspaceManager {\n    protected async loadAdditionalDocuments(\n        _folders: WorkspaceFolder[],\n        _collector: (document: LangiumDocument) => void\n    ): Promise<void> {\n        await super.loadAdditionalDocuments(_folders, _collector);\n        const stdLibUri = URI.file(path.join(__dirname, '../res', STD_LIB_MODULE_NAME));\n        console.log(`Adding stdlib document from ${stdLibUri}`);\n        const stdlib = this.langiumDocuments.getOrCreateDocument(stdLibUri);\n        _collector(stdlib);\n    }\n}\n"],"mappings":";;;;;;AAAA;AACA;AAEA;AACA;AAAkD;AAElD;AACA;AACA;AACe,MAAMA,sBAAsB,SAASC,gCAAuB,CAAC;EACxE,MAAgBC,uBAAuB,CACnCC,QAA2B,EAC3BC,UAA+C,EAClC;IACb,MAAM,KAAK,CAACF,uBAAuB,CAACC,QAAQ,EAAEC,UAAU,CAAC;IACzD,MAAMC,SAAS,GAAGC,cAAG,CAACC,IAAI,CAACC,aAAI,CAACC,IAAI,CAACC,SAAS,EAAE,QAAQ,EAAEC,8BAAmB,CAAC,CAAC;IAC/EC,OAAO,CAACC,GAAG,CAAE,+BAA8BR,SAAU,EAAC,CAAC;IACvD,MAAMS,MAAM,GAAG,IAAI,CAACC,gBAAgB,CAACC,mBAAmB,CAACX,SAAS,CAAC;IACnED,UAAU,CAACU,MAAM,CAAC;EACtB;AACJ;AAAC"}

package/package.json

@@ -3,7 +3,7 @@
   "publisher": "zenstack",
   "displayName": "ZenStack Language Tools",
   "description": "A toolkit for building secure CRUD apps with Next.js + Typescript",
-  "version": "0.6.0-pre.8",
+  "version": "1.0.0-alpha.19",
   "author": {
     "name": "ZenStack Team"
   },
@@ -22,7 +22,7 @@
     "url": "https://github.com/zenstackhq/zenstack"
   },
   "publishConfig": {
-    "directory": "bundle",
+    "directory": "dist",
     "linkDirectory": true
   },
   "engines": {
@@ -63,7 +63,7 @@
   "bin": {
     "zenstack": "bin/cli"
   },
-  "main": "./extension.js",
+  "main": "./bundle/extension.js",
   "dependencies": {
     "@prisma/generator-helper": "^4.7.1",
     "@prisma/internals": "^4.7.1",
@@ -73,13 +73,14 @@
     "colors": "1.4.0",
     "commander": "^8.3.0",
     "cuid": "^2.1.8",
-    "langium": "^0.5.0",
+    "langium": "^1.0.1",
     "mixpanel": "^0.17.0",
     "node-machine-id": "^1.1.12",
-    "ora": "^6.1.2",
+    "ora": "^5.4.1",
     "pluralize": "^8.0.0",
     "prisma": "~4.7.0",
     "promisify": "^0.0.3",
+    "semver": "^7.3.8",
     "sleep-promise": "^9.1.0",
     "ts-morph": "^16.0.0",
     "uuid": "^9.0.0",
@@ -89,46 +90,50 @@
     "vscode-languageserver-textdocument": "^1.0.7",
     "vscode-uri": "^3.0.6",
     "zod": "^3.19.1",
-    "@zenstackhq/language": "0.6.0-pre.2",
-    "@zenstackhq/runtime": "0.6.0-pre.2",
-    "@zenstackhq/sdk": "0.6.0-pre.2"
+    "@zenstackhq/language": "1.0.0-alpha.19",
+    "@zenstackhq/runtime": "1.0.0-alpha.19",
+    "@zenstackhq/sdk": "1.0.0-alpha.19"
   },
   "devDependencies": {
+    "@babel/cli": "^7.19.3",
+    "@babel/core": "^7.20.5",
+    "@babel/preset-env": "^7.20.2",
+    "@babel/preset-typescript": "^7.18.6",
     "@types/async-exit-hook": "^2.0.0",
     "@types/jest": "^29.2.0",
     "@types/node": "^14.18.32",
     "@types/pluralize": "^0.0.29",
+    "@types/semver": "^7.3.13",
     "@types/tmp": "^0.2.3",
     "@types/uuid": "^8.3.4",
     "@types/vscode": "^1.56.0",
     "@typescript-eslint/eslint-plugin": "^5.42.0",
     "@typescript-eslint/parser": "^5.42.0",
+    "babel-plugin-inline-dotenv": "^1.7.0",
     "concurrently": "^7.4.0",
     "dotenv": "^16.0.3",
     "esbuild": "^0.15.12",
     "eslint": "^8.27.0",
+    "eslint-plugin-jest": "^27.1.7",
     "jest": "^29.2.1",
-    "langium-cli": "^0.5.0",
+    "langium-cli": "^1.0.0",
     "rimraf": "^3.0.2",
     "tmp": "^0.2.1",
     "ts-jest": "^29.0.3",
     "ts-node": "^10.9.1",
     "tsc-alias": "^1.7.0",
-    "tsconfig-paths-jest": "^0.0.1",
     "typescript": "^4.8.4",
     "vsce": "^2.13.0"
   },
   "scripts": {
     "vscode:publish": "vsce publish --no-dependencies",
-    "vscode:prepublish": "cp ../../README.md ./ && pnpm lint && pnpm build",
+    "vscode:prepublish": "pnpm lint && pnpm bundle",
     "vscode:package": "vsce package --no-dependencies",
-    "clean": "rimraf bundle",
-    "build": "pnpm lint && pnpm bundle && tsc --emitDeclarationOnly --declaration ",
-    "bundle": "pnpm clean && node build/bundle.js --minify",
-    "watch": "node build/bundle.js --watch",
-    "ts:watch": "tsc --watch --noEmit",
-    "tsc-alias:watch": "tsc-alias --watch",
-    "lint": "eslint src --ext ts",
+    "clean": "rimraf bundle dist",
+    "build": "pnpm clean && pnpm lint && tsc && babel src -d dist --extensions '.ts' && cp -r bin src/res ./README.md ./LICENSE ./package.json dist/ && node build/post-build.js",
+    "bundle": "pnpm clean && pnpm lint && node build/bundle.js --minify",
+    "watch": "babel src -d dist --extensions '.ts' -w",
+    "lint": "eslint src tests --ext ts",
     "test": "jest",
     "publish-dev": "pnpm publish --tag dev",
     "postinstall": "node bin/post-install.js"

package/plugins/access-policy/expression-writer.d.ts

@@ -0,0 +1,38 @@
+import { Expression } from '@zenstackhq/language/ast';
+import { CodeBlockWriter } from 'ts-morph';
+/**
+ * Utility for writing ZModel expression as Prisma query argument objects into a ts-morph writer
+ */
+export declare class ExpressionWriter {
+    private readonly writer;
+    private readonly isPostGuard;
+    private readonly plainExprBuilder;
+    /**
+     * Constructs a new ExpressionWriter
+     *
+     * @param isPostGuard indicates if we're writing for post-update conditions
+     */
+    constructor(writer: CodeBlockWriter, isPostGuard?: boolean);
+    /**
+     * Writes the given ZModel expression.
+     */
+    write(expr: Expression): void;
+    private writeReference;
+    private writeMemberAccess;
+    private writeExprList;
+    private writeBinary;
+    private writeCollectionPredicate;
+    private isFieldAccess;
+    private guard;
+    private plain;
+    private writeComparison;
+    private writeOperator;
+    private writeFieldCondition;
+    private block;
+    private isModelTyped;
+    private mapOperator;
+    private negateOperator;
+    private writeLogical;
+    private writeUnary;
+    private writeLiteral;
+}

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

@@ -0,0 +1,323 @@
+"use strict";
+
+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 }; }
+/**
+ * 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`);
+    }
+  }
+  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(',');
+      }
+    }
+    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;
+    }
+  }
+  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;
+    }
+    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);
+      }
+    }
+    if ((0, _ast.isReferenceExpr)(expr) && (0, _ast.isDataModelField)(expr.target.ref) && !this.isPostGuard) {
+      return true;
+    }
+    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`);
+    }
+    if (!leftIsFieldAccess && !rightIsFieldAccess) {
+      // compile down to a plain expression
+      this.guard(() => {
+        this.plain(expr.left);
+        this.writer.write(' ' + operator + ' ');
+        this.plain(expr.right);
+      });
+      return;
+    }
+    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.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
+      };
+    }
+    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}`);
+            });
+          });
+        } 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.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}`);
+    }
+    if (!selector) {
+      throw new _sdk.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.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();
+    }
+  }
+  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';
+    }
+  }
+  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.PluginError(`Unary operator "${expr.operator}" is not supported`);
+    }
+    this.writer.write('NOT: ');
+    this.write(expr.operand);
+  }
+  writeLiteral(expr) {
+    this.guard(() => {
+      this.plain(expr);
+    });
+  }
+}
+exports.ExpressionWriter = ExpressionWriter;
+//# sourceMappingURL=expression-writer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expression-writer.js","names":["ExpressionWriter","constructor","writer","isPostGuard","plainExprBuilder","TypeScriptExpressionTransformer","write","expr","_write","$type","LiteralExpr","writeLiteral","UnaryExpr","writeUnary","BinaryExpr","writeBinary","ReferenceExpr","writeReference","MemberAccessExpr","writeMemberAccess","Error","block","isEnumField","target","ref","name","writeFieldCondition","operand","member","writeExprList","exprs","i","length","operator","writeLogical","writeComparison","writeCollectionPredicate","left","right","isFieldAccess","isThisExpr","isMemberAccessExpr","isFutureExpr","isReferenceExpr","isDataModelField","guard","GUARD_FIELD_NAME","plain","transform","leftIsFieldAccess","rightIsFieldAccess","PluginError","fieldAccess","negateOperator","$container","$resolvedType","dataModel","isModelTyped","idField","getIdField","writeOperator","writeOperand","mapOperator","writeCondition","relationOp","selector","condition","inlineBlock","isDataModel","decl","undefined"],"sources":["../../../src/plugins/access-policy/expression-writer.ts"],"sourcesContent":["import {\n    BinaryExpr,\n    DataModel,\n    Expression,\n    LiteralExpr,\n    MemberAccessExpr,\n    ReferenceExpr,\n    UnaryExpr,\n    isDataModel,\n    isDataModelField,\n    isEnumField,\n    isMemberAccessExpr,\n    isReferenceExpr,\n    isThisExpr,\n} from '@zenstackhq/language/ast';\nimport { GUARD_FIELD_NAME, PluginError } from '@zenstackhq/sdk';\nimport { CodeBlockWriter } from 'ts-morph';\nimport { getIdField } from '../../utils/ast-utils';\nimport TypeScriptExpressionTransformer from './typescript-expression-transformer';\nimport { isFutureExpr } from './utils';\n\ntype ComparisonOperator = '==' | '!=' | '>' | '>=' | '<' | '<=';\n\n/**\n * Utility for writing ZModel expression as Prisma query argument objects into a ts-morph writer\n */\nexport class ExpressionWriter {\n    private readonly plainExprBuilder: TypeScriptExpressionTransformer;\n\n    /**\n     * Constructs a new ExpressionWriter\n     *\n     * @param isPostGuard indicates if we're writing for post-update conditions\n     */\n    constructor(private readonly writer: CodeBlockWriter, private readonly isPostGuard = false) {\n        this.plainExprBuilder = new TypeScriptExpressionTransformer(this.isPostGuard);\n    }\n\n    /**\n     * Writes the given ZModel expression.\n     */\n    write(expr: Expression): void {\n        const _write = () => {\n            switch (expr.$type) {\n                case LiteralExpr:\n                    this.writeLiteral(expr as LiteralExpr);\n                    break;\n\n                case UnaryExpr:\n                    this.writeUnary(expr as UnaryExpr);\n                    break;\n\n                case BinaryExpr:\n                    this.writeBinary(expr as BinaryExpr);\n                    break;\n\n                case ReferenceExpr:\n                    this.writeReference(expr as ReferenceExpr);\n                    break;\n\n                case MemberAccessExpr:\n                    this.writeMemberAccess(expr as MemberAccessExpr);\n                    break;\n\n                default:\n                    throw new Error(`Not implemented: ${expr.$type}`);\n            }\n        };\n\n        this.block(_write);\n    }\n\n    private writeReference(expr: ReferenceExpr) {\n        if (isEnumField(expr.target.ref)) {\n            throw new Error('We should never get here');\n        } else {\n            this.writer.write(`${expr.target.ref?.name}: true`);\n        }\n    }\n\n    private writeMemberAccess(expr: MemberAccessExpr) {\n        this.writeFieldCondition(\n            expr.operand,\n            () => {\n                this.block(() => {\n                    this.writer.write(`${expr.member.ref?.name}: true`);\n                });\n            },\n            'is'\n        );\n    }\n\n    private writeExprList(exprs: Expression[]) {\n        this.writer.write('[');\n        for (let i = 0; i < exprs.length; i++) {\n            this.write(exprs[i]);\n            if (i !== exprs.length - 1) {\n                this.writer.write(',');\n            }\n        }\n        this.writer.write(']');\n    }\n\n    private writeBinary(expr: BinaryExpr) {\n        switch (expr.operator) {\n            case '&&':\n            case '||':\n                this.writeLogical(expr, expr.operator);\n                break;\n\n            case '==':\n            case '!=':\n            case '>':\n            case '>=':\n            case '<':\n            case '<=':\n                this.writeComparison(expr, expr.operator);\n                break;\n\n            case '?':\n            case '!':\n            case '^':\n                this.writeCollectionPredicate(expr, expr.operator);\n                break;\n        }\n    }\n\n    private writeCollectionPredicate(expr: BinaryExpr, operator: string) {\n        this.writeFieldCondition(\n            expr.left,\n            () => {\n                this.write(expr.right);\n            },\n            operator === '?' ? 'some' : operator === '!' ? 'every' : 'none'\n        );\n    }\n\n    private isFieldAccess(expr: Expression): boolean {\n        if (isThisExpr(expr)) {\n            return true;\n        }\n\n        if (isMemberAccessExpr(expr)) {\n            if (isFutureExpr(expr.operand) && this.isPostGuard) {\n                // when writing for post-update, future().field.x is a field access\n                return true;\n            } else {\n                return this.isFieldAccess(expr.operand);\n            }\n        }\n        if (isReferenceExpr(expr) && isDataModelField(expr.target.ref) && !this.isPostGuard) {\n            return true;\n        }\n        return false;\n    }\n\n    private guard(write: () => void) {\n        this.writer.write(`${GUARD_FIELD_NAME}: `);\n        write();\n    }\n\n    private plain(expr: Expression) {\n        this.writer.write(this.plainExprBuilder.transform(expr));\n    }\n\n    private writeComparison(expr: BinaryExpr, operator: ComparisonOperator) {\n        const leftIsFieldAccess = this.isFieldAccess(expr.left);\n        const rightIsFieldAccess = this.isFieldAccess(expr.right);\n\n        if (leftIsFieldAccess && rightIsFieldAccess) {\n            throw new PluginError(`Comparison between fields are not supported yet`);\n        }\n\n        if (!leftIsFieldAccess && !rightIsFieldAccess) {\n            // compile down to a plain expression\n            this.guard(() => {\n                this.plain(expr.left);\n                this.writer.write(' ' + operator + ' ');\n                this.plain(expr.right);\n            });\n\n            return;\n        }\n\n        let fieldAccess: Expression;\n        let operand: Expression;\n        if (leftIsFieldAccess) {\n            fieldAccess = expr.left;\n            operand = expr.right;\n        } else {\n            fieldAccess = expr.right;\n            operand = expr.left;\n            operator = this.negateOperator(operator);\n        }\n\n        if (isMemberAccessExpr(fieldAccess) && isFutureExpr(fieldAccess.operand)) {\n            // future().field should be treated as the \"field\" directly, so we\n            // strip 'future().' and synthesize a reference expr\n            fieldAccess = {\n                $type: ReferenceExpr,\n                $container: fieldAccess.$container,\n                target: fieldAccess.member,\n                $resolvedType: fieldAccess.$resolvedType,\n            } as ReferenceExpr;\n        }\n\n        this.writeFieldCondition(\n            fieldAccess,\n            () => {\n                this.block(\n                    () => {\n                        const dataModel = this.isModelTyped(fieldAccess);\n                        if (dataModel) {\n                            const idField = getIdField(dataModel);\n                            if (!idField) {\n                                throw new PluginError(`Data model ${dataModel.name} does not have an id field`);\n                            }\n                            // comparing with an object, conver to \"id\" comparison instead\n                            this.writer.write(`${idField.name}: `);\n                            this.block(() => {\n                                this.writeOperator(operator, () => {\n                                    this.plain(operand);\n                                    this.writer.write(`?.${idField.name}`);\n                                });\n                            });\n                        } else {\n                            this.writeOperator(operator, () => {\n                                this.plain(operand);\n                            });\n                        }\n                    },\n                    // \"this\" expression is compiled away (to .id access), so we should\n                    // avoid generating a new layer\n                    !isThisExpr(fieldAccess)\n                );\n            },\n            'is'\n        );\n    }\n\n    private writeOperator(operator: ComparisonOperator, writeOperand: () => void) {\n        if (operator === '!=') {\n            // wrap a 'not'\n            this.writer.write('not: ');\n            this.block(() => {\n                this.writeOperator('==', writeOperand);\n            });\n        } else {\n            this.writer.write(`${this.mapOperator(operator)}: `);\n            writeOperand();\n        }\n    }\n\n    private writeFieldCondition(\n        fieldAccess: Expression,\n        writeCondition: () => void,\n        relationOp: 'is' | 'some' | 'every' | 'none'\n    ) {\n        let selector: string | undefined;\n        let operand: Expression | undefined;\n\n        if (isThisExpr(fieldAccess)) {\n            // pass on\n            writeCondition();\n            return;\n        } else if (isReferenceExpr(fieldAccess)) {\n            selector = fieldAccess.target.ref?.name;\n        } else if (isMemberAccessExpr(fieldAccess)) {\n            if (isFutureExpr(fieldAccess.operand)) {\n                // future().field should be treated as the \"field\"\n                selector = fieldAccess.member.ref?.name;\n            } else {\n                selector = fieldAccess.member.ref?.name;\n                operand = fieldAccess.operand;\n            }\n        } else {\n            throw new PluginError(`Unsupported expression type: ${fieldAccess.$type}`);\n        }\n\n        if (!selector) {\n            throw new PluginError(`Failed to write FieldAccess expression`);\n        }\n\n        if (operand) {\n            // member access expression\n            this.writeFieldCondition(\n                operand,\n                () => {\n                    this.block(\n                        () => {\n                            this.writer.write(selector + ': ');\n                            if (this.isModelTyped(fieldAccess)) {\n                                // expression is resolved to a model, generate relation query\n                                this.block(() => {\n                                    this.writer.write(`${relationOp}: `);\n                                    writeCondition();\n                                });\n                            } else {\n                                // generate plain query\n                                writeCondition();\n                            }\n                        },\n                        // if operand is \"this\", it doesn't really generate a new layer of query,\n                        // so we should avoid generating a new block\n                        !isThisExpr(operand)\n                    );\n                },\n                'is'\n            );\n        } else if (this.isModelTyped(fieldAccess)) {\n            // reference resolved to a model, generate relation query\n            this.writer.write(selector + ': ');\n            this.block(() => {\n                this.writer.write(`${relationOp}: `);\n                writeCondition();\n            });\n        } else {\n            // generate a plain query\n            this.writer.write(selector + ': ');\n            writeCondition();\n        }\n    }\n\n    private block(write: () => void, condition = true) {\n        if (condition) {\n            this.writer.inlineBlock(write);\n        } else {\n            write();\n        }\n    }\n\n    private isModelTyped(expr: Expression) {\n        return isDataModel(expr.$resolvedType?.decl) ? (expr.$resolvedType?.decl as DataModel) : undefined;\n    }\n\n    private mapOperator(operator: '==' | '!=' | '>' | '>=' | '<' | '<=') {\n        switch (operator) {\n            case '==':\n                return 'equals';\n            case '!=':\n                throw new Error('Operation != should have been compiled away');\n            case '>':\n                return 'gt';\n            case '>=':\n                return 'gte';\n            case '<':\n                return 'lt';\n            case '<=':\n                return 'lte';\n        }\n    }\n\n    private negateOperator(operator: '==' | '!=' | '>' | '>=' | '<' | '<=') {\n        switch (operator) {\n            case '>':\n                return '<=';\n            case '<':\n                return '>=';\n            case '>=':\n                return '<';\n            case '<=':\n                return '>';\n            default:\n                return operator;\n        }\n    }\n\n    private writeLogical(expr: BinaryExpr, operator: '&&' | '||') {\n        this.writer.write(`${operator === '&&' ? 'AND' : 'OR'}: `);\n        this.writeExprList([expr.left, expr.right]);\n    }\n\n    private writeUnary(expr: UnaryExpr) {\n        if (expr.operator !== '!') {\n            throw new PluginError(`Unary operator \"${expr.operator}\" is not supported`);\n        }\n\n        this.writer.write('NOT: ');\n        this.write(expr.operand);\n    }\n\n    private writeLiteral(expr: LiteralExpr) {\n        this.guard(() => {\n            this.plain(expr);\n        });\n    }\n}\n"],"mappings":"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"}

package/plugins/access-policy/index.d.ts

@@ -0,0 +1,4 @@
+import { Model } from '@zenstackhq/language/ast';
+import { PluginOptions } from '@zenstackhq/sdk';
+export declare const name = "Access Policy";
+export default function run(model: Model, options: PluginOptions): Promise<void>;

package/plugins/access-policy/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = run;
+exports.name = void 0;
+var _policyGuardGenerator = _interopRequireDefault(require("./policy-guard-generator"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const name = 'Access Policy';
+exports.name = name;
+async function run(model, options) {
+  return new _policyGuardGenerator.default().generate(model, options);
+}
+//# sourceMappingURL=index.js.map

package/plugins/access-policy/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["name","run","model","options","PolicyGenerator","generate"],"sources":["../../../src/plugins/access-policy/index.ts"],"sourcesContent":["import { Model } from '@zenstackhq/language/ast';\nimport { PluginOptions } from '@zenstackhq/sdk';\nimport PolicyGenerator from './policy-guard-generator';\n\nexport const name = 'Access Policy';\n\nexport default async function run(model: Model, options: PluginOptions) {\n    return new PolicyGenerator().generate(model, options);\n}\n"],"mappings":";;;;;;;AAEA;AAAuD;AAEhD,MAAMA,IAAI,GAAG,eAAe;AAAC;AAErB,eAAeC,GAAG,CAACC,KAAY,EAAEC,OAAsB,EAAE;EACpE,OAAO,IAAIC,6BAAe,EAAE,CAACC,QAAQ,CAACH,KAAK,EAAEC,OAAO,CAAC;AACzD"}

package/plugins/access-policy/policy-guard-generator.d.ts

@@ -0,0 +1,15 @@
+import { Model } from '@zenstackhq/language/ast';
+import { PluginOptions } from '@zenstackhq/sdk';
+/**
+ * Generates source file that contains Prisma query guard objects used for injecting database queries
+ */
+export default class PolicyGenerator {
+    generate(model: Model, options: PluginOptions): Promise<void>;
+    private getPolicyExpressions;
+    private processUpdatePolicies;
+    private visitPolicyExpression;
+    private hasFutureReference;
+    private generateQueryGuardForModel;
+    private generatePreValueSelect;
+    private generateQueryGuardFunction;
+}