idb-ts 3.0.0 → 3.0.3

package/README.md

@@ -1,15 +1,36 @@
-# idb-ts
+# 🚀 idb-ts
 
-## Installation
-```
+[![npm version](https://img.shields.io/npm/v/idb-ts.svg)](https://www.npmjs.com/package/idb-ts)
+[![minified](https://badgen.net/bundlephobia/min/idb-ts)](https://badgen.net/bundlephobia/min/idb-ts)
+[![minified + gzipped](https://badgen.net/bundlephobia/minzip/idb-ts)](https://badgen.net/bundlephobia/minzip/idb-ts)
+
+[![GitHub stars](https://img.shields.io/github/stars/maifeeulasad/idb-ts)](https://github.com/maifeeulasad/idb-ts/stargazers)
+[![GitHub watchers](https://img.shields.io/github/watchers/maifeeulasad/idb-ts)](https://github.com/maifeeulasad/idb-ts/watchers)
+[![Commits after release](https://img.shields.io/github/commits-since/maifeeulasad/idb-ts/latest/main?include_prereleases)](https://img.shields.io/github/commits-since/maifeeulasad/idb-ts/latest/main?include_prereleases)
+
+## 📌 Introduction
+**idb-ts** is a lightweight, declarative, and type-safe way to work with IndexedDB using TypeScript. Effortlessly perform CRUD operations on your database with clean, structured code! 🔥
+
+## 📦 Installation
+Install via npm and start using IndexedDB like a pro! ⚡
+```sh
 npm i idb-ts
 ```
 
-## Example
+## ✨ Features
+- ✅ **Declarative & Type-Safe** - Define your data models with decorators.
+- ⚡ **Easy CRUD Operations** - Perform create, read, update, and delete seamlessly.
+- 🚀 **Fully Typed API** - Benefit from TypeScript’s powerful type system.
+- 🏎️ **Performance Optimized** - Minimal overhead with IndexedDB's native capabilities.
 
-### Declaring entity
-```
+---
+
+## 📖 Example Usage
 
+### 🏗️ Declaring Entities
+Use decorators to define your data models with automatic schema management.
+
+```typescript
 @DataClass()
 class User {
   @KeyPath()
@@ -41,8 +62,10 @@ class Location {
 }
 ```
 
-### CRUD on DB
-```
+### 🔄 CRUD Operations
+Perform database operations in an intuitive way:
+
+```typescript
 const db = await Database.build("idb-crud", [User, Location]);
 
 const alice = new User("Alice", 25, "123 Main St");
@@ -52,25 +75,30 @@ await db.create(User, alice);
 await db.create(Location, nyc);
 
 const readAlice = await db.read(User, "Alice");
-console.log("Read user:", readAlice);
+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);
+console.log("📋 All users:", users);
 
 await db.delete(User, "Alice");
-console.log("User Alice deleted.");
+console.log("❌ User Alice deleted.");
 
 const remainingUsers = await db.list(User);
-console.log("Remaining users:", remainingUsers);
+console.log("🔍 Remaining users:", remainingUsers);
 
 const locations = await db.list(Location);
-console.log("All locations:", locations);
+console.log("🌍 All locations:", locations);
 ```
 
-## Links
- - GitHub: https://github.com/maifeeulasad/idb-ts
- - NPM: https://www.npmjs.com/package/idb-ts
+---
+
+## 🔗 Useful Links
+- 📂 **GitHub**: [maifeeulasad/idb-ts](https://github.com/maifeeulasad/idb-ts)
+- 📦 **NPM**: [idb-ts](https://www.npmjs.com/package/idb-ts)
+
+🎉 **Enjoy seamless IndexedDB integration with TypeScript! Happy coding!** 🚀
+

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "idb-ts",
-  "version": "3.0.0",
+  "version": "3.0.3",
   "description": "Easy CRUD for indexed-db, written in TypeScript",
-  "main": "index.ts",
+  "main": "lib/index.js",
   "scripts": {
     "prepare": "npm run build",
     "build": "tsc"

package/index.ts

@@ -1,188 +0,0 @@
-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;
-  }
-
-  public 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 };