synapse-storage 3.0.19 → 4.0.1

package/dist/core/storage/adapters/indexed-DB.service.d.ts

@@ -0,0 +1,89 @@
+import { IAsyncPluginExecutor } from '../modules/plugin/plugin.interface';
+import { ConfigureAsyncMiddlewares, IEventEmitter, ILogger, IndexedDBStorageConfig, StorageType } from '../storage.interface';
+import { StorageKey, StorageKeyType } from '../utils/storage-key';
+import { AsyncBaseStorage } from './async-base-storage.service';
+export interface IndexedDBConfig {
+    dbName?: string;
+}
+export declare class IndexedDBManager {
+    private readonly dbName;
+    private readonly logger?;
+    private static instances;
+    private db;
+    private initPromise;
+    private storeNames;
+    private dbVersion;
+    private constructor();
+    static getInstance(dbName: string, dbVersion?: number, logger?: ILogger): IndexedDBManager;
+    initialize(): Promise<IDBDatabase>;
+    private autoDetectAndOpen;
+    private detectCurrentVersion;
+    ensureStoreExists(storeName: string): Promise<IDBDatabase>;
+    private openDatabase;
+    closeDatabase(): void;
+    deleteDatabase(): Promise<void>;
+    ensureStoresExist(storeNames: string[]): Promise<IDBDatabase>;
+    getCurrentVersion(): number;
+}
+export declare class IndexedDBStorage<T extends Record<string, any>> extends AsyncBaseStorage<T> {
+    protected static readonly STORAGE_TYPE: StorageType;
+    readonly type: StorageType;
+    private readonly DB_NAME;
+    private readonly STORE_NAME;
+    private dbManager;
+    constructor(config: IndexedDBStorageConfig<T>, pluginExecutor?: IAsyncPluginExecutor, eventEmitter?: IEventEmitter, logger?: ILogger);
+    static create<T extends Record<string, any>>(config: IndexedDBStorageConfig, pluginExecutor?: IAsyncPluginExecutor, eventEmitter?: IEventEmitter, logger?: ILogger): IndexedDBStorage<T>;
+    protected doInitialize(): Promise<this>;
+    static createStorages<S extends Record<string, any>>(dbName: string, configs: {
+        [K in keyof S]: {
+            name: string;
+            initialState?: S[K];
+            middlewares?: ConfigureAsyncMiddlewares;
+            pluginExecutor?: IAsyncPluginExecutor;
+            eventEmitter?: IEventEmitter;
+        };
+    }, logger?: ILogger): Promise<{
+        [K in keyof S]: IndexedDBStorage<S[K]>;
+    }>;
+    /**
+     * Выполняет операцию в рамках IDB-транзакции.
+     * Обёртка для низкоуровневого IDB transaction API.
+     *
+     * @param mode - Режим транзакции ('readonly' | 'readwrite')
+     * @param fn - Callback, получающий IDBObjectStore. Возвращает результат операции.
+     * @returns Promise с результатом callback-а
+     */
+    transaction<R>(mode: IDBTransactionMode, fn: (store: IDBObjectStore) => IDBRequest<R> | R): Promise<R>;
+    /**
+     * Текущая версия базы данных.
+     */
+    get dbVersion(): number;
+    /**
+     * Имя базы данных.
+     */
+    get dbName(): string;
+    /**
+     * Имя object store в IndexedDB.
+     */
+    get storeName(): string;
+    private getTransaction;
+    private getObjectStore;
+    protected doGet(key: StorageKeyType): Promise<any>;
+    protected doSet(key: StorageKeyType, value: any): Promise<void>;
+    private putValueInStore;
+    protected doUpdate(updates: Array<{
+        key: string | StorageKey;
+        value: any;
+    }>): Promise<void>;
+    protected doDelete(key: StorageKeyType): Promise<boolean>;
+    protected doClear(): Promise<void>;
+    protected doKeys(): Promise<string[]>;
+    protected doHas(key: StorageKeyType): Promise<boolean>;
+    /**
+     * Override performCleanup: persistent storage should NOT clear data on destroy.
+     * Only clean up middleware and runtime resources, not persisted data.
+     */
+    protected performCleanup(): Promise<void>;
+    protected doDestroy(): Promise<void>;
+}
+//# sourceMappingURL=indexed-DB.service.d.ts.map

