@powersync/service-sync-rules 0.29.10 → 0.31.0

package/dist/compiler/bucket_resolver.js

@@ -0,0 +1,131 @@
+import { HashSet, StableHasher } from './equality.js';
+import { equalsIgnoringResultSetList, equalsIgnoringResultSetUnordered } from './compatibility.js';
+/**
+ * Describes how to resolve a subscription to buckets.
+ */
+export class StreamResolver {
+    options;
+    requestFilters;
+    lookupStages;
+    resolvedBucket;
+    uniqueName;
+    constructor(options, requestFilters, lookupStages, resolvedBucket, uniqueName) {
+        this.options = options;
+        this.requestFilters = requestFilters;
+        this.lookupStages = lookupStages;
+        this.resolvedBucket = resolvedBucket;
+        this.uniqueName = uniqueName;
+    }
+    buildInstantiationHash(hasher) {
+        equalsIgnoringResultSetUnordered.hash(hasher, this.requestFilters);
+        this.resolvedBucket.buildInstantiationHash(hasher);
+    }
+    hasIdenticalInstantiation(other) {
+        if (other.options != this.options) {
+            return false;
+        }
+        if (!equalsIgnoringResultSetUnordered.equals(other.requestFilters, this.requestFilters)) {
+            return false;
+        }
+        return other.resolvedBucket.hasIdenticalInstantiation(this.resolvedBucket);
+    }
+}
+export class ParameterLookup {
+    lookup;
+    instantiation;
+    constructor(lookup, instantiation) {
+        this.lookup = lookup;
+        this.instantiation = instantiation;
+    }
+    buildHash(hasher) {
+        hasher.addHash(this.lookup.behaviorHashCode);
+        hasher.add(...this.instantiation);
+    }
+    equals(other) {
+        return (other instanceof ParameterLookup &&
+            other.lookup.behavesIdenticalTo(this.lookup) &&
+            StableHasher.defaultListEquality.equals(other.instantiation, this.instantiation));
+    }
+}
+export class EvaluateTableValuedFunction {
+    tableValuedFunction;
+    outputs;
+    filters;
+    constructor(tableValuedFunction, outputs, filters) {
+        this.tableValuedFunction = tableValuedFunction;
+        this.outputs = outputs;
+        this.filters = filters;
+    }
+    buildHash(hasher) {
+        this.tableValuedFunction.buildBehaviorHashCode(hasher);
+        equalsIgnoringResultSetList.hash(hasher, this.outputs);
+        equalsIgnoringResultSetList.hash(hasher, this.filters);
+    }
+    equals(other) {
+        return (other instanceof EvaluateTableValuedFunction &&
+            other.tableValuedFunction.behavesIdenticalTo(this.tableValuedFunction) &&
+            equalsIgnoringResultSetList.equals(other.outputs, this.outputs) &&
+            equalsIgnoringResultSetList.equals(other.filters, this.filters));
+    }
+}
+export class ResolveBucket {
+    instantiation;
+    evaluators = new HashSet({
+        hash: (hasher, value) => value.buildBehaviorHashCode(hasher),
+        equals: (a, b) => a.behavesIdenticalTo(b)
+    });
+    constructor(evaluator, instantiation) {
+        this.instantiation = instantiation;
+        this.evaluators.add(evaluator);
+    }
+    buildInstantiationHash(hasher) {
+        hasher.add(...this.instantiation);
+    }
+    hasIdenticalInstantiation(other) {
+        return StableHasher.defaultListEquality.equals(other.instantiation, this.instantiation);
+    }
+}
+/**
+ * A value derived from request data.
+ */
+export class RequestParameterValue {
+    expression;
+    constructor(expression) {
+        this.expression = expression;
+    }
+    buildHash(hasher) {
+        this.expression.assumingSameResultSetEqualityHashCode(hasher);
+    }
+    equals(other) {
+        return other instanceof RequestParameterValue && other.expression.equalsAssumingSameResultSet(this.expression);
+    }
+}
+export class LookupResultParameterValue {
+    resultIndex;
+    lookup; // Set lazily
+    constructor(resultIndex) {
+        this.resultIndex = resultIndex;
+    }
+    buildHash(hasher) {
+        this.lookup?.buildHash(hasher);
+        hasher.addHash(this.resultIndex);
+    }
+    equals(other) {
+        return (other instanceof LookupResultParameterValue &&
+            other.lookup.equals(this.lookup) &&
+            other.resultIndex == this.resultIndex);
+    }
+}
+export class IntersectionParameterValue {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    buildHash(hasher) {
+        hasher.add(...this.inner);
+    }
+    equals(other) {
+        return (other instanceof IntersectionParameterValue && StableHasher.defaultListEquality.equals(other.inner, this.inner));
+    }
+}
+//# sourceMappingURL=bucket_resolver.js.map

