promise-idb 1.0.0

package/dist/AsyncDB.d.ts

@@ -0,0 +1,13 @@
+import DBStore from "./DBStore";
+import type { AsyncDBInstance } from "./types";
+export default class AsyncDB {
+    private openReq;
+    private db;
+    private dbName;
+    private version?;
+    private stores;
+    private constructor();
+    static init(dbName: string, version?: number): AsyncDB;
+    createStore<T>(name: string, options?: IDBObjectStoreParameters): DBStore<T>;
+    build(): Promise<AsyncDBInstance>;
+}

package/dist/AsyncDB.js

@@ -0,0 +1,58 @@
+import IDbError from "./DBError";
+import DBStore from "./DBStore";
+export default class AsyncDB {
+    openReq;
+    db;
+    dbName;
+    version;
+    stores;
+    constructor(dbName, version) {
+        this.dbName = dbName;
+        this.version = version;
+        this.stores = new Map();
+    }
+    static init(dbName, version) {
+        return new AsyncDB(dbName, version);
+    }
+    createStore(name, options) {
+        const store = new DBStore(name, options);
+        this.stores.set(name, store);
+        return store;
+    }
+    async build() {
+        return new Promise((res, rej) => {
+            this.openReq = window.indexedDB.open(this.dbName, this.version);
+            this.openReq.onerror = (e) => {
+                rej(new IDbError(e.target.error?.message, e));
+            };
+            this.openReq.onsuccess = (e) => {
+                this.db = e.target.result;
+                const entries = this.stores.entries();
+                for (const [_, store] of entries)
+                    store.setDB(this.db);
+                res({
+                    db: this.db,
+                    dbName: this.dbName,
+                    openReq: this.openReq,
+                    version: this.version,
+                });
+            };
+            this.openReq.onupgradeneeded = (e) => {
+                this.db = e.target.result;
+                for (const store of this.stores.values()) {
+                    const s = this.db.createObjectStore(store.name, store.getOptions());
+                    const indexes = store.getIndexes();
+                    for (const index of indexes) {
+                        const name = index.name;
+                        const keyPath = index.keyPath;
+                        const options = index.options;
+                        s.createIndex(name, keyPath, options);
+                    }
+                }
+            };
+            this.openReq.onblocked = (e) => {
+                rej(new IDbError(e.target.error?.message, e));
+            };
+        });
+    }
+}

package/dist/DBError.d.ts

@@ -0,0 +1,6 @@
+import type { IEvent } from "./types";
+export default class DBError extends Error {
+    event?: IEvent;
+    stack?: string | undefined;
+    constructor(message: string | undefined, e?: IEvent);
+}

package/dist/DBError.js

@@ -0,0 +1,9 @@
+export default class DBError extends Error {
+    event;
+    stack;
+    constructor(message, e) {
+        super(message);
+        this.message = `AsyncDB Error: ${message}`;
+        this.event = e;
+    }
+}

package/dist/DBStore.d.ts

@@ -0,0 +1,19 @@
+import DBSToreIndex from "./DBStoreIndex";
+export default class DBStore<T> {
+    name: string;
+    private options?;
+    private indexes;
+    db: IDBDatabase;
+    constructor(name: string, options?: IDBObjectStoreParameters);
+    setDB(db: IDBDatabase): void;
+    add(data: T): Promise<unknown>;
+    get(query: IDBValidKey | IDBKeyRange): Promise<T>;
+    getAll(query?: IDBValidKey | IDBKeyRange | null | undefined, count?: number): Promise<T[]>;
+    getKey(query: IDBValidKey | IDBKeyRange): Promise<T>;
+    getAllKeys(query?: IDBValidKey | IDBKeyRange | null | undefined, count?: number): Promise<T[]>;
+    update<K = T>(value: K, key?: IDBValidKey): Promise<T>;
+    delete(query: IDBValidKey | IDBKeyRange): Promise<unknown>;
+    addIndex(name: string, keyPath: string | string[], options?: IDBIndexParameters): void;
+    getIndexes(): DBSToreIndex[];
+    getOptions(): IDBObjectStoreParameters | undefined;
+}

