@powersync/common 0.0.0-dev-20260202162549 → 0.0.0-dev-20260202163643

package/lib/client/Query.d.ts

@@ -0,0 +1,97 @@
+import { WatchedQueryComparator } from './watched/processors/comparators.js';
+import { DifferentialWatchedQuery, DifferentialWatchedQueryOptions } from './watched/processors/DifferentialQueryProcessor.js';
+import { StandardWatchedQuery } from './watched/processors/OnChangeQueryProcessor.js';
+import { WatchedQueryOptions } from './watched/WatchedQuery.js';
+/**
+ * Query parameters for {@link ArrayQueryDefinition#parameters}
+ */
+export type QueryParam = string | number | boolean | null | undefined | bigint | Uint8Array;
+/**
+ * Options for building a query with {@link AbstractPowerSyncDatabase#query}.
+ * This query will be executed with {@link AbstractPowerSyncDatabase#getAll}.
+ */
+export interface ArrayQueryDefinition<RowType = unknown> {
+    sql: string;
+    parameters?: ReadonlyArray<Readonly<QueryParam>>;
+    /**
+     * Maps the raw SQLite row to a custom typed object.
+     * @example
+     * ```javascript
+     * mapper: (row) => ({
+     *  ...row,
+     *  created_at: new Date(row.created_at as string),
+     * })
+     * ```
+     */
+    mapper?: (row: Record<string, unknown>) => RowType;
+}
+/**
+ * Options for {@link Query#watch}.
+ */
+export interface StandardWatchedQueryOptions<RowType> extends WatchedQueryOptions {
+    /**
+     * The underlying watched query implementation (re)evaluates the query on any SQLite table change.
+     *
+     * Providing this optional comparator can be used to filter duplicate result set emissions when the result set is unchanged.
+     * The comparator compares the previous and current result set.
+     *
+     * For an efficient comparator see {@link ArrayComparator}.
+     *
+     * @example
+     * ```javascript
+     * comparator: new ArrayComparator({
+     *     compareBy: (item) => JSON.stringify(item)
+     * })
+     * ```
+     */
+    comparator?: WatchedQueryComparator<RowType[]>;
+    /**
+     * The initial data state reported while the query is loading for the first time.
+     * @default []
+     */
+    placeholderData?: RowType[];
+}
+export interface Query<RowType> {
+    /**
+     * Creates a {@link WatchedQuery} which watches and emits results of the linked query.
+     *
+     * By default the returned watched query will emit changes whenever a change to the underlying SQLite tables is made.
+     * These changes might not be relevant to the query, but the query will emit a new result set.
+     *
+     * A {@link StandardWatchedQueryOptions#comparator} can be provided to limit the data emissions. The watched query will still
+     * query the underlying DB on underlying table changes, but the result will only be emitted if the comparator detects a change in the results.
+     *
+     * The comparator in this method is optimized and returns early as soon as it detects a change. Each data emission will correlate to a change in the result set,
+     * but note that the result set will not maintain internal object references to the previous result set. If internal object references are needed,
+     * consider using {@link Query#differentialWatch} instead.
+     */
+    watch(options?: StandardWatchedQueryOptions<RowType>): StandardWatchedQuery<ReadonlyArray<Readonly<RowType>>>;
+    /**
+     * Creates a {@link WatchedQuery} which watches and emits results of the linked query.
+     *
+     * This query method watches for changes in the underlying SQLite tables and runs the query on each table change.
+     * The difference between the current and previous result set is computed.
+     * The watched query will not emit changes if the result set is identical to the previous result set.
+     *
+     * If the result set is different, the watched query will emit the new result set and emit a detailed diff of the changes via the `onData` and `onDiff` listeners.
+     *
+     * The deep differentiation allows maintaining result set object references between result emissions.
+     * The {@link DifferentialWatchedQuery#state} `data` array will contain the previous row references for unchanged rows.
+     *
+     * @example
+     * ```javascript
+     * const watchedLists = powerSync.query({sql: 'SELECT * FROM lists'})
+     *  .differentialWatch();
+     *
+     * const disposeListener = watchedLists.registerListener({
+     *  onData: (lists) => {
+     *    console.log('The latest result set for the query is', lists);
+     *  },
+     *  onDiff: (diff) => {
+     *    console.log('The lists result set has changed since the last emission', diff.added, diff.removed, diff.updated, diff.all)
+     *  }
+     * })
+     * ```
+     */
+    differentialWatch(options?: DifferentialWatchedQueryOptions<RowType>): DifferentialWatchedQuery<RowType>;
+}