package/dist/compiler/bucket_resolver.js.map

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

package/dist/compiler/compatibility.d.ts

@@ -0,0 +1,16 @@
+import { Equality, StableHasher } from './equality.js';
+/**
+ * Interface for structures that can be compared for equality in a way that ignores referenced result set.
+ *
+ * This is primarily used to compare expressions across streams. If we have two streams defined as
+ * `SELECT * FROM users WHERE id = ...` , the `id` column would not be equal between those since it references a the
+ * logical `users` table added to each individual statement. But if we are in a context where we know the physical table
+ * is the same, this allows comparing expressions for equality.
+ */
+export interface EqualsIgnoringResultSet {
+    equalsAssumingSameResultSet(other: EqualsIgnoringResultSet): boolean;
+    assumingSameResultSetEqualityHashCode(hasher: StableHasher): void;
+}
+export declare const equalsIgnoringResultSet: Equality<EqualsIgnoringResultSet>;
+export declare const equalsIgnoringResultSetList: Equality<Iterable<EqualsIgnoringResultSet>>;
+export declare const equalsIgnoringResultSetUnordered: Equality<Iterable<EqualsIgnoringResultSet>>;

package/dist/compiler/compatibility.js

@@ -0,0 +1,12 @@
+import { listEquality } from './equality.js';
+export const equalsIgnoringResultSet = {
+    equals: function (a, b) {
+        return a.equalsAssumingSameResultSet(b);
+    },
+    hash: function (hasher, value) {
+        return value.assumingSameResultSetEqualityHashCode(hasher);
+    }
+};
+export const equalsIgnoringResultSetList = listEquality(equalsIgnoringResultSet);
+export const equalsIgnoringResultSetUnordered = listEquality(equalsIgnoringResultSet);
+//# sourceMappingURL=compatibility.js.map

package/dist/compiler/compatibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compatibility.js","sourceRoot":"","sources":["../../src/compiler/compatibility.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,YAAY,EAAgB,MAAM,eAAe,CAAC;AAerE,MAAM,CAAC,MAAM,uBAAuB,GAAsC;IACxE,MAAM,EAAE,UAAU,CAA0B,EAAE,CAA0B;QACtE,OAAO,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC;IAC1C,CAAC;IACD,IAAI,EAAE,UAAU,MAAoB,EAAE,KAA8B;QAClE,OAAO,KAAK,CAAC,qCAAqC,CAAC,MAAM,CAAC,CAAC;IAC7D,CAAC;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAG,YAAY,CAAC,uBAAuB,CAAC,CAAC;AACjF,MAAM,CAAC,MAAM,gCAAgC,GAAG,YAAY,CAAC,uBAAuB,CAAC,CAAC"}

package/dist/compiler/compiler.d.ts

