@anfenn/dync 1.0.7 → 1.0.9

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-export { A as AfterRemoteAddCallback, a as ApiFunctions, d as BatchFirstLoadResult, b as BatchPushPayload, c as BatchPushResult, B as BatchSync, C as ConflictResolutionStrategy, D as Dync, F as FirstLoadProgress, e as FirstLoadProgressCallback, f as MissingRemoteRecordDuringUpdateCallback, M as MissingRemoteRecordStrategy, g as MutationEvent, S as SyncAction, h as SyncOptions, i as SyncState, j as SyncedRecord, T as TableMap } from './index.shared-DsDBNWlz.cjs';
-export { M as MemoryAdapter, a as MemoryQueryContext, S as SQLiteAdapter, b as SqliteQueryContext, c as StorageAdapter } from './dexie-1_xyU5MV.cjs';
+export { A as AfterRemoteAddCallback, a as ApiFunctions, d as BatchFirstLoadResult, b as BatchPushPayload, c as BatchPushResult, B as BatchSync, C as ConflictResolutionStrategy, D as Dync, F as FirstLoadProgress, e as FirstLoadProgressCallback, f as MissingRemoteRecordDuringUpdateCallback, M as MissingRemoteRecordStrategy, g as MutationEvent, S as SyncAction, h as SyncOptions, i as SyncState, j as SyncedRecord, T as TableMap } from './index.shared-C8JTfet7.cjs';
+export { M as MemoryAdapter, a as MemoryQueryContext, S as SQLiteAdapter, b as SqliteQueryContext, c as StorageAdapter } from './dexie-BqktVP7s.cjs';
 export { S as SQLiteDatabaseDriver, b as SQLiteQueryResult, a as SQLiteRunResult } from './types-CSbIAfu2.cjs';
 import 'dexie';
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { A as AfterRemoteAddCallback, a as ApiFunctions, d as BatchFirstLoadResult, b as BatchPushPayload, c as BatchPushResult, B as BatchSync, C as ConflictResolutionStrategy, D as Dync, F as FirstLoadProgress, e as FirstLoadProgressCallback, f as MissingRemoteRecordDuringUpdateCallback, M as MissingRemoteRecordStrategy, g as MutationEvent, S as SyncAction, h as SyncOptions, i as SyncState, j as SyncedRecord, T as TableMap } from './index.shared-Byhq6TyU.js';
-export { M as MemoryAdapter, a as MemoryQueryContext, S as SQLiteAdapter, b as SqliteQueryContext, c as StorageAdapter } from './dexie-ChZ0o0Sz.js';
+export { A as AfterRemoteAddCallback, a as ApiFunctions, d as BatchFirstLoadResult, b as BatchPushPayload, c as BatchPushResult, B as BatchSync, C as ConflictResolutionStrategy, D as Dync, F as FirstLoadProgress, e as FirstLoadProgressCallback, f as MissingRemoteRecordDuringUpdateCallback, M as MissingRemoteRecordStrategy, g as MutationEvent, S as SyncAction, h as SyncOptions, i as SyncState, j as SyncedRecord, T as TableMap } from './index.shared-DajtjVW7.js';
+export { M as MemoryAdapter, a as MemoryQueryContext, S as SQLiteAdapter, b as SqliteQueryContext, c as StorageAdapter } from './dexie-DRLMKLl5.js';
 export { S as SQLiteDatabaseDriver, b as SQLiteQueryResult, a as SQLiteRunResult } from './types-CSbIAfu2.js';
 import 'dexie';
 

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   SqliteQueryContext,
   SyncAction,
   createLocalId
