@hubspot/local-dev-lib 0.2.3 → 0.3.0

package/lib/cms/watch.js

@@ -18,35 +18,24 @@ const escapeRegExp_1 = require("../../utils/escapeRegExp");
 const path_2 = require("../path");
 const notify_1 = require("../../utils/notify");
 const themes_1 = require("./themes");
-const logger_1 = require("../../utils/logger");
-const logger_2 = require("../../utils/logger");
+const logger_1 = require("../logging/logger");
+const lang_1 = require("../../utils/lang");
 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);
+async function uploadFile(accountId, file, dest, options, mode = null) {
     const src = options.src;
     const absoluteSrcPath = path_1.default.resolve((0, path_2.getCwd)(), file);
     const themeJsonPath = (0, themes_1.getThemeJSONPath)(absoluteSrcPath);
@@ -55,11 +44,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,22 +60,22 @@ 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 });
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadAttempt`, { file, dest }));
     const apiOptions = (0, fileMapper_1.getFileMapperQueryValues)(mode, 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 });
+            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((error) => {
-                (0, logger_2.debug)(`${i18nKey}.uploadFailed`, {
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadFailed`, {
                     file,
                     dest,
-                });
+                }));
                 (0, apiErrors_1.throwApiUploadError)(error, {
                     accountId,
                     request: dest,
@@ -96,23 +85,22 @@ async function uploadFile(accountId, file, dest, options, mode = null, logCallba
         });
     });
 }
-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`, {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.deleteFailed`, {
                 remoteFilePath,
-            });
+            }));
             (0, apiErrors_1.throwApiError)(error, {
                 accountId,
                 request: remoteFilePath,
@@ -120,8 +108,7 @@ async function deleteRemoteFile(accountId, filePath, remoteFilePath, logCallback
         });
     });
 }
-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, { mode, remove, disableInitial, notify, commandOptions, filePaths, }, postInitialUploadCallback = null, onUploadFolderError, onQueueAddError) {
     const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(src)}`);
     if (notify) {
         (0, ignoreRules_1.ignoreFile)(notify);
@@ -137,11 +124,11 @@ 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`, {
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.folderUploadSuccess`, {
                 src,
                 dest,
                 accountId,
-            });
+            }));
             if (postInitialUploadCallback) {
                 postInitialUploadCallback(result);
             }
@@ -151,14 +138,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);
+        }, mode);
         (0, notify_1.triggerNotify)(notify, 'Added', filePath, uploadPromise);
     });
     if (remove) {
@@ -169,19 +156,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 +185,7 @@ function watch(accountId, src, dest, { mode, remove, disableInitial, notify, com
         const uploadPromise = uploadFile(accountId, filePath, destPath, {
             src,
             commandOptions,
-        }, mode, logCallbacks);
+        }, mode);
         (0, notify_1.triggerNotify)(notify, 'Changed', filePath, uploadPromise);
     });
     return watcher;

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,7 +9,7 @@ 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("./logging/logger");
 const ignoreRules_1 = require("./ignoreRules");
 const http_1 = __importDefault(require("../http"));
 const escapeRegExp_1 = require("../utils/escapeRegExp");
@@ -17,17 +17,9 @@ 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 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,14 +28,14 @@ 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;
@@ -58,21 +50,20 @@ async function uploadFolder(accountId, src, dest, logCallbacks) {
     }
 }
 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, {
@@ -96,7 +87,7 @@ 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);
     }
@@ -108,22 +99,21 @@ async function fetchFolderContents(accountId, folder, dest, overwrite, includeAr
         });
     }
     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);
     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,52 +121,51 @@ 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 });
     }
     if (file.hidden) {
         (0, standardErrors_1.throwErrorWithMessage)(`${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);
             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);
             }
         }
     }

package/lib/fileMapper.d.ts

@@ -1,6 +1,4 @@
 import { FileMapperNode, Mode, FileMapperOptions, FileMapperInputOptions } from '../types/Files';
-import { LogCallbacksArg } from '../types/LogCallbacks';
-declare const filemapperCallbackKeys: readonly ["skippedExisting", "wroteFolder", "completedFetch", "folderFetch", "completedFolderFetch"];
 export declare function isPathToFile(filepath: string): boolean;
 export declare function isPathToModule(filepath: string): boolean;
 export declare function isPathToRoot(filepath: string): boolean;
