@zenstackhq/runtime 3.0.0-alpha.19 → 3.0.0-alpha.20

package/dist/plugins/policy/index.d.cts

@@ -1,5 +1,5 @@
 import * as kysely from 'kysely';
-import { R as RuntimePlugin, V as OnKyselyQueryArgs } from '../../contract-CxX20JtH.cjs';
+import { R as RuntimePlugin, V as OnKyselyQueryArgs } from '../../contract-XFKcwhq7.cjs';
 import { SchemaDef } from '@zenstackhq/sdk/schema';
 import 'decimal.js';
 

package/dist/plugins/policy/index.d.ts

@@ -1,5 +1,5 @@
 import * as kysely from 'kysely';
-import { R as RuntimePlugin, V as OnKyselyQueryArgs } from '../../contract-CxX20JtH.js';
+import { R as RuntimePlugin, V as OnKyselyQueryArgs } from '../../contract-XFKcwhq7.js';
 import { SchemaDef } from '@zenstackhq/sdk/schema';
 import 'decimal.js';
 

package/dist/plugins/policy/index.js

@@ -16,18 +16,33 @@ var RejectedByPolicyError = class extends Error {
 // src/plugins/policy/policy-handler.ts
 import { invariant as invariant6 } from "@zenstackhq/common-helpers";
 import { AliasNode as AliasNode3, BinaryOperationNode as BinaryOperationNode3, ColumnNode as ColumnNode2, DeleteQueryNode, FromNode as FromNode2, IdentifierNode as IdentifierNode2, InsertQueryNode, OperationNodeTransformer, OperatorNode as OperatorNode3, PrimitiveValueListNode, RawNode, ReturningNode, SelectionNode as SelectionNode2, SelectQueryNode as SelectQueryNode2, TableNode as TableNode3, UpdateQueryNode, ValueNode as ValueNode3, ValuesNode, WhereNode as WhereNode2 } from "kysely";
-import { match as match7 } from "ts-pattern";
+import { match as match8 } from "ts-pattern";
 
 // src/client/crud/dialects/index.ts
-import { match as match4 } from "ts-pattern";
+import { match as match5 } from "ts-pattern";
 
 // src/client/crud/dialects/postgresql.ts
 import { invariant as invariant2 } from "@zenstackhq/common-helpers";
 import { sql as sql2 } from "kysely";
-import { match as match2 } from "ts-pattern";
+import { match as match3 } from "ts-pattern";
 
 // src/client/constants.ts
 var DELEGATE_JOINED_FIELD_PREFIX = "$delegate$";
+var LOGICAL_COMBINATORS = [
+  "AND",
+  "OR",
+  "NOT"
+];
+var AGGREGATE_OPERATORS = [
+  "_count",
+  "_sum",
+  "_avg",
+  "_min",
+  "_max"
+];
+
+// src/client/query-utils.ts
+import { match } from "ts-pattern";
 
 // src/schema/expression.ts
 var ExpressionUtils = {
@@ -332,11 +347,15 @@ function getDelegateDescendantModels(schema, model, collected = /* @__PURE__ */
   ];
 }
 __name(getDelegateDescendantModels, "getDelegateDescendantModels");
+function aggregate(eb, expr2, op) {
+  return match(op).with("_count", () => eb.fn.count(expr2)).with("_sum", () => eb.fn.sum(expr2)).with("_avg", () => eb.fn.avg(expr2)).with("_min", () => eb.fn.min(expr2)).with("_max", () => eb.fn.max(expr2)).exhaustive();
+}
+__name(aggregate, "aggregate");
 
 // src/client/crud/dialects/base.ts
 import { invariant, isPlainObject } from "@zenstackhq/common-helpers";
 import { sql } from "kysely";
-import { match, P } from "ts-pattern";
+import { match as match2, P } from "ts-pattern";
 
 // src/utils/enumerate.ts
 function enumerate(x) {
@@ -393,7 +412,7 @@ var BaseCrudDialect = class {
       if (key.startsWith("$")) {
         continue;
       }
-      if (key === "AND" || key === "OR" || key === "NOT") {
+      if (this.isLogicalCombinator(key)) {
         result = this.and(eb, result, this.buildCompositeFilter(eb, model, modelAlias, key, payload));
         continue;
       }
@@ -414,8 +433,11 @@ var BaseCrudDialect = class {
     }
     return result;
   }
+  isLogicalCombinator(key) {
+    return LOGICAL_COMBINATORS.includes(key);
+  }
   buildCompositeFilter(eb, model, modelAlias, key, payload) {
-    return match(key).with("AND", () => this.and(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("OR", () => this.or(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("NOT", () => eb.not(this.buildCompositeFilter(eb, model, modelAlias, "AND", payload))).exhaustive();
+    return match2(key).with("AND", () => this.and(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("OR", () => this.or(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("NOT", () => eb.not(this.buildCompositeFilter(eb, model, modelAlias, "AND", payload))).exhaustive();
   }
   buildRelationFilter(eb, model, modelAlias, field, fieldDef, payload) {
     if (!fieldDef.array) {
@@ -564,7 +586,7 @@ var BaseCrudDialect = class {
     if (isEnum(this.schema, fieldDef.type)) {
       return this.buildEnumFilter(eb, fieldRef, fieldDef, payload);
     }
-    return match(fieldDef.type).with("String", () => this.buildStringFilter(eb, fieldRef, payload)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(eb, fieldRef, payload)).with("Json", () => {
+    return match2(fieldDef.type).with("String", () => this.buildStringFilter(eb, fieldRef, payload)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(eb, fieldRef, payload)).with("Json", () => {
       throw new InternalError("JSON filters are not supported yet");
     }).with("Unsupported", () => {
       throw new QueryError(`Unsupported field cannot be used in filters`);
@@ -592,7 +614,7 @@ var BaseCrudDialect = class {
         continue;
       }
       const rhs = Array.isArray(value) ? value.map(getRhs) : getRhs(value);
-      const condition = match(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
+      const condition = match2(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
         invariant(Array.isArray(rhs), "right hand side must be an array");
         if (rhs.length === 0) {
           return this.false(eb);
@@ -606,7 +628,11 @@ var BaseCrudDialect = class {
         } else {
           return eb.not(eb(lhs, "in", rhs));
         }
-      }).with("lt", () => eb(lhs, "<", rhs)).with("lte", () => eb(lhs, "<=", rhs)).with("gt", () => eb(lhs, ">", rhs)).with("gte", () => eb(lhs, ">=", rhs)).with("not", () => eb.not(recurse(value))).otherwise(() => {
+      }).with("lt", () => eb(lhs, "<", rhs)).with("lte", () => eb(lhs, "<=", rhs)).with("gt", () => eb(lhs, ">", rhs)).with("gte", () => eb(lhs, ">=", rhs)).with("not", () => eb.not(recurse(value))).with(P.union(...AGGREGATE_OPERATORS), (op2) => {
+        const innerResult = this.buildStandardFilter(eb, type, value, aggregate(eb, lhs, op2), getRhs, recurse, throwIfInvalid);
+        consumedKeys.push(...innerResult.consumedKeys);
+        return this.and(eb, ...innerResult.conditions);
+      }).otherwise(() => {
         if (throwIfInvalid) {
           throw new QueryError(`Invalid filter key: ${op}`);
         } else {
@@ -636,7 +662,7 @@ var BaseCrudDialect = class {
         if (key === "mode" || consumedKeys.includes(key)) {
           continue;
         }
-        const condition = match(key).with("contains", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`%${value}%`)) : eb(fieldRef, "like", sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`${value}%`)) : eb(fieldRef, "like", sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`%${value}`)) : eb(fieldRef, "like", sql.val(`%${value}`))).otherwise(() => {
+        const condition = match2(key).with("contains", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`%${value}%`)) : eb(fieldRef, "like", sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`${value}%`)) : eb(fieldRef, "like", sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`%${value}`)) : eb(fieldRef, "like", sql.val(`%${value}`))).otherwise(() => {
           throw new QueryError(`Invalid string filter key: ${key}`);
         });
         if (condition) {
@@ -717,9 +743,7 @@ var BaseCrudDialect = class {
           invariant(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
             invariant(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-            result = result.orderBy((eb) => eb.fn(field.slice(1), [
-              sql.ref(k)
-            ]), sql.raw(this.negateSort(v, negated)));
+            result = result.orderBy((eb) => aggregate(eb, sql.ref(`${modelAlias}.${k}`), field), sql.raw(this.negateSort(v, negated)));
           }
           continue;
         }
@@ -914,7 +938,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
         return value.map((v) => this.transformPrimitive(v, type, false));
       }
     } else {
-      return match2(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).with("Decimal", () => value !== null ? value.toString() : value).otherwise(() => value);
+      return match3(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).with("Decimal", () => value !== null ? value.toString() : value).otherwise(() => value);
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
@@ -1071,7 +1095,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
 // src/client/crud/dialects/sqlite.ts
 import { invariant as invariant3 } from "@zenstackhq/common-helpers";
 import { sql as sql3 } from "kysely";
-import { match as match3 } from "ts-pattern";
+import { match as match4 } from "ts-pattern";
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "SqliteCrudDialect");
@@ -1089,7 +1113,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       if (this.schema.typeDefs && type in this.schema.typeDefs) {
         return JSON.stringify(value);
       } else {
-        return match3(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
+        return match4(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
       }
     }
   }
@@ -1235,7 +1259,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
 
 // src/client/crud/dialects/index.ts
 function getCrudDialect(schema, options) {
-  return match4(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).exhaustive();
+  return match5(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).exhaustive();
 }
 __name(getCrudDialect, "getCrudDialect");
 
@@ -1560,17 +1584,17 @@ var ColumnCollector = class extends DefaultOperationNodeVisitor {
 // src/plugins/policy/expression-transformer.ts
 import { invariant as invariant5 } from "@zenstackhq/common-helpers";
 import { AliasNode as AliasNode2, BinaryOperationNode as BinaryOperationNode2, ColumnNode, expressionBuilder, FromNode, FunctionNode as FunctionNode2, IdentifierNode, OperatorNode as OperatorNode2, ReferenceNode as ReferenceNode2, SelectionNode, SelectQueryNode, TableNode as TableNode2, ValueListNode, ValueNode as ValueNode2, WhereNode } from "kysely";
-import { match as match6 } from "ts-pattern";
+import { match as match7 } from "ts-pattern";
 
 // src/plugins/policy/expression-evaluator.ts
 import { invariant as invariant4 } from "@zenstackhq/common-helpers";
-import { match as match5 } from "ts-pattern";
+import { match as match6 } from "ts-pattern";
 var ExpressionEvaluator = class {
   static {
     __name(this, "ExpressionEvaluator");
   }
   evaluate(expression, context) {
-    const result = match5(expression).when(ExpressionUtils.isArray, (expr2) => this.evaluateArray(expr2, context)).when(ExpressionUtils.isBinary, (expr2) => this.evaluateBinary(expr2, context)).when(ExpressionUtils.isField, (expr2) => this.evaluateField(expr2, context)).when(ExpressionUtils.isLiteral, (expr2) => this.evaluateLiteral(expr2)).when(ExpressionUtils.isMember, (expr2) => this.evaluateMember(expr2, context)).when(ExpressionUtils.isUnary, (expr2) => this.evaluateUnary(expr2, context)).when(ExpressionUtils.isCall, (expr2) => this.evaluateCall(expr2, context)).when(ExpressionUtils.isThis, () => context.thisValue).when(ExpressionUtils.isNull, () => null).exhaustive();
+    const result = match6(expression).when(ExpressionUtils.isArray, (expr2) => this.evaluateArray(expr2, context)).when(ExpressionUtils.isBinary, (expr2) => this.evaluateBinary(expr2, context)).when(ExpressionUtils.isField, (expr2) => this.evaluateField(expr2, context)).when(ExpressionUtils.isLiteral, (expr2) => this.evaluateLiteral(expr2)).when(ExpressionUtils.isMember, (expr2) => this.evaluateMember(expr2, context)).when(ExpressionUtils.isUnary, (expr2) => this.evaluateUnary(expr2, context)).when(ExpressionUtils.isCall, (expr2) => this.evaluateCall(expr2, context)).when(ExpressionUtils.isThis, () => context.thisValue).when(ExpressionUtils.isNull, () => null).exhaustive();
     return result ?? null;
   }
   evaluateCall(expr2, context) {
@@ -1581,7 +1605,7 @@ var ExpressionEvaluator = class {
     }
   }
   evaluateUnary(expr2, context) {
-    return match5(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
+    return match6(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
   }
   evaluateMember(expr2, context) {
     let val = this.evaluate(expr2.receiver, context);
@@ -1605,7 +1629,7 @@ var ExpressionEvaluator = class {
     }
     const left = this.evaluate(expr2.left, context);
     const right = this.evaluate(expr2.right, context);
-    return match5(expr2.op).with("==", () => left === right).with("!=", () => left !== right).with(">", () => left > right).with(">=", () => left >= right).with("<", () => left < right).with("<=", () => left <= right).with("&&", () => left && right).with("||", () => left || right).with("in", () => {
+    return match6(expr2.op).with("==", () => left === right).with("!=", () => left !== right).with(">", () => left > right).with(">=", () => left >= right).with("<", () => left < right).with("<=", () => left <= right).with("&&", () => left && right).with("||", () => left || right).with("in", () => {
       const _right = right ?? [];
       invariant4(Array.isArray(_right), 'expected array for "in" operator');
       return _right.includes(left);
@@ -1619,7 +1643,7 @@ var ExpressionEvaluator = class {
       return false;
     }
     invariant4(Array.isArray(left), "expected array");
-    return match5(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
+    return match6(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
       ...context,
       thisValue: item
     }))).with("!", () => left.every((item) => this.evaluate(expr2.right, {
@@ -1873,7 +1897,7 @@ var ExpressionTransformer = class {
     const count = FunctionNode2.create("count", [
       ValueNode2.createImmediate(1)
     ]);
-    const predicateResult = match6(expr2.op).with("?", () => BinaryOperationNode2.create(count, OperatorNode2.create(">"), ValueNode2.createImmediate(0))).with("!", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode2.createImmediate(0))).with("^", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode2.createImmediate(0))).exhaustive();
+    const predicateResult = match7(expr2.op).with("?", () => BinaryOperationNode2.create(count, OperatorNode2.create(">"), ValueNode2.createImmediate(0))).with("!", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode2.createImmediate(0))).with("^", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode2.createImmediate(0))).exhaustive();
     return this.transform(expr2.left, {
       ...context,
       memberSelect: SelectionNode.create(AliasNode2.create(predicateResult, IdentifierNode.create("$t"))),
@@ -1904,7 +1928,7 @@ var ExpressionTransformer = class {
     return BinaryOperationNode2.create(this.transform(expr2.operand, context), this.transformOperator("!="), trueNode(this.dialect));
   }
   transformOperator(op) {
-    const mappedOp = match6(op).with("==", () => "=").otherwise(() => op);
+    const mappedOp = match7(op).with("==", () => "=").otherwise(() => op);
     return OperatorNode2.create(mappedOp);
   }
   _call(expr2, context) {
@@ -2307,7 +2331,7 @@ var PolicyHandler = class extends OperationNodeTransformer {
     return disjunction(this.dialect, rows.map((row) => conjunction(this.dialect, idFields.map((field) => BinaryOperationNode3.create(ColumnNode2.create(field), OperatorNode3.create("="), ValueNode3.create(row[field]))))));
   }
   getMutationModel(node) {
-    const r = match7(node).when(InsertQueryNode.is, (node2) => getTableName(node2.into)).when(UpdateQueryNode.is, (node2) => getTableName(node2.table)).when(DeleteQueryNode.is, (node2) => {
+    const r = match8(node).when(InsertQueryNode.is, (node2) => getTableName(node2.into)).when(UpdateQueryNode.is, (node2) => getTableName(node2.table)).when(DeleteQueryNode.is, (node2) => {
       if (node2.from.froms.length !== 1) {
         throw new InternalError("Only one from table is supported for delete");
       }