@@ -0,0 +1,110 @@
+import { NodeLocation, PGNode } from 'pgsql-ast-parser';
+import { PointLookup, RowEvaluator } from './rows.js';
+import { StreamResolver } from './bucket_resolver.js';
+import { StreamOptions, SyncPlan } from '../sync_plan/plan.js';
+import { PreparedSubquery } from './sqlite.js';
+import { SourceSchema } from '../types.js';
+export interface SyncStreamsCompilerOptions {
+    /**
+     * Used exclusively for linting against the given {@link schema}.
+     *
+     * The default schema must not affect compiled sync plans because sync plans can be loaded with different default
+     * schemas.
+     */
+    defaultSchema?: string;
+    /**
+     * An optional schema, used exclusively for linting table and column references that can't be resolved in it.
+     *
+     * Sync streams compile to the same plan regardless of the assumed schema, and it's possible to reuse compiled sync
+     * streams across schema changes.
+     */
+    schema?: SourceSchema;
+}
+/**
+ * State for compiling sync streams.
+ *
+ * The output of compiling all sync streams is a {@link SyncPlan}, a declarative description of the sync process that
+ * can be serialized to bucket storage. The compiler stores a mutable intermediate representation that is essentially a
+ * copy of the sync plan, except that we're using JavaScript classes with methods to compute hash codes and equality
+ * relations. This allows the compiler to efficiently de-duplicate parameters and buckets.
+ *
+ * Overall, the compilation process is as follows: Each data query for a stream is first parsed by
+ * {@link StreamQueryParser} into a canonicalized intermediate representation (see that class for details).
+ * Then, {@link QuerierGraphBuilder} analyzes a chain of `AND` expressions to identify parameters (as partition keys)
+ * and their instantiation, as well as static filters that need to be added to reach row.
+ */
+export declare class SyncStreamsCompiler {
+    readonly options: SyncStreamsCompilerOptions;
+    readonly output: CompiledStreamQueries;
+    private readonly locations;
+    constructor(options: SyncStreamsCompilerOptions);
+    /**
+     * Tries to parse the SQL query as a `SELECT` statement into a form supported for common table expressions.
+     *
+     * Common table expressions are parsed and validated independently and without a shared scope, meaning that CTEs are
+     * not allowed to reference other CTEs. This limitation is deliberate, but we _could_ support it (referenced CTEs
+     * would just get inlined into the new CTE by the parser). So we can revisit this and potentially support that in the
+     * future.
+     *
+     * Returns null and reports errors if that fails.
+     */
+    commonTableExpression(sql: string, errors: ParsingErrorListener): PreparedSubquery | null;
+    /**
+     * Utility for compiling a sync stream.
+     *
+     * @param options Name, priority and `auto_subscribe` state for the stream.
+     */
+    stream(options: StreamOptions): IndividualSyncStreamCompiler;
+}
+/**
+ * Utility for compiling a single sync stream.
+ */
+export interface IndividualSyncStreamCompiler {
+    /**
+     * Makes a common table expression prepared through {@link SyncStreamsCompiler.commonTableExpression} available when
+     * parsing queries for this stream.
+     */
+    registerCommonTableExpression(name: string, cte: PreparedSubquery): void;
+    /**
+     * Validates and adds a parameter query to this stream.
+     *
+     * @param sql The SQL query to add.
+     * @param errors An error reporter associating source positions with the current SQL source.
+     */
+    addQuery(sql: string, errors: ParsingErrorListener): void;
+    /**
+     * Merges added queries into compatible bucket groups and adds them to the compiled sync plan.
+     */
+    finish(): void;
+}
+/**
+ * Something reporting errors.
+ *
+ * While sync streams can be made up of multiple SQL statements from different YAML strings, we want to be able to
+ * accurately describe the source of an error in YAML when we report it.
+ *
+ * So, every transformation that might need to report errors receives an instance of this interface which implicitly
+ * binds errors to one specific SQL string.
+ */
+export interface ParsingErrorListener {
+    report(message: string, location: NodeLocation | PGNode, options?: {
+        isWarning: boolean;
+    }): void;
+}
+/**
+ * A mutable collection of resources (row evaluators, point lookups and stream resolvers) created for all streams in a
+ * definition file.
+ */
+export declare class CompiledStreamQueries {
+    private readonly _evaluators;
+    private readonly _pointLookups;
+    readonly resolvers: StreamResolver[];
+    get evaluators(): RowEvaluator[];
+    get pointLookups(): PointLookup[];
+    canonicalizeEvaluator(evaluator: RowEvaluator): RowEvaluator;
+    canonicalizePointLookup(lookup: PointLookup): PointLookup;
+    /**
+     * @returns A sync plan representing an immutable snapshot of this intermediate representation.
+     */
+    toSyncPlan(): SyncPlan;
+}

package/dist/compiler/compiler.js

