@rsweeten/dropbox-sync 0.1.0

package/dist/adapters/next.js

@@ -0,0 +1,120 @@
+import { createDropboxSyncClient } from '../core/client';
+import { cookies } from 'next/headers';
+import { NextResponse } from 'next/server';
+/**
+ * Next.js-specific helper to create a Dropbox sync client
+ * Can be used in both client and server components
+ */
+export function useNextDropboxSync(credentials) {
+    return createDropboxSyncClient(credentials);
+}
+/**
+ * Server-side helper to get credentials from Next.js cookies
+ */
+export async function getCredentialsFromCookies() {
+    const cookieStore = await cookies();
+    return {
+        clientId: process.env.DROPBOX_APP_KEY || '',
+        clientSecret: process.env.DROPBOX_APP_SECRET,
+        accessToken: cookieStore.get('dropbox_access_token')?.value,
+        refreshToken: cookieStore.get('dropbox_refresh_token')?.value,
+    };
+}
+/**
+ * Server action to handle Dropbox OAuth callback
+ */
+export async function handleOAuthCallback(request) {
+    const url = new URL(request.url);
+    const code = url.searchParams.get('code');
+    if (!code) {
+        return NextResponse.redirect(new URL('/auth/error', request.url));
+    }
+    const redirectUri = process.env.DROPBOX_REDIRECT_URI ||
+        `${process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000'}/api/dropbox/auth/callback`;
+    const dropboxSync = createDropboxSyncClient({
+        clientId: process.env.DROPBOX_APP_KEY || '',
+        clientSecret: process.env.DROPBOX_APP_SECRET,
+    });
+    try {
+        const tokens = await dropboxSync.auth.exchangeCodeForToken(code, redirectUri);
+        // Create response with redirect
+        const response = NextResponse.redirect(new URL('/', request.url));
+        // Set cookies with the tokens
+        response.cookies.set({
+            name: 'dropbox_access_token',
+            value: tokens.accessToken,
+            httpOnly: true,
+            secure: process.env.NODE_ENV === 'production',
+            maxAge: tokens.expiresAt
+                ? (tokens.expiresAt - Date.now()) / 1000
+                : 14 * 24 * 60 * 60, // 14 days default
+            sameSite: 'lax',
+            path: '/',
+        });
+        if (tokens.refreshToken) {
+            response.cookies.set({
+                name: 'dropbox_refresh_token',
+                value: tokens.refreshToken,
+                httpOnly: true,
+                secure: process.env.NODE_ENV === 'production',
+                maxAge: 365 * 24 * 60 * 60, // 1 year
+                sameSite: 'lax',
+                path: '/',
+            });
+        }
+        // Set a non-httpOnly cookie to indicate connection status to the client
+        response.cookies.set({
+            name: 'dropbox_connected',
+            value: 'true',
+            secure: process.env.NODE_ENV === 'production',
+            maxAge: tokens.expiresAt
+                ? (tokens.expiresAt - Date.now()) / 1000
+                : 14 * 24 * 60 * 60,
+            sameSite: 'lax',
+            path: '/',
+        });
+        return response;
+    }
+    catch (error) {
+        console.error('Error completing Dropbox OAuth flow:', error);
+        return NextResponse.redirect(new URL('/auth/error', request.url));
+    }
+}
+/**
+ * Create API route handlers for a Next.js app
+ */
+export function createNextDropboxApiHandlers() {
+    return {
+        /**
+         * Handler for status check route
+         */
+        async status() {
+            const cookieStore = await cookies();
+            const isConnected = !!cookieStore.get('dropbox_access_token')?.value;
+            return NextResponse.json({ connected: isConnected });
+        },
+        /**
+         * Handler for OAuth start route
+         */
+        async oauthStart() {
+            const dropboxSync = createDropboxSyncClient({
+                clientId: process.env.DROPBOX_APP_KEY || '',
+            });
+            const redirectUri = process.env.DROPBOX_REDIRECT_URI ||
+                `${process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000'}/api/dropbox/auth/callback`;
+            const authUrl = await dropboxSync.auth.getAuthUrl(redirectUri);
+            return NextResponse.redirect(authUrl);
+        },
+        /**
+         * Handler for logout route
+         */
+        async logout() {
+            const response = NextResponse.json({ success: true });
+            // Clear all Dropbox-related cookies
+            response.cookies.delete('dropbox_access_token');
+            response.cookies.delete('dropbox_refresh_token');
+            response.cookies.delete('dropbox_connected');
+            return response;
+        },
+    };
+}

