@powersync/service-sync-rules 0.0.0-dev-20260129132348 → 0.0.0-dev-20260202103935

package/dist/compiler/expression.d.ts

@@ -0,0 +1,77 @@
+import { Expr, NodeLocation, PGNode } from 'pgsql-ast-parser';
+import { SourceResultSet } from './table.js';
+import { EqualsIgnoringResultSet } from './compatibility.js';
+import { StableHasher } from './equality.js';
+import { ConnectionParameterSource } from '../sync_plan/plan.js';
+import { SqlExpression } from '../sync_plan/expression.js';
+/**
+ * An analyzed SQL expression tracking dependencies on non-static data (i.e. rows or connection sources).
+ *
+ * Consider the sync stream `SELECT * FROM issues WHERE is_public OR auth.param('is_admin')`. To be able to explicitly
+ * track dependencies referenced in expressions, we transform them into a {@link SyncExpression}. For the `WHERE` clause
+ * in that example, the {@link sqlExpression} would be `?1 OR (?2 ->> 'is_admin')`, where `?1` is a {@link ColumnInRow}
+ * and `?2` is a {@link ConnectionParameter}.
+ *
+ * Once in this form, it's easy to reason about dependencies in expressions (used to later generate parameter match
+ * clauses) and to evaluate expressions at runtime (by preparing them as a statement and binding external values).
+ */
+export declare class SyncExpression implements EqualsIgnoringResultSet {
+    #private;
+    /**
+     * The AST node backing {@link sql}.
+     *
+     * We use this to be able to compose expressions, e.g. to possibly merge them.
+     */
+    readonly node: SqlExpression<ExpressionInput>;
+    readonly locations: NodeLocations;
+    /**
+     * The original expression, where references to row or connection parameters have been replaced with SQL variables
+     * that are tracked through {@link instantiation}.
+     *
+     * This is only used to compute hash codes and to check instances for equality. {@link node} is the canonical
+     * representation of this expression.
+     */
+    get sql(): string;
+    /**
+     * The values to instantiate parameters in {@link sqlExpression} with to retain original semantics of the
+     * expression.
+     */
+    get instantiation(): readonly ExpressionInput[];
+    get location(): NodeLocation;
+    constructor(
+    /**
+     * The AST node backing {@link sql}.
+     *
+     * We use this to be able to compose expressions, e.g. to possibly merge them.
+     */
+    node: SqlExpression<ExpressionInput>, locations: NodeLocations);
+    equalsAssumingSameResultSet(other: EqualsIgnoringResultSet): boolean;
+    assumingSameResultSetEqualityHashCode(hasher: StableHasher): void;
+}
+export type ExpressionInput = ColumnInRow | ConnectionParameter;
+export declare class ColumnInRow implements EqualsIgnoringResultSet {
+    readonly syntacticOrigin: Expr;
+    readonly resultSet: SourceResultSet;
+    readonly column: string;
+    constructor(syntacticOrigin: Expr, resultSet: SourceResultSet, column: string);
+    equalsAssumingSameResultSet(other: EqualsIgnoringResultSet): boolean;
+    assumingSameResultSetEqualityHashCode(hasher: StableHasher): void;
+}
+export declare class ConnectionParameter implements EqualsIgnoringResultSet {
+    readonly syntacticOrigin: Expr;
+    readonly source: ConnectionParameterSource;
+    constructor(syntacticOrigin: Expr, source: ConnectionParameterSource);
+    equalsAssumingSameResultSet(other: EqualsIgnoringResultSet): boolean;
+    assumingSameResultSetEqualityHashCode(hasher: StableHasher): void;
+}
+/**
+ * Tracks the original source location for translated {@link SqlExpression} nodes.
+ *
+ * We want to serialize translated expressions for sync plan, so embedding source offsets in them expands the size of
+ * sync plans and is tedious. We only need access to node locations while compiling sync streams, which we store in this
+ * in-memory map.
+ */
+export declare class NodeLocations {
+    readonly sourceForNode: Map<SqlExpression<unknown>, PGNode | NodeLocation>;
+    locationFor(source: SqlExpression<unknown>): NodeLocation;
+}

