@indexeddb-orm/idb-orm 0.0.1

package/svelte-demo-app/src/database/Database.ts

@@ -0,0 +1,29 @@
+import { Database } from 'idb-orm';
+
+import { PostEntity } from '../entities/Post';
+import { PostTagEntity } from '../entities/PostTag';
+import { ProfileEntity } from '../entities/Profile';
+import { TagEntity } from '../entities/Tag';
+import { UserEntity } from '../entities/User';
+import { migrations } from '../migrations';
+
+// Create database with entity registration
+export const db = Database.createDatabase({
+  name: 'DexieORMDemo',
+  version: 6,
+  entities: [UserEntity, PostEntity, ProfileEntity, TagEntity, PostTagEntity],
+  config: {
+    // This will be ignored when migrations are provided
+    // onSchemaChangeStrategy: 'selective',
+    migrations: migrations, // Migrations take priority over reset strategy
+
+    // Cloud sync configuration (optional)
+    // cloudSync: {
+    //   databaseUrl: 'https://your-database-url.dexie.cloud', // Replace with your actual URL
+    //   enableOfflineSupport: true,
+    //   syncInterval: 30000, // Sync every 30 seconds (optional)
+    //   tables: ['users', 'posts', 'profiles'] // Specific tables to sync
+    //   (optional - syncs all if empty)
+    // }
+  },
+});

package/svelte-demo-app/src/entities/Post.ts

@@ -0,0 +1,46 @@
+import { BaseEntity, defineEntity } from 'idb-orm';
+import { z } from 'zod';
+
+import type { TagEntity } from './Tag';
+
+const PostSchema = z.object({
+  id: z.number().optional(),
+  title: z.string().min(1, 'Title is required'),
+  content: z.string().min(1, 'Content is required'),
+  authorId: z.number().positive('Author ID must be positive'),
+  published: z.boolean().optional(),
+  postTags: z.array(z.string()).optional(),
+  likes: z.number().min(0, 'Likes must be non-negative').optional(),
+  createdAt: z.number().optional(),
+  updatedAt: z.number().optional(),
+});
+
+export 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',
+  schema: PostSchema,
+  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' },
+  },
+});

package/svelte-demo-app/src/entities/PostTag.ts

@@ -0,0 +1,22 @@
+import { BaseEntity, defineEntity } from 'idb-orm';
+import { z } from 'zod';
+
+const PostTagSchema = z.object({
+  id: z.number().optional(),
+  sourceId: z.number(),
+  targetId: z.number(),
+});
+
+export class PostTagEntity extends BaseEntity<number> {
+  sourceId!: number;
+  targetId!: number;
+}
+
+defineEntity(PostTagEntity, {
+  tableName: 'post_tags',
+  schema: PostTagSchema,
+  columns: {
+    sourceId: { indexed: true },
+    targetId: { indexed: true },
+  },
+});

package/svelte-demo-app/src/entities/Profile.ts

