Merge pull request #9 from maifeeulasad/orm-flavor-runtime-method-generation

[feature]: orm flavor runtime method generation w repo pattern;

Author: maifeeulasad

.github/workflows/ci.yaml

@@ -15,9 +15,11 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: 20.x
+      - name: Install build tools
+        run: npm i -g pnpm
       - name: Install dependencies
-        run: npm ci
+        run: pnpm i
       - name: Run tests
-        run: npm run test
+        run: pnpm test
       - name: Run tests with coverage
-        run: npm run test:coverage
+        run: pnpm test:coverage

__tests__/annotation.test.ts

@@ -70,4 +70,23 @@ describe('IndexedDB annotation', () => {
     expect(db).toBeDefined();
   });
 
+  it('should expose getAvailableEntities utility', async () => {
+    @DataClass()
+    class Foo {
+      @KeyPath()
+      id!: string;
+    }
+
+    @DataClass()
+    class Bar {
+      @KeyPath()
+      id!: string;
+    }
+
+    const db = await Database.build('UtilDB', [Foo, Bar]);
+    const entities = db.getAvailableEntities();
+    expect(entities).toContain('Foo');
+    expect(entities).toContain('Bar');
+  });
+
 });

__tests__/database.test.ts

@@ -1,4 +1,4 @@
-import { Database, KeyPath, DataClass, Index } from '../index';
+import { Database, KeyPath, DataClass, Index, EntityRepository } from '../index';
 
 @DataClass()
 class User {
@@ -20,65 +20,59 @@ class User {
 }
 
 describe('IndexedDB CRUD', () => {
-  let db: Database;
+  let db: Record<string, EntityRepository<any>>;
 
   beforeAll(async () => {
     db = await Database.build('TestDB', [User]);
   });
 
   it('should create a new user', async () => {
     const user = new User('u1', 'Alice', 30);
-    await db.create(User, user);
-
-    const stored = await db.read(User, 'u1');
+    await db.User.create(user);
+    const stored = await db.User.read('u1');
     expect(stored).toEqual(user);
   });
 
   it('should update an existing user', async () => {
     const user = new User('u1', 'Alice', 31);
-    await db.update(User, user);
-
-    const updated = await db.read(User, 'u1');
+    await db.User.update(user);
+    const updated = await db.User.read('u1');
     expect(updated?.age).toBe(31);
   });
 
   it('should list all users', async () => {
-    const users = await db.list(User);
+    const users = await db.User.list();
     expect(users.length).toBeGreaterThan(0);
-    expect(users.find(u => u.id === 'u1')).toBeDefined();
+    expect(users.find((u: User) => u.id === 'u1')).toBeDefined();
   });
 
   it('should paginate results', async () => {
-    await db.create(User, new User('u2', 'Bob', 25));
-    await db.create(User, new User('u3', 'Charlie', 22));
-
-    const page1 = await db.listPaginated(User, 1, 2);
-    const page2 = await db.listPaginated(User, 2, 2);
-
+    await db.User.create(new User('u2', 'Bob', 25));
+    await db.User.create(new User('u3', 'Charlie', 22));
+    const page1 = await db.User.listPaginated(1, 2);
+    const page2 = await db.User.listPaginated(2, 2);
     expect(page1.length).toBe(2);
     expect(page2.length).toBeGreaterThanOrEqual(0);
   });
 
   it('should delete a user', async () => {
-    await db.delete(User, 'u1');
-    const deleted = await db.read(User, 'u1');
+    await db.User.delete('u1');
+    const deleted = await db.User.read('u1');
     expect(deleted).toBeUndefined();
   });
 
   it('should find users by email index', async () => {
     const user = new User('u5', 'Diana', 35, 'diana@example.com');
-    await db.create(User, user);
-
-    const found = await db.findByIndex(User, 'email', 'diana@example.com');
+    await db.User.create(user);
+    const found = await db.User.findByIndex('email', 'diana@example.com');
     expect(found.length).toBe(1);
     expect(found[0].name).toBe('Diana');
   });
 
   it('should find one user by email index', async () => {
     const user = new User('u6', 'Eve', 29, 'eve@example.com');
-    await db.create(User, user);
-
-    const found = await db.findOneByIndex(User, 'email', 'eve@example.com');
+    await db.User.create(user);
+    const found = await db.User.findOneByIndex('email', 'eve@example.com');
     expect(found).toBeDefined();
     expect(found!.name).toBe('Eve');
   });

__tests__/indexing.test.ts

@@ -22,72 +22,72 @@ class User {
 }
 
 describe('IndexedDB Indexing', () => {
-  let db: Database;
+  let db: any;
 
   beforeAll(async () => {
     db = await Database.build('IndexingTestDB', [User]);
   });
 
   beforeEach(async () => {
     // Clear existing data
-    const users = await db.list(User);
+    const users = await db.User.list();
     for (const user of users) {
-      await db.delete(User, user.id);
+      await db.User.delete(user.id);
     }
 
     // Add test data
-    await db.create(User, new User('u1', 'alice@example.com', 30, 'Alice'));
-    await db.create(User, new User('u2', 'bob@example.com', 25, 'Bob'));
-    await db.create(User, new User('u3', 'charlie@example.com', 30, 'Charlie'));
-    await db.create(User, new User('u4', 'alice@work.com', 28, 'Alice Smith'));
+    await db.User.create(new User('u1', 'alice@example.com', 30, 'Alice'));
+    await db.User.create(new User('u2', 'bob@example.com', 25, 'Bob'));
+    await db.User.create(new User('u3', 'charlie@example.com', 30, 'Charlie'));
+    await db.User.create(new User('u4', 'alice@work.com', 28, 'Alice Smith'));
   });
 
   it('should find users by email index', async () => {
-    const users = await db.findByIndex(User, 'email', 'alice@example.com');
+    const users = await db.User.findByIndex('email', 'alice@example.com');
     expect(users.length).toBe(1);
     expect(users[0].name).toBe('Alice');
     expect(users[0].email).toBe('alice@example.com');
   });
 
   it('should find multiple users by age index', async () => {
-    const users = await db.findByIndex(User, 'age', 30);
+    const users = await db.User.findByIndex('age', 30);
     expect(users.length).toBe(2);
-    const names = users.map(u => u.name).sort();
+    const names = users.map((u: User) => u.name).sort();
     expect(names).toEqual(['Alice', 'Charlie']);
   });
 
   it('should find single user by email index', async () => {
-    const user = await db.findOneByIndex(User, 'email', 'bob@example.com');
+    const user = await db.User.findOneByIndex('email', 'bob@example.com');
     expect(user).toBeDefined();
     expect(user!.name).toBe('Bob');
     expect(user!.age).toBe(25);
   });
 
   it('should return undefined when no user found by index', async () => {
-    const user = await db.findOneByIndex(User, 'email', 'nonexistent@example.com');
+    const user = await db.User.findOneByIndex('email', 'nonexistent@example.com');
     expect(user).toBeUndefined();
   });
 
   it('should return empty array when no users found by index', async () => {
-    const users = await db.findByIndex(User, 'age', 99);
+    const users = await db.User.findByIndex('age', 99);
     expect(users).toEqual([]);
   });
 
   it('should throw error when querying non-existent index', async () => {
-    await expect(db.findByIndex(User, 'nonexistent', 'value')).rejects.toThrow(
+    await expect(db.User.findByIndex('nonexistent', 'value')).rejects.toThrow(
       "Index 'nonexistent' does not exist on User"
     );
   });
 
   it('should throw error when querying non-existent index with findOneByIndex', async () => {
-    await expect(db.findOneByIndex(User, 'nonexistent', 'value')).rejects.toThrow(
+    await expect(db.User.findOneByIndex('nonexistent', 'value')).rejects.toThrow(
       "Index 'nonexistent' does not exist on User"
     );
   });
 
   it('should work with non-indexed fields not being queryable by index', async () => {
     // name field is not indexed, so this should throw an error
-    await expect(db.findByIndex(User, 'name', 'Alice')).rejects.toThrow(
+    await expect(db.User.findByIndex('name', 'Alice')).rejects.toThrow(
       "Index 'name' does not exist on User"
     );
   });