package/dist/compiler/expression.js

@@ -0,0 +1,122 @@
+import { equalsIgnoringResultSetList } from './compatibility.js';
+import { ExpressionToSqlite } from '../sync_plan/expression_to_sql.js';
+import { RecursiveExpressionVisitor } from '../sync_plan/expression_visitor.js';
+import { getLocation } from '../errors.js';
+/**
+ * An analyzed SQL expression tracking dependencies on non-static data (i.e. rows or connection sources).
+ *
+ * Consider the sync stream `SELECT * FROM issues WHERE is_public OR auth.param('is_admin')`. To be able to explicitly
+ * track dependencies referenced in expressions, we transform them into a {@link SyncExpression}. For the `WHERE` clause
+ * in that example, the {@link sqlExpression} would be `?1 OR (?2 ->> 'is_admin')`, where `?1` is a {@link ColumnInRow}
+ * and `?2` is a {@link ConnectionParameter}.
+ *
+ * Once in this form, it's easy to reason about dependencies in expressions (used to later generate parameter match
+ * clauses) and to evaluate expressions at runtime (by preparing them as a statement and binding external values).
+ */
+export class SyncExpression {
+    node;
+    locations;
+    #sql;
+    #instantiation;
+    /**
+     * The original expression, where references to row or connection parameters have been replaced with SQL variables
+     * that are tracked through {@link instantiation}.
+     *
+     * This is only used to compute hash codes and to check instances for equality. {@link node} is the canonical
+     * representation of this expression.
+     */
+    get sql() {
+        return (this.#sql ??= ExpressionToSqlite.toSqlite(this.node));
+    }
+    /**
+     * The values to instantiate parameters in {@link sqlExpression} with to retain original semantics of the
+     * expression.
+     */
+    get instantiation() {
+        if (this.#instantiation != null) {
+            return this.#instantiation;
+        }
+        const instantiation = [];
+        FindExternalData.instance.visit(this.node, instantiation);
+        return (this.#instantiation = instantiation);
+    }
+    get location() {
+        return this.locations.locationFor(this.node);
+    }
+    constructor(
+    /**
+     * The AST node backing {@link sql}.
+     *
+     * We use this to be able to compose expressions, e.g. to possibly merge them.
+     */
+    node, locations) {
+        this.node = node;
+        this.locations = locations;
+    }
+    equalsAssumingSameResultSet(other) {
+        return (other instanceof SyncExpression &&
+            other.sql == this.sql &&
+            equalsIgnoringResultSetList.equals(other.instantiation, this.instantiation));
+    }
+    assumingSameResultSetEqualityHashCode(hasher) {
+        hasher.addString(this.sql);
+        equalsIgnoringResultSetList.hash(hasher, this.instantiation);
+    }
+}
+class FindExternalData extends RecursiveExpressionVisitor {
+    defaultExpression(expr, arg) {
+        this.visitChildren(expr, arg);
+    }
+    visitExternalData(expr, arg) {
+        arg.push(expr.source);
+    }
+    static instance = new FindExternalData();
+}
+export class ColumnInRow {
+    syntacticOrigin;
+    resultSet;
+    column;
+    constructor(syntacticOrigin, resultSet, column) {
+        this.syntacticOrigin = syntacticOrigin;
+        this.resultSet = resultSet;
+        this.column = column;
+    }
+    equalsAssumingSameResultSet(other) {
+        return other instanceof ColumnInRow && other.column == this.column;
+    }
+    assumingSameResultSetEqualityHashCode(hasher) {
+        hasher.addString(this.column);
+    }
+}
+export class ConnectionParameter {
+    syntacticOrigin;
+    source;
+    constructor(syntacticOrigin, source) {
+        this.syntacticOrigin = syntacticOrigin;
+        this.source = source;
+    }
+    equalsAssumingSameResultSet(other) {
+        return other instanceof ConnectionParameter && other.source == this.source;
+    }
+    assumingSameResultSetEqualityHashCode(hasher) {
+        hasher.addString(this.source);
+    }
+}
+/**
+ * Tracks the original source location for translated {@link SqlExpression} nodes.
+ *
+ * We want to serialize translated expressions for sync plan, so embedding source offsets in them expands the size of
+ * sync plans and is tedious. We only need access to node locations while compiling sync streams, which we store in this
+ * in-memory map.
+ */
+export class NodeLocations {
+    sourceForNode = new Map();
+    locationFor(source) {
+        const location = getLocation(this.sourceForNode.get(source));
+        if (location == null) {
+            throw new Error('Missing location');
+        }
+        return location;
+    }
+}
+//# sourceMappingURL=expression.js.map

package/dist/compiler/expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.js","sourceRoot":"","sources":["../../src/compiler/expression.ts"],"names":[],"mappings":"AAEA,OAAO,EAA2B,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAI1F,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C;;;;;;;;;;GAUG;AACH,MAAM,OAAO,cAAc;IAuCd;IACA;IAvCX,IAAI,CAAU;IACd,cAAc,CAA8B;IAE5C;;;;;;OAMG;IACH,IAAI,GAAG;QACL,OAAO,CAAC,IAAI,CAAC,IAAI,KAAK,kBAAkB,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAChE,CAAC;IAED;;;OAGG;IACH,IAAI,aAAa;QACf,IAAI,IAAI,CAAC,cAAc,IAAI,IAAI,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC,cAAc,CAAC;QAC7B,CAAC;QAED,MAAM,aAAa,GAAsB,EAAE,CAAC;QAC5C,gBAAgB,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;QAC1D,OAAO,CAAC,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC,CAAC;IAC/C,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED;IACE;;;;OAIG;IACM,IAAoC,EACpC,SAAwB;QADxB,SAAI,GAAJ,IAAI,CAAgC;QACpC,cAAS,GAAT,SAAS,CAAe;IAChC,CAAC;IAEJ,2BAA2B,CAAC,KAA8B;QACxD,OAAO,CACL,KAAK,YAAY,cAAc;YAC/B,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG;YACrB,2BAA2B,CAAC,MAAM,CAAC,KAAK,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,CAC5E,CAAC;IACJ,CAAC;IAED,qCAAqC,CAAC,MAAoB;QACxD,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3B,2BAA2B,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;IAC/D,CAAC;CACF;AAED,MAAM,gBAAiB,SAAQ,0BAAoE;IACjG,iBAAiB,CAAC,IAAoC,EAAE,GAAsB;QAC5E,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAChC,CAAC;IAED,iBAAiB,CAAC,IAAmC,EAAE,GAAsB;QAC3E,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACxB,CAAC;IAED,MAAM,CAAU,QAAQ,GAAqB,IAAI,gBAAgB,EAAE,CAAC;;AAKtE,MAAM,OAAO,WAAW;IAEX;IACA;IACA;IAHX,YACW,eAAqB,EACrB,SAA0B,EAC1B,MAAc;QAFd,oBAAe,GAAf,eAAe,CAAM;QACrB,cAAS,GAAT,SAAS,CAAiB;QAC1B,WAAM,GAAN,MAAM,CAAQ;IACtB,CAAC;IAEJ,2BAA2B,CAAC,KAA8B;QACxD,OAAO,KAAK,YAAY,WAAW,IAAI,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC;IACrE,CAAC;IAED,qCAAqC,CAAC,MAAoB;QACxD,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;CACF;AAED,MAAM,OAAO,mBAAmB;IAEnB;IACA;IAFX,YACW,eAAqB,EACrB,MAAiC;QADjC,oBAAe,GAAf,eAAe,CAAM;QACrB,WAAM,GAAN,MAAM,CAA2B;IACzC,CAAC;IAEJ,2BAA2B,CAAC,KAA8B;QACxD,OAAO,KAAK,YAAY,mBAAmB,IAAI,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC;IAC7E,CAAC;IAED,qCAAqC,CAAC,MAAoB;QACxD,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,OAAO,aAAa;IACf,aAAa,GAAG,IAAI,GAAG,EAAiD,CAAC;IAElF,WAAW,CAAC,MAA8B;QACxC,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;QAC7D,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;QACtC,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF"}

package/dist/compiler/filter.d.ts

@@ -0,0 +1,71 @@
+import { NodeLocation } from 'pgsql-ast-parser';
+import { ExpressionInput, SyncExpression } from './expression.js';
+import { SourceResultSet } from './table.js';
+import { EqualsIgnoringResultSet } from './compatibility.js';
+import { StableHasher } from './equality.js';
+export interface Or {
+    terms: And[];
+}
+export interface And {
+    terms: BaseTerm[];
+}
+/**
+ * A boolean expression that doesn't have boolean operators with subexpressions referencing different tables in it.
+ *
+ * These basic terms form a filter by being composed into a distributive normal form. For analysis, we just need to know
+ * how terms from different tables relate to each other. So `users.id = auth.user_id() AND issues.is_public` need to be
+ * two terms in an {@link And}, but `users.is_deleted OR users.is_admin` can be represented as a single base term.
+ */
+export type BaseTerm = SingleDependencyExpression | EqualsClause;
+export declare function isBaseTerm(value: unknown): value is BaseTerm;
+/**
+ * A {@link SyncExpression} that only depends on a single result set or connection data.
+ */
+export declare class SingleDependencyExpression implements EqualsIgnoringResultSet {
+    readonly expression: SyncExpression;
+    /**
+     * The single result set on which the expression depends on.
+     *
+     * If null, the expression is allowed to depend on subscription parameters instead.
+     */
+    readonly resultSet: SourceResultSet | null;
+    /**
+     * Whether this expression depends on data derived from the connection or subscription.
+     */
+    readonly dependsOnConnection: boolean;
+    constructor(expression: SyncExpression | SingleDependencyExpression);
+    equalsAssumingSameResultSet(other: EqualsIgnoringResultSet): boolean;
+    assumingSameResultSetEqualityHashCode(hasher: StableHasher): void;
+    /**
+     * If all inputs have a single dependency, returns either the result set they all depend on or `null` and whether they
+     * depend on connection data.
+     *
+     * If the inputs have more than a single distinct dependency, returns null.
+     */
+    static extractSingleDependency(inputs: Iterable<ExpressionInput>): [SourceResultSet | null, boolean] | null;
+}
+/**
+ * A {@link SyncExpression} that only depends on data from a single row.
+ */
+export declare class RowExpression extends SingleDependencyExpression {
+    readonly resultSet: SourceResultSet;
+    constructor(expression: SyncExpression | SingleDependencyExpression);
+}
+/**
+ * A {@link SyncExpression} that only depends on connection data.
+ */
+export declare class RequestExpression extends SingleDependencyExpression {
+    constructor(expression: SyncExpression | SingleDependencyExpression);
+}
+/**
+ * An expression of the form `foo = bar`, where `foo` and `bar` are expressions allowed to depend on different sources.
+ */
+export declare class EqualsClause {
+    readonly left: SingleDependencyExpression;
+    readonly right: SingleDependencyExpression;
+    constructor(left: SingleDependencyExpression, right: SingleDependencyExpression);
+    get location(): NodeLocation | undefined;
+}
+export declare class InvalidExpressionError extends Error {
+    constructor(message: string);
+}

package/dist/compiler/filter.js

@@ -0,0 +1,110 @@
+import { ColumnInRow, SyncExpression } from './expression.js';
+import { expandNodeLocations } from '../errors.js';
+export function isBaseTerm(value) {
+    return value instanceof SingleDependencyExpression || value instanceof EqualsClause;
+}
+/**
+ * A {@link SyncExpression} that only depends on a single result set or connection data.
+ */
+export class SingleDependencyExpression {
+    expression;
+    /**
+     * The single result set on which the expression depends on.
+     *
+     * If null, the expression is allowed to depend on subscription parameters instead.
+     */
+    resultSet;
+    /**
+     * Whether this expression depends on data derived from the connection or subscription.
+     */
+    dependsOnConnection;
+    constructor(expression) {
+        if (expression instanceof SyncExpression) {
+            const checked = SingleDependencyExpression.extractSingleDependency(expression.instantiation);
+            if (checked == null) {
+                throw new InvalidExpressionError('Expression with multiple dependencies passed to SingleDependencyExpression');
+            }
+            this.expression = expression;
+            this.resultSet = checked[0];
+            this.dependsOnConnection = checked[1];
+        }
+        else {
+            this.expression = expression.expression;
+            this.resultSet = expression.resultSet;
+            this.dependsOnConnection = expression.dependsOnConnection;
+        }
+    }
+    equalsAssumingSameResultSet(other) {
+        return other instanceof SingleDependencyExpression && other.expression.equalsAssumingSameResultSet(this.expression);
+    }
+    assumingSameResultSetEqualityHashCode(hasher) {
+        this.expression.assumingSameResultSetEqualityHashCode(hasher);
+    }
+    /**
+     * If all inputs have a single dependency, returns either the result set they all depend on or `null` and whether they
+     * depend on connection data.
+     *
+     * If the inputs have more than a single distinct dependency, returns null.
+     */
+    static extractSingleDependency(inputs) {
+        let resultSet = null;
+        let hasSubscriptionDependency = false;
+        for (const dependency of inputs) {
+            if (dependency instanceof ColumnInRow) {
+                if ((resultSet != null && resultSet !== dependency.resultSet) || hasSubscriptionDependency) {
+                    return null;
+                }
+                resultSet = dependency.resultSet;
+            }
+            else {
+                if (resultSet != null) {
+                    return null;
+                }
+                hasSubscriptionDependency = true;
+            }
+        }
+        return [resultSet, hasSubscriptionDependency];
+    }
+}
+/**
+ * A {@link SyncExpression} that only depends on data from a single row.
+ */
+export class RowExpression extends SingleDependencyExpression {
+    constructor(expression) {
+        super(expression);
+        if (this.resultSet == null) {
+            throw new InvalidExpressionError('Does not depend on a single result set');
+        }
+    }
+}
+/**
+ * A {@link SyncExpression} that only depends on connection data.
+ */
+export class RequestExpression extends SingleDependencyExpression {
+    constructor(expression) {
+        super(expression);
+        if (this.resultSet != null) {
+            throw new InvalidExpressionError('Does not depend on connection data');
+        }
+    }
+}
+/**
+ * An expression of the form `foo = bar`, where `foo` and `bar` are expressions allowed to depend on different sources.
+ */
+export class EqualsClause {
+    left;
+    right;
+    constructor(left, right) {
+        this.left = left;
+        this.right = right;
+    }
+    get location() {
+        return expandNodeLocations([this.left.expression.location, this.right.expression.location]);
+    }
+}
+export class InvalidExpressionError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+//# sourceMappingURL=filter.js.map

package/dist/compiler/filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.js","sourceRoot":"","sources":["../../src/compiler/filter.ts"],"names":[],"mappings":"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"}

package/dist/compiler/filter_simplifier.d.ts

@@ -0,0 +1,26 @@
+import { Or } from './filter.js';
+import { NodeLocations } from './expression.js';
+import { BinaryOperator, SqlExpression } from '../sync_plan/expression.js';
+export declare class FilterConditionSimplifier {
+    simplifyOr(or: Or): Or;
+    private simplifyAnd;
+    /**
+     * Re-orders terms based on their dependencies, and then uses the given operator to merge expressions with the same
+     * dependency set.
+     *
+     * This is used to push boolean expressions down if they can be evaluated on the same table. For instance, the and
+     * terms `[row.foo, row.bar]` can be represented as a single base term `row.foo AND row.bar`. Pushing operators down
+     * into the expression generally reduces the complexity of the sync plan. In particular for `OR` terms, it can also
+     * reduce the amount of buckets since each term in an `OR` is implemented as another bucket.
+     */
+    private mergeByCommonDependencies;
+    private simplifyBase;
+    /**
+     * Reduces expressions through a chain of binary operators.
+     *
+     * For instance, `composeExpressions('AND', a, b, c)` returns `a AND b AND c` as a single expression. All expressions
+     * must have compatible dependencies.
+     */
+    private composeExpressions;
+}
+export declare function composeExpressionNodes<T>(locations: NodeLocations, operator: BinaryOperator, terms: SqlExpression<T>[]): SqlExpression<T>;

package/dist/compiler/filter_simplifier.js

@@ -0,0 +1,119 @@
+import { EqualsClause, isBaseTerm, SingleDependencyExpression } from './filter.js';
+import { SyncExpression } from './expression.js';
+import { expandNodeLocations } from '../errors.js';
+export class FilterConditionSimplifier {
+    simplifyOr(or) {
+        const andTerms = [];
+        let baseTerms = [];
+        for (const term of or.terms) {
+            const simplified = this.simplifyAnd(term);
+            if (isBaseTerm(simplified)) {
+                baseTerms.push(simplified);
+            }
+            else {
+                andTerms.push(simplified);
+            }
+        }
+        baseTerms = this.mergeByCommonDependencies('or', baseTerms);
+        for (const term of baseTerms) {
+            andTerms.push({ terms: [term] });
+        }
+        return { terms: andTerms };
+    }
+    simplifyAnd(and) {
+        const merged = this.mergeByCommonDependencies('and', and.terms);
+        if (merged.length == 1) {
+            return merged[0];
+        }
+        return { terms: merged };
+    }
+    /**
+     * Re-orders terms based on their dependencies, and then uses the given operator to merge expressions with the same
+     * dependency set.
+     *
+     * This is used to push boolean expressions down if they can be evaluated on the same table. For instance, the and
+     * terms `[row.foo, row.bar]` can be represented as a single base term `row.foo AND row.bar`. Pushing operators down
+     * into the expression generally reduces the complexity of the sync plan. In particular for `OR` terms, it can also
+     * reduce the amount of buckets since each term in an `OR` is implemented as another bucket.
+     */
+    mergeByCommonDependencies(operator, baseTerms) {
+        const byResultSet = new Map();
+        const noResultSet = [];
+        const rest = [];
+        for (const term of baseTerms) {
+            const simplified = this.simplifyBase(term);
+            if (simplified instanceof SingleDependencyExpression) {
+                if (simplified.resultSet != null) {
+                    if (byResultSet.has(simplified.resultSet)) {
+                        byResultSet.get(simplified.resultSet).push(simplified);
+                    }
+                    else {
+                        byResultSet.set(simplified.resultSet, [simplified]);
+                    }
+                }
+                else {
+                    noResultSet.push(simplified);
+                }
+            }
+            else {
+                rest.push(term);
+            }
+        }
+        const addMerged = (elements) => {
+            if (elements.length == 0) {
+                return;
+            }
+            rest.push(this.composeExpressions(operator, ...elements));
+        };
+        addMerged(noResultSet);
+        for (const terms of byResultSet.values()) {
+            addMerged(terms);
+        }
+        return rest;
+    }
+    simplifyBase(base) {
+        if (base instanceof EqualsClause) {
+            // If the left and right terms have shared dependencies, we shouldn't represent this as an equals clause. For
+            // instance, terms like `notes.state = 'public'` are generated as an equals clause initially but they can just be
+            // a row condition that is much cheaper to compute than a static bucket parameter. Similarly, `row.foo = row.bar`
+            // must be a row condition since it can't be represented as parameters that could be instantiated.
+            if (SingleDependencyExpression.extractSingleDependency([
+                ...base.left.expression.instantiation,
+                ...base.right.expression.instantiation
+            ])) {
+                return this.composeExpressions('=', base.left, base.right);
+            }
+        }
+        return base;
+    }
+    /**
+     * Reduces expressions through a chain of binary operators.
+     *
+     * For instance, `composeExpressions('AND', a, b, c)` returns `a AND b AND c` as a single expression. All expressions
+     * must have compatible dependencies.
+     */
+    composeExpressions(operator, ...terms) {
+        if (terms.length == 0) {
+            throw new Error("Can't compose zero expressions");
+        }
+        const locations = terms[0].expression.locations;
+        const inner = composeExpressionNodes(locations, operator, terms.map((t) => t.expression.node));
+        return new SingleDependencyExpression(new SyncExpression(inner, locations));
+    }
+}
+export function composeExpressionNodes(locations, operator, terms) {
+    if (terms.length == 0) {
+        throw new Error("Can't compose zero expressions");
+    }
+    const [first, ...rest] = terms;
+    let inner = first;
+    for (const additional of rest) {
+        inner = { type: 'binary', operator, left: inner, right: additional };
+    }
+    const location = expandNodeLocations(terms.map((e) => locations.locationFor(e)));
+    if (location) {
+        locations.sourceForNode.set(inner, location);
+    }
+    return inner;
+}
+//# sourceMappingURL=filter_simplifier.js.map

package/dist/compiler/filter_simplifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter_simplifier.js","sourceRoot":"","sources":["../../src/compiler/filter_simplifier.ts"],"names":[],"mappings":"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"}

package/dist/compiler/ir_to_sync_plan.d.ts

@@ -0,0 +1,37 @@
+import * as plan from '../sync_plan/plan.js';
+import { CompiledStreamQueries } from './compiler.js';
+export declare class CompilerModelToSyncPlan {
+    private static readonly evaluatorHash;
+    private mappedObjects;
+    private buckets;
+    /**
+     * Mapping of row evaluators to buckets.
+     *
+     * One might expect one stream to result in one bucket, but that is not generally the case. First, a stream might
+     * define multiple buckets. For instance, `SELECT * FROM notes WHERE notes.is_public OR auth.parameter('admin')`
+     * requires two buckets since there are different ways a row in `notes` might be synced (we have one bucket with
+     * public notes and one bucket of all notes, and then decide which ones a given user has access to by inspecting the
+     * token).
+     *
+     * Further, a stream might have multiple evaluators but only a single bucket. A stream with queries
+     * `SELECT * FROM foo` and `SELECT * FROM bar` is an example for that, we want to merge `foo` and `bar` into the same
+     * bucket in this case. This is represented by a {@link resolver.StreamResolver} having multiple evaluators attached
+     * to it.
+     *
+     * Finally, we may even be able to re-use buckets between streams. This is not possible in many cases, but can be done
+     * if e.g. one stream is `SELECT * FROM profiles WHERE user = auth.user_id()` and another one is
+     * `SELECT * FROM profiles WHERE user IN (SELECT member FROM orgs WHERE id = auth.parameter('org'))`. Because the
+     * partitioning on `profiles` is the same in both cases, it doesn't matter how the buckets are instantiated.
+     */
+    private evaluatorsToBuckets;
+    private translateStatefulObject;
+    translate(source: CompiledStreamQueries): plan.SyncPlan;
+    private createBucketSource;
+    private translatePartitionKey;
+    private translateRowEvaluator;
+    private translatePointLookup;
+    private translateExpression;
+    private translateStreamResolver;
+    private translateExpandingLookup;
+    private translateParameterValue;
+}