@anfenn/dync 1.0.3 → 1.0.5

package/src/storage/sqlite/SQLiteTable.ts

@@ -1,4 +1,4 @@
-import type { StorageTable, StorageWhereClause, StorageCollection } from '../types';
+import type { AddItem, StorageTable, StorageWhereClause, StorageCollection } from '../types';
 import { LOCAL_PK } from '../../types';
 import type { SQLiteTableSchemaMetadata, SQLiteIterateEntriesOptions, SQLiteOrderByOptions, SQLiteCollectionState, TableEntry } from './types';
 import { SQLiteAdapter } from './SQLiteAdapter';
@@ -11,15 +11,15 @@ export class SQLiteTable<T = any> implements StorageTable<T> {
     readonly schema: SQLiteTableSchemaMetadata;
     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>;
     };
 
@@ -54,19 +54,19 @@ export class SQLiteTable<T = any> implements StorageTable<T> {
         });
     }
 
-    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> {
         await this.baseDelete(key);
     }
 
@@ -78,7 +78,7 @@ export class SQLiteTable<T = any> implements StorageTable<T> {
         await this.adapter.execute(`DELETE FROM ${quoteIdentifier(this.name)}`);
     }
 
-    async get(key: unknown): Promise<T | undefined> {
+    async get(key: string): Promise<T | undefined> {
         if (!key || typeof key !== 'string') {
             return undefined;
         }
@@ -96,12 +96,12 @@ export class SQLiteTable<T = any> implements StorageTable<T> {
         return Number(rows[0]?.count ?? 0);
     }
 
-    async bulkAdd(items: T[]): Promise<unknown> {
-        return this.baseBulkAdd(items);
+    async bulkAdd(items: AddItem<T>[]): Promise<string[]> {
+        return this.baseBulkAdd(items as T[]);
     }
 
-    private async baseBulkAdd(items: T[]): Promise<unknown> {
-        if (!items.length) return undefined;
+    private async baseBulkAdd(items: T[]): Promise<string[]> {
+        if (!items.length) return [];
 
         const columns = this.columnNames;
         const columnCount = columns.length;
@@ -109,7 +109,7 @@ export class SQLiteTable<T = any> implements StorageTable<T> {
         const maxParamsPerBatch = 500;
         const batchSize = Math.max(1, Math.floor(maxParamsPerBatch / columnCount));
 
-        let lastKey: unknown = undefined;
+        const allKeys: string[] = [];
 
         for (let i = 0; i < items.length; i += batchSize) {
             const batch = items.slice(i, i + batchSize);
@@ -121,32 +121,31 @@ export class SQLiteTable<T = any> implements StorageTable<T> {
 
             for (const record of records) {
                 values.push(...this.extractColumnValues(record));
+                allKeys.push((record as any)[LOCAL_PK]);
             }
 
             await this.adapter.run(
                 `INSERT INTO ${quoteIdentifier(this.name)} (${columns.map((c) => quoteIdentifier(c)).join(', ')}) VALUES ${placeholders}`,
                 values,
             );
-
-            lastKey = (records[records.length - 1] as any)[LOCAL_PK];
         }
 
-        return lastKey;
+        return allKeys;
     }
 
-    async bulkPut(items: T[]): Promise<unknown> {
+    async bulkPut(items: T[]): Promise<string[]> {
         return this.baseBulkPut(items);
     }
 
-    private async baseBulkPut(items: T[]): Promise<unknown> {
-        if (!items.length) return undefined;
+    private async baseBulkPut(items: T[]): Promise<string[]> {
+        if (!items.length) return [];
 
         const columns = this.columnNames;
         const columnCount = columns.length;
         const maxParamsPerBatch = 500;
         const batchSize = Math.max(1, Math.floor(maxParamsPerBatch / columnCount));
 
-        let lastKey: unknown = undefined;
+        const allKeys: string[] = [];
 
         for (let i = 0; i < items.length; i += batchSize) {
             const batch = items.slice(i, i + batchSize);
@@ -158,20 +157,19 @@ export class SQLiteTable<T = any> implements StorageTable<T> {
 
             for (const record of records) {
                 values.push(...this.extractColumnValues(record));
+                allKeys.push((record as any)[LOCAL_PK]);
             }
 
             await this.adapter.run(
                 `INSERT OR REPLACE INTO ${quoteIdentifier(this.name)} (${columns.map((c) => quoteIdentifier(c)).join(', ')}) VALUES ${placeholders}`,
                 values,
             );
-
-            lastKey = (records[records.length - 1] as any)[LOCAL_PK];
         }
 
-        return lastKey;
+        return allKeys;
     }
 
-    async bulkGet(keys: Array<unknown>): Promise<Array<T | undefined>> {
+    async bulkGet(keys: string[]): Promise<Array<T | undefined>> {
         if (!keys.length) return [];
 
         // Use IN clause for bulk lookup
@@ -197,11 +195,11 @@ export class SQLiteTable<T = any> implements StorageTable<T> {
         return keys.map((key) => (key && typeof key === 'string' ? recordMap.get(key) : undefined));
     }
 
-    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 async baseBulkUpdate(keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>): Promise<number> {
+    private async baseBulkUpdate(keysAndChanges: Array<{ key: string; changes: Partial<T> }>): Promise<number> {
         if (!keysAndChanges.length) return 0;
 
         let updatedCount = 0;
@@ -212,11 +210,11 @@ export class SQLiteTable<T = any> implements StorageTable<T> {
         return updatedCount;
     }
 
-    async bulkDelete(keys: Array<unknown>): Promise<void> {
+    async bulkDelete(keys: string[]): Promise<void> {
         await this.baseBulkDelete(keys);
     }
 
-    private async baseBulkDelete(keys: Array<unknown>): Promise<void> {
+    private async baseBulkDelete(keys: string[]): Promise<void> {
         if (!keys.length) return;
 
         const validKeys = keys.filter((k) => k && typeof k === 'string');

package/src/storage/sqlite/drivers/WaSqliteDriver.ts

@@ -476,9 +476,9 @@ export class WaSqliteDriver implements SQLiteDatabaseDriver {
 
     /**
      * Delete the database.
-     * This will close the database if open and remove all persisted data.
+     * This will close the database if open and delete all persisted data.
      * For IndexedDB-based VFS, this deletes the IndexedDB database.
-     * For OPFS-based VFS, this removes the files from OPFS.
+     * For OPFS-based VFS, this deletes the files from OPFS.
      */
     async delete(): Promise<void> {
         // Close if open
@@ -499,12 +499,12 @@ export class WaSqliteDriver implements SQLiteDatabaseDriver {
                 };
             });
         } else {
-            // For OPFS-based VFS, remove the directory
+            // For OPFS-based VFS, delete the directory
             const dbPath = this.buildDatabasePath();
             const root = await navigator.storage.getDirectory();
 
             try {
-                // Try to remove the file/directory
+                // Try to delete the file/directory
                 const pathParts = dbPath.split('/').filter(Boolean);
                 let current = root;
 
@@ -513,11 +513,11 @@ export class WaSqliteDriver implements SQLiteDatabaseDriver {
                     current = await current.getDirectoryHandle(pathParts[i]!);
                 }
 
-                // Remove the database file
+                // Delete the database file
                 const filename = pathParts[pathParts.length - 1]!;
                 await current.removeEntry(filename, { recursive: true });
 
-                // Also try to remove associated journal/wal files
+                // Also try to delete associated journal/wal files
                 const associatedFiles = [`${filename}-journal`, `${filename}-wal`, `${filename}-shm`];
                 for (const file of associatedFiles) {
                     try {

package/src/storage/types.ts

@@ -71,23 +71,26 @@ export interface StorageWhereClause<T = any> {
     notEqual(value: any): StorageCollection<T>;
 }
 
+// Item type for add operations - _localId is optional since Dync auto-generates it
+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: T): Promise<unknown>;
-    put(item: T): Promise<unknown>;
-    update(key: unknown, changes: Partial<T>): Promise<number>;
-    delete(key: unknown): Promise<void>;
+    add(item: AddItem<T>): Promise<string>;
+    put(item: T): Promise<string>;
+    update(key: string, changes: Partial<T>): Promise<number>;
+    delete(key: string): Promise<void>;
     clear(): Promise<void>;
-    get(key: unknown): Promise<T | undefined>;
+    get(key: string): Promise<T | undefined>;
     toArray(): Promise<T[]>;
     count(): Promise<number>;
-    bulkAdd(items: T[]): Promise<unknown>;
-    bulkPut(items: T[]): Promise<unknown>;
-    bulkGet(keys: Array<unknown>): Promise<Array<T | undefined>>;
-    bulkUpdate(keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>): Promise<number>;
-    bulkDelete(keys: Array<unknown>): Promise<void>;
+    bulkAdd(items: AddItem<T>[]): Promise<string[]>;
+    bulkPut(items: T[]): Promise<string[]>;
+    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>;
     orderBy(index: string | string[]): StorageCollection<T>;
     reverse(): StorageCollection<T>;
@@ -98,15 +101,15 @@ export interface StorageTable<T = any> {
     jsFilter(predicate: (item: T) => boolean): StorageCollection<T>;
     // The "raw" property exposes the underlying storage operations without Dync sync logic.
     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>;
     };
 }

package/src/types.ts

@@ -15,7 +15,7 @@ export interface SyncedRecord {
 export interface ApiFunctions {
     add: (item: any) => Promise<any | undefined>;
     update: (id: any, changes: any, item: any) => Promise<boolean>;
-    remove: (id: any) => Promise<void>;
+    delete: (id: any) => Promise<void>;
     list: (lastUpdatedAt: Date) => Promise<any[]>;
     firstLoad?: (lastId: any) => Promise<any[]>;
 }
@@ -29,9 +29,9 @@ export interface ApiFunctions {
  */
 export interface BatchPushPayload {
     table: string;
-    action: 'add' | 'update' | 'remove';
+    action: 'add' | 'update' | 'delete';
     localId: string;
-    // Server-assigned ID (for update/remove)
+    // Server-assigned ID (for update/delete)
     id?: any;
     // The data to sync (for add/update)
     data?: any;
@@ -152,7 +152,7 @@ export interface SyncState extends PersistedSyncState {
 export enum SyncAction {
     Create = 'create',
     Update = 'update',
-    Remove = 'remove', // Remote removes are a noop if no record found
+    Delete = 'delete', // Remote deletes are a noop if no record found
 }
 
 export interface PendingChange {