@@ -17,7 +15,7 @@ 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, mode?: Mode, options?: FileMapperInputOptions): Promise<FileMapperNode>;
 /**
  * Fetch a file/folder and write to local file system.
  *
@@ -25,5 +23,5 @@ 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 declare function downloadFileOrFolder(accountId: number, src: string, dest: string, mode?: Mode, options?: FileMapperInputOptions): Promise<void>;
 export {};

package/lib/fileMapper.js

@@ -9,20 +9,14 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const p_queue_1 = __importDefault(require("p-queue"));
 const path_2 = require("./path");
+const logger_1 = require("./logging/logger");
 const fileMapper_1 = require("../api/fileMapper");
 const standardErrors_1 = require("../errors/standardErrors");
 const extensions_1 = require("../constants/extensions");
 const files_1 = require("../constants/files");
 const fileSystemErrors_1 = require("../errors/fileSystemErrors");
-const logger_1 = require("../utils/logger");
+const lang_1 = require("../utils/lang");
 const i18nKey = 'lib.fileMapper';
-const filemapperCallbackKeys = [
-    'skippedExisting',
-    'wroteFolder',
-    'completedFetch',
-    'folderFetch',
-    'completedFolderFetch',
-];
 const queue = new p_queue_1.default({
     concurrency: 10,
 });
@@ -147,13 +141,12 @@ async function skipExisting(filepath, overwrite = false) {
     }
     return false;
 }
-async function fetchAndWriteFileStream(accountId, srcPath, filepath, mode, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function fetchAndWriteFileStream(accountId, srcPath, filepath, mode, options = {}) {
     if (typeof srcPath !== 'string' || !srcPath.trim()) {
         return;
     }
     if (await skipExisting(filepath, options.overwrite)) {
-        logger('skippedExisting', `${i18nKey}.skippedExisting`, { filepath });
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.skippedExisting`, { filepath }));
         return;
     }
     if (!(0, path_2.isAllowedExtension)(srcPath)) {
@@ -170,18 +163,17 @@ async function fetchAndWriteFileStream(accountId, srcPath, filepath, mode, optio
 }
 // Writes an individual file or folder (not recursive).  If file source is missing, the
 //file is fetched.
-async function writeFileMapperNode(accountId, filepath, node, mode, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function writeFileMapperNode(accountId, filepath, node, mode, options = {}) {
     const localFilepath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve(filepath));
     if (await skipExisting(localFilepath, options.overwrite)) {
-        logger('skippedExisting', `${i18nKey}.skippedExisting`, {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.skippedExisting`, {
             filepath: localFilepath,
-        });
+        }));
         return true;
     }
     if (!node.folder) {
         try {
-            await fetchAndWriteFileStream(accountId, node.path, localFilepath, mode, options, logCallbacks);
+            await fetchAndWriteFileStream(accountId, node.path, localFilepath, mode, options);
             return true;
         }
         catch (err) {
@@ -190,9 +182,9 @@ async function writeFileMapperNode(accountId, filepath, node, mode, options = {}
     }
     try {
         await fs_extra_1.default.ensureDir(localFilepath);
-        logger('wroteFolder', `${i18nKey}.wroteFolder`, {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.wroteFolder`, {
             filepath: localFilepath,
-        });
+        }));
     }
     catch (err) {
         (0, fileSystemErrors_1.throwFileSystemError)(err, {
@@ -207,8 +199,7 @@ async function writeFileMapperNode(accountId, filepath, node, mode, options = {}
 function isTimeout(err) {
     return !!err && (err.status === 408 || err.code === 'ESOCKETTIMEDOUT');
 }
-async function downloadFile(accountId, src, destPath, mode, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function downloadFile(accountId, src, destPath, mode, options = {}) {
     const { isFile, isHubspot } = getTypeDataFromPath(src);
     try {
         if (!isFile) {
@@ -233,13 +224,13 @@ async function downloadFile(accountId, src, destPath, mode, options = {}, logCal
                 : path_1.default.resolve(cwd, dest, name);
         }
         const localFsPath = (0, path_2.convertToLocalFileSystemPath)(filepath);
-        await fetchAndWriteFileStream(accountId, src, localFsPath, mode, options, logCallbacks);
+        await fetchAndWriteFileStream(accountId, src, localFsPath, mode, options);
         await queue.onIdle();
-        logger('completedFetch', `${i18nKey}.completedFetch`, {
+        logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.completedFetch`, {
             src,
             version: getAssetVersionIdentifier(options.assetVersion, src),
             dest,
-        });
+        }));
     }
     catch (err) {
         const error = err;
@@ -251,8 +242,7 @@ async function downloadFile(accountId, src, destPath, mode, options = {}, logCal
         }
     }
 }
-async function fetchFolderFromApi(accountId, src, mode, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function fetchFolderFromApi(accountId, src, mode, options = {}) {
     const { isRoot, isFolder, isHubspot } = getTypeDataFromPath(src);
     if (!isFolder) {
         (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidFetchFolderRequest`, {
@@ -265,7 +255,7 @@ async function fetchFolderFromApi(accountId, src, mode, options = {}, logCallbac
         const node = isHubspot
             ? await (0, fileMapper_1.downloadDefault)(accountId, srcPath, queryValues)
             : await (0, fileMapper_1.download)(accountId, srcPath, queryValues);
-        logger('folderFetch', `${i18nKey}.folderFetch`, { src, accountId });
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.folderFetch`, { src, accountId }));
         return node;
     }
     catch (err) {
@@ -279,10 +269,9 @@ async function fetchFolderFromApi(accountId, src, mode, options = {}, logCallbac
     }
 }
 exports.fetchFolderFromApi = fetchFolderFromApi;
-async function downloadFolder(accountId, src, destPath, mode, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function downloadFolder(accountId, src, destPath, mode, options = {}) {
     try {
-        const node = await fetchFolderFromApi(accountId, src, mode, options, logCallbacks);
+        const node = await fetchFolderFromApi(accountId, src, mode, options);
         if (!node) {
             return;
         }
@@ -293,7 +282,7 @@ async function downloadFolder(accountId, src, destPath, mode, options = {}, logC
         let success = true;
         recurseFolder(node, (childNode, filepath) => {
             queue.add(async () => {
-                const succeeded = await writeFileMapperNode(accountId, filepath || '', childNode, mode, options, logCallbacks);
+                const succeeded = await writeFileMapperNode(accountId, filepath || '', childNode, mode, options);
                 if (succeeded === false) {
                     success = false;
                 }
@@ -302,11 +291,11 @@ async function downloadFolder(accountId, src, destPath, mode, options = {}, logC
         }, rootPath);
         await queue.onIdle();
         if (success) {
-            logger('completedFolderFetch', `${i18nKey}.completedFolderFetch`, {
+            logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.completedFolderFetch`, {
                 src,
                 version: getAssetVersionIdentifier(options.assetVersion, src),
                 dest,
-            });
+            }));
         }
         else {
             (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.incompleteFetch`, { src });
@@ -323,16 +312,16 @@ async function downloadFolder(accountId, src, destPath, mode, options = {}, logC
  * @param {FileMapperInputArguments} input
  * @returns {Promise}
  */
