@wxn0brp/db-storage-web 0.120.0 → 0.120.2

package/dist/indexed.d.ts

@@ -6,8 +6,19 @@ export declare class IndexedDBActions extends ActionsBase {
     db: IDBDatabase;
     _version: number;
     _inited: boolean;
+    version: string;
+    capabilities: {
+        transactions: boolean;
+        indexes: boolean;
+        persistent: boolean;
+    };
     constructor(name: string);
     _getDBName(): string;
+    _dbContext(): {
+        adapter: string;
+        db: string;
+    };
+    _requireDb(): IDBDatabase;
     init(): Promise<void>;
     _loadVersion(): Promise<void>;
     _saveVersion(): Promise<void>;
@@ -20,10 +31,12 @@ export declare class IndexedDBActions extends ActionsBase {
     getCollections(): Promise<string[]>;
     removeCollection(collection: string): Promise<boolean>;
     add(query: VQueryT.Add): Promise<DataInternal>;
+    bulkAdd(query: VQueryT.BulkAdd): 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>;
+    count(query: VQueryT.Count): Promise<number>;
 }

package/dist/indexed.js

@@ -1,11 +1,19 @@
 import { ActionsBase } from "@wxn0brp/db-core/base/actions";
-import { addId } from "@wxn0brp/db-core/helpers/addId";
+import { AdapterCloseError, AdapterError, AdapterInitError, } from "@wxn0brp/db-core/errors";
+import { addId, addIdBulk } from "@wxn0brp/db-core/helpers/addId";
 import { findObj, matchObj, updateObj } from "@wxn0brp/db-core/utils/process";
+import { version } from "./version.js";
 export class IndexedDBActions extends ActionsBase {
     name;
     db = null;
     _version = 1;
     _inited = false;
+    version = version;
+    capabilities = {
+        transactions: false,
+        indexes: false,
+        persistent: true,
+    };
     constructor(name) {
         super();
         this.name = name;
@@ -13,27 +21,43 @@ export class IndexedDBActions extends ActionsBase {
     _getDBName() {
         return "vdb_" + this.name;
     }
+    _dbContext() {
+        return {
+            adapter: "IndexedDB",
+            db: this._getDBName(),
+        };
+    }
+    _requireDb() {
+        if (!this.db)
+            throw new AdapterError("Database not initialized", this._dbContext());
+        return this.db;
+    }
     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");
-                }
-            };
-        });
+        try {
+            await 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");
+                    }
+                };
+            });
+        }
+        catch (err) {
+            throw new AdapterInitError(err, this._dbContext());
+        }
     }
     async _loadVersion() {
         if (!this.db)
@@ -61,14 +85,18 @@ export class IndexedDBActions extends ActionsBase {
         });
     }
     async close() {
-        if (this.db) {
+        if (!this.db)
+            return;
+        try {
             this.db.close();
             this.db = null;
         }
+        catch (err) {
+            throw new AdapterCloseError(err, this._dbContext());
+        }
     }
     async _changeSchema(upgradeFn) {
-        if (!this.db)
-            throw new Error("Database not initialized");
+        this._requireDb();
         const newVersion = this.db.version + 1;
         this.db.close();
         this.db = null;
@@ -92,8 +120,7 @@ export class IndexedDBActions extends ActionsBase {
         });
     }
     async _getStore(collection, mode) {
-        if (!this.db)
-            throw new Error("Database not initialized");
+        this._requireDb();
         const tx = this.db.transaction(collection, mode);
         return tx.objectStore(collection);
     }