package/dist/adapters/nuxt.d.ts

@@ -0,0 +1,36 @@
+import type { DropboxCredentials, DropboxSyncClient } from '../core/types';
+import type { H3Event } from 'h3';
+/**
+ * Nuxt-specific helper for creating a Dropbox sync client
+ * Can be used in both client and server components
+ */
+export declare function useNuxtDropboxSync(credentials?: Partial<DropboxCredentials>): DropboxSyncClient;
+/**
+ * Server-side helper to get credentials from Nuxt server event
+ */
+export declare function getCredentialsFromCookies(event: H3Event): DropboxCredentials;
+/**
+ * Create API event handlers for a Nuxt app
+ */
+export declare function createNuxtApiHandlers(): {
+    /**
+     * Handler for status check endpoint
+     */
+    status(event: H3Event): Promise<{
+        connected: boolean;
+    }>;
+    /**
+     * Handler for OAuth start endpoint
+     */
+    oauthStart(event: H3Event): Promise<any>;
+    /**
+     * Handler for OAuth callback endpoint
+     */
+    oauthCallback(event: H3Event): Promise<any>;
+    /**
+     * Handler for logout endpoint
+     */
+    logout(event: H3Event): Promise<{
+        success: boolean;
+    }>;
+};

package/dist/adapters/nuxt.js

