3694513745

Build Type

github

Committed by GitHub

Commit Message

Merge 2dbb860e9 into 83ac6d7c8

Pull Request Pull Request #441: fix: single file upload on Node 16

Run Details

1077 of 1387 branches covered (77.65%)

Branch coverage included in aggregate %.

35 of 54 new or added lines in 9 files covered. (64.81%)

1 existing line in 1 file now uncovered.

3935 of 4421 relevant lines covered (89.01%)

121.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.3

/src/commands/folders/download.js

'use strict';

const { flags } = require('@oclif/command');
const BoxCommand = require('../../box-command');
const fs = require('fs');
const mkdirp = require('mkdirp');
const path = require('path');
const BoxCLIError = require('../../cli-error');
const ora = require('ora');
const archiver = require('archiver');
const dateTime = require('date-fns');
const utils = require('../../util');

/**
 * Saves a file to disk
 *
 * @param {string} folderPath The folder path this item occurs at within the folder being downloaded
 * @param {Object} file The file record
 * @param {Readable} stream The stream of file contents
 * @returns {Promise<void>} A promise resolving when the file is completely written to disk
 * @throws BoxCLIError
 * @private
 */
function saveFileToDisk(folderPath, file, stream) {

        try {
                let output = fs.createWriteStream(path.join(folderPath, file.path));
                stream.pipe(output);
        } catch (ex) {
                throw new BoxCLIError(`Error downloading file ${file.id} to ${file.path}`, ex);
        }

        /* eslint-disable promise/avoid-new */
        // We need to await the end of the stream to avoid a race condition here
        return new Promise((resolve, reject) => {
                stream.on('end', resolve);
                stream.on('error', reject);
        });
        /* eslint-enable promise/avoid-new */
}

class FoldersDownloadCommand extends BoxCommand {
        async run() {
                const { flags, args } = this.parse(FoldersDownloadCommand);

                this.maxDepth = flags.hasOwnProperty('depth') && flags.depth >= 0 ? flags.depth : Number.POSITIVE_INFINITY;

                let outputPath;
                let id = args.id;
                let outputFinalized = Promise.resolve();

                let destinationPath;
                if (flags.destination) {
                        await utils.checkDir(flags.destination, flags['create-path']);
                        destinationPath = flags.destination;
                } else {
                        destinationPath = this.settings.boxDownloadsFolderPath;
                }

                /* eslint-disable no-sync */
                if (!fs.existsSync(destinationPath)) {
                        throw new BoxCLIError('Destination path must exist');
                }

                const fsStat = fs.statSync(destinationPath);
                if (!fsStat.isDirectory()) {
                        throw new BoxCLIError('Destination path must be a directory');
                }
                /* eslint-enable no-sync */

                let spinner = ora('Starting download').start();

                if (flags.zip) {
                        let fileName = `folders-download-${id}-${dateTime.format(new Date(), 'YYYY-MM-DDTHH_mm_ss_SSS')}.zip`;
                        outputPath = path.join(destinationPath, fileName);
                        outputFinalized = this._setupZip(outputPath);
                }

                try {
                        for await (let item of this._getItems(id, '')) {
                                if (item.type === 'folder' && !this.zip) {

                                        // Set output path to the top-level folder, which is the first item in the generator
                                        outputPath = outputPath || path.join(destinationPath, item.path);

                                        spinner.text = `Creating folder ${item.id} at ${item.path}`;
                                        try {
                                                await mkdirp(path.join(destinationPath, item.path));
                                        } catch (ex) {
                                                throw new BoxCLIError(`Folder ${item.path} could not be created`, ex);
                                        }
                                } else if (item.type === 'file') {

                                        spinner.text = `Downloading file ${item.id} to ${item.path}`;
                                        let stream = await this.client.files.getReadStream(item.id);

                                        if (this.zip) {
                                                this.zip.append(stream, { name: item.path });
                                        } else {
                                                // @TODO(2018-08-15): Improve performance by queueing async work and performing in parallel
                                                await saveFileToDisk(destinationPath, item, stream);
                                        }
                                }
                        }
                } catch (err) {
                        spinner.stop();
                        throw err;
                }

                if (this.zip) {
                        this.zip.finalize();
                }
                await outputFinalized;
                spinner.succeed(`Downloaded folder ${id} to ${outputPath}`);
        }