-} from "./chunk-PCA4XM2N.js";
+} from "./chunk-MOYMEJP5.js";
 import "./chunk-SQB6E7V2.js";
 export {
   Dync,

package/dist/{index.shared-DsDBNWlz.d.cts → index.shared-C8JTfet7.d.cts}

@@ -1,4 +1,4 @@
-import { d as StorageTable, c as StorageAdapter, T as TableSchemaDefinition, D as DexieQueryContext, b as SqliteQueryContext, a as MemoryQueryContext } from './dexie-1_xyU5MV.cjs';
+import { d as StorageTable, c as StorageAdapter, T as TableSchemaDefinition, D as DexieQueryContext, b as SqliteQueryContext, a as MemoryQueryContext } from './dexie-BqktVP7s.cjs';
 import { c as SQLiteVersionConfigurator } from './types-CSbIAfu2.cjs';
 
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';

package/dist/{index.shared-Byhq6TyU.d.ts → index.shared-DajtjVW7.d.ts}

@@ -1,4 +1,4 @@
-import { d as StorageTable, c as StorageAdapter, T as TableSchemaDefinition, D as DexieQueryContext, b as SqliteQueryContext, a as MemoryQueryContext } from './dexie-ChZ0o0Sz.js';
+import { d as StorageTable, c as StorageAdapter, T as TableSchemaDefinition, D as DexieQueryContext, b as SqliteQueryContext, a as MemoryQueryContext } from './dexie-DRLMKLl5.js';
 import { c as SQLiteVersionConfigurator } from './types-CSbIAfu2.js';
 
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';

package/dist/react/index.d.cts

@@ -1,5 +1,5 @@
-import { a as ApiFunctions, h as SyncOptions, B as BatchSync, D as Dync, i as SyncState } from '../index.shared-DsDBNWlz.cjs';
-import { c as StorageAdapter } from '../dexie-1_xyU5MV.cjs';
+import { a as ApiFunctions, h as SyncOptions, B as BatchSync, D as Dync, i as SyncState } from '../index.shared-C8JTfet7.cjs';
+import { c as StorageAdapter } from '../dexie-BqktVP7s.cjs';
 import '../types-CSbIAfu2.cjs';
 import 'dexie';
 

package/dist/react/index.d.ts

@@ -1,5 +1,5 @@
-import { a as ApiFunctions, h as SyncOptions, B as BatchSync, D as Dync, i as SyncState } from '../index.shared-Byhq6TyU.js';
-import { c as StorageAdapter } from '../dexie-ChZ0o0Sz.js';
+import { a as ApiFunctions, h as SyncOptions, B as BatchSync, D as Dync, i as SyncState } from '../index.shared-DajtjVW7.js';
+import { c as StorageAdapter } from '../dexie-DRLMKLl5.js';
 import '../types-CSbIAfu2.js';
 import 'dexie';
 

package/dist/react/index.js

@@ -1,6 +1,6 @@
 import {
   Dync
-} from "../chunk-PCA4XM2N.js";
+} from "../chunk-MOYMEJP5.js";
 import "../chunk-SQB6E7V2.js";
 
 // src/react/useDync.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anfenn/dync",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "private": false,
   "description": "Write once, run IndexedDB & SQLite with sync anywhere - React, React Native, Expo, Capacitor, Electron & Node.js",
   "keywords": [

package/src/storage/dexie/DexieTable.ts

@@ -8,7 +8,6 @@ export class DexieTable<T = any> implements StorageTable<T> {
     readonly name: string;
     readonly schema: unknown;
     readonly primaryKey: unknown;
-    readonly hook: unknown;
     readonly raw = Object.freeze({
         add: (item: T): Promise<string> => this.table.add(item) as Promise<string>,
         put: (item: T): Promise<string> => this.table.put(item) as Promise<string>,
@@ -29,7 +28,6 @@ export class DexieTable<T = any> implements StorageTable<T> {
         this.name = table.name;
         this.schema = table.schema;
         this.primaryKey = table.schema?.primKey;
-        this.hook = table.hook;
     }
 
     add(item: AddItem<T>): Promise<string> {
@@ -84,8 +82,8 @@ export class DexieTable<T = any> implements StorageTable<T> {
         return this.table.bulkDelete(keys as any);
     }
 
-    where(index: string | string[]): StorageWhereClause<T> {
-        return new DexieWhereClause(this.table.where(normalizeIndexName(index)));
+    where(index: string): StorageWhereClause<T> {
+        return new DexieWhereClause(this.table.where(index));
     }
 
     orderBy(index: string | string[]): StorageCollection<T> {
@@ -104,11 +102,6 @@ export class DexieTable<T = any> implements StorageTable<T> {
         return new DexieCollection(this.table.limit(count));
     }
 
-    mapToClass(ctor: new (...args: any[]) => any): StorageTable<T> {
-        this.table.mapToClass(ctor as any);
-        return this;
-    }
-
     async each(callback: (item: T) => void | Promise<void>): Promise<void> {
         const tasks: Array<void | Promise<void>> = [];
         await this.table.each((item) => {

package/src/storage/memory/MemoryTable.ts

@@ -10,7 +10,6 @@ export class MemoryTable<T extends MemoryRecord = MemoryRecord> implements Stora
     readonly name: string;
     readonly schema: unknown = undefined;
     readonly primaryKey: unknown = LOCAL_PK;
-    readonly hook: unknown = Object.freeze({});
     readonly raw: {
         add: (item: T) => Promise<string>;
         put: (item: T) => Promise<string>;
@@ -133,7 +132,7 @@ export class MemoryTable<T extends MemoryRecord = MemoryRecord> implements Stora
         }
     }
 
-    where(index: string | string[]): StorageWhereClause<T> {
+    where(index: string): StorageWhereClause<T> {
         return this.createWhereClause(index);
     }
 
@@ -155,10 +154,6 @@ export class MemoryTable<T extends MemoryRecord = MemoryRecord> implements Stora
         return this.createCollection({ limit: count });
     }
 
-    mapToClass(_ctor: new (...args: any[]) => any): StorageTable<T> {
-        return this;
-    }
-
     async each(callback: (item: T) => void | Promise<void>): Promise<void> {
         for (const [, record] of this.entries()) {
             await callback(this.cloneRecord(record));
@@ -187,8 +182,8 @@ export class MemoryTable<T extends MemoryRecord = MemoryRecord> implements Stora
         });
     }
 
-    createWhereClause(index: string | string[], baseCollection?: MemoryCollection<T>): MemoryWhereClause<T> {
-        return new MemoryWhereClause(this, index, baseCollection);
+    createWhereClause(column: string, baseCollection?: MemoryCollection<T>): MemoryWhereClause<T> {
+        return new MemoryWhereClause(this, column, baseCollection);
     }
 
     entries(): Array<[string, T]> {

package/src/storage/memory/MemoryWhereClause.ts

@@ -5,12 +5,12 @@ import type { MemoryCollection } from './MemoryCollection';
 
 export class MemoryWhereClause<T extends MemoryRecord = MemoryRecord> implements StorageWhereClause<T> {
     private readonly table: MemoryTable<T>;
-    private readonly index: string | string[];
+    private readonly column: string;
     private readonly baseCollection?: MemoryCollection<T>;
 
-    constructor(table: MemoryTable<T>, index: string | string[], baseCollection?: MemoryCollection<T>) {
+    constructor(table: MemoryTable<T>, column: string, baseCollection?: MemoryCollection<T>) {
         this.table = table;
-        this.index = index;
+        this.column = column;
         this.baseCollection = baseCollection;
     }
 
@@ -116,10 +116,10 @@ export class MemoryWhereClause<T extends MemoryRecord = MemoryRecord> implements
     }
 
     private createCollection(predicate: (indexValue: unknown) => boolean): StorageCollection<T> {
-        const condition = (record: T, _key: string): boolean => predicate(this.table.getIndexValue(record, this.index));
+        const condition = (record: T, _key: string): boolean => predicate(this.table.getIndexValue(record, this.column));
         if (this.baseCollection) {
             const combined = (record: T, key: string): boolean =>
-                this.baseCollection!.matches(record, key) || predicate(this.table.getIndexValue(record, this.index));
+                this.baseCollection!.matches(record, key) || predicate(this.table.getIndexValue(record, this.column));
             return this.table.createCollectionFromPredicate(combined, this.baseCollection);
         }
         return this.table.createCollectionFromPredicate(condition);

package/src/storage/sqlite/SQLiteTable.ts

@@ -9,7 +9,6 @@ import { cloneValue, createDefaultState, normalizeComparableValue, quoteIdentifi
 export class SQLiteTable<T = any> implements StorageTable<T> {
     readonly name: string;
     readonly schema: SQLiteTableSchemaMetadata;
-    readonly hook: unknown = Object.freeze({});
     readonly raw: {
         add: (item: T) => Promise<string>;
         put: (item: T) => Promise<string>;
@@ -224,7 +223,7 @@ export class SQLiteTable<T = any> implements StorageTable<T> {
         await this.adapter.run(`DELETE FROM ${quoteIdentifier(this.name)} WHERE ${quoteIdentifier(LOCAL_PK)} IN (${placeholders})`, validKeys);
     }
 
-    where(index: string | string[]): StorageWhereClause<T> {
+    where(index: string): StorageWhereClause<T> {
         return this.createWhereClause(index);
     }
 
@@ -246,10 +245,6 @@ export class SQLiteTable<T = any> implements StorageTable<T> {
         return this.createCollection({ limit: count });
     }
 
-    mapToClass(_ctor: new (...args: any[]) => any): StorageTable<T> {
-        return this;
-    }
-
     async each(callback: (item: T) => void | Promise<void>): Promise<void> {
         const entries = await this.getEntries();
         for (const entry of entries) {
@@ -277,8 +272,8 @@ export class SQLiteTable<T = any> implements StorageTable<T> {
         });
     }
 
-    createWhereClause(index: string | string[], baseCollection?: SQLiteCollection<T>): SQLiteWhereClause<T> {
-        return new SQLiteWhereClause(this, index, baseCollection);
+    createWhereClause(column: string, baseCollection?: SQLiteCollection<T>): SQLiteWhereClause<T> {
+        return new SQLiteWhereClause(this, column, baseCollection);
     }
 
     async *iterateEntries(options?: SQLiteIterateEntriesOptions): AsyncGenerator<TableEntry<T>> {

package/src/storage/sqlite/SQLiteWhereClause.ts

@@ -5,55 +5,20 @@ import { SQLiteCollection } from './SQLiteCollection';
 
 export class SQLiteWhereClause<T = any> implements StorageWhereClause<T> {
     private readonly table: SQLiteTable<T>;
-    private readonly index: string | string[];
+    private readonly column: string;
     private readonly baseCollection?: SQLiteCollection<T>;
 
-    constructor(table: SQLiteTable<T>, index: string | string[], baseCollection?: SQLiteCollection<T>) {
+    constructor(table: SQLiteTable<T>, column: string, baseCollection?: SQLiteCollection<T>) {
         this.table = table;
-        this.index = index;
+        this.column = column;
         this.baseCollection = baseCollection;
     }
 
-    private getColumn(): string {
-        // For compound indexes, we only support the first column in SQL conditions
-        // Complex compound index queries fall back to JS
-        if (Array.isArray(this.index)) {
-            return this.index[0]!;
-        }
-        return this.index;
-    }
-
-    private isCompoundIndex(): boolean {
-        return Array.isArray(this.index) && this.index.length > 1;
-    }
-
-    private getCompoundColumns(): string[] {
-        return Array.isArray(this.index) ? this.index : [this.index];
-    }
-
-    private getCompoundValues(value: unknown): unknown[] {
-        // For compound indexes, value should be an array of values matching each column
-        if (Array.isArray(value)) {
-            return value;
-        }
-        // Single value for single-column index
-        return [value];
-    }
-
     private createCollectionWithCondition(condition: SQLiteCondition): SQLiteCollection<T> {
         const base = this.baseCollection ?? this.table.createCollection();
         return base.addSqlCondition(condition);
     }
 
-    private createCollectionWithJsPredicate(predicate: (record: T) => boolean): SQLiteCollection<T> {
-        const base = this.baseCollection ?? this.table.createCollection();
-        return base.jsFilter(predicate) as SQLiteCollection<T>;
-    }
-
-    private getIndexValue(record: T): unknown {
-        return this.table.getIndexValue(record, this.index);
-    }
-
     private flattenArgs<TValue>(args: any[]): TValue[] {
         if (args.length === 1 && Array.isArray(args[0])) {
             return args[0] as TValue[];
@@ -62,85 +27,53 @@ export class SQLiteWhereClause<T = any> implements StorageWhereClause<T> {
     }
 
     equals(value: any): StorageCollection<T> {
-        if (this.isCompoundIndex()) {
-            // Use native SQL: WHERE col1 = ? AND col2 = ? AND ...
-            const columns = this.getCompoundColumns();
-            const values = this.getCompoundValues(value);
-            return this.createCollectionWithCondition({
-                type: 'compoundEquals',
-                columns,
-                values,
-            });
-        }
         return this.createCollectionWithCondition({
             type: 'equals',
-            column: this.getColumn(),
+            column: this.column,
             value,
         });
     }
 
     above(value: any): StorageCollection<T> {
-        if (this.isCompoundIndex()) {
-            return this.createCollectionWithJsPredicate((record) => this.table.compareValues(this.getIndexValue(record), value) > 0);
-        }
         return this.createCollectionWithCondition({
             type: 'comparison',
-            column: this.getColumn(),
+            column: this.column,
             op: '>',
             value,
         });
     }
 
     aboveOrEqual(value: any): StorageCollection<T> {
-        if (this.isCompoundIndex()) {
-            return this.createCollectionWithJsPredicate((record) => this.table.compareValues(this.getIndexValue(record), value) >= 0);
-        }
         return this.createCollectionWithCondition({
             type: 'comparison',
-            column: this.getColumn(),
+            column: this.column,
             op: '>=',
             value,
         });
     }
 
     below(value: any): StorageCollection<T> {
-        if (this.isCompoundIndex()) {
-            return this.createCollectionWithJsPredicate((record) => this.table.compareValues(this.getIndexValue(record), value) < 0);
-        }
         return this.createCollectionWithCondition({
             type: 'comparison',
-            column: this.getColumn(),
+            column: this.column,
             op: '<',
             value,
         });
     }
 
     belowOrEqual(value: any): StorageCollection<T> {
-        if (this.isCompoundIndex()) {
-            return this.createCollectionWithJsPredicate((record) => this.table.compareValues(this.getIndexValue(record), value) <= 0);
-        }
         return this.createCollectionWithCondition({
             type: 'comparison',
-            column: this.getColumn(),
+            column: this.column,
             op: '<=',
             value,
         });
     }
 
     between(lower: any, upper: any, includeLower = true, includeUpper = false): StorageCollection<T> {
-        if (this.isCompoundIndex()) {
-            return this.createCollectionWithJsPredicate((record) => {
-                const value = this.getIndexValue(record);
-                const lowerCmp = this.table.compareValues(value, lower);
-                const upperCmp = this.table.compareValues(value, upper);
-                const lowerPass = includeLower ? lowerCmp >= 0 : lowerCmp > 0;
-                const upperPass = includeUpper ? upperCmp <= 0 : upperCmp < 0;
-                return lowerPass && upperPass;
-            });
-        }
         return this.createCollectionWithCondition({
             type: 'between',
-            column: this.getColumn(),
+            column: this.column,
             lower,
             upper,
             includeLower,
@@ -149,24 +82,19 @@ export class SQLiteWhereClause<T = any> implements StorageWhereClause<T> {
     }
 
     inAnyRange(ranges: Array<[any, any]>, options?: { includeLower?: boolean; includeUpper?: boolean }): StorageCollection<T> {
-        // inAnyRange with multiple ranges uses OR logic - can be expressed in SQL
-        if (this.isCompoundIndex() || ranges.length === 0) {
-            return this.createCollectionWithJsPredicate((record) => {
-                const value = this.getIndexValue(record);
-                return ranges.some(([lower, upper]) => {
-                    const lowerCmp = this.table.compareValues(value, lower);
-                    const upperCmp = this.table.compareValues(value, upper);
-                    const lowerPass = options?.includeLower !== false ? lowerCmp >= 0 : lowerCmp > 0;
-                    const upperPass = options?.includeUpper ? upperCmp <= 0 : upperCmp < 0;
-                    return lowerPass && upperPass;
-                });
-            });
+        if (ranges.length === 0) {
+            // Empty ranges = no matches
+            return this.createCollectionWithCondition({
+                type: 'comparison',
+                column: this.column,
+                op: '=',
+                value: null,
+            }).jsFilter(() => false) as SQLiteCollection<T>;
         }
 
-        const column = this.getColumn();
         const orConditions: SQLiteCondition[] = ranges.map(([lower, upper]) => ({
             type: 'between' as const,
-            column,
+            column: this.column,
             lower,
             upper,
             includeLower: options?.includeLower !== false,
@@ -180,31 +108,21 @@ export class SQLiteWhereClause<T = any> implements StorageWhereClause<T> {
     }
 
     startsWith(prefix: string): StorageCollection<T> {
-        if (this.isCompoundIndex()) {
-            return this.createCollectionWithJsPredicate((record) => String(this.getIndexValue(record) ?? '').startsWith(prefix));
-        }
         // SQLite LIKE pattern: 'prefix%' matches strings starting with prefix
         // Escape special LIKE characters in the prefix
         const escapedPrefix = prefix.replace(/[%_\\]/g, '\\$&');
         return this.createCollectionWithCondition({
             type: 'like',
-            column: this.getColumn(),
+            column: this.column,
             pattern: `${escapedPrefix}%`,
         });
     }
 
     startsWithIgnoreCase(prefix: string): StorageCollection<T> {
-        if (this.isCompoundIndex()) {
-            return this.createCollectionWithJsPredicate((record) =>
-                String(this.getIndexValue(record) ?? '')
-                    .toLowerCase()
-                    .startsWith(prefix.toLowerCase()),
-            );
-        }
         const escapedPrefix = prefix.replace(/[%_\\]/g, '\\$&');
         return this.createCollectionWithCondition({
             type: 'like',
-            column: this.getColumn(),
+            column: this.column,
             pattern: `${escapedPrefix}%`,
             caseInsensitive: true,
         });
@@ -212,19 +130,20 @@ export class SQLiteWhereClause<T = any> implements StorageWhereClause<T> {
 
     startsWithAnyOf(...args: any[]): StorageCollection<T> {
         const prefixes = this.flattenArgs<string>(args);
-        if (this.isCompoundIndex() || prefixes.length === 0) {
-            return this.createCollectionWithJsPredicate((record) => {
-                const value = String(this.getIndexValue(record) ?? '');
-                return prefixes.some((prefix) => value.startsWith(prefix));
-            });
+        if (prefixes.length === 0) {
+            return this.createCollectionWithCondition({
+                type: 'comparison',
+                column: this.column,
+                op: '=',
+                value: null,
+            }).jsFilter(() => false) as SQLiteCollection<T>;
         }
 
-        const column = this.getColumn();
         const orConditions: SQLiteCondition[] = prefixes.map((prefix) => {
             const escapedPrefix = prefix.replace(/[%_\\]/g, '\\$&');
             return {
                 type: 'like' as const,
-                column,
+                column: this.column,
                 pattern: `${escapedPrefix}%`,
             };
         });
@@ -237,20 +156,20 @@ export class SQLiteWhereClause<T = any> implements StorageWhereClause<T> {
 
     startsWithAnyOfIgnoreCase(...args: any[]): StorageCollection<T> {
         const prefixes = this.flattenArgs<string>(args);
-        if (this.isCompoundIndex() || prefixes.length === 0) {
-            const lowerPrefixes = prefixes.map((p) => p.toLowerCase());
-            return this.createCollectionWithJsPredicate((record) => {
-                const value = String(this.getIndexValue(record) ?? '').toLowerCase();
-                return lowerPrefixes.some((prefix) => value.startsWith(prefix));
-            });
+        if (prefixes.length === 0) {
+            return this.createCollectionWithCondition({
+                type: 'comparison',
+                column: this.column,
+                op: '=',
+                value: null,
+            }).jsFilter(() => false) as SQLiteCollection<T>;
         }
 
-        const column = this.getColumn();
         const orConditions: SQLiteCondition[] = prefixes.map((prefix) => {
             const escapedPrefix = prefix.replace(/[%_\\]/g, '\\$&');
             return {
                 type: 'like' as const,
-                column,
+                column: this.column,
                 pattern: `${escapedPrefix}%`,
                 caseInsensitive: true,
             };
@@ -263,12 +182,9 @@ export class SQLiteWhereClause<T = any> implements StorageWhereClause<T> {
     }
 
     equalsIgnoreCase(value: string): StorageCollection<T> {
-        if (this.isCompoundIndex()) {
-            return this.createCollectionWithJsPredicate((record) => String(this.getIndexValue(record) ?? '').toLowerCase() === value.toLowerCase());
-        }
         return this.createCollectionWithCondition({
             type: 'equals',
-            column: this.getColumn(),
+            column: this.column,
             value,
             caseInsensitive: true,
         });
@@ -276,38 +192,18 @@ export class SQLiteWhereClause<T = any> implements StorageWhereClause<T> {
 
     anyOf(...args: any[]): StorageCollection<T> {
         const values = this.flattenArgs<any>(args);
-        if (this.isCompoundIndex()) {
-            // Use native SQL: (col1 = ? AND col2 = ?) OR (col1 = ? AND col2 = ?) OR ...
-            const columns = this.getCompoundColumns();
-            const orConditions: SQLiteCondition[] = values.map((value) => ({
-                type: 'compoundEquals' as const,
-                columns,
-                values: this.getCompoundValues(value),
-            }));
-            return this.createCollectionWithCondition({
-                type: 'or',
-                conditions: orConditions,
-            });
-        }
         return this.createCollectionWithCondition({
             type: 'in',
-            column: this.getColumn(),
+            column: this.column,
             values,
         });
     }
 
     anyOfIgnoreCase(...args: any[]): StorageCollection<T> {
         const values = this.flattenArgs<string>(args);
-        if (this.isCompoundIndex()) {
-            const lowerValues = values.map((v) => v.toLowerCase());
-            return this.createCollectionWithJsPredicate((record) => {
-                const value = String(this.getIndexValue(record) ?? '').toLowerCase();
-                return lowerValues.includes(value);
-            });
-        }
         return this.createCollectionWithCondition({
             type: 'in',
-            column: this.getColumn(),
+            column: this.column,
             values,
             caseInsensitive: true,
         });
@@ -315,25 +211,17 @@ export class SQLiteWhereClause<T = any> implements StorageWhereClause<T> {
 
     noneOf(...args: any[]): StorageCollection<T> {
         const values = this.flattenArgs<any>(args);
-        if (this.isCompoundIndex()) {
-            return this.createCollectionWithJsPredicate((record) =>
-                values.every((candidate) => this.table.compareValues(this.getIndexValue(record), candidate) !== 0),
-            );
-        }
         return this.createCollectionWithCondition({
             type: 'notIn',
-            column: this.getColumn(),
+            column: this.column,
             values,
         });
     }
 
     notEqual(value: any): StorageCollection<T> {
-        if (this.isCompoundIndex()) {
-            return this.createCollectionWithJsPredicate((record) => this.table.compareValues(this.getIndexValue(record), value) !== 0);
-        }
         return this.createCollectionWithCondition({
             type: 'comparison',
-            column: this.getColumn(),
+            column: this.column,
             op: '!=',
             value,
         });

package/src/storage/sqlite/helpers.ts

@@ -59,12 +59,6 @@ const buildCondition = (condition: SQLiteCondition): BuiltCondition => {
         return { clause: `(${subClauses.join(' OR ')})`, parameters: subParams };
     }
 
-    // Handle compound equals (multiple columns ANDed together)
-    if (condition.type === 'compoundEquals') {
-        const clauses = condition.columns.map((col) => `${quoteIdentifier(col)} = ?`);
-        return { clause: `(${clauses.join(' AND ')})`, parameters: condition.values };
-    }
-
     const col = quoteIdentifier(condition.column);
 
     switch (condition.type) {

package/src/storage/sqlite/types.ts

@@ -69,12 +69,6 @@ export interface SQLiteConditionOr {
     conditions: SQLiteCondition[];
 }
 
-export interface SQLiteConditionCompoundEquals {
-    type: 'compoundEquals';
-    columns: string[];
-    values: unknown[];
-}
-
 export type SQLiteCondition =
     | SQLiteConditionEquals
     | SQLiteConditionComparison
@@ -82,8 +76,7 @@ export type SQLiteCondition =
     | SQLiteConditionIn
     | SQLiteConditionNotIn
     | SQLiteConditionLike
-    | SQLiteConditionOr
-    | SQLiteConditionCompoundEquals;
+    | SQLiteConditionOr;
 
 export interface SQLiteCollectionState<T> {
     /** SQL-expressible WHERE conditions (ANDed together) */

package/src/storage/types.ts

@@ -77,7 +77,6 @@ export type AddItem<T> = Omit<T, '_localId'> & { _localId?: string };
 export interface StorageTable<T = any> {
     readonly name: string;
     readonly schema: unknown;
-    readonly hook: unknown;
     add(item: AddItem<T>): Promise<string>;
     put(item: T): Promise<string>;
     update(key: string, changes: Partial<T>): Promise<number>;
@@ -91,12 +90,11 @@ export interface StorageTable<T = any> {
     bulkGet(keys: string[]): Promise<Array<T | undefined>>;
     bulkUpdate(keysAndChanges: Array<{ key: string; changes: Partial<T> }>): Promise<number>;
     bulkDelete(keys: string[]): Promise<void>;
-    where(index: string | string[]): StorageWhereClause<T>;
+    where(index: string): StorageWhereClause<T>;
     orderBy(index: string | string[]): StorageCollection<T>;
     reverse(): StorageCollection<T>;
     offset(offset: number): StorageCollection<T>;
     limit(count: number): StorageCollection<T>;
-    mapToClass(ctor: new (...args: any[]) => any): StorageTable<T>;
     each(callback: (item: T) => void | Promise<void>): Promise<void>;
     jsFilter(predicate: (item: T) => boolean): StorageCollection<T>;
     // The "raw" property exposes the underlying storage operations without Dync sync logic.