@@ -0,0 +1,190 @@
+import { createDropboxSyncClient } from '../core/client';
+import { useCookie, useRuntimeConfig } from 'nuxt/app';
+/**
+ * Helper to safely access runtime config properties
+ */
+function getConfigValue(obj, path, defaultValue) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === undefined || current === null) {
+            return defaultValue;
+        }
+        current = current[part];
+    }
+    return current || defaultValue;
+}
+/**
+ * Nuxt-specific helper for creating a Dropbox sync client
+ * Can be used in both client and server components
+ */
+export function useNuxtDropboxSync(credentials) {
+    // Get Nuxt runtime config (for client ID and secret)
+    const config = useRuntimeConfig();
+    // Create base credentials with defaults from runtime config
+    const baseCredentials = {
+        clientId: getConfigValue(config, 'public.dropboxAppKey', ''),
+        clientSecret: getConfigValue(config, 'dropboxAppSecret', ''),
+        ...credentials,
+    };
+    // On client-side, attempt to get tokens from cookies
+    if (process.client) {
+        const accessToken = useCookie('dropbox_access_token');
+        const refreshToken = useCookie('dropbox_refresh_token');
+        if (accessToken.value && !baseCredentials.accessToken) {
+            baseCredentials.accessToken = accessToken.value;
+        }
+        if (refreshToken.value && !baseCredentials.refreshToken) {
+            baseCredentials.refreshToken = refreshToken.value;
+        }
+    }
+    return createDropboxSyncClient(baseCredentials);
+}
+/**
+ * Server-side helper to get credentials from Nuxt server event
+ */
+export function getCredentialsFromCookies(event) {
+    const config = useRuntimeConfig();
+    // Get cookies from Nuxt server event
+    const accessToken = getCookie(event, 'dropbox_access_token');
+    const refreshToken = getCookie(event, 'dropbox_refresh_token');
+    return {
+        clientId: getConfigValue(config, 'public.dropboxAppKey', ''),
+        clientSecret: getConfigValue(config, 'dropboxAppSecret', ''),
+        accessToken,
+        refreshToken,
+    };
+}
+/**
+ * Create API event handlers for a Nuxt app
+ */
+export function createNuxtApiHandlers() {
+    return {
+        /**
+         * Handler for status check endpoint
+         */
+        async status(event) {
+            const accessToken = getCookie(event, 'dropbox_access_token');
+            const isConnected = !!accessToken;
+            return { connected: isConnected };
+        },
+        /**
+         * Handler for OAuth start endpoint
+         */
+        async oauthStart(event) {
+            const config = useRuntimeConfig();
+            const dropboxSync = createDropboxSyncClient({
+                clientId: getConfigValue(config, 'public.dropboxAppKey', ''),
+            });
+            const redirectUri = getConfigValue(config, 'dropboxRedirectUri', '') ||
+                `${getConfigValue(config, 'public.appUrl', 'http://localhost:3000')}/api/dropbox/auth/callback`;
+            const authUrl = await dropboxSync.auth.getAuthUrl(redirectUri);
+            return sendRedirect(event, authUrl);
+        },
+        /**
+         * Handler for OAuth callback endpoint
+         */
+        async oauthCallback(event) {
+            const config = useRuntimeConfig();
+            // Get the authorization code from query parameters
+            const query = getQuery(event);
+            const code = query.code;
+            if (!code) {
+                return sendRedirect(event, '/auth/error');
+            }
+            const redirectUri = getConfigValue(config, 'dropboxRedirectUri', '') ||
+                `${getConfigValue(config, 'public.appUrl', 'http://localhost:3000')}/api/dropbox/auth/callback`;
+            const dropboxSync = createDropboxSyncClient({
+                clientId: getConfigValue(config, 'public.dropboxAppKey', ''),
+                clientSecret: getConfigValue(config, 'dropboxAppSecret', ''),
+            });
+            try {
+                const tokens = await dropboxSync.auth.exchangeCodeForToken(code, redirectUri);
+                // Set cookies with the tokens
+                setCookie(event, 'dropbox_access_token', tokens.accessToken, {
+                    httpOnly: true,
+                    secure: process.env.NODE_ENV === 'production',
+                    maxAge: tokens.expiresAt
+                        ? Math.floor((tokens.expiresAt - Date.now()) / 1000)
+                        : 14 * 24 * 60 * 60, // 14 days default
+                    sameSite: 'lax',
+                    path: '/',
+                });
+                if (tokens.refreshToken) {
+                    setCookie(event, 'dropbox_refresh_token', tokens.refreshToken, {
+                        httpOnly: true,
+                        secure: process.env.NODE_ENV === 'production',
+                        maxAge: 365 * 24 * 60 * 60, // 1 year
+                        sameSite: 'lax',
+                        path: '/',
+                    });
+                }
+                // Set a non-httpOnly cookie to indicate connection status to the client
+                setCookie(event, 'dropbox_connected', 'true', {
+                    secure: process.env.NODE_ENV === 'production',
+                    maxAge: tokens.expiresAt
+                        ? Math.floor((tokens.expiresAt - Date.now()) / 1000)
+                        : 14 * 24 * 60 * 60,
+                    sameSite: 'lax',
+                    path: '/',
+                });
+                return sendRedirect(event, '/');
+            }
+            catch (error) {
+                console.error('Error completing Dropbox OAuth flow:', error);
+                return sendRedirect(event, '/auth/error');
+            }
+        },
+        /**
+         * Handler for logout endpoint
+         */
+        async logout(event) {
+            // Clear all Dropbox-related cookies
+            deleteCookie(event, 'dropbox_access_token');
+            deleteCookie(event, 'dropbox_refresh_token');
+            deleteCookie(event, 'dropbox_connected');
+            return { success: true };
+        },
+    };
+}
+/**
+ * Helper functions to work with Nuxt's H3Event
+ * These import statements need to be added to avoid reference errors
+ */
+const { getCookie, setCookie, deleteCookie } = useNuxtCookies();
+const { getQuery, sendRedirect } = useNuxtServer();
+/**
+ * Helper to access h3 cookie methods
+ */
+function useNuxtCookies() {
+    return {
+        getCookie: (event, name) => {
+            // Import inside function to avoid module loading issues
+            const { getCookie } = require('h3');
+            return getCookie(event, name);
+        },
+        setCookie: (event, name, value, options) => {
+            const { setCookie } = require('h3');
+            return setCookie(event, name, value, options);
+        },
+        deleteCookie: (event, name, options) => {
+            const { deleteCookie } = require('h3');
+            return deleteCookie(event, name, { ...options, path: '/' });
+        },
+    };
+}
+/**
+ * Helper to access h3 server methods
+ */
+function useNuxtServer() {
+    return {
+        getQuery: (event) => {
+            const { getQuery } = require('h3');
+            return getQuery(event);
+        },
+        sendRedirect: (event, location) => {
+            const { sendRedirect } = require('h3');
+            return sendRedirect(event, location);
+        },
+    };
+}