package/lib/client/Query.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Query.js.map

package/lib/client/Query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Query.js","sourceRoot":"","sources":["../../src/client/Query.ts"],"names":[],"mappings":""}

package/lib/client/SQLOpenFactory.d.ts

@@ -0,0 +1,42 @@
+import { DBAdapter } from '../db/DBAdapter.js';
+export interface SQLOpenOptions {
+    /**
+     * Filename for the database.
+     */
+    dbFilename: string;
+    /**
+     * Directory where the database file is located.
+     *
+     * When set, the directory must exist when the database is opened, it will
+     * not be created automatically.
+     */
+    dbLocation?: string;
+    /**
+     * Enable debugMode to log queries to the performance timeline.
+     *
+     * Defaults to false.
+     *
+     * To enable in development builds, use:
+     *
+     *    debugMode: process.env.NODE_ENV !== 'production'
+     */
+    debugMode?: boolean;
+}
+export interface SQLOpenFactory {
+    /**
+     * Opens a connection adapter to a SQLite DB
+     */
+    openDB(): DBAdapter;
+}
+/**
+ * Tests if the input is a {@link SQLOpenOptions}
+ */
+export declare const isSQLOpenOptions: (test: any) => test is SQLOpenOptions;
+/**
+ * Tests if input is a {@link SQLOpenFactory}
+ */
+export declare const isSQLOpenFactory: (test: any) => test is SQLOpenFactory;
+/**
+ * Tests if input is a {@link DBAdapter}
+ */
+export declare const isDBAdapter: (test: any) => test is DBAdapter;

package/lib/client/SQLOpenFactory.js

@@ -0,0 +1,20 @@
+/**
+ * Tests if the input is a {@link SQLOpenOptions}
+ */
+export const isSQLOpenOptions = (test) => {
+    // typeof null is `object`, but you cannot use the `in` operator on `null.
+    return test && typeof test == 'object' && 'dbFilename' in test;
+};
+/**
+ * Tests if input is a {@link SQLOpenFactory}
+ */
+export const isSQLOpenFactory = (test) => {
+    return typeof test?.openDB == 'function';
+};
+/**
+ * Tests if input is a {@link DBAdapter}
+ */
+export const isDBAdapter = (test) => {
+    return typeof test?.writeTransaction == 'function';
+};
+//# sourceMappingURL=SQLOpenFactory.js.map

package/lib/client/SQLOpenFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SQLOpenFactory.js","sourceRoot":"","sources":["../../src/client/SQLOpenFactory.ts"],"names":[],"mappings":"AAkCA;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,IAAS,EAA0B,EAAE;IACpE,0EAA0E;IAC1E,OAAO,IAAI,IAAI,OAAO,IAAI,IAAI,QAAQ,IAAI,YAAY,IAAI,IAAI,CAAC;AACjE,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,IAAS,EAA0B,EAAE;IACpE,OAAO,OAAO,IAAI,EAAE,MAAM,IAAI,UAAU,CAAC;AAC3C,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,IAAS,EAAqB,EAAE;IAC1D,OAAO,OAAO,IAAI,EAAE,gBAAgB,IAAI,UAAU,CAAC;AACrD,CAAC,CAAC"}

package/lib/client/compilableQueryWatch.d.ts

@@ -0,0 +1,7 @@
+import { CompilableQuery } from './../types/types.js';
+import { AbstractPowerSyncDatabase, SQLWatchOptions } from './AbstractPowerSyncDatabase.js';
+export interface CompilableQueryWatchHandler<T> {
+    onResult: (results: T[]) => void;
+    onError?: (error: Error) => void;
+}
+export declare function compilableQueryWatch<T>(db: AbstractPowerSyncDatabase, query: CompilableQuery<T>, handler: CompilableQueryWatchHandler<T>, options?: SQLWatchOptions): void;

