@powersync/common 0.0.0-dev-20250701144132 → 0.0.0-dev-20250710153817

package/lib/client/AbstractPowerSyncDatabase.d.ts

@@ -1,5 +1,5 @@
 import { Mutex } from 'async-mutex';
-import Logger, { ILogger } from 'js-logger';
+import { ILogger } from 'js-logger';
 import { DBAdapter, QueryResult, Transaction } from '../db/DBAdapter.js';
 import { SyncStatus } from '../db/crud/SyncStatus.js';
 import { UploadQueueStats } from '../db/crud/UploadQueueStatus.js';
@@ -84,7 +84,6 @@ export declare const DEFAULT_POWERSYNC_CLOSE_OPTIONS: PowerSyncCloseOptions;
 export declare const DEFAULT_WATCH_THROTTLE_MS = 30;
 export declare const DEFAULT_POWERSYNC_DB_OPTIONS: {
     retryDelayMs: number;
-    logger: Logger.ILogger;
     crudUploadThrottleMs: number;
 };
 export declare const DEFAULT_CRUD_BATCH_LIMIT = 100;
@@ -123,6 +122,7 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
     protected _schema: Schema;
     private _database;
     protected runExclusiveMutex: Mutex;
+    logger: ILogger;
     constructor(options: PowerSyncDatabaseOptionsWithDBAdapter);
     constructor(options: PowerSyncDatabaseOptionsWithOpenFactory);
     constructor(options: PowerSyncDatabaseOptionsWithSettings);
@@ -185,7 +185,6 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * Cannot be used while connected - this should only be called before {@link AbstractPowerSyncDatabase.connect}.
      */
     updateSchema(schema: Schema): Promise<void>;