package/dist/adapters/svelte.d.ts

@@ -0,0 +1,39 @@
+import type { DropboxCredentials, DropboxSyncClient } from '../core/types';
+import type { Cookies } from '@sveltejs/kit';
+/**
+ * SvelteKit-specific helper for creating a Dropbox sync client
+ * Can be used in both client and server contexts
+ */
+export declare function useSvelteDropboxSync(credentials: DropboxCredentials): DropboxSyncClient;
+/**
+ * Helper to get credentials from SvelteKit cookies
+ */
+export declare function getCredentialsFromCookies(cookies: Cookies): DropboxCredentials;
+/**
+ * Create server-side handlers for SvelteKit
+ */
+export declare function createSvelteKitHandlers(): {
+    /**
+     * Handler for status check endpoint
+     */
+    status({ cookies }: {
+        cookies: Cookies;
+    }): Promise<Response>;
+    /**
+     * Handler for OAuth start endpoint
+     */
+    oauthStart(): Promise<Response>;
+    /**
+     * Handler for OAuth callback endpoint
+     */
+    oauthCallback({ url, cookies }: {
+        url: URL;
+        cookies: Cookies;
+    }): Promise<Response>;
+    /**
+     * Handler for logout endpoint
+     */
+    logout({ cookies }: {
+        cookies: Cookies;
+    }): Promise<Response>;
+};

package/dist/adapters/svelte.js

