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

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

@@ -90,5 +90,5 @@ export interface BucketStorageAdapter extends BaseObserver<BucketStorageListener
     /**
      * Invokes the `powersync_control` function for the sync client.
      */
-    control(op: PowerSyncControlCommand, payload: string | ArrayBuffer | null): Promise<string>;
+    control(op: PowerSyncControlCommand, payload: string | Uint8Array | null): Promise<string>;
 }

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

@@ -56,7 +56,7 @@ export declare class SqliteBucketStorage extends BaseObserver<BucketStorageListe
      * Set a target checkpoint.
      */
     setTargetCheckpoint(checkpoint: Checkpoint): Promise<void>;
-    control(op: PowerSyncControlCommand, payload: string | ArrayBuffer | null): Promise<string>;
+    control(op: PowerSyncControlCommand, payload: string | Uint8Array | ArrayBuffer | null): Promise<string>;
     hasMigratedSubkeys(): Promise<boolean>;
     migrateToFixedSubkeys(): Promise<void>;
     static _subkeyMigrationKey: string;

package/lib/client/sync/stream/AbstractRemote.d.ts

@@ -1,5 +1,4 @@
 import type { BSON } from 'bson';
-import { Buffer } from 'buffer';
 import { type fetch } from 'cross-fetch';
 import Logger, { ILogger } from 'js-logger';
 import { DataStream } from '../../../utils/DataStream.js';
