@hubspot/local-dev-lib 0.2.1 → 0.2.2-experimental.0

package/lib/cms/watch.js

@@ -7,46 +7,50 @@ exports.watch = void 0;
 const path_1 = __importDefault(require("path"));
 const chokidar_1 = __importDefault(require("chokidar"));
 const p_queue_1 = __importDefault(require("p-queue"));
-const debounce_1 = require("debounce");
-const apiErrors_1 = require("../../errors/apiErrors");
+const debounce_1 = __importDefault(require("debounce"));
 const handleFieldsJS_1 = require("./handleFieldsJS");
 const uploadFolder_1 = require("./uploadFolder");
 const ignoreRules_1 = require("../ignoreRules");
 const fileMapper_1 = require("../fileMapper");
 const fileMapper_2 = require("../../api/fileMapper");
-const escapeRegExp_1 = require("../../utils/escapeRegExp");
+const escapeRegExp_1 = require("../escapeRegExp");
 const path_2 = require("../path");
-const notify_1 = require("../../utils/notify");
+const notify_1 = require("../notify");
 const themes_1 = require("./themes");
-const logger_1 = require("../../utils/logger");
-const logger_2 = require("../../utils/logger");
+const logger_1 = require("../logger");
+const lang_1 = require("../../utils/lang");
+const HubSpotHttpError_1 = require("../../models/HubSpotHttpError");
+const errors_1 = require("../../errors");
 const i18nKey = 'lib.cms.watch';
-const watchCallbackKeys = [
-    'notifyOfThemePreview',
-    'uploadSuccess',
-    'deleteSuccess',
-    'folderUploadSuccess',
-    'ready',
-    'deleteSuccessWithType',
-];
-const makeLogger = (logger_1.makeTypedLogger);
 const queue = new p_queue_1.default({
     concurrency: 10,
 });
-function _notifyOfThemePreview(filePath, accountId, logCallbacks) {
-    const logger = makeLogger(logCallbacks);
+function _notifyOfThemePreview(filePath, accountId) {
     if (queue.size > 0)
         return;
     const previewUrl = (0, themes_1.getThemePreviewUrl)(filePath, accountId);
     if (!previewUrl)
         return;
-    logger('notifyOfThemePreview', `${i18nKey}.notifyOfThemePreview`, {
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.notifyOfThemePreview`, {
         previewUrl,
-    });
+    }));
 }
-const notifyOfThemePreview = (0, debounce_1.debounce)(_notifyOfThemePreview, 1000);
-async function uploadFile(accountId, file, dest, options, mode = null, logCallbacks) {
-    const logger = makeLogger(logCallbacks);
+const notifyOfThemePreview = (0, debounce_1.default)(_notifyOfThemePreview, 1000);
+const defaultOnUploadFileError = (file, dest, accountId) => (error) => {
+    const uploadFailedMessage = (0, lang_1.i18n)(`${i18nKey}.uploadFailed`, {
+        file,
+        dest,
+    });
+    logger_1.logger.debug(uploadFailedMessage);
+    throw new HubSpotHttpError_1.HubSpotHttpError(uploadFailedMessage, {
+        cause: error,
+    }, {
+        accountId,
+        request: dest,
+        payload: file,
+    });
+};
+async function uploadFile(accountId, file, dest, options, cmsPublishMode = null, onUploadFileError = defaultOnUploadFileError) {
     const src = options.src;
     const absoluteSrcPath = path_1.default.resolve((0, path_2.getCwd)(), file);
     const themeJsonPath = (0, themes_1.getThemeJSONPath)(absoluteSrcPath);
@@ -55,11 +59,11 @@ async function uploadFile(accountId, file, dest, options, mode = null, logCallba
         : path_1.default.dirname((0, path_2.getCwd)());
     const convertFields = (0, handleFieldsJS_1.isConvertableFieldJs)(src, file, options.commandOptions.convertFields);
     if (!(0, path_2.isAllowedExtension)(file) && !convertFields) {
-        (0, logger_2.debug)(`${i18nKey}.skipUnsupportedExtension`, { file });
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.skipUnsupportedExtension`, { file }));
         return;
     }
     if ((0, ignoreRules_1.shouldIgnoreFile)(file)) {
-        (0, logger_2.debug)(`${i18nKey}.skipIgnoreRule`, { file });
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.skipIgnoreRule`, { file }));
         return;
     }
     let fieldsJs = undefined;
@@ -71,57 +75,48 @@ async function uploadFile(accountId, file, dest, options, mode = null, logCallba
         dest = (0, path_2.convertToUnixPath)(path_1.default.join(path_1.default.dirname(dest), 'fields.json'));
     }
     const fileToUpload = convertFields && fieldsJs?.outputPath ? fieldsJs.outputPath : file;
-    (0, logger_2.debug)(`${i18nKey}.uploadAttempt`, { file, dest });
-    const apiOptions = (0, fileMapper_1.getFileMapperQueryValues)(mode, options);
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadAttempt`, { file, dest }));
+    const apiOptions = (0, fileMapper_1.getFileMapperQueryValues)(cmsPublishMode, options);
     queue.add(() => {
         return (0, fileMapper_2.upload)(accountId, fileToUpload, dest, apiOptions)
             .then(() => {
-            logger('uploadSuccess', `${i18nKey}.uploadSuccess`, { file, dest });
-            notifyOfThemePreview(file, accountId, logCallbacks);
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.uploadSuccess`, { file, dest }));
+            notifyOfThemePreview(file, accountId);
         })
             .catch(() => {
-            (0, logger_2.debug)(`${i18nKey}.uploadFailed`, { file, dest });
-            (0, logger_2.debug)(`${i18nKey}.uploadRetry`, { file, dest });
-            return (0, fileMapper_2.upload)(accountId, file, dest, apiOptions).catch((error) => {
-                (0, logger_2.debug)(`${i18nKey}.uploadFailed`, {
-                    file,
-                    dest,
-                });
-                (0, apiErrors_1.throwApiUploadError)(error, {
-                    accountId,
-                    request: dest,
-                    payload: file,
-                });
-            });
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadFailed`, { file, dest }));
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadRetry`, { file, dest }));
+            return (0, fileMapper_2.upload)(accountId, file, dest, apiOptions).catch(onUploadFileError(file, dest, accountId));
         });
     });
 }
-async function deleteRemoteFile(accountId, filePath, remoteFilePath, logCallbacks) {
-    const logger = makeLogger(logCallbacks);
+async function deleteRemoteFile(accountId, filePath, remoteFilePath) {
     if ((0, ignoreRules_1.shouldIgnoreFile)(filePath)) {
-        (0, logger_2.debug)(`${i18nKey}.skipIgnoreRule`, { file: filePath });
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.skipIgnoreRule`, { file: filePath }));
         return;
     }