package/lib/client/compilableQueryWatch.js

@@ -0,0 +1,38 @@
+import { runOnSchemaChange } from './runOnSchemaChange.js';
+export function compilableQueryWatch(db, query, handler, options) {
+    const { onResult, onError = (e) => { } } = handler ?? {};
+    if (!onResult) {
+        throw new Error('onResult is required');
+    }
+    const watchQuery = async (abortSignal) => {
+        try {
+            const toSql = query.compile();
+            const resolvedTables = await db.resolveTables(toSql.sql, toSql.parameters, options);
+            // Fetch initial data
+            const result = await query.execute();
+            onResult(result);
+            db.onChangeWithCallback({
+                onChange: async () => {
+                    try {
+                        const result = await query.execute();
+                        onResult(result);
+                    }
+                    catch (error) {
+                        onError(error);
+                    }
+                },
+                onError
+            }, {
+                ...(options ?? {}),
+                tables: resolvedTables,
+                // Override the abort signal since we intercept it
+                signal: abortSignal
+            });
+        }
+        catch (error) {
+            onError(error);
+        }
+    };
+    runOnSchemaChange(watchQuery, db, options);
+}
+//# sourceMappingURL=compilableQueryWatch.js.map

package/lib/client/compilableQueryWatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilableQueryWatch.js","sourceRoot":"","sources":["../../src/client/compilableQueryWatch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAO3D,MAAM,UAAU,oBAAoB,CAClC,EAA6B,EAC7B,KAAyB,EACzB,OAAuC,EACvC,OAAyB;IAEzB,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,CAAC,CAAQ,EAAE,EAAE,GAAE,CAAC,EAAE,GAAG,OAAO,IAAI,EAAE,CAAC;IAC/D,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;IAC1C,CAAC;IAED,MAAM,UAAU,GAAG,KAAK,EAAE,WAAwB,EAAE,EAAE;QACpD,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;YAC9B,MAAM,cAAc,GAAG,MAAM,EAAE,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,UAAgB,EAAE,OAAO,CAAC,CAAC;YAE1F,qBAAqB;YACrB,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC;YACrC,QAAQ,CAAC,MAAM,CAAC,CAAC;YAEjB,EAAE,CAAC,oBAAoB,CACrB;gBACE,QAAQ,EAAE,KAAK,IAAI,EAAE;oBACnB,IAAI,CAAC;wBACH,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC;wBACrC,QAAQ,CAAC,MAAM,CAAC,CAAC;oBACnB,CAAC;oBAAC,OAAO,KAAU,EAAE,CAAC;wBACpB,OAAO,CAAC,KAAK,CAAC,CAAC;oBACjB,CAAC;gBACH,CAAC;gBACD,OAAO;aACR,EACD;gBACE,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC;gBAClB,MAAM,EAAE,cAAc;gBACtB,kDAAkD;gBAClD,MAAM,EAAE,WAAW;aACpB,CACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,OAAO,CAAC,KAAK,CAAC,CAAC;QACjB,CAAC;IACH,CAAC,CAAC;IAEF,iBAAiB,CAAC,UAAU,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC;AAC7C,CAAC"}

package/lib/client/connection/PowerSyncBackendConnector.d.ts

@@ -0,0 +1,23 @@
+import { PowerSyncCredentials } from './PowerSyncCredentials.js';
+import type { AbstractPowerSyncDatabase } from '../AbstractPowerSyncDatabase.js';
+export interface PowerSyncBackendConnector {
+    /** Allows the PowerSync client to retrieve an authentication token from your backend
+     * which is used to authenticate against the PowerSync service.
+     *
+     * This should always fetch a fresh set of credentials - don't use cached
+     * values.
+     *
+     * Return null if the user is not signed in. Throw an error if credentials
+     * cannot be fetched due to a network error or other temporary error.
+     *
+     * This token is kept for the duration of a sync connection.
+     */
+    fetchCredentials: () => Promise<PowerSyncCredentials | null>;
+    /** Upload local changes to the app backend.
+     *
+     * Use {@link AbstractPowerSyncDatabase.getCrudBatch} to get a batch of changes to upload.
+     *
+     * Any thrown errors will result in a retry after the configured wait period (default: 5 seconds).
+     */
+    uploadData: (database: AbstractPowerSyncDatabase) => Promise<void>;
+}

