ngx-sp-auth 4.5.0 → 4.5.2

package/fesm2022/ngx-sp-auth.mjs

@@ -230,11 +230,36 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImpo
                     args: [LIB_CUSTOM_ENVIRONMENT_SERVICE]
                 }] }] });
 
+/**
+ * Mecanismo simples de lock para evitar race conditions
+ * Garante que apenas uma operação crítica (init/delete) execute por vez
+ */
+class DatabaseLock {
+    constructor() {
+        this.isLocked = false;
+        this.queue = [];
+    }
+    async acquire(operation) {
+        while (this.isLocked) {
+            // Aguarda até que a lock seja liberada
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+        this.isLocked = true;
+        try {
+            return await operation();
+        }
+        finally {
+            this.isLocked = false;
+        }
+    }
+}
 class IndexedDBService {
     // #endregion ==========> PROPERTIES <==========
     constructor(_customEnvironment) {
         this._customEnvironment = _customEnvironment;
         this._dbName = "Sp_Filtros_";
+        this._lock = new DatabaseLock();
+        this._isInitialized = false;
         if (!window.indexedDB) {
             alert("Seu navegador não suporta uma versão estável do IndexedDB. Salvamento de filtros em sessão não estará disponível.");
         }
@@ -249,15 +274,16 @@ class IndexedDBService {
      * @param value Valor a ser inserido
      */
     async add(value) {
-        const db = await openDB(this._dbName, 1);
+        await this._ensureInitialized();
+        if (!this.request) {
+            throw new Error('Database not initialized. Call initializeDatabase() first.');
+        }
         try {
-            await db.add('filters', value);
+            await this.request.add('filters', value);
         }
-        finally {
-            try {
-                db.close();
-            }
-            catch (e) { /* não faz nada */ }
+        catch (error) {
+            console.error('Error adding value to IndexedDB:', error);
+            throw error;
         }
     }
     // #endregion ADD
@@ -265,20 +291,20 @@ class IndexedDBService {
     /**
      * Busca um valor na base dentro de um objectStore.
      *
-     * @param storeName Nome do objectStore
      * @param key Valor da chave única
      * @returns Promise<> com o valor encontrado ou undefined se não encontrar
      */
     async get(key) {
-        const db = await openDB(this._dbName, 1);
+        await this._ensureInitialized();
+        if (!this.request) {
+            throw new Error('Database not initialized. Call initializeDatabase() first.');
+        }
         try {
-            return await db.get('filters', key);
+            return await this.request.get('filters', key);
         }
-        finally {
-            try {
-                db.close();
-            }
-            catch (e) { /* não faz nada */ }
+        catch (error) {
+            console.error('Error getting value from IndexedDB:', error);
+            throw error;
         }
     }
     // #endregion GET
@@ -289,15 +315,16 @@ class IndexedDBService {
      * @param value Valor atualizado
      */
     async update(value) {
-        const db = await openDB(this._dbName, 1);
+        await this._ensureInitialized();
+        if (!this.request) {
+            throw new Error('Database not initialized. Call initializeDatabase() first.');
+        }
         try {
-            await db.put('filters', value);
+            await this.request.put('filters', value);
         }
-        finally {
-            try {
-                db.close();
-            }
-            catch (e) { /* não faz nada */ }
+        catch (error) {
+            console.error('Error updating value in IndexedDB:', error);
+            throw error;
         }
     }
     // #endregion UPDATE
@@ -308,82 +335,154 @@ class IndexedDBService {
      * @param key Valor da chave única
      */
     async delete(key) {
-        const db = await openDB(this._dbName, 1);
+        await this._ensureInitialized();
+        if (!this.request) {
+            throw new Error('Database not initialized. Call initializeDatabase() first.');
+        }
         try {
-            await db.delete('filters', key);
+            await this.request.delete('filters', key);
         }
-        finally {
-            try {
-                db.close();
-            }
-            catch (e) { /* não faz nada */ }
+        catch (error) {
+            console.error('Error deleting value from IndexedDB:', error);
+            throw error;
         }
     }
     // #endregion DELETE
     // #endregion ==========> ACTIONS <==========
     // #region ==========> UTILS <==========
+    /**
+     * Garante que a database foi inicializada antes de usar qualquer operação.
+     * Se `initializeDatabase()` foi chamado mas ainda não completou, aguarda a promise.
+     * Previne race conditions ao tentar usar operações durante a inicialização.
+     *
+     * @private
+     */
+    async _ensureInitialized() {
+        // Se já está inicializando, aguarda a promise existente
+        if (this._initPromise) {
+            await this._initPromise;
+            return;
+        }
+        // Se já foi inicializado com sucesso, retorna imediatamente
+        if (this._isInitialized && this.request) {
+            return;
+        }
+        // Se chegou aqui e não está inicializado, significa que initializeDatabase() não foi chamado
+        throw new Error('IndexedDB not initialized. Call initializeDatabase() and await it before using any operations.');
+    }
     /**
      * Inicializa as configurações iniciais do IndexedDB e já cria o objectStore que será utilizado caso não exista.
      *
-     * O object store que será criado terá sua chave inline na propriedade `key` e o índice será a propriedade `context`, portanto todos os valores que forem inseridos **DEVEM** ser um objeto com pelo menos a propriedade `key` e `context`.
-     * Deve ser chamado no constructor do seu componente para garantir inicialização correta pelo componente
+     * ⚠️ IMPORTANTE: Deve ser chamado com `await` no ngOnInit() do seu componente, não no constructor!
+     *
+     * O object store que será criado terá sua chave inline na propriedade `key` e o índice será a propriedade `context`,
+     * portanto todos os valores que forem inseridos **DEVEM** ser um objeto com pelo menos a propriedade `key` e `context`.
      *
-     * @param dbName Nome da base de dados que será usada
+     * @example
+     * async ngOnInit() {
+     *   await this._indexedDB.initializeDatabase();
+     *   const restored = await this._indexedDB.get('minha-chave');
+     * }
     */
     async initializeDatabase() {
-        this.request = await openDB(this._dbName, 1, {
-            upgrade(db) {
-                // Criar objectStore se não houver um mesmo com este nome
-                if (!db.objectStoreNames.contains('filters')) {
-                    const store = db.createObjectStore('filters', { keyPath: 'key' });
-                    store.createIndex('context', 'context');
-                }
-            },
-            blocked() {
-                // notify user / log: another tab has old version open
-                console.warn('IndexedDB blocked — feche outras abas');
-            },
-            blocking() {
-                // this instance is blocking a future version request
-                console.warn('IndexedDB blocking — considere fechar esta conexão');
+        return this._lock.acquire(async () => {
+            // Se já está inicializado, não refaz
+            if (this._isInitialized && this.request) {
+                return;
+            }
+            // Marca que está inicializando
+            const initPromise = this._performInitialization();
+            this._initPromise = initPromise;
+            try {
+                await initPromise;
+                this._isInitialized = true;
+            }
+            finally {
+                this._initPromise = undefined;
             }
         });
     }
+    /**
+     * Executa a inicialização real da database.
+     * @private
+     */
+    async _performInitialization() {
+        try {
+            this.request = await openDB(this._dbName, 1, {
+                upgrade(db) {
+                    // Criar objectStore se não houver um mesmo com este nome
+                    if (!db.objectStoreNames.contains('filters')) {
+                        const store = db.createObjectStore('filters', { keyPath: 'key' });
+                        store.createIndex('context', 'context');
+                    }
+                },
+                blocked() {
+                    console.warn('IndexedDB blocked — feche outras abas com esta aplicação');
+                },
+                blocking() {
+                    console.warn('IndexedDB blocking — recarregue a página se persistir');
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error initializing IndexedDB:', error);
+            throw error;
+        }
+    }
     /**
      * Exclui uma database do IndexedDB com base no nome.
      *
-     * @param name Nome da database
+     * Deve ser chamado durante o logout para limpar dados do usuário.
+     *
+     * @example
+     * await this._indexedDB.closeOpenConnection();
+     * await this._indexedDB.deleteDatabase();
     */
     async deleteDatabase() {
-        // Fecha a conexão persistente local, se existir, antes de tentar excluir a DB
-        if (this.request) {
+        return this._lock.acquire(async () => {
+            // Fecha a conexão persistente local, se existir, antes de tentar excluir a DB
+            await this._closeConnection();
             try {
-                this.request.close();
+                await deleteDB(this._dbName);
+                this._isInitialized = false;
             }
             catch (err) {
-                console.warn('deleteDatabase() => erro ao fechar conexão local', err);
+                console.warn('Error deleting IndexedDB:', err);
+                throw err;
             }
-            this.request = undefined;
-        }
-        return await deleteDB(this._dbName);
+        });
     }
     /**
      * Fecha a conexão persistente (se existir) sem excluir a database.
      * Útil para cenários onde se precisa liberar a conexão antes de chamar `deleteDatabase()`.
+     *
+     * @example
+     * await this._indexedDB.closeOpenConnection();
     */
     async closeOpenConnection() {
+        return this._lock.acquire(async () => {
+            await this._closeConnection();
+        });
+    }
+    /**
+     * Executa o fechamento real da conexão.
+     * @private
+     */
+    async _closeConnection() {
         if (this.request) {
             try {
                 this.request.close();
             }
             catch (err) {
-                console.warn('closeOpenConnection() => erro ao fechar conexão', err);
+                console.warn('Error closing IndexedDB connection:', err);
             }
             this.request = undefined;
+            this._isInitialized = false;
         }
     }
     /**
-     * Valida se já existe um valor cadastrado na base com a chave-única que foi informada, se houver retorna ele, caso contrário cria um registro placeholder para poder atualizar depois.
+     * Valida se já existe um valor cadastrado na base com a chave-única que foi informada,
+     * se houver retorna ele, caso contrário cria um registro placeholder para poder atualizar depois.
      *
      * @param key Valor da chave única
      * @param value (opcional) Valor placeholder caso não exista um valor previamente criado
@@ -396,6 +495,7 @@ class IndexedDBService {
         if (!this._restored && value) {
             // Se não existir nada, inicializa um registro placeholder dentro do objectStore existente
             await this.add(value);
+            return value?.payload;
         }
         else {
             // Se encontrar valor retorna apenas o payload com os dados que serão usados na tela