@gloablehive/celphone-wechat-plugin 1.0.0

package/dist/src/cache/saas-connector.js

@@ -0,0 +1,289 @@
+/**
+ * SAAS Connector - SAAS communication + offline fallback
+ *
+ * Features:
+ * - Health check for SAAS connectivity
+ * - Online/offline status tracking
+ * - Fallback to local cache when offline
+ * - Offline timeout alerts
+ * - Message queue for offline storage
+ */
+import { DEFAULT_SAAS_CONFIG, } from './types.js';
+/**
+ * SAAS Connector class
+ */
+export class SAASConnector {
+    config;
+    status;
+    statusCallbacks;
+    offlineTimeoutCallbacks;
+    healthCheckInterval;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_SAAS_CONFIG, ...config };
+        this.status = {
+            isOnline: false,
+            lastConnected: 0,
+            consecutiveFailures: 0,
+            offlineDuration: 0,
+        };
+        this.statusCallbacks = [];
+        this.offlineTimeoutCallbacks = [];
+    }
+    /**
+     * Start health check loop
+     */
+    startHealthCheck(intervalMs = 30000) {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+        }
+        // Initial check
+        this.checkHealth();
+        // Periodic check
+        this.healthCheckInterval = setInterval(() => {
+            this.checkHealth();
+        }, intervalMs);
+    }
+    /**
+     * Stop health check
+     */
+    stopHealthCheck() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+    }
+    /**
+     * Check SAAS health status
+     */
+    async checkHealth() {
+        try {
+            const response = await fetch(`${this.config.apiBaseUrl}/health`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.config.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                signal: AbortSignal.timeout(this.config.timeout),
+            });
+            const wasOnline = this.status.isOnline;
+            this.status.isOnline = response.ok;
+            this.status.lastConnected = response.ok ? Date.now() : this.status.lastConnected;
+            this.status.consecutiveFailures = response.ok ? 0 : this.status.consecutiveFailures + 1;
+            // Calculate offline duration
+            if (!this.status.isOnline && this.status.lastConnected > 0) {
+                this.status.offlineDuration = Date.now() - this.status.lastConnected;
+            }
+            else if (this.status.isOnline) {
+                this.status.offlineDuration = 0;
+            }
+            // Notify status change
+            if (wasOnline !== this.status.isOnline) {
+                this.notifyStatusChange();
+            }
+            // Check offline timeout
+            if (this.status.offlineDuration > this.config.offlineThreshold) {
+                this.notifyOfflineTimeout();
+            }
+            return response.ok;
+        }
+        catch (error) {
+            const wasOnline = this.status.isOnline;
+            this.status.isOnline = false;
+            this.status.consecutiveFailures++;
+            this.status.offlineDuration = this.status.lastConnected > 0
+                ? Date.now() - this.status.lastConnected
+                : this.config.offlineThreshold + 1;
+            if (wasOnline) {
+                this.notifyStatusChange();
+            }
+            if (this.status.offlineDuration > this.config.offlineThreshold) {
+                this.notifyOfflineTimeout();
+            }
+            return false;
+        }
+    }
+    /**
+     * Get current connection status
+     */
+    getConnectionStatus() {
+        return { ...this.status };
+    }
+    /**
+     * Check if online
+     */
+    isOnline() {
+        return this.status.isOnline;
+    }
+    // ========== Online: SAAS API calls ==========
+    /**
+     * Query user profile from SAAS
+     */
+    async queryUserProfile(userId) {
+        if (!this.status.isOnline) {
+            throw new Error('SAAS is offline');
+        }
+        try {
+            const response = await fetch(`${this.config.apiBaseUrl}/users/${userId}`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.config.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                signal: AbortSignal.timeout(this.config.timeout),
+            });
+            if (!response.ok) {
+                throw new Error(`SAAS API error: ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            this.status.consecutiveFailures++;
+            throw error;
+        }
+    }
+    /**
+     * Query order from SAAS
+     */
+    async queryOrder(orderId) {
+        if (!this.status.isOnline) {
+            throw new Error('SAAS is offline');
+        }
+        try {
+            const response = await fetch(`${this.config.apiBaseUrl}/orders/${orderId}`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.config.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                signal: AbortSignal.timeout(this.config.timeout),
+            });
+            if (!response.ok) {
+                throw new Error(`SAAS API error: ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            this.status.consecutiveFailures++;
+            throw error;
+        }
+    }
+    /**
+     * Sync message to SAAS
+     */
+    async syncMessage(msg) {
+        if (!this.status.isOnline) {
+            throw new Error('SAAS is offline');
+        }
+        try {
+            const response = await fetch(`${this.config.apiBaseUrl}/messages`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.config.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(msg),
+                signal: AbortSignal.timeout(this.config.timeout),
+            });
+            if (!response.ok) {
+                throw new Error(`SAAS API error: ${response.status}`);
+            }
+        }
+        catch (error) {
+            this.status.consecutiveFailures++;
+            throw error;
+        }
+    }
+    // ========== Offline: Fallback to local cache ==========
+    /**
+     * Query user profile from local cache (fallback)
+     */
+    async queryUserProfileOffline(userId, localCacheGetter) {
+        if (this.status.isOnline) {
+            // Online: try SAAS first, fallback to local
+            try {
+                return await this.queryUserProfile(userId);
+            }
+            catch {
+                // Fallback to local
+                return await localCacheGetter(userId);
+            }
+        }
+        // Offline: use local cache
+        return await localCacheGetter(userId);
+    }
+    /**
+     * Query order from local cache (fallback)
+     */
+    async queryOrderOffline(orderId, localCacheGetter) {
+        if (this.status.isOnline) {
+            try {
+                return await this.queryOrder(orderId);
+            }
+            catch {
+                return await localCacheGetter(orderId);
+            }
+        }
+        return await localCacheGetter(orderId);
+    }
+    /**
+     * Get offline message for user
+     */
+    getOfflineMessage() {
+        if (this.status.offlineDuration > this.config.offlineThreshold) {
+            return '抱歉，系统当前无法连接到后台服务，部分功能可能不可用。请稍后再试。';
+        }
+        return '您好，当前服务响应较慢，请稍等片刻。';
+    }
+    // ========== Event Callbacks ==========
+    /**
+     * Register status change callback
+     */
+    onStatusChange(callback) {
+        this.statusCallbacks.push(callback);
+    }
+    /**
+     * Register offline timeout callback
+     */
+    onOfflineTimeout(callback) {
+        this.offlineTimeoutCallbacks.push(callback);
+    }
+    /**
+     * Notify status change
+     */
+    notifyStatusChange() {
+        for (const callback of this.statusCallbacks) {
+            try {
+                callback(this.status);
+            }
+            catch (error) {
+                console.error('[SAASConnector] Status callback error:', error);
+            }
+        }
+    }
+    /**
+     * Notify offline timeout
+     */
+    notifyOfflineTimeout() {
+        for (const callback of this.offlineTimeoutCallbacks) {
+            try {
+                callback();
+            }
+            catch (error) {
+                console.error('[SAASConnector] Offline timeout callback error:', error);
+            }
+        }
+    }
+    /**
+     * Update config
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+}
+/**
+ * Create SAAS connector instance
+ */
+export function createSAASConnector(config) {
+    return new SAASConnector(config);
+}
+export { DEFAULT_SAAS_CONFIG };

