idb-ts 1.0.0 → 2.0.0

package/README.md

@@ -1,4 +1,9 @@
-# ts-indexeddb
+# idb-ts
+
+## Installation
+```
+npm i idb-ts
+```
 
 ## Example
 
@@ -64,4 +69,8 @@ console.log("Remaining users:", remainingUsers);
 
 const locations = await db.list(Location);
 console.log("All locations:", locations);
-```
+```
+
+## Links
+ - GitHub: https://github.com/maifeeulasad/idb-ts
+ - NPM: https://www.npmjs.com/package/idb-ts

package/index.ts

@@ -25,40 +25,49 @@ class Database {
   private classes: Function[];
   private db: IDBDatabase | null = null;
 
-  constructor(dbName: string, classes: Function[]) {
+  private constructor(dbName: string, classes: Function[]) {
     this.dbName = dbName;
     if (!classes.every(cls => Reflect.getMetadata("dataclass", cls))) {
       throw new Error("All classes should be decorated with @DataClass.");
     }
     this.classes = classes;
-    this.initDB();
   }
 
-  private initDB(): void {
-    const request = indexedDB.open(this.dbName, 1);
+  static async build(dbName: string, classes: Function[]): Promise<Database> {
+    const instance = new Database(dbName, classes);
+    await instance.initDB();
+    return instance;
+  }
+
+  private async initDB(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, 1);
 
-    request.onupgradeneeded = () => {
-      const db = request.result;
+      request.onupgradeneeded = () => {
+        const db = request.result;
 
-      this.classes.forEach((cls) => {
-        const keyPathFields = Reflect.getMetadata("keypath", cls) || [];
+        this.classes.forEach((cls) => {
+          const keyPathFields = Reflect.getMetadata("keypath", cls) || [];
 
-        const storeName = cls.name.toLowerCase() + "s";
+          const storeName = cls.name.toLowerCase() + "s";
 
-        if (!db.objectStoreNames.contains(storeName)) {
-          db.createObjectStore(storeName, { keyPath: keyPathFields[0] });
-        }
-      });
-    };
+          if (!db.objectStoreNames.contains(storeName)) {
+            db.createObjectStore(storeName, { keyPath: keyPathFields[0] });
+          }
+        });
+      };
 
-    request.onsuccess = () => {
-      this.db = request.result;
-      console.log(`Database initialized with object stores for: ${this.classes.map(cls => cls.name).join(", ")}`);
-    };
+      request.onsuccess = () => {
+        this.db = request.result;
+        console.log(`Database initialized with object stores for: ${this.classes.map(cls => cls.name).join(", ")}`);
+        resolve();
+      };
 
-    request.onerror = () => {
-      console.error("Error initializing database:", request.error);
-    };
+      request.onerror = () => {
+        console.error("Error initializing database:", request.error);
+        reject(request.error);
+      };
+    });
   }
 
   private getObjectStore(className: string, mode: IDBTransactionMode): IDBObjectStore {

package/lib/index.d.ts

@@ -5,7 +5,8 @@ declare class Database {
     private dbName;
     private classes;
     private db;
-    constructor(dbName: string, classes: Function[]);
+    private constructor();
+    static build(dbName: string, classes: Function[]): Promise<Database>;
     private initDB;
     private getObjectStore;
     create<T>(cls: {

package/lib/index.js

@@ -39,27 +39,39 @@ class Database {
             throw new Error("All classes should be decorated with @DataClass.");
         }
         this.classes = classes;
-        this.initDB();
+    }
+    static build(dbName, classes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = new Database(dbName, classes);
+            yield instance.initDB();
+            return instance;
+        });
     }
     initDB() {
-        const request = indexedDB.open(this.dbName, 1);
-        request.onupgradeneeded = () => {
-            const db = request.result;
-            this.classes.forEach((cls) => {
-                const keyPathFields = Reflect.getMetadata("keypath", cls) || [];
-                const storeName = cls.name.toLowerCase() + "s";
-                if (!db.objectStoreNames.contains(storeName)) {
-                    db.createObjectStore(storeName, { keyPath: keyPathFields[0] });
-                }
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const request = indexedDB.open(this.dbName, 1);
+                request.onupgradeneeded = () => {
+                    const db = request.result;
+                    this.classes.forEach((cls) => {
+                        const keyPathFields = Reflect.getMetadata("keypath", cls) || [];
+                        const storeName = cls.name.toLowerCase() + "s";
+                        if (!db.objectStoreNames.contains(storeName)) {
+                            db.createObjectStore(storeName, { keyPath: keyPathFields[0] });
+                        }
+                    });
+                };
+                request.onsuccess = () => {
+                    this.db = request.result;
+                    console.log(`Database initialized with object stores for: ${this.classes.map(cls => cls.name).join(", ")}`);
+                    resolve();
+                };
+                request.onerror = () => {
+                    console.error("Error initializing database:", request.error);
+                    reject(request.error);
+                };
             });
-        };
-        request.onsuccess = () => {
-            this.db = request.result;
-            console.log(`Database initialized with object stores for: ${this.classes.map(cls => cls.name).join(", ")}`);
-        };
-        request.onerror = () => {
-            console.error("Error initializing database:", request.error);
-        };
+        });
     }
     getObjectStore(className, mode) {
         if (!this.db) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idb-ts",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Easy CRUD for indexed-db, written in TypeScript",
   "main": "index.ts",
   "scripts": {