delta-sync/dist/core/types.d.ts

A lightweight framework for bi-directional database synchronization with automatic version tracking and conflict resolution.

export type SyncOperationType = 'put' | 'delete';
export interface SyncQueryOptions {
    since?: number;
    limit?: number;
    offset?: number;
    includeDeleted?: boolean;
}
export interface SyncQueryResult<T = any> {
    items: T[];
    hasMore: boolean;
}
export interface SyncProgress {
    processed: number;
    total: number;
}
export interface SyncResult {
    success: boolean;
    error?: string;
    syncedAt?: number;
    stats?: {
        uploaded: number;
        downloaded: number;
        errors: number;
    };
}
export declare enum SyncStatus {
    ERROR = -2,// Error status
    OFFLINE = -1,// Offline status
    IDLE = 0,// Idle status
    UPLOADING = 1,// Upload synchronization in progress
    DOWNLOADING = 2,// Download synchronization in progress
    OPERATING = 3
}
export interface SyncOptions {
    autoSync?: {
        enabled?: boolean;
        pullInterval?: number;
        pushDebounce?: number;
        retryDelay?: number;
    };
    onStatusUpdate?: (status: SyncStatus) => void;
    onVersionUpdate?: (_ver: number) => void;
    onChangePushed?: (changes: DataChangeSet) => void;
    onChangePulled?: (changes: DataChangeSet) => void;
    onPullAvailableCheck?: () => boolean;
    onPushAvailableCheck?: () => boolean;
    maxRetries?: number;
    timeout?: number;
    batchSize?: number;
    payloadSize?: number;
    maxFileSize?: number;
    fileChunkSize?: number;
}
export interface SyncViewItem {
    id: string;
    store: string;
    _ver: number;
    deleted?: boolean;
    isAttachment?: boolean;
}
export interface DeletedItem extends Record<string, any> {
    id: string;
    _ver: number;
    deleted: boolean;
}
export interface DataChange<T = any> {
    id: string;
    _ver: number;
    data?: T;
}
export interface DataChangeSet {
    delete: Map<string, DataChange[]>;
    put: Map<string, DataChange[]>;
}
export declare class SyncView {
    private items;
    private storeIndex;
    constructor();
    upsert(item: SyncViewItem): void;
    upsertBatch(items: SyncViewItem[]): void;
    get(store: string, id: string): SyncViewItem | undefined;
    getByStore(store: string, offset?: number, limit?: number): SyncViewItem[];
    getStores(): string[];
    static diffViews(local: SyncView, remote: SyncView): {
        toDownload: SyncViewItem[];
        toUpload: SyncViewItem[];
    };
    private getKey;
    delete(store: string, id: string): void;
    size(): number;
    storeSize(store: string): number;
    clear(): void;
    countByStore(store: string, includeDeleted?: boolean): number;
}
export interface DatabaseAdapter {
    readStore<T extends {
        id: string;
    }>(storeName: string, limit?: number, offset?: number): Promise<{
        items: T[];
        hasMore: boolean;
    }>;
    readBulk<T extends {
        id: string;
    }>(storeName: string, ids: string[]): Promise<T[]>;
    putBulk<T extends {
        id: string;
    }>(storeName: string, items: T[]): Promise<T[]>;
    deleteBulk(storeName: string, ids: string[]): Promise<void>;
    clearStore(storeName: string): Promise<boolean>;
    getStores(): Promise<string[]>;
}
export interface ICoordinator {
    initSync?: () => Promise<void>;
    disposeSync?: () => Promise<void>;
    query<T extends {
        id: string;
    }>(storeName: string, options?: SyncQueryOptions): Promise<SyncQueryResult<T>>;
    getCurrentView(): Promise<SyncView>;
    readBulk<T extends {
        id: string;
    }>(storeName: string, ids: string[]): Promise<T[]>;
    putBulk<T extends {
        id: string;
    }>(storeName: string, items: T[]): Promise<T[]>;
    deleteBulk(storeName: string, ids: string[]): Promise<void>;
    extractChanges(items: SyncViewItem[]): Promise<DataChangeSet>;
    applyChanges(changeSet: DataChangeSet): Promise<void>;
}
export interface ISyncEngine {
    initialize(): Promise<void>;
    enableAutoSync(interval?: number): void;
    disableAutoSync(): void;
    updateSyncOptions(options: Partial<SyncOptions>): SyncOptions;
    setCloudAdapter(cloudAdapter: DatabaseAdapter): Promise<void>;
    save<T extends {
        id: string;
    }>(storeName: string, data: T | T[]): Promise<T[]>;
    delete(storeName: string, ids: string | string[]): Promise<void>;
    sync(): Promise<SyncResult>;
    push(): Promise<SyncResult>;
    pull(): Promise<SyncResult>;
    query<T extends {
        id: string;
    }>(storeName: string, options?: SyncQueryOptions): Promise<SyncQueryResult<T>>;
    clearCloudStores(strings: string | string[]): Promise<void>;
    clearLocalStores(strings: string | string[]): Promise<void>;
    getlocalAdapter(): DatabaseAdapter;
    getlocalCoordinator(): ICoordinator;
    getCloudAdapter(): DatabaseAdapter | undefined;
    getCloudCoordinator(): ICoordinator | undefined;
    dispose(): void;
    disconnectCloud(): void;
}