@anfenn/dync 1.0.0

package/src/core/tableEnhancers.ts

@@ -0,0 +1,457 @@
+import { createLocalId } from '../helpers';
+import { SyncAction, type MutationEvent, type SyncedRecord } from '../types';
+import type { StorageTable } from '../storage/types';
+import { DYNC_STATE_TABLE, type StateHelpers } from './StateManager';
+import type { WithTransaction } from './types';
+export type EmitMutation = (event: MutationEvent) => void;
+
+/**
+ * Wraps a table with mutation emission for reactive updates.
+ * This allows useLiveQuery to work with any table.
+ */
+export function wrapWithMutationEmitter<T>(table: StorageTable<T>, tableName: string, emitMutation: EmitMutation): void {
+    const rawAdd = table.raw.add;
+    const rawPut = table.raw.put;
+    const rawUpdate = table.raw.update;
+    const rawDelete = table.raw.delete;
+    const rawBulkAdd = table.raw.bulkAdd;
+    const rawBulkPut = table.raw.bulkPut;
+    const rawBulkUpdate = table.raw.bulkUpdate;
+    const rawBulkDelete = table.raw.bulkDelete;
+    const rawClear = table.raw.clear;
+
+    table.add = async (item: T) => {
+        const result = await rawAdd(item);
+        emitMutation({ type: 'add', tableName, keys: [result] });
+        return result;
+    };
+
+    table.put = async (item: T) => {
+        const result = await rawPut(item);
+        emitMutation({ type: 'update', tableName, keys: [result] });
+        return result;
+    };
+
+    table.update = async (key: unknown, changes: Partial<T>) => {
+        const result = await rawUpdate(key, changes);
+        if (result > 0) {
+            emitMutation({ type: 'update', tableName, keys: [key] });
+        }
+        return result;
+    };
+
+    table.delete = async (key: unknown) => {
+        await rawDelete(key);
+        emitMutation({ type: 'delete', tableName, keys: [key] });
+    };
+
+    table.bulkAdd = async (items: T[]) => {
+        const result = await rawBulkAdd(items);
+        if (items.length > 0) {
+            emitMutation({ type: 'add', tableName });
+        }
+        return result;
+    };
+
+    table.bulkPut = async (items: T[]) => {
+        const result = await rawBulkPut(items);
+        if (items.length > 0) {
+            emitMutation({ type: 'update', tableName });
+        }
+        return result;
+    };
+
+    table.bulkUpdate = async (keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>) => {
+        const result = await rawBulkUpdate(keysAndChanges);
+        if (result > 0) {
+            emitMutation({ type: 'update', tableName, keys: keysAndChanges.map((kc) => kc.key) });
+        }
+        return result;
+    };
+
+    table.bulkDelete = async (keys: unknown[]) => {
+        await rawBulkDelete(keys);
+        if (keys.length > 0) {
+            emitMutation({ type: 'delete', tableName });
+        }
+    };
+
+    table.clear = async () => {
+        await rawClear();
+        emitMutation({ type: 'delete', tableName });
+    };
+}
+
+interface SetupOptions {
+    owner: object;
+    tableCache: Map<string, StorageTable<any>>;
+    enhancedTables: Set<string>;
+    getTable: (name: string) => StorageTable<any>;
+}
+
+export function setupEnhancedTables({ owner, tableCache, enhancedTables, getTable }: SetupOptions, tableNames: string[]): void {
+    for (const tableName of tableNames) {
+        tableCache.delete(tableName);
+        enhancedTables.delete(tableName);
+
+        if (!Object.prototype.hasOwnProperty.call(owner, tableName)) {
+            Object.defineProperty(owner, tableName, {
+                get: () => getTable(tableName),
+                enumerable: true,
+                configurable: true,
+            });
+        }
+    }
+}
+
+interface EnhanceOptions<T> {
+    table: StorageTable<T & SyncedRecord>;
+    tableName: string;
+    withTransaction: WithTransaction;
+    state: StateHelpers;
+    enhancedTables: Set<string>;
+    emitMutation: EmitMutation;
+}
+
+export function enhanceSyncTable<T>({ table, tableName, withTransaction, state, enhancedTables, emitMutation }: EnhanceOptions<T>): void {
+    const rawAdd = table.raw.add;
+    const rawPut = table.raw.put;
+    const rawUpdate = table.raw.update;
+    const rawDelete = table.raw.delete;
+    const rawBulkAdd = table.raw.bulkAdd;
+    const rawBulkPut = table.raw.bulkPut;
+    const rawBulkUpdate = table.raw.bulkUpdate;
+    const rawBulkDelete = table.raw.bulkDelete;
+    const rawClear = table.raw.clear;
+
+    const wrappedAdd = async (item: any) => {
+        let localId = item._localId;
+        if (!localId) localId = createLocalId();
+
+        const syncedItem = {
+            ...item,
+            _localId: localId,
+            updated_at: new Date().toISOString(),
+        };
+
+        let result: any;
+        await withTransaction('rw', [tableName, DYNC_STATE_TABLE], async () => {
+            result = await rawAdd(syncedItem);
+
+            await state.addPendingChange({
+                action: SyncAction.Create,
+                stateKey: tableName,
+                localId,
+                changes: syncedItem,
+                before: null,
+                after: syncedItem,
+            });
+        });
+
+        emitMutation({ type: 'add', tableName, keys: [localId] });
+        return result;
+    };
+
+    const wrappedPut = async (item: any) => {
+        let localId = item._localId;
+        if (!localId) localId = createLocalId();
+
+        const syncedItem = {
+            ...item,
+            _localId: localId,
+            updated_at: new Date().toISOString(),
+        };
+
+        let result: any;
+        let isUpdate = false;
+        let existingRecord: any;
+
+        await withTransaction('rw', [tableName, DYNC_STATE_TABLE], async (tables) => {
+            const txTable = tables[tableName]!;
+            existingRecord = await txTable.get(localId);
+            isUpdate = !!existingRecord;
+
+            result = await rawPut(syncedItem);
+
+            await state.addPendingChange({
+                action: isUpdate ? SyncAction.Update : SyncAction.Create,
+                stateKey: tableName,
+                localId,
+                id: existingRecord?.id,
+                changes: syncedItem,
+                before: existingRecord ?? null,
+                after: syncedItem,
+            });
+        });
+
+        emitMutation({ type: isUpdate ? 'update' : 'add', tableName, keys: [localId] });
+        return result;
+    };
+
+    const wrappedUpdate = async (key: any, changes: any) => {
+        const updatedChanges = {
+            ...changes,
+            updated_at: new Date().toISOString(),
+        };
+
+        let result = 0;
+        await withTransaction('rw', [tableName, DYNC_STATE_TABLE], async (tables) => {
+            const txTable = tables[tableName]!;
+            const record = await txTable.get(key);
+            if (!record) {
+                throw new Error(`Record with key=${key} not found`);
+            }
+
+            result = (await rawUpdate(key, updatedChanges as any)) ?? 0;
+            if (result > 0) {
+                await state.addPendingChange({
+                    action: SyncAction.Update,
+                    stateKey: tableName,
+                    localId: key,
+                    id: record.id,
+                    changes: updatedChanges,
+                    before: record,
+                    after: { ...record, ...updatedChanges },
+                });
+            }
+        });
+
+        if (result > 0) {
+            emitMutation({ type: 'update', tableName, keys: [key] });
+        }
+        return result;
+    };
+
+    const wrappedDelete = async (key: any) => {
+        let deletedLocalId: string | undefined;
+        await withTransaction('rw', [tableName, DYNC_STATE_TABLE], async (tables) => {
+            const txTable = tables[tableName]!;
+            const record = await txTable.get(key);
+
+            await rawDelete(key);
+
+            if (record) {
+                deletedLocalId = record._localId;
+                await state.addPendingChange({
+                    action: SyncAction.Remove,
+                    stateKey: tableName,
+                    localId: record._localId,
+                    id: record.id,
+                    changes: null,
+                    before: record,
+                });
+            }
+        });
+
+        if (deletedLocalId) {
+            emitMutation({ type: 'delete', tableName, keys: [deletedLocalId] });
+        }
+    };
+
+    const wrappedBulkAdd = async (items: any[]) => {
+        if (items.length === 0) return;
+
+        const now = new Date().toISOString();
+        const syncedItems = items.map((item) => {
+            const localId = item._localId || createLocalId();
+            return {
+                ...item,
+                _localId: localId,
+                updated_at: now,
+            };
+        });
+
+        let result: any;
+        await withTransaction('rw', [tableName, DYNC_STATE_TABLE], async () => {
+            result = await rawBulkAdd(syncedItems);
+
+            for (const syncedItem of syncedItems) {
+                await state.addPendingChange({
+                    action: SyncAction.Create,
+                    stateKey: tableName,
+                    localId: syncedItem._localId,
+                    changes: syncedItem,
+                    before: null,
+                    after: syncedItem,
+                });
+            }
+        });
+
+        emitMutation({ type: 'add', tableName, keys: syncedItems.map((i) => i._localId) });
+        return result;
+    };
+
+    const wrappedBulkPut = async (items: any[]) => {
+        if (items.length === 0) return;
+
+        const now = new Date().toISOString();
+        const syncedItems = items.map((item) => {
+            const localId = item._localId || createLocalId();
+            return {
+                ...item,
+                _localId: localId,
+                updated_at: now,
+            };
+        });
+        const localIds = syncedItems.map((i) => i._localId);
+
+        let result: any;
+        await withTransaction('rw', [tableName, DYNC_STATE_TABLE], async (tables) => {
+            const txTable = tables[tableName]!;
+
+            // Check which items already exist
+            const existingRecords = await txTable.bulkGet(localIds);
+            const existingMap = new Map<string, any>();
+            for (let i = 0; i < localIds.length; i++) {
+                if (existingRecords[i]) {
+                    existingMap.set(localIds[i], existingRecords[i]);
+                }
+            }
+
+            result = await rawBulkPut(syncedItems);
+
+            for (const syncedItem of syncedItems) {
+                const existing = existingMap.get(syncedItem._localId);
+                await state.addPendingChange({
+                    action: existing ? SyncAction.Update : SyncAction.Create,
+                    stateKey: tableName,
+                    localId: syncedItem._localId,
+                    id: existing?.id,
+                    changes: syncedItem,
+                    before: existing ?? null,
+                    after: syncedItem,
+                });
+            }
+        });
+
+        emitMutation({ type: 'update', tableName, keys: localIds });
+        return result;
+    };
+
+    const wrappedBulkUpdate = async (keysAndChanges: Array<{ key: any; changes: any }>) => {
+        if (keysAndChanges.length === 0) return 0;
+
+        const now = new Date().toISOString();
+        const updatedKeysAndChanges = keysAndChanges.map(({ key, changes }) => ({
+            key,
+            changes: {
+                ...changes,
+                updated_at: now,
+            },
+        }));
+
+        let result = 0;
+        const updatedKeys: string[] = [];
+
+        await withTransaction('rw', [tableName, DYNC_STATE_TABLE], async (tables) => {
+            const txTable = tables[tableName]!;
+
+            // Get all records before updating
+            const keys = updatedKeysAndChanges.map((kc) => kc.key);
+            const records = await txTable.bulkGet(keys);
+            const recordMap = new Map<string, any>();
+            for (let i = 0; i < keys.length; i++) {
+                if (records[i]) {
+                    recordMap.set(String(keys[i]), records[i]);
+                }
+            }
+
+            result = await rawBulkUpdate(updatedKeysAndChanges);
+
+            for (const { key, changes } of updatedKeysAndChanges) {
+                const record = recordMap.get(String(key));
+                if (record) {
+                    updatedKeys.push(record._localId);
+                    await state.addPendingChange({
+                        action: SyncAction.Update,
+                        stateKey: tableName,
+                        localId: record._localId,
+                        id: record.id,
+                        changes,
+                        before: record,
+                        after: { ...record, ...changes },
+                    });
+                }
+            }
+        });
+
+        if (updatedKeys.length > 0) {
+            emitMutation({ type: 'update', tableName, keys: updatedKeys });
+        }
+        return result;
+    };
+
+    const wrappedBulkDelete = async (keys: any[]) => {
+        if (keys.length === 0) return;
+
+        const deletedLocalIds: string[] = [];
+        await withTransaction('rw', [tableName, DYNC_STATE_TABLE], async (tables) => {
+            const txTable = tables[tableName]!;
+
+            // Get all records before deleting
+            const records = await txTable.bulkGet(keys);
+
+            await rawBulkDelete(keys);
+
+            for (const record of records) {
+                if (record) {
+                    deletedLocalIds.push(record._localId);
+                    await state.addPendingChange({
+                        action: SyncAction.Remove,
+                        stateKey: tableName,
+                        localId: record._localId,
+                        id: record.id,
+                        changes: null,
+                        before: record,
+                    });
+                }
+            }
+        });
+
+        if (deletedLocalIds.length > 0) {
+            emitMutation({ type: 'delete', tableName, keys: deletedLocalIds });
+        }
+    };
+
+    const wrappedClear = async () => {
+        const deletedLocalIds: string[] = [];
+        await withTransaction('rw', [tableName, DYNC_STATE_TABLE], async (tables) => {
+            const txTable = tables[tableName]!;
+
+            // Get all records before clearing
+            const allRecords = await txTable.toArray();
+
+            await rawClear();
+
+            for (const record of allRecords) {
+                if (record._localId) {
+                    deletedLocalIds.push(record._localId);
+                    await state.addPendingChange({
+                        action: SyncAction.Remove,
+                        stateKey: tableName,
+                        localId: record._localId,
+                        id: record.id,
+                        changes: null,
+                        before: record,
+                    });
+                }
+            }
+        });
+
+        if (deletedLocalIds.length > 0) {
+            emitMutation({ type: 'delete', tableName, keys: deletedLocalIds });
+        }
+    };
+
+    table.add = wrappedAdd;
+    table.put = wrappedPut;
+    table.update = wrappedUpdate;
+    table.delete = wrappedDelete;
+    table.bulkAdd = wrappedBulkAdd;
+    table.bulkPut = wrappedBulkPut;
+    table.bulkUpdate = wrappedBulkUpdate;
+    table.bulkDelete = wrappedBulkDelete;
+    table.clear = wrappedClear;
+
+    enhancedTables.add(tableName);
+}