package/dist/DBStore.js

@@ -0,0 +1,138 @@
+import DBSToreIndex from "./DBStoreIndex";
+import IDbError from "./DBError";
+export default class DBStore {
+    name;
+    options;
+    indexes;
+    db;
+    constructor(name, options) {
+        this.name = name;
+        this.options = options;
+        this.indexes = [];
+    }
+    setDB(db) {
+        this.db = db;
+    }
+    add(data) {
+        return new Promise((res, rej) => {
+            const transaction = this.db.transaction(this.name, "readwrite");
+            const s = transaction.objectStore(this.name);
+            const result = s.add(data);
+            result.onerror = (e) => {
+                const message = e.target.error?.message;
+                transaction.commit();
+                rej(new IDbError(message, e));
+            };
+            result.onsuccess = () => {
+                transaction.commit();
+                res(true);
+            };
+        });
+    }
+    get(query) {
+        return new Promise((res, rej) => {
+            const transaction = this.db.transaction(this.name, "readwrite");
+            const s = transaction.objectStore(this.name);
+            const result = s.get(query);
+            result.onerror = (e) => {
+                const message = e.target.error?.message;
+                transaction.commit();
+                rej(new IDbError(message, e));
+            };
+            result.onsuccess = (e) => {
+                transaction.commit();
+                res(e.target.result);
+            };
+        });
+    }
+    getAll(query, count) {
+        return new Promise((res, rej) => {
+            const transaction = this.db.transaction(this.name, "readwrite");
+            const s = transaction.objectStore(this.name);
+            const result = s.getAll(query, count);
+            result.onerror = (e) => {
+                const message = e.target.error?.message;
+                transaction.commit();
+                rej(new IDbError(message, e));
+            };
+            result.onsuccess = (e) => {
+                transaction.commit();
+                res(e.target.result);
+            };
+        });
+    }
+    getKey(query) {
+        return new Promise((res, rej) => {
+            const transaction = this.db.transaction(this.name, "readwrite");
+            const s = transaction.objectStore(this.name);
+            const result = s.getKey(query);
+            result.onerror = (e) => {
+                const message = e.target.error?.message;
+                transaction.commit();
+                rej(new IDbError(message, e));
+            };
+            result.onsuccess = (e) => {
+                transaction.commit();
+                res(e.target.result);
+            };
+        });
+    }
+    getAllKeys(query, count) {
+        return new Promise((res, rej) => {
+            const transaction = this.db.transaction(this.name, "readwrite");
+            const s = transaction.objectStore(this.name);
+            const result = s.add(query, count);
+            result.onerror = (e) => {
+                const message = e.target.error?.message;
+                transaction.commit();
+                rej(new IDbError(message, e));
+            };
+            result.onsuccess = (e) => {
+                transaction.commit();
+                res(e.target.result);
+            };
+        });
+    }
+    update(value, key) {
+        return new Promise((res, rej) => {
+            const transaction = this.db.transaction(this.name, "readwrite");
+            const s = transaction.objectStore(this.name);
+            const result = s.put(value, key);
+            result.onerror = (e) => {
+                const message = e.target.error?.message;
+                transaction.commit();
+                rej(new IDbError(message, e));
+            };
+            result.onsuccess = (e) => {
+                transaction.commit();
+                res(e.target.result);
+            };
+        });
+    }
+    delete(query) {
+        return new Promise((res, rej) => {
+            const transaction = this.db.transaction(this.name, "readwrite");
+            const s = transaction.objectStore(this.name);
+            const result = s.delete(query);
+            result.onerror = (e) => {
+                const message = e.target.error?.message;
+                transaction.commit();
+                rej(new IDbError(message, e));
+            };
+            result.onsuccess = (e) => {
+                transaction.commit();
+                res(e.target.result);
+            };
+        });
+    }
+    addIndex(name, keyPath, options) {
+        const index = new DBSToreIndex(name, keyPath, options);
+        this.indexes.push(index);
+    }
+    getIndexes() {
+        return this.indexes;
+    }
+    getOptions() {
+        return this.options;
+    }
+}

package/dist/DBStoreIndex.d.ts

