@wxn0brp/db-storage-web 0.100.0 → 0.110.1

package/README.md

@@ -8,7 +8,7 @@ This plugin provides web storage (localStorage/sessionStorage) operations for Va
 npm install @wxn0brp/db-storage-web
 ```
 
-## Usage
+## LocalStorage
 
 ```typescript
 import { createWebStorageValthera } from "@wxn0brp/db-storage-web";
@@ -20,4 +20,16 @@ const db = createWebStorageValthera("my-db", {
     { id: 2, name: "Mieszko" }
   ]
 });
-```
+```
+
+## IndexedDB
+
+```typescript
+import { createIndexedDBValthera } from "@wxn0brp/db-storage-web";
+
+const db = createIndexedDBValthera("my-db");
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -2,6 +2,10 @@ import { ValtheraClass } from "@wxn0brp/db-core";
 import { Data } from "@wxn0brp/db-core/types/data";
 import { Collection } from "@wxn0brp/db-core/helpers/collection";
 export * from "./storage.js";
+export * from "./indexed.js";
 export declare function createWebStorageValthera<T extends Record<string, Data[]>>(name: string, data?: T, storage?: Storage): ValtheraClass & {
     [K in keyof T]: Collection<T[K][number]>;
 };
+export declare function createIndexedDBValthera<T extends Record<string, Data[]>>(name: string): ValtheraClass & {
+    [K in keyof T]: Collection<T[K][number]>;
+};

package/dist/index.js

@@ -1,14 +1,22 @@
 import { forgeValthera, ValtheraClass } from "@wxn0brp/db-core";
 import { WebStorageActions } from "./storage.js";
+import { IndexedDBActions } from "./indexed.js";
 export * from "./storage.js";
+export * from "./indexed.js";
 export function createWebStorageValthera(name, data, storage = localStorage) {
     const db = new ValtheraClass({
-        dbAction: new WebStorageActions(name, storage)
+        dbAction: new WebStorageActions(name, storage),
     });
     if (!data)
         return forgeValthera(db);
     for (const collection of Object.keys(data)) {
-        db.dbAction._write(collection, data[collection]);
+        db.adapter._write(collection, data[collection]);
     }
     return forgeValthera(db);
 }
+export function createIndexedDBValthera(name) {
+    const db = new ValtheraClass({
+        adapter: new IndexedDBActions(name),
+    });
+    return forgeValthera(db);
+}

package/dist/indexed.d.ts

@@ -0,0 +1,29 @@
+import { ActionsBase } from "@wxn0brp/db-core/base/actions";
+import { DataInternal } from "@wxn0brp/db-core/types/data";
+import { VQueryT } from "@wxn0brp/db-core/types/query";
+export declare class IndexedDBActions extends ActionsBase {
+    name: string;
+    db: IDBDatabase;
+    _version: number;
+    _inited: boolean;
+    constructor(name: string);
+    _getDBName(): string;
+    init(): Promise<void>;
+    _loadVersion(): Promise<void>;
+    _saveVersion(): Promise<void>;
+    close(): Promise<void>;
+    _changeSchema(upgradeFn: (db: IDBDatabase) => void): Promise<void>;
+    _getStore(collection: string, mode: IDBTransactionMode): Promise<IDBObjectStore>;
+    _getAllEntries(collection: string): Promise<DataInternal[]>;
+    ensureCollection(collection: string): Promise<boolean>;
+    issetCollection(collection: string): Promise<boolean>;
+    getCollections(): Promise<string[]>;
+    removeCollection(collection: string): Promise<boolean>;
+    add(query: VQueryT.Add): Promise<DataInternal>;
+    find(query: VQueryT.Find): Promise<DataInternal[]>;
+    findOne(query: VQueryT.FindOne): Promise<DataInternal | null>;
+    update(query: VQueryT.Update): Promise<DataInternal[]>;
+    updateOne(query: VQueryT.Update): Promise<DataInternal | null>;
+    remove(query: VQueryT.Remove): Promise<DataInternal[]>;
+    removeOne(query: VQueryT.Remove): Promise<DataInternal | null>;
+}

package/dist/indexed.js

@@ -0,0 +1,275 @@
+import { ActionsBase } from "@wxn0brp/db-core/base/actions";
+import { addId } from "@wxn0brp/db-core/helpers/addId";
+import { findObj, matchObj, updateObj } from "@wxn0brp/db-core/utils/process";
+export class IndexedDBActions extends ActionsBase {
+    name;
+    db = null;
+    _version = 1;
+    _inited = false;
+    constructor(name) {
+        super();
+        this.name = name;
+    }
+    _getDBName() {
+        return "vdb_" + this.name;
+    }
+    async init() {
+        if (this.db)
+            return;
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this._getDBName());
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                this.db = request.result;
+                this._version = this.db.version;
+                this._loadVersion()
+                    .then(() => resolve())
+                    .catch(reject);
+            };
+            request.onupgradeneeded = event => {
+                const db = request.result;
+                this._version = db.version;
+                if (!db.objectStoreNames.contains("_meta")) {
+                    db.createObjectStore("_meta");
+                }
+            };
+        });
+    }
+    async _loadVersion() {
+        if (!this.db)
+            return;
+        return new Promise((resolve, reject) => {
+            const tx = this.db.transaction("_meta", "readonly");
+            const store = tx.objectStore("_meta");
+            const request = store.get("version");
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                this._version = request.result || 1;
+                resolve();
+            };
+        });
+    }
+    async _saveVersion() {
+        if (!this.db)
+            return;
+        return new Promise((resolve, reject) => {
+            const tx = this.db.transaction("_meta", "readwrite");
+            const store = tx.objectStore("_meta");
+            const request = store.put(this._version, "version");
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve();
+        });
+    }
+    async close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+    async _changeSchema(upgradeFn) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        const newVersion = this.db.version + 1;
+        this.db.close();
+        this.db = null;
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this._getDBName(), newVersion);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                this.db = request.result;
+                this._version = this.db.version;
+                this._saveVersion()
+                    .then(() => resolve())
+                    .catch(reject);
+            };
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                if (!db.objectStoreNames.contains("_meta")) {
+                    db.createObjectStore("_meta");
+                }
+                upgradeFn(db);
+            };
+        });
+    }
+    async _getStore(collection, mode) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        const tx = this.db.transaction(collection, mode);
+        return tx.objectStore(collection);
+    }
+    async _getAllEntries(collection) {
+        const store = await this._getStore(collection, "readonly");
+        return new Promise((resolve, reject) => {
+            const request = store.getAll();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result || []);
+        });
+    }
+    async ensureCollection(collection) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        if (this.db.objectStoreNames.contains(collection))
+            return false;
+        await this._changeSchema(db => {
+            if (!db.objectStoreNames.contains(collection)) {
+                db.createObjectStore(collection, {
+                    keyPath: "_id",
+                });
+            }
+        });
+        return true;
+    }
+    async issetCollection(collection) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        return this.db.objectStoreNames.contains(collection);
+    }
+    async getCollections() {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        const collections = [];
+        for (let i = 0; i < this.db.objectStoreNames.length; i++) {
+            const name = this.db.objectStoreNames.item(i);
+            if (name && name !== "_meta") {
+                collections.push(name);
+            }
+        }
+        return collections;
+    }
+    async removeCollection(collection) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        if (!this.db.objectStoreNames.contains(collection))
+            return false;
+        await this._changeSchema(db => {
+            if (db.objectStoreNames.contains(collection)) {
+                db.deleteObjectStore(collection);
+            }
+        });
+        return true;
+    }
+    async add(query) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        await this.ensureCollection(query.collection);
+        await addId(query, this);
+        const { collection, data } = query;
+        const store = await this._getStore(collection, "readwrite");
+        return new Promise((resolve, reject) => {
+            const request = store.put(data);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(data);
+        });
+    }
+    async find(query) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        await this.ensureCollection(query.collection);
+        const entries = await this._getAllEntries(query.collection);
+        return entries.map(entry => findObj(query, entry)).filter(Boolean);
+    }
+    async findOne(query) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        await this.ensureCollection(query.collection);
+        const entries = await this._getAllEntries(query.collection);
+        for (const entry of entries) {
+            const result = findObj(query, entry);
+            if (result)
+                return result;
+        }
+        return null;
+    }
+    async update(query) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        await this.ensureCollection(query.collection);
+        const store = await this._getStore(query.collection, "readwrite");
+        const entries = await new Promise((resolve, reject) => {
+            const request = store.getAll();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result || []);
+        });
+        const updated = [];
+        for (const entry of entries) {
+            if (matchObj(query, entry)) {
+                const updatedEntry = updateObj(query, entry);
+                updated.push(updatedEntry);
+                await new Promise((resolve, reject) => {
+                    const putRequest = store.put(updatedEntry);
+                    putRequest.onerror = () => reject(putRequest.error);
+                    putRequest.onsuccess = () => resolve();
+                });
+            }
+        }
+        return updated;
+    }
+    async updateOne(query) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        await this.ensureCollection(query.collection);
+        const store = await this._getStore(query.collection, "readwrite");
+        const entries = await new Promise((resolve, reject) => {
+            const request = store.getAll();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result || []);
+        });
+        for (const entry of entries) {
+            if (matchObj(query, entry)) {
+                const updatedEntry = updateObj(query, entry);
+                await new Promise((resolve, reject) => {
+                    const putRequest = store.put(updatedEntry);
+                    putRequest.onerror = () => reject(putRequest.error);
+                    putRequest.onsuccess = () => resolve();
+                });
+                return updatedEntry;
+            }
+        }
+        return null;
+    }
+    async remove(query) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        await this.ensureCollection(query.collection);
+        const store = await this._getStore(query.collection, "readwrite");
+        const entries = await new Promise((resolve, reject) => {
+            const request = store.getAll();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result || []);
+        });
+        const removed = [];
+        for (const entry of entries) {
+            if (matchObj(query, entry)) {
+                removed.push(entry);
+                await new Promise((resolve, reject) => {
+                    const deleteRequest = store.delete(entry._id);
+                    deleteRequest.onerror = () => reject(deleteRequest.error);
+                    deleteRequest.onsuccess = () => resolve();
+                });
+            }
+        }
+        return removed;
+    }
+    async removeOne(query) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        await this.ensureCollection(query.collection);
+        const store = await this._getStore(query.collection, "readwrite");
+        const entries = await new Promise((resolve, reject) => {
+            const request = store.getAll();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result || []);
+        });
+        for (const entry of entries) {
+            if (matchObj(query, entry)) {
+                await new Promise((resolve, reject) => {
+                    const deleteRequest = store.delete(entry._id);
+                    deleteRequest.onerror = () => reject(deleteRequest.error);
+                    deleteRequest.onsuccess = () => resolve();
+                });
+                return entry;
+            }
+        }
+        return null;
+    }
+}

package/dist/storage.d.ts

@@ -1,8 +1,8 @@
 import { CustomActionsBase } from "@wxn0brp/db-core/base/custom";
 export declare class WebStorageActions extends CustomActionsBase {
     name: string;
-    private storage;
-    constructor(name: string, storage?: Storage);
+    _storage: Storage;
+    constructor(name: string, _storage?: Storage);
     _getPath(collection: string): string;
     _read(collection: string): any;
     _write(collection: string, data: object[]): void;

package/dist/storage.js

@@ -2,44 +2,44 @@ import { CustomFileCpu } from "@wxn0brp/db-core";
 import { CustomActionsBase } from "@wxn0brp/db-core/base/custom";
 export class WebStorageActions extends CustomActionsBase {
     name;
-    storage;
-    constructor(name, storage = localStorage) {
+    _storage;
+    constructor(name, _storage = localStorage) {
         super();
         this.name = name;
-        this.storage = storage;
+        this._storage = _storage;
         this.fileCpu = new CustomFileCpu(this._read.bind(this), this._write.bind(this));
     }
     _getPath(collection) {
         return "vdb_" + this.name + "_" + collection;
     }
     _read(collection) {
-        const data = this.storage.getItem(this._getPath(collection));
+        const data = this._storage.getItem(this._getPath(collection));
         return data ? JSON.parse(data) : [];
     }
     _write(collection, data) {
-        this.storage.setItem(this._getPath(collection), JSON.stringify(data));
+        this._storage.setItem(this._getPath(collection), JSON.stringify(data));
     }
     async ensureCollection(collection) {
         const key = this._getPath(collection);
-        if (!this.storage.getItem(key))
-            this.storage.setItem(key, JSON.stringify([]));
+        if (!this._storage.getItem(key))
+            this._storage.setItem(key, JSON.stringify([]));
         return true;
     }
     async issetCollection(collection) {
-        return !!this.storage.getItem(this._getPath(collection));
+        return !!this._storage.getItem(this._getPath(collection));
     }
     async getCollections() {
         const keys = [];
         const prefix = "vdb_" + this.name + "_";
-        for (let i = 0; i < this.storage.length; i++) {
-            const key = this.storage.key(i);
+        for (let i = 0; i < this._storage.length; i++) {
+            const key = this._storage.key(i);
             if (key.startsWith(prefix))
                 keys.push(key.replace(prefix, ""));
         }
         return keys;
     }
     async removeCollection(collection) {
-        this.storage.removeItem(this._getPath(collection));
+        this._storage.removeItem(this._getPath(collection));
         return true;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db-storage-web",
-  "version": "0.100.0",
+  "version": "0.110.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",
@@ -18,12 +18,13 @@
     "vdb-adapter"
   ],
   "peerDependencies": {
-    "@wxn0brp/db-core": "~0.10.0"
+    "@wxn0brp/db-core": "^0.11.5"
   },
   "devDependencies": {
-    "@wxn0brp/db-core": "~0.10.0",
-    "tsc-alias": "*",
-    "typescript": "*"
+    "@wxn0brp/biome": "*",
+    "@wxn0brp/db-core": "^0.11.5",
+    "tsc-alias": "^1",
+    "typescript": "^7"
   },
   "files": [
     "dist"