@pnp/cli-microsoft365 5.8.0-beta.b2e656e → 5.8.0-beta.c1d5041

package/dist/m365/spo/commands/file/file-add.js

@@ -42,73 +42,66 @@ class SpoFileAddCommand extends SpoCommand_1.default {
     allowUnknownOptions() {
         return true;
     }
-    commandAction(logger, args, cb) {
-        const folderPath = utils_1.urlUtil.getServerRelativePath(args.options.webUrl, args.options.folder);
-        const fullPath = path.resolve(args.options.path);
-        const fileName = utils_1.fsUtil.getSafeFileName(path.basename(fullPath));
-        let isCheckedOut = false;
-        let listSettings;
-        if (this.debug) {
-            logger.logToStderr(`folder path: ${folderPath}...`);
-        }
-        if (this.debug) {
-            logger.logToStderr('Check if the specified folder exists.');
-            logger.logToStderr('');
-        }
-        if (this.debug) {
-            logger.logToStderr(`file name: ${fileName}...`);
-        }
-        const requestOptions = {
-            url: `${args.options.webUrl}/_api/web/GetFolderByServerRelativeUrl('${encodeURIComponent(folderPath)}')`,
-            headers: {
-                'accept': 'application/json;odata=nometadata'
-            }
-        };
-        request_1.default.get(requestOptions).catch(() => {
-            // folder does not exist so will attempt to create the folder tree
-            return utils_1.spo.ensureFolder(args.options.webUrl, folderPath, logger, this.debug);
-        })
-            .then(() => {
-            if (args.options.checkOut) {
-                return this.fileCheckOut(fileName, args.options.webUrl, folderPath)
-                    .then(() => {
-                    // flag the file is checkedOut by the command
-                    // so in case of command failure we can try check it in
-                    isCheckedOut = true;
-                    return Promise.resolve();
-                })
-                    .catch((err) => {
-                    return Promise.reject(err);
-                });
+    commandAction(logger, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const folderPath = utils_1.urlUtil.getServerRelativePath(args.options.webUrl, args.options.folder);
+            const fullPath = path.resolve(args.options.path);
+            const fileName = utils_1.fsUtil.getSafeFileName(path.basename(fullPath));
+            let isCheckedOut = false;
+            let listSettings;
+            if (this.debug) {
+                logger.logToStderr(`folder path: ${folderPath}...`);
             }
-            return Promise.resolve();
-        })
-            .then(() => {
-            if (this.verbose) {
-                logger.logToStderr(`Upload file to site ${args.options.webUrl}...`);
+            if (this.debug) {
+                logger.logToStderr('Check if the specified folder exists.');
+                logger.logToStderr('');
             }
-            const fileStats = fs.statSync(fullPath);
-            const fileSize = fileStats.size;
             if (this.debug) {
-                logger.logToStderr(`File size is ${fileSize} bytes`);
+                logger.logToStderr(`file name: ${fileName}...`);
             }
-            // only up to 250 MB are allowed in a single request
-            if (fileSize > this.fileChunkingThreshold) {
-                const fileChunkCount = Math.ceil(fileSize / this.fileChunkSize);
+            try {
+                try {
+                    const requestOptions = {
+                        url: `${args.options.webUrl}/_api/web/GetFolderByServerRelativeUrl('${encodeURIComponent(folderPath)}')`,
+                        headers: {
+                            'accept': 'application/json;odata=nometadata'
+                        }
+                    };
+                    yield request_1.default.get(requestOptions);
+                }
+                catch (err) {
+                    // folder does not exist so will attempt to create the folder tree
+                    yield utils_1.spo.ensureFolder(args.options.webUrl, folderPath, logger, this.debug);
+                }
+                if (args.options.checkOut) {
+                    yield this.fileCheckOut(fileName, args.options.webUrl, folderPath);
+                    // flag the file is checkedOut by the command
+                    // so in case of command failure we can try check it in
+                    isCheckedOut = true;
+                }
                 if (this.verbose) {
-                    logger.logToStderr(`Uploading ${fileSize} bytes in ${fileChunkCount} chunks...`);
+                    logger.logToStderr(`Upload file to site ${args.options.webUrl}...`);
                 }
-                // initiate chunked upload session
-                const uploadId = (0, uuid_1.v4)();
-                const requestOptions = {
-                    url: `${args.options.webUrl}/_api/web/GetFolderByServerRelativeUrl('${encodeURIComponent(folderPath)}')/Files/GetByPathOrAddStub(DecodedUrl='${encodeURIComponent(fileName)}')/StartUpload(uploadId=guid'${uploadId}')`,
-                    headers: {
-                        'accept': 'application/json;odata=nometadata'
+                const fileStats = fs.statSync(fullPath);
+                const fileSize = fileStats.size;
+                if (this.debug) {
+                    logger.logToStderr(`File size is ${fileSize} bytes`);
+                }
+                // only up to 250 MB are allowed in a single request
+                if (fileSize > this.fileChunkingThreshold) {
+                    const fileChunkCount = Math.ceil(fileSize / this.fileChunkSize);
+                    if (this.verbose) {
+                        logger.logToStderr(`Uploading ${fileSize} bytes in ${fileChunkCount} chunks...`);
                     }
-                };
-                return request_1.default
-                    .post(requestOptions)
-                    .then(() => {
+                    // initiate chunked upload session
+                    const uploadId = (0, uuid_1.v4)();
+                    const requestOptions = {
+                        url: `${args.options.webUrl}/_api/web/GetFolderByServerRelativeUrl('${encodeURIComponent(folderPath)}')/Files/GetByPathOrAddStub(DecodedUrl='${encodeURIComponent(fileName)}')/StartUpload(uploadId=guid'${uploadId}')`,
+                        headers: {
+                            'accept': 'application/json;odata=nometadata'
+                        }
+                    };
+                    yield request_1.default.post(requestOptions);
                     // session started successfully, now upload our file chunks
                     const fileUploadInfo = {
                         Name: fileName,
@@ -120,16 +113,15 @@ class SpoFileAddCommand extends SpoCommand_1.default {
                         Position: 0,
                         Size: fileSize
                     };
-                    return new Promise((resolve, reject) => {
-                        this.uploadFileChunks(fileUploadInfo, logger, resolve, reject);
-                    })
-                        .then(() => {
+                    try {
+                        yield new Promise((resolve, reject) => {
+                            this.uploadFileChunks(fileUploadInfo, logger, resolve, reject);
+                        });
                         if (this.verbose) {
                             logger.logToStderr(`Finished uploading ${fileUploadInfo.Position} bytes in ${fileChunkCount} chunks`);
                         }
-                        return Promise.resolve();
-                    })
-                        .catch((err) => {
+                    }
+                    catch (err) {
                         if (this.verbose) {
                             logger.logToStderr('Cancelling upload session due to error...');
                         }
@@ -139,124 +131,110 @@ class SpoFileAddCommand extends SpoCommand_1.default {
                                 'accept': 'application/json;odata=nometadata'
                             }
                         };
-                        return request_1.default
-                            .post(requestOptions)
-                            .then(() => {
-                            return Promise.reject(err); // original error
-                        })
-                            .catch((err_) => {
+                        try {
+                            yield request_1.default.post(requestOptions);
+                            throw err;
+                        }
+                        catch (err) {
                             if (this.debug) {
-                                logger.logToStderr(`Failed to cancel upload session: ${err_}`);
+                                logger.logToStderr(`Failed to cancel upload session: ${err}`);
                             }
-                            return Promise.reject(err); // original error
-                        });
-                    });
-                });
-            }
-            // upload small file in a single request
-            const fileBody = fs.readFileSync(fullPath);
-            const bodyLength = fileBody.byteLength;
-            const requestOptions = {
-                url: `${args.options.webUrl}/_api/web/GetFolderByServerRelativeUrl('${encodeURIComponent(folderPath)}')/Files/Add(url='${encodeURIComponent(fileName)}', overwrite=true)`,
-                data: fileBody,
-                headers: {
-                    'accept': 'application/json;odata=nometadata',
-                    'content-length': bodyLength
-                },
-                maxBodyLength: this.fileChunkingThreshold
-            };
-            return request_1.default.post(requestOptions);
-        })
-            .then(() => {
-            if (args.options.contentType || args.options.publish || args.options.approve) {
-                return this.getFileParentList(fileName, args.options.webUrl, folderPath, logger)
-                    .then((listSettingsResp) => {
-                    listSettings = listSettingsResp;
+                            throw err;
+                        }
+                    }
+                }
+                else {
+                    // upload small file in a single request
+                    const fileBody = fs.readFileSync(fullPath);
+                    const bodyLength = fileBody.byteLength;
+                    const requestOptions = {
+                        url: `${args.options.webUrl}/_api/web/GetFolderByServerRelativeUrl('${encodeURIComponent(folderPath)}')/Files/Add(url='${encodeURIComponent(fileName)}', overwrite=true)`,
+                        data: fileBody,
+                        headers: {
+                            'accept': 'application/json;odata=nometadata',
+                            'content-length': bodyLength
+                        },
+                        maxBodyLength: this.fileChunkingThreshold
+                    };
+                    yield request_1.default.post(requestOptions);
+                }
+                if (args.options.contentType || args.options.publish || args.options.approve) {
+                    listSettings = yield this.getFileParentList(fileName, args.options.webUrl, folderPath, logger);
                     if (args.options.contentType) {
-                        return this.listHasContentType(args.options.contentType, args.options.webUrl, listSettings, logger);
+                        yield this.listHasContentType(args.options.contentType, args.options.webUrl, listSettings, logger);
                     }
-                    return Promise.resolve();
-                });
-            }
-            return Promise.resolve();
-        })
-            .then(() => {
-            // check if there are unknown options
-            // and map them as fields to update
-            const fieldsToUpdate = this.mapUnknownOptionsAsFieldValue(args.options);
-            if (args.options.contentType) {
-                fieldsToUpdate.push({
-                    FieldName: 'ContentType',
-                    FieldValue: args.options.contentType
-                });
-            }
-            if (fieldsToUpdate.length > 0) {
-                // perform list item update and checkin
-                return this.validateUpdateListItem(args.options.webUrl, folderPath, fileName, fieldsToUpdate, logger, args.options.checkInComment);
-            }
-            else if (isCheckedOut) {
-                // perform checkin
-                return this.fileCheckIn(args, fileName);
-            }
-            return Promise.resolve();
-        })
-            .then(() => {
-            // approve and publish cannot be used together
-            // when approve is used it will automatically publish the file
-            // so then no need to publish afterwards
-            if (args.options.approve) {
-                if (this.verbose) {
-                    logger.logToStderr(`Approve file ${fileName}`);
                 }
-                // approve the existing file with given comment
-                const requestOptions = {
-                    url: `${args.options.webUrl}/_api/web/GetFolderByServerRelativeUrl('${encodeURIComponent(folderPath)}')/Files('${encodeURIComponent(fileName)}')/approve(comment='${encodeURIComponent(args.options.approveComment || '')}')`,
-                    headers: {
-                        'accept': 'application/json;odata=nometadata'
-                    },
-                    responseType: 'json'
-                };
-                return request_1.default.post(requestOptions);
-            }
-            else if (args.options.publish) {
-                if (listSettings.EnableModeration && listSettings.EnableMinorVersions) {
-                    return Promise.reject('The file cannot be published without approval. Moderation for this list is enabled. Use the --approve option instead of --publish to approve and publish the file');
+                // check if there are unknown options
+                // and map them as fields to update
+                const fieldsToUpdate = this.mapUnknownOptionsAsFieldValue(args.options);
+                if (args.options.contentType) {
+                    fieldsToUpdate.push({
+                        FieldName: 'ContentType',
+                        FieldValue: args.options.contentType
+                    });
                 }
-                if (this.verbose) {
-                    logger.logToStderr(`Publish file ${fileName}`);
+                if (fieldsToUpdate.length > 0) {
+                    // perform list item update and checkin
+                    yield this.validateUpdateListItem(args.options.webUrl, folderPath, fileName, fieldsToUpdate, logger, args.options.checkInComment);
                 }
-                // publish the existing file with given comment
-                const requestOptions = {
-                    url: `${args.options.webUrl}/_api/web/GetFolderByServerRelativeUrl('${encodeURIComponent(folderPath)}')/Files('${encodeURIComponent(fileName)}')/publish(comment='${encodeURIComponent(args.options.publishComment || '')}')`,
-                    headers: {
-                        'accept': 'application/json;odata=nometadata'
-                    },
-                    responseType: 'json'
-                };
-                return request_1.default.post(requestOptions);
-            }
-            return Promise.resolve();
-        })
-            .then(_ => cb(), (err) => {
-            if (isCheckedOut) {
-                // in a case the command has done checkout
-                // then have to rollback the checkout
-                const requestOptions = {
-                    url: `${args.options.webUrl}/_api/web/GetFolderByServerRelativeUrl('${encodeURIComponent(folderPath)}')/Files('${encodeURIComponent(fileName)}')/UndoCheckOut()`
-                };
-                request_1.default.post(requestOptions)
-                    .then(_ => this.handleRejectedODataJsonPromise(err, logger, cb))
-                    .catch(checkoutError => {
+                else if (isCheckedOut) {
+                    // perform checkin
+                    yield this.fileCheckIn(args, fileName);
+                }
+                // approve and publish cannot be used together
+                // when approve is used it will automatically publish the file
+                // so then no need to publish afterwards
+                if (args.options.approve) {
+                    if (this.verbose) {
+                        logger.logToStderr(`Approve file ${fileName}`);
+                    }
+                    // approve the existing file with given comment
+                    const requestOptions = {
+                        url: `${args.options.webUrl}/_api/web/GetFolderByServerRelativeUrl('${encodeURIComponent(folderPath)}')/Files('${encodeURIComponent(fileName)}')/approve(comment='${encodeURIComponent(args.options.approveComment || '')}')`,
+                        headers: {
+                            'accept': 'application/json;odata=nometadata'
+                        },
+                        responseType: 'json'
+                    };
+                    yield request_1.default.post(requestOptions);
+                }
+                else if (args.options.publish) {
+                    if (listSettings.EnableModeration && listSettings.EnableMinorVersions) {
+                        throw 'The file cannot be published without approval. Moderation for this list is enabled. Use the --approve option instead of --publish to approve and publish the file';
+                    }
                     if (this.verbose) {
-                        logger.logToStderr('Could not rollback file checkout');
-                        logger.logToStderr(checkoutError);
-                        logger.logToStderr('');
+                        logger.logToStderr(`Publish file ${fileName}`);
                     }
-                    this.handleRejectedODataJsonPromise(err, logger, cb);
-                });
+                    // publish the existing file with given comment
+                    const requestOptions = {
+                        url: `${args.options.webUrl}/_api/web/GetFolderByServerRelativeUrl('${encodeURIComponent(folderPath)}')/Files('${encodeURIComponent(fileName)}')/publish(comment='${encodeURIComponent(args.options.publishComment || '')}')`,
+                        headers: {
+                            'accept': 'application/json;odata=nometadata'
+                        },
+                        responseType: 'json'
+                    };
+                    yield request_1.default.post(requestOptions);
+                }
             }
-            else {
-                this.handleRejectedODataJsonPromise(err, logger, cb);
+            catch (err) {
+                if (isCheckedOut) {
+                    // in a case the command has done checkout
+                    // then have to rollback the checkout
+                    const requestOptions = {
+                        url: `${args.options.webUrl}/_api/web/GetFolderByServerRelativeUrl('${encodeURIComponent(folderPath)}')/Files('${encodeURIComponent(fileName)}')/UndoCheckOut()`
+                    };
+                    try {
+                        yield request_1.default.post(requestOptions);
+                    }
+                    catch (err) {
+                        if (this.verbose) {
+                            logger.logToStderr('Could not rollback file checkout');
+                            logger.logToStderr(err);
+                            logger.logToStderr('');
+                        }
+                    }
+                }
+                this.handleRejectedODataJsonPromise(err);
             }
         });
     }

package/dist/m365/spo/commands/file/file-checkin.js

@@ -40,38 +40,43 @@ class SpoFileCheckinCommand extends SpoCommand_1.default {
     get description() {
         return 'Checks in specified file';
     }
-    commandAction(logger, args, cb) {
-        let type = CheckinType.Major;
-        if (args.options.type) {
-            switch (args.options.type.toLowerCase()) {
-                case 'minor':
-                    type = CheckinType.Minor;
-                    break;
-                case 'overwrite':
-                    type = CheckinType.Overwrite;
+    commandAction(logger, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let type = CheckinType.Major;
+            if (args.options.type) {
+                switch (args.options.type.toLowerCase()) {
+                    case 'minor':
+                        type = CheckinType.Minor;
+                        break;
+                    case 'overwrite':
+                        type = CheckinType.Overwrite;
+                }
             }
-        }
-        let comment = '';
-        if (args.options.comment) {
-            comment = encodeURIComponent(args.options.comment);
-        }
-        let requestUrl = '';
-        if (args.options.id) {
-            requestUrl = `${args.options.webUrl}/_api/web/GetFileById('${encodeURIComponent(args.options.id)}')/checkin(comment='${comment}',checkintype=${type})`;
-        }
-        if (args.options.fileUrl) {
-            requestUrl = `${args.options.webUrl}/_api/web/GetFileByServerRelativeUrl('${encodeURIComponent(args.options.fileUrl)}')/checkin(comment='${comment}',checkintype=${type})`;
-        }
-        const requestOptions = {
-            url: requestUrl,
-            headers: {
-                'accept': 'application/json;odata=nometadata'
-            },
-            responseType: 'json'
-        };
-        request_1.default
-            .post(requestOptions)
-            .then(_ => cb(), (err) => this.handleRejectedODataJsonPromise(err, logger, cb));
+            let comment = '';
+            if (args.options.comment) {
+                comment = encodeURIComponent(args.options.comment);
+            }
+            let requestUrl = '';
+            if (args.options.id) {
+                requestUrl = `${args.options.webUrl}/_api/web/GetFileById('${encodeURIComponent(args.options.id)}')/checkin(comment='${comment}',checkintype=${type})`;
+            }
+            if (args.options.fileUrl) {
+                requestUrl = `${args.options.webUrl}/_api/web/GetFileByServerRelativeUrl('${encodeURIComponent(args.options.fileUrl)}')/checkin(comment='${comment}',checkintype=${type})`;
+            }
+            const requestOptions = {
+                url: requestUrl,
+                headers: {
+                    'accept': 'application/json;odata=nometadata'
+                },
+                responseType: 'json'
+            };
+            try {
+                yield request_1.default.post(requestOptions);
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        });
     }
 }
 _SpoFileCheckinCommand_instances = new WeakSet(), _SpoFileCheckinCommand_initTelemetry = function _SpoFileCheckinCommand_initTelemetry() {

package/dist/m365/spo/commands/file/file-checkout.js

@@ -34,24 +34,29 @@ class SpoFileCheckoutCommand extends SpoCommand_1.default {
     get description() {
         return 'Checks out specified file';
     }
-    commandAction(logger, args, cb) {
-        let requestUrl = '';
-        if (args.options.id) {
-            requestUrl = `${args.options.webUrl}/_api/web/GetFileById('${encodeURIComponent(args.options.id)}')/checkout`;
-        }
-        if (args.options.fileUrl) {
-            requestUrl = `${args.options.webUrl}/_api/web/GetFileByServerRelativeUrl('${encodeURIComponent(args.options.fileUrl)}')/checkout`;
-        }
-        const requestOptions = {
-            url: requestUrl,
-            headers: {
-                'accept': 'application/json;odata=nometadata'
-            },
-            responseType: 'json'
-        };
-        request_1.default
-            .post(requestOptions)
-            .then(_ => cb(), (err) => this.handleRejectedODataJsonPromise(err, logger, cb));
+    commandAction(logger, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let requestUrl = '';
+            if (args.options.id) {
+                requestUrl = `${args.options.webUrl}/_api/web/GetFileById('${encodeURIComponent(args.options.id)}')/checkout`;
+            }
+            if (args.options.fileUrl) {
+                requestUrl = `${args.options.webUrl}/_api/web/GetFileByServerRelativeUrl('${encodeURIComponent(args.options.fileUrl)}')/checkout`;
+            }
+            const requestOptions = {
+                url: requestUrl,
+                headers: {
+                    'accept': 'application/json;odata=nometadata'
+                },
+                responseType: 'json'
+            };
+            try {
+                yield request_1.default.post(requestOptions);
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        });
     }
 }
 _SpoFileCheckoutCommand_instances = new WeakSet(), _SpoFileCheckoutCommand_initTelemetry = function _SpoFileCheckoutCommand_initTelemetry() {

package/dist/m365/spo/commands/file/file-copy.js

@@ -37,70 +37,68 @@ class SpoFileCopyCommand extends SpoCommand_1.default {
     getExcludedOptionsWithUrls() {
         return ['targetUrl'];
     }
-    commandAction(logger, args, cb) {
-        const webUrl = args.options.webUrl;
-        const parsedUrl = url.parse(webUrl);
-        const tenantUrl = `${parsedUrl.protocol}//${parsedUrl.hostname}`;
-        // Check if the source file exists.
-        // Called on purpose, we explicitly check if user specified file
-        // in the sourceUrl option.
-        // The CreateCopyJobs endpoint accepts file, folder or batch from both.
-        // A user might enter folder instead of file as source url by mistake
-        // then there are edge cases when deleteIfAlreadyExists flag is set
-        // the user can receive misleading error message.
-        this
-            .fileExists(tenantUrl, webUrl, args.options.sourceUrl)
-            .then(() => {
-            if (args.options.deleteIfAlreadyExists) {
-                // try delete target file, if deleteIfAlreadyExists flag is set
-                const filename = args.options.sourceUrl.replace(/^.*[\\\/]/, '');
-                return this.recycleFile(tenantUrl, args.options.targetUrl, filename, logger);
+    commandAction(logger, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const webUrl = args.options.webUrl;
+            const parsedUrl = url.parse(webUrl);
+            const tenantUrl = `${parsedUrl.protocol}//${parsedUrl.hostname}`;
+            try {
+                // Check if the source file exists.
+                // Called on purpose, we explicitly check if user specified file
+                // in the sourceUrl option.
+                // The CreateCopyJobs endpoint accepts file, folder or batch from both.
+                // A user might enter folder instead of file as source url by mistake
+                // then there are edge cases when deleteIfAlreadyExists flag is set
+                // the user can receive misleading error message.
+                yield this.fileExists(tenantUrl, webUrl, args.options.sourceUrl);
+                if (args.options.deleteIfAlreadyExists) {
+                    // try delete target file, if deleteIfAlreadyExists flag is set
+                    const filename = args.options.sourceUrl.replace(/^.*[\\\/]/, '');
+                    yield this.recycleFile(tenantUrl, args.options.targetUrl, filename, logger);
+                }
+                // all preconditions met, now create copy job
+                const sourceAbsoluteUrl = utils_1.urlUtil.urlCombine(webUrl, args.options.sourceUrl);
+                const allowSchemaMismatch = args.options.allowSchemaMismatch || false;
+                const requestUrl = utils_1.urlUtil.urlCombine(webUrl, '/_api/site/CreateCopyJobs');
+                const requestOptions = {
+                    url: requestUrl,
+                    headers: {
+                        'accept': 'application/json;odata=nometadata'
+                    },
+                    data: {
+                        exportObjectUris: [sourceAbsoluteUrl],
+                        destinationUri: utils_1.urlUtil.urlCombine(tenantUrl, args.options.targetUrl),
+                        options: {
+                            "AllowSchemaMismatch": allowSchemaMismatch,
+                            "IgnoreVersionHistory": true
+                        }
+                    },
+                    responseType: 'json'
+                };
+                const jobInfo = yield request_1.default.post(requestOptions);
+                yield new Promise((resolve, reject) => {
+                    this.dots = '';
+                    const copyJobInfo = jobInfo.value[0];
+                    const progressPollInterval = 30 * 60; //used previously implemented interval. The API does not provide guidance on what value should be used.
+                    setTimeout(() => {
+                        utils_1.spo.waitUntilCopyJobFinished({
+                            copyJobInfo,
+                            siteUrl: webUrl,
+                            pollingInterval: progressPollInterval,
+                            resolve,
+                            reject,
+                            logger,
+                            dots: this.dots,
+                            debug: this.debug,
+                            verbose: this.verbose
+                        });
+                    }, progressPollInterval);
+                });
             }
-            return Promise.resolve();
-        })
-            .then(() => {
-            // all preconditions met, now create copy job
-            const sourceAbsoluteUrl = utils_1.urlUtil.urlCombine(webUrl, args.options.sourceUrl);
-            const allowSchemaMismatch = args.options.allowSchemaMismatch || false;
-            const requestUrl = utils_1.urlUtil.urlCombine(webUrl, '/_api/site/CreateCopyJobs');
-            const requestOptions = {
-                url: requestUrl,
-                headers: {
-                    'accept': 'application/json;odata=nometadata'
-                },
-                data: {
-                    exportObjectUris: [sourceAbsoluteUrl],
-                    destinationUri: utils_1.urlUtil.urlCombine(tenantUrl, args.options.targetUrl),
-                    options: {
-                        "AllowSchemaMismatch": allowSchemaMismatch,
-                        "IgnoreVersionHistory": true
-                    }
-                },
-                responseType: 'json'
-            };
-            return request_1.default.post(requestOptions);
-        })
-            .then((jobInfo) => {
-            return new Promise((resolve, reject) => {
-                this.dots = '';
-                const copyJobInfo = jobInfo.value[0];
-                const progressPollInterval = 30 * 60; //used previously implemented interval. The API does not provide guidance on what value should be used.
-                setTimeout(() => {
-                    utils_1.spo.waitUntilCopyJobFinished({
-                        copyJobInfo,
-                        siteUrl: webUrl,
-                        pollingInterval: progressPollInterval,
-                        resolve,
-                        reject,
-                        logger,
-                        dots: this.dots,
-                        debug: this.debug,
-                        verbose: this.verbose
-                    });
-                }, progressPollInterval);
-            });
-        })
-            .then(_ => cb(), (err) => this.handleRejectedODataJsonPromise(err, logger, cb));
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        });
     }
     /**
      * Checks if a file exists on the server relative url