-    get logger(): Logger.ILogger;
     /**
      * Wait for initialization to complete.
      * While initializing is automatic, this helps to catch and report initialization errors.

package/lib/client/AbstractPowerSyncDatabase.js

@@ -27,7 +27,6 @@ export const DEFAULT_POWERSYNC_CLOSE_OPTIONS = {
 export const DEFAULT_WATCH_THROTTLE_MS = 30;
 export const DEFAULT_POWERSYNC_DB_OPTIONS = {
     retryDelayMs: 5000,
-    logger: Logger.get('PowerSyncDatabase'),
     crudUploadThrottleMs: DEFAULT_CRUD_UPLOAD_THROTTLE_MS
 };
 export const DEFAULT_CRUD_BATCH_LIMIT = 100;
@@ -70,6 +69,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
     _schema;
     _database;
     runExclusiveMutex;
+    logger;
     constructor(options) {
         super();
         this.options = options;
@@ -89,6 +89,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
         else {
             throw new Error('The provided `database` option is invalid.');
         }
+        this.logger = options.logger ?? Logger.get(`PowerSyncDatabase[${this._database.name}]`);
         this.bucketStorageAdapter = this.generateBucketStorageAdapter();
         this.closed = false;
         this.currentStatus = new SyncStatus({});
@@ -268,16 +269,13 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
             schema.validate();
         }
         catch (ex) {
-            this.options.logger?.warn('Schema validation failed. Unexpected behaviour could occur', ex);
+            this.logger.warn('Schema validation failed. Unexpected behaviour could occur', ex);
         }
         this._schema = schema;
         await this.database.execute('SELECT powersync_replace_schema(?)', [JSON.stringify(this.schema.toJSON())]);
         await this.database.refreshSchema();
         this.iterateListeners(async (cb) => cb.schemaChanged?.(schema));
     }
-    get logger() {
-        return this.options.logger;
-    }
     /**
      * Wait for initialization to complete.
      * While initializing is automatic, this helps to catch and report initialization errors.
@@ -617,7 +615,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
      * @param options Options for configuring watch behavior
      */
     watchWithCallback(sql, parameters, handler, options) {
-        const { onResult, onError = (e) => this.options.logger?.error(e) } = handler ?? {};
+        const { onResult, onError = (e) => this.logger.error(e) } = handler ?? {};
         if (!onResult) {
             throw new Error('onResult is required');
         }
@@ -723,7 +721,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
      * @returns A dispose function to stop watching for changes
      */
     onChangeWithCallback(handler, options) {
-        const { onChange, onError = (e) => this.options.logger?.error(e) } = handler ?? {};
+        const { onChange, onError = (e) => this.logger.error(e) } = handler ?? {};
         if (!onChange) {
             throw new Error('onChange is required');
         }

package/lib/client/ConnectionManager.js

@@ -136,7 +136,6 @@ export class ConnectionManager extends BaseObserver {
         await this.disconnectingPromise;
         this.logger.debug('Attempting to connect to PowerSync instance');
         await this.syncStreamImplementation?.connect(appliedOptions);
-        this.syncStreamImplementation?.triggerCrudUpload();
     }
     /**
      * Close the sync connection.

package/lib/client/sync/stream/AbstractStreamingSyncImplementation.js

@@ -169,9 +169,12 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
     }
     async getWriteCheckpoint() {
         const clientId = await this.options.adapter.getClientId();
+        this.logger.debug(`Creating write checkpoint for ${clientId}`);
         let path = `/write-checkpoint2.json?client_id=${clientId}`;
         const response = await this.options.remote.get(path);
-        return response['data']['write_checkpoint'];
+        const checkpoint = response['data']['write_checkpoint'];
+        this.logger.debug(`Got write checkpoint: ${checkpoint}`);
+        return checkpoint;
     }
     async _uploadAllCrud() {
         return this.obtainLock({
@@ -182,17 +185,17 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
                  */
                 let checkedCrudItem;
                 while (true) {
-                    this.updateSyncStatus({
-                        dataFlow: {
-                            uploading: true
-                        }
-                    });
                     try {
                         /**
                          * This is the first item in the FIFO CRUD queue.
                          */
                         const nextCrudItem = await this.options.adapter.nextCrudItem();
                         if (nextCrudItem) {
+                            this.updateSyncStatus({
+                                dataFlow: {
+                                    uploading: true
+                                }
+                            });
                             if (nextCrudItem.clientId == checkedCrudItem?.clientId) {
                                 // This will force a higher log level than exceptions which are caught here.
                                 this.logger.warn(`Potentially previously uploaded CRUD entries are still present in the upload queue.
@@ -210,7 +213,11 @@ The next upload iteration will be delayed.`);
                         }
                         else {
                             // Uploading is completed
-                            await this.options.adapter.updateLocalTarget(() => this.getWriteCheckpoint());
+                            this.logger.debug('Upload complete, creating write checkpoint');
+                            const neededUpdate = await this.options.adapter.updateLocalTarget(() => this.getWriteCheckpoint());
+                            if (neededUpdate == false) {
+                                this.logger.debug('No write checkpoint needed');
+                            }
                             break;
                         }
                     }
@@ -247,23 +254,17 @@ The next upload iteration will be delayed.`);
         const controller = new AbortController();
         this.abortController = controller;
         this.streamingSyncPromise = this.streamingSync(this.abortController.signal, options);
-        // Return a promise that resolves when the connection status is updated
+        // Return a promise that resolves when the connection status is updated to indicate that we're connected.
         return new Promise((resolve) => {
             const disposer = this.registerListener({
-                statusUpdated: (update) => {
-                    // This is triggered as soon as a connection is read from
-                    if (typeof update.connected == 'undefined') {
-                        // only concern with connection updates
-                        return;
-                    }
-                    if (update.connected == false) {
-                        /**
-                         * This function does not reject if initial connect attempt failed.
-                         * Connected can be false if the connection attempt was aborted or if the initial connection
-                         * attempt failed.
-                         */
+                statusChanged: (status) => {
+                    if (status.dataFlowStatus.downloadError != null) {
                         this.logger.warn('Initial connect attempt did not successfully connect to server');
                     }
+                    else if (status.connecting) {
+                        // Still connecting.
+                        return;
+                    }
                     disposer();
                     resolve();
                 }
@@ -655,6 +656,7 @@ The next upload iteration will be delayed.`);
         const adapter = this.options.adapter;
         const remote = this.options.remote;
         let receivingLines = null;
+        let hadSyncLine = false;
         const abortController = new AbortController();
         signal.addEventListener('abort', () => abortController.abort());
         // Pending sync lines received from the service, as well as local events that trigger a powersync_control
@@ -698,6 +700,9 @@ The next upload iteration will be delayed.`);
                     }
                 });
             }
+            // The rust client will set connected: true after the first sync line because that's when it gets invoked, but
+            // we're already connected here and can report that.
+            syncImplementation.updateSyncStatus({ connected: true });
             try {
                 while (!controlInvocations.closed) {
                     const line = await controlInvocations.read();
@@ -705,6 +710,10 @@ The next upload iteration will be delayed.`);
                         return;
                     }
                     await control(line.command, line.payload);
+                    if (!hadSyncLine) {
+                        syncImplementation.triggerCrudUpload();
+                        hadSyncLine = true;
+                    }
                 }
             }
             finally {
@@ -742,7 +751,7 @@ The next upload iteration will be delayed.`);
                     return {
                         priority: status.priority,
                         hasSynced: status.has_synced ?? undefined,
-                        lastSyncedAt: status?.last_synced_at != null ? new Date(status.last_synced_at) : undefined
+                        lastSyncedAt: status?.last_synced_at != null ? new Date(status.last_synced_at * 1000) : undefined
                     };
                 }
                 const info = instruction.UpdateSyncStatus.status;
@@ -865,8 +874,9 @@ The next upload iteration will be delayed.`);
             // We have pending entries in the local upload queue or are waiting to confirm a write
             // checkpoint, which prevented this checkpoint from applying. Wait for that to complete and
             // try again.
-            this.logger.debug('Could not apply checkpoint due to local data. Waiting for in-progress upload before retrying.');
+            this.logger.debug(`Could not apply checkpoint ${checkpoint.last_op_id} due to local data. Waiting for in-progress upload before retrying.`);
             await Promise.race([pending, onAbortPromise(abort)]);