package/dist/src/cache/syncer.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Cloud Syncer - Sync local cache to cloud database
+ *
+ * Local-first + periodic sync strategy:
+ * - Incremental sync based on lastSyncTimestamp
+ * - Full sync for initialization/recovery
+ */
+import { SyncConfig, SyncResult, SyncLog, WeChatMessage, UserProfile } from './types.js';
+/**
+ * Cloud Syncer class
+ */
+export declare class CloudSyncer {
+    private config;
+    private syncLogPath;
+    constructor(config: SyncConfig, syncLogPath: string);
+    /**
+     * Check if sync should run
+     */
+    shouldSync(): boolean;
+    /**
+     * Incremental sync - only sync new messages
+     */
+    syncIncremental(): Promise<SyncResult>;
+    /**
+     * Full sync - sync all data
+     */
+    syncFull(): Promise<SyncResult>;
+    /**
+     * Sync single message
+     */
+    syncMessage(message: WeChatMessage): Promise<void>;
+    /**
+     * Sync user profile
+     */
+    syncProfile(profile: UserProfile): Promise<void>;
+    /**
+     * Get unsynced messages from local cache
+     */
+    private getUnsyncedMessages;
+    /**
+     * Sync single record to database
+     */
+    private syncRecord;
+    /**
+     * Write sync log
+     */
+    private writeSyncLog;
+    /**
+     * Get sync logs
+     */
+    getSyncLogs(limit?: number): Promise<SyncLog[]>;
+    /**
+     * Test database connection
+     */
+    testConnection(): Promise<boolean>;
+}
+/**
+ * Create syncer instance
+ */
+export declare function createSyncer(config: SyncConfig, syncLogPath: string): CloudSyncer;

package/dist/src/cache/syncer.js