package/src/core/types.ts

@@ -0,0 +1,3 @@
+import type { StorageTable, TransactionMode } from '../storage/types';
+
+export type WithTransaction = <T>(mode: TransactionMode, tableNames: string[], fn: (tables: Record<string, StorageTable<any>>) => Promise<T>) => Promise<T>;

package/src/createLocalId.native.ts

@@ -0,0 +1,8 @@
+import * as Crypto from 'expo-crypto';
+
+export function createLocalId(): string {
+    if (Crypto.randomUUID) {
+        return Crypto.randomUUID();
+    }
+    throw new Error('createLocalId(): expo-crypto randomUUID is not available');
+}

package/src/createLocalId.ts

@@ -0,0 +1,6 @@
+export function createLocalId(): string {
+    if (typeof globalThis.crypto?.randomUUID === 'function') {
+        return globalThis.crypto.randomUUID();
+    }
+    throw new Error('createLocalId(): crypto.randomUUID is not available');
+}

package/src/dexie.ts

@@ -0,0 +1,2 @@
+export { DexieAdapter, DexieQueryContext } from './storage/dexie';
+export type { StorageAdapter } from './storage/types';

package/src/expoSqlite.ts

@@ -0,0 +1,2 @@
+export { ExpoSQLiteDriver } from './storage/sqlite/drivers/ExpoSQLiteDriver.native';
+export type { SQLiteDatabaseDriver, SQLiteQueryResult, SQLiteRunResult } from './storage/sqlite/types';

