@powersync/service-sync-rules 0.29.9 → 0.30.0

package/dist/compiler/equality.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Stable value-based hashcodes for JavaScript. The sync streams compiler uses hashmaps derived from this to efficiently
+ * de-duplicate equivalent expressions and lookups.
+ *
+ * This is copied from Dart SDK sources, which in turn based the algorithm on Jenkins hash functions.
+ *
+ * Because hash codes are stable across restarts, they should not be used for untrusted inputs to avoid attacks
+ * provoking hash collisions and subpar hashmap performance. The sync rules package only uses these hashes to compile
+ * sync streams, but the compiled IR processing source rows does not need these hashes.
+ */
+export declare class StableHasher {
+    private static readonly seed;
+    private hash;
+    addHash(value: number): void;
+    reset(): number;
+    addString(value: string): void;
+    add(...e: Equatable[]): void;
+    buildHashCode(): number;
+    /**
+     * Hashes a value under the given equality implementation.
+     */
+    static hashWith<T>(equality: Equality<T>, value: T): number;
+    private static readonly hasher;
+    /**
+     * The default equality for {@link Equatable} types.
+     */
+    private static readonly defaultEquality;
+    static readonly defaultListEquality: Equality<Iterable<Equatable>>;
+}
+/**
+ * A generic equality relation on objects.
+ */
+export interface Equality<T> {
+    /**
+     * Checks whether a and b are equal according to this equality implementation.
+     *
+     * This must hold the usual properties for equality relations (reflexivity, symmetry and transitivety).
+     */
+    equals(a: T, b: T): boolean;
+    /**
+     * Adds a value to a stable hasher.
+     *
+     * The implementation of hashes must be compatible with {@link equals}, meaning that if values `a` and `b` are equal,
+     * they must also generate the same hash. Two distinct values may also generate the same hashcode though.
+     */
+    hash(hasher: StableHasher, value: T): void;
+}
+/**
+ * Interface for objects that have a logical default equality.
+ */
+export interface Equatable {
+    buildHash(hasher: StableHasher): void;
+    equals(other: unknown): boolean;
+}
+/**
+ * Creates an equality operator matching iterables with elements compared by an inner equality.
+ *
+ * Two iterables are considered equal if they contain the same elements in the same order.
+ */
+export declare function listEquality<E>(equality: Equality<E>): Equality<Iterable<E>>;
+/**
+ * Creates an equality operator matching iterables with elements compared by an inner equality.
+ *
+ * Two iterables are considered equal if they contain the same elements, in any order.
+ */
+export declare function unorderedEquality<E>(equality: Equality<E>): Equality<Iterable<E>>;
+/**
+ * A hash map implementation based on a custom {@link Equality}.
+ *
+ * Like {@link Map}, this implementation also preserves insertion-order.
+ */
+export declare class HashMap<K, V> {
+    private readonly equality;
+    private readonly map;
+    private first;
+    private last;
+    constructor(equality: Equality<K>);
+    private computeHashCode;
+    get isEmpty(): boolean;
+    get entries(): Iterable<[K, V]>;
+    private iterateEntries;
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    setOrUpdate(key: K, updater: (old: V | undefined, oldKey: K | undefined) => V): void;
+    putIfAbsent(key: K, ifAbsent: () => V): V;
+    private addEntryInBucket;
+}
+/**
+ * An insertion-order preserving hash set implementation based on {@link HashMap}.
+ */
+export declare class HashSet<K> implements Iterable<K> {
+    private readonly inner;
+    constructor(equality: Equality<K>);
+    [Symbol.iterator](): Iterator<K>;
+    private entries;
+    add(element: K): boolean;
+    getOrInsert(element: K): [K, boolean];
+    private static readonly sentinel;
+}

package/dist/compiler/equality.js

