@anfenn/dync 1.0.3 → 1.0.4

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-BGwvMH8f.cjs';
-import { c as StorageAdapter } from '../dexie-Bv-fV10P.cjs';
+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 '../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-CkYsQYyn.js';
-import { c as StorageAdapter } from '../dexie-DJFApKsM.js';
+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 '../types-CSbIAfu2.js';
 import 'dexie';
 

package/dist/react/index.js

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

package/package.json

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

package/src/core/tableEnhancers.ts

@@ -1,6 +1,6 @@
 import { createLocalId } from '../helpers';
 import { SyncAction, type MutationEvent, type SyncedRecord } from '../types';
-import type { StorageTable } from '../storage/types';
+import type { AddItem, StorageTable } from '../storage/types';
 import { DYNC_STATE_TABLE, type StateHelpers } from './StateManager';
 import type { WithTransaction } from './types';
 export type EmitMutation = (event: MutationEvent) => void;
@@ -20,8 +20,8 @@ export function wrapWithMutationEmitter<T>(table: StorageTable<T>, tableName: st
     const rawBulkDelete = table.raw.bulkDelete;
     const rawClear = table.raw.clear;
 
-    table.add = async (item: T) => {
-        const result = await rawAdd(item);
+    table.add = async (item: AddItem<T>) => {
+        const result = await rawAdd(item as T);
         emitMutation({ type: 'add', tableName, keys: [result] });
         return result;
     };
@@ -32,7 +32,7 @@ export function wrapWithMutationEmitter<T>(table: StorageTable<T>, tableName: st
         return result;
     };
 
-    table.update = async (key: unknown, changes: Partial<T>) => {
+    table.update = async (key: string, changes: Partial<T>) => {
         const result = await rawUpdate(key, changes);
         if (result > 0) {
             emitMutation({ type: 'update', tableName, keys: [key] });
@@ -40,13 +40,13 @@ export function wrapWithMutationEmitter<T>(table: StorageTable<T>, tableName: st
         return result;
     };
 
-    table.delete = async (key: unknown) => {
+    table.delete = async (key: string) => {
         await rawDelete(key);
         emitMutation({ type: 'delete', tableName, keys: [key] });
     };
 
-    table.bulkAdd = async (items: T[]) => {
-        const result = await rawBulkAdd(items);
+    table.bulkAdd = async (items: AddItem<T>[]) => {
+        const result = await rawBulkAdd(items as T[]);
         if (items.length > 0) {
             emitMutation({ type: 'add', tableName });
         }
@@ -61,7 +61,7 @@ export function wrapWithMutationEmitter<T>(table: StorageTable<T>, tableName: st
         return result;
     };
 
-    table.bulkUpdate = async (keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>) => {
+    table.bulkUpdate = async (keysAndChanges: Array<{ key: string; changes: Partial<T> }>) => {
         const result = await rawBulkUpdate(keysAndChanges);
         if (result > 0) {
             emitMutation({ type: 'update', tableName, keys: keysAndChanges.map((kc) => kc.key) });
@@ -69,7 +69,7 @@ export function wrapWithMutationEmitter<T>(table: StorageTable<T>, tableName: st
         return result;
     };
 
-    table.bulkDelete = async (keys: unknown[]) => {
+    table.bulkDelete = async (keys: string[]) => {
         await rawBulkDelete(keys);
         if (keys.length > 0) {
             emitMutation({ type: 'delete', tableName });
@@ -134,7 +134,7 @@ export function enhanceSyncTable<T>({ table, tableName, withTransaction, state,
             updated_at: new Date().toISOString(),
         };
 
-        let result: any;
+        let result!: string;
         await withTransaction('rw', [tableName, DYNC_STATE_TABLE], async () => {
             result = await rawAdd(syncedItem);
 
@@ -162,7 +162,7 @@ export function enhanceSyncTable<T>({ table, tableName, withTransaction, state,
             updated_at: new Date().toISOString(),
         };
 
-        let result: any;
+        let result!: string;
         let isUpdate = false;
         let existingRecord: any;
 
@@ -248,8 +248,8 @@ export function enhanceSyncTable<T>({ table, tableName, withTransaction, state,
         }
     };
 
-    const wrappedBulkAdd = async (items: any[]) => {
-        if (items.length === 0) return;
+    const wrappedBulkAdd = async (items: any[]): Promise<string[]> => {
+        if (items.length === 0) return [];
 
         const now = new Date().toISOString();
         const syncedItems = items.map((item) => {
@@ -261,7 +261,7 @@ export function enhanceSyncTable<T>({ table, tableName, withTransaction, state,
             };
         });
 
-        let result: any;
+        let result!: string[];
         await withTransaction('rw', [tableName, DYNC_STATE_TABLE], async () => {
             result = await rawBulkAdd(syncedItems);
 
@@ -281,8 +281,8 @@ export function enhanceSyncTable<T>({ table, tableName, withTransaction, state,
         return result;
     };
 
-    const wrappedBulkPut = async (items: any[]) => {
-        if (items.length === 0) return;
+    const wrappedBulkPut = async (items: any[]): Promise<string[]> => {
+        if (items.length === 0) return [];
 
         const now = new Date().toISOString();
         const syncedItems = items.map((item) => {
@@ -295,7 +295,7 @@ export function enhanceSyncTable<T>({ table, tableName, withTransaction, state,
         });
         const localIds = syncedItems.map((i) => i._localId);
 
-        let result: any;
+        let result!: string[];
         await withTransaction('rw', [tableName, DYNC_STATE_TABLE], async (tables) => {
             const txTable = tables[tableName]!;
 

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;