dropbox-v2-api

Dropbox API v2 wrapper for nodejs.

The dropbox-v2-api package interface is generated automatically - it's based on Dropbox endpoints description JSON file which is a mirror of Dropbox API HTTP endpoints description, retrived from official documentaion webpage.

Why this package?

• Simple API (no custom function names, see full api showcase)
• Full support for streams (see upload/download examples)
• Supports Dropbox Paper API
• Examples for all endpoints (see more)

Get started

$ npm i -s dropbox-v2-api

const dropbox = require('dropbox-v2-api');

Auth

• using token

dropbox.authenticate({
    token: 'your token'
});

• using oauth2 flow (see example app)

//set credentials
const oauth = dropbox.authenticate({
    client_id: 'APP_KEY',
    client_secret: 'APP_SECRET',
    redirect_uri: 'REDIRECT_URI'
});
//generate and visit authorization sevice 
const authUrl = oauth.generateAuthUrl();
//after redirection, you should receive code
oauth.getToken(code, (err, response) => {
    //you are authorized now!
});

Full API showcase

dropbox({
    resource: (string),
    parameters: (object?),
    readStream: (readable stream object?)
}, (err, result) => {
    if (err) { return console.log('err:', err); }
    console.log(result);
});

• resource (string) represent API target. It contains Dropbox's namespace and method name. eg. 'users/get_account', 'users/get_space_usage', 'files/upload', 'files/list_folder/longpoll', 'sharing/share_folder' more at official documentation
• parameters (object?) optional parameters, depends on resource field
• readStream (readable stream?) Upload-type requests might contains readStream field, which is readable stream

For Download-type requests, the function dropbox returns readable stream.

Upload and Download examples

upload see docs

Upload-type requests might contains readStream field, which is readable stream

dropbox({
    resource: 'files/upload',
    parameters: {
        path: '/dropbox/path/to/file.js'
    },
    readStream: fs.createReadStream('path/to/file.js')
}, (err, result) => {
    //upload completed
});

or, using streams:

const dropboxUploadStream = dropbox({
    resource: 'files/upload',
    parameters: {
        path: '/dropbox/path/to/file.js'
    }
}, (err, result) => {
    //upload completed
});

fs.createReadStream('path/to/file.js').pipe(dropboxUploadStream);

download see docs

Download-type requests return writableStream

dropbox({
    resource: 'files/download',
    parameters: {
        path: '/dropbox/image.jpg'
    }
}, (err, result) => {
    //download completed
})
.pipe(fs.createWriteStream('./image.jpg'));

download & upload

You can easely use streams:

const downloadStream = dropbox({
    resource: 'files/download',
    parameters: { path: '/source/file/path' }				
});

const uploadStream = dropbox({
    resource: 'files/upload',
    parameters: { path: '/target/file/path' }				
}, (err, response) => {
    //upload finished
});

downloadStream.pipe(uploadStream);

API call examples

get_current_account see docs

dropbox({
    resource: 'users/get_current_account'
}, (err, response) => {
    if (err) { return console.log('err:', err); }
    console.log(response);
});

get_metadata see docs

dropbox({
    resource: 'files/get_metadata',
    parameters: {
        path: '/dropbox/path/to/file.js',
        include_media_info: false
	}
}, function(err, result) => {
    if(err){ return console.log('err:', err); }
    console.log(result);
});

upload_session see docs

const CHUNK_LENGTH = 100;
//create read streams, which generates set of 100 (CHUNK_LENGTH) characters of values: 1 and 2
const firstUploadChunkStream = () => utils.createMockedReadStream('1', CHUNK_LENGTH); 
const secondUploadChunkStream = () => utils.createMockedReadStream('2', CHUNK_LENGTH);

sessionStart((sessionId) => {
    sessionAppend(sessionId, () => {
        sessionFinish(sessionId);
    });
});

function sessionStart(cb) {
    dropbox({
        resource: 'files/upload_session/start',
        parameters: {
            close: false
        },
        readStream: firstUploadChunkStream()
    }, (err, response) => {
        if (err) { return console.log('sessionStart error: ', err) }
        console.log('sessionStart response:', response);
        cb(response.session_id);
    });
}


function sessionAppend(sessionId, cb) {
    dropbox({
        resource: 'files/upload_session/append_v2',
        parameters: {
            cursor: {
                session_id: sessionId,
                offset: CHUNK_LENGTH
            },
            close: false,
        },
        readStream: secondUploadChunkStream()
    }, (err, response) => {
        if(err){ return console.log('sessionAppend error: ', err) }
        console.log('sessionAppend response:', response);
        cb();
    });
}

function sessionFinish(sessionId) {
    dropbox({
        resource: 'files/upload_session/finish',
        parameters: {
            cursor: {
                session_id: sessionId,
                offset: CHUNK_LENGTH * 2
            },
            commit: {
                path: "/result.txt",
                mode: "add",
                autorename: true,
                mute: false
            }
        }
    }, (err, response) => {
        if (err) { return console.log('sessionFinish error: ', err) }
        console.log('sessionFinish response:', response);
    });
}

check test cases or examples for more examples...