package/src/helpers.ts

@@ -0,0 +1,87 @@
+import { SyncAction } from './types';
+import { createLocalId } from './createLocalId';
+
+export { createLocalId };
+
+export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+    return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve();
+            return;
+        }
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', () => {
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+}
+
+export function changeKeysTo(input: any | any[], toIdKey: string, toUpdatedAtKey: string, toDeletedKey: string) {
+    if (!input) return input;
+    const isArray = Array.isArray(input);
+    const result = (isArray ? input : [input]).map((item) => {
+        const { id, updated_at, deleted, ...rest } = item;
+        return {
+            [toIdKey]: id,
+            [toUpdatedAtKey]: updated_at,
+            [toDeletedKey]: deleted,
+            ...rest,
+        };
+    });
+    return isArray ? result : result[0];
+}
+
+export function changeKeysFrom(input: any | any[], fromIdKey: string, fromUpdatedAtKey: string, fromDeletedKey: string) {
+    if (!input) return input;
+    const isArray = Array.isArray(input);
+    const result = (isArray ? input : [input]).map((item) => {
+        const { [fromIdKey]: id, [fromUpdatedAtKey]: updated_at, [fromDeletedKey]: deleted, ...rest } = item;
+        return {
+            id,
+            updated_at,
+            deleted,
+            ...rest,
+        };
+    });
+    return isArray ? result : result[0];
+}
+
+export function orderFor(a: SyncAction): number {
+    switch (a) {
+        case SyncAction.Create:
+            return 1;
+        case SyncAction.Update:
+            return 2;
+        case SyncAction.Remove:
+            return 3;
+    }
+}
+
+export function omitFields(item: any, fields: string[]) {
+    const result = { ...item };
+    for (const k of fields) delete result[k];
+    return result;
+}
+
+export function addOnSetDo(obj: any, key: string, fn: (v: any) => void): void {
+    let value = obj[key];
+
+    Object.defineProperty(obj, key, {
+        get() {
+            return value;
+        },
+        set(newVal) {
+            value = newVal;
+            fn(value);
+        },
+        enumerable: true,
+        configurable: false,
+    });
+}
+
+export function deleteKeyIfEmptyObject(obj: any, key: string) {
+    if (obj[key] && Object.keys(obj[key]).length === 0) {
+        delete obj[key];
+    }
+}

package/src/index.native.ts

@@ -0,0 +1,28 @@
+export * from './index.shared';
+export { MemoryAdapter } from './storage/memory';
+export { SQLiteAdapter } from './storage/sqlite';
+export { MemoryQueryContext } from './storage/memory';
+export { SqliteQueryContext } from './storage/sqlite';
+export type { SQLiteDatabaseDriver, SQLiteQueryResult, SQLiteRunResult } from './storage/sqlite/types';
+export type { StorageAdapter } from './storage/types';
+export { SyncAction } from './types';
+export { createLocalId } from './helpers';
+
+export type {
+    AfterRemoteAddCallback,
+    ApiFunctions,
+    BatchSync,
+    BatchPushPayload,
+    BatchPushResult,
+    BatchFirstLoadResult,
+    ConflictResolutionStrategy,
+    FirstLoadProgress,
+    FirstLoadProgressCallback,
+    MissingRemoteRecordStrategy,
+    MissingRemoteRecordDuringUpdateCallback,
+    MutationEvent,
+    SyncOptions,
+    SyncState,
+    SyncedRecord,
+    TableMap,
+} from './types';