idb-ts 0.0.1 → 2.0.0

package/README.md

@@ -1 +1,76 @@
-# ts-indexeddb
+# idb-ts
+
+## Installation
+```
+npm i idb-ts
+```
+
+## Example
+
+### Declaring entity
+```
+
+@DataClass()
+class User {
+  @KeyPath()
+  name: string;
+  age: number;
+  cell?: string;
+  address: string;
+
+  constructor(name: string, age: number, address: string, cell?: string) {
+    this.name = name;
+    this.age = age;
+    this.address = address;
+    this.cell = cell;
+  }
+}
+
+@DataClass()
+class Location {
+  @KeyPath()
+  id: string;
+  city: string;
+  country: string;
+
+  constructor(id: string, city: string, country: string) {
+    this.id = id;
+    this.city = city;
+    this.country = country;
+  }
+}
+```
+
+### CRUD on DB
+```
+const db = new Database("idb-crud", [User, Location]);
+
+const alice = new User("Alice", 25, "123 Main St");
+const nyc = new Location("1", "New York", "USA");
+
+await db.create(User, alice);
+await db.create(Location, nyc);
+
+const readAlice = await db.read(User, "Alice");
+console.log("Read user:", readAlice);
+
+alice.age = 26;
+alice.address = "789 Maple St";
+await db.update(User, alice);
+
+const users = await db.list(User);
+console.log("All users:", users);
+
+await db.delete(User, "Alice");
+console.log("User Alice deleted.");
+
+const remainingUsers = await db.list(User);
+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

@@ -1 +1,188 @@
-console.log('Hello, world!');
+import 'reflect-metadata';
+
+function KeyPath(): PropertyDecorator {
+  return (target: Object, propertyKey: string | symbol) => {
+    const constructor = target.constructor as Function;
+    Reflect.defineMetadata("keypath", [propertyKey as string], constructor);
+  };
+}
+
+function DataClass(): ClassDecorator {
+  return (target: Function) => {
+    if (!Reflect.getMetadata("keypath", target)) {
+      throw new Error(`No keypath field defined for the class ${target.name}.`);
+    }
+    const keyPathFields = Reflect.getMetadata("keypath", target) || [];
+    if (keyPathFields.length > 1) {
+      throw new Error(`Only one keypath field can be defined for the class ${target.name}.`);
+    }
+    Reflect.defineMetadata("dataclass", true, target);
+  };
+}
+
+class Database {
+  private dbName: string;
+  private classes: Function[];
+  private db: IDBDatabase | null = null;
+
+  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;
+  }
+
+  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;
+
+        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);
+      };
+    });
+  }
+
+  private getObjectStore(className: string, mode: IDBTransactionMode): IDBObjectStore {
+    if (!this.db) {
+      throw new Error("Database not initialized.");
+    }
+    const storeName = className.toLowerCase() + "s";
+    const transaction = this.db.transaction(storeName, mode);
+    return transaction.objectStore(storeName);
+  }
+
+  async create<T>(cls: { new(...args: any[]): T }, item: T): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const store = this.getObjectStore(cls.name, "readwrite");
+        const request = store.add(item);
+
+        request.onsuccess = () => {
+          console.log(`Item added to ${cls.name}:`, item);
+          resolve();
+        };
+
+        request.onerror = () => {
+          console.error(`Error adding item to ${cls.name}:`, request.error);
+          reject(request.error);
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  async read<T>(cls: { new(...args: any[]): T }, key: string): Promise<T | undefined> {
+    return new Promise((resolve, reject) => {
+      try {
+        const store = this.getObjectStore(cls.name, "readonly");
+        const request = store.get(key);
+
+        request.onsuccess = () => {
+          console.log(`Item read from ${cls.name}:`, request.result);
+          resolve(request.result as T | undefined);
+        };
+
+        request.onerror = () => {
+          console.error(`Error reading item from ${cls.name}:`, request.error);
+          reject(request.error);
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  async update<T>(cls: { new(...args: any[]): T }, item: T): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const store = this.getObjectStore(cls.name, "readwrite");
+        const request = store.put(item);
+
+        request.onsuccess = () => {
+          console.log(`Item updated in ${cls.name}:`, item);
+          resolve();
+        };
+
+        request.onerror = () => {
+          console.error(`Error updating item in ${cls.name}:`, request.error);
+          reject(request.error);
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  async delete<T>(cls: { new(...args: any[]): T }, key: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const store = this.getObjectStore(cls.name, "readwrite");
+        const request = store.delete(key);
+
+        request.onsuccess = () => {
+          console.log(`Item deleted from ${cls.name}:`, key);
+          resolve();
+        };
+
+        request.onerror = () => {
+          console.error(`Error deleting item from ${cls.name}:`, request.error);
+          reject(request.error);
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  async list<T>(cls: { new(...args: any[]): T }): Promise<T[]> {
+    return new Promise((resolve, reject) => {
+      try {
+        const store = this.getObjectStore(cls.name, "readonly");
+        const request = store.getAll();
+
+        request.onsuccess = () => {
+          console.log(`All items from ${cls.name}:`, request.result);
+          resolve(request.result as T[]);
+        };
+
+        request.onerror = () => {
+          console.error(`Error listing items from ${cls.name}:`, request.error);
+          reject(request.error);
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+}
+
+export { Database, KeyPath, DataClass };

package/lib/index.d.ts

@@ -0,0 +1,28 @@
+import 'reflect-metadata';
+declare function KeyPath(): PropertyDecorator;
+declare function DataClass(): ClassDecorator;
+declare class Database {
+    private dbName;
+    private classes;
+    private db;
+    private constructor();
+    static build(dbName: string, classes: Function[]): Promise<Database>;
+    private initDB;
+    private getObjectStore;
+    create<T>(cls: {
+        new (...args: any[]): T;
+    }, item: T): Promise<void>;
+    read<T>(cls: {
+        new (...args: any[]): T;
+    }, key: string): Promise<T | undefined>;
+    update<T>(cls: {
+        new (...args: any[]): T;
+    }, item: T): Promise<void>;
+    delete<T>(cls: {
+        new (...args: any[]): T;
+    }, key: string): Promise<void>;
+    list<T>(cls: {
+        new (...args: any[]): T;
+    }): Promise<T[]>;
+}
+export { Database, KeyPath, DataClass };

package/lib/index.js

@@ -1,2 +1,190 @@
 "use strict";
-console.log('Hello, world!');
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataClass = exports.KeyPath = exports.Database = void 0;
+require("reflect-metadata");
+function KeyPath() {
+    return (target, propertyKey) => {
+        const constructor = target.constructor;
+        Reflect.defineMetadata("keypath", [propertyKey], constructor);
+    };
+}
+exports.KeyPath = KeyPath;
+function DataClass() {
+    return (target) => {
+        if (!Reflect.getMetadata("keypath", target)) {
+            throw new Error(`No keypath field defined for the class ${target.name}.`);
+        }
+        const keyPathFields = Reflect.getMetadata("keypath", target) || [];
+        if (keyPathFields.length > 1) {
+            throw new Error(`Only one keypath field can be defined for the class ${target.name}.`);
+        }
+        Reflect.defineMetadata("dataclass", true, target);
+    };
+}
+exports.DataClass = DataClass;
+class Database {
+    constructor(dbName, classes) {
+        this.db = null;
+        this.dbName = dbName;
+        if (!classes.every(cls => Reflect.getMetadata("dataclass", cls))) {
+            throw new Error("All classes should be decorated with @DataClass.");
+        }
+        this.classes = classes;
+    }
+    static build(dbName, classes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = new Database(dbName, classes);
+            yield instance.initDB();
+            return instance;
+        });
+    }
+    initDB() {
+        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);
+                };
+            });
+        });
+    }
+    getObjectStore(className, mode) {
+        if (!this.db) {
+            throw new Error("Database not initialized.");
+        }
+        const storeName = className.toLowerCase() + "s";
+        const transaction = this.db.transaction(storeName, mode);
+        return transaction.objectStore(storeName);
+    }
+    create(cls, item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    const store = this.getObjectStore(cls.name, "readwrite");
+                    const request = store.add(item);
+                    request.onsuccess = () => {
+                        console.log(`Item added to ${cls.name}:`, item);
+                        resolve();
+                    };
+                    request.onerror = () => {
+                        console.error(`Error adding item to ${cls.name}:`, request.error);
+                        reject(request.error);
+                    };
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    read(cls, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    const store = this.getObjectStore(cls.name, "readonly");
+                    const request = store.get(key);
+                    request.onsuccess = () => {
+                        console.log(`Item read from ${cls.name}:`, request.result);
+                        resolve(request.result);
+                    };
+                    request.onerror = () => {
+                        console.error(`Error reading item from ${cls.name}:`, request.error);
+                        reject(request.error);
+                    };
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    update(cls, item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    const store = this.getObjectStore(cls.name, "readwrite");
+                    const request = store.put(item);
+                    request.onsuccess = () => {
+                        console.log(`Item updated in ${cls.name}:`, item);
+                        resolve();
+                    };
+                    request.onerror = () => {
+                        console.error(`Error updating item in ${cls.name}:`, request.error);
+                        reject(request.error);
+                    };
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    delete(cls, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    const store = this.getObjectStore(cls.name, "readwrite");
+                    const request = store.delete(key);
+                    request.onsuccess = () => {
+                        console.log(`Item deleted from ${cls.name}:`, key);
+                        resolve();
+                    };
+                    request.onerror = () => {
+                        console.error(`Error deleting item from ${cls.name}:`, request.error);
+                        reject(request.error);
+                    };
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    list(cls) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    const store = this.getObjectStore(cls.name, "readonly");
+                    const request = store.getAll();
+                    request.onsuccess = () => {
+                        console.log(`All items from ${cls.name}:`, request.result);
+                        resolve(request.result);
+                    };
+                    request.onerror = () => {
+                        console.error(`Error listing items from ${cls.name}:`, request.error);
+                        reject(request.error);
+                    };
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+}
+exports.Database = Database;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idb-ts",
-  "version": "0.0.1",
+  "version": "2.0.0",
   "description": "Easy CRUD for indexed-db, written in TypeScript",
   "main": "index.ts",
   "scripts": {
@@ -21,9 +21,12 @@
   "bugs": {
     "url": "https://github.com/maifeeulasad/idb-crud/issues"
   },
-  "files": ["lib"],
+  "files": [
+    "lib"
+  ],
   "homepage": "https://github.com/maifeeulasad/idb-crud#readme",
   "devDependencies": {
+    "reflect-metadata": "^0.2.2",
     "typescript": "^4.6.3"
   }
-}
+}