@@ -133,7 +132,7 @@ export declare abstract class AbstractRemote {
      * @param bson A BSON encoder and decoder. When set, the data stream will be requested with a BSON payload
      * (required for compatibility with older sync services).
      */
-    socketStreamRaw<T>(options: SocketSyncStreamOptions, map: (buffer: Buffer) => T, bson?: typeof BSON): Promise<DataStream>;
+    socketStreamRaw<T>(options: SocketSyncStreamOptions, map: (buffer: Uint8Array) => T, bson?: typeof BSON): Promise<DataStream<T>>;
     /**
      * Connects to the sync/stream http endpoint, parsing lines as JSON.
      */

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

@@ -10,8 +10,12 @@ const POWERSYNC_JS_VERSION = PACKAGE.version;
 const SYNC_QUEUE_REQUEST_LOW_WATER = 5;
 // Keep alive message is sent every period
 const KEEP_ALIVE_MS = 20_000;
-// The ACK must be received in this period
-const KEEP_ALIVE_LIFETIME_MS = 30_000;
+// One message of any type must be received in this period.
+const SOCKET_TIMEOUT_MS = 30_000;
+// One keepalive message must be received in this period.
+// If there is a backlog of messages (for example on slow connections), keepalive messages could be delayed
+// significantly. Therefore this is longer than the socket timeout.
+const KEEP_ALIVE_LIFETIME_MS = 90_000;
 export const DEFAULT_REMOTE_LOGGER = Logger.get('PowerSyncRemote');
 export var FetchStrategy;
 (function (FetchStrategy) {
@@ -208,12 +212,25 @@ export class AbstractRemote {
         // headers with websockets on web. The browser userAgent is however added
         // automatically as a header.
         const userAgent = this.getUserAgent();
+        let keepAliveTimeout;
+        const resetTimeout = () => {
+            clearTimeout(keepAliveTimeout);
+            keepAliveTimeout = setTimeout(() => {
+                this.logger.error(`No data received on WebSocket in ${SOCKET_TIMEOUT_MS}ms, closing connection.`);
+                stream.close();
+            }, SOCKET_TIMEOUT_MS);
+        };
+        resetTimeout();
         const url = this.options.socketUrlTransformer(request.url);
         const connector = new RSocketConnector({
             transport: new WebsocketClientTransport({
                 url,
                 wsCreator: (url) => {
-                    return this.createSocket(url);
+                    const socket = this.createSocket(url);
+                    socket.addEventListener('message', (event) => {
+                        resetTimeout();
+                    });
+                    return socket;
                 }
             }),
             setup: {
@@ -236,16 +253,20 @@ export class AbstractRemote {
         }
         catch (ex) {
             this.logger.error(`Failed to connect WebSocket`, ex);
+            clearTimeout(keepAliveTimeout);
             throw ex;
         }
+        resetTimeout();
         const stream = new DataStream({
             logger: this.logger,
             pressure: {
                 lowWaterMark: SYNC_QUEUE_REQUEST_LOW_WATER
-            }
+            },
+            mapLine: map
         });
         let socketIsClosed = false;
         const closeSocket = () => {
+            clearTimeout(keepAliveTimeout);
             if (socketIsClosed) {
                 return;
             }
@@ -307,7 +328,7 @@ export class AbstractRemote {
                     if (!data) {
                         return;
                     }
-                    stream.enqueueData(map(data));
+                    stream.enqueueData(data);
                 },
                 onComplete: () => {
                     stream.close();
@@ -418,7 +439,8 @@ export class AbstractRemote {
         const decoder = new TextDecoder();
         let buffer = '';
         const stream = new DataStream({
-            logger: this.logger
+            logger: this.logger,
+            mapLine: mapLine
         });
         const l = stream.registerListener({
             lowWater: async () => {
@@ -429,7 +451,7 @@ export class AbstractRemote {
                         if (done) {
                             const remaining = buffer.trim();
                             if (remaining.length != 0) {
-                                stream.enqueueData(mapLine(remaining));
+                                stream.enqueueData(remaining);
                             }
                             stream.close();
                             await closeReader();
@@ -441,7 +463,7 @@ export class AbstractRemote {
                         for (var i = 0; i < lines.length - 1; i++) {
                             var l = lines[i].trim();
                             if (l.length > 0) {
-                                stream.enqueueData(mapLine(l));
+                                stream.enqueueData(l);
                                 didCompleteLine = true;
                             }
                         }

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

@@ -668,19 +668,35 @@ The next upload iteration will be delayed.`);
                 data: instr.request
             };
             if (resolvedOptions.connectionMethod == SyncStreamConnectionMethod.HTTP) {
-                controlInvocations = await remote.postStreamRaw(syncOptions, (line) => ({
-                    command: PowerSyncControlCommand.PROCESS_TEXT_LINE,
-                    payload: line
-                }));
+                controlInvocations = await remote.postStreamRaw(syncOptions, (line) => {
+                    if (typeof line == 'string') {
+                        return {
+                            command: PowerSyncControlCommand.PROCESS_TEXT_LINE,
+                            payload: line
+                        };
+                    }
+                    else {
+                        // Directly enqueued by us
+                        return line;
+                    }
+                });
             }
             else {
                 controlInvocations = await remote.socketStreamRaw({
                     ...syncOptions,
                     fetchStrategy: resolvedOptions.fetchStrategy
-                }, (buffer) => ({
-                    command: PowerSyncControlCommand.PROCESS_BSON_LINE,
-                    payload: buffer
-                }));
+                }, (payload) => {
+                    if (payload instanceof Uint8Array) {
+                        return {
+                            command: PowerSyncControlCommand.PROCESS_BSON_LINE,
+                            payload: payload
+                        };
+                    }
+                    else {
+                        // Directly enqueued by us
+                        return payload;
+                    }
+                });
             }
             try {
                 while (!controlInvocations.closed) {

package/lib/utils/DataStream.d.ts

@@ -1,6 +1,7 @@
 import { ILogger } from 'js-logger';
 import { BaseListener, BaseObserver } from './BaseObserver.js';
-export type DataStreamOptions = {
+export type DataStreamOptions<ParsedData, SourceData> = {
+    mapLine?: (line: SourceData) => ParsedData;
     /**
      * Close the stream if any consumer throws an error
      */
@@ -28,13 +29,14 @@ export declare const DEFAULT_PRESSURE_LIMITS: {
  * native JS streams or async iterators.
  * This is handy for environments such as React Native which need polyfills for the above.
  */
-export declare class DataStream<Data extends any = any> extends BaseObserver<DataStreamListener<Data>> {
-    protected options?: DataStreamOptions | undefined;
-    dataQueue: Data[];
+export declare class DataStream<ParsedData, SourceData = any> extends BaseObserver<DataStreamListener<ParsedData>> {
+    protected options?: DataStreamOptions<ParsedData, SourceData> | undefined;
+    dataQueue: SourceData[];
     protected isClosed: boolean;
     protected processingPromise: Promise<void> | null;
     protected logger: ILogger;
-    constructor(options?: DataStreamOptions | undefined);
+    protected mapLine: (line: SourceData) => ParsedData;
+    constructor(options?: DataStreamOptions<ParsedData, SourceData> | undefined);
     get highWatermark(): number;
     get lowWatermark(): number;
     get closed(): boolean;
@@ -42,22 +44,18 @@ export declare class DataStream<Data extends any = any> extends BaseObserver<Dat
     /**
      * Enqueues data for the consumers to read
      */
-    enqueueData(data: Data): void;
+    enqueueData(data: SourceData): void;
     /**
      * Reads data once from the data stream
      * @returns a Data payload or Null if the stream closed.
      */
-    read(): Promise<Data | null>;
+    read(): Promise<ParsedData | null>;
     /**
      * Executes a callback for each data item in the stream
      */
-    forEach(callback: DataStreamCallback<Data>): () => void;
+    forEach(callback: DataStreamCallback<ParsedData>): () => void;
     protected processQueue(): Promise<void>;
-    /**
-     * Creates a new data stream which is a map of the original
-     */
-    map<ReturnData>(callback: (data: Data) => ReturnData): DataStream<ReturnData>;
     protected hasDataReader(): boolean;
     protected _processQueue(): Promise<void>;
-    protected iterateAsyncErrored(cb: (l: BaseListener) => Promise<void>): Promise<void>;
+    protected iterateAsyncErrored(cb: (l: Partial<DataStreamListener<ParsedData>>) => Promise<void>): Promise<void>;
 }

package/lib/utils/DataStream.js

@@ -15,12 +15,14 @@ export class DataStream extends BaseObserver {
     isClosed;
     processingPromise;
     logger;
+    mapLine;
     constructor(options) {
         super();
         this.options = options;
         this.processingPromise = null;
         this.isClosed = false;
         this.dataQueue = [];
+        this.mapLine = options?.mapLine ?? ((line) => line);
         this.logger = options?.logger ?? Logger.get('DataStream');
         if (options?.closeOnError) {
             const l = this.registerListener({
@@ -110,22 +112,6 @@ export class DataStream extends BaseObserver {
         }
         return (this.processingPromise = this._processQueue());
     }
-    /**
-     * Creates a new data stream which is a map of the original
-     */
-    map(callback) {
-        const stream = new DataStream(this.options);
-        const l = this.registerListener({
-            data: async (data) => {
-                stream.enqueueData(callback(data));
-            },
-            closed: () => {
-                stream.close();
-                l?.();
-            }
-        });
-        return stream;
-    }
     hasDataReader() {
         return Array.from(this.listeners.values()).some((l) => !!l.data);
     }
@@ -136,7 +122,8 @@ export class DataStream extends BaseObserver {
         }
         if (this.dataQueue.length) {
             const data = this.dataQueue.shift();
-            await this.iterateAsyncErrored(async (l) => l.data?.(data));
+            const mapped = this.mapLine(data);
+            await this.iterateAsyncErrored(async (l) => l.data?.(mapped));
         }
         if (this.dataQueue.length <= this.lowWatermark) {
             await this.iterateAsyncErrored(async (l) => l.lowWater?.());
@@ -148,7 +135,7 @@ export class DataStream extends BaseObserver {
         }
     }
     async iterateAsyncErrored(cb) {
-        for (let i of Array.from(this.listeners.values())) {
+        for (let i of this.listeners.values()) {
             try {
                 await cb(i);
             }

package/package.json

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