package/lib/client/connection/PowerSyncBackendConnector.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=PowerSyncBackendConnector.js.map

package/lib/client/connection/PowerSyncBackendConnector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PowerSyncBackendConnector.js","sourceRoot":"","sources":["../../../src/client/connection/PowerSyncBackendConnector.ts"],"names":[],"mappings":""}

package/lib/client/connection/PowerSyncCredentials.d.ts

@@ -0,0 +1,5 @@
+export interface PowerSyncCredentials {
+    endpoint: string;
+    token: string;
+    expiresAt?: Date;
+}

package/lib/client/connection/PowerSyncCredentials.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=PowerSyncCredentials.js.map

package/lib/client/connection/PowerSyncCredentials.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PowerSyncCredentials.js","sourceRoot":"","sources":["../../../src/client/connection/PowerSyncCredentials.ts"],"names":[],"mappings":""}

package/lib/client/constants.d.ts

@@ -0,0 +1 @@
+export declare const MAX_OP_ID = "9223372036854775807";

package/lib/client/constants.js

@@ -0,0 +1,2 @@
+export const MAX_OP_ID = '9223372036854775807';
+//# sourceMappingURL=constants.js.map

package/lib/client/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/client/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,SAAS,GAAG,qBAAqB,CAAC"}

package/lib/client/runOnSchemaChange.d.ts

@@ -0,0 +1,2 @@
+import { AbstractPowerSyncDatabase, SQLWatchOptions } from './AbstractPowerSyncDatabase.js';
+export declare function runOnSchemaChange(callback: (signal: AbortSignal) => void, db: AbstractPowerSyncDatabase, options?: SQLWatchOptions): void;

package/lib/client/runOnSchemaChange.js

@@ -0,0 +1,24 @@
+export function runOnSchemaChange(callback, db, options) {
+    const triggerWatchedQuery = () => {
+        const abortController = new AbortController();
+        let disposeSchemaListener = null;
+        const stopWatching = () => {
+            abortController.abort('Abort triggered');
+            disposeSchemaListener?.();
+            disposeSchemaListener = null;
+            // Stop listening to upstream abort for this watch
+            options?.signal?.removeEventListener('abort', stopWatching);
+        };
+        options?.signal?.addEventListener('abort', stopWatching);
+        disposeSchemaListener = db.registerListener({
+            schemaChanged: async () => {
+                stopWatching();
+                // Re trigger the watched query (recursively), setTimeout ensures that we don't modify the list of listeners while iterating through them
+                setTimeout(() => triggerWatchedQuery(), 0);
+            }
+        });
+        callback(abortController.signal);
+    };
+    triggerWatchedQuery();
+}
+//# sourceMappingURL=runOnSchemaChange.js.map

package/lib/client/runOnSchemaChange.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runOnSchemaChange.js","sourceRoot":"","sources":["../../src/client/runOnSchemaChange.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,iBAAiB,CAC/B,QAAuC,EACvC,EAA6B,EAC7B,OAAyB;IAEzB,MAAM,mBAAmB,GAAG,GAAG,EAAE;QAC/B,MAAM,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC;QAC9C,IAAI,qBAAqB,GAAwB,IAAI,CAAC;QACtD,MAAM,YAAY,GAAG,GAAG,EAAE;YACxB,eAAe,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;YACzC,qBAAqB,EAAE,EAAE,CAAC;YAC1B,qBAAqB,GAAG,IAAI,CAAC;YAC7B,kDAAkD;YAClD,OAAO,EAAE,MAAM,EAAE,mBAAmB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QAC9D,CAAC,CAAC;QAEF,OAAO,EAAE,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QACzD,qBAAqB,GAAG,EAAE,CAAC,gBAAgB,CAAC;YAC1C,aAAa,EAAE,KAAK,IAAI,EAAE;gBACxB,YAAY,EAAE,CAAC;gBACf,yIAAyI;gBACzI,UAAU,CAAC,GAAG,EAAE,CAAC,mBAAmB,EAAE,EAAE,CAAC,CAAC,CAAC;YAC7C,CAAC;SACF,CAAC,CAAC;QACH,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC,CAAC;IAEF,mBAAmB,EAAE,CAAC;AACxB,CAAC"}