-    (0, logger_2.debug)(`${i18nKey}.deleteAttempt`, { remoteFilePath });
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.deleteAttempt`, { remoteFilePath }));
     return queue.add(() => {
         return (0, fileMapper_2.deleteFile)(accountId, remoteFilePath)
             .then(() => {
-            logger('deleteSuccess', `${i18nKey}.deleteSuccess`, { remoteFilePath });
-            notifyOfThemePreview(filePath, accountId, logCallbacks);
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.deleteSuccess`, { remoteFilePath }));
+            notifyOfThemePreview(filePath, accountId);
         })
-            .catch((error) => {
-            (0, logger_2.debug)(`${i18nKey}.deleteFailed`, {
+            .catch(error => {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.deleteFailed`, {
                 remoteFilePath,
-            });
-            (0, apiErrors_1.throwApiError)(error, {
-                accountId,
-                request: remoteFilePath,
-            });
+            }));
+            if ((0, errors_1.isHubSpotHttpError)(error)) {
+                error.updateContext({
+                    accountId,
+                    request: remoteFilePath,
+                });
+            }
+            throw error;
         });
     });
 }
-function watch(accountId, src, dest, { mode, remove, disableInitial, notify, commandOptions, filePaths, }, postInitialUploadCallback = null, onUploadFolderError, onQueueAddError, logCallbacks) {
-    const logger = makeLogger(logCallbacks);
+function watch(accountId, src, dest, { cmsPublishMode, remove, disableInitial, notify, commandOptions, filePaths, }, postInitialUploadCallback = null, onUploadFolderError, onQueueAddError, onUploadFileError) {
     const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(src)}`);
     if (notify) {
         (0, ignoreRules_1.ignoreFile)(notify);
@@ -136,12 +131,12 @@ function watch(accountId, src, dest, { mode, remove, disableInitial, notify, com
     }
     if (!disableInitial) {
         // Use uploadFolder so that failures of initial upload are retried
-        const uploadFolderPromise = (0, uploadFolder_1.uploadFolder)(accountId, src, dest, {}, commandOptions, filePaths, mode || null).then(result => {
-            logger('folderUploadSuccess', `${i18nKey}.folderUploadSuccess`, {
+        const uploadFolderPromise = (0, uploadFolder_1.uploadFolder)(accountId, src, dest, {}, commandOptions, filePaths, cmsPublishMode || null).then(result => {
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.folderUploadSuccess`, {
                 src,
                 dest,
                 accountId,
-            });
+            }));
             if (postInitialUploadCallback) {
                 postInitialUploadCallback(result);
             }
@@ -151,14 +146,14 @@ function watch(accountId, src, dest, { mode, remove, disableInitial, notify, com
         }
     }
     watcher.on('ready', () => {
-        logger('ready', `${i18nKey}.ready`, { src });
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.ready`, { src }));
     });
     watcher.on('add', async (filePath) => {
         const destPath = getDesignManagerPath(filePath);
         const uploadPromise = uploadFile(accountId, filePath, destPath, {
             src,
             commandOptions,
-        }, mode, logCallbacks);
+        }, cmsPublishMode, onUploadFileError);
         (0, notify_1.triggerNotify)(notify, 'Added', filePath, uploadPromise);
     });
     if (remove) {
@@ -169,19 +164,19 @@ function watch(accountId, src, dest, { mode, remove, disableInitial, notify, com
             }
             const remotePath = getDesignManagerPath(filePath);
             if ((0, ignoreRules_1.shouldIgnoreFile)(filePath)) {
-                (0, logger_2.debug)(`${i18nKey}.skipIgnoreRule`, { file: filePath });
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.skipIgnoreRule`, { file: filePath }));
                 return;
             }
-            (0, logger_2.debug)(`${i18nKey}.deleteAttemptWithType`, {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.deleteAttemptWithType`, {
                 type,
                 remoteFilePath: remotePath,
-            });
+            }));
             const queueAddPromise = queue.add(() => {
-                const deletePromise = deleteRemoteFile(accountId, filePath, remotePath, logCallbacks).then(() => {
-                    logger('deleteSuccessWithType', `${i18nKey}.deleteSuccessWithType`, {
+                const deletePromise = deleteRemoteFile(accountId, filePath, remotePath).then(() => {
+                    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.deleteSuccessWithType`, {
                         type,
                         remoteFilePath: remotePath,
-                    });
+                    }));
                 });
                 if (onQueueAddError) {
                     queueAddPromise.catch(onQueueAddError);
@@ -198,7 +193,7 @@ function watch(accountId, src, dest, { mode, remove, disableInitial, notify, com
         const uploadPromise = uploadFile(accountId, filePath, destPath, {
             src,
             commandOptions,
-        }, mode, logCallbacks);
+        }, cmsPublishMode, onUploadFileError);
         (0, notify_1.triggerNotify)(notify, 'Changed', filePath, uploadPromise);
     });
     return watcher;

package/lib/customObjects.js

@@ -9,7 +9,6 @@ const path_1 = __importDefault(require("path"));
 const prettier_1 = __importDefault(require("prettier"));
 const path_2 = require("../lib/path");
 const customObjects_1 = require("../api/customObjects");
-const apiErrors_1 = require("../errors/apiErrors");
 function getResolvedPath(dest, name) {
     if (name)
         return path_1.default.resolve((0, path_2.getCwd)(), dest || '', `${name}.json`);
@@ -24,13 +23,8 @@ async function writeSchemaToDisk(schema, dest) {
 }
 exports.writeSchemaToDisk = writeSchemaToDisk;
 async function downloadSchemas(accountId, dest) {
-    let response;
-    try {
-        response = await (0, customObjects_1.fetchObjectSchemas)(accountId);
-    }
-    catch (err) {
-        (0, apiErrors_1.throwApiError)(err);
-    }
+    const axiosResponse = await (0, customObjects_1.fetchObjectSchemas)(accountId);
+    const response = axiosResponse.data;
     if (response.results.length) {
         for (const schema of response.results) {
             await writeSchemaToDisk(schema, dest);
@@ -40,13 +34,8 @@ async function downloadSchemas(accountId, dest) {
 }
 exports.downloadSchemas = downloadSchemas;
 async function downloadSchema(accountId, schemaObjectType, dest) {
-    let response;
-    try {
-        response = await (0, customObjects_1.fetchObjectSchema)(accountId, schemaObjectType);
-    }
-    catch (err) {
-        (0, apiErrors_1.throwApiError)(err);
-    }
+    const axiosResponse = await (0, customObjects_1.fetchObjectSchema)(accountId, schemaObjectType);
+    const response = axiosResponse.data;
     await writeSchemaToDisk(response, dest);
     return response;
 }

package/lib/fileManager.d.ts

@@ -1,6 +1,2 @@
-import { LogCallbacksArg } from '../types/LogCallbacks';
-declare const uploadCallbackKeys: readonly ["uploadSuccess"];
-declare const downloadCallbackKeys: readonly ["skippedExisting", "fetchFolderStarted", "fetchFolderSuccess", "fetchFileStarted", "fetchFileSuccess"];
-export declare function uploadFolder(accountId: number, src: string, dest: string, logCallbacks?: LogCallbacksArg<typeof uploadCallbackKeys>): Promise<void>;
-export declare function downloadFileOrFolder(accountId: number, src: string, dest: string, overwrite?: boolean, includeArchived?: boolean, logCallbacks?: LogCallbacksArg<typeof downloadCallbackKeys>): Promise<void>;
-export {};
+export declare function uploadFolder(accountId: number, src: string, dest: string): Promise<void>;
+export declare function downloadFileOrFolder(accountId: number, src: string, dest: string, overwrite?: boolean, includeArchived?: boolean): Promise<void>;

package/lib/fileManager.js

@@ -9,25 +9,16 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const fileManager_1 = require("../api/fileManager");
 const fs_1 = require("./fs");
-const logger_1 = require("../utils/logger");
+const logger_1 = require("./logger");
 const ignoreRules_1 = require("./ignoreRules");
-const http_1 = __importDefault(require("../http"));
-const escapeRegExp_1 = require("../utils/escapeRegExp");
+const http_1 = require("../http");
+const escapeRegExp_1 = require("./escapeRegExp");
 const path_2 = require("./path");
-const apiErrors_1 = require("../errors/apiErrors");
-const standardErrors_1 = require("../errors/standardErrors");
-const fileSystemErrors_1 = require("../errors/fileSystemErrors");
+const lang_1 = require("../utils/lang");
+const errors_1 = require("../errors");
+const FileSystemError_1 = require("../models/FileSystemError");
 const i18nKey = 'lib.fileManager';
-const uploadCallbackKeys = ['uploadSuccess'];
-const downloadCallbackKeys = [
-    'skippedExisting',
-    'fetchFolderStarted',
-    'fetchFolderSuccess',
-    'fetchFileStarted',
-    'fetchFileSuccess',
-];
-async function uploadFolder(accountId, src, dest, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function uploadFolder(accountId, src, dest) {
     const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(src)}`);
     const files = await (0, fs_1.walk)(src);
     const filesToUpload = files.filter((0, ignoreRules_1.createIgnoreFilter)(false));
@@ -36,46 +27,48 @@ async function uploadFolder(accountId, src, dest, logCallbacks) {
         const file = filesToUpload[index];
         const relativePath = file.replace(regex, '');
         const destPath = (0, path_2.convertToUnixPath)(path_1.default.join(dest, relativePath));
-        (0, logger_1.debug)(`${i18nKey}.uploadStarted`, {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadStarted`, {
             file,
             destPath,
             accountId,
-        });
+        }));
         try {
             await (0, fileManager_1.uploadFile)(accountId, file, destPath);
-            logger('uploadSuccess', `${i18nKey}.uploadSuccess`, { file, destPath });
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.uploadSuccess`, { file, destPath }));
         }
         catch (err) {
-            const error = err;
-            if ((0, standardErrors_1.isFatalError)(error)) {
-                (0, standardErrors_1.throwError)(error);
+            if ((0, errors_1.isHubSpotHttpError)(err)) {
+                err.updateContext({
+                    filepath: file,
+                    dest: destPath,
+                });
+                throw err;
             }
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.uploadFailed`, {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.uploadFailed`, {
                 file,
                 destPath,
-            });
+            }));
         }
     }
 }
 exports.uploadFolder = uploadFolder;
-async function skipExisting(overwrite, filepath, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function skipExisting(overwrite, filepath) {
     if (overwrite) {
         return false;
     }
     if (await fs_extra_1.default.pathExists(filepath)) {
-        logger('skippedExisting', `${i18nKey}.skippedExisting`, { filepath });
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.skippedExisting`, { filepath }));
         return true;
     }
     return false;
 }
-async function downloadFile(accountId, file, dest, overwrite, logCallbacks) {
+async function downloadFile(accountId, file, dest, overwrite) {
     const fileName = `${file.name}.${file.extension}`;
     const destPath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.join(dest, fileName));
-    if (await skipExisting(overwrite || false, destPath, logCallbacks)) {
+    if (await skipExisting(overwrite || false, destPath)) {
         return;
     }
-    await http_1.default.getOctetStream(accountId, {
+    await http_1.http.getOctetStream(accountId, {
         baseURL: file.url,
         url: '',
     }, destPath);
@@ -86,7 +79,7 @@ async function fetchAllPagedFiles(accountId, folderId, includeArchived) {
     let count = 0;
     let offset = 0;
     while (totalFiles === null || count < totalFiles) {
-        const response = await (0, fileManager_1.fetchFiles)(accountId, folderId, offset, includeArchived);
+        const { data: response } = await (0, fileManager_1.fetchFiles)(accountId, folderId, offset, includeArchived);
         if (totalFiles === null) {
             totalFiles = response.total_count;
         }
@@ -96,34 +89,33 @@ async function fetchAllPagedFiles(accountId, folderId, includeArchived) {
     }
     return files;
 }
-async function fetchFolderContents(accountId, folder, dest, overwrite, includeArchived, logCallbacks) {
+async function fetchFolderContents(accountId, folder, dest, overwrite, includeArchived) {
     try {
         await fs_extra_1.default.ensureDir(dest);
     }
     catch (err) {
-        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
             dest,
             accountId,
-            write: true,
+            operation: 'write',
         });
     }
     const files = await fetchAllPagedFiles(accountId, folder.id, includeArchived);
-    (0, logger_1.debug)(`${i18nKey}.fetchingFiles`, {
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.fetchingFiles`, {
         fileCount: files.length,
         folderName: folder.name || '',
-    });
+    }));
     for (const file of files) {
-        await downloadFile(accountId, file, dest, overwrite, logCallbacks);
+        await downloadFile(accountId, file, dest, overwrite);
     }
-    const { objects: folders } = await (0, fileManager_1.fetchFolders)(accountId, folder.id);
+    const { data: { objects: folders }, } = await (0, fileManager_1.fetchFolders)(accountId, folder.id);
     for (const folder of folders) {
         const nestedFolder = path_1.default.join(dest, folder.name);
-        await fetchFolderContents(accountId, folder, nestedFolder, overwrite, includeArchived, logCallbacks);
+        await fetchFolderContents(accountId, folder, nestedFolder, overwrite, includeArchived);
     }
 }
 // Download a folder and write to local file system.
-async function downloadFolder(accountId, src, dest, folder, overwrite, includeArchived, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function downloadFolder(accountId, src, dest, folder, overwrite, includeArchived) {
     let absolutePath;
     if (folder.name) {
         absolutePath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve((0, path_2.getCwd)(), dest, folder.name));
@@ -131,65 +123,62 @@ async function downloadFolder(accountId, src, dest, folder, overwrite, includeAr
     else {
         absolutePath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve((0, path_2.getCwd)(), dest));
     }
-    logger('fetchFolderStarted', `${i18nKey}.fetchFolderStarted`, {
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.fetchFolderStarted`, {
         src,
         path: absolutePath,
         accountId,
-    });
-    await fetchFolderContents(accountId, folder, absolutePath, overwrite, includeArchived, logCallbacks);
-    logger('fetchFolderSuccess', `${i18nKey}.fetchFolderSuccess`, {
+    }));
+    await fetchFolderContents(accountId, folder, absolutePath, overwrite, includeArchived);
+    logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.fetchFolderSuccess`, {
         src,
         dest,
-    });
+    }));
 }
 // Download a single file and write to local file system.
-async function downloadSingleFile(accountId, src, dest, file, overwrite, includeArchived, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function downloadSingleFile(accountId, src, dest, file, overwrite, includeArchived) {
     if (!includeArchived && file.archived) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.archivedFile`, { src });
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.archivedFile`, { src }));
     }
     if (file.hidden) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.hiddenFile`, { src });
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.hiddenFile`, { src }));
     }
-    logger('fetchFileStarted', `${i18nKey}.fetchFileStarted`, {
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.fetchFileStarted`, {
         src,
         dest,
         accountId,
-    });
-    await downloadFile(accountId, file, dest, overwrite, logCallbacks);
-    logger('fetchFileSuccess', `${i18nKey}.fetchFileSuccess`, {
+    }));
+    await downloadFile(accountId, file, dest, overwrite);
+    logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.fetchFileSuccess`, {
         src,
         dest,
-    });
+    }));
 }
 // Lookup path in file manager and initiate download
