@indexeddb-orm/idb-orm 0.0.1

package/tests/aggregation.e2e.test.ts

@@ -0,0 +1,87 @@
+import {
+ beforeEach, describe, expect, it,
+} from 'vitest';
+
+import {
+ defineEntity, newEntity,
+} from '../src';
+import { Database } from '../src/Database';
+import { BaseEntity } from '../src/services/BaseEntity';
+
+class Author extends BaseEntity<number> {
+  name!: string;
+}
+defineEntity(Author, { tableName: 'authors', columns: { name: { required: true } } });
+
+class Article extends BaseEntity<number> {
+  title!: string;
+  category?: string;
+  views?: number;
+  authorId?: number;
+  author?: Author;
+}
+defineEntity(Article, {
+  tableName: 'articles',
+  columns: {
+    title: { required: true },
+    category: {},
+    views: {},
+    authorId: { indexed: true },
+  },
+  relations: {
+    author: { type: 'one-to-one', target: Author, foreignKey: 'authorId' },
+  },
+});
+
+const ENTITIES = [Author, Article];
+
+describe('Aggregation', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = Database.createDatabase({
+      name: `agg-db-${Date.now()}-${Math.random()}`,
+      version: 1,
+      entities: ENTITIES,
+      config: { onSchemaChangeStrategy: 'all' },
+    });
+
+    await db.clearAllData();
+  });
+
+  it('where + sort + limit + count/sum/avg/min/max + groupBy', async () => {
+    const authors = db.getRepository(Author);
+    const articles = db.getRepository(Article);
+
+    const a1 = await authors.add(newEntity(Author, { name: 'Ann' }));
+    const a2 = await authors.add(newEntity(Author, { name: 'Ben' }));
+
+    await articles.bulkAdd([
+      { title: 'T1', category: 'tech', views: 5, authorId: a1 } as Article,
+      { title: 'T2', category: 'tech', views: 15, authorId: a1 } as Article,
+      { title: 'T3', category: 'life', views: 20, authorId: a2 } as Article,
+    ]);
+
+    const res = await db.aggregate({
+      entityClass: Article,
+      options: {
+        where: { category: 'tech' } as Partial<Article>,
+        sort: { field: 'views', direction: 'desc' },
+        limit: 2,
+        count: true,
+        sum: ['views'],
+        avg: ['views'],
+        min: ['views'],
+        max: ['views'],
+        groupBy: 'category',
+      },
+    });
+
+    expect(res.count).toBe(2);
+    expect(res.sum?.views).toBe(20);
+    expect(res.avg?.views).toBe(10);
+    expect(res.min?.views).toBe(5);
+    expect(res.max?.views).toBe(15);
+    expect(res.groups?.find(g => g.key === 'tech')?.count).toBe(2);
+  });
+});

package/tests/base-entity.e2e.test.ts

@@ -0,0 +1,47 @@
+import {
+ describe, expect, it,
+} from 'vitest';
+import { z } from 'zod';
+
+import { BaseEntity } from '../src/services/BaseEntity';
+
+class Person extends BaseEntity<number> {
+  name?: string;
+  age?: number;
+
+  static schema = z.object({
+    name: z.string(),
+    age: z.number().int().nonnegative(),
+  });
+}
+
+describe('BaseEntity', () => {
+  it('validate returns valid result for correct data', () => {
+    const p = new Person();
+    Object.assign(p, { name: 'John', age: 30 });
+    const result = p.validate();
+    expect(result.isValid).toBe(true);
+    expect(result.errors.length).toBe(0);
+  });
+
+  it('validate returns errors for invalid data', () => {
+    const p = new Person();
+    Object.assign(p, { name: 'John', age: -1 });
+    const result = p.validate();
+    expect(result.isValid).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+  });
+
+  it('validateOrThrow throws on invalid', () => {
+    const p = new Person();
+    Object.assign(p, { name: 'John', age: -1 });
+    expect(() => p.validateOrThrow()).toThrowError();
+  });
+
+  it('init assigns data and validates', () => {
+    const p = new Person();
+    const inited = p.init({ name: 'Alice', age: 22 });
+    expect(inited.name).toBe('Alice');
+    expect(inited.age).toBe(22);
+  });
+});

package/tests/database-api.e2e.test.ts