@@ -0,0 +1,134 @@
+import { createDropboxSyncClient } from '../core/client';
+/**
+ * SvelteKit-specific helper for creating a Dropbox sync client
+ * Can be used in both client and server contexts
+ */
+export function useSvelteDropboxSync(credentials) {
+    return createDropboxSyncClient(credentials);
+}
+/**
+ * Helper to get credentials from SvelteKit cookies
+ */
+export function getCredentialsFromCookies(cookies) {
+    return {
+        clientId: process.env.DROPBOX_APP_KEY || '',
+        clientSecret: process.env.DROPBOX_APP_SECRET,
+        accessToken: cookies.get('dropbox_access_token'),
+        refreshToken: cookies.get('dropbox_refresh_token'),
+    };
+}
+/**
+ * Create server-side handlers for SvelteKit
+ */
+export function createSvelteKitHandlers() {
+    return {
+        /**
+         * Handler for status check endpoint
+         */
+        async status({ cookies }) {
+            const isConnected = !!cookies.get('dropbox_access_token');
+            return new Response(JSON.stringify({ connected: isConnected }), {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        },
+        /**
+         * Handler for OAuth start endpoint
+         */
+        async oauthStart() {
+            const dropboxSync = createDropboxSyncClient({
+                clientId: process.env.DROPBOX_APP_KEY || '',
+            });
+            const redirectUri = process.env.DROPBOX_REDIRECT_URI ||
+                `${process.env.PUBLIC_APP_URL || 'http://localhost:5173'}/api/dropbox/auth/callback`;
+            const authUrl = await dropboxSync.auth.getAuthUrl(redirectUri);
+            return new Response(null, {
+                status: 302,
+                headers: {
+                    Location: authUrl,
+                },
+            });
+        },
+        /**
+         * Handler for OAuth callback endpoint
+         */
+        async oauthCallback({ url, cookies }) {
+            const code = url.searchParams.get('code');
+            if (!code) {
+                return new Response(null, {
+                    status: 302,
+                    headers: {
+                        Location: '/auth/error',
+                    },
+                });
+            }
+            const redirectUri = process.env.DROPBOX_REDIRECT_URI ||
+                `${process.env.PUBLIC_APP_URL || 'http://localhost:5173'}/api/dropbox/auth/callback`;
+            const dropboxSync = createDropboxSyncClient({
+                clientId: process.env.DROPBOX_APP_KEY || '',
+                clientSecret: process.env.DROPBOX_APP_SECRET,
+            });
+            try {
+                const tokens = await dropboxSync.auth.exchangeCodeForToken(code, redirectUri);
+                // Set cookies with the tokens
+                cookies.set('dropbox_access_token', tokens.accessToken, {
+                    path: '/',
+                    httpOnly: true,
+                    secure: process.env.NODE_ENV === 'production',
+                    maxAge: tokens.expiresAt
+                        ? Math.floor((tokens.expiresAt - Date.now()) / 1000)
+                        : 14 * 24 * 60 * 60, // 14 days default
+                    sameSite: 'lax',
+                });
+                if (tokens.refreshToken) {
+                    cookies.set('dropbox_refresh_token', tokens.refreshToken, {
+                        path: '/',
+                        httpOnly: true,
+                        secure: process.env.NODE_ENV === 'production',
+                        maxAge: 365 * 24 * 60 * 60, // 1 year
+                        sameSite: 'lax',
+                    });
+                }
+                cookies.set('dropbox_connected', 'true', {
+                    path: '/',
+                    secure: process.env.NODE_ENV === 'production',
+                    maxAge: tokens.expiresAt
+                        ? Math.floor((tokens.expiresAt - Date.now()) / 1000)
+                        : 14 * 24 * 60 * 60,
+                    sameSite: 'lax',
+                });
+                return new Response(null, {
+                    status: 302,
+                    headers: {
+                        Location: '/',
+                    },
+                });
+            }
+            catch (error) {
+                console.error('Error completing Dropbox OAuth flow:', error);
+                return new Response(null, {
+                    status: 302,
+                    headers: {
+                        Location: '/auth/error',
+                    },
+                });
+            }
+        },
+        /**
+         * Handler for logout endpoint
+         */
+        async logout({ cookies }) {
+            cookies.delete('dropbox_access_token', { path: '/' });
+            cookies.delete('dropbox_refresh_token', { path: '/' });
+            cookies.delete('dropbox_connected', { path: '/' });
+            return new Response(JSON.stringify({ success: true }), {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        },
+    };
+}

package/dist/core/auth.d.ts

@@ -0,0 +1,3 @@
+import { Dropbox } from 'dropbox';
+import type { AuthMethods, DropboxCredentials } from './types';
+export declare function createAuthMethods(getClient: () => Dropbox, credentials: DropboxCredentials, setAccessToken: (token: string) => void): AuthMethods;

package/dist/core/auth.js

@@ -0,0 +1,84 @@
+export function createAuthMethods(getClient, credentials, setAccessToken) {
+    return {
+        /**
+         * Generate an authentication URL for Dropbox OAuth flow
+         */
+        async getAuthUrl(redirectUri, state) {
+            const dropbox = getClient();
+            const randomState = state || Math.random().toString(36).substring(2, 15);
+            // Cast to extended auth type to access missing methods
+            const auth = dropbox.auth;
+            // 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, redirectUri) {
+            const dropbox = getClient();
+            // Cast to extended auth type to access missing methods
+            const auth = dropbox.auth;
+            // 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() {
+            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/dist/core/client.d.ts

@@ -0,0 +1,5 @@
+import type { DropboxCredentials, DropboxSyncClient } from './types';
+/**
+ * Creates a Dropbox sync client with auth, sync, and socket methods
+ */
+export declare function createDropboxSyncClient(credentials: DropboxCredentials): DropboxSyncClient;

package/dist/core/client.js

@@ -0,0 +1,37 @@
+import { Dropbox } from 'dropbox';
+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) {
+    let dropboxClient = null;
+    function getClient() {
+        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) {
+        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/dist/core/socket.d.ts

@@ -0,0 +1,2 @@
+import type { SocketMethods } from './types';
+export declare function createSocketMethods(): SocketMethods;