Catch bulk input errors with converted delegate command (#134)

Author: Matt Willer

src/box-command.js

@@ -254,6 +254,7 @@ class BoxCommand extends Command {
 			this.constructor.args = originalArgs;
 			this.constructor.flags = originalFlags;
 			this.bulkOutputList = [];
+			this.bulkErrors = [];
 			this._singleRun = this.run;
 			this.run = this.bulkOutputRun;
 		}
@@ -379,8 +380,10 @@ class BoxCommand extends Command {
 		bulkCalls = bulkCalls.map(args => args.filter(o => o !== undefined));
 		DEBUG.execute('Read %d entries from bulk file %s', bulkCalls.length, this.flags['bulk-file-path']);
 
+		let bulkEntryIndex = 0;
 		for (let bulkData of bulkCalls) {
 			this.argv = [];
+			bulkEntryIndex += 1;
 
 			// For each possible arg, find the correct value between bulk input
 			// and values given on the command line
@@ -411,13 +414,36 @@ class BoxCommand extends Command {
 			DEBUG.execute('Executing in bulk mode argv: %O', this.argv);
 			// @TODO(2018-08-29): Convert this to a promise queue to improve performance
 			/* eslint-disable no-await-in-loop */
-			await this._singleRun();
+			try {
+				await this._singleRun();
+			} catch (err) {
+				// In bulk mode, we don't want to write directly to console and kill the command
+				// Instead, we should buffer the error output so subsequent commands might be able to succeed
+				DEBUG.execute('Caught error from bulk input entry %d', bulkEntryIndex);
+				this.bulkErrors.push({index: bulkEntryIndex, data: bulkData, error: err});
+			}
 			/* eslint-enable no-await-in-loop */
 		}
 
 		this.isBulk = false;
 		DEBUG.execute('Leaving bulk mode and writing final output');
 		await this.output(this.bulkOutputList);
+		let numErrors = this.bulkErrors.length;
+		if (numErrors > 0) {
+			this.info(chalk`{redBright ${numErrors} entr${numErrors > 1 ? 'ies' : 'y'} failed!}`);
+			this.bulkErrors.forEach(errorInfo => {
+				this.info(chalk`{dim ----------}`);
+				let entryData = errorInfo.data
+					.map(o => `    ${o.fieldKey}=${o.value}`)
+					.join(os.EOL);
+				this.info(chalk`{redBright Entry ${errorInfo.index} (${os.EOL + entryData + os.EOL}) failed with error:}`);
+				let err = errorInfo.error;
+				let errMsg = chalk`{redBright ${this.flags && this.flags.verbose ? err.stack : err.message}${os.EOL}}`;
+				this.info(errMsg);
+			});
+		} else {
+			this.info(chalk`{green All bulk input entries processed successfully.}`);
+		}
 	}
 
 	/**
@@ -773,21 +799,22 @@ class BoxCommand extends Command {
 		/* eslint-disable no-shadow,no-catch-shadow */
 		} catch (err) {
 			// The oclif default catch handler rethrows most errors; handle those here
-			DEBUG.execute('Handling re-thrown error in handler');
+			DEBUG.execute('Handling re-thrown error in base command handler');
 
 			if (err.code === 'EEXIT') {
 				// oclif throws this when it handled the error itself and wants to exit, so just let it do that
 				DEBUG.execute('Got EEXIT code, exiting immediately');
 				return;
 			}
 
-			let errorMsg = this.flags && this.flags.verbose ? err.stack : err.message;
+			let errorMsg = chalk`{redBright ${this.flags && this.flags.verbose ? err.stack : err.message}${os.EOL}}`;
 
 			// Write the error message but let the process exit gracefully with error code so stderr gets written out
 			// @NOTE: Exiting the process in the callback enables tests to mock out stderr and run to completion!
 			/* eslint-disable no-process-exit,unicorn/no-process-exit */
-			process.stderr.write(chalk`{redBright ${errorMsg}${os.EOL}}`, 'utf8', () => process.exit(2));
+			process.stderr.write(errorMsg, 'utf8', () => process.exit(2));
 			/* eslint-enable no-process-exit,unicorn/no-process-exit */
+
 		}
 
 	}
@@ -883,12 +910,13 @@ class BoxCommand extends Command {
 	}
 
 	/**
-	 * Converts time interval shorthands like 5w, -3d, etc to timestamps. It also ensures any timestamp
-	 * passed in is properly formatted for API calls
+	 * Converts time interval shorthand like 5w, -3d, etc to timestamps. It also ensures any timestamp
+	 * passed in is properly formatted for API calls.
+	 *
 	 * @param {string} time The command lint input string for the datetime
-	 * @returns {string} The full RFC3339-formatted datetime string
+	 * @returns {string} The full RFC3339-formatted datetime string in UTC
 	 */