@@ -0,0 +1,284 @@
+/**
+ * Stable value-based hashcodes for JavaScript. The sync streams compiler uses hashmaps derived from this to efficiently
+ * de-duplicate equivalent expressions and lookups.
+ *
+ * This is copied from Dart SDK sources, which in turn based the algorithm on Jenkins hash functions.
+ *
+ * Because hash codes are stable across restarts, they should not be used for untrusted inputs to avoid attacks
+ * provoking hash collisions and subpar hashmap performance. The sync rules package only uses these hashes to compile
+ * sync streams, but the compiled IR processing source rows does not need these hashes.
+ */
+export class StableHasher {
+    static seed = 614160925; // 'PowerSync'.hashCode on the Dart VM
+    hash = StableHasher.seed;
+    addHash(value) {
+        let hash = 0x1fffffff & (this.hash + value);
+        hash = 0x1fffffff & (hash + ((0x0007ffff & hash) << 10));
+        this.hash = hash ^ (hash >> 6);
+    }
+    reset() {
+        const old = this.hash;
+        this.hash = StableHasher.seed;
+        return old;
+    }
+    addString(value) {
+        for (let i = 0; i < value.length; i++) {
+            this.addHash(value.charCodeAt(i));
+        }
+    }
+    add(...e) {
+        for (const param of e) {
+            param.buildHash(this);
+        }
+    }
+    buildHashCode() {
+        let hash = this.hash;
+        hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
+        hash = hash ^ (hash >> 11);
+        return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
+    }
+    /**
+     * Hashes a value under the given equality implementation.
+     */
+    static hashWith(equality, value) {
+        const saved = this.hasher.reset();
+        equality.hash(this.hasher, value);
+        const result = this.hasher.buildHashCode();
+        this.hasher.hash = saved;
+        return result;
+    }
+    static hasher = new StableHasher();
+    /**
+     * The default equality for {@link Equatable} types.
+     */
+    static defaultEquality = {
+        hash(hasher, value) {
+            value.buildHash(hasher);
+        },
+        equals(a, b) {
+            return a.equals(b);
+        }
+    };
+    static defaultListEquality = listEquality(this.defaultEquality);
+}
+/**
+ * Creates an equality operator matching iterables with elements compared by an inner equality.
+ *
+ * Two iterables are considered equal if they contain the same elements in the same order.
+ */
+export function listEquality(equality) {
+    return {
+        equals: (a, b) => {
+            if (a === b)
+                return true;
+            const iteratorA = a[Symbol.iterator]();
+            const iteratorB = b[Symbol.iterator]();
+            while (true) {
+                let nextA = iteratorA.next();
+                let nextB = iteratorB.next();
+                if (nextA.done != nextB.done) {
+                    return false; // Different lengths
+                }
+                else if (nextA.done) {
+                    return true; // Both done
+                }
+                else {
+                    const elementA = nextA.value;
+                    const elementB = nextB.value;
+                    if (!equality.equals(elementA, elementB)) {
+                        return false;
+                    }
+                }
+            }
+        },
+        hash: (hasher, value) => {
+            for (const e of value) {
+                equality.hash(hasher, e);
+            }
+        }
+    };
+}
+/**
+ * Creates an equality operator matching iterables with elements compared by an inner equality.
+ *
+ * Two iterables are considered equal if they contain the same elements, in any order.
+ */
+export function unorderedEquality(equality) {
+    return {
+        equals: (a, b) => {
+            if (a === b)
+                return true;
+            let counts = new HashMap(equality);
+            let length = 0;
+            // Count how often each element exists in a.
+            for (const e of a) {
+                counts.setOrUpdate(e, (old) => (old ?? 0) + 1);
+                length++;
+            }
+            // Then compare with b.
+            for (const e of b) {
+                let matched = false;
+                counts.setOrUpdate(e, (old) => {
+                    matched = old != null && old > 0;
+                    if (matched) {
+                        return old - 1;
+                    }
+                    else {
+                        return 0;
+                    }
+                });
+                if (!matched) {
+                    return false;
+                }
+                length--;
+            }
+            return length == 0;
+        },
+        hash: (hasher, value) => {
+            // https://github.com/dart-lang/core/blob/3e55c1ce7be48b469da5be043b5931fe6405f74a/pkgs/collection/lib/src/equality.dart#L236-L248
+            let hash = 0;
+            for (const element of value) {
+                hash = (hash + StableHasher.hashWith(equality, element)) & 0x7fffffff;
+            }
+            hasher.addHash(hash);
+        }
+    };
+}
+/**
+ * A hash map implementation based on a custom {@link Equality}.
+ *
+ * Like {@link Map}, this implementation also preserves insertion-order.
+ */
+export class HashMap {
+    equality;
+    // We create one bucket per unique hash, and then store collisions in an array.
+    map = new Map();
+    first;
+    last;
+    constructor(equality) {
+        this.equality = equality;
+    }
+    computeHashCode(key) {
+        return StableHasher.hashWith(this.equality, key);
+    }
+    get isEmpty() {
+        return this.first == null;
+    }
+    get entries() {
+        return this.iterateEntries();
+    }
+    *iterateEntries() {
+        let next = this.first;
+        while (next != null) {
+            yield [next.key, next.value];
+            next = next.next;
+        }
+    }
+    get(key) {
+        const hashCode = this.computeHashCode(key);
+        const bucket = this.map.get(hashCode);
+        if (bucket) {
+            for (const entry of bucket) {
+                if (this.equality.equals(entry.key, key)) {
+                    return entry.value;
+                }
+            }
+        }
+    }
+    set(key, value) {
+        const hashCode = this.computeHashCode(key);
+        let bucket = this.map.get(hashCode);
+        if (!bucket) {
+            bucket = [];
+            this.map.set(hashCode, bucket);
+        }
+        this.addEntryInBucket(bucket, key, value);
+    }
+    setOrUpdate(key, updater) {
+        const hashCode = this.computeHashCode(key);
+        let bucket = this.map.get(hashCode);
+        if (!bucket) {
+            bucket = [];
+            this.map.set(hashCode, bucket);
+        }
+        else {
+            for (const entry of bucket) {
+                if (this.equality.equals(entry.key, key)) {
+                    entry.value = updater(entry.value, entry.key);
+                    return;
+                }
+            }
+        }
+        this.addEntryInBucket(bucket, key, updater(undefined, undefined));
+    }
+    putIfAbsent(key, ifAbsent) {
+        let result = undefined;
+        this.setOrUpdate(key, (old) => {
+            if (old == null) {
+                return (result = ifAbsent());
+            }
+            else {
+                return (result = old);
+            }
+        });
+        return result;
+    }
+    addEntryInBucket(bucket, key, value) {
+        const entry = new LinkedHashMapEntry(key, value);
+        bucket.push(entry);
+        if (this.first) {
+            this.last.next = entry;
+            entry.prev = this.last;
+            this.last = entry;
+        }
+        else {
+            this.first = this.last = entry;
+        }
+    }
+}
+/**
+ * An insertion-order preserving hash set implementation based on {@link HashMap}.
+ */
+export class HashSet {
+    inner;
+    constructor(equality) {
+        this.inner = new HashMap(equality);
+    }
+    [Symbol.iterator]() {
+        return this.entries()[Symbol.iterator]();
+    }
+    *entries() {
+        for (const [k, _] of this.inner.entries) {
+            yield k;
+        }
+    }
+    add(element) {
+        return this.getOrInsert(element)[1];
+    }
+    getOrInsert(element) {
+        let result = null;
+        this.inner.setOrUpdate(element, (old, oldKey) => {
+            if (oldKey == null) {
+                result = [element, true];
+                return HashSet.sentinel;
+            }
+            else {
+                result = [oldKey, false];
+                return oldKey;
+            }
+        });
+        return result;
+    }
+    static sentinel = new Object();
+}
+class LinkedHashMapEntry {
+    key;
+    prev;
+    next;
+    value;
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+}
+//# sourceMappingURL=equality.js.map

package/dist/compiler/equality.js.map

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

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":"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"}

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);
+}