@@ -0,0 +1,177 @@
+import {
+ beforeEach, describe, expect, it,
+} from 'vitest';
+
+import {
+ defineEntity, newEntity,
+} from '../src';
+import { Database } from '../src/Database';
+import { BaseEntity } from '../src/services/BaseEntity';
+
+class User extends BaseEntity<number> {
+  name!: string;
+}
+defineEntity(User, { tableName: 'users', columns: { name: { required: true } } });
+
+class Post extends BaseEntity<number> {
+  title!: string;
+  category?: string;
+  likes?: number;
+  comments?: Comment[];
+}
+defineEntity(Post, {
+  tableName: 'posts',
+  columns: {
+    title: { required: true },
+    category: {},
+    likes: {},
+  },
+  relations: {
+    comments: { type: 'one-to-many', target: 'comments', foreignKey: 'postId' },
+  },
+});
+
+class Comment extends BaseEntity<number> {
+  text!: string;
+  postId?: number;
+}
+defineEntity(Comment, {
+  tableName: 'comments',
+  columns: {
+    text: { required: true },
+    postId: { indexed: true },
+  },
+});
+
+const ENTITIES = [User, Post, Comment];
+
+describe('Database public API', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = Database.createDatabase({
+      name: `e2e-db-${Date.now()}-${Math.random()}`,
+      version: 1,
+      entities: ENTITIES,
+      config: { onSchemaChangeStrategy: 'all' },
+    });
+
+    await db.clearAllData();
+  });
+
+  it('createDatabase + getRepository + basic CRUD', async () => {
+    const users = db.getRepository(User);
+    const u = newEntity(User, { name: 'Alice' });
+    const id = await users.add(u);
+
+    const fetched = await users.get(id as number);
+    expect((fetched as User).name).toBe('Alice');
+  });
+
+  it('getTypedTable/getTableForEntity are typed aliases', async () => {
+    const t1 = db.getTypedTable(User);
+    const t2 = db.getTableForEntity(User);
+
+    const u = newEntity(User, { name: 'Bob' });
+    const id = await t1.add(u);
+    const fetched = await t2.get(id as number);
+    expect((fetched as User).name).toBe('Bob');
+  });
+
+  it('getEntities/getEntity expose entity registry', () => {
+    const entities = db.getEntities();
+    expect(entities.length).toBe(3);
+    expect(db.getEntity('users')).toBe(User);
+    expect(db.getEntity('unknown')).toBeUndefined();
+  });
+
+  it(
+    'loadRelations/loadRelationByName/saveWithRelations/deleteWithRelations (one-to-many)',
+    async () => {
+      const posts = db.getRepository(Post);
+      const comments = db.getRepository(Comment);
+
+      const pNew = newEntity(Post, { title: 'P1' });
+      const postId = (await posts.add(pNew)) as number;
+
+      const c1 = newEntity(Comment, { text: 'c1', postId });
+      const c2 = newEntity(Comment, { text: 'c2', postId });
+
+      const saved1 = await db
+      .saveWithRelations({ entity: c1, entityClass: Comment });
+      const saved2 = await db
+      .saveWithRelations({ entity: c2, entityClass: Comment });
+      expect(saved1.id && saved2.id).toBeTruthy();
+
+      const loadedByName = await db.loadRelationByName({
+        entity: { id: postId } as Post,
+        entityClass: Post,
+        relationName: 'comments',
+      });
+      expect(Array.isArray(loadedByName)).toBe(true);
+      expect((loadedByName as Comment[]).length).toBe(2);
+
+      const loadedPost = await db.loadRelations({
+        entity: { id: postId } as Post,
+        entityClass: Post,
+        relationNames: ['comments'],
+      });
+      expect(loadedPost.comments?.length).toBe(2);
+
+      await db.deleteWithRelations({ entity: saved1, entityClass: Comment });
+      const remaining = await comments.toCollection().toArray();
+      expect(remaining.length).toBe(1);
+    },
+  );
+
+  it('aggregate: count/sum/avg/min/max/groupBy/filter/sort/limit', async () => {
+    const posts = db.getRepository(Post);
+
+    await posts.bulkAdd([
+      { title: 'A', category: 'tech', likes: 5 } as Post,
+      { title: 'B', category: 'tech', likes: 15 } as Post,
+      { title: 'C', category: 'life', likes: 20 } as Post,
+    ]);
+
+    const res = await db.aggregate({
+      entityClass: Post,
+      options: {
+        where: { category: 'tech' } as Partial<Post>,
+        sort: { field: 'likes', direction: 'desc' },
+        limit: 2,
+        count: true,
+        sum: ['likes'],
+        avg: ['likes'],
+        min: ['likes'],
+        max: ['likes'],
+        groupBy: 'category',
+      },
+    });
+
+    expect(res.count).toBe(2);
+    expect(res.sum?.likes).toBe(20);
+    expect(res.avg?.likes).toBe(10);
+    expect(res.min?.likes).toBe(5);
+    expect(res.max?.likes).toBe(15);
+    expect(res.groups?.find(g => g.key === 'tech')?.count).toBe(2);
+  });
+
+  it('clearAllData removes all rows', async () => {
+    const users = db.getRepository(User);
+    const u = newEntity(User, { name: 'X' });
+    await users.add(u);
+    await db.clearAllData();
+    const all = await users.toCollection().toArray();
+    expect(all.length).toBe(0);
+  });
+
+  it('runMigrations/checkSchemaChanges/resetDatabase hooks work (smoke)', async () => {
+    await db.runMigrations([{ name: 'noop', version: 1, up: async () => {} }]);
+
+    const changed = await db.checkSchemaChanges();
+    expect(typeof changed).toBe('boolean');
+
+    await db.resetDatabase();
+    expect(true).toBe(true);
+  });
+});