package/lib/client/sync/bucket/BucketStorageAdapter.d.ts

@@ -0,0 +1,102 @@
+import { BaseListener, BaseObserverInterface, Disposable } from '../../../utils/BaseObserver.js';
+import { CrudBatch } from './CrudBatch.js';
+import { CrudEntry, OpId } from './CrudEntry.js';
+import { SyncDataBatch } from './SyncDataBatch.js';
+export interface BucketDescription {
+    name: string;
+    priority: number;
+}
+export interface Checkpoint {
+    last_op_id: OpId;
+    buckets: BucketChecksum[];
+    write_checkpoint?: string;
+    streams?: any[];
+}
+export interface BucketState {
+    bucket: string;
+    op_id: string;
+}
+export interface ChecksumCache {
+    checksums: Map<string, {
+        checksum: BucketChecksum;
+        last_op_id: OpId;
+    }>;
+    lastOpId: OpId;
+}
+export interface SyncLocalDatabaseResult {
+    ready: boolean;
+    checkpointValid: boolean;
+    checkpointFailures?: string[];
+}
+export type SavedProgress = {
+    atLast: number;
+    sinceLast: number;
+};
+export type BucketOperationProgress = Record<string, SavedProgress>;
+export interface BucketChecksum {
+    bucket: string;
+    priority?: number;
+    /**
+     * 32-bit unsigned hash.
+     */
+    checksum: number;
+    /**
+     * Count of operations - informational only.
+     */
+    count?: number;
+    /**
+     * The JavaScript client does not use this field, which is why it's defined to be `any`. We rely on the structure of
+     * this interface to pass custom `BucketChecksum`s to the Rust client in unit tests, which so all fields need to be
+     * present.
+     */
+    subscriptions?: any;
+}
+export declare enum PSInternalTable {
+    DATA = "ps_data",
+    CRUD = "ps_crud",
+    BUCKETS = "ps_buckets",
+    OPLOG = "ps_oplog",
+    UNTYPED = "ps_untyped"
+}
+export declare enum PowerSyncControlCommand {
+    PROCESS_TEXT_LINE = "line_text",
+    PROCESS_BSON_LINE = "line_binary",
+    STOP = "stop",
+    START = "start",
+    NOTIFY_TOKEN_REFRESHED = "refreshed_token",
+    NOTIFY_CRUD_UPLOAD_COMPLETED = "completed_upload",
+    UPDATE_SUBSCRIPTIONS = "update_subscriptions"
+}
+export interface BucketStorageListener extends BaseListener {
+    crudUpdate: () => void;
+}
+export interface BucketStorageAdapter extends BaseObserverInterface<BucketStorageListener>, Disposable {
+    init(): Promise<void>;
+    saveSyncData(batch: SyncDataBatch, fixedKeyFormat?: boolean): Promise<void>;
+    removeBuckets(buckets: string[]): Promise<void>;
+    setTargetCheckpoint(checkpoint: Checkpoint): Promise<void>;
+    startSession(): void;
+    getBucketStates(): Promise<BucketState[]>;
+    getBucketOperationProgress(): Promise<BucketOperationProgress>;
+    hasMigratedSubkeys(): Promise<boolean>;
+    migrateToFixedSubkeys(): Promise<void>;
+    syncLocalDatabase(checkpoint: Checkpoint, priority?: number): Promise<{
+        checkpointValid: boolean;
+        ready: boolean;
+        failures?: any[];
+    }>;
+    nextCrudItem(): Promise<CrudEntry | undefined>;
+    hasCrud(): Promise<boolean>;
+    getCrudBatch(limit?: number): Promise<CrudBatch | null>;
+    hasCompletedSync(): Promise<boolean>;
+    updateLocalTarget(cb: () => Promise<string>): Promise<boolean>;
+    getMaxOpId(): string;
+    /**
+     * Get an unique client id.
+     */
+    getClientId(): Promise<string>;
+    /**
+     * Invokes the `powersync_control` function for the sync client.
+     */
+    control(op: PowerSyncControlCommand, payload: string | Uint8Array | null): Promise<string>;
+}

