@rsweeten/dropbox-sync 0.1.0

package/src/core/auth.ts

@@ -0,0 +1,148 @@
+import { Dropbox } from 'dropbox'
+import type { AuthMethods, DropboxCredentials, TokenResponse } from './types'
+
+// Define missing types for Dropbox SDK
+interface DropboxAuthExtended {
+    getAuthenticationUrl(
+        redirectUri: string,
+        state: string,
+        authType?: string,
+        tokenAccessType?: string,
+        scope?: string | string[],
+        includeGrantedScopes?: string,
+        usePKCE?: boolean
+    ): string
+
+    getAccessTokenFromCode(
+        redirectUri: string,
+        code: string
+    ): Promise<{
+        result: {
+            access_token: string
+            refresh_token?: string
+            expires_in?: number
+        }
+    }>
+}
+
+export function createAuthMethods(
+    getClient: () => Dropbox,
+    credentials: DropboxCredentials,
+    setAccessToken: (token: string) => void
+): AuthMethods {
+    return {
+        /**
+         * Generate an authentication URL for Dropbox OAuth flow
+         */
+        async getAuthUrl(redirectUri: string, state?: string): Promise<string> {
+            const dropbox: any = getClient()
+            const randomState =
+                state || Math.random().toString(36).substring(2, 15)
+
+            // Cast to extended auth type to access missing methods
+            const auth = dropbox.auth as unknown as DropboxAuthExtended
+
+            // Generate the authentication URL
+            const authUrl = auth.getAuthenticationUrl(
+                redirectUri,
+                randomState,
+                'code', // Use authorization code flow
+                'offline', // Request a refresh token for long-lived access
+                undefined, // No scope specified, request full access
+                undefined, // No include_granted_scopes
+                true // Force reapproval to ensure we get fresh tokens
+            )
+
+            return authUrl
+        },
+
+        /**
+         * Exchange authorization code for access token
+         */
+        async exchangeCodeForToken(
+            code: string,
+            redirectUri: string
+        ): Promise<TokenResponse> {
+            const dropbox: any = getClient()
+            // Cast to extended auth type to access missing methods
+            const auth = dropbox.auth as unknown as DropboxAuthExtended
+
+            // Exchange the code for an access token
+            const response = await auth.getAccessTokenFromCode(
+                redirectUri,
+                code
+            )
+
+            const tokenResponse = {
+                accessToken: response.result.access_token,
+                refreshToken: response.result.refresh_token,
+                expiresAt: response.result.expires_in
+                    ? Date.now() + response.result.expires_in * 1000
+                    : undefined,
+            }
+
+            // Update the client with the new token
+            setAccessToken(tokenResponse.accessToken)
+
+            return tokenResponse
+        },
+
+        /**
+         * Refresh an expired access token using the refresh token
+         */
+        async refreshAccessToken(): Promise<TokenResponse> {
+            if (
+                !credentials.refreshToken ||
+                !credentials.clientId ||
+                !credentials.clientSecret
+            ) {
+                throw new Error(
+                    'Refresh token, client ID, and client secret are required to refresh access token'
+                )
+            }
+
+            // Dropbox API endpoint for token refresh
+            const tokenUrl = 'https://api.dropboxapi.com/oauth2/token'
+
+            // Prepare the form data for the token request
+            const formData = new URLSearchParams({
+                grant_type: 'refresh_token',
+                refresh_token: credentials.refreshToken,
+                client_id: credentials.clientId,
+                client_secret: credentials.clientSecret,
+            })
+
+            // Make the request to refresh the token
+            const response = await fetch(tokenUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: formData.toString(),
+            })
+
+            if (!response.ok) {
+                await response.text() // Consume the response body
+                throw new Error(
+                    `Failed to refresh token: ${response.status} ${response.statusText}`
+                )
+            }
+
+            // Parse the response
+            const data = await response.json()
+
+            const tokenResponse = {
+                accessToken: data.access_token,
+                refreshToken: data.refresh_token || credentials.refreshToken,
+                expiresAt: data.expires_in
+                    ? Date.now() + data.expires_in * 1000
+                    : undefined,
+            }
+
+            // Update the client with the new token
+            setAccessToken(tokenResponse.accessToken)
+
+            return tokenResponse
+        },
+    }
+}

package/src/core/client.ts

@@ -0,0 +1,52 @@
+import { Dropbox } from 'dropbox'
+import type {
+    DropboxCredentials,
+    DropboxSyncClient,
+    AuthMethods,
+    SyncMethods,
+    TokenResponse,
+    SocketMethods,
+} from './types'
+import { createAuthMethods } from './auth'
+import { createSyncMethods } from './sync'
+import { createSocketMethods } from './socket'
+
+/**
+ * Creates a Dropbox sync client with auth, sync, and socket methods
+ */
+export function createDropboxSyncClient(
+    credentials: DropboxCredentials
+): DropboxSyncClient {
+    let dropboxClient: Dropbox | null = null
+
+    function getClient(): Dropbox {
+        if (!dropboxClient) {
+            if (credentials.accessToken) {
+                dropboxClient = new Dropbox({
+                    accessToken: credentials.accessToken,
+                })
+            } else if (credentials.clientId) {
+                dropboxClient = new Dropbox({ clientId: credentials.clientId })
+            } else {
+                throw new Error(
+                    'Either clientId or accessToken must be provided'
+                )
+            }
+        }
+        return dropboxClient
+    }
+
+    function setAccessToken(token: string): void {
+        dropboxClient = new Dropbox({ accessToken: token })
+    }
+
+    const auth = createAuthMethods(getClient, credentials, setAccessToken)
+    const socket = createSocketMethods()
+    const sync = createSyncMethods(getClient, credentials, socket)
+
+    return {
+        auth,
+        sync,
+        socket,
+    }
+}

package/src/core/socket.ts

@@ -0,0 +1,73 @@
+import { io, Socket as IOSocket } from 'socket.io-client'
+import type { SocketMethods } from './types'
+
+export function createSocketMethods(): SocketMethods {
+    let socket: IOSocket | null = null
+    const handlers: Record<string, ((...args: any[]) => void)[]> = {}
+
+    return {
+        /**
+         * Establish a Socket.IO connection
+         */
+        connect() {
+            if (!socket) {
+                // Default connection to the server's base URL
+                const url =
+                    globalThis?.window?.location?.origin ||
+                    'http://localhost:3000'
+                socket = io(url)
+            }
+
+            if (socket && !socket.connected) {
+                socket.connect()
+            }
+        },
+
+        /**
+         * Disconnect the Socket.IO connection
+         */
+        disconnect() {
+            if (socket && socket.connected) {
+                socket.disconnect()
+            }
+        },
+
+        /**
+         * Listen for an event on the Socket.IO connection
+         */
+        on(event: string, handler: (...args: any[]) => void) {
+            if (!handlers[event]) {
+                handlers[event] = []
+            }
+            handlers[event].push(handler)
+
+            if (socket) {
+                socket.on(event, handler)
+            }
+        },
+
+        /**
+         * Remove listeners for an event on the Socket.IO connection
+         */
+        off(event: string) {
+            if (socket && handlers[event]) {
+                for (const handler of handlers[event]) {
+                    socket.off(event, handler)
+                }
+                delete handlers[event]
+            }
+        },
+
+        /**
+         * Emit an event on the Socket.IO connection
+         */
+        emit(event: string, ...args: any[]) {
+            if (socket) {
+                socket.emit(event, ...args)
+                return true
+            }
+
+            return false
+        },
+    }
+}