package/tests/decorators.e2e.test.ts

@@ -0,0 +1,40 @@
+import {
+ describe, expect, it,
+} from 'vitest';
+
+import { defineEntity } from '../src';
+import { BaseEntity } from '../src/services/BaseEntity';
+import { SchemaBuilder } from '../src/services/SchemaBuilder';
+
+class DecorTest extends BaseEntity<number> {
+  a: string;
+  email?: string;
+  b?: number;
+}
+
+defineEntity(DecorTest, {
+  tableName: 'decor_tests',
+  columns: {
+    a: { required: true },
+    email: { unique: true },
+    b: { indexed: true },
+  },
+  compoundIndexes: [
+    { columns: ['a', 'b'], unique: true },
+  ],
+});
+
+describe('defineEntity schema', () => {
+  it('Column/Unique/Index/CompoundIndex reflected in schema',
+    () => {
+    const schema = SchemaBuilder.buildSchema([DecorTest]);
+    const tableSchema = schema['decor_tests'];
+    expect(tableSchema).toBeTruthy();
+
+    expect(tableSchema.includes('id')).toBe(true);
+    expect(tableSchema.includes('b')).toBe(true);
+    expect(tableSchema.includes('&email')).toBe(true);
+    expect(tableSchema.includes('[a+b]')).toBe(true);
+    expect(tableSchema.includes('&[a+b]')).toBe(true);
+  });
+});

package/tests/entity-schema.e2e.test.ts

@@ -0,0 +1,58 @@
+import {
+ describe, expect, it,
+} from 'vitest';
+import { z } from 'zod';
+
+import { defineEntity } from '../src';
+import { BaseEntity } from '../src/services/BaseEntity';
+import { EntitySchema } from '../src/services/EntitySchema';
+
+class Thing extends BaseEntity<number> {
+  name: string;
+  count?: number;
+
+  static schema = z.object({
+    name: z.string(),
+    count: z.number().int().nonnegative(),
+  });
+}
+
+defineEntity(Thing, {
+  tableName: 'things',
+  columns: {
+    name: { required: true },
+    count: { default: 0 },
+  },
+});
+
+describe('EntitySchema', () => {
+  const schema = new EntitySchema(Thing, Thing.schema);
+
+  it('getTableName returns explicit tableName', () => {
+    expect(schema.getTableName()).toBe('things');
+  });
+
+  it('getSchema returns zod schema', () => {
+    expect(schema.getSchema()).toBe(Thing.schema);
+  });
+
+  it('getColumns returns metadata keys', () => {
+    const cols = schema.getColumns();
+    expect(Object.keys(cols)).toContain('name');
+    expect(Object.keys(cols)).toContain('count');
+  });
+
+  it('validate checks required and types', () => {
+    const ok = schema.validate({ name: 'ok', count: 1 });
+    expect(ok.isValid).toBe(true);
+
+    const bad = schema.validate({ count: -1 });
+    expect(bad.isValid).toBe(false);
+  });
+
+  it('create applies defaults and assigns data', () => {
+    const t = schema.create({ name: 'abc' });
+    expect(t.name).toBe('abc');
+    expect(t.count).toBe(0);
+  });
+});

package/tests/relation-loader-table-names.test.ts

