@indexeddb-orm/idb-orm 0.0.1

package/tests/relations.e2e.test.ts

@@ -0,0 +1,178 @@
+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;
+  profile?: Profile;
+  posts?: Post[];
+}
+
+defineEntity(User, {
+  tableName: 'users',
+  columns: { name: { required: true } },
+  relations: {
+    profile: { type: 'one-to-one', target: 'profiles', foreignKey: 'userId', cascade: true },
+    posts: { type: 'one-to-many', target: 'posts', foreignKey: 'authorId', cascade: true },
+  },
+});
+
+class Profile extends BaseEntity<number> {
+  bio?: string;
+  userId?: number;
+}
+
+defineEntity(Profile, {
+  tableName: 'profiles',
+  columns: {
+    bio: {},
+    userId: { indexed: true },
+  },
+});
+
+class Post extends BaseEntity<number> {
+  title!: string;
+  tags?: Tag[];
+  authorId?: number;
+}
+
+defineEntity(Post, {
+  tableName: 'posts',
+  columns: {
+    title: { required: true },
+    authorId: { indexed: true },
+  },
+  relations: {
+    tags: { type: 'many-to-many', target: 'tags', joinTable: 'post_tags', cascade: true },
+  },
+});
+
+class Tag extends BaseEntity<number> {
+  name!: string;
+}
+
+defineEntity(Tag, {
+  tableName: 'tags',
+  columns: { name: { required: true } },
+});
+
+class PostTag extends BaseEntity<number> {
+  sourceId!: number;
+  targetId!: number;
+}
+
+defineEntity(PostTag, {
+  tableName: 'post_tags',
+  columns: {
+    sourceId: { indexed: true },
+    targetId: { indexed: true },
+  },
+});
+
+const ENTITIES = [User, Profile, Post, Tag, PostTag];
+
+describe('Relations', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = Database.createDatabase({
+      name: `rel-db-${Date.now()}-${Math.random()}`,
+      version: 1,
+      entities: ENTITIES,
+      config: { onSchemaChangeStrategy: 'all' },
+    });
+
+    await db.clearAllData();
+  });
+
+  it('one-to-one: load and cascade delete', async () => {
+    const users = db.getRepository(User);
+    const profiles = db.getRepository(Profile);
+
+    const u = newEntity(User, { name: 'U' });
+    const userId = await users.add(u);
+
+    const profile = newEntity(Profile, { bio: 'Bio', userId });
+    const saved = await db
+      .saveWithRelations({ entity: profile, entityClass: Profile });
+
+    const loaded = await db.loadRelationByName({
+      entity: { id: userId },
+      entityClass: User,
+      relationName: 'profile',
+    });
+    expect(loaded!.bio).toBe('Bio');
+
+    await db.deleteWithRelations({ entity: saved, entityClass: Profile });
+    const after = await profiles.get(saved.id!);
+    expect(after).toBeUndefined();
+  });
+
+  it('one-to-many: load and cascade delete', async () => {
+    const users = db.getRepository(User);
+    const posts = db.getRepository(Post);
+
+    const u = newEntity(User, { name: 'U' });
+    const userId = await users.add(u);
+
+    const p1 = newEntity(Post, { title: 'P1', authorId: userId });
+    const p2 = newEntity(Post, { title: 'P2', authorId: userId });
+
+    await db.saveWithRelations({ entity: p1, entityClass: Post });
+    await db.saveWithRelations({ entity: p2, entityClass: Post });
+
+    const loaded = await db.loadRelationByName({
+      entity: { id: userId },
+      entityClass: User,
+      relationName: 'posts',
+    });
+    expect((loaded as Post[]).length).toBe(2);
+
+    const first = await posts.where('authorId').equals(userId).first();
+    await db.deleteWithRelations({ entity: first!, entityClass: Post });
+
+    const remaining = await posts.where('authorId').equals(userId).toArray();
+    expect(remaining.length).toBe(1);
+  });
+
+  it('many-to-many: load and cascade delete removes join links', async () => {
+    const posts = db.getRepository(Post);
+    const tags = db.getRepository(Tag);
+    const join = db.table('post_tags');
+
+    const pNew = newEntity(Post, { title: 'P' });
+    const postId = await posts.add(pNew);
+
+    const tA = newEntity(Tag, { name: 'a' });
+    const tagAId = await tags.add(tA);
+
+    const tB = newEntity(Tag, { name: 'b' });
+    const tagBId = await tags.add(tB);
+
+    const p = newEntity(Post, {
+      id: postId,
+      title: 'P',
+      tags: [{ id: tagAId } as Tag, { id: tagBId } as Tag],
+    });
+    await db.saveWithRelations({ entity: p, entityClass: Post });
+
+    const loaded = await db.loadRelationByName({
+      entity: { id: postId } as Post,
+      entityClass: Post,
+      relationName: 'tags',
+    });
+    expect((loaded as Tag[]).length).toBe(2);
+
+    await db
+      .deleteWithRelations({ entity: { id: postId } as Post, entityClass: Post });
+
+    const links = await join.where('sourceId').equals(postId).toArray();
+    expect(links.length).toBe(0);
+  });
+});

package/tests/zod-runtime.e2e.test.ts