        /**
         * Generator for items in the given folder.  Yields items starting with the top-level folder itself.
         * @param {string} folderId The ID of the folder to generate items for
         * @param {string} folderPath The relative path so far down the folder tree
         * @yields {Object} Item records
         * @returns {void}
         * @private
         */
        async* _getItems(folderId, folderPath) {

                let folder = await this.client.folders.get(folderId);
                folderPath = path.join(folderPath, folder.name);

                yield {
                        type: 'folder',
                        id: folderId,
                        name: folder.name,
                        path: folderPath,
                };

                let folderItems = folder.item_collection.entries;
                if (folder.item_collection.total_count > folderItems.length) {
                        let iterator = await this.client.folders.getItems(folderId, { usemarker: true, fields: 'type,id,name' });
                        folderItems = { [Symbol.asyncIterator]: () => iterator };
                }
                for await (let item of folderItems) {
                        if (item.type === 'folder' && folderPath.split(path.sep).length <= this.maxDepth) {
                                yield* this._getItems(item.id, folderPath);
                        } else if (item.type === 'file') {
                                yield {
                                        type: 'file',
                                        id: item.id,
                                        name: item.name,
                                        path: path.join(folderPath, item.name),
                                };
                        }
                }
        }

        /**
         * Sets up a zip archive writing to the given destination.
         *
         * @param {string} destinationPath The path where the .zip file should be written
         * @returns {Promise<void>} A promise resolving when the archive is finalized and written to disk
         * @throws BoxCLIError
         * @private
         */
        _setupZip(destinationPath) {

                // Set up archive stream
                this.zip = archiver('zip', {
                        zlib: { level: 9 } // Use the best available compression
                });

                let output;
                try {
                        output = fs.createWriteStream(destinationPath);
                } catch (ex) {
                        throw new BoxCLIError(`Could not write to destination path ${destinationPath}`, ex);
                }

                this.zip.on('error', err => {
                        throw new BoxCLIError('Error writing to zip file', err);
                });

                this.zip.pipe(output);

                /* eslint-disable promise/avoid-new */
                // We need to await the end of the stream to avoid a race condition here
                return new Promise((resolve, reject) => {
                        output.on('end', resolve);
                        output.on('close', resolve);
                        output.on('error', reject);
                });
                /* eslint-enable promise/avoid-new */
        }
}

FoldersDownloadCommand.description = 'Download a folder';
FoldersDownloadCommand.examples = ['box folders:download 22222'];

FoldersDownloadCommand.flags = {
        ...BoxCommand.flags,
        destination: flags.string({
                description: 'The destination folder to download the Box folder into',
                parse: utils.parsePath
        }),
        zip: flags.boolean({
                description: 'Download the folder into a single .zip archive',
        }),
        depth: flags.integer({
                description:
                        'Number of levels deep to recurse when downloading the folder tree',
        }),
        'create-path': flags.boolean({
                description: 'Recursively creates a path to a directory if it does not exist',
                allowNo: true,
                default: true,
        }),
};

FoldersDownloadCommand.args = [
        {
                name: 'id',
                required: true,
                hidden: false,
                description: 'ID of the folder to download',
        }
];

module.exports = FoldersDownloadCommand;