@@ -0,0 +1,130 @@
+import { parse } from 'pgsql-ast-parser';
+import { HashSet } from './equality.js';
+import { CompilerModelToSyncPlan } from './ir_to_sync_plan.js';
+import { QuerierGraphBuilder } from './querier_graph.js';
+import { StreamQueryParser } from './parser.js';
+import { NodeLocations } from './expression.js';
+import { SqlScope } from './scope.js';
+/**
+ * State for compiling sync streams.
+ *
+ * The output of compiling all sync streams is a {@link SyncPlan}, a declarative description of the sync process that
+ * can be serialized to bucket storage. The compiler stores a mutable intermediate representation that is essentially a
+ * copy of the sync plan, except that we're using JavaScript classes with methods to compute hash codes and equality
+ * relations. This allows the compiler to efficiently de-duplicate parameters and buckets.
+ *
+ * Overall, the compilation process is as follows: Each data query for a stream is first parsed by
+ * {@link StreamQueryParser} into a canonicalized intermediate representation (see that class for details).
+ * Then, {@link QuerierGraphBuilder} analyzes a chain of `AND` expressions to identify parameters (as partition keys)
+ * and their instantiation, as well as static filters that need to be added to reach row.
+ */
+export class SyncStreamsCompiler {
+    options;
+    output = new CompiledStreamQueries();
+    locations = new NodeLocations();
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Tries to parse the SQL query as a `SELECT` statement into a form supported for common table expressions.
+     *
+     * Common table expressions are parsed and validated independently and without a shared scope, meaning that CTEs are
+     * not allowed to reference other CTEs. This limitation is deliberate, but we _could_ support it (referenced CTEs
+     * would just get inlined into the new CTE by the parser). So we can revisit this and potentially support that in the
+     * future.
+     *
+     * Returns null and reports errors if that fails.
+     */
+    commonTableExpression(sql, errors) {
+        const parser = new StreamQueryParser({
+            compiler: this,
+            originalText: sql,
+            locations: this.locations,
+            parentScope: new SqlScope({}),
+            errors
+        });
+        const stmt = tryParse(sql, errors);
+        if (stmt == null) {
+            return null;
+        }
+        return parser.parseAsSubquery(stmt);
+    }
+    /**
+     * Utility for compiling a sync stream.
+     *
+     * @param options Name, priority and `auto_subscribe` state for the stream.
+     */
+    stream(options) {
+        const builder = new QuerierGraphBuilder(this, options);
+        const rootScope = new SqlScope({});
+        return {
+            registerCommonTableExpression: (name, cte) => {
+                rootScope.registerCommonTableExpression(name, cte);
+            },
+            addQuery: (sql, errors) => {
+                const stmt = tryParse(sql, errors);
+                if (stmt == null) {
+                    return;
+                }
+                const parser = new StreamQueryParser({
+                    compiler: this,
+                    originalText: sql,
+                    locations: this.locations,
+                    parentScope: rootScope,
+                    errors
+                });
+                const query = parser.parse(stmt);
+                if (query) {
+                    builder.process(query, errors);
+                }
+            },
+            finish: () => builder.finish()
+        };
+    }
+}
+function tryParse(sql, errors) {
+    try {
+        const [stmt] = parse(sql, { locationTracking: true });
+        return stmt;
+    }
+    catch (e) {
+        const location = e.token?._location;
+        errors.report(e.message, location ?? { start: 0, end: sql.length });
+        return null;
+    }
+}
+/**
+ * A mutable collection of resources (row evaluators, point lookups and stream resolvers) created for all streams in a
+ * definition file.
+ */
+export class CompiledStreamQueries {
+    _evaluators = new HashSet({
+        hash: (hasher, value) => value.buildBehaviorHashCode(hasher),
+        equals: (a, b) => a.behavesIdenticalTo(b)
+    });
+    _pointLookups = new HashSet({
+        hash: (hasher, value) => value.buildBehaviorHashCode(hasher),
+        equals: (a, b) => a.behavesIdenticalTo(b)
+    });
+    resolvers = [];
+    get evaluators() {
+        return [...this._evaluators];
+    }
+    get pointLookups() {
+        return [...this._pointLookups];
+    }
+    canonicalizeEvaluator(evaluator) {
+        return this._evaluators.getOrInsert(evaluator)[0];
+    }
+    canonicalizePointLookup(lookup) {
+        return this._pointLookups.getOrInsert(lookup)[0];
+    }
+    /**
+     * @returns A sync plan representing an immutable snapshot of this intermediate representation.
+     */
+    toSyncPlan() {
+        const translator = new CompilerModelToSyncPlan();
+        return translator.translate(this);
+    }
+}
+//# sourceMappingURL=compiler.js.map

package/dist/compiler/compiler.js.map

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

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