@@ -0,0 +1,69 @@
+import {
+ beforeEach, describe, expect, it,
+} from 'vitest';
+import { z } from 'zod';
+
+import { defineEntity } from '../src';
+import { Database } from '../src/Database';
+import { BaseEntity } from '../src/services/BaseEntity';
+import { EntitySchema } from '../src/services/EntitySchema';
+
+class Product extends BaseEntity<number> {
+  name?: string;
+  price?: number;
+  static schema = z.object({
+    name: z.string(),
+    price: z.number().positive(),
+  });
+}
+
+defineEntity(Product, { tableName: 'products' });
+
+describe('Zod runtime validation', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = Database.createDatabase({
+      name: `zod-db-${Date.now()}-${Math.random()}`,
+      version: 1,
+      entities: [Product],
+      config: { onSchemaChangeStrategy: 'all' },
+    });
+
+    await db.clearAllData();
+  });
+
+  it('BaseEntity.validate and validateOrThrow (registered entity)', () => {
+    const entityCtor = db.getEntity('products')!;
+    expect(entityCtor).toBe(Product);
+
+    const ok = new Product();
+    Object.assign(ok, { name: 'X', price: 1 });
+
+    const okRes = ok.validate();
+    expect(okRes.isValid).toBe(true);
+
+    const bad = new Product();
+    Object.assign(bad, { name: 'Y', price: -2 });
+
+    const badRes = bad.validate();
+    expect(badRes.isValid).toBe(false);
+    expect(() => bad.validateOrThrow()).toThrowError();
+  });
+
+  it('EntitySchema.validate with schema and create', () => {
+    const schema = new EntitySchema(Product, Product.schema);
+
+    const valid = schema.validate({ name: 'A', price: 2 });
+    expect(valid.isValid).toBe(true);
+
+    const invalid = schema
+    .validate({ name: 'A', price: -1 } as Partial<Product>);
+
+    expect(invalid.isValid).toBe(false);
+
+    const p = schema.create({ name: 'B', price: 3 });
+    expect(p.name).toBe('B');
+    expect(p.price).toBe(3);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022", "DOM"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "experimentalDecorators": false,
+    "emitDecoratorMetadata": false,
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "demo-app"]
+}

package/vitest.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    setupFiles: ['./vitest.setup.ts'],
+    include: ['tests/**/*.test.ts'],
+    globals: true,
+  },
+  esbuild: {
+    tsconfigRaw: {
+      compilerOptions: {
+        experimentalDecorators: true,
+        useDefineForClassFields: false,
+        target: 'ES2022',
+      },
+    },
+  },
+});
+
+

package/vitest.setup.ts

@@ -0,0 +1,27 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import FDBFactory from 'fake-indexeddb/lib/FDBFactory';
+import FDBKeyRange from 'fake-indexeddb/lib/FDBKeyRange';
+
+if (!(globalThis as any).indexedDB) {
+  (globalThis as any).indexedDB = new FDBFactory();
+}
+
+if (!(globalThis as any).IDBKeyRange) {
+  (globalThis as any).IDBKeyRange = FDBKeyRange;
+}
+
+class MemoryLocalStorage {
+  private store = new Map<string, string>();
+  getItem(key: string):
+  string | null { return this.store.has(key) ? this.store.get(key)! : null; }
+  setItem(key: string, value: string): void { this.store.set(key, String(value)); }
+  removeItem(key: string): void { this.store.delete(key); }
+  clear(): void { this.store.clear(); }
+}
+
+if (!(globalThis as any).localStorage) {
+  (globalThis as any).localStorage = new MemoryLocalStorage();
+}
+
+

package/vue-demo-app/README.md

@@ -0,0 +1,61 @@
+# Dexie ORM Demo App
+
+A demonstration app showcasing the capabilities of the **Dexie ORM for IndexedDB** library.
+
+## Library Features
+
+- **Entity Configuration** - define entities using `defineEntity()`
+- **Automatic Schema** - automatic schema generation with primary keys and indexes
+- **Relations** - entity relationships with helpers
+- **Zod Validation** - runtime validation
+- **Aggregations** - aggregate functions (count, avg, sum)
+- **Live Queries** - reactive queries with `useLiveQuery()`
+- **TypeScript** - full type safety
+- **Cloud Sync** - synchronization with Dexie Cloud
+
+## Quick Start
+
+### Requirements
+- Node.js 18+
+- npm or yarn
+
+### Installation and Running
+
+1. **Install dependencies:**
+   ```bash
+   npm install
+   ```
+
+2. **Run in development mode:**
+   ```bash
+   npm run dev
+   ```
+
+3. **Open in browser:**
+   ```
+   http://localhost:5173
+   ```
+
+### Production Build
+
+```bash
+npm run build
+```
+
+## App Features
+
+### Admin Tab
+- **Overview** - library capabilities overview
+- **Admin Actions** - function testing buttons
+- **Live Query Demo** - reactive queries demonstration
+- **TypeScript Demo** - type safety testing
+- **Posts Demo** - advanced queries and aggregations
+
+### Cloud Sync Tab
+- **Sync Status** - synchronization status
+- **Sync Controls** - synchronization management buttons
+- **Instructions** - configuration instructions
+
+## More Information
+
+For more information visit our official [page](https://idb-orm.com).

package/vue-demo-app/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Dexie ORM Vue Demo</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>