@angular-helpers/storage 1.1.0 → 1.2.0

package/fesm2022/angular-helpers-storage.mjs

@@ -1,11 +1,20 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, signal, inject, DestroyRef, computed, Inject, Optional } from '@angular/core';
+import { InjectionToken, Inject, Injectable, signal, inject, DestroyRef, computed, Optional } from '@angular/core';
 
 /**
  * Token de inyección para el Transporte de Almacenamiento activo
  */
 const STORAGE_TRANSPORT = new InjectionToken('STORAGE_TRANSPORT');
 
+/**
+ * Injection token to configure the AES-GCM encryption passphrase for StorageTransports.
+ * Defaults to the legacy string for seamless backward compatibility.
+ */
+const SECURE_STORAGE_PASSPHRASE = new InjectionToken('SECURE_STORAGE_PASSPHRASE', {
+    providedIn: 'root',
+    factory: () => 'angular-helpers-secure-storage-passphrase',
+});
+
 const ENCRYPTION_SALT = new Uint8Array([7, 21, 14, 9, 3, 18, 5, 12, 1, 20, 16, 2, 8, 15, 6, 11]);
 function getCrypto() {
     if (typeof crypto !== 'undefined')
@@ -98,47 +107,54 @@ async function deserializeData(text, useToon = false) {
     return JSON.parse(text);
 }
 class LocalStorageTransport {
+    secretPassphrase;
     VIRTUAL_BASE_URL = 'https://angular-helpers.local/storage-cache/';
-    SECRET_PASSPHRASE = 'angular-helpers-secure-storage-passphrase';
     storageType = 'local';
     encrypt = false;
     dbName = 'ah_db';
     storeName = 'kv';
     cacheName = 'ah_cache';
-    constructor() {
+    constructor(secretPassphrase = 'fallback-passphrase-angular-helpers-default-key-sec') {
+        this.secretPassphrase = secretPassphrase;
         // If running in worker context, fall back to indexeddb as default L2
         if (typeof window === 'undefined') {
             this.storageType = 'indexeddb';
         }
     }
-    async openDB() {
+    async openDB(dbName, storeName) {
         return new Promise((resolve, reject) => {
-            const request = indexedDB.open(this.dbName, 1);
+            const request = indexedDB.open(dbName, 1);
             request.onupgradeneeded = () => {
                 const db = request.result;
-                if (!db.objectStoreNames.contains(this.storeName)) {
-                    db.createObjectStore(this.storeName);
+                if (!db.objectStoreNames.contains(storeName)) {
+                    db.createObjectStore(storeName);
                 }
             };
             request.onsuccess = () => resolve(request.result);
             request.onerror = () => reject(request.error);
         });
     }
-    async read(key, useToon) {
+    async read(key, options) {
         try {
-            if (this.storageType === 'cacheapi') {
+            const storageType = options?.storageType ?? this.storageType;
+            const encryptData = options?.encrypt ?? this.encrypt;
+            const dbName = options?.dbName ?? this.dbName;
+            const storeName = options?.storeName ?? this.storeName;
+            const cacheName = options?.cacheName ?? this.cacheName;
+            const useToon = options?.serializer === 'toon';
+            if (storageType === 'cacheapi') {
                 const cacheContext = getCaches();
                 if (!cacheContext) {
                     throw new Error('Cache API is not supported in this environment');
                 }
-                const cache = await cacheContext.open(this.cacheName);
+                const cache = await cacheContext.open(cacheName);
                 const url = `${this.VIRTUAL_BASE_URL}${key}`;
                 const response = await cache.match(url);
                 if (!response)
                     return undefined;
-                if (this.encrypt) {
+                if (encryptData) {
                     const cipherText = await response.text();
-                    const plainText = await decrypt(cipherText, this.SECRET_PASSPHRASE);
+                    const plainText = await decrypt(cipherText, this.secretPassphrase);
                     return await deserializeData(plainText, useToon);
                 }
                 if (useToon) {
@@ -149,11 +165,11 @@ class LocalStorageTransport {
                     return (await response.json());
                 }
             }
-            if (this.storageType === 'indexeddb') {
-                const db = await this.openDB();
+            if (storageType === 'indexeddb') {
+                const db = await this.openDB(dbName, storeName);
                 return new Promise((resolve, reject) => {
-                    const transaction = db.transaction(this.storeName, 'readonly');
-                    const store = transaction.objectStore(this.storeName);
+                    const transaction = db.transaction(storeName, 'readonly');
+                    const store = transaction.objectStore(storeName);
                     const request = store.get(key);
                     request.onsuccess = async () => {
                         const rawVal = request.result;
@@ -162,8 +178,8 @@ class LocalStorageTransport {
                             return;
                         }
                         try {
-                            if (this.encrypt) {
-                                const plainText = await decrypt(rawVal, this.SECRET_PASSPHRASE);
+                            if (encryptData) {
+                                const plainText = await decrypt(rawVal, this.secretPassphrase);
                                 resolve(await deserializeData(plainText, useToon));
                             }
                             else {
@@ -179,14 +195,14 @@ class LocalStorageTransport {
             }
             // Local or Session Storage (Main Thread Only)
             if (typeof window === 'undefined') {
-                throw new Error(`Storage type '${this.storageType}' is not supported in Worker context`);
+                throw new Error(`Storage type '${storageType}' is not supported in Worker context`);
             }
-            const storage = this.storageType === 'session' ? window.sessionStorage : window.localStorage;
+            const storage = storageType === 'session' ? window.sessionStorage : window.localStorage;
             const raw = storage.getItem(key);
             if (raw === null)
                 return undefined;
-            if (this.encrypt) {
-                const plainText = await decrypt(raw, this.SECRET_PASSPHRASE);
+            if (encryptData) {
+                const plainText = await decrypt(raw, this.secretPassphrase);
                 return await deserializeData(plainText, useToon);
             }
             return await deserializeData(raw, useToon);
@@ -196,33 +212,39 @@ class LocalStorageTransport {
             return undefined;
         }
     }
-    async write(key, data, useToon) {
+    async write(key, data, options) {
         try {
+            const storageType = options?.storageType ?? this.storageType;
+            const encryptData = options?.encrypt ?? this.encrypt;
+            const dbName = options?.dbName ?? this.dbName;
+            const storeName = options?.storeName ?? this.storeName;
+            const cacheName = options?.cacheName ?? this.cacheName;
+            const useToon = options?.serializer === 'toon';
             let payload = await serializeData(data, useToon);
-            if (this.encrypt) {
-                payload = await encrypt(payload, this.SECRET_PASSPHRASE);
+            if (encryptData) {
+                payload = await encrypt(payload, this.secretPassphrase);
             }
-            if (this.storageType === 'cacheapi') {
+            if (storageType === 'cacheapi') {
                 const cacheContext = getCaches();
                 if (!cacheContext) {
                     throw new Error('Cache API is not supported in this environment');
                 }
-                const cache = await cacheContext.open(this.cacheName);
+                const cache = await cacheContext.open(cacheName);
                 const url = `${this.VIRTUAL_BASE_URL}${key}`;
                 const response = new Response(payload, {
                     headers: {
-                        'Content-Type': useToon && !this.encrypt ? 'application/toon' : 'application/json',
+                        'Content-Type': useToon && !encryptData ? 'application/toon' : 'application/json',
                         'X-Storage-Date': new Date().toISOString(),
                     },
                 });
                 await cache.put(url, response);
                 return;
             }
-            if (this.storageType === 'indexeddb') {
-                const db = await this.openDB();
+            if (storageType === 'indexeddb') {
+                const db = await this.openDB(dbName, storeName);
                 return new Promise((resolve, reject) => {
-                    const transaction = db.transaction(this.storeName, 'readwrite');
-                    const store = transaction.objectStore(this.storeName);
+                    const transaction = db.transaction(storeName, 'readwrite');
+                    const store = transaction.objectStore(storeName);
                     const request = store.put(payload, key);
                     request.onsuccess = () => resolve();
                     request.onerror = () => reject(request.error);
@@ -230,32 +252,36 @@ class LocalStorageTransport {
             }
             // Local or Session Storage (Main Thread Only)
             if (typeof window === 'undefined') {
-                throw new Error(`Storage type '${this.storageType}' is not supported in Worker context`);
+                throw new Error(`Storage type '${storageType}' is not supported in Worker context`);
             }
-            const storage = this.storageType === 'session' ? window.sessionStorage : window.localStorage;
+            const storage = storageType === 'session' ? window.sessionStorage : window.localStorage;
             storage.setItem(key, payload);
         }
         catch (error) {
             console.error(`[LocalStorageTransport] Error al escribir clave: ${key}`, error);
         }
     }
-    async delete(key) {
+    async delete(key, options) {
         try {
-            if (this.storageType === 'cacheapi') {
+            const storageType = options?.storageType ?? this.storageType;
+            const dbName = options?.dbName ?? this.dbName;
+            const storeName = options?.storeName ?? this.storeName;
+            const cacheName = options?.cacheName ?? this.cacheName;
+            if (storageType === 'cacheapi') {
                 const cacheContext = getCaches();
                 if (!cacheContext) {
                     throw new Error('Cache API is not supported in this environment');
                 }
-                const cache = await cacheContext.open(this.cacheName);
+                const cache = await cacheContext.open(cacheName);
                 const url = `${this.VIRTUAL_BASE_URL}${key}`;
                 await cache.delete(url);
                 return;
             }
-            if (this.storageType === 'indexeddb') {
-                const db = await this.openDB();
+            if (storageType === 'indexeddb') {
+                const db = await this.openDB(dbName, storeName);
                 return new Promise((resolve, reject) => {
-                    const transaction = db.transaction(this.storeName, 'readwrite');
-                    const store = transaction.objectStore(this.storeName);
+                    const transaction = db.transaction(storeName, 'readwrite');
+                    const store = transaction.objectStore(storeName);
                     const request = store.delete(key);
                     request.onsuccess = () => resolve();
                     request.onerror = () => reject(request.error);
@@ -263,9 +289,9 @@ class LocalStorageTransport {
             }
             // Local or Session Storage (Main Thread Only)
             if (typeof window === 'undefined') {
-                throw new Error(`Storage type '${this.storageType}' is not supported in Worker context`);
+                throw new Error(`Storage type '${storageType}' is not supported in Worker context`);
             }
-            const storage = this.storageType === 'session' ? window.sessionStorage : window.localStorage;
+            const storage = storageType === 'session' ? window.sessionStorage : window.localStorage;
             storage.removeItem(key);
         }
         catch (error) {
@@ -289,13 +315,16 @@ class LocalStorageTransport {
         window.addEventListener('storage', listener);
         return () => window.removeEventListener('storage', listener);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: LocalStorageTransport, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: LocalStorageTransport, deps: [{ token: SECURE_STORAGE_PASSPHRASE }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: LocalStorageTransport, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: LocalStorageTransport, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SECURE_STORAGE_PASSPHRASE]
+                }] }] });
 
 class SafeReadonlyMap {
     _map;
@@ -340,21 +369,9 @@ function injectStorageSignal(key, defaultValue, options) {
     if (!transport) {
         transport = inject(LocalStorageTransport);
     }
-    // Configurar las propiedades de persistencia si es transporte local
-    if (transport instanceof LocalStorageTransport) {
-        transport.storageType = options.storageType;
-        transport.encrypt = !!options.encrypt;
-        if (options.dbName)
-            transport.dbName = options.dbName;
-        if (options.storeName)
-            transport.storeName = options.storeName;
-        if (options.cacheName)
-            transport.cacheName = options.cacheName;
-    }
-    const useToon = options.serializer === 'toon';
     // 1. Cargar valor inicial de L2
     transport
-        .read(key, useToon)
+        .read(key, options)
         .then((value) => {
         state.set({
             data: value !== undefined ? value : defaultValue,
@@ -374,7 +391,7 @@ function injectStorageSignal(key, defaultValue, options) {
     const originalUpdate = state.update.bind(state);
     const persist = (newData) => {
         transport
-            .write(key, newData, useToon)
+            .write(key, newData, options)
             .catch((err) => console.error(`[injectStorageSignal] Error escribiendo clave: ${key}`, err));
     };
     const customSignal = state;
@@ -498,21 +515,9 @@ class EntityStore {
     }
     initPersistence(key) {
         const transport = this._resolveTransport();
-        const useToon = this.options.storageOptions?.serializer === 'toon';
-        if (transport instanceof LocalStorageTransport && this.options.storageOptions) {
-            const opts = this.options.storageOptions;
-            transport.storageType = opts.storageType;
-            transport.encrypt = !!opts.encrypt;
-            if (opts.dbName)
-                transport.dbName = opts.dbName;
-            if (opts.storeName)
-                transport.storeName = opts.storeName;
-            if (opts.cacheName)
-                transport.cacheName = opts.cacheName;
-        }
         this._isRestoring = true;
         transport
-            .read(key, useToon)
+            .read(key, this.options.storageOptions)
             .then((data) => {
             if (data && Array.isArray(data)) {
                 this.setMany(data);
@@ -527,20 +532,8 @@ class EntityStore {
         if (this._isRestoring || !this.options.persistKey)
             return;
         const transport = this._resolveTransport();
-        const useToon = this.options.storageOptions?.serializer === 'toon';
-        if (transport instanceof LocalStorageTransport && this.options.storageOptions) {
-            const opts = this.options.storageOptions;
-            transport.storageType = opts.storageType;
-            transport.encrypt = !!opts.encrypt;
-            if (opts.dbName)
-                transport.dbName = opts.dbName;
-            if (opts.storeName)
-                transport.storeName = opts.storeName;
-            if (opts.cacheName)
-                transport.cacheName = opts.cacheName;
-        }
         transport
-            .write(this.options.persistKey, this.list(), useToon)
+            .write(this.options.persistKey, this.list(), this.options.storageOptions)
             .catch((err) => console.error(`[EntityStore] Error guardando entidades persistidas:`, err));
     }
 }
@@ -604,17 +597,19 @@ class WorkerStorageTransport {
             this.pendingRequests.clear();
         };
     }
-    read(key, useToon) {
+    read(key, options) {
         this.ensureWorker();
-        return this.postRequest('read', key, undefined, { useToon });
+        const useToon = options?.serializer === 'toon';
+        return this.postRequest('read', key, undefined, { ...options, useToon });
     }
-    write(key, data, useToon) {
+    write(key, data, options) {
         this.ensureWorker();
-        return this.postRequest('write', key, data, { useToon });
+        const useToon = options?.serializer === 'toon';
+        return this.postRequest('write', key, data, { ...options, useToon });
     }
-    delete(key) {
+    delete(key, options) {
         this.ensureWorker();
-        return this.postRequest('delete', key);
+        return this.postRequest('delete', key, undefined, options);
     }
     onChange(key, callback) {
         if (!this.changeCallbacks.has(key)) {
@@ -672,4 +667,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.13", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { EntityStore, LocalStorageTransport, STORAGE_TRANSPORT, STORAGE_WORKER_FACTORY, SafeReadonlyMap, WorkerStorageTransport, injectEntityStore, injectStorageSignal };
+export { EntityStore, LocalStorageTransport, SECURE_STORAGE_PASSPHRASE, STORAGE_TRANSPORT, STORAGE_WORKER_FACTORY, SafeReadonlyMap, WorkerStorageTransport, injectEntityStore, injectStorageSignal };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-helpers/storage",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Sistema de almacenamiento reactivo premium para Angular con soporte para Cache API, IndexedDB, compresión TOON y blindaje en runtime.",
   "homepage": "https://gaspar1992.github.io/angular-helpers/docs/storage",
   "repository": {

package/types/angular-helpers-storage.d.ts

@@ -27,15 +27,15 @@ interface StorageTransport {
     /**
      * Lee un valor persistido asíncronamente
      */
-    read<T>(key: string, useToon?: boolean): Promise<T | undefined>;
+    read<T>(key: string, options?: StorageSignalOptions): Promise<T | undefined>;
     /**
      * Escribe un valor persistido asíncronamente
      */
-    write<T>(key: string, data: T, useToon?: boolean): Promise<void>;
+    write<T>(key: string, data: T, options?: StorageSignalOptions): Promise<void>;
     /**
      * Elimina un valor persistido
      */
-    delete(key: string): Promise<void>;
+    delete(key: string, options?: StorageSignalOptions): Promise<void>;
     /**
      * Suscribe un callback para cambios externos (sincronización multi-pestaña)
      * Devuelve una función para des-suscribirse.
@@ -48,18 +48,18 @@ interface StorageTransport {
 declare const STORAGE_TRANSPORT: InjectionToken<StorageTransport>;
 
 declare class LocalStorageTransport implements StorageTransport {
+    private readonly secretPassphrase;
     private readonly VIRTUAL_BASE_URL;
-    private readonly SECRET_PASSPHRASE;
     storageType: 'local' | 'session' | 'indexeddb' | 'cacheapi';
     encrypt: boolean;
     dbName: string;
     storeName: string;
     cacheName: string;
-    constructor();
+    constructor(secretPassphrase?: string);
     private openDB;
-    read<T>(key: string, useToon?: boolean): Promise<T | undefined>;
-    write<T>(key: string, data: T, useToon?: boolean): Promise<void>;
-    delete(key: string): Promise<void>;
+    read<T>(key: string, options?: StorageSignalOptions): Promise<T | undefined>;
+    write<T>(key: string, data: T, options?: StorageSignalOptions): Promise<void>;
+    delete(key: string, options?: StorageSignalOptions): Promise<void>;
     onChange<T>(key: string, callback: (value: T) => void): () => void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageTransport, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageTransport>;
@@ -141,6 +141,12 @@ interface WorkerStorageResponse {
  */
 declare const STORAGE_WORKER_FACTORY: InjectionToken<() => Worker>;
 
+/**
+ * Injection token to configure the AES-GCM encryption passphrase for StorageTransports.
+ * Defaults to the legacy string for seamless backward compatibility.
+ */
+declare const SECURE_STORAGE_PASSPHRASE: InjectionToken<string>;
+
 declare class WorkerStorageTransport implements StorageTransport {
     private readonly workerFactory?;
     private worker?;
@@ -148,9 +154,9 @@ declare class WorkerStorageTransport implements StorageTransport {
     private readonly changeCallbacks;
     constructor(workerFactory?: () => Worker);
     private initWorker;
-    read<T>(key: string, useToon?: boolean): Promise<T | undefined>;
-    write<T>(key: string, data: T, useToon?: boolean): Promise<void>;
-    delete(key: string): Promise<void>;
+    read<T>(key: string, options?: StorageSignalOptions): Promise<T | undefined>;
+    write<T>(key: string, data: T, options?: StorageSignalOptions): Promise<void>;
+    delete(key: string, options?: StorageSignalOptions): Promise<void>;
     onChange<T>(key: string, callback: (value: T) => void): () => void;
     private ensureWorker;
     private generateId;
@@ -159,5 +165,5 @@ declare class WorkerStorageTransport implements StorageTransport {
     static ɵprov: i0.ɵɵInjectableDeclaration<WorkerStorageTransport>;
 }
 
-export { EntityStore, LocalStorageTransport, STORAGE_TRANSPORT, STORAGE_WORKER_FACTORY, SafeReadonlyMap, WorkerStorageTransport, injectEntityStore, injectStorageSignal };
+export { EntityStore, LocalStorageTransport, SECURE_STORAGE_PASSPHRASE, STORAGE_TRANSPORT, STORAGE_WORKER_FACTORY, SafeReadonlyMap, WorkerStorageTransport, injectEntityStore, injectStorageSignal };
 export type { EntityStoreOptions, StorageSignalOptions, StorageSignalState, StorageTransport, WorkerStorageAction, WorkerStorageRequest, WorkerStorageResponse };