-async function downloadFileOrFolder(accountId, src, dest, overwrite, includeArchived, logCallbacks) {
+async function downloadFileOrFolder(accountId, src, dest, overwrite, includeArchived) {
     try {
         if (src == '/') {
             // Filemanager API treats 'None' as the root
             const rootFolder = { id: 'None', name: '' };
-            await downloadFolder(accountId, src, dest, rootFolder, overwrite, includeArchived, logCallbacks);
+            await downloadFolder(accountId, src, dest, rootFolder, overwrite, includeArchived);
         }
         else {
-            const { file, folder } = await (0, fileManager_1.fetchStat)(accountId, src);
+            const { data: { file, folder }, } = await (0, fileManager_1.fetchStat)(accountId, src);
             if (file) {
-                await downloadSingleFile(accountId, src, dest, file, overwrite, includeArchived, logCallbacks);
+                await downloadSingleFile(accountId, src, dest, file, overwrite, includeArchived);
             }
             else if (folder) {
-                await downloadFolder(accountId, src, dest, folder, overwrite, includeArchived, logCallbacks);
+                await downloadFolder(accountId, src, dest, folder, overwrite, includeArchived);
             }
         }
     }
     catch (err) {
-        const error = err;
-        if (error.isAxiosError) {
-            (0, apiErrors_1.throwApiError)(err, {
+        if ((0, errors_1.isAuthError)(err)) {
+            err.updateContext({
                 request: src,
                 accountId,
             });
         }
-        else
-            (0, standardErrors_1.throwError)(error);
+        throw err;
     }
 }
 exports.downloadFileOrFolder = downloadFileOrFolder;

package/lib/fileMapper.d.ts

@@ -1,23 +1,13 @@
-import { FileMapperNode, Mode, FileMapperOptions, FileMapperInputOptions } from '../types/Files';
-import { LogCallbacksArg } from '../types/LogCallbacks';
-declare const filemapperCallbackKeys: readonly ["skippedExisting", "wroteFolder", "completedFetch", "folderFetch", "completedFolderFetch"];
+import { FileMapperNode, CmsPublishMode, FileMapperOptions, FileMapperInputOptions, PathTypeData, RecursiveFileMapperCallback } from '../types/Files';
 export declare function isPathToFile(filepath: string): boolean;
 export declare function isPathToModule(filepath: string): boolean;
 export declare function isPathToRoot(filepath: string): boolean;
 export declare function isPathToHubspot(filepath: string): boolean;
-export declare function getFileMapperQueryValues(mode?: Mode | null, { staging, assetVersion }?: FileMapperInputOptions): FileMapperOptions;
-type PathTypeData = {
-    isModule: boolean;
-    isHubspot: boolean;
-    isFile: boolean;
-    isRoot: boolean;
-    isFolder: boolean;
-};
+export declare function getFileMapperQueryValues(cmsPublishMode?: CmsPublishMode | null, { staging, assetVersion }?: FileMapperInputOptions): FileMapperOptions;
 export declare function getTypeDataFromPath(src: string): PathTypeData;
-type RecursiveFileMapperCallback = (node: FileMapperNode, filepath?: string, depth?: number) => boolean;
 export declare function recurseFolder(node: FileMapperNode, callback: RecursiveFileMapperCallback, filepath?: string, depth?: number): boolean;
 export declare function writeUtimes(accountId: number, filepath: string, node: FileMapperNode): Promise<void>;
-export declare function fetchFolderFromApi(accountId: number, src: string, mode?: Mode, options?: FileMapperInputOptions, logCallbacks?: LogCallbacksArg<typeof filemapperCallbackKeys>): Promise<FileMapperNode>;
+export declare function fetchFolderFromApi(accountId: number, src: string, cmsPublishMode?: CmsPublishMode, options?: FileMapperInputOptions): Promise<FileMapperNode>;
 /**
  * Fetch a file/folder and write to local file system.
  *
@@ -25,5 +15,4 @@ export declare function fetchFolderFromApi(accountId: number, src: string, mode?
  * @param {FileMapperInputArguments} input
  * @returns {Promise}
  */
-export declare function downloadFileOrFolder(accountId: number, src: string, dest: string, mode?: Mode, options?: FileMapperInputOptions, logCallbacks?: LogCallbacksArg<typeof filemapperCallbackKeys>): Promise<void>;
-export {};
+export declare function downloadFileOrFolder(accountId: number, src: string, dest: string, cmsPublishMode?: CmsPublishMode, options?: FileMapperInputOptions): Promise<void>;