@anfenn/dync 1.0.26 → 1.0.28

package/dist/react/index.d.cts

@@ -1,5 +1,5 @@
-import { b as SyncApi, k as SyncState } from '../types-BgGGLrE9.cjs';
-import '../dexie-DtgGGM68.cjs';
+import { a as SyncApi, k as SyncState } from '../types-9I2fmDbU.cjs';
+import '../dexie-T9m1mP1h.cjs';
 import 'dexie';
 import '../types-CSbIAfu2.cjs';
 

package/dist/react/index.d.ts

@@ -1,5 +1,5 @@
-import { b as SyncApi, k as SyncState } from '../types-B1Vn8_DF.js';
-import '../dexie-B1FuZqDB.js';
+import { a as SyncApi, k as SyncState } from '../types-DLFva7gq.js';
+import '../dexie-BFPA0JU2.js';
 import 'dexie';
 import '../types-CSbIAfu2.js';
 

package/dist/{types-BgGGLrE9.d.cts → types-9I2fmDbU.d.cts}

@@ -1,4 +1,4 @@
-import { b as StorageTable } from './dexie-DtgGGM68.cjs';
+import { d as StorageAdapter, a as StorageTable } from './dexie-T9m1mP1h.cjs';
 
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
 interface Logger {
@@ -94,6 +94,12 @@ interface SyncOptions {
     onAfterMissingRemoteRecordDuringUpdate?: MissingRemoteRecordDuringUpdateCallback;
     conflictResolutionStrategy?: ConflictResolutionStrategy;
 }
+interface DyncOptions<TStoreMap extends Record<string, any> = Record<string, any>> {
+    databaseName: string;
+    storageAdapter: StorageAdapter;
+    sync: Partial<Record<keyof TStoreMap, ApiFunctions>> | BatchSync;
+    options?: SyncOptions;
+}
 interface FirstLoadProgress {
     table: string;
     inserted: number;
@@ -104,7 +110,6 @@ type FirstLoadProgressCallback = (progress: FirstLoadProgress) => void;
 type SyncApi = {
     enable: (enabled: boolean) => Promise<void>;
     startFirstLoad: (onProgress?: FirstLoadProgressCallback) => Promise<void>;
-    /** Current sync state - use useSyncState() hook for reactive updates in React */
     readonly state: SyncState;
     resolveConflict: (localId: string, keepLocal: boolean) => Promise<void>;
     onStateChange: (fn: (state: SyncState) => void) => () => void;
@@ -151,8 +156,8 @@ interface FieldConflict {
     localValue: any;
     remoteValue: any;
 }
-type TableMap<TStoreMap extends Record<string, unknown>> = {
+type TableMap<TStoreMap extends Record<string, any>> = {
     [K in keyof TStoreMap]: StorageTable<TStoreMap[K]>;
 };
 
-export { type ApiFunctions as A, type BatchSync as B, type ConflictResolutionStrategy as C, type FirstLoadProgress as F, type MissingRemoteRecordStrategy as M, type SyncOptions as S, type TableMap as T, type SyncStatus as a, type SyncApi as b, SyncAction as c, type AfterRemoteAddCallback as d, type BatchPushPayload as e, type BatchPushResult as f, type BatchFirstLoadResult as g, type FirstLoadProgressCallback as h, type MissingRemoteRecordDuringUpdateCallback as i, type MutationEvent as j, type SyncState as k, type SyncedRecord as l };
+export { type AfterRemoteAddCallback as A, type BatchSync as B, type ConflictResolutionStrategy as C, type DyncOptions as D, type FirstLoadProgress as F, type MissingRemoteRecordStrategy as M, type SyncStatus as S, type TableMap as T, type SyncApi as a, SyncAction as b, type ApiFunctions as c, type BatchPushPayload as d, type BatchPushResult as e, type BatchFirstLoadResult as f, type FirstLoadProgressCallback as g, type MissingRemoteRecordDuringUpdateCallback as h, type MutationEvent as i, type SyncOptions as j, type SyncState as k, type SyncedRecord as l };

package/dist/{types-B1Vn8_DF.d.ts → types-DLFva7gq.d.ts}

@@ -1,4 +1,4 @@
-import { b as StorageTable } from './dexie-B1FuZqDB.js';
+import { d as StorageAdapter, a as StorageTable } from './dexie-BFPA0JU2.js';
 
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
 interface Logger {
@@ -94,6 +94,12 @@ interface SyncOptions {
     onAfterMissingRemoteRecordDuringUpdate?: MissingRemoteRecordDuringUpdateCallback;
     conflictResolutionStrategy?: ConflictResolutionStrategy;
 }
+interface DyncOptions<TStoreMap extends Record<string, any> = Record<string, any>> {
+    databaseName: string;
+    storageAdapter: StorageAdapter;
+    sync: Partial<Record<keyof TStoreMap, ApiFunctions>> | BatchSync;
+    options?: SyncOptions;
+}
 interface FirstLoadProgress {
     table: string;
     inserted: number;
@@ -104,7 +110,6 @@ type FirstLoadProgressCallback = (progress: FirstLoadProgress) => void;
 type SyncApi = {
     enable: (enabled: boolean) => Promise<void>;
     startFirstLoad: (onProgress?: FirstLoadProgressCallback) => Promise<void>;
-    /** Current sync state - use useSyncState() hook for reactive updates in React */
     readonly state: SyncState;
     resolveConflict: (localId: string, keepLocal: boolean) => Promise<void>;
     onStateChange: (fn: (state: SyncState) => void) => () => void;
@@ -151,8 +156,8 @@ interface FieldConflict {
     localValue: any;
     remoteValue: any;
 }
-type TableMap<TStoreMap extends Record<string, unknown>> = {
+type TableMap<TStoreMap extends Record<string, any>> = {
     [K in keyof TStoreMap]: StorageTable<TStoreMap[K]>;
 };
 
-export { type ApiFunctions as A, type BatchSync as B, type ConflictResolutionStrategy as C, type FirstLoadProgress as F, type MissingRemoteRecordStrategy as M, type SyncOptions as S, type TableMap as T, type SyncStatus as a, type SyncApi as b, SyncAction as c, type AfterRemoteAddCallback as d, type BatchPushPayload as e, type BatchPushResult as f, type BatchFirstLoadResult as g, type FirstLoadProgressCallback as h, type MissingRemoteRecordDuringUpdateCallback as i, type MutationEvent as j, type SyncState as k, type SyncedRecord as l };
+export { type AfterRemoteAddCallback as A, type BatchSync as B, type ConflictResolutionStrategy as C, type DyncOptions as D, type FirstLoadProgress as F, type MissingRemoteRecordStrategy as M, type SyncStatus as S, type TableMap as T, type SyncApi as a, SyncAction as b, type ApiFunctions as c, type BatchPushPayload as d, type BatchPushResult as e, type BatchFirstLoadResult as f, type FirstLoadProgressCallback as g, type MissingRemoteRecordDuringUpdateCallback as h, type MutationEvent as i, type SyncOptions as j, type SyncState as k, type SyncedRecord as l };

package/package.json

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

package/src/index.native.ts

@@ -16,6 +16,7 @@ export type {
     BatchPushResult,
     BatchFirstLoadResult,
     ConflictResolutionStrategy,
+    DyncOptions,
     FirstLoadProgress,
     FirstLoadProgressCallback,
     MissingRemoteRecordStrategy,

package/src/index.shared.ts

@@ -3,6 +3,7 @@ import { sleep } from './helpers';
 import {
     type ApiFunctions,
     type BatchSync,
+    type DyncOptions,
     type SyncOptions,
     type SyncState,
     type SyncedRecord,
@@ -36,7 +37,7 @@ const DEFAULT_MIN_LOG_LEVEL: LogLevel = 'debug';
 const DEFAULT_MISSING_REMOTE_RECORD_STRATEGY: MissingRemoteRecordStrategy = 'insert-remote-record';
 const DEFAULT_CONFLICT_RESOLUTION_STRATEGY: ConflictResolutionStrategy = 'try-shallow-merge';
 
-class DyncBase<_TStoreMap = Record<string, any>> {
+class DyncBase<_TStoreMap extends Record<string, any> = Record<string, any>> {
     private readonly adapter: StorageAdapter;
     private readonly tableCache = new Map<string, StorageTable<any>>();
     private readonly mutationWrappedTables = new Set<string>();
@@ -63,31 +64,35 @@ class DyncBase<_TStoreMap = Record<string, any>> {
     /**
      * Create a new Dync instance.
      *
-     * Mode 1 - Per-table endpoints:
-     * @param databaseName - Name of the database
-     * @param syncApis - Map of table names to API functions
-     * @param storageAdapter - Storage adapter implementation (required)
-     * @param options - Sync options
+     * @example Per-table sync mode
+     * ```ts
+     * const db = new Dync<Store>({
+     *     databaseName: 'my-app',
+     *     storageAdapter: new SQLiteAdapter(driver),
+     *     sync: { todos: todoSyncApi },
+     * });
+     * ```
      *
-     * Mode 2 - Batch endpoints:
-     * @param databaseName - Name of the database
-     * @param batchSync - Batch sync config (syncTables, push, pull, firstLoad)
-     * @param storageAdapter - Storage adapter implementation (required)
-     * @param options - Sync options
+     * @example Batch sync mode
+     * ```ts
+     * const db = new Dync<Store>({
+     *     databaseName: 'my-app',
+     *     storageAdapter: new SQLiteAdapter(driver),
+     *     sync: { syncTables: ['todos'], push, pull },
+     * });
+     * ```
      */
-    constructor(databaseName: string, syncApis: Record<string, ApiFunctions>, storageAdapter: StorageAdapter, options?: SyncOptions);
-    constructor(databaseName: string, batchSync: BatchSync, storageAdapter: StorageAdapter, options?: SyncOptions);
-    constructor(databaseName: string, syncApisOrBatchSync: Record<string, ApiFunctions> | BatchSync, storageAdapter: StorageAdapter, options?: SyncOptions) {
-        // Detect mode based on whether the second arg has sync API shape (has 'list' function)
-        const isBatchMode = typeof (syncApisOrBatchSync as BatchSync).push === 'function';
+    constructor(config: DyncOptions<_TStoreMap>) {
+        const { databaseName, storageAdapter, sync: syncConfig, options } = config;
+
+        // Detect mode based on whether sync config has batch sync shape
+        const isBatchMode = typeof (syncConfig as BatchSync).push === 'function' && typeof (syncConfig as BatchSync).pull === 'function';
 
         if (isBatchMode) {
-            // Batch mode: (databaseName, batchSync, options?)
-            this.batchSync = syncApisOrBatchSync as BatchSync;
+            this.batchSync = syncConfig as BatchSync;
             this.syncedTables = new Set(this.batchSync.syncTables);
         } else {
-            // Per-table mode: (databaseName, syncApis, options?)
-            this.syncApis = syncApisOrBatchSync as Record<string, ApiFunctions>;
+            this.syncApis = syncConfig as Record<string, ApiFunctions>;
             this.syncedTables = new Set(Object.keys(this.syncApis));
         }
 
@@ -177,6 +182,19 @@ class DyncBase<_TStoreMap = Record<string, any>> {
                 self.adapter.defineSchema(versionNumber, fullSchema, schemaOptions);
                 self.setupEnhancedTables(Object.keys(schema));
 
+                // Define getters for direct table access (e.g., db.todos)
+                for (const tableName of Object.keys(schema)) {
+                    if (!(tableName in self)) {
+                        Object.defineProperty(self, tableName, {
+                            get() {
+                                return self.table(tableName);
+                            },
+                            enumerable: true,
+                            configurable: false,
+                        });
+                    }
+                }
+
                 return builder;
             },
             sqlite(configure: (builder: SQLiteVersionConfigurator) => void) {
@@ -590,27 +608,16 @@ class DyncBase<_TStoreMap = Record<string, any>> {
     };
 }
 
-type DyncInstance<TStoreMap extends Record<string, unknown> = Record<string, unknown>> = DyncBase<TStoreMap> &
+type DyncInstance<TStoreMap extends Record<string, any> = Record<string, any>> = DyncBase<TStoreMap> &
     TableMap<TStoreMap> & {
         table<K extends keyof TStoreMap & string>(name: K): StorageTable<TStoreMap[K]>;
         table(name: string): StorageTable<any>;
     };
 
-const DyncConstructor = DyncBase as unknown as {
-    prototype: DyncInstance<Record<string, unknown>>;
-    new <TStoreMap extends Record<string, unknown> = Record<string, unknown>>(
-        databaseName: string,
-        syncApis: Record<string, ApiFunctions>,
-        storageAdapter: StorageAdapter,
-        options?: SyncOptions,
-    ): DyncInstance<TStoreMap>;
-    new <TStoreMap extends Record<string, unknown> = Record<string, unknown>>(
-        databaseName: string,
-        batchSync: BatchSync,
-        storageAdapter: StorageAdapter,
-        options?: SyncOptions,
-    ): DyncInstance<TStoreMap>;
-} & typeof DyncBase;
-
-export const Dync = DyncConstructor;
-export type Dync<TStoreMap extends Record<string, unknown> = Record<string, unknown>> = DyncInstance<TStoreMap>;
+// Export Dync as a class-like constructor with proper typing for direct table access
+export const Dync = DyncBase as unknown as {
+    <TStoreMap extends Record<string, any> = Record<string, any>>(config: DyncOptions<TStoreMap>): DyncInstance<TStoreMap>;
+    new <TStoreMap extends Record<string, any> = Record<string, any>>(config: DyncOptions<TStoreMap>): DyncInstance<TStoreMap>;
+};
+
+export type Dync<TStoreMap extends Record<string, any> = Record<string, any>> = DyncInstance<TStoreMap>;

package/src/index.ts

@@ -16,6 +16,7 @@ export type {
     BatchPushResult,
     BatchFirstLoadResult,
     ConflictResolutionStrategy,
+    DyncOptions,
     FirstLoadProgress,
     FirstLoadProgressCallback,
     MissingRemoteRecordStrategy,

package/src/types.ts

@@ -1,5 +1,5 @@
 import type { Logger, LogLevel } from './logger';
-import type { StorageTable } from './storage/types';
+import type { StorageAdapter, StorageTable } from './storage/types';
 
 export const SERVER_PK = 'id';
 export const LOCAL_PK = '_localId';
@@ -122,6 +122,13 @@ export interface SyncOptions {
     conflictResolutionStrategy?: ConflictResolutionStrategy;
 }
 
+export interface DyncOptions<TStoreMap extends Record<string, any> = Record<string, any>> {
+    databaseName: string;
+    storageAdapter: StorageAdapter;
+    sync: Partial<Record<keyof TStoreMap, ApiFunctions>> | BatchSync;
+    options?: SyncOptions;
+}
+
 export interface FirstLoadProgress {
     table: string;
     inserted: number;
@@ -134,7 +141,7 @@ export type FirstLoadProgressCallback = (progress: FirstLoadProgress) => void;
 export type SyncApi = {
     enable: (enabled: boolean) => Promise<void>;
     startFirstLoad: (onProgress?: FirstLoadProgressCallback) => Promise<void>;
-    /** Current sync state - use useSyncState() hook for reactive updates in React */
+    // Current sync state - use useSyncState() hook for reactive updates in React
     readonly state: SyncState;
     resolveConflict: (localId: string, keepLocal: boolean) => Promise<void>;
     onStateChange: (fn: (state: SyncState) => void) => () => void;
@@ -190,7 +197,7 @@ export interface FieldConflict {
     remoteValue: any;
 }
 
-export type TableMap<TStoreMap extends Record<string, unknown>> = {
+export type TableMap<TStoreMap extends Record<string, any>> = {
     [K in keyof TStoreMap]: StorageTable<TStoreMap[K]>;
 };