@powersync/service-core 0.0.0-dev-20240620165206

package/dist/routes/routes-index.d.ts

@@ -0,0 +1,6 @@
+export * as auth from './auth.js';
+export * as endpoints from './endpoints/route-endpoints-index.js';
+export * as hooks from './hooks.js';
+export * from './route-register.js';
+export * from './router-socket.js';
+export * from './router.js';

package/dist/routes/routes-index.js

@@ -0,0 +1,7 @@
+export * as auth from './auth.js';
+export * as endpoints from './endpoints/route-endpoints-index.js';
+export * as hooks from './hooks.js';
+export * from './route-register.js';
+export * from './router-socket.js';
+export * from './router.js';
+//# sourceMappingURL=routes-index.js.map

package/dist/routes/routes-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-index.js","sourceRoot":"","sources":["../../src/routes/routes-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,SAAS,MAAM,sCAAsC,CAAC;AAClE,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC"}

package/dist/runner/teardown.d.ts

@@ -0,0 +1,2 @@
+import * as utils from '../util/util-index.js';
+export declare function teardown(runnerConfig: utils.RunnerConfig): Promise<void>;

package/dist/runner/teardown.js

@@ -0,0 +1,94 @@
+// Script to tear down the data when deleting an instance.
+// This deletes:
+// 1. The replication slots on the source postgres instance (if available).
+// 2. The mongo database.
+import * as timers from 'timers/promises';
+import * as db from '../db/db-index.js';
+import * as storage from '../storage/storage-index.js';
+import * as utils from '../util/util-index.js';
+import * as replication from '../replication/replication-index.js';
+import { logger } from '@powersync/lib-services-framework';
+/**
+ * Attempt to terminate a single sync rules instance.
+ *
+ * This may fail with a lock error.
+ */
+async function terminateReplicator(storageFactory, connection, syncRules) {
+    // The lock may still be active if the current replication instance
+    // hasn't stopped yet.
+    const lock = await syncRules.lock();
+    try {
+        const parsed = syncRules.parsed();
+        const storage = storageFactory.getInstance(parsed);
+        const stream = new replication.WalStreamRunner({
+            factory: storageFactory,
+            storage: storage,
+            source_db: connection,
+            lock
+        });
+        logger.info(`Terminating replication slot ${stream.slot_name}`);
+        await stream.terminate();
+        logger.info(`Terminated replication slot ${stream.slot_name}`);
+    }
+    finally {
+        await lock.release();
+    }
+}
+/**
+ * Terminate all replicating sync rules, deleting the replication slots.
+ *
+ * Retries lock and other errors for up to two minutes.
+ *
+ * This is a best-effot attempt. In some cases it may not be possible to delete the replication
+ * slot, such as when the postgres instance is unreachable.
+ */
+async function terminateReplicators(storageFactory, connection) {
+    const start = Date.now();
+    while (Date.now() - start < 12000) {
+        let retry = false;
+        const replicationRules = await storageFactory.getReplicatingSyncRules();
+        for (let syncRules of replicationRules) {
+            try {
+                await terminateReplicator(storageFactory, connection, syncRules);
+            }
+            catch (e) {
+                retry = true;
+                console.error(e);
+                logger.warn(`Failed to terminate ${syncRules.slot_name}`, e);
+            }
+        }
+        if (!retry) {
+            break;
+        }
+        await timers.setTimeout(5000);
+    }
+}
+export async function teardown(runnerConfig) {
+    const config = await utils.loadConfig(runnerConfig);
+    const mongoDB = storage.createPowerSyncMongo(config.storage);
+    try {
+        logger.info(`Waiting for auth`);
+        await db.mongo.waitForAuth(mongoDB.db);
+        const bucketStorage = new storage.MongoBucketStorage(mongoDB, { slot_name_prefix: config.slot_name_prefix });
+        const connection = config.connection;
+        logger.info(`Terminating replication slots`);
+        if (connection) {
+            await terminateReplicators(bucketStorage, connection);
+        }
+        const database = mongoDB.db;
+        logger.info(`Dropping database ${database.namespace}`);
+        await database.dropDatabase();
+        logger.info(`Done`);
+        await mongoDB.client.close();
+        // If there was an error connecting to postgress, the process may stay open indefinitely.
+        // This forces an exit.
+        // We do not consider those errors a teardown failure.
+        process.exit(0);
+    }
+    catch (e) {
+        logger.error(`Teardown failure`, e);
+        await mongoDB.client.close();
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=teardown.js.map

package/dist/runner/teardown.js.map

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

package/dist/storage/BucketStorage.d.ts

@@ -0,0 +1,307 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EvaluatedParameters, EvaluatedRow, SqlSyncRules, SqliteJsonRow, SqliteJsonValue, SqliteRow, ToastableSqliteRow } from '@powersync/service-sync-rules';
+import * as replication from '../replication/replication-index.js';
+import * as util from '../util/util-index.js';
+import { SourceTable } from './SourceTable.js';
+export interface BucketStorageFactory {
+    /**
+     * Update sync rules from configuration, if changed.
+     */
+    configureSyncRules(sync_rules: string, options?: {
+        lock?: boolean;
+    }): Promise<{
+        updated: boolean;
+        persisted_sync_rules?: PersistedSyncRulesContent;
+        lock?: ReplicationLock;
+    }>;
+    /**
+     * Get a storage instance to query sync data for specific sync rules.
+     */
+    getInstance(options: PersistedSyncRules): SyncRulesBucketStorage;
+    /**
+     * Deploy new sync rules.
+     */
+    updateSyncRules(options: UpdateSyncRulesOptions): Promise<PersistedSyncRulesContent>;
+    /**
+     * Indicate that a slot was removed, and we should re-sync by creating
+     * a new sync rules instance.
+     *
+     * This is roughly the same as deploying a new version of the current sync
+     * rules, but also accounts for cases where the current sync rules are not
+     * the latest ones.
+     *
+     * Replication should be restarted after this.
+     *
+     * @param slot_name The removed slot
+     */
+    slotRemoved(slot_name: string): Promise<void>;
+    /**
+     * Get the sync rules used for querying.
+     */
+    getActiveSyncRules(): Promise<PersistedSyncRules | null>;
+    /**
+     * Get the sync rules used for querying.
+     */
+    getActiveSyncRulesContent(): Promise<PersistedSyncRulesContent | null>;
+    /**
+     * Get the sync rules that will be active next once done with initial replicatino.
+     */
+    getNextSyncRules(): Promise<PersistedSyncRules | null>;
+    /**
+     * Get the sync rules that will be active next once done with initial replicatino.
+     */
+    getNextSyncRulesContent(): Promise<PersistedSyncRulesContent | null>;
+    /**
+     * Get all sync rules currently replicating. Typically this is the "active" and "next" sync rules.
+     */
+    getReplicatingSyncRules(): Promise<PersistedSyncRulesContent[]>;
+    /**
+     * Get all sync rules stopped but not terminated yet.
+     */
+    getStoppedSyncRules(): Promise<PersistedSyncRulesContent[]>;
+    /**
+     * Same as:
+     * getInstance(await getActiveSyncRules()).getCheckpoint().
+     */
+    getActiveCheckpoint(): Promise<ActiveCheckpoint>;
+    createWriteCheckpoint(user_id: string, lsns: Record<string, string>): Promise<bigint>;
+    lastWriteCheckpoint(user_id: string, lsn: string): Promise<bigint | null>;
+    watchWriteCheckpoint(user_id: string, signal: AbortSignal): AsyncIterable<WriteCheckpoint>;
+    /**
+     * Get storage size of active sync rules.
+     */
+    getStorageMetrics(): Promise<StorageMetrics>;
+    /**
+     * Get the unique identifier for this instance of Powersync
+     */
+    getPowerSyncInstanceId(): Promise<string>;
+}
+export interface WriteCheckpoint {
+    base: ActiveCheckpoint;
+    writeCheckpoint: bigint | null;
+}
+export interface ActiveCheckpoint {
+    readonly checkpoint: util.OpId;
+    readonly lsn: string;
+    hasSyncRules(): boolean;
+    getBucketStorage(): Promise<SyncRulesBucketStorage | null>;
+}
+export interface StorageMetrics {
+    /**
+     * Size of operations (bucket_data)
+     */
+    operations_size_bytes: number;
+    /**
+     * Size of parameter storage.
+     *
+     * Replication storage -> raw data as received from Postgres.
+     */
+    parameters_size_bytes: number;
+    /**
+     * Size of current_data.
+     */
+    replication_size_bytes: number;
+}
+export interface PersistedSyncRulesContent {
+    readonly id: number;
+    readonly sync_rules_content: string;
+    readonly slot_name: string;
+    readonly last_fatal_error?: string | null;
+    readonly last_keepalive_ts?: Date | null;
+    readonly last_checkpoint_ts?: Date | null;
+    parsed(): PersistedSyncRules;
+    lock(): Promise<ReplicationLock>;
+}
+export interface ReplicationLock {
+    sync_rules_id: number;
+    release(): Promise<void>;
+}
+export interface PersistedSyncRules {
+    readonly id: number;
+    readonly sync_rules: SqlSyncRules;
+    readonly slot_name: string;
+}
+export declare class DefaultPersistedSyncRules implements PersistedSyncRules {
+    readonly id: number;
+    readonly sync_rules: SqlSyncRules;
+    readonly checkpoint_lsn: string | null;
+    constructor(id: number, sync_rules: SqlSyncRules, checkpoint_lsn: string | null);
+    get slot_name(): string;
+}
+export interface UpdateSyncRulesOptions {
+    content: string;
+    lock?: boolean;
+}
+export interface SyncRulesBucketStorageOptions {
+    sync_rules: SqlSyncRules;
+    group_id: number;
+}
+export declare const DEFAULT_DOCUMENT_BATCH_LIMIT = 1000;
+export declare const DEFAULT_DOCUMENT_CHUNK_LIMIT_BYTES: number;
+export interface BucketDataBatchOptions {
+    /** Limit number of documents returned. Defaults to 1000. */
+    limit?: number;
+    /**
+     * Limit size of chunks returned. Defaults to 1MB.
+     *
+     * This is a lower bound, not an upper bound. As soon as the chunk size goes over this limit,
+     * it is returned.
+     *
+     * Note that an individual data row can be close to 16MB in size, so this does not help in
+     * extreme cases.
+     */
+    chunkLimitBytes?: number;
+}
+export interface SyncRulesBucketStorage {
+    readonly sync_rules: SqlSyncRules;
+    readonly group_id: number;
+    readonly slot_name: string;
+    readonly factory: BucketStorageFactory;
+    resolveTable(options: ResolveTableOptions): Promise<ResolveTableResult>;
+    startBatch(options: {}, callback: (batch: BucketStorageBatch) => Promise<void>): Promise<FlushedResult | null>;
+    getCheckpoint(): Promise<{
+        checkpoint: util.OpId;
+        lsn: string;
+    }>;
+    getParameterSets(checkpoint: util.OpId, lookups: SqliteJsonValue[][]): Promise<SqliteJsonRow[]>;
+    /**
+     * Get a "batch" of data for a checkpoint.
+     *
+     * The results will be split into separate SyncBucketData chunks to:
+     * 1. Separate buckets.
+     * 2. Limit the size of each individual chunk according to options.batchSizeLimitBytes.
+     *
+     * @param checkpoint the checkpoint
+     * @param dataBuckets current bucket states
+     * @param options batch size options
+     */
+    getBucketDataBatch(checkpoint: util.OpId, dataBuckets: Map<string, string>, options?: BucketDataBatchOptions): AsyncIterable<util.SyncBucketData>;
+    /**
+     * Compute checksums for a given list of buckets.
+     *
+     * Returns zero checksums for any buckets not found.
+     */
+    getChecksums(checkpoint: util.OpId, buckets: string[]): Promise<util.ChecksumMap>;
+    /**
+     * Terminate the sync rules.
+     *
+     * This clears the storage, and sets state to TERMINATED.
+     *
+     * Must only be called on stopped sync rules.
+     */
+    terminate(): Promise<void>;
+    getStatus(): Promise<SyncRuleStatus>;
+    /**
+     * Clear the storage, without changing state.
+     */
+    clear(): Promise<void>;
+    setSnapshotDone(lsn: string): Promise<void>;
+    autoActivate(): Promise<void>;
+    /**
+     * Record a replication error.
+     *
+     * This could be a recoverable error (e.g. temporary network failure),
+     * or a permanent error (e.g. missing toast data).
+     *
+     * Errors are cleared on commit.
+     */
+    reportError(e: any): Promise<void>;
+}
+export interface SyncRuleStatus {
+    checkpoint_lsn: string | null;
+    active: boolean;
+    snapshot_done: boolean;
+}
+export interface ResolveTableOptions {
+    group_id: number;
+    connection_id: number;
+    connection_tag: string;
+    relation: replication.PgRelation;
+    sync_rules: SqlSyncRules;
+}
+export interface ResolveTableResult {
+    table: SourceTable;
+    dropTables: SourceTable[];
+}
+export interface FlushedResult {
+    flushed_op: string;
+}
+export interface BucketStorageBatch {
+    /**
+     * Save an op, and potentially flush.
+     *
+     * This can be an insert, update or delete op.
+     */
+    save(record: SaveOptions): Promise<FlushedResult | null>;
+    /**
+     * Replicate a truncate op - deletes all data in the specified tables.
+     */
+    truncate(sourceTables: SourceTable[]): Promise<FlushedResult | null>;
+    /**
+     * Drop one or more tables.
+     *
+     * This is the same as truncate, but additionally removes the SourceTable record.
+     */
+    drop(sourceTables: SourceTable[]): Promise<FlushedResult | null>;
+    /**
+     * Explicitly flush all pending changes in the batch.
+     *
+     * This does not create a new checkpoint until `commit()` is called. This means it's
+     * safe to flush multiple times in the middle of a large transaction.
+     *
+     * @returns null if there are no changes to flush.
+     */
+    flush(): Promise<FlushedResult | null>;
+    /**
+     * Flush and commit any saved ops. This creates a new checkpoint.
+     *
+     * Only call this after a transaction.
+     */
+    commit(lsn: string): Promise<boolean>;
+    /**
+     * Advance the checkpoint LSN position, without any associated op.
+     *
+     * This must only be called when not inside a transaction.
+     *
+     * @returns true if the checkpoint was advanced, false if this was a no-op
+     */
+    keepalive(lsn: string): Promise<boolean>;
+    markSnapshotDone(tables: SourceTable[], no_checkpoint_before_lsn: string): Promise<SourceTable[]>;
+}
+export interface SaveParameterData {
+    sourceTable: SourceTable;
+    /** UUID */
+    sourceKey: string;
+    evaluated: EvaluatedParameters[];
+}
+export interface SaveBucketData {
+    sourceTable: SourceTable;
+    /** UUID */
+    sourceKey: string;
+    evaluated: EvaluatedRow[];
+}
+export type SaveOptions = SaveInsert | SaveUpdate | SaveDelete;
+export interface SaveInsert {
+    tag: 'insert';
+    sourceTable: SourceTable;
+    before?: undefined;
+    after: SqliteRow;
+}
+export interface SaveUpdate {
+    tag: 'update';
+    sourceTable: SourceTable;
+    before?: SqliteRow;
+    /**
+     * A null value means null column.
+     *
+     * An undefined value means it's a TOAST value - must be copied from another record.
+     */
+    after: ToastableSqliteRow;
+}
+export interface SaveDelete {
+    tag: 'delete';
+    sourceTable: SourceTable;
+    before: SqliteRow;
+    after?: undefined;
+}
+export declare function mergeToast(record: ToastableSqliteRow, persisted: ToastableSqliteRow): ToastableSqliteRow;

package/dist/storage/BucketStorage.js

@@ -0,0 +1,25 @@
+export class DefaultPersistedSyncRules {
+    constructor(id, sync_rules, checkpoint_lsn) {
+        this.id = id;
+        this.sync_rules = sync_rules;
+        this.checkpoint_lsn = checkpoint_lsn;
+    }
+    get slot_name() {
+        return `powersync_${this.id}`;
+    }
+}
+export const DEFAULT_DOCUMENT_BATCH_LIMIT = 1000;
+export const DEFAULT_DOCUMENT_CHUNK_LIMIT_BYTES = 1 * 1024 * 1024;
+export function mergeToast(record, persisted) {
+    const newRecord = {};
+    for (let key in record) {
+        if (typeof record[key] == 'undefined') {
+            newRecord[key] = persisted[key];
+        }
+        else {
+            newRecord[key] = record[key];
+        }
+    }
+    return newRecord;
+}
+//# sourceMappingURL=BucketStorage.js.map

package/dist/storage/BucketStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BucketStorage.js","sourceRoot":"","sources":["../../src/storage/BucketStorage.ts"],"names":[],"mappings":"AA+JA,MAAM,OAAO,yBAAyB;IAGpC,YAA4B,EAAU,EAAkB,UAAwB,EAAE,cAA6B;QAAnF,OAAE,GAAF,EAAE,CAAQ;QAAkB,eAAU,GAAV,UAAU,CAAc;QAC9E,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACvC,CAAC;IAED,IAAI,SAAS;QACX,OAAO,aAAa,IAAI,CAAC,EAAE,EAAE,CAAC;IAChC,CAAC;CACF;AAYD,MAAM,CAAC,MAAM,4BAA4B,GAAG,IAAI,CAAC;AACjD,MAAM,CAAC,MAAM,kCAAkC,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;AA2MlE,MAAM,UAAU,UAAU,CAAC,MAA0B,EAAE,SAA6B;IAClF,MAAM,SAAS,GAAuB,EAAE,CAAC;IACzC,KAAK,IAAI,GAAG,IAAI,MAAM,EAAE;QACtB,IAAI,OAAO,MAAM,CAAC,GAAG,CAAC,IAAI,WAAW,EAAE;YACrC,SAAS,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;SACjC;aAAM;YACL,SAAS,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;SAC9B;KACF;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/storage/ChecksumCache.d.ts

@@ -0,0 +1,50 @@
+import { BucketChecksum, OpId } from '../util/protocol-types.js';
+import { ChecksumMap } from '../util/utils.js';
+export interface FetchPartialBucketChecksum {
+    bucket: string;
+    start?: OpId;
+    end: OpId;
+}
+export type FetchChecksums = (batch: FetchPartialBucketChecksum[]) => Promise<ChecksumMap>;
+export interface ChecksumCacheOptions {
+    /**
+     * Upstream checksum implementation.
+     *
+     * This fetches a batch of either entire bucket checksums, or a partial range.
+     */
+    fetchChecksums: FetchChecksums;
+    /**
+     * Maximum number of cached checksums.
+     */
+    maxSize?: number;
+}
+/**
+ * Implement a LRU cache for checksum requests. Each (bucket, checkpoint) request is cached separately,
+ * while the lookups occur in batches.
+ *
+ * For each bucket, we keep a separate OrderedSet of cached checkpoints.
+ * This allows us to do incrementally update checksums by using the last cached checksum for the same bucket.
+ *
+ * We use the LRUCache fetchMethod to deduplicate in-progress requests.
+ */
+export declare class ChecksumCache {
+    /**
+     * The primary checksum cache, with key of `${checkpoint}/${bucket}`.
+     */
+    private cache;
+    /**
+     * For each bucket, an ordered set of cached checkpoints.
+     */
+    private bucketCheckpoints;
+    private fetchChecksums;
+    constructor(options: ChecksumCacheOptions);
+    getChecksums(checkpoint: OpId, buckets: string[]): Promise<BucketChecksum[]>;
+    /**
+     * Get bucket checksums for a checkpoint.
+     *
+     * Any checksums not found upstream are returned as zero checksums.
+     *
+     * @returns a Map with exactly one entry for each bucket requested
+     */
+    getChecksumMap(checkpoint: OpId, buckets: string[]): Promise<ChecksumMap>;
+}