-	getDateFromString(time) {
+	static normalizeDateString(time) {
 		// Attempt to parse date as timestamp or string
 		let newDate = time.match(/^\d+$/u) ? dateTime.parse(parseInt(time, 10) * 1000) : dateTime.parse(time);
 		if (!dateTime.isValid(newDate)) {
@@ -915,18 +943,13 @@ class BoxCommand extends Command {
 				newDate = new Date();
 			} else {
 
-				this.error(`Cannot parse date format "${time}"`);
+				throw new BoxCLIError(`Cannot parse date format "${time}"`);
 			}
 		}
 
-		// Dates are always in the user's local timezone, but for
-		// consistency we move them all to UTC
-
-
 		// Format the timezone to RFC3339 format for the Box API
-		// Also always use UTC for consistency
-		return newDate.toISOString().replace(/\.\d{3}Z$/u, '-00:00');
-		// return dateTime.format(newDate, 'YYYY-MM-DDTHH:mm:ssZ');
+		// Also always use UTC timezone for consistency in tests
+		return newDate.toISOString().replace(/\.\d{3}Z$/u, '+00:00');
 	}
 
 	/**

src/commands/collaborations/create.js

@@ -2,62 +2,15 @@
 
 const BoxCommand = require('../../box-command');
 const { flags } = require('@oclif/command');
+const CollaborationModule = require('../../modules/collaboration');
 
 class CollaborationsAddCommand extends BoxCommand {
 
 	async run() {
 		const { flags, args } = this.parse(CollaborationsAddCommand);
-		let params = {
-			body: {
-				item: {
-					type: args.itemType,
-					id: args.itemID,
-				},
-				accessible_by: {}
-			},
-			qs: {}
-		};
 
-		if (flags.fields) {
-			params.qs.fields = flags.fields;
-		}
-		if (flags.hasOwnProperty('notify')) {
-			params.qs.notify = flags.notify;
-		}
-		if (flags.hasOwnProperty('can-view-path')) {
-			params.body.can_view_path = flags['can-view-path'];
-		}
-		if (flags.role) {
-			params.body.role = flags.role.replace('_', ' ');
-		} else if (flags.editor) {
-			params.body.role = this.client.collaborationRoles.EDITOR;
-		} else if (flags.viewer) {
-			params.body.role = this.client.collaborationRoles.VIEWER;
-		} else if (flags.previewer) {
-			params.body.role = this.client.collaborationRoles.PREVIEWER;
-		} else if (flags.uploader) {
-			params.body.role = this.client.collaborationRoles.UPLOADER;
-		} else if (flags['previewer-uploader']) {
-			params.body.role = this.client.collaborationRoles.PREVIEWER_UPLOADER;
-		} else if (flags['viewer-uploader']) {
-			params.body.role = this.client.collaborationRoles.VIEWER_UPLOADER;
-		} else if (flags['co-owner']) {
-			params.body.role = this.client.collaborationRoles.CO_OWNER;
-		}
-
-		if (flags['user-id']) {
-			params.body.accessible_by.type = 'user';
-			params.body.accessible_by.id = flags['user-id'];
-		} else if (flags['group-id']) {
-			params.body.accessible_by.type = 'group';
-			params.body.accessible_by.id = flags['group-id'];
-		} else if (flags.login) {
-			params.body.accessible_by.type = 'user';
-			params.body.accessible_by.login = flags.login;
-		}
-
-		// @TODO (2018-07-07): Should implement this using the Node SDK
-		let collaboration = await this.client.wrapWithDefaultHandler(this.client.post)('/collaborations', params);
+		let collabModule = new CollaborationModule(this.client);
+		let collaboration = await collabModule.createCollaboration(args, flags);
 		await this.output(collaboration);
 	}
 }

src/commands/collaborations/update.js

@@ -37,7 +37,7 @@ class CollaborationsUpdateCommand extends BoxCommand {
 			params.body.role = this.client.collaborationRoles.OWNER;
 		}
 		if (flags['expires-at']) {
-			params.body.expires_at = this.getDateFromString(flags['expires-at']);
+			params.body.expires_at = flags['expires-at'];
 		}
 
 		// @TODO (2018-07-07): Should implement this using the Node SDK
@@ -205,6 +205,7 @@ CollaborationsUpdateCommand.flags = {
 	}),
 	'expires-at': flags.string({
 		description: 'When the collaboration should expire',
+		parse: input => BoxCommand.normalizeDateString(input),
 	})
 };
 

src/commands/events/index.js

@@ -25,15 +25,15 @@ class EventsGetCommand extends BoxCommand {
 		if (flags['stream-position']) {
 			options.stream_position = flags['stream-position'];
 		} else if (options.stream_type === 'admin_logs') {
-			options.created_before = this.getDateFromString(flags['created-before'] || DEFAULT_END_TIME);
+			options.created_before = flags['created-before'] || BoxCommand.normalizeDateString(DEFAULT_END_TIME);
 
 			if (flags['created-before'] && !flags['created-after']) {
 				// If the user specified an end time but no start time, recompute the default start time as
 				// the specified end time minus five days
 				let endTime = date.addDays(date.parse(options.created_before), -5);
-				options.created_after = endTime.toISOString().replace(/\.\d{3}Z$/u, '-00:00');
+				options.created_after = endTime.toISOString().replace(/\.\d{3}Z$/u, '+00:00');
 			} else {
-				options.created_after = this.getDateFromString(flags['created-after'] || DEFAULT_START_TIME);
+				options.created_after = flags['created-after'] || BoxCommand.normalizeDateString(DEFAULT_START_TIME);
 			}
 		}
 
@@ -70,14 +70,16 @@ EventsGetCommand.flags = {
 		description: 'Get enterprise events'
 	}),
 	'created-after': flags.string({
-		description: 'Return enterprise events that occured after a time. Use a timestamp or shorthand syntax 0t, like 5w for 5 weeks. If not used, defaults to 5 days before the end date',
+		description: 'Return enterprise events that occurred after a time. Use a timestamp or shorthand syntax 0t, like 5w for 5 weeks. If not used, defaults to 5 days before the end date',
 		exclusive: ['stream_position'],
 		dependsOn: ['enterprise'],
+		parse: input => BoxCommand.normalizeDateString(input),
 	}),
 	'created-before': flags.string({
-		description: 'Return enterprise events that occured before a time. Use a timestamp or shorthand syntax 0t, like 5w for 5 weeks. If not used, defaults to now',
+		description: 'Return enterprise events that occurred before a time. Use a timestamp or shorthand syntax 0t, like 5w for 5 weeks. If not used, defaults to now',
 		exclusive: ['stream_position'],
 		dependsOn: ['enterprise'],
+		parse: input => BoxCommand.normalizeDateString(input),
 	}),
 	'event-types': flags.string({
 		description: 'Return enterprise events filtered by event types. Format using a comma delimited list: NEW_USER,DELETE_USER,EDIT_USER',

src/commands/events/poll.js

@@ -14,10 +14,10 @@ class EventsPollCommand extends BoxCommand {
 			options.event_type = flags['event-types'];
 		}
 		if (flags['start-date']) {
-			options.startDate = this.getDateFromString(flags['start-date']);
+			options.startDate = flags['start-date'];
 		}
 		if (flags['end-date']) {
-			options.endDate = this.getDateFromString(flags['end-date']);
+			options.endDate = flags['end-date'];
 		}
 		if (flags['polling-interval']) {
 			options.pollingInterval = flags['polling-interval'];
@@ -48,8 +48,14 @@ EventsPollCommand.flags = {
 		description: 'Get enterprise events'
 	}),
 	'event-types': flags.string({ description: 'Return enterprise events filtered by event types. Format using a comma delimited list: NEW_USER,DELETE_USER,EDIT_USER' }),
-	'start-date': flags.string({ description: 'Return enterprise events that occured after this time. Use a timestamp or shorthand syntax 00t, like 05w for 5 weeks. If not used, defaults to now' }),
-	'end-date': flags.string({ description: 'Return enterprise events that occured before this time. Use a timestamp or shorthand syntax 00t, like 05w for 5 weeks.' }),
+	'start-date': flags.string({
+		description: 'Return enterprise events that occured after this time. Use a timestamp or shorthand syntax 00t, like 05w for 5 weeks. If not used, defaults to now',
+		parse: input => BoxCommand.normalizeDateString(input),
+	}),
+	'end-date': flags.string({
+		description: 'Return enterprise events that occured before this time. Use a timestamp or shorthand syntax 00t, like 05w for 5 weeks.',
+		parse: input => BoxCommand.normalizeDateString(input),
+	}),
 	'polling-interval': flags.string({ description: 'Number of seconds to wait before polling for new events. Default is 60 seconds.' })
 };
 

src/commands/files/collaborations/add.js

@@ -3,15 +3,20 @@
 const BoxCommand = require('../../../box-command');
 const { flags } = require('@oclif/command');
 const CollaborationsCreateCommand = require('../../collaborations/create');
+const CollaborationModule = require('../../../modules/collaboration');
 
 class FilesCollaborationsAddCommand extends BoxCommand {
-	run() {
-		const { args } = this.parse(FilesCollaborationsAddCommand);
+	async run() {
+		const { args, flags } = this.parse(FilesCollaborationsAddCommand);
 
-		// Clone the args and insert the "file" type at the correct position for the generic command
-		let argv = this.argv.slice();
-		argv.splice(argv.indexOf(args.id) + 1, 0, 'file');
-		return CollaborationsCreateCommand.run(argv);
+		// Transform arguments for generic module
+		args.itemType = 'file';
+		args.itemID = args.id;
+		delete args.id;
+
+		let collabModule = new CollaborationModule(this.client);
+		let collaboration = await collabModule.createCollaboration(args, flags);
+		await this.output(collaboration);
 	}
 }
 

src/commands/files/lock.js

@@ -9,7 +9,7 @@ class FilesLockCommand extends BoxCommand {
 		let options = {};
 
 		if (flags.expires) {
-			options.expires_at = this.getDateFromString(flags.expires);
+			options.expires_at = flags.expires;
 		}
 		if (flags.hasOwnProperty('prevent-download')) {
 			options.is_download_prevented = flags['prevent-download'];
@@ -26,7 +26,10 @@ FilesLockCommand.description = 'Lock a file';
 
 FilesLockCommand.flags = {
 	...BoxCommand.flags,
-	expires: flags.string({ description: 'Make the lock expire from a timespan set from now. Use s for seconds, m for minutes, h for hours, d for days, w for weeks, M for months. For example, 30 seconds is 30s' }),
+	expires: flags.string({
+		description: 'Make the lock expire from a timespan set from now. Use s for seconds, m for minutes, h for hours, d for days, w for weeks, M for months. For example, 30 seconds is 30s',
+		parse: input => BoxCommand.normalizeDateString(input),
+	}),
 	'prevent-download': flags.boolean({
 		description: 'Prevent download of locked file',
 		allowNo: true

src/commands/files/share.js

@@ -3,15 +3,20 @@
 const BoxCommand = require('../../box-command');
 const { flags } = require('@oclif/command');
 const SharedLinksCreateCommand = require('../shared-links/create');
+const SharedLinksModule = require('../../modules/shared-links');
 
 class FilesShareCommand extends BoxCommand {
-	run() {
-		const { args } = this.parse(FilesShareCommand);
+	async run() {
+		const { args, flags } = this.parse(FilesShareCommand);
 
-		// Clone the args and insert the "file" type at the correct position for the generic command
-		let argv = this.argv.slice();
-		argv.splice(argv.indexOf(args.id) + 1, 0, 'file');
-		return SharedLinksCreateCommand.run(argv);
+		// Transform arguments for generic module
+		args.itemType = 'file';
+		args.itemID = args.id;
+		delete args.id;
+
+		let sharedLinksModule = new SharedLinksModule(this.client);
+		let updatedItem = await sharedLinksModule.createSharedLink(args, flags);
+		await this.output(updatedItem.shared_link);
 	}
 }
 

src/commands/files/unshare.js

@@ -2,15 +2,21 @@
 
 const BoxCommand = require('../../box-command');
 const SharedLinksDeleteCommand = require('../shared-links/delete');
+const SharedLinksModule = require('../../modules/shared-links');
+const chalk = require('chalk');
 
 class FilesUnshareCommand extends BoxCommand {
-	run() {
+	async run() {
 		const { args } = this.parse(FilesUnshareCommand);
 
-		// Clone the args and insert the "file" type at the correct position for the generic command
-		let argv = this.argv.slice();
-		argv.splice(argv.indexOf(args.id) + 1, 0, 'file');
-		return SharedLinksDeleteCommand.run(argv);
+		// Transform arguments for generic module
+		args.itemType = 'file';
+		args.itemID = args.id;
+		delete args.id;
+
+		let sharedLinksModule = new SharedLinksModule(this.client);
+		let item = await sharedLinksModule.removeSharedLink(args);
+		this.info(chalk`{green Removed shared link from ${args.itemType} "${item.name}"}`);
 	}
 }