@anfenn/dync 1.0.3 → 1.0.5

package/src/helpers.ts

@@ -53,7 +53,7 @@ export function orderFor(a: SyncAction): number {
             return 1;
         case SyncAction.Update:
             return 2;
-        case SyncAction.Remove:
+        case SyncAction.Delete:
             return 3;
     }
 }

package/src/storage/dexie/DexieAdapter.ts

@@ -3,7 +3,7 @@ import type { StorageAdapter, StorageTable, StorageTransactionContext, Transacti
 import type { StorageSchemaDefinitionOptions } from '../sqlite/types';
 import type { TableSchemaDefinition } from '../sqlite/schema';
 import { DexieQueryContext } from './DexieQueryContext';
-import { DexieStorageTable } from './DexieStorageTable';
+import { DexieTable } from './DexieTable';
 
 export class DexieAdapter implements StorageAdapter {
     readonly type = 'DexieAdapter';
@@ -55,7 +55,7 @@ export class DexieAdapter implements StorageAdapter {
     table<T = any>(name: string): StorageTable<T> {
         if (!this.tableCache.has(name)) {
             const table = this.db.table<T>(name);
-            this.tableCache.set(name, new DexieStorageTable(table));
+            this.tableCache.set(name, new DexieTable(table));
         }
         return this.tableCache.get(name)! as StorageTable<T>;
     }

package/src/storage/dexie/{DexieStorageCollection.ts → DexieCollection.ts}

@@ -1,12 +1,12 @@
-import type { Collection as DexieCollection } from 'dexie';
+import type { Collection } from 'dexie';
 import type { StorageCollection, StorageWhereClause } from '../types';
 import { normalizeIndexName } from './helpers';
-import { DexieStorageWhereClause } from './DexieStorageWhereClause';
+import { DexieWhereClause } from './DexieWhereClause';
 
-export class DexieStorageCollection<T = any> implements StorageCollection<T> {
-    private readonly collection: DexieCollection<T, any, T>;
+export class DexieCollection<T = any> implements StorageCollection<T> {
+    private readonly collection: Collection<T, any, T>;
 
-    constructor(collection: DexieCollection<T, any, T>) {
+    constructor(collection: Collection<T, any, T>) {
         this.collection = collection;
     }
 
@@ -79,31 +79,31 @@ export class DexieStorageCollection<T = any> implements StorageCollection<T> {
     }
 
     distinct(): StorageCollection<T> {
-        return new DexieStorageCollection(this.collection.distinct());
+        return new DexieCollection(this.collection.distinct());
     }
 
     jsFilter(predicate: (item: T) => boolean): StorageCollection<T> {
-        return new DexieStorageCollection(this.collection.filter(predicate));
+        return new DexieCollection(this.collection.filter(predicate));
     }
 
     or(index: string): StorageWhereClause<T> {
-        return new DexieStorageWhereClause(this.collection.or(normalizeIndexName(index)));
+        return new DexieWhereClause(this.collection.or(normalizeIndexName(index)));
     }
 
     clone(props?: Record<string, unknown>): StorageCollection<T> {
-        return new DexieStorageCollection(this.collection.clone(props));
+        return new DexieCollection(this.collection.clone(props));
     }
 
     reverse(): StorageCollection<T> {
-        return new DexieStorageCollection(this.collection.reverse());
+        return new DexieCollection(this.collection.reverse());
     }
 
     offset(offset: number): StorageCollection<T> {
-        return new DexieStorageCollection(this.collection.offset(offset));
+        return new DexieCollection(this.collection.offset(offset));
     }
 
     limit(count: number): StorageCollection<T> {
-        return new DexieStorageCollection(this.collection.limit(count));
+        return new DexieCollection(this.collection.limit(count));
     }
 
     toCollection(): StorageCollection<T> {

package/src/storage/dexie/DexieTable.ts

@@ -0,0 +1,123 @@
+import type { Table } from 'dexie';
+import type { AddItem, StorageCollection, StorageTable, StorageWhereClause } from '../types';
+import { normalizeIndexName } from './helpers';
+import { DexieCollection } from './DexieCollection';
+import { DexieWhereClause } from './DexieWhereClause';
+
+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>,
+        update: (key: string, changes: Partial<T>) => this.table.update(key as any, changes as any),
+        delete: (key: string) => this.table.delete(key as any),
+        get: (key: string) => this.table.get(key as any),
+        bulkAdd: (items: T[]): Promise<string[]> => this.table.bulkAdd(items, { allKeys: true }) as Promise<string[]>,
+        bulkPut: (items: T[]): Promise<string[]> => this.table.bulkPut(items, { allKeys: true }) as Promise<string[]>,
+        bulkUpdate: (keysAndChanges: Array<{ key: string; changes: Partial<T> }>) => this.table.bulkUpdate(keysAndChanges as any),
+        bulkDelete: (keys: string[]) => this.table.bulkDelete(keys as any),
+        clear: () => this.table.clear(),
+    });
+
+    private readonly table: Table<T, any, T>;
+
+    constructor(table: Table<T, any, T>) {
+        this.table = table;
+        this.name = table.name;
+        this.schema = table.schema;
+        this.primaryKey = table.schema?.primKey;
+        this.hook = table.hook;
+    }
+
+    add(item: AddItem<T>): Promise<string> {
+        return this.table.add(item as T);
+    }
+
+    put(item: T): Promise<string> {
+        return this.table.put(item);
+    }
+
+    update(key: string, changes: Partial<T>): Promise<number> {
+        return this.table.update(key as any, changes as any);
+    }
+
+    delete(key: string): Promise<void> {
+        return this.table.delete(key as any).then(() => undefined);
+    }
+
+    clear(): Promise<void> {
+        return this.table.clear();
+    }
+
+    get(key: string): Promise<T | undefined> {
+        return this.table.get(key as any);
+    }
+
+    toArray(): Promise<T[]> {
+        return this.table.toArray();
+    }
+
+    count(): Promise<number> {
+        return this.table.count();
+    }
+
+    bulkAdd(items: AddItem<T>[]): Promise<string[]> {
+        return this.table.bulkAdd(items as T[], { allKeys: true }) as Promise<string[]>;
+    }
+
+    bulkPut(items: T[]): Promise<string[]> {
+        return this.table.bulkPut(items, { allKeys: true }) as Promise<string[]>;
+    }
+
+    bulkGet(keys: string[]): Promise<Array<T | undefined>> {
+        return this.table.bulkGet(keys as any);
+    }
+
+    bulkUpdate(keysAndChanges: Array<{ key: string; changes: Partial<T> }>): Promise<number> {
+        return this.table.bulkUpdate(keysAndChanges as any);
+    }
+
+    bulkDelete(keys: string[]): Promise<void> {
+        return this.table.bulkDelete(keys as any);
+    }
+
+    where(index: string | string[]): StorageWhereClause<T> {
+        return new DexieWhereClause(this.table.where(normalizeIndexName(index)));
+    }
+
+    orderBy(index: string | string[]): StorageCollection<T> {
+        return new DexieCollection(this.table.orderBy(normalizeIndexName(index)));
+    }
+
+    reverse(): StorageCollection<T> {
+        return new DexieCollection(this.table.reverse());
+    }
+
+    offset(offset: number): StorageCollection<T> {
+        return new DexieCollection(this.table.offset(offset));
+    }
+
+    limit(count: number): StorageCollection<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) => {
+            tasks.push(callback(item));
+        });
+        await Promise.all(tasks.map((task) => (task ? Promise.resolve(task) : Promise.resolve())));
+    }
+
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T> {
+        return new DexieCollection(this.table.filter(predicate));
+    }
+}

package/src/storage/dexie/{DexieStorageWhereClause.ts → DexieWhereClause.ts}

@@ -1,36 +1,36 @@
-import type { WhereClause as DexieWhereClause } from 'dexie';
+import type { WhereClause } from 'dexie';
 import type { StorageCollection, StorageWhereClause } from '../types';
-import { DexieStorageCollection } from './DexieStorageCollection';
+import { DexieCollection } from './DexieCollection';
 
-export class DexieStorageWhereClause<T = any> implements StorageWhereClause<T> {
-    private readonly clause: DexieWhereClause<T, any, T>;
+export class DexieWhereClause<T = any> implements StorageWhereClause<T> {
+    private readonly clause: WhereClause<T, any, T>;
 
-    constructor(clause: DexieWhereClause<T, any, T>) {
+    constructor(clause: WhereClause<T, any, T>) {
         this.clause = clause;
     }
 
     equals(value: any): StorageCollection<T> {
-        return new DexieStorageCollection(this.clause.equals(value));
+        return new DexieCollection(this.clause.equals(value));
     }
 
     above(value: any): StorageCollection<T> {
-        return new DexieStorageCollection(this.clause.above(value));
+        return new DexieCollection(this.clause.above(value));
     }
 
     aboveOrEqual(value: any): StorageCollection<T> {
-        return new DexieStorageCollection(this.clause.aboveOrEqual(value));
+        return new DexieCollection(this.clause.aboveOrEqual(value));
     }
 
     below(value: any): StorageCollection<T> {
-        return new DexieStorageCollection(this.clause.below(value));
+        return new DexieCollection(this.clause.below(value));
     }
 
     belowOrEqual(value: any): StorageCollection<T> {
-        return new DexieStorageCollection(this.clause.belowOrEqual(value));
+        return new DexieCollection(this.clause.belowOrEqual(value));
     }
 
     between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): StorageCollection<T> {
-        return new DexieStorageCollection(this.clause.between(lower, upper, includeLower, includeUpper));
+        return new DexieCollection(this.clause.between(lower, upper, includeLower, includeUpper));
     }
 
     inAnyRange(ranges: Array<[any, any]>, options?: { includeLower?: boolean; includeUpper?: boolean }): StorageCollection<T> {
@@ -40,58 +40,58 @@ export class DexieStorageWhereClause<T = any> implements StorageWhereClause<T> {
                   includeUppers: options.includeUpper,
               }
             : undefined;
-        return new DexieStorageCollection(this.clause.inAnyRange(ranges as any, normalizedOptions));
+        return new DexieCollection(this.clause.inAnyRange(ranges as any, normalizedOptions));
     }
 
     startsWith(prefix: string): StorageCollection<T> {
-        return new DexieStorageCollection(this.clause.startsWith(prefix));
+        return new DexieCollection(this.clause.startsWith(prefix));
     }
 
     startsWithIgnoreCase(prefix: string): StorageCollection<T> {
-        return new DexieStorageCollection(this.clause.startsWithIgnoreCase(prefix));
+        return new DexieCollection(this.clause.startsWithIgnoreCase(prefix));
     }
 
     startsWithAnyOf(...prefixes: string[]): StorageCollection<T>;
     startsWithAnyOf(prefixes: string[]): StorageCollection<T>;
     startsWithAnyOf(...args: any[]): StorageCollection<T> {
         const values = this.flattenArgs<string>(args);
-        return new DexieStorageCollection(this.clause.startsWithAnyOf(...values));
+        return new DexieCollection(this.clause.startsWithAnyOf(...values));
     }
 
     startsWithAnyOfIgnoreCase(...prefixes: string[]): StorageCollection<T>;
     startsWithAnyOfIgnoreCase(prefixes: string[]): StorageCollection<T>;
     startsWithAnyOfIgnoreCase(...args: any[]): StorageCollection<T> {
         const values = this.flattenArgs<string>(args);
-        return new DexieStorageCollection(this.clause.startsWithAnyOfIgnoreCase(...values));
+        return new DexieCollection(this.clause.startsWithAnyOfIgnoreCase(...values));
     }
 
     equalsIgnoreCase(value: string): StorageCollection<T> {
-        return new DexieStorageCollection(this.clause.equalsIgnoreCase(value));
+        return new DexieCollection(this.clause.equalsIgnoreCase(value));
     }
 
     anyOf(...values: any[]): StorageCollection<T>;
     anyOf(values: any[]): StorageCollection<T>;
     anyOf(...args: any[]): StorageCollection<T> {
         const values = this.flattenArgs<any>(args);
-        return new DexieStorageCollection(this.clause.anyOf(...values));
+        return new DexieCollection(this.clause.anyOf(...values));
     }
 
     anyOfIgnoreCase(...values: string[]): StorageCollection<T>;
     anyOfIgnoreCase(values: string[]): StorageCollection<T>;
     anyOfIgnoreCase(...args: any[]): StorageCollection<T> {
         const values = this.flattenArgs<string>(args);
-        return new DexieStorageCollection(this.clause.anyOfIgnoreCase(...values));
+        return new DexieCollection(this.clause.anyOfIgnoreCase(...values));
     }
 
     noneOf(...values: any[]): StorageCollection<T>;
     noneOf(values: any[]): StorageCollection<T>;
     noneOf(...args: any[]): StorageCollection<T> {
         const values = this.flattenArgs<any>(args);
-        return new DexieStorageCollection(this.clause.noneOf(values as any));
+        return new DexieCollection(this.clause.noneOf(values as any));
     }
 
     notEqual(value: any): StorageCollection<T> {
-        return new DexieStorageCollection(this.clause.notEqual(value));
+        return new DexieCollection(this.clause.notEqual(value));
     }
 
     private flattenArgs<TValue>(args: any[]): TValue[] {

package/src/storage/dexie/index.ts

@@ -1,7 +1,7 @@
 // Export all classes
 export { DexieAdapter } from './DexieAdapter';
 export { DexieQueryContext } from './DexieQueryContext';
-export { DexieStorageCollection } from './DexieStorageCollection';
-export { DexieStorageWhereClause } from './DexieStorageWhereClause';
-export { DexieStorageTable } from './DexieStorageTable';
+export { DexieCollection } from './DexieCollection';
+export { DexieWhereClause } from './DexieWhereClause';
+export { DexieTable } from './DexieTable';
 export { normalizeIndexName } from './helpers';

package/src/storage/memory/MemoryTable.ts

@@ -1,4 +1,4 @@
-import type { StorageCollection, StorageTable, StorageWhereClause } from '../types';
+import type { AddItem, StorageCollection, StorageTable, StorageWhereClause } from '../types';
 import { LOCAL_PK } from '../../types';
 import { createLocalId } from '../../helpers';
 import type { MemoryCollectionState, MemoryRecord } from './types';
@@ -12,15 +12,15 @@ export class MemoryTable<T extends MemoryRecord = MemoryRecord> implements Stora
     readonly primaryKey: unknown = LOCAL_PK;
     readonly hook: unknown = Object.freeze({});
     readonly raw: {
-        add: (item: T) => Promise<unknown>;
-        put: (item: T) => Promise<unknown>;
-        update: (key: unknown, changes: Partial<T>) => Promise<number>;
-        delete: (key: unknown) => Promise<void>;
-        get: (key: unknown) => Promise<T | undefined>;
-        bulkAdd: (items: T[]) => Promise<unknown>;
-        bulkPut: (items: T[]) => Promise<unknown>;
-        bulkUpdate: (keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>) => Promise<number>;
-        bulkDelete: (keys: Array<unknown>) => Promise<void>;
+        add: (item: T) => Promise<string>;
+        put: (item: T) => Promise<string>;
+        update: (key: string, changes: Partial<T>) => Promise<number>;
+        delete: (key: string) => Promise<void>;
+        get: (key: string) => Promise<T | undefined>;
+        bulkAdd: (items: T[]) => Promise<string[]>;
+        bulkPut: (items: T[]) => Promise<string[]>;
+        bulkUpdate: (keysAndChanges: Array<{ key: string; changes: Partial<T> }>) => Promise<number>;
+        bulkDelete: (keys: string[]) => Promise<void>;
         clear: () => Promise<void>;
     };
     private readonly records = new Map<string, T>();
@@ -30,32 +30,32 @@ export class MemoryTable<T extends MemoryRecord = MemoryRecord> implements Stora
         this.raw = {
             add: async (item: T) => this.baseAdd(item),
             put: async (item: T) => this.basePut(item),
-            update: async (key: unknown, changes: Partial<T>) => this.baseUpdate(key, changes),
-            delete: async (key: unknown) => {
+            update: async (key: string, changes: Partial<T>) => this.baseUpdate(key, changes),
+            delete: async (key: string) => {
                 this.baseDelete(key);
             },
-            get: async (key: unknown) => this.baseGet(key),
+            get: async (key: string) => this.baseGet(key),
             bulkAdd: async (items: T[]) => this.baseBulkAdd(items),
             bulkPut: async (items: T[]) => this.baseBulkPut(items),
-            bulkUpdate: async (keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>) => this.baseBulkUpdate(keysAndChanges),
-            bulkDelete: async (keys: Array<unknown>) => this.baseBulkDelete(keys),
+            bulkUpdate: async (keysAndChanges: Array<{ key: string; changes: Partial<T> }>) => this.baseBulkUpdate(keysAndChanges),
+            bulkDelete: async (keys: string[]) => this.baseBulkDelete(keys),
             clear: async () => this.baseClear(),
         };
     }
 
-    async add(item: T): Promise<unknown> {
-        return this.baseAdd(item);
+    async add(item: AddItem<T>): Promise<string> {
+        return this.baseAdd(item as T);
     }
 
-    async put(item: T): Promise<unknown> {
+    async put(item: T): Promise<string> {
         return this.basePut(item);
     }
 
-    async update(key: unknown, changes: Partial<T>): Promise<number> {
+    async update(key: string, changes: Partial<T>): Promise<number> {
         return this.baseUpdate(key, changes);
     }
 
-    async delete(key: unknown): Promise<void> {
+    async delete(key: string): Promise<void> {
         this.baseDelete(key);
     }
 
@@ -67,7 +67,7 @@ export class MemoryTable<T extends MemoryRecord = MemoryRecord> implements Stora
         this.records.clear();
     }
 
-    async get(key: unknown): Promise<T | undefined> {
+    async get(key: string): Promise<T | undefined> {
         const stored = this.baseGet(key);
         return stored ? this.cloneRecord(stored) : undefined;
     }
@@ -80,41 +80,41 @@ export class MemoryTable<T extends MemoryRecord = MemoryRecord> implements Stora
         return this.records.size;
     }
 
-    async bulkAdd(items: T[]): Promise<unknown> {
-        return this.baseBulkAdd(items);
+    async bulkAdd(items: AddItem<T>[]): Promise<string[]> {
+        return this.baseBulkAdd(items as T[]);
     }
 
-    private baseBulkAdd(items: T[]): unknown {
-        let lastKey: unknown = undefined;
+    private baseBulkAdd(items: T[]): string[] {
+        const keys: string[] = [];
         for (let index = 0; index < items.length; index += 1) {
             const item = items[index]!;
-            lastKey = this.baseAdd(item);
+            keys.push(this.baseAdd(item));
         }
-        return lastKey;
+        return keys;
     }
 
-    async bulkPut(items: T[]): Promise<unknown> {
+    async bulkPut(items: T[]): Promise<string[]> {
         return this.baseBulkPut(items);
     }
 
-    private baseBulkPut(items: T[]): unknown {
-        let lastKey: unknown = undefined;
+    private baseBulkPut(items: T[]): string[] {
+        const keys: string[] = [];
         for (let index = 0; index < items.length; index += 1) {
             const item = items[index]!;
-            lastKey = this.basePut(item);
+            keys.push(this.basePut(item));
         }
-        return lastKey;
+        return keys;
     }
 
-    async bulkGet(keys: Array<unknown>): Promise<Array<T | undefined>> {
+    async bulkGet(keys: string[]): Promise<Array<T | undefined>> {
         return Promise.all(keys.map((key) => this.get(key)));
     }
 
-    async bulkUpdate(keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>): Promise<number> {
+    async bulkUpdate(keysAndChanges: Array<{ key: string; changes: Partial<T> }>): Promise<number> {
         return this.baseBulkUpdate(keysAndChanges);
     }
 
-    private baseBulkUpdate(keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>): number {
+    private baseBulkUpdate(keysAndChanges: Array<{ key: string; changes: Partial<T> }>): number {
         let updatedCount = 0;
         for (const { key, changes } of keysAndChanges) {
             const result = this.baseUpdate(key, changes);
@@ -123,11 +123,11 @@ export class MemoryTable<T extends MemoryRecord = MemoryRecord> implements Stora
         return updatedCount;
     }
 
-    async bulkDelete(keys: Array<unknown>): Promise<void> {
+    async bulkDelete(keys: string[]): Promise<void> {
         this.baseBulkDelete(keys);
     }
 
-    private baseBulkDelete(keys: Array<unknown>): void {
+    private baseBulkDelete(keys: string[]): void {
         for (const key of keys) {
             this.baseDelete(key);
         }
@@ -277,7 +277,7 @@ export class MemoryTable<T extends MemoryRecord = MemoryRecord> implements Stora
         return primaryKey;
     }
 
-    private baseUpdate(key: unknown, changes: Partial<T>): number {
+    private baseUpdate(key: string, changes: Partial<T>): number {
         const primaryKey = this.resolveKey(key);
         if (!primaryKey) {
             return 0;
@@ -291,14 +291,14 @@ export class MemoryTable<T extends MemoryRecord = MemoryRecord> implements Stora
         return 1;
     }
 
-    private baseDelete(key: unknown): void {
+    private baseDelete(key: string): void {
         const primaryKey = this.resolveKey(key);
         if (primaryKey) {
             this.records.delete(primaryKey);
         }
     }
 
-    private baseGet(key: unknown): T | undefined {
+    private baseGet(key: string): T | undefined {
         const primaryKey = this.resolveKey(key);
         if (!primaryKey) {
             return undefined;