@anfenn/dync 1.0.13 → 1.0.15

package/dist/react/index.d.cts

@@ -1,4 +1,4 @@
-import { a as ApiFunctions, h as SyncOptions, B as BatchSync, D as Dync, i as SyncState } from '../index.shared-C8JTfet7.cjs';
+import { a as ApiFunctions, h as SyncOptions, B as BatchSync, D as Dync, i as SyncState } from '../index.shared-DHuT0l_t.cjs';
 import { c as StorageAdapter } from '../dexie-BqktVP7s.cjs';
 import '../types-CSbIAfu2.cjs';
 import 'dexie';

package/dist/react/index.d.ts

@@ -1,4 +1,4 @@
-import { a as ApiFunctions, h as SyncOptions, B as BatchSync, D as Dync, i as SyncState } from '../index.shared-DajtjVW7.js';
+import { a as ApiFunctions, h as SyncOptions, B as BatchSync, D as Dync, i as SyncState } from '../index.shared-D-fB8Odd.js';
 import { c as StorageAdapter } from '../dexie-DRLMKLl5.js';
 import '../types-CSbIAfu2.js';
 import 'dexie';

package/dist/react/index.js

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

package/package.json

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

package/src/core/StateManager.ts

@@ -1,5 +1,15 @@
 import { deleteKeyIfEmptyObject, omitFields } from '../helpers';
-import { LOCAL_PK, UPDATED_AT, SyncAction, type PendingChange, type PersistedSyncState, type SyncState, type SyncStatus } from '../types';
+import {
+    LOCAL_PK,
+    UPDATED_AT,
+    SyncAction,
+    ApiError,
+    parseApiError,
+    type PendingChange,
+    type PersistedSyncState,
+    type SyncState,
+    type SyncStatus,
+} from '../types';
 import type { StorageAdapter } from '../storage/types';
 
 const LOCAL_ONLY_SYNC_FIELDS = [LOCAL_PK, UPDATED_AT];
@@ -28,7 +38,7 @@ export interface StateHelpers {
     hydrate(): Promise<void>;
     getState(): PersistedSyncState;
     setState(setterOrState: PersistedSyncState | ((state: PersistedSyncState) => Partial<PersistedSyncState>)): Promise<void>;
-    setErrorInMemory(error: Error): void;
+    setApiError(error: Error | undefined): void;
     addPendingChange(change: Omit<PendingChange, 'version'>): Promise<void>;
     samePendingVersion(tableName: string, localId: string, version: number): boolean;
     removePendingChange(localId: string, tableName: string): Promise<void>;
@@ -44,6 +54,7 @@ export interface StateHelpers {
 export class StateManager implements StateHelpers {
     private persistedState: PersistedSyncState;
     private syncStatus: SyncStatus;
+    private apiError?: ApiError;
     private readonly listeners = new Set<(state: SyncState) => void>();
     private readonly storageAdapter?: StorageAdapter;
     private hydrated = false;
@@ -100,12 +111,8 @@ export class StateManager implements StateHelpers {
         return this.persist();
     }
 
-    /**
-     * Set error in memory only without persisting to database.
-     * Used when the database itself failed to open.
-     */
-    setErrorInMemory(error: Error): void {
-        this.persistedState = { ...this.persistedState, error };
+    setApiError(error: Error | undefined): void {
+        this.apiError = error ? parseApiError(error) : undefined;
         this.emit();
     }
 
@@ -199,7 +206,7 @@ export class StateManager implements StateHelpers {
     }
 
     getSyncState(): SyncState {
-        return buildSyncState(this.persistedState, this.syncStatus, this.hydrated);
+        return buildSyncState(this.persistedState, this.syncStatus, this.hydrated, this.apiError);
     }
 
     subscribe(listener: (state: SyncState) => void): () => void {
@@ -229,12 +236,13 @@ function resolveNextState(
     return { ...current, ...setterOrState };
 }
 
-function buildSyncState(state: PersistedSyncState, status: SyncStatus, hydrated: boolean): SyncState {
+function buildSyncState(state: PersistedSyncState, status: SyncStatus, hydrated: boolean, apiError?: ApiError): SyncState {
     const persisted = clonePersistedState(state);
     const syncState: SyncState = {
         ...persisted,
         status,
         hydrated,
+        apiError,
     };
     deleteKeyIfEmptyObject(syncState, 'conflicts');
     return syncState;

package/src/index.shared.ts

@@ -358,10 +358,7 @@ class DyncBase<_TStoreMap = Record<string, any>> {
         }
 
         this.syncStatus = 'idle';
-        await this.state.setState((syncState) => ({
-            ...syncState,
-            error: pullResult.error ?? firstPushSyncError,
-        }));
+        this.state.setApiError(pullResult.error ?? firstPushSyncError);
 
         if (this.mutationsDuringSync) {
             this.mutationsDuringSync = false;

package/src/types.ts

@@ -5,6 +5,69 @@ export const SERVER_PK = 'id';
 export const LOCAL_PK = '_localId';
 export const UPDATED_AT = 'updated_at';
 
+export class ApiError extends Error {
+    readonly isNetworkError: boolean;
+    override readonly cause?: Error;
+
+    constructor(message: string, isNetworkError: boolean, cause?: Error) {
+        super(message);
+        this.name = 'ApiError';
+        this.isNetworkError = isNetworkError;
+        this.cause = cause;
+    }
+}
+
+/**
+ * Detects if an error is a network-level failure from common HTTP libraries.
+ * Supports: fetch, axios, Apollo GraphQL, and generic network errors.
+ */
+function isNetworkError(error: Error): boolean {
+    const message = error.message.toLowerCase();
+    const name = error.name;
+
+    // fetch: throws TypeError on network failure
+    if (name === 'TypeError' && (message.includes('failed to fetch') || message.includes('network request failed'))) {
+        return true;
+    }
+
+    // axios: sets error.code for network issues
+    const code = (error as any).code;
+    if (code === 'ERR_NETWORK' || code === 'ECONNABORTED' || code === 'ENOTFOUND' || code === 'ECONNREFUSED') {
+        return true;
+    }
+
+    // axios: no response means request never reached server
+    if ((error as any).isAxiosError && (error as any).response === undefined) {
+        return true;
+    }
+
+    // Apollo GraphQL: network error wrapper
+    if (name === 'ApolloError' && (error as any).networkError) {
+        return true;
+    }
+
+    // Generic network error messages
+    if (message.includes('network error') || message.includes('networkerror')) {
+        return true;
+    }
+
+    return false;
+}
+
+export function parseApiError(error: unknown): ApiError {
+    if (error instanceof ApiError) {
+        return error;
+    }
+
+    if (error instanceof Error) {
+        return new ApiError(error.message, isNetworkError(error), error);
+    }
+
+    // Non-Error thrown (string, object, etc.)
+    const message = String(error);
+    return new ApiError(message, false);
+}
+
 export interface SyncedRecord {
     _localId: string;
     id?: any;
@@ -138,7 +201,6 @@ export interface PersistedSyncState {
     firstLoadDone: boolean;
     pendingChanges: PendingChange[];
     lastPulled: Record<string, string>;
-    error?: Error;
     conflicts?: Record<string, Conflict>;
 }
 
@@ -147,6 +209,7 @@ export type SyncStatus = 'disabled' | 'disabling' | 'idle' | 'syncing' | 'error'
 export interface SyncState extends PersistedSyncState {
     status: SyncStatus;
     hydrated: boolean;
+    apiError?: ApiError;
 }
 
 export enum SyncAction {