@@ -0,0 +1,39 @@
+import { BaseEntity, defineEntity } from 'idb-orm';
+import { z } from 'zod';
+
+const ProfileSchema = z.object({
+  id: z.number().optional(),
+  userId: z.number().positive('User ID must be positive'),
+  bio: z.string().optional(),
+  avatar: z.string().url().optional(),
+  website: z.string().url().optional(),
+  location: z.string().optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+
+export type Profile = z.infer<typeof ProfileSchema>;
+
+export class ProfileEntity extends BaseEntity<number> {
+  userId!: number;
+  bio?: string;
+  avatar?: string;
+  website?: string;
+  location?: string;
+  createdAt!: number;
+  updatedAt!: number;
+}
+
+defineEntity(ProfileEntity, {
+  tableName: 'profiles',
+  schema: ProfileSchema,
+  columns: {
+    userId: { indexed: true },
+    bio: { indexed: true },
+    avatar: {},
+    website: {},
+    location: {},
+    createdAt: { indexed: true },
+    updatedAt: { indexed: true },
+  },
+});

package/svelte-demo-app/src/entities/Tag.ts

@@ -0,0 +1,33 @@
+import { BaseEntity, defineEntity } from 'idb-orm';
+import { z } from 'zod';
+
+const TagSchema = z.object({
+  id: z.number().optional(),
+  name: z.string().min(1, 'Tag name is required'),
+  color: z.string().regex(/^#[0-9A-F]{6}$/i, 'Color must be a valid hex color'),
+  description: z.string().optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+
+export type Tag = z.infer<typeof TagSchema>;
+
+export class TagEntity extends BaseEntity<number> {
+  name!: string;
+  color!: string;
+  description?: string;
+  createdAt!: number;
+  updatedAt!: number;
+}
+
+defineEntity(TagEntity, {
+  tableName: 'tags',
+  schema: TagSchema,
+  columns: {
+    name: { required: true, unique: true, indexed: true },
+    color: { required: true },
+    description: {},
+    createdAt: { indexed: true },
+    updatedAt: { indexed: true },
+  },
+});

package/svelte-demo-app/src/entities/User.ts

@@ -0,0 +1,62 @@
+import {
+ BaseEntity,
+ defineEntity,
+} from 'idb-orm';
+import { z } from 'zod';
+
+import type { PostEntity } from './Post';
+import type { ProfileEntity } from './Profile';
+
+// Zod schema for validation
+export const UserSchema = z.object({
+  id: z.number().optional(),
+  name: z.string().min(2, 'Name must be at least 2 characters'),
+  email: z.string().email('Invalid email format'),
+  age: z.number().min(18, 'Must be at least 18 years old'),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  isActive: z.boolean().default(true),
+  tags: z.array(z.string()).default([]),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  // Note:
+  // 'posts' and 'profile' relations are not in schema - they're loaded separately
+});
+
+export type User = z.infer<typeof UserSchema>;
+
+export 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',
+  schema: UserSchema,
+  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: { indexed: true },
+  },
+  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' },
+  },
+});

package/svelte-demo-app/src/lib/database/Database.ts

@@ -0,0 +1,30 @@
+import { browser } from '$app/environment';
+import { Database } from '../../../../src/Database';
+
+import { PostEntity } from '../entities/Post';
+import { PostTagEntity } from '../entities/PostTag';
+import { ProfileEntity } from '../entities/Profile';
+import { TagEntity } from '../entities/Tag';
+import { UserEntity } from '../entities/User';
+import { migrations } from '../migrations';
+
+// Create database with entity registration - only in browser
+export const db = browser ? Database.createDatabase({
+  name: 'DexieORMDemo',
+  version: 6,
+  entities: [UserEntity, PostEntity, ProfileEntity, TagEntity, PostTagEntity],
+  config: {
+    // This will be ignored when migrations are provided
+    // onSchemaChangeStrategy: 'selective',
+    migrations: migrations, // Migrations take priority over reset strategy
+
+    // Cloud sync configuration (optional)
+    // cloudSync: {
+    //   databaseUrl: 'https://your-database-url.dexie.cloud', // Replace with your actual URL
+    //   enableOfflineSupport: true,
+    //   syncInterval: 30000, // Sync every 30 seconds (optional)
+    //   tables: ['users', 'posts', 'profiles'] // Specific tables to sync
+    //   (optional - syncs all if empty)
+    // }
+  },
+}) : null;

package/svelte-demo-app/src/lib/entities/Post.ts

@@ -0,0 +1,47 @@
+import { BaseEntity } from '../../../../src/services/BaseEntity';
+import { defineEntity } from '../../../../src/services/EntityRegistry';
+import { z } from 'zod';
+
+import type { TagEntity } from './Tag';
+
+const PostSchema = z.object({
+  id: z.number().optional(),
+  title: z.string().min(1, 'Title is required'),
+  content: z.string().min(1, 'Content is required'),
+  authorId: z.number().positive('Author ID must be positive'),
+  published: z.boolean().optional(),
+  postTags: z.array(z.string()).optional(),
+  likes: z.number().min(0, 'Likes must be non-negative').optional(),
+  createdAt: z.number().optional(),
+  updatedAt: z.number().optional(),
+});
+
+export 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',
+  schema: PostSchema,
+  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' },
+  },
+});

package/svelte-demo-app/src/lib/entities/PostTag.ts

@@ -0,0 +1,23 @@
+import { BaseEntity } from '../../../../src/services/BaseEntity';
+import { defineEntity } from '../../../../src/services/EntityRegistry';
+import { z } from 'zod';
+
+const PostTagSchema = z.object({
+  id: z.number().optional(),
+  sourceId: z.number(),
+  targetId: z.number(),
+});
+
+export class PostTagEntity extends BaseEntity<number> {
+  sourceId!: number;
+  targetId!: number;
+}
+
+defineEntity(PostTagEntity, {
+  tableName: 'post_tags',
+  schema: PostTagSchema,
+  columns: {
+    sourceId: { indexed: true },
+    targetId: { indexed: true },
+  },
+});

