favalib 0.0.2 → 0.0.4

package/build/TwoFaLib.d.mts

@@ -72,13 +72,9 @@ declare class TwoFaLib extends TypedEventTarget<TwoFaLibEventMapEvents> {
     /**
      * Sets a server url, this will allow syncing with the server.
      * @param serverUrl - The server url.
+     * @param force - Force setting the sync server url, even if no connection can be made
      */
-    setSyncServerUrl(serverUrl: string): Promise<void>;
-    /**
-     * Sets the sync state, this will initiate the sync manager instance.
-     * @param syncState - The state of the sync.
-     */
-    private setSyncState;
+    setSyncServerUrl(serverUrl: string, force?: boolean): Promise<void>;
     /**
      * Dispatches a library event.
      * @param eventType - The type of the event to dispatch, uses the TwoFaLibEvent enum.

package/build/TwoFaLib.mjs

@@ -1,8 +1,8 @@
 import { TypedEventTarget } from 'typescript-event-target';
 import TwoFaLibMediator from './TwoFaLibMediator.mjs';
 import { TwoFaLibEvent } from './TwoFaLibEvent.mjs';
-import { InitializationError } from './TwoFALibError.mjs';
-import SyncManager from './subclasses/SyncManager.mjs';
+import { InitializationError, SyncError } from './TwoFALibError.mjs';
+import SyncManager, { ConnectionStatus } from './subclasses/SyncManager.mjs';
 import LibraryLoader from './subclasses/LibraryLoader.mjs';
 import ExportImportManager from './subclasses/ExportImportManager.mjs';
 import PersistentStorageManager from './subclasses/PersistentStorageManager.mjs';
@@ -72,7 +72,8 @@ class TwoFaLib extends TypedEventTarget {
             this.mediator.getComponent('vaultDataManager').replaceVault(vault);
         }
         if (syncState?.serverUrl) {
-            this.setSyncState(syncState);
+            // Initiate the syncManager
+            this.mediator.registerComponent('syncManager', new SyncManager(this.mediator, this.deviceType, this.publicKey, this.privateKey, syncState, this.deviceId));
         }
         else {
             // If no syncmanager we're ready now, otherwise the syncmanager is responsible for emitting the ready event
@@ -139,27 +140,47 @@ class TwoFaLib extends TypedEventTarget {
     /**
      * Sets a server url, this will allow syncing with the server.
      * @param serverUrl - The server url.
+     * @param force - Force setting the sync server url, even if no connection can be made
      */
-    async setSyncServerUrl(serverUrl) {
+    async setSyncServerUrl(serverUrl, force = false) {
         if (this.sync) {
+            // close connection so no data is send to the old syncServer
             this.sync.closeServerConnection();
-            this.mediator.unRegisterComponent('syncManager');
         }
         const newSyncState = {
             serverUrl,
             devices: [],
             commandSendQueue: [],
         };
-        this.setSyncState(newSyncState);
+        const newSyncManager = new SyncManager(this.mediator, this.deviceType, this.publicKey, this.privateKey, newSyncState, this.deviceId);
+        const success = await new Promise((resolve) => {
+            this.addEventListener(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, (event) => {
+                if (event.detail.newStatus === ConnectionStatus.CONNECTED) {
+                    resolve(true);
+                }
+                if (event.detail.newStatus === ConnectionStatus.FAILED) {
+                    resolve(false);
+                }
+            });
+        });
+        if (!success) {
+            if (force) {
+                this.log('warning', `Failed to connect to server at ${serverUrl}, force setting`);
+            }
+            else {
+                if (this.sync) {
+                    // re-establish old connection
+                    this.sync.initServerConnection();
+                }
+                newSyncManager.closeServerConnection();
+                throw new SyncError(`Failed to connect to server at ${serverUrl}, not setting`);
+            }
+        }
+        // connection succeeded (or force=true), switch to the new syncManager
+        this.mediator.unRegisterComponent('syncManager');
+        this.mediator.registerComponent('syncManager', newSyncManager);
         await this.forceSave();
     }
-    /**
-     * Sets the sync state, this will initiate the sync manager instance.
-     * @param syncState - The state of the sync.
-     */
-    setSyncState(syncState) {
-        this.mediator.registerComponent('syncManager', new SyncManager(this.mediator, this.deviceType, this.publicKey, this.privateKey, syncState, this.deviceId));
-    }
     /**
      * Dispatches a library event.
      * @param eventType - The type of the event to dispatch, uses the TwoFaLibEvent enum.

package/build/interfaces/Events.d.mts

@@ -1,6 +1,7 @@
 import type { EmptyObject } from 'type-fest';
 import type { TwoFaLibEvent } from '../TwoFaLibEvent.mjs';
 import type { LockedRepresentationString } from './Vault.mjs';
+import type { ConnectionStatus } from '../subclasses/SyncManager.mjs';
 export interface ChangedEvent {
     newLockedRepresentationString: LockedRepresentationString;
 }
@@ -9,7 +10,7 @@ export interface TwoFaLibEventMap {
     [TwoFaLibEvent.LoadedFromLockedRepresentation]: EmptyObject;
     [TwoFaLibEvent.ConnectToExistingVaultFinished]: EmptyObject;
     [TwoFaLibEvent.ConnectionToSyncServerStatusChanged]: {
-        connected: boolean;
+        newStatus: ConnectionStatus;
     };
     [TwoFaLibEvent.Log]: {
         severity: 'info' | 'warning';

package/build/subclasses/SyncManager.d.mts

@@ -6,6 +6,12 @@ import { VaultSyncStateWithServerUrl } from '../interfaces/Vault.mjs';
 import { SyncCommandFromServer } from 'favaserver/ServerMessage';
 import { SyncCommandFromClient } from 'favaserver/ClientMessage';
 import type { AddSyncDeviceData } from '../Command/commands/AddSyncDeviceCommand.mjs';
+export declare enum ConnectionStatus {
+    CONNECTING = 0,
+    CONNECTED = 1,
+    NOT_CONNECTED = 2,
+    FAILED = 3
+}
 /**
  * Manages synchronization of 2FA devices and communication with the server.
  */
@@ -24,6 +30,7 @@ declare class SyncManager {
     private commandSendQueue;
     private reconnectTimeout?;
     private terminateTimeout?;
+    private connectionFailedTimeout?;
     private shouldReconnect;
     /**
      * Public getter for the command send queue.

package/build/subclasses/SyncManager.mjs

@@ -7,6 +7,13 @@ import { InitializationError, SyncAddDeviceFlowConflictError, SyncError, SyncInW
 import AddSyncDeviceCommand from '../Command/commands/AddSyncDeviceCommand.mjs';
 const IN_TESTING = process.env.NODE_ENV === 'test';
 const IN_DEV = process.env.NODE_ENV === 'development';
+export var ConnectionStatus;
+(function (ConnectionStatus) {
+    ConnectionStatus[ConnectionStatus["CONNECTING"] = 0] = "CONNECTING";
+    ConnectionStatus[ConnectionStatus["CONNECTED"] = 1] = "CONNECTED";
+    ConnectionStatus[ConnectionStatus["NOT_CONNECTED"] = 2] = "NOT_CONNECTED";
+    ConnectionStatus[ConnectionStatus["FAILED"] = 3] = "FAILED";
+})(ConnectionStatus || (ConnectionStatus = {}));
 const generateNonCryptographicRandomString = () => {
     const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
     const length = Math.floor(Math.random() * 64) + 1;
@@ -53,6 +60,16 @@ class SyncManager {
         this.commandSendQueue = commandSendQueue;
         this.serverUrl = serverUrl;
         this.initServerConnection();
+        // if not yet connected after 2 tries, emit ready event so we can continue
+        this.connectionFailedTimeout = setTimeout(() => {
+            if (!this.readyEventEmitted && !this.webSocketConnected) {
+                this.log('warning', 'Failed to connect to sync backend');
+                this.dispatchLibEvent(TwoFaLibEvent.Ready);
+                this.dispatchLibEvent(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, {
+                    newStatus: ConnectionStatus.FAILED,
+                });
+            }
+        }, this.reconnectInterval + 1000);
     }
     get libraryLoader() {
         return this.mediator.getComponent('libraryLoader');
@@ -123,8 +140,10 @@ class SyncManager {
             this.log('info', 'Connected to server.');
             this.sendToServer('connect', { deviceId: syncManager.deviceId });
             this.dispatchLibEvent(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, {
-                connected: true,
+                newStatus: ConnectionStatus.CONNECTED,
             });
+            clearTimeout(this.connectionFailedTimeout);
+            this.connectionFailedTimeout = undefined;
             // send any commands that were done while offline
             void this.processCommandSendQueue();
         });
@@ -132,15 +151,18 @@ class SyncManager {
         this.ws = ws;
     }
     handleWebSocketClose(event) {
-        this.dispatchLibEvent(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, {
-            connected: false,
-        });
         if (this.shouldReconnect) {
+            this.dispatchLibEvent(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, {
+                newStatus: ConnectionStatus.CONNECTING,
+            });
             // if we shouldn't reconnect, this closing is expected
             this.log('warning', `WebSocket closed: ${event.code} ${event.reason}`);
             this.attemptReconnect();
         }
         else {
+            this.dispatchLibEvent(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, {
+                newStatus: ConnectionStatus.NOT_CONNECTED,
+            });
             // Connection closed, no need to force terminate
             if (this.terminateTimeout) {
                 clearTimeout(this.terminateTimeout);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "favalib",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "",
   "type": "module",
   "exports": {