@@ -0,0 +1,192 @@
+import {
+ beforeEach, describe, expect, it,
+} from 'vitest';
+
+import { defineEntity } from '../src';
+import { Database } from '../src/Database';
+import { BaseEntity } from '../src/services/BaseEntity';
+
+class TagEntity extends BaseEntity<number> {
+  name!: string;
+  color!: string;
+  description?: string;
+  createdAt!: number;
+  updatedAt!: number;
+}
+
+defineEntity(TagEntity, {
+  tableName: 'tags',
+  columns: {
+    name: { required: true, unique: true, indexed: true },
+    color: { required: true },
+    description: {},
+    createdAt: { indexed: true },
+    updatedAt: { indexed: true },
+  },
+});
+
+class PostEntity extends BaseEntity<number> {
+  title!: string;
+  content!: string;
+  authorId!: number;
+  published?: boolean;
+  postTags?: string[];
+  likes?: number;
+  createdAt?: number;
+  updatedAt?: number;
+  tags?: TagEntity[];
+}
+
+defineEntity(PostEntity, {
+  tableName: 'posts',
+  columns: {
+    title: { required: true, indexed: true },
+    content: { required: true },
+    authorId: { required: true, indexed: true },
+    published: { default: false, indexed: true },
+    postTags: {},
+    likes: { default: 0, indexed: true },
+    createdAt: { default: () => Date.now(), indexed: true },
+    updatedAt: { default: () => Date.now() },
+  },
+  relations: {
+    tags: { type: 'many-to-many', target: 'tags', joinTable: 'post_tags' },
+  },
+});
+
+class ProfileEntity extends BaseEntity<number> {
+  userId!: number;
+  bio?: string;
+  avatar?: string;
+  website?: string;
+  location?: string;
+  createdAt!: number;
+  updatedAt!: number;
+}
+
+defineEntity(ProfileEntity, {
+  tableName: 'profiles',
+  columns: {
+    userId: { indexed: true },
+    bio: {},
+    avatar: {},
+    website: {},
+    location: {},
+    createdAt: { indexed: true },
+    updatedAt: { indexed: true },
+  },
+});
+
+class UserEntity extends BaseEntity<number> {
+  name!: string;
+  email!: string;
+  age!: number;
+  createdAt!: number;
+  updatedAt!: number;
+  isActive!: boolean;
+  tags!: string[];
+  metadata!: Record<string, unknown>;
+  posts?: PostEntity[];
+  profile?: ProfileEntity;
+}
+
+defineEntity(UserEntity, {
+  tableName: 'users',
+  columns: {
+    name: { required: true, indexed: true },
+    email: { required: true, unique: true },
+    age: { indexed: true },
+    createdAt: { indexed: true },
+    updatedAt: { indexed: true },
+    isActive: { indexed: true },
+    tags: {},
+    metadata: {},
+  },
+  compoundIndexes: [
+    { columns: ['name', 'email'], unique: false, name: 'name_email_index' },
+    { columns: ['age', 'isActive'], unique: false, name: 'age_active_index' },
+    { columns: ['email'], unique: true, name: 'unique_email_index' },
+  ],
+  relations: {
+    posts: { type: 'one-to-many', target: 'posts', foreignKey: 'authorId' },
+    profile: { type: 'one-to-one', target: 'profiles', foreignKey: 'userId' },
+  },
+});
+
+describe('RelationLoader table name resolution (demo parity)', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = Database.createDatabase({
+      name: `rl-names-${Date.now()}-${Math.random()}`,
+      version: 1,
+      entities: [UserEntity, ProfileEntity, PostEntity, TagEntity],
+      config: { onSchemaChangeStrategy: 'all' },
+    });
+    await db.clearAllData();
+  });
+
+  it('saves user with relations using users/profiles/posts tables (no userentitys)', async () => {
+    const user = Object.assign(new UserEntity(), {
+      name: 'John Doe',
+      email: 'john@example.com',
+      age: 30,
+      tags: ['developer'],
+      metadata: { source: 'relation-test' },
+    });
+
+    const profile = Object.assign(new ProfileEntity(), {
+      bio: 'Full-stack developer',
+      avatar: 'https://example.com/avatar.jpg',
+      website: 'https://johndoe.com',
+      location: 'New York',
+    });
+
+    const post1 = Object.assign(new PostEntity(), {
+      title: 'My First Post',
+      content: 'This is my first post!',
+      published: true,
+      likes: 10,
+    });
+
+    const post2 = Object.assign(new PostEntity(), {
+      title: 'Learning Dexie ORM',
+      content: 'Dexie ORM is awesome!',
+      published: true,
+      likes: 25,
+    });
+
+    const tag1 = Object.assign(new TagEntity(), {
+      name: 'javascript',
+      color: '#f7df1e',
+      description: 'JavaScript programming',
+    });
+
+    const tag2 = Object.assign(new TagEntity(), {
+      name: 'typescript',
+      color: '#3178c6',
+      description: 'TypeScript programming',
+    });
+
+    user.profile = profile;
+    user.posts = [post1, post2];
+    post1.tags = [tag1, tag2];
+    post2.tags = [tag1];
+
+    const saved = await db
+    .saveWithRelations({ entity: user, entityClass: UserEntity });
+
+    expect(saved.id).toBeTruthy();
+
+    const usersCount = await db.table('users').count();
+    expect(usersCount).toBe(1);
+
+    const profiles = await db.table('profiles').where('userId').equals(saved.id!).toArray();
+    expect(profiles.length).toBe(1);
+
+    const posts = await db.table('posts').where('authorId').equals(saved.id!).toArray();
+    expect(posts.length).toBe(2);
+  });
+});
+
+