package/svelte-demo-app/src/lib/entities/Profile.ts

@@ -0,0 +1,40 @@
+import { BaseEntity } from '../../../../src/services/BaseEntity';
+import { defineEntity } from '../../../../src/services/EntityRegistry';
+import { z } from 'zod';
+
+const ProfileSchema = z.object({
+  id: z.number().optional(),
+  userId: z.number().positive('User ID must be positive'),
+  bio: z.string().optional(),
+  avatar: z.string().url().optional(),
+  website: z.string().url().optional(),
+  location: z.string().optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+
+export type Profile = z.infer<typeof ProfileSchema>;
+
+export class ProfileEntity extends BaseEntity<number> {
+  userId!: number;
+  bio?: string;
+  avatar?: string;
+  website?: string;
+  location?: string;
+  createdAt!: number;
+  updatedAt!: number;
+}
+
+defineEntity(ProfileEntity, {
+  tableName: 'profiles',
+  schema: ProfileSchema,
+  columns: {
+    userId: { indexed: true },
+    bio: { indexed: true },
+    avatar: {},
+    website: {},
+    location: {},
+    createdAt: { indexed: true },
+    updatedAt: { indexed: true },
+  },
+});

package/svelte-demo-app/src/lib/entities/Tag.ts

@@ -0,0 +1,34 @@
+import { BaseEntity } from '../../../../src/services/BaseEntity';
+import { defineEntity } from '../../../../src/services/EntityRegistry';
+import { z } from 'zod';
+
+const TagSchema = z.object({
+  id: z.number().optional(),
+  name: z.string().min(1, 'Tag name is required'),
+  color: z.string().regex(/^#[0-9A-F]{6}$/i, 'Color must be a valid hex color'),
+  description: z.string().optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+
+export type Tag = z.infer<typeof TagSchema>;
+
+export class TagEntity extends BaseEntity<number> {
+  name!: string;
+  color!: string;
+  description?: string;
+  createdAt!: number;
+  updatedAt!: number;
+}
+
+defineEntity(TagEntity, {
+  tableName: 'tags',
+  schema: TagSchema,
+  columns: {
+    name: { required: true, unique: true, indexed: true },
+    color: { required: true },
+    description: {},
+    createdAt: { indexed: true },
+    updatedAt: { indexed: true },
+  },
+});

package/svelte-demo-app/src/lib/entities/User.ts

@@ -0,0 +1,59 @@
+import { BaseEntity } from '../../../../src/services/BaseEntity';
+import { defineEntity } from '../../../../src/services/EntityRegistry';
+import { z } from 'zod';
+
+import type { PostEntity } from './Post';
+import type { ProfileEntity } from './Profile';
+
+// Zod schema for validation
+export const UserSchema = z.object({
+  id: z.number().optional(),
+  name: z.string().min(2, 'Name must be at least 2 characters'),
+  email: z.string().email('Invalid email format'),
+  age: z.number().min(18, 'Must be at least 18 years old'),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  isActive: z.boolean().default(true),
+  tags: z.array(z.string()).default([]),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  // Note: 'posts' and 'profile' relations are not in schema - they're loaded separately
+});
+
+export type User = z.infer<typeof UserSchema>;
+
+export 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',
+  schema: UserSchema,
+  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: { indexed: true },
+  },
+  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' },
+  },
+});

package/svelte-demo-app/src/lib/index.ts

@@ -0,0 +1,7 @@
+// Export all entities and database
+export { db } from './database/Database';
+export { UserEntity, UserSchema, type User } from './entities/User';
+export { PostEntity } from './entities/Post';
+export { ProfileEntity, ProfileSchema, type Profile } from './entities/Profile';
+export { TagEntity, TagSchema, type Tag } from './entities/Tag';
+export { PostTagEntity } from './entities/PostTag';

package/svelte-demo-app/src/lib/migrations/001-add-user-email-index.ts

@@ -0,0 +1,17 @@
+import type { Migration } from '../../../src/types';
+
+export const addUserEmailIndex: Migration = {
+  version: 1,
+  name: 'add-user-email-index',
+  up: async () => {
+    console.log('Adding email index to users table...');
+    // This migration would add an index to the email field
+    // In a real scenario, you might need to recreate the table with the new index
+    console.log('Email index added successfully');
+  },
+  down: async () => {
+    console.log('Removing email index from users table...');
+    // This would remove the index
+    console.log('Email index removed successfully');
+  },
+};

package/svelte-demo-app/src/lib/migrations/002-add-post-category.ts

@@ -0,0 +1,37 @@
+import type { Migration } from '../../../src/types';
+
+export const addPostCategory: Migration = {
+  version: 2,
+  name: 'add-post-category',
+  up: async (db) => {
+  console.log('Adding category field to posts table...');
+
+    const posts = await db.table('posts').toArray();
+    const updatedPosts = posts.map((post: Record<string, unknown>) => ({
+      ...post,
+      category: 'general',
+    }));
+
+    const postsRepo = db.table('posts');
+    await postsRepo.clear();
+    await postsRepo.bulkAdd(updatedPosts);
+
+    console.log('Category field added to all existing posts');
+  },
+  down: async (db) => {
+    console.log('Removing category field from posts table...');
+
+    const posts = await db.table('posts').toArray();
+    const updatedPosts = posts
+    .map(({ _category, ...post }: Record<string, unknown>) => {
+
+      return post;
+    });
+
+    const postsRepo = db.table('posts');
+    await postsRepo.clear();
+    await postsRepo.bulkAdd(updatedPosts);
+
+    console.log('Category field removed from all posts');
+  },
+};

package/svelte-demo-app/src/lib/migrations/index.ts

@@ -0,0 +1,8 @@
+import type { Migration } from '../../../src/types';
+import { addUserEmailIndex } from './001-add-user-email-index';
+import { addPostCategory } from './002-add-post-category';
+
+export const migrations: Migration[] = [
+  addUserEmailIndex,
+  addPostCategory,
+];

package/svelte-demo-app/src/migrations/001-add-user-email-index.ts

@@ -0,0 +1,17 @@
+import type { Migration } from '../../../src/types';
+
+export const addUserEmailIndex: Migration = {
+  version: 1,
+  name: 'add-user-email-index',
+  up: async () => {
+    console.log('Adding email index to users table...');
+    // This migration would add an index to the email field
+    // In a real scenario, you might need to recreate the table with the new index
+    console.log('Email index added successfully');
+  },
+  down: async () => {
+    console.log('Removing email index from users table...');
+    // This would remove the index
+    console.log('Email index removed successfully');
+  },
+};

package/svelte-demo-app/src/migrations/002-add-post-category.ts

@@ -0,0 +1,37 @@
+import type { Migration } from '../../../src/types';
+
+export const addPostCategory: Migration = {
+  version: 2,
+  name: 'add-post-category',
+  up: async (db) => {
+  console.log('Adding category field to posts table...');
+
+    const posts = await db.table('posts').toArray();
+    const updatedPosts = posts.map((post: Record<string, unknown>) => ({
+      ...post,
+      category: 'general',
+    }));
+
+    const postsRepo = db.table('posts');
+    await postsRepo.clear();
+    await postsRepo.bulkAdd(updatedPosts);
+
+    console.log('Category field added to all existing posts');
+  },
+  down: async (db) => {
+    console.log('Removing category field from posts table...');
+
+    const posts = await db.table('posts').toArray();
+    const updatedPosts = posts
+    .map(({ _category, ...post }: Record<string, unknown>) => {
+
+      return post;
+    });
+
+    const postsRepo = db.table('posts');
+    await postsRepo.clear();
+    await postsRepo.bulkAdd(updatedPosts);
+
+    console.log('Category field removed from all posts');
+  },
+};

package/svelte-demo-app/src/migrations/index.ts

@@ -0,0 +1,8 @@
+import type { Migration } from '../../../src/types';
+import { addUserEmailIndex } from './001-add-user-email-index';
+import { addPostCategory } from './002-add-post-category';
+
+export const migrations: Migration[] = [
+  addUserEmailIndex,
+  addPostCategory,
+];

package/svelte-demo-app/src/routes/+layout.js

@@ -0,0 +1,3 @@
+// Disable SSR for this layout to allow IndexedDB to work
+export const ssr = false;
+export const prerender = false;