-async function downloadFileOrFolder(accountId, src, dest, mode, options = {}, logCallbacks) {
+async function downloadFileOrFolder(accountId, src, dest, mode, options = {}) {
     if (!src) {
         return;
     }
     const { isFile } = getTypeDataFromPath(src);
     if (isFile) {
-        await downloadFile(accountId, src, dest, mode, options, logCallbacks);
+        await downloadFile(accountId, src, dest, mode, options);
     }
     else {
-        await downloadFolder(accountId, src, dest, mode, options, logCallbacks);
+        await downloadFolder(accountId, src, dest, mode, options);
     }
 }
 exports.downloadFileOrFolder = downloadFileOrFolder;

package/lib/github.d.ts

@@ -1,7 +1,5 @@
 /// <reference types="node" />
-import { GithubReleaseData } from '../types/Github';
-import { LogCallbacksArg } from '../types/LogCallbacks';
-declare const cloneGithubRepoCallbackKeys: readonly ["success"];
+import { GithubReleaseData, GithubRepoFile } from '../types/Github';
 type RepoPath = `${string}/${string}`;
 export declare function fetchFileFromRepository(repoPath: RepoPath, filePath: string, ref: string): Promise<Buffer>;
 export declare function fetchReleaseData(repoPath: RepoPath, tag?: string): Promise<GithubReleaseData>;
@@ -12,6 +10,7 @@ type CloneGithubRepoOptions = {
     tag?: string;
     sourceDir?: string;
 };
-export declare function cloneGithubRepo(repoPath: RepoPath, dest: string, options?: CloneGithubRepoOptions, logCallbacks?: LogCallbacksArg<typeof cloneGithubRepoCallbackKeys>): Promise<boolean>;
+export declare function cloneGithubRepo(repoPath: RepoPath, dest: string, options?: CloneGithubRepoOptions): Promise<boolean>;
 export declare function downloadGithubRepoContents(repoPath: RepoPath, contentPath: string, dest: string, ref?: string, filter?: (contentPiecePath: string, downloadPath: string) => boolean): Promise<void>;
+export declare function listGithubRepoContents(repoPath: RepoPath, contentPath: string, fileFilter?: 'file' | 'dir'): Promise<GithubRepoFile[]>;
 export {};