@@ -0,0 +1,6 @@
+export default class DBStoreIndex {
+    name: string;
+    keyPath: string | string[];
+    options?: IDBIndexParameters;
+    constructor(name: string, keyPath: string | string[], options?: IDBIndexParameters);
+}

package/dist/DBStoreIndex.js

@@ -0,0 +1,10 @@
+export default class DBStoreIndex {
+    name;
+    keyPath;
+    options;
+    constructor(name, keyPath, options) {
+        this.name = name;
+        this.keyPath = keyPath;
+        this.options = options;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import DBError from "./DBError";
+import DBStore from "./DBStore";
+import DBStoreIndex from "./DBStoreIndex";
+import AsyncDB from "./AsyncDB";
+export { DBError, DBStore, DBStoreIndex, AsyncDB };
+export default AsyncDB;

package/dist/index.js

@@ -0,0 +1,6 @@
+import DBError from "./DBError";
+import DBStore from "./DBStore";
+import DBStoreIndex from "./DBStoreIndex";
+import AsyncDB from "./AsyncDB";
+export { DBError, DBStore, DBStoreIndex, AsyncDB };
+export default AsyncDB;

package/dist/types.d.ts

@@ -0,0 +1,45 @@
+import DBStore from "./DBStore";
+export type IEvent = Event & {
+    target: IDBOpenDBRequest;
+};
+export type StoreArgs = {
+    name: string;
+    options?: IDBObjectStoreParameters | undefined;
+};
+export type IndexArgs = {
+    name: string;
+    keyPath: string | string[];
+    options?: IDBIndexParameters;
+};
+export type StoreArguments = {
+    store: StoreArgs;
+    indexes: IndexArgs[];
+};
+export type StringsToObject<T extends readonly string[]> = {
+    [K in T[number]]: null;
+};
+export type AsyncDBCallback = ((ev: IEvent) => any) | null;
+export interface IDbAsync {
+    addEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    dispatchEvent(event: IEvent): boolean;
+    error: DOMException | null;
+    onblocked: AsyncDBCallback;
+    onerror: AsyncDBCallback;
+    onsuccess: AsyncDBCallback;
+    onupgradeneeded: AsyncDBCallback;
+    readyState: IDBRequestReadyState;
+    removeEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    result: AsyncDBDatabase;
+    source: IDBObjectStore | IDBIndex | IDBCursor;
+    transaction: IDBTransaction | null;
+}
+export type AsyncDBDatabase = IDBDatabase & {
+    getStore<T>(name: string): DBStore<T>;
+};
+export type StoreMap = Record<string, DBStore<any>>;
+export type AsyncDBInstance = {
+    openReq: IDbAsync;
+    db: AsyncDBDatabase;
+    dbName: string;
+    version?: number;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "promise-idb",
+  "version": "1.0.0",
+  "description": "A lightweight TypeScript library that simplifies IndexedDB with async/await syntax and Promise-based API for modern browser storage",
+  "homepage": "https://github.com/Maliklar/async-indexeddb#readme",
+  "bugs": {
+    "url": "https://github.com/Maliklar/async-indexeddb/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Maliklar/async-indexeddb.git"
+  },
+  "keywords": [
+    "indexeddb",
+    "indexed-db",
+    "idb",
+    "database",
+    "db",
+    "browser-database",
+    "client-database",
+    "web-database",
+    "storage",
+    "browser-storage",
+    "persistent-storage",
+    "offline-storage",
+    "async",
+    "promise",
+    "async-await",
+    "promises",
+    "typescript",
+    "typed",
+    "types",
+    "typescript-library",
+    "wrapper",
+    "indexeddb-wrapper",
+    "indexeddb-helper",
+    "database-wrapper",
+    "utility",
+    "helper",
+    "offline",
+    "offline-first",
+    "pwa",
+    "progressive-web-app",
+    "client-side",
+    "frontend",
+    "browser",
+    "data",
+    "persistence",
+    "key-value",
+    "nosql",
+    "store",
+    "crud"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "license": "MIT",
+  "author": "Malik Elbadri <elbadrimalik@gmail.com>",
+  "type": "module",
+  "types": "dist/types.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}