package/dist/core/storage/adapters/indexed-DB.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexed-DB.service.d.ts","sourceRoot":"","sources":["../../../../src/core/storage/adapters/indexed-DB.service.ts"],"names":[],"mappings":"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"}

package/dist/core/storage/adapters/indexed-DB.service.js

@@ -0,0 +1,596 @@
+import { SingletonMixin } from "../modules/singleton/mixin.util.js";
+import { StorageKey } from "../utils/storage-key.js";
+import { AsyncBaseStorage } from "./async-base-storage.service.js";
+import { getValueByPath, parsePath, setValueByPath } from "./path.utils.js";
+
+
+
+
+
+
+
+
+
+// Управляет соединением с базой данных
+class IndexedDBManager {
+    dbName;
+    logger;
+    static instances = new Map();
+    db = null;
+    initPromise = null;
+    storeNames = new Set();
+    dbVersion;
+    constructor(dbName, dbVersion, logger){
+        this.dbName = dbName;
+        this.logger = logger;
+        this.dbVersion = dbVersion;
+    }
+    static getInstance(dbName, dbVersion = 1, logger) {
+        if (!IndexedDBManager.instances.has(dbName)) {
+            IndexedDBManager.instances.set(dbName, new IndexedDBManager(dbName, dbVersion, logger));
+        }
+        const instance = IndexedDBManager.instances.get(dbName);
+        // Update version if higher version is requested
+        if (dbVersion > instance.dbVersion) {
+            instance.dbVersion = dbVersion;
+        }
+        return instance;
+    }
+    async initialize() {
+        if (this.db) {
+            return this.db;
+        }
+        if (!this.initPromise) {
+            this.initPromise = this.autoDetectAndOpen();
+        }
+        return this.initPromise;
+    }
+    async autoDetectAndOpen() {
+        // Auto-detect the current DB version to avoid VersionError
+        const currentVersion = await this.detectCurrentVersion();
+        if (currentVersion > this.dbVersion) {
+            this.logger?.debug(`Auto-detected higher DB version: ${currentVersion} (requested: ${this.dbVersion})`);
+            this.dbVersion = currentVersion;
+        }
+        return this.openDatabase();
+    }
+    detectCurrentVersion() {
+        return new Promise((resolve)=>{
+            try {
+                const request = indexedDB.open(this.dbName);
+                request.onsuccess = ()=>{
+                    const version = request.result.version;
+                    request.result.close();
+                    resolve(version);
+                };
+                request.onerror = ()=>resolve(0);
+            } catch  {
+                resolve(0);
+            }
+        });
+    }
+    async ensureStoreExists(storeName) {
+        await this.initialize();
+        if (this.db.objectStoreNames.contains(storeName)) {
+            this.storeNames.add(storeName);
+            return this.db;
+        }
+        this.logger?.debug(`Store "${storeName}" not found, upgrading database`, {
+            dbName: this.dbName,
+            currentStores: Array.from(this.db.objectStoreNames)
+        });
+        this.db.close();
+        this.db = null;
+        this.dbVersion++;
+        this.initPromise = this.openDatabase([
+            storeName
+        ]);
+        const newDb = await this.initPromise;
+        this.storeNames.add(storeName);
+        return newDb;
+    }
+    async openDatabase(newStores = []) {
+        return new Promise((resolve, reject)=>{
+            this.logger?.debug(`Opening database "${this.dbName}" with version ${this.dbVersion}`);
+            const request = indexedDB.open(this.dbName, this.dbVersion);
+            request.onerror = ()=>{
+                this.logger?.error(`Failed to open database "${this.dbName}"`, {
+                    error: request.error
+                });
+                reject(request.error);
+            };
+            request.onblocked = ()=>{
+                this.logger?.warn(`Database "${this.dbName}" upgrade blocked by another connection. Close other tabs or connections.`);
+                reject(new Error(`Database "${this.dbName}" upgrade blocked — close other tabs using this database`));
+            };
+            request.onsuccess = ()=>{
+                this.db = request.result;
+                // Auto-close when another connection requests a version upgrade
+                this.db.onversionchange = ()=>{
+                    this.db?.close();
+                    this.db = null;
+                    this.initPromise = null;
+                };
+                // Add existing stores to our set
+                for(let i = 0; i < this.db.objectStoreNames.length; i++){
+                    this.storeNames.add(this.db.objectStoreNames[i]);
+                }
+                this.logger?.debug(`Database "${this.dbName}" opened successfully`, {
+                    version: this.db.version,
+                    stores: Array.from(this.db.objectStoreNames)
+                });
+                resolve(this.db);
+            };
+            request.onupgradeneeded = (event)=>{
+                const db = event.target.result;
+                this.logger?.debug(`Upgrading database "${this.dbName}" to version ${this.dbVersion}`);
+                // Create new stores that don't exist yet
+                for (const storeName of newStores){
+                    if (!db.objectStoreNames.contains(storeName)) {
+                        this.logger?.debug(`Creating store "${storeName}"`);
+                        db.createObjectStore(storeName);
+                    }
+                }
+            };
+        });
+    }
+    closeDatabase() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            this.initPromise = null;
+        }
+    }
+    async deleteDatabase() {
+        this.closeDatabase();
+        return new Promise((resolve, reject)=>{
+            const request = indexedDB.deleteDatabase(this.dbName);
+            request.onsuccess = ()=>{
+                this.logger?.debug(`Database "${this.dbName}" deleted successfully`);
+                IndexedDBManager.instances.delete(this.dbName);
+                this.storeNames.clear();
+                resolve();
+            };
+            request.onerror = ()=>{
+                this.logger?.error(`Failed to delete database "${this.dbName}"`, {
+                    error: request.error
+                });
+                reject(request.error);
+            };
+        });
+    }
+    async ensureStoresExist(storeNames) {
+        // Сначала инициализируем базу
+        await this.initialize();
+        // Проверяем, какие хранилища уже существуют
+        const missingStores = storeNames.filter((name)=>!this.db.objectStoreNames.contains(name));
+        // Если все хранилища уже существуют, просто возвращаем базу
+        if (missingStores.length === 0) {
+            return this.db;
+        }
+        // Иначе нам нужно обновить базу для создания новых хранилищ
+        this.logger?.debug(`Создание недостающих хранилищ: ${missingStores.join(', ')}`, {
+            dbName: this.dbName,
+            currentStores: Array.from(this.db.objectStoreNames)
+        });
+        // Закрываем текущее соединение
+        this.db.close();
+        this.db = null;
+        // Увеличиваем версию один раз для всех новых хранилищ
+        this.dbVersion++;
+        this.initPromise = this.openDatabase(missingStores);
+        return this.initPromise;
+    }
+    // Метод для получения текущей версии
+    getCurrentVersion() {
+        return this.dbVersion;
+    }
+}
+class IndexedDBStorage extends AsyncBaseStorage {
+    static STORAGE_TYPE = 'indexedDB';
+    type = 'indexedDB';
+    DB_NAME;
+    STORE_NAME;
+    dbManager;
+    constructor(config, pluginExecutor, eventEmitter, logger){
+        super(config, pluginExecutor, eventEmitter, logger);
+        this.DB_NAME = config.options?.dbName || 'app_storage';
+        this.STORE_NAME = config.name;
+        // Get database manager instance (version is auto-detected internally)
+        this.dbManager = IndexedDBManager.getInstance(this.DB_NAME, 1, logger);
+    }
+    static create(config, pluginExecutor, eventEmitter, logger) {
+        return SingletonMixin.handleSingletonCreation(config, this.STORAGE_TYPE, (finalConfig)=>new IndexedDBStorage(finalConfig, pluginExecutor, eventEmitter, logger), logger);
+    }
+    async doInitialize() {
+        try {
+            this.logger?.debug(`Initializing IndexedDB storage "${this.STORE_NAME}"`);
+            // Создаем store в базе данных
+            await this.dbManager.ensureStoreExists(this.STORE_NAME);
+            // Проверяем, что хранилище доступно
+            const db = await this.dbManager.initialize();
+            if (!db.objectStoreNames.contains(this.STORE_NAME)) {
+                throw new Error(`Store "${this.STORE_NAME}" not found after initialization`);
+            }
+            // Инициализируем middleware
+            this.initializeMiddlewares();
+            // Инициализируем с middleware
+            await this.initializeWithMiddlewares();
+            this.logger?.debug(`IndexedDB storage "${this.STORE_NAME}" initialized successfully`);
+            return this;
+        } catch (error) {
+            this.logger?.error(`Ошибка инициализации IndexedDB "${this.name}"`, {
+                error
+            });
+            throw error;
+        }
+    }
+    static async createStorages(dbName, configs, logger) {
+        // Используем единый IndexedDBManager (версия определяется автоматически)
+        const dbManager = IndexedDBManager.getInstance(dbName, 1, logger);
+        // Получаем имена всех хранилищ, которые нужно создать
+        const storeNames = Object.values(configs).map((config)=>config.name);
+        // Предварительно создаем все хранилища в рамках одной операции
+        await dbManager.ensureStoresExist(storeNames);
+        // Создаем и инициализируем все хранилища
+        const result = {};
+        for (const [key, config] of Object.entries(configs)){
+            const storage = new IndexedDBStorage({
+                ...config,
+                options: {
+                    dbName
+                }
+            }, config.pluginExecutor, config.eventEmitter, logger);
+            // Инициализируем хранилище
+            result[key] = await storage.initialize();
+        }
+        return result;
+    }
+    // ─── IndexedDB-specific API ────────────────────────────────────────────────
+    /**
+   * Выполняет операцию в рамках IDB-транзакции.
+   * Обёртка для низкоуровневого IDB transaction API.
+   *
+   * @param mode - Режим транзакции ('readonly' | 'readwrite')
+   * @param fn - Callback, получающий IDBObjectStore. Возвращает результат операции.
+   * @returns Promise с результатом callback-а
+   */ async transaction(mode, fn) {
+        const store = await this.getObjectStore(mode);
+        return new Promise((resolve, reject)=>{
+            const tx = store.transaction;
+            tx.onerror = ()=>reject(tx.error);
+            tx.onabort = ()=>reject(tx.error || new Error('Transaction aborted'));
+            try {
+                const result = fn(store);
+                if (result instanceof IDBRequest) {
+                    result.onsuccess = ()=>resolve(result.result);
+                    result.onerror = ()=>reject(result.error);
+                } else {
+                    // Sync result — resolve when transaction completes
+                    tx.oncomplete = ()=>resolve(result);
+                }
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+   * Текущая версия базы данных.
+   */ get dbVersion() {
+        return this.dbManager.getCurrentVersion();
+    }
+    /**
+   * Имя базы данных.
+   */ get dbName() {
+        return this.DB_NAME;
+    }
+    /**
+   * Имя object store в IndexedDB.
+   */ get storeName() {
+        return this.STORE_NAME;
+    }
+    // ─── Private helpers ───────────────────────────────────────────────────────
+    async getTransaction(mode = 'readonly') {
+        try {
+            // Ensure database is open and our store exists
+            const db = await this.dbManager.ensureStoreExists(this.STORE_NAME);
+            // Проверяем существование хранилища перед созданием транзакции
+            if (!db.objectStoreNames.contains(this.STORE_NAME)) {
+                // Попытка исправить проблему - закрываем и снова открываем
+                this.logger?.warn(`Object store "${this.STORE_NAME}" not found, attempting to repair`);
+                db.close();
+                this.dbManager.closeDatabase();
+                // Пробуем заново создать хранилище с инкрементом версии
+                const newDb = await this.dbManager.ensureStoreExists(this.STORE_NAME);
+                if (!newDb.objectStoreNames.contains(this.STORE_NAME)) {
+                    throw new Error(`Object store "${this.STORE_NAME}" still doesn't exist after repair attempt`);
+                }
+                return newDb.transaction(this.STORE_NAME, mode);
+            }
+            return db.transaction(this.STORE_NAME, mode);
+        } catch (error) {
+            this.logger?.error(`Failed to create transaction for store "${this.STORE_NAME}"`, {
+                error
+            });
+            throw error;
+        }
+    }
+    async getObjectStore(mode = 'readonly') {
+        const transaction = await this.getTransaction(mode);
+        return transaction.objectStore(this.STORE_NAME);
+    }
+    async doGet(key) {
+        const store = await this.getObjectStore();
+        // Для пустого ключа возвращаем все состояние
+        if (key === '') {
+            return new Promise((resolve, reject)=>{
+                const request = store.getAll();
+                request.onerror = ()=>reject(request.error);
+                request.onsuccess = ()=>{
+                    const allValues = request.result;
+                    const allKeys = store.getAllKeys();
+                    allKeys.onsuccess = ()=>{
+                        const state = allKeys.result.reduce((acc, k, index)=>{
+                            if (k !== 'root') {
+                                acc[k] = allValues[index];
+                            }
+                            return acc;
+                        }, {});
+                        resolve(state);
+                    };
+                    allKeys.onerror = ()=>reject(allKeys.error);
+                };
+            });
+        }
+        // Проверяем, является ли ключ "сырым"
+        if (key instanceof StorageKey && key.isUnparseable()) {
+            return new Promise((resolve, reject)=>{
+                const request = store.get(key.valueOf());
+                request.onerror = ()=>reject(request.error);
+                request.onsuccess = ()=>resolve(request.result);
+            });
+        }
+        // Для вложенного пути
+        const parts = parsePath(key);
+        if (parts.length > 1) {
+            const rootKey = parts[0];
+            return new Promise((resolve, reject)=>{
+                const request = store.get(rootKey);
+                request.onerror = ()=>reject(request.error);
+                request.onsuccess = ()=>{
+                    const rootValue = request.result;
+                    if (!rootValue) {
+                        resolve(undefined);
+                        return;
+                    }
+                    const value = getValueByPath(rootValue, parts.slice(1).join('.'));
+                    resolve(value);
+                };
+            });
+        }
+        // Для простого ключа
+        return new Promise((resolve, reject)=>{
+            const request = store.get(parts[0]);
+            request.onerror = ()=>reject(request.error);
+            request.onsuccess = ()=>resolve(request.result);
+        });
+    }
+    async doSet(key, value) {
+        // Для пустого ключа устанавливаем все состояние
+        if (key === '') {
+            const store = await this.getObjectStore('readwrite');
+            return new Promise((resolve, reject)=>{
+                const tx = store.transaction;
+                tx.oncomplete = ()=>{
+                    resolve();
+                };
+                tx.onerror = ()=>{
+                    reject(tx.error);
+                };
+                const clearRequest = store.clear();
+                clearRequest.onsuccess = ()=>{
+                    const entries = Object.entries(value);
+                    for (const [entryKey, entryValue] of entries){
+                        store.put(entryValue, entryKey);
+                    }
+                };
+                clearRequest.onerror = ()=>{
+                    reject(clearRequest.error);
+                };
+            });
+        }
+        const store = await this.getObjectStore('readwrite');
+        // Для "сырого" ключа
+        if (key instanceof StorageKey && key.isUnparseable()) {
+            await this.putValueInStore(store, key.valueOf(), value);
+            return;
+        }
+        // Для вложенного пути
+        const parts = parsePath(key);
+        if (parts.length > 1) {
+            const rootKey = parts[0];
+            return new Promise((resolve, reject)=>{
+                const request = store.get(rootKey);
+                request.onerror = ()=>reject(request.error);
+                request.onsuccess = ()=>{
+                    const rootValue = request.result || {};
+                    const updatedValue = setValueByPath(rootValue, parts.slice(1).join('.'), value);
+                    const putRequest = store.put(updatedValue, rootKey);
+                    putRequest.onerror = ()=>reject(putRequest.error);
+                    putRequest.onsuccess = ()=>resolve();
+                };
+            });
+        }
+        // Для простого ключа
+        await this.putValueInStore(store, parts[0], value);
+    }
+    async putValueInStore(store, key, value) {
+        return new Promise((resolve, reject)=>{
+            const request = store.put(value, key.valueOf());
+            request.onerror = ()=>reject(request.error);
+            request.onsuccess = ()=>resolve();
+        });
+    }
+    async doUpdate(updates) {
+        // Группируем обновления
+        const updatesByRoot = new Map();
+        const rawUpdates = [];
+        // Разделяем обновления на "сырые" и обычные
+        for (const { key, value } of updates){
+            if (key instanceof StorageKey && key.isUnparseable()) {
+                rawUpdates.push({
+                    key: key.valueOf(),
+                    value
+                });
+                continue;
+            }
+            const parts = parsePath(key);
+            const rootKey = parts[0];
+            const path = parts.slice(1);
+            if (!updatesByRoot.has(rootKey)) {
+                updatesByRoot.set(rootKey, []);
+            }
+            updatesByRoot.get(rootKey).push({
+                path,
+                value
+            });
+        }
+        // Одна транзакция на весь doUpdate — атомарность
+        const transaction = await this.getTransaction('readwrite');
+        const store = transaction.objectStore(this.STORE_NAME);
+        return new Promise((resolve, reject)=>{
+            transaction.oncomplete = ()=>resolve();
+            transaction.onerror = ()=>{
+                this.logger?.error('Error during update:', {
+                    error: transaction.error
+                });
+                reject(transaction.error);
+            };
+            transaction.onabort = ()=>{
+                this.logger?.error('Update transaction aborted:', {
+                    error: transaction.error
+                });
+                reject(transaction.error || new Error('Transaction aborted'));
+            };
+            // Обрабатываем "сырые" обновления
+            for (const { key, value } of rawUpdates){
+                store.put(value, key);
+            }
+            // Обрабатываем сгруппированные обновления
+            // Для каждого rootKey: читаем текущее значение, применяем все path-обновления, записываем обратно
+            const rootKeys = Array.from(updatesByRoot.keys());
+            if (rootKeys.length === 0) {
+                // Нет сгруппированных обновлений — транзакция завершится сама
+                return;
+            }
+            for (const rootKey of rootKeys){
+                const getRequest = store.get(rootKey);
+                getRequest.onsuccess = ()=>{
+                    const rootValue = getRequest.result || {};
+                    let updatedValue = {
+                        ...rootValue
+                    };
+                    const pathUpdates = updatesByRoot.get(rootKey);
+                    for (const { path, value } of pathUpdates){
+                        if (path.length === 0) {
+                            updatedValue = value;
+                        } else {
+                            updatedValue = setValueByPath(updatedValue, path.join('.'), value);
+                        }
+                    }
+                    store.put(updatedValue, rootKey);
+                };
+            }
+        });
+    }
+    async doDelete(key) {
+        const store = await this.getObjectStore('readwrite');
+        // Для "сырого" ключа
+        if (key instanceof StorageKey && key.isUnparseable()) {
+            return new Promise((resolve, reject)=>{
+                const request = store.delete(key.valueOf());
+                request.onerror = ()=>reject(request.error);
+                request.onsuccess = ()=>resolve(true);
+            });
+        }
+        const parts = parsePath(key);
+        // Для простого ключа
+        if (parts.length === 1) {
+            return new Promise((resolve, reject)=>{
+                const request = store.delete(parts[0]);
+                request.onerror = ()=>reject(request.error);
+                request.onsuccess = ()=>resolve(true);
+            });
+        }
+        // Для вложенного пути
+        const rootKey = parts[0];
+        return new Promise((resolve, reject)=>{
+            const getRequest = store.get(rootKey);
+            getRequest.onerror = ()=>reject(getRequest.error);
+            getRequest.onsuccess = ()=>{
+                const rootValue = getRequest.result;
+                if (!rootValue) {
+                    resolve(false);
+                    return;
+                }
+                const parent = getValueByPath(rootValue, parts.slice(0, -1).join('.'));
+                const lastKey = parts[parts.length - 1];
+                if (!parent || !(lastKey in parent)) {
+                    resolve(false);
+                    return;
+                }
+                if (Array.isArray(parent)) {
+                    const index = parseInt(lastKey, 10);
+                    if (!isNaN(index)) {
+                        parent.splice(index, 1);
+                    } else {
+                        // @ts-ignore
+                        delete parent[lastKey];
+                    }
+                } else {
+                    delete parent[lastKey];
+                }
+                const putRequest = store.put(rootValue, rootKey);
+                putRequest.onerror = ()=>reject(putRequest.error);
+                putRequest.onsuccess = ()=>resolve(true);
+            };
+        });
+    }
+    async doClear() {
+        const store = await this.getObjectStore('readwrite');
+        return new Promise((resolve, reject)=>{
+            const request = store.clear();
+            request.onsuccess = ()=>resolve();
+            request.onerror = ()=>reject(request.error);
+        });
+    }
+    async doKeys() {
+        const store = await this.getObjectStore();
+        const request = store.getAllKeys();
+        return new Promise((resolve, reject)=>{
+            request.onsuccess = ()=>{
+                resolve(request.result);
+            };
+            request.onerror = ()=>reject(request.error);
+        });
+    }
+    async doHas(key) {
+        const value = await this.doGet(key);
+        return value !== undefined;
+    }
+    /**
+   * Override performCleanup: persistent storage should NOT clear data on destroy.
+   * Only clean up middleware and runtime resources, not persisted data.
+   */ async performCleanup() {
+        await this.pluginExecutor?.executeOnClear();
+        await this.doDestroy();
+    }
+    async doDestroy() {
+    // Persistent storage: do NOT clear data on destroy.
+    // Only release runtime resources. Data persists across component lifecycles.
+    }
+}
+
+export { IndexedDBManager, IndexedDBStorage };
+
+//# sourceMappingURL=indexed-DB.service.js.map