@@ -106,8 +133,7 @@ export class IndexedDBActions extends ActionsBase {
         });
     }
     async ensureCollection(collection) {
-        if (!this.db)
-            throw new Error("Database not initialized");
+        this._requireDb();
         if (this.db.objectStoreNames.contains(collection))
             return false;
         await this._changeSchema(db => {
@@ -120,13 +146,11 @@ export class IndexedDBActions extends ActionsBase {
         return true;
     }
     async issetCollection(collection) {
-        if (!this.db)
-            throw new Error("Database not initialized");
+        this._requireDb();
         return this.db.objectStoreNames.contains(collection);
     }
     async getCollections() {
-        if (!this.db)
-            throw new Error("Database not initialized");
+        this._requireDb();
         const collections = [];
         for (let i = 0; i < this.db.objectStoreNames.length; i++) {
             const name = this.db.objectStoreNames.item(i);
@@ -137,8 +161,7 @@ export class IndexedDBActions extends ActionsBase {
         return collections;
     }
     async removeCollection(collection) {
-        if (!this.db)
-            throw new Error("Database not initialized");
+        this._requireDb();
         if (!this.db.objectStoreNames.contains(collection))
             return false;
         await this._changeSchema(db => {
@@ -149,8 +172,7 @@ export class IndexedDBActions extends ActionsBase {
         return true;
     }
     async add(query) {
-        if (!this.db)
-            throw new Error("Database not initialized");
+        this._requireDb();
         await this.ensureCollection(query.collection);
         await addId(query, this);
         const { collection, data } = query;
@@ -161,16 +183,32 @@ export class IndexedDBActions extends ActionsBase {
             request.onsuccess = () => resolve(data);
         });
     }
+    async bulkAdd(query) {
+        this._requireDb();
+        await this.ensureCollection(query.collection);
+        await addIdBulk(query, this);
+        const store = await this._getStore(query.collection, "readwrite");
+        const tx = store.transaction;
+        return new Promise((resolve, reject) => {
+            const results = [];
+            tx.onerror = () => reject(new AdapterError(tx.error, this._dbContext()));
+            tx.onabort = () => reject(new AdapterError(tx.error ?? new Error("Transaction aborted"), this._dbContext()));
+            tx.oncomplete = () => resolve(results);
+            for (const data of query.datas) {
+                const request = store.put(data);
+                request.onerror = () => reject(new AdapterError(request.error, this._dbContext()));
+                request.onsuccess = () => results.push(data);
+            }
+        });
+    }
     async find(query) {
-        if (!this.db)
-            throw new Error("Database not initialized");
+        this._requireDb();
         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");
+        this._requireDb();
         await this.ensureCollection(query.collection);
         const entries = await this._getAllEntries(query.collection);
         for (const entry of entries) {
@@ -181,8 +219,7 @@ export class IndexedDBActions extends ActionsBase {
         return null;
     }
     async update(query) {
-        if (!this.db)
-            throw new Error("Database not initialized");
+        this._requireDb();
         await this.ensureCollection(query.collection);
         const store = await this._getStore(query.collection, "readwrite");
         const entries = await new Promise((resolve, reject) => {
@@ -205,8 +242,7 @@ export class IndexedDBActions extends ActionsBase {
         return updated;
     }
     async updateOne(query) {
-        if (!this.db)
-            throw new Error("Database not initialized");
+        this._requireDb();
         await this.ensureCollection(query.collection);
         const store = await this._getStore(query.collection, "readwrite");
         const entries = await new Promise((resolve, reject) => {
@@ -228,8 +264,7 @@ export class IndexedDBActions extends ActionsBase {
         return null;
     }
     async remove(query) {
-        if (!this.db)
-            throw new Error("Database not initialized");
+        this._requireDb();
         await this.ensureCollection(query.collection);
         const store = await this._getStore(query.collection, "readwrite");
         const entries = await new Promise((resolve, reject) => {
@@ -251,8 +286,7 @@ export class IndexedDBActions extends ActionsBase {
         return removed;
     }
     async removeOne(query) {
-        if (!this.db)
-            throw new Error("Database not initialized");
+        this._requireDb();
         await this.ensureCollection(query.collection);
         const store = await this._getStore(query.collection, "readwrite");
         const entries = await new Promise((resolve, reject) => {
@@ -272,4 +306,26 @@ export class IndexedDBActions extends ActionsBase {
         }
         return null;
     }
+    async count(query) {
+        this._requireDb();
+        await this.ensureCollection(query.collection);
+        const entries = await this._getAllEntries(query.collection);
+        if (entries.length === 0)
+            return 0;
+        const { search } = query;
+        if (!search ||
+            (typeof search === "object" && Object.keys(search).length === 0)) {
+            return entries.length;
+        }
+        let count = 0;
+        for (const entry of entries) {
+            if (matchObj({
+                search,
+                collection: query.collection,
+            }, entry)) {
+                count++;
+            }
+        }
+        return count;
+    }
 }

package/dist/storage.d.ts

@@ -1,7 +1,15 @@
 import { CustomActionsBase } from "@wxn0brp/db-core/base/custom";
+import { DataInternal } from "@wxn0brp/db-core/types/data";
+import { VQueryT } from "@wxn0brp/db-core/types/query";
 export declare class WebStorageActions extends CustomActionsBase {
     name: string;
     _storage: Storage;
+    version: string;
+    capabilities: {
+        transactions: boolean;
+        indexes: boolean;
+        persistent: boolean;
+    };
     constructor(name: string, _storage?: Storage);
     _getPath(collection: string): string;
     _read(collection: string): any;
@@ -10,4 +18,6 @@ export declare class WebStorageActions extends CustomActionsBase {
     issetCollection(collection: string): Promise<boolean>;
     getCollections(): Promise<string[]>;
     removeCollection(collection: string): Promise<boolean>;
+    bulkAdd(query: VQueryT.BulkAdd): Promise<DataInternal[]>;
+    count(config: VQueryT.Count): Promise<number>;
 }

package/dist/storage.js

@@ -1,8 +1,17 @@
 import { CustomFileCpu } from "@wxn0brp/db-core";
 import { CustomActionsBase } from "@wxn0brp/db-core/base/custom";
+import { addIdBulk } from "@wxn0brp/db-core/helpers/addId";
+import { hasFieldsAdvanced } from "@wxn0brp/db-core/utils/hasFieldsAdvanced";
+import { version } from "./version.js";
 export class WebStorageActions extends CustomActionsBase {
     name;
     _storage;
+    version = version;
+    capabilities = {
+        transactions: false,
+        indexes: false,
+        persistent: true,
+    };
     constructor(name, _storage = localStorage) {
         super();
         this.name = name;
@@ -42,4 +51,27 @@ export class WebStorageActions extends CustomActionsBase {
         this._storage.removeItem(this._getPath(collection));
         return true;
     }
+    async bulkAdd(query) {
+        await this.ensureCollection(query.collection);
+        await addIdBulk(query, this);
+        const data = this._read(query.collection);
+        data.push(...query.datas);
+        this._write(query.collection, data);
+        return query.datas;
+    }
+    async count(config) {
+        const data = this._read(config.collection);
+        if (data.length === 0)
+            return 0;
+        const { search } = config;
+        if (!search ||
+            (typeof search === "object" && Object.keys(search).length === 0)) {
+            return data.length;
+        }
+        let count = 0;
+        for (const item of data)
+            if (hasFieldsAdvanced(item, search))
+                count++;
+        return count;
+    }
 }

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "0.120.2";

package/dist/version.js

@@ -0,0 +1 @@
+export const version = "0.120.2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db-storage-web",
-  "version": "0.120.0",
+  "version": "0.120.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",
@@ -17,12 +17,11 @@
     "valtheradb",
     "vdb-adapter"
   ],
-  "peerDependencies": {
-    "@wxn0brp/db-core": "^0.12.0"
+  "dependencies": {
+    "@wxn0brp/db-core": "^0.12.10"
   },
   "devDependencies": {
     "@wxn0brp/biome": "*",
-    "@wxn0brp/db-core": "^0.12.0",
     "tsc-alias": "^1",
     "typescript": "^7"
   },