@@ -0,0 +1,177 @@
+/**
+ * Cloud Syncer - Sync local cache to cloud database
+ *
+ * Local-first + periodic sync strategy:
+ * - Incremental sync based on lastSyncTimestamp
+ * - Full sync for initialization/recovery
+ */
+const ENCODING = 'utf-8';
+/**
+ * Cloud Syncer class
+ */
+export class CloudSyncer {
+    config;
+    syncLogPath;
+    constructor(config, syncLogPath) {
+        this.config = config;
+        this.syncLogPath = syncLogPath;
+    }
+    /**
+     * Check if sync should run
+     */
+    shouldSync() {
+        if (this.config.syncMode === 'realtime')
+            return true;
+        if (this.config.syncMode === 'manual')
+            return false;
+        const now = Date.now();
+        return now - this.config.lastSyncTimestamp > this.config.syncIntervalMs;
+    }
+    /**
+     * Incremental sync - only sync new messages
+     */
+    async syncIncremental() {
+        const startTime = Date.now();
+        const log = {
+            id: `sync-${startTime}`,
+            syncType: 'incremental',
+            startedAt: startTime,
+            recordsCount: 0,
+            status: 'pending',
+        };
+        try {
+            // In real implementation, this would:
+            // 1. Read local messages since lastSyncTimestamp
+            // 2. Batch insert/update to database
+            // 3. Update lastSyncTimestamp
+            console.log('[Syncer] Running incremental sync since', new Date(this.config.lastSyncTimestamp));
+            // Placeholder: would query database
+            const records = await this.getUnsyncedMessages();
+            for (const record of records) {
+                await this.syncRecord(record);
+                log.recordsCount++;
+            }
+            // Update last sync timestamp
+            this.config.lastSyncTimestamp = startTime;
+            log.status = 'completed';
+            log.completedAt = Date.now();
+            await this.writeSyncLog(log);
+            return {
+                recordsSynced: log.recordsCount,
+                duration: log.completedAt - log.startedAt,
+                errors: [],
+            };
+        }
+        catch (error) {
+            log.status = 'failed';
+            log.error = error.message;
+            log.completedAt = Date.now();
+            await this.writeSyncLog(log);
+            return {
+                recordsSynced: log.recordsCount,
+                duration: log.completedAt - log.startedAt,
+                errors: [error.message],
+            };
+        }
+    }
+    /**
+     * Full sync - sync all data
+     */
+    async syncFull() {
+        const startTime = Date.now();
+        const log = {
+            id: `sync-full-${startTime}`,
+            syncType: 'full',
+            startedAt: startTime,
+            recordsCount: 0,
+            status: 'pending',
+        };
+        try {
+            // Would sync all messages, profiles, etc.
+            console.log('[Syncer] Running full sync');
+            // Placeholder implementation
+            log.status = 'completed';
+            log.completedAt = Date.now();
+            await this.writeSyncLog(log);
+            return {
+                recordsSynced: log.recordsCount,
+                duration: log.completedAt - log.startedAt,
+                errors: [],
+            };
+        }
+        catch (error) {
+            log.status = 'failed';
+            log.error = error.message;
+            log.completedAt = Date.now();
+            await this.writeSyncLog(log);
+            return {
+                recordsSynced: log.recordsCount,
+                duration: log.completedAt - log.startedAt,
+                errors: [error.message],
+            };
+        }
+    }
+    /**
+     * Sync single message
+     */
+    async syncMessage(message) {
+        // In real implementation, would insert into database
+        console.log('[Syncer] Syncing message:', message.messageId);
+    }
+    /**
+     * Sync user profile
+     */
+    async syncProfile(profile) {
+        // In real implementation, would upsert into database
+        console.log('[Syncer] Syncing profile:', profile.wechatId);
+    }
+    /**
+     * Get unsynced messages from local cache
+     */
+    async getUnsyncedMessages() {
+        // Placeholder: would read from local queue
+        return [];
+    }
+    /**
+     * Sync single record to database
+     */
+    async syncRecord(record) {
+        // Placeholder: would call database API
+    }
+    /**
+     * Write sync log
+     */
+    async writeSyncLog(log) {
+        // Placeholder: would write to sync-logs directory
+        console.log('[Syncer] Sync log:', log.id, log.status, log.recordsCount);
+    }
+    /**
+     * Get sync logs
+     */
+    async getSyncLogs(limit = 10) {
+        // Placeholder: would read from sync-logs directory
+        return [];
+    }
+    /**
+     * Test database connection
+     */
+    async testConnection() {
+        // Placeholder: would test database connectivity
+        try {
+            // In real implementation:
+            // const client = new Client({ connectionString: this.config.databaseUrl });
+            // await client.connect();
+            // await client.end();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+/**
+ * Create syncer instance
+ */
+export function createSyncer(config, syncLogPath) {
+    return new CloudSyncer(config, syncLogPath);
+}