1	'use strict';
2
3	const { flags } = require('@oclif/command');	3✔
4	const BoxCommand = require('../../box-command');	3✔
5	const fs = require('fs');	3✔
6	const mkdirp = require('mkdirp');	3✔
7	const path = require('path');	3✔
8	const BoxCLIError = require('../../cli-error');	3✔
9	const ora = require('ora');	3✔
10	const archiver = require('archiver');	3✔
11	const dateTime = require('date-fns');	3✔
12	const utils = require('../../util');	3✔
13
14	/**
15	* Saves a file to disk
16	*
17	* @param {string} folderPath The folder path this item occurs at within the folder being downloaded
18	* @param {Object} file The file record
19	* @param {Readable} stream The stream of file contents
20	* @returns {Promise<void>} A promise resolving when the file is completely written to disk
21	* @throws BoxCLIError
22	* @private
23	*/
24	function saveFileToDisk(folderPath, file, stream) {
25
26	try {	633✔
27	let output = fs.createWriteStream(path.join(folderPath, file.path));	633✔
28	stream.pipe(output);	633✔
29	} catch (ex) {
30	throw new BoxCLIError(`Error downloading file ${file.id} to ${file.path}`, ex);	×
31	}
32
33	/* eslint-disable promise/avoid-new */
34	// We need to await the end of the stream to avoid a race condition here
35	return new Promise((resolve, reject) => {	633✔
36	stream.on('end', resolve);	633✔
37	stream.on('error', reject);	633✔
38	});
39	/* eslint-enable promise/avoid-new */
40	}
41
42	class FoldersDownloadCommand extends BoxCommand {
43	async run() {
44	const { flags, args } = this.parse(FoldersDownloadCommand);	21✔
45
46	this.maxDepth = flags.hasOwnProperty('depth') && flags.depth >= 0 ? flags.depth : Number.POSITIVE_INFINITY;	21✔
47
48	let outputPath;
49	let id = args.id;	21✔
50	let outputFinalized = Promise.resolve();	21✔
51
52	let destinationPath;
53	if (flags.destination) {	21✔
54	await utils.checkDir(flags.destination, flags['create-path']);	18✔
55	destinationPath = flags.destination;	15✔
56	} else {
57	destinationPath = this.settings.boxDownloadsFolderPath;	3✔
58	}
59
60	/* eslint-disable no-sync */
61	if (!fs.existsSync(destinationPath)) {	18!
NEW 62	throw new BoxCLIError('Destination path must exist');	×
63	}
64
65	const fsStat = fs.statSync(destinationPath);	18✔
66	if (!fsStat.isDirectory()) {	18!
UNCOV 67	throw new BoxCLIError('Destination path must be a directory');	×
68	}
69	/* eslint-enable no-sync */
70
71	let spinner = ora('Starting download').start();	18✔
72
73	if (flags.zip) {	18✔
74	let fileName = `folders-download-${id}-${dateTime.format(new Date(), 'YYYY-MM-DDTHH_mm_ss_SSS')}.zip`;	3✔
75	outputPath = path.join(destinationPath, fileName);	3✔
76	outputFinalized = this._setupZip(outputPath);	3✔
77	}
78
79	try {	18✔
80	for await (let item of this._getItems(id, '')) {	18✔
81	if (item.type === 'folder' && !this.zip) {	672✔
82
83	// Set output path to the top-level folder, which is the first item in the generator
84	outputPath = outputPath \|\| path.join(destinationPath, item.path);	24✔
85
86	spinner.text = `Creating folder ${item.id} at ${item.path}`;	24✔
87	try {	24✔
88	await mkdirp(path.join(destinationPath, item.path));	24✔
89	} catch (ex) {
90	throw new BoxCLIError(`Folder ${item.path} could not be created`, ex);	×
91	}
92	} else if (item.type === 'file') {	648✔
93
94	spinner.text = `Downloading file ${item.id} to ${item.path}`;	642✔
95	let stream = await this.client.files.getReadStream(item.id);	642✔
96
97	if (this.zip) {	642✔
98	this.zip.append(stream, { name: item.path });	9✔
99	} else {
100	// @TODO(2018-08-15): Improve performance by queueing async work and performing in parallel
101	await saveFileToDisk(destinationPath, item, stream);	633✔
102	}
103	}
104	}
105	} catch (err) {
106	spinner.stop();	×
107	throw err;	×
108	}
109
110	if (this.zip) {	18✔
111	this.zip.finalize();	3✔
112	}
113	await outputFinalized;	18✔
114	spinner.succeed(`Downloaded folder ${id} to ${outputPath}`);	18✔
115	}
116
117	/**
118	* Generator for items in the given folder. Yields items starting with the top-level folder itself.
119	* @param {string} folderId The ID of the folder to generate items for
120	* @param {string} folderPath The relative path so far down the folder tree
121	* @yields {Object} Item records
122	* @returns {void}
123	* @private
124	*/
125	async* _getItems(folderId, folderPath) {
126
127	let folder = await this.client.folders.get(folderId);	30✔
128	folderPath = path.join(folderPath, folder.name);	30✔
129
130	yield {	30✔
131	type: 'folder',
132	id: folderId,
133	name: folder.name,
134	path: folderPath,
135	};
136
137	let folderItems = folder.item_collection.entries;	30✔
138	if (folder.item_collection.total_count > folderItems.length) {	30✔
139	let iterator = await this.client.folders.getItems(folderId, { usemarker: true, fields: 'type,id,name' });	3✔
140	folderItems = { [Symbol.asyncIterator]: () => iterator };	3✔
141	}
142	for await (let item of folderItems) {	30✔
143	if (item.type === 'folder' && folderPath.split(path.sep).length <= this.maxDepth) {	657✔
144	yield* this._getItems(item.id, folderPath);	12✔
145	} else if (item.type === 'file') {	645✔
146	yield {	642✔
147	type: 'file',
148	id: item.id,
149	name: item.name,
150	path: path.join(folderPath, item.name),
151	};
152	}
153	}
154	}
155
156	/**
157	* Sets up a zip archive writing to the given destination.
158	*
159	* @param {string} destinationPath The path where the .zip file should be written
160	* @returns {Promise<void>} A promise resolving when the archive is finalized and written to disk
161	* @throws BoxCLIError
162	* @private
163	*/
164	_setupZip(destinationPath) {
165
166	// Set up archive stream
167	this.zip = archiver('zip', {	3✔
168	zlib: { level: 9 } // Use the best available compression
169	});
170
171	let output;
172	try {	3✔
173	output = fs.createWriteStream(destinationPath);	3✔
174	} catch (ex) {
175	throw new BoxCLIError(`Could not write to destination path ${destinationPath}`, ex);	×
176	}
177
178	this.zip.on('error', err => {	3✔
179	throw new BoxCLIError('Error writing to zip file', err);	×
180	});
181
182	this.zip.pipe(output);	3✔
183
184	/* eslint-disable promise/avoid-new */
185	// We need to await the end of the stream to avoid a race condition here
186	return new Promise((resolve, reject) => {	3✔
187	output.on('end', resolve);	3✔
188	output.on('close', resolve);	3✔
189	output.on('error', reject);	3✔
190	});
191	/* eslint-enable promise/avoid-new */
192	}
193	}
194
195	FoldersDownloadCommand.description = 'Download a folder';	3✔
196	FoldersDownloadCommand.examples = ['box folders:download 22222'];	3✔
197
198	FoldersDownloadCommand.flags = {	3✔
199	...BoxCommand.flags,
200	destination: flags.string({
201	description: 'The destination folder to download the Box folder into',
202	parse: utils.parsePath
203	}),
204	zip: flags.boolean({
205	description: 'Download the folder into a single .zip archive',
206	}),
207	depth: flags.integer({
208	description:
209	'Number of levels deep to recurse when downloading the folder tree',
210	}),
211	'create-path': flags.boolean({
212	description: 'Recursively creates a path to a directory if it does not exist',
213	allowNo: true,
214	default: true,
215	}),
216	};
217
218	FoldersDownloadCommand.args = [	3✔
219	{
220	name: 'id',
221	required: true,
222	hidden: false,
223	description: 'ID of the folder to download',
224	}
225	];
226
227	module.exports = FoldersDownloadCommand;	3✔

box / boxcli / 3694513745

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous