@rsweeten/dropbox-sync 0.1.0

package/src/core/sync.ts

@@ -0,0 +1,476 @@
+import path from 'path'
+import fs from 'fs'
+import { Dropbox } from 'dropbox'
+import type {
+    DropboxCredentials,
+    SyncMethods,
+    SyncOptions,
+    SyncResult,
+    SyncProgress,
+    ProgressCallback,
+    SocketMethods,
+} from './types'
+
+// Define interface for Dropbox file entries
+interface DropboxFileEntry {
+    '.tag': string;
+    path_display?: string;
+    [key: string]: any;
+}
+
+// Define interface for Dropbox API responses
+interface DropboxListFolderResponse {
+    result: {
+        entries: DropboxFileEntry[];
+        has_more: boolean;
+        cursor: string;
+    };
+}
+
+interface DropboxDownloadResponse {
+    result: {
+        fileBlob?: Blob;
+        fileBinary?: string;
+        [key: string]: any;
+    };
+}
+
+export function createSyncMethods(
+    getClient: () => Dropbox,
+    credentials: DropboxCredentials,
+    socket: SocketMethods
+): SyncMethods {
+    let syncCancelled = false
+
+    /**
+     * Normalize path for consistent comparison between local and Dropbox paths
+     */
+    function normalizePath(filePath: string): string {
+        // Remove any leading slashes for consistency, then add a single leading slash
+        return '/' + filePath.replace(/^\/+/, '').toLowerCase()
+    }
+
+    /**
+     * Convert blob/buffer types to Buffer
+     */
+    async function blobToBuffer(data: any): Promise<Buffer> {
+        // If it's already a Buffer, return it directly
+        if (Buffer.isBuffer(data)) {
+            return data
+        }
+
+        // If it's a Blob, convert it to a Buffer
+        if (typeof Blob !== 'undefined' && data instanceof Blob) {
+            const arrayBuffer = await data.arrayBuffer()
+            return Buffer.from(arrayBuffer)
+        }
+
+        // If it's a plain ArrayBuffer
+        if (data instanceof ArrayBuffer) {
+            return Buffer.from(data)
+        }
+
+        // If it's a string
+        if (typeof data === 'string') {
+            return Buffer.from(data)
+        }
+
+        // If we don't know what it is, throw an error
+        throw new Error(`Unsupported data type: ${typeof data}`)
+    }
+
+    /**
+     * Recursively scan local directory for files to sync
+     */
+    async function scanLocalDirectory(
+        dir: string,
+        baseDir = ''
+    ): Promise<string[]> {
+        const files: string[] = []
+
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true })
+
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name)
+                const relativePath = path.join(baseDir, entry.name)
+
+                if (entry.isDirectory()) {
+                    files.push(
+                        ...(await scanLocalDirectory(fullPath, relativePath))
+                    )
+                } else if (
+                    /\.(jpg|jpeg|png|gif|bmp|webp|svg|json)$/i.test(entry.name)
+                ) {
+                    // Only include image files by default
+                    files.push('/' + relativePath.replace(/\\/g, '/'))
+                }
+            }
+        } catch (error) {
+            console.error(`Error scanning directory ${dir}:`, error)
+        }
+
+        return files
+    }
+
+    /**
+     * Recursively scan Dropbox folder for files
+     */
+    async function scanDropboxFolder(
+        dropboxPath: string = ''
+    ): Promise<string[]> {
+        const dropbox = getClient()
+        const files: string[] = []
+
+        async function fetchFolderContents(path: string) {
+            try {
+                const response = await dropbox.filesListFolder({
+                    path,
+                    recursive: true,
+                }) as unknown as DropboxListFolderResponse
+
+                for (const entry of response.result.entries) {
+                    if (
+                        entry['.tag'] === 'file' &&
+                        entry.path_display &&
+                        /\.(jpg|jpeg|png|gif|bmp|webp|svg|json)$/i.test(
+                            entry.path_display
+                        )
+                    ) {
+                        files.push(entry.path_display)
+                    }
+                }
+
+                if (response.result.has_more) {
+                    await continueListing(response.result.cursor)
+                }
+            } catch (error) {
+                console.error('Error fetching Dropbox folder contents:', error)
+                throw error
+            }
+        }
+
+        async function continueListing(cursor: string) {
+            const response = await dropbox.filesListFolderContinue({
+                cursor: cursor,
+            }) as unknown as DropboxListFolderResponse
+
+            for (const entry of response.result.entries) {
+                if (
+                    entry['.tag'] === 'file' &&
+                    entry.path_display &&
+                    /\.(jpg|jpeg|png|gif|bmp|webp|svg|json)$/i.test(
+                        entry.path_display
+                    )
+                ) {
+                    files.push(entry.path_display)
+                }
+            }
+
+            if (response.result.has_more) {
+                await continueListing(response.result.cursor)
+            }
+        }
+
+        await fetchFolderContents(dropboxPath)
+        return files
+    }
+
+    return {
+        /**
+         * Scan local directory for files
+         */
+        async scanLocalFiles(dir?: string): Promise<string[]> {
+            if (!dir && typeof window === 'undefined') {
+                throw new Error(
+                    'Local directory must be provided in Node.js environment'
+                )
+            }
+
+            const localDir = dir || path.join(process.cwd(), 'public', 'img')
+            return scanLocalDirectory(localDir)
+        },
+
+        /**
+         * Scan Dropbox folder for files
+         */
+        async scanDropboxFiles(dir?: string): Promise<string[]> {
+            const dropboxDir = dir || ''
+            return scanDropboxFolder(dropboxDir)
+        },
+
+        /**
+         * Compare local and Dropbox files and create a sync queue
+         */
+        async createSyncQueue(
+            options?: Partial<SyncOptions>
+        ): Promise<{ uploadQueue: string[]; downloadQueue: string[] }> {
+            const localDir =
+                options?.localDir || path.join(process.cwd(), 'public', 'img')
+            const dropboxDir = options?.dropboxDir || ''
+
+            const localFiles = await scanLocalDirectory(localDir)
+            const dropboxFiles = await scanDropboxFolder(dropboxDir)
+
+            // Normalize paths for comparison
+            const normalizedDropboxFiles = dropboxFiles.map(normalizePath)
+            const normalizedLocalFiles = localFiles.map(normalizePath)
+
+            // Files to upload (in local but not in Dropbox)
+            const uploadQueue = localFiles.filter((localFile) => {
+                const normalizedLocalFile = normalizePath(localFile)
+                return !normalizedDropboxFiles.includes(normalizedLocalFile)
+            })
+
+            // Files to download (in Dropbox but not in local)
+            const downloadQueue = dropboxFiles.filter((dropboxFile) => {
+                const normalizedDropboxFile = normalizePath(dropboxFile)
+                return !normalizedLocalFiles.includes(normalizedDropboxFile)
+            })
+
+            return { uploadQueue, downloadQueue }
+        },
+
+        /**
+         * Synchronize files between local filesystem and Dropbox
+         */
+        async syncFiles(options?: Partial<SyncOptions>): Promise<SyncResult> {
+            const localDir =
+                options?.localDir || path.join(process.cwd(), 'public', 'img')
+            const dropboxDir = options?.dropboxDir || ''
+            const progressCallback = options?.progressCallback
+
+            syncCancelled = false
+            const result: SyncResult = {
+                uploaded: [],
+                downloaded: [],
+                errors: [],
+            }
+
+            // Report initial progress
+            const reportProgress = (progress: SyncProgress) => {
+                if (progressCallback) {
+                    progressCallback(progress)
+                }
+
+                // Also emit via Socket.IO if available
+                if (progress.progress !== undefined && progress.message) {
+                    socket.emit('sync:progress', {
+                        type: progress.type || 'progress',
+                        message: progress.message,
+                        progress: progress.progress,
+                        socketId: 'dropbox-sync-module',
+                    })
+                }
+            }
+
+            reportProgress({
+                stage: 'init',
+                progress: 0,
+                message: 'Starting Dropbox synchronization',
+            })
+
+            try {
+                // Get the Dropbox client
+                const dropbox = getClient()
+
+                // Get files to sync
+                reportProgress({
+                    stage: 'listing',
+                    message: 'Analyzing files to sync...',
+                    progress: 0,
+                })
+
+                const { uploadQueue, downloadQueue } =
+                    await this.createSyncQueue({ localDir, dropboxDir })
+                const totalTasks = uploadQueue.length + downloadQueue.length
+
+                // Socket notification about queue
+                socket.emit('sync:queue', {
+                    total: totalTasks,
+                    totalUploads: uploadQueue.length,
+                    totalDownloads: downloadQueue.length,
+                })
+
+                if (totalTasks === 0) {
+                    reportProgress({
+                        stage: 'complete',
+                        progress: 100,
+                        message: 'All files are already in sync',
+                    })
+
+                    socket.emit('sync:complete', {
+                        message: 'All files are already in sync',
+                    })
+
+                    return result
+                }
+
+                let completedTasks = 0
+
+                // Upload files to Dropbox
+                for (const file of uploadQueue) {
+                    if (syncCancelled) {
+                        break
+                    }
+
+                    try {
+                        reportProgress({
+                            stage: 'processing',
+                            type: 'upload',
+                            current: completedTasks + 1,
+                            total: totalTasks,
+                            progress: Math.round(
+                                (completedTasks / totalTasks) * 100
+                            ),
+                            message: `Uploading: ${file}`,
+                            item: file,
+                        })
+
+                        // Upload logic
+                        const localFilePath = path.join(
+                            localDir,
+                            file.replace(/^\/+/, '')
+                        )
+                        const dropboxFilePath = '/' + file.replace(/^\/+/, '')
+                        const fileContent = fs.readFileSync(localFilePath)
+
+                        await dropbox.filesUpload({
+                            path: dropboxFilePath,
+                            contents: fileContent,
+                            mode: { '.tag': 'overwrite' },
+                        })
+
+                        result.uploaded.push(file)
+                        completedTasks++
+                    } catch (error) {
+                        result.errors.push({ file, error: error as Error })
+                        console.error(`Error uploading file ${file}:`, error)
+                    }
+                }
+
+                // Download files from Dropbox
+                for (const file of downloadQueue) {
+                    if (syncCancelled) {
+                        break
+                    }
+
+                    try {
+                        reportProgress({
+                            stage: 'processing',
+                            type: 'download',
+                            current: completedTasks + 1,
+                            total: totalTasks,
+                            progress: Math.round(
+                                (completedTasks / totalTasks) * 100
+                            ),
+                            message: `Downloading: ${file}`,
+                            item: file,
+                        })
+
+                        // Download logic
+                        const dropboxFilePath = file
+                        const localRelativePath = file.replace(/^\/+/, '')
+                        const localFilePath = path.join(
+                            localDir,
+                            localRelativePath
+                        )
+
+                        // Download the file from Dropbox with proper error handling
+                        const response = await dropbox.filesDownload({
+                            path: dropboxFilePath,
+                        }) as unknown as DropboxDownloadResponse
+
+                        // Get file content - handle different possible response formats
+                        let fileContent: Buffer;
+                        const responseResult = response.result;
+
+                        if (responseResult.fileBlob) {
+                            fileContent = await blobToBuffer(responseResult.fileBlob)
+                        } else if (responseResult.fileBinary) {
+                            fileContent = Buffer.from(
+                                responseResult.fileBinary,
+                                'binary'
+                            )
+                        } else {
+                            // For Node.js environment, Dropbox might return content in different properties
+                            const contentKey = Object.keys(responseResult).find(
+                                (key) => ['content', 'fileContent', 'file', 'data'].includes(key)
+                            )
+
+                            if (contentKey) {
+                                fileContent = Buffer.from(responseResult[contentKey])
+                            } else {
+                                throw new Error(
+                                    `Could not find file content in Dropbox response for ${dropboxFilePath}`
+                                )
+                            }
+                        }
+
+                        // Create directory if it doesn't exist
+                        const dirPath = path.dirname(localFilePath)
+                        if (!fs.existsSync(dirPath)) {
+                            fs.mkdirSync(dirPath, { recursive: true })
+                        }
+
+                        // Write the file to disk
+                        fs.writeFileSync(localFilePath, fileContent)
+
+                        result.downloaded.push(file)
+                        completedTasks++
+                    } catch (error) {
+                        result.errors.push({ file, error: error as Error })
+                        console.error(`Error downloading file ${file}:`, error)
+
+                        // Emit error but continue with the next file
+                        socket.emit('sync:error', {
+                            message: `Error downloading ${file}: ${
+                                (error as Error).message
+                            }`,
+                            continue: true,
+                        })
+                    }
+                }
+
+                // Report completion
+                reportProgress({
+                    stage: 'complete',
+                    progress: 100,
+                    message: 'Synchronization completed successfully',
+                })
+
+                // Sync complete notification
+                socket.emit('sync:complete', {
+                    message: 'Synchronization completed successfully',
+                    stats: {
+                        uploaded: result.uploaded.length,
+                        downloaded: result.downloaded.length,
+                    },
+                })
+            } catch (error) {
+                reportProgress({
+                    stage: 'error',
+                    message: `Error: ${(error as Error).message}`,
+                })
+
+                // Emit error notification
+                socket.emit('sync:error', {
+                    message: (error as Error).message,
+                })
+
+                // Re-throw the error for handling by the caller
+                throw error
+            }
+
+            return result
+        },
+
+        /**
+         * Cancel an ongoing synchronization
+         */
+        cancelSync() {
+            syncCancelled = true
+            socket.emit('sync:cancel', {})
+        },
+    }
+}

package/src/core/types.ts

@@ -0,0 +1,83 @@
+export interface DropboxCredentials {
+    clientId: string
+    clientSecret?: string
+    accessToken?: string
+    refreshToken?: string
+}
+
+export interface SyncOptions {
+    localDir: string
+    dropboxDir?: string
+    fileTypes?: RegExp
+    progressCallback?: ProgressCallback
+}
+
+export interface SyncResult {
+    uploaded: string[]
+    downloaded: string[]
+    errors: { file: string; error: Error }[]
+}
+
+export interface SyncProgress {
+    stage: 'init' | 'listing' | 'processing' | 'complete' | 'error'
+    current?: number
+    total?: number
+    message?: string
+    item?: string
+    progress?: number
+    type?: 'upload' | 'download'
+}
+
+export type ProgressCallback = (progress: SyncProgress) => void
+
+export interface SyncActivity {
+    type: 'upload' | 'download'
+    file: string
+    timestamp: number
+}
+
+export interface SyncStats {
+    total: number
+    uploads: number
+    downloads: number
+    completed: number
+}
+
+export interface TokenResponse {
+    accessToken: string
+    refreshToken?: string
+    expiresAt?: number
+}
+
+export interface AuthMethods {
+    getAuthUrl(redirectUri: string, state?: string): Promise<string>
+    exchangeCodeForToken(
+        code: string,
+        redirectUri: string
+    ): Promise<TokenResponse>
+    refreshAccessToken(): Promise<TokenResponse>
+}
+
+export interface SyncMethods {
+    scanLocalFiles(dir?: string): Promise<string[]>
+    scanDropboxFiles(dir?: string): Promise<string[]>
+    createSyncQueue(
+        options?: Partial<SyncOptions>
+    ): Promise<{ uploadQueue: string[]; downloadQueue: string[] }>
+    syncFiles(options?: Partial<SyncOptions>): Promise<SyncResult>
+    cancelSync(): void
+}
+
+export interface SocketMethods {
+    connect(): void
+    disconnect(): void
+    on(event: string, handler: (...args: any[]) => void): void
+    off(event: string): void
+    emit(event: string, ...args: any[]): void
+}
+
+export interface DropboxSyncClient {
+    auth: AuthMethods
+    sync: SyncMethods
+    socket: SocketMethods
+}

package/src/index.ts

@@ -0,0 +1,32 @@
+// Export all core types and functionality
+export * from './core/types'
+export * from './core/auth'
+export * from './core/client'
+export * from './core/sync'
+export * from './core/socket'
+
+// Export framework-specific adapters with renamed exports to avoid conflicts
+export {
+    useNextDropboxSync,
+    createNextDropboxApiHandlers,
+    handleOAuthCallback as handleNextOAuthCallback,
+    getCredentialsFromCookies as getNextCredentialsFromCookies,
+} from './adapters/next'
+
+export {
+    useSvelteDropboxSync,
+    createSvelteKitHandlers,
+    getCredentialsFromCookies as getSvelteCredentialsFromCookies,
+} from './adapters/svelte'
+
+export {
+    useNuxtDropboxSync,
+    createNuxtApiHandlers,
+    getCredentialsFromCookies as getNuxtCredentialsFromCookies,
+} from './adapters/nuxt'
+
+export * from './adapters/angular'
+
+// Export default client creator function
+import { createDropboxSyncClient } from './core/client'
+export default createDropboxSyncClient

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "strict": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "lib": ["DOM", "ESNext"],
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "examples", "**/*.test.ts"]
+}