package/lib/client/sync/bucket/BucketStorageAdapter.js

@@ -0,0 +1,19 @@
+export var PSInternalTable;
+(function (PSInternalTable) {
+    PSInternalTable["DATA"] = "ps_data";
+    PSInternalTable["CRUD"] = "ps_crud";
+    PSInternalTable["BUCKETS"] = "ps_buckets";
+    PSInternalTable["OPLOG"] = "ps_oplog";
+    PSInternalTable["UNTYPED"] = "ps_untyped";
+})(PSInternalTable || (PSInternalTable = {}));
+export var PowerSyncControlCommand;
+(function (PowerSyncControlCommand) {
+    PowerSyncControlCommand["PROCESS_TEXT_LINE"] = "line_text";
+    PowerSyncControlCommand["PROCESS_BSON_LINE"] = "line_binary";
+    PowerSyncControlCommand["STOP"] = "stop";
+    PowerSyncControlCommand["START"] = "start";
+    PowerSyncControlCommand["NOTIFY_TOKEN_REFRESHED"] = "refreshed_token";
+    PowerSyncControlCommand["NOTIFY_CRUD_UPLOAD_COMPLETED"] = "completed_upload";
+    PowerSyncControlCommand["UPDATE_SUBSCRIPTIONS"] = "update_subscriptions";
+})(PowerSyncControlCommand || (PowerSyncControlCommand = {}));
+//# sourceMappingURL=BucketStorageAdapter.js.map

package/lib/client/sync/bucket/BucketStorageAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BucketStorageAdapter.js","sourceRoot":"","sources":["../../../../src/client/sync/bucket/BucketStorageAdapter.ts"],"names":[],"mappings":"AA4DA,MAAM,CAAN,IAAY,eAMX;AAND,WAAY,eAAe;IACzB,mCAAgB,CAAA;IAChB,mCAAgB,CAAA;IAChB,yCAAsB,CAAA;IACtB,qCAAkB,CAAA;IAClB,yCAAsB,CAAA;AACxB,CAAC,EANW,eAAe,KAAf,eAAe,QAM1B;AAED,MAAM,CAAN,IAAY,uBAQX;AARD,WAAY,uBAAuB;IACjC,0DAA+B,CAAA;IAC/B,4DAAiC,CAAA;IACjC,wCAAa,CAAA;IACb,0CAAe,CAAA;IACf,qEAA0C,CAAA;IAC1C,4EAAiD,CAAA;IACjD,wEAA6C,CAAA;AAC/C,CAAC,EARW,uBAAuB,KAAvB,uBAAuB,QAQlC"}

package/lib/client/sync/bucket/CrudBatch.d.ts

@@ -0,0 +1,31 @@
+import { CrudEntry } from './CrudEntry.js';
+/**
+ * A batch of client-side changes.
+ */
+export declare class CrudBatch {
+    /**
+     * List of client-side changes.
+     */
+    crud: CrudEntry[];
+    /**
+     * true if there are more changes in the local queue.
+     */
+    haveMore: boolean;
+    /**
+     * Call to remove the changes from the local queue, once successfully uploaded.
+     */
+    complete: (writeCheckpoint?: string) => Promise<void>;
+    constructor(
+    /**
+     * List of client-side changes.
+     */
+    crud: CrudEntry[], 
+    /**
+     * true if there are more changes in the local queue.
+     */
+    haveMore: boolean, 
+    /**
+     * Call to remove the changes from the local queue, once successfully uploaded.
+     */
+    complete: (writeCheckpoint?: string) => Promise<void>);
+}

package/lib/client/sync/bucket/CrudBatch.js