+            this.logger.debug(`Pending uploads complete, retrying local checkpoint at ${checkpoint.last_op_id}`);
             if (abort.aborted) {
                 return { applied: false, endIteration: true };
             }

package/lib/db/crud/SyncProgress.d.ts

@@ -1,4 +1,4 @@
-import { BucketProgress } from 'src/client/sync/stream/core-instruction.js';
+import type { BucketProgress } from '../../client/sync/stream/core-instruction.js';
 /** @internal */
 export type InternalProgressInformation = Record<string, BucketProgress>;
 /**

package/lib/utils/DataStream.d.ts

@@ -34,6 +34,7 @@ export declare class DataStream<ParsedData, SourceData = any> extends BaseObserv
     dataQueue: SourceData[];
     protected isClosed: boolean;
     protected processingPromise: Promise<void> | null;
+    protected notifyDataAdded: (() => void) | null;
     protected logger: ILogger;
     protected mapLine: (line: SourceData) => ParsedData;
     constructor(options?: DataStreamOptions<ParsedData, SourceData> | undefined);
@@ -54,7 +55,7 @@ export declare class DataStream<ParsedData, SourceData = any> extends BaseObserv
      * Executes a callback for each data item in the stream
      */
     forEach(callback: DataStreamCallback<ParsedData>): () => void;
-    protected processQueue(): Promise<void>;
+    protected processQueue(): Promise<void> | undefined;
     protected hasDataReader(): boolean;
     protected _processQueue(): Promise<void>;
     protected iterateAsyncErrored(cb: (l: Partial<DataStreamListener<ParsedData>>) => Promise<void>): Promise<void>;

package/lib/utils/DataStream.js

@@ -14,6 +14,7 @@ export class DataStream extends BaseObserver {
     dataQueue;
     isClosed;
     processingPromise;
+    notifyDataAdded;
     logger;
     mapLine;
     constructor(options) {
@@ -58,6 +59,7 @@ export class DataStream extends BaseObserver {
             throw new Error('Cannot enqueue data into closed stream.');
         }
         this.dataQueue.push(data);
+        this.notifyDataAdded?.();
         this.processQueue();
     }
     /**
@@ -98,10 +100,20 @@ export class DataStream extends BaseObserver {
             data: callback
         });
     }
-    async processQueue() {
+    processQueue() {
         if (this.processingPromise) {
             return;
         }
+        const promise = (this.processingPromise = this._processQueue());
+        promise.finally(() => {
+            return (this.processingPromise = null);
+        });
+        return promise;
+    }
+    hasDataReader() {
+        return Array.from(this.listeners.values()).some((l) => !!l.data);
+    }
+    async _processQueue() {
         /**
          * Allow listeners to mutate the queue before processing.
          * This allows for operations such as dropping or compressing data
@@ -110,14 +122,7 @@ export class DataStream extends BaseObserver {
         if (this.dataQueue.length >= this.highWatermark) {
             await this.iterateAsyncErrored(async (l) => l.highWater?.());
         }
-        return (this.processingPromise = this._processQueue());
-    }
-    hasDataReader() {
-        return Array.from(this.listeners.values()).some((l) => !!l.data);
-    }
-    async _processQueue() {
         if (this.isClosed || !this.hasDataReader()) {
-            Promise.resolve().then(() => (this.processingPromise = null));
             return;
         }
         if (this.dataQueue.length) {
@@ -126,16 +131,22 @@ export class DataStream extends BaseObserver {
             await this.iterateAsyncErrored(async (l) => l.data?.(mapped));
         }
         if (this.dataQueue.length <= this.lowWatermark) {
-            await this.iterateAsyncErrored(async (l) => l.lowWater?.());
+            const dataAdded = new Promise((resolve) => {
+                this.notifyDataAdded = resolve;
+            });
+            await Promise.race([this.iterateAsyncErrored(async (l) => l.lowWater?.()), dataAdded]);
+            this.notifyDataAdded = null;
         }
-        this.processingPromise = null;
-        if (this.dataQueue.length) {
+        if (this.dataQueue.length > 0) {
             // Next tick
             setTimeout(() => this.processQueue());
         }
     }
     async iterateAsyncErrored(cb) {
-        for (let i of this.listeners.values()) {
+        // Important: We need to copy the listeners, as calling a listener could result in adding another
+        // listener, resulting in infinite loops.
+        const listeners = Array.from(this.listeners.values());
+        for (let i of listeners) {
             try {
                 await cb(i);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/common",
-  "version": "0.0.0-dev-20250701144132",
+  "version": "0.0.0-dev-20250710153817",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -13,8 +13,9 @@
   "exports": {
     ".": {
       "import": "./dist/bundle.mjs",
-      "default": "./dist/bundle.mjs",
-      "types": "./lib/index.d.ts"
+      "require": "./dist/bundle.cjs",
+      "types": "./lib/index.d.ts",
+      "default": "./dist/bundle.mjs"
     }
   },
   "author": "JOURNEYAPPS",