@shaxpir/duiduidui-models 1.4.9 → 1.4.10

package/dist/repo/ShareSync.d.ts

@@ -46,6 +46,8 @@ export declare class ShareSync {
     private _durableStore;
     private _storageFactory?;
     constructor(encryption: Encryption, options: ShareSyncOptions);
+    private setupConnectionEvents;
+    private createConnectionWithDurableStore;
     private initializeDurableStore;
     isDebug(): boolean;
     isOnline(): boolean;

package/dist/repo/ShareSync.js

@@ -38,7 +38,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShareSync = exports.ShareSyncFactory = exports.ShareSyncDisposalStrategy = void 0;
 const client_1 = __importStar(require("@shaxpir/sharedb/lib/client"));
-const durable_store_1 = __importDefault(require("@shaxpir/sharedb/lib/client/durable-store"));
 const shaxpir_common_1 = require("@shaxpir/shaxpir-common");
 const reconnecting_websocket_1 = __importDefault(require("reconnecting-websocket"));
 const models_1 = require("../models");
@@ -111,62 +110,66 @@ class ShareSync {
             updateSocketIsOpen();
             shareSync._listener.onSocketEvent('error', event);
         });
-        // Create the ShareDB connection from the socket (without DurableStore initially)
-        shareSync._connection = new client_1.Connection(shareSync._socket);
-        // Initialize DurableStore asynchronously if enabled
+        // Initialize DurableStore first if enabled, then create connection with it
         if (shareSync._hasDurableStore) {
-            shareSync.initializeDurableStore(options).catch((error) => {
+            shareSync.initializeDurableStore(options).then(() => {
+                // Create connection with DurableStore options
+                shareSync._connection = shareSync.createConnectionWithDurableStore(shareSync._socket, options);
+                shareSync.setupConnectionEvents(options);
+            }).catch((error) => {
                 console.error('Failed to initialize DurableStore:', error);
                 shareSync._opErrorCallback && shareSync._opErrorCallback(error);
             });
         }
-        else if (options.onReadyCallback) {
-            // If there is no DurableStore, then we can call the onReadyCallback now. However,
-            // we have to use setTimeout to invoke it, because the callback will probably want
-            // to retrieve the ShareSync instance from the factory, and because the constructor
-            // hasn't actually finished yet, the INSTANCE pointer hasn't quite been assigned yet.
-            setTimeout(options.onReadyCallback, 1);
+        else {
+            // Create the ShareDB connection from the socket (without DurableStore)
+            shareSync._connection = new client_1.Connection(shareSync._socket);
+            shareSync.setupConnectionEvents(options);
+            if (options.onReadyCallback) {
+                // If there is no DurableStore, then we can call the onReadyCallback now. However,
+                // we have to use setTimeout to invoke it, because the callback will probably want
+                // to retrieve the ShareSync instance from the factory, and because the constructor
+                // hasn't actually finished yet, the INSTANCE pointer hasn't quite been assigned yet.
+                setTimeout(options.onReadyCallback, 1);
+            }
         }
-        shareSync._connection.on('error', (err) => {
+    }
+    setupConnectionEvents(options) {
+        this._connection.on('error', (err) => {
             console.error(`ShareSync connection error: ${err}\n  Error code: ${err.code}\n  Error message: ${err.message}\n  Error stack: ${err.stack}\n`);
         });
         // If the client provided a pingInterval option, then set up a periodic ping the
         // connection alive. Clients who don't provide this option will send pings.
-        if (options.pingInterval && typeof (options.pingInterval) === 'number') {
-            setInterval(() => { shareSync.ping(); }, options.pingInterval);
+        if (options && options.pingInterval && typeof (options.pingInterval) === 'number') {
+            setInterval(() => { this.ping(); }, options.pingInterval);
         }
     }
+    createConnectionWithDurableStore(socket, options) {
+        return new client_1.Connection(socket, {
+            durableStore: {
+                storage: this._storage,
+                debug: this._debug,
+                extVersionDecoder: (docData) => {
+                    if (docData &&
+                        docData.meta &&
+                        docData.meta.updated_at &&
+                        docData.meta.updated_at.utc_time) {
+                        return docData.meta.updated_at.utc_time;
+                    }
+                    return null;
+                },
+                onReadyCallback: options.onReadyCallback
+            }
+        });
+    }
     async initializeDurableStore(options) {
         try {
             // Create storage implementation if factory is provided
             if (this._storageFactory) {
                 this._storage = await this._storageFactory();
             }
-            // Create DurableStore with the storage
-            if (this._storage) {
-                this._durableStore = new durable_store_1.default(this._storage, {
-                    debug: this._debug,
-                    // Version decoder for determining document freshness
-                    // Uses the 'docData.meta.updated_at.utc_time' field (universal to all Model subclasses)
-                    extVersionDecoder: (docData) => {
-                        if (docData &&
-                            docData.meta &&
-                            docData.meta.updated_at &&
-                            docData.meta.updated_at.utc_time) {
-                            return docData.meta.updated_at.utc_time;
-                        }
-                        return null;
-                    }
-                });
-                // Attach DurableStore to connection
-                this._connection.useDurableStore(this._durableStore);
-                // Call ready callback once DurableStore is initialized
-                if (options.onReadyCallback) {
-                    options.onReadyCallback();
-                }
-            }
-            else {
-                console.warn('DurableStore enabled but no storage factory provided');
+            if (!this._storage) {
+                throw new Error('DurableStore enabled but no storage factory provided');
             }
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaxpir/duiduidui-models",
-  "version": "1.4.9",
+  "version": "1.4.10",
   "repository": {
     "type": "git",
     "url": "https://github.com/shaxpir/duiduidui-models"