@@ -0,0 +1,26 @@
+/**
+ * A batch of client-side changes.
+ */
+export class CrudBatch {
+    crud;
+    haveMore;
+    complete;
+    constructor(
+    /**
+     * List of client-side changes.
+     */
+    crud, 
+    /**
+     * true if there are more changes in the local queue.
+     */
+    haveMore, 
+    /**
+     * Call to remove the changes from the local queue, once successfully uploaded.
+     */
+    complete) {
+        this.crud = crud;
+        this.haveMore = haveMore;
+        this.complete = complete;
+    }
+}
+//# sourceMappingURL=CrudBatch.js.map

package/lib/client/sync/bucket/CrudBatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CrudBatch.js","sourceRoot":"","sources":["../../../../src/client/sync/bucket/CrudBatch.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,OAAO,SAAS;IAKX;IAIA;IAIA;IAZT;IACE;;OAEG;IACI,IAAiB;IACxB;;OAEG;IACI,QAAiB;IACxB;;OAEG;IACI,QAAqD;QARrD,SAAI,GAAJ,IAAI,CAAa;QAIjB,aAAQ,GAAR,QAAQ,CAAS;QAIjB,aAAQ,GAAR,QAAQ,CAA6C;IAC3D,CAAC;CACL"}

package/lib/client/sync/bucket/CrudEntry.d.ts

@@ -0,0 +1,95 @@
+/**
+ * 64-bit unsigned integer stored as a string in base-10.
+ *
+ * Not sortable as a string.
+ */
+export type OpId = string;
+/**
+ * Type of local change.
+ */
+export declare enum UpdateType {
+    /** Insert or replace existing row. All non-null columns are included in the data. Generated by INSERT statements. */
+    PUT = "PUT",
+    /** Update existing row. Contains the id, and value of each changed column. Generated by UPDATE statements. */
+    PATCH = "PATCH",
+    /** Delete existing row. Contains the id. Generated by DELETE statements. */
+    DELETE = "DELETE"
+}
+export type CrudEntryJSON = {
+    id: string;
+    data: string;
+    tx_id?: number;
+};
+/**
+ * The output JSON seems to be a third type of JSON, not the same as the input JSON.
+ */
+type CrudEntryOutputJSON = {
+    op_id: number;
+    op: UpdateType;
+    type: string;
+    id: string;
+    tx_id?: number;
+    data?: Record<string, any>;
+    old?: Record<string, any>;
+    metadata?: string;
+};
+/**
+ * A single client-side change.
+ */
+export declare class CrudEntry {
+    /**
+     * Auto-incrementing client-side id.
+     */
+    clientId: number;
+    /**
+     * ID of the changed row.
+     */
+    id: string;
+    /**
+     * Type of change.
+     */
+    op: UpdateType;
+    /**
+     * Data associated with the change.
+     */
+    opData?: Record<string, any>;
+    /**
+     * For tables where the `trackPreviousValues` option has been enabled, this tracks previous values for
+     * `UPDATE` and `DELETE` statements.
+     */
+    previousValues?: Record<string, any>;
+    /**
+     * Table that contained the change.
+     */
+    table: string;
+    /**
+     * Auto-incrementing transaction id. This is the same for all operations within the same transaction.
+     */
+    transactionId?: number;
+    /**
+     * Client-side metadata attached with this write.
+     *
+     * This field is only available when the `trackMetadata` option was set to `true` when creating a table
+     * and the insert or update statement set the `_metadata` column.
+     */
+    metadata?: string;
+    static fromRow(dbRow: CrudEntryJSON): CrudEntry;
+    constructor(clientId: number, op: UpdateType, table: string, id: string, transactionId?: number, opData?: Record<string, any>, previousValues?: Record<string, any>, metadata?: string);
+    /**
+     * Converts the change to JSON format.
+     */
+    toJSON(): CrudEntryOutputJSON;
+    equals(entry: CrudEntry): boolean;
+    /**
+     * The hash code for this object.
+     * @deprecated This should not be necessary in the JS SDK.
+     * Use the  @see CrudEntry#equals method instead.
+     * TODO remove in the next major release.
+     */
+    hashCode(): string;
+    /**
+     * Generates an array for use in deep comparison operations
+     */
+    toComparisonArray(): (string | number | Record<string, any> | undefined)[];
+}
+export {};