@hubspot/local-dev-lib 0.0.1-experimental.0

package/lib/customObjects.d.ts

@@ -0,0 +1,5 @@
+import { Schema } from '../types/Schemas';
+export declare function getResolvedPath(dest?: string, name?: string): string;
+export declare function writeSchemaToDisk(schema: Schema, dest?: string): Promise<void>;
+export declare function downloadSchemas(accountId: number, dest?: string): Promise<Array<Schema>>;
+export declare function downloadSchema(accountId: number, schemaObjectType: string, dest?: string): Promise<Schema>;

package/lib/customObjects.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadSchema = exports.downloadSchemas = exports.writeSchemaToDisk = exports.getResolvedPath = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const prettier_1 = __importDefault(require("prettier"));
+const path_2 = require("../lib/path");
+const customObjects_1 = require("../api/customObjects");
+function getResolvedPath(dest, name) {
+    if (name)
+        return path_1.default.resolve((0, path_2.getCwd)(), dest || '', `${name}.json`);
+    return path_1.default.resolve((0, path_2.getCwd)(), dest || '');
+}
+exports.getResolvedPath = getResolvedPath;
+async function writeSchemaToDisk(schema, dest) {
+    const formattedSchema = await prettier_1.default.format(JSON.stringify(schema), {
+        parser: 'json',
+    });
+    fs_extra_1.default.outputFileSync(getResolvedPath(dest, schema.name), formattedSchema);
+}
+exports.writeSchemaToDisk = writeSchemaToDisk;
+async function downloadSchemas(accountId, dest) {
+    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);
+        }
+    }
+    return response.results;
+}
+exports.downloadSchemas = downloadSchemas;
+async function downloadSchema(accountId, schemaObjectType, dest) {
+    const axiosResponse = await (0, customObjects_1.fetchObjectSchema)(accountId, schemaObjectType);
+    const response = axiosResponse.data;
+    await writeSchemaToDisk(response, dest);
+    return response;
+}
+exports.downloadSchema = downloadSchema;

package/lib/environment.d.ts

@@ -0,0 +1,2 @@
+import { Environment } from '../types/Config';
+export declare function getValidEnv(env?: Environment | null, maskedProductionValue?: Environment): Environment;

package/lib/environment.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidEnv = void 0;
+const environments_1 = require("../constants/environments");
+function getValidEnv(env, maskedProductionValue) {
+    const prodValue = typeof maskedProductionValue === 'string'
+        ? maskedProductionValue
+        : environments_1.ENVIRONMENTS.PROD;
+    const returnVal = typeof env &&
+        typeof env === 'string' &&
+        env.toLowerCase() === environments_1.ENVIRONMENTS.QA
+        ? environments_1.ENVIRONMENTS.QA
+        : prodValue;
+    return returnVal;
+}
+exports.getValidEnv = getValidEnv;

package/lib/escapeRegExp.d.ts

@@ -0,0 +1 @@
+export declare function escapeRegExp(string: string): string;

package/lib/escapeRegExp.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeRegExp = void 0;
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+exports.escapeRegExp = escapeRegExp;

package/lib/fileManager.d.ts

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,184 @@
+"use strict";
+// FILE MANAGER - not to be confused with fileMapper.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFileOrFolder = exports.uploadFolder = void 0;
+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("./logger");
+const ignoreRules_1 = require("./ignoreRules");
+const http_1 = require("../http");
+const escapeRegExp_1 = require("./escapeRegExp");
+const path_2 = require("./path");
+const lang_1 = require("../utils/lang");
+const errors_1 = require("../errors");
+const FileSystemError_1 = require("../models/FileSystemError");
+const i18nKey = 'lib.fileManager';
+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));
+    const len = filesToUpload.length;
+    for (let index = 0; index < len; index++) {
+        const file = filesToUpload[index];
+        const relativePath = file.replace(regex, '');
+        const destPath = (0, path_2.convertToUnixPath)(path_1.default.join(dest, relativePath));
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadStarted`, {
+            file,
+            destPath,
+            accountId,
+        }));
+        try {
+            await (0, fileManager_1.uploadFile)(accountId, file, destPath);
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.uploadSuccess`, { file, destPath }));
+        }
+        catch (err) {
+            if ((0, errors_1.isHubSpotHttpError)(err)) {
+                err.updateContext({
+                    filepath: file,
+                    dest: destPath,
+                });
+                throw err;
+            }
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.uploadFailed`, {
+                file,
+                destPath,
+            }));
+        }
+    }
+}
+exports.uploadFolder = uploadFolder;
+async function skipExisting(overwrite, filepath) {
+    if (overwrite) {
+        return false;
+    }
+    if (await fs_extra_1.default.pathExists(filepath)) {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.skippedExisting`, { filepath }));
+        return true;
+    }
+    return false;
+}
+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)) {
+        return;
+    }
+    await http_1.http.getOctetStream(accountId, {
+        baseURL: file.url,
+        url: '',
+    }, destPath);
+}
+async function fetchAllPagedFiles(accountId, folderId, includeArchived) {
+    let totalFiles = null;
+    let files = [];
+    let count = 0;
+    let offset = 0;
+    while (totalFiles === null || count < totalFiles) {
+        const { data: response } = await (0, fileManager_1.fetchFiles)(accountId, folderId, offset, includeArchived);
+        if (totalFiles === null) {
+            totalFiles = response.total_count;
+        }
+        count += response.objects.length;
+        offset += response.objects.length;
+        files = files.concat(response.objects);
+    }
+    return files;
+}
+async function fetchFolderContents(accountId, folder, dest, overwrite, includeArchived) {
+    try {
+        await fs_extra_1.default.ensureDir(dest);
+    }
+    catch (err) {
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+            dest,
+            accountId,
+            operation: 'write',
+        });
+    }
+    const files = await fetchAllPagedFiles(accountId, folder.id, includeArchived);
+    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);
+    }
+    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);
+    }
+}
+// Download a folder and write to local file system.
+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));
+    }
+    else {
+        absolutePath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve((0, path_2.getCwd)(), dest));
+    }
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.fetchFolderStarted`, {
+        src,
+        path: absolutePath,
+        accountId,
+    }));
+    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) {
+    if (!includeArchived && file.archived) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.archivedFile`, { src }));
+    }
+    if (file.hidden) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.hiddenFile`, { src }));
+    }
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.fetchFileStarted`, {
+        src,
+        dest,
+        accountId,
+    }));
+    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) {
+    try {
+        if (src == '/') {
+            // Filemanager API treats 'None' as the root
+            const rootFolder = { id: 'None', name: '' };
+            await downloadFolder(accountId, src, dest, rootFolder, overwrite, includeArchived);
+        }
+        else {
+            const { data: { file, folder }, } = await (0, fileManager_1.fetchStat)(accountId, src);
+            if (file) {
+                await downloadSingleFile(accountId, src, dest, file, overwrite, includeArchived);
+            }
+            else if (folder) {
+                await downloadFolder(accountId, src, dest, folder, overwrite, includeArchived);
+            }
+        }
+    }
+    catch (err) {
+        if ((0, errors_1.isAuthError)(err)) {
+            err.updateContext({
+                request: src,
+                accountId,
+            });
+        }
+        throw err;
+    }
+}
+exports.downloadFileOrFolder = downloadFileOrFolder;

package/lib/fileMapper.d.ts

@@ -0,0 +1,18 @@
+import { FileMapperNode, Mode, 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;
+export declare function getTypeDataFromPath(src: string): PathTypeData;
+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): Promise<FileMapperNode>;
+/**
+ * Fetch a file/folder and write to local file system.
+ *
+ * @async
+ * @param {FileMapperInputArguments} input
+ * @returns {Promise}
+ */
+export declare function downloadFileOrFolder(accountId: number, src: string, dest: string, mode?: Mode, options?: FileMapperInputOptions): Promise<void>;

package/lib/fileMapper.js

@@ -0,0 +1,317 @@
+"use strict";
+// FILE MAPPER - not to be confused with fileManager.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFileOrFolder = exports.fetchFolderFromApi = exports.writeUtimes = exports.recurseFolder = exports.getTypeDataFromPath = exports.getFileMapperQueryValues = exports.isPathToHubspot = exports.isPathToRoot = exports.isPathToModule = exports.isPathToFile = void 0;
+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("./logger");
+const fileMapper_1 = require("../api/fileMapper");
+const extensions_1 = require("../constants/extensions");
+const files_1 = require("../constants/files");
+const errors_1 = require("../errors");
+const lang_1 = require("../utils/lang");
+const FileSystemError_1 = require("../models/FileSystemError");
+const i18nKey = 'lib.fileMapper';
+const queue = new p_queue_1.default({
+    concurrency: 10,
+});
+function isPathToFile(filepath) {
+    const ext = (0, path_2.getExt)(filepath);
+    return !!ext && ext !== extensions_1.MODULE_EXTENSION && ext !== extensions_1.FUNCTIONS_EXTENSION;
+}
+exports.isPathToFile = isPathToFile;
+function isPathToModule(filepath) {
+    const ext = (0, path_2.getExt)(filepath);
+    return ext === extensions_1.MODULE_EXTENSION;
+}
+exports.isPathToModule = isPathToModule;
+function isPathToRoot(filepath) {
+    if (typeof filepath !== 'string')
+        return false;
+    // Root pattern matches empty strings and: / \
+    return /^(\/|\\)?$/.test(filepath.trim());
+}
+exports.isPathToRoot = isPathToRoot;
+function isPathToHubspot(filepath) {
+    if (typeof filepath !== 'string')
+        return false;
+    return /^(\/|\\)?@hubspot/i.test(filepath.trim());
+}
+exports.isPathToHubspot = isPathToHubspot;
+function useApiBuffer(mode) {
+    return mode === files_1.MODE.draft;
+}
+// Determines API param based on mode an options
+function getFileMapperQueryValues(mode, { staging, assetVersion } = {}) {
+    return {
+        params: {
+            buffer: useApiBuffer(mode),
+            environmentId: staging ? 2 : 1,
+            version: assetVersion,
+        },
+    };
+}
+exports.getFileMapperQueryValues = getFileMapperQueryValues;
+// Determines version number to log based on input.options
+function getAssetVersionIdentifier(assetVersion, src) {
+    if (typeof assetVersion !== 'undefined' &&
+        typeof src !== 'undefined' &&
+        src.startsWith('@hubspot/')) {
+        return ` v${assetVersion}`;
+    }
+    return '';
+}
+function validateFileMapperNode(node) {
+    if (node === Object(node))
+        return;
+    let json;
+    try {
+        json = JSON.stringify(node, null, 2);
+    }
+    catch (err) {
+        json = node;
+    }
+    throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidNode`, {
+        json: JSON.stringify(json),
+    }));
+}
+function getTypeDataFromPath(src) {
+    const isModule = isPathToModule(src);
+    const isHubspot = isPathToHubspot(src);
+    const isFile = !isModule && isPathToFile(src);
+    const isRoot = !isModule && !isFile && isPathToRoot(src);
+    const isFolder = !isFile;
+    return {
+        isModule,
+        isHubspot,
+        isFile,
+        isRoot,
+        isFolder,
+    };
+}
+exports.getTypeDataFromPath = getTypeDataFromPath;
+function recurseFolder(node, callback, filepath = '', depth = 0) {
+    validateFileMapperNode(node);
+    const isRootFolder = node.folder && depth === 0;
+    if (isRootFolder) {
+        if (!filepath) {
+            filepath = node.name;
+        }
+    }
+    else {
+        filepath = path_1.default.join(filepath, node.name);
+    }
+    let __break = callback(node, filepath, depth);
+    if (__break === false)
+        return __break;
+    __break = node.children.every(childNode => {
+        __break = recurseFolder(childNode, callback, filepath, depth + 1);
+        return __break !== false;
+    });
+    return depth === 0 ? false : __break;
+}
+exports.recurseFolder = recurseFolder;
+async function writeUtimes(accountId, filepath, node) {
+    try {
+        const now = new Date();
+        const atime = node.createdAt ? new Date(node.createdAt) : now;
+        const mtime = node.updatedAt ? new Date(node.updatedAt) : now;
+        await fs_extra_1.default.utimes(filepath, atime, mtime);
+    }
+    catch (err) {
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+            filepath,
+            accountId,
+            operation: 'write',
+        });
+    }
+}
+exports.writeUtimes = writeUtimes;
+async function skipExisting(filepath, overwrite = false) {
+    if (overwrite) {
+        return false;
+    }
+    if (await fs_extra_1.default.pathExists(filepath)) {
+        return true;
+    }
+    return false;
+}
+async function fetchAndWriteFileStream(accountId, srcPath, filepath, mode, options = {}) {
+    if (typeof srcPath !== 'string' || !srcPath.trim()) {
+        return;
+    }
+    if (await skipExisting(filepath, options.overwrite)) {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.skippedExisting`, { filepath }));
+        return;
+    }
+    if (!(0, path_2.isAllowedExtension)(srcPath, Array.from(extensions_1.JSR_ALLOWED_EXTENSIONS))) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidFileType`, { srcPath }));
+    }
+    const node = await (0, fileMapper_1.fetchFileStream)(accountId, srcPath, filepath, getFileMapperQueryValues(mode, options));
+    await writeUtimes(accountId, filepath, node);
+}
+// 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 = {}) {
+    const localFilepath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve(filepath));
+    if (await skipExisting(localFilepath, options.overwrite)) {
+        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);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    try {
+        await fs_extra_1.default.ensureDir(localFilepath);
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.wroteFolder`, {
+            filepath: localFilepath,
+        }));
+    }
+    catch (err) {
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+            filepath: localFilepath,
+            accountId,
+            operation: 'write',
+        });
+    }
+    return true;
+}
+async function downloadFile(accountId, src, destPath, mode, options = {}) {
+    const { isFile, isHubspot } = getTypeDataFromPath(src);
+    if (!isFile) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidRequest`, { src }));
+    }
+    try {
+        const dest = path_1.default.resolve(destPath);
+        const cwd = (0, path_2.getCwd)();
+        let filepath;
+        if (dest === cwd) {
+            // Dest: CWD
+            filepath = path_1.default.resolve(cwd, path_1.default.basename(src));
+        }
+        else if (isPathToFile(dest)) {
+            // Dest: file path
+            filepath = path_1.default.isAbsolute(dest) ? dest : path_1.default.resolve(cwd, dest);
+        }
+        else {
+            // Dest: folder path
+            const name = path_1.default.basename(src);
+            filepath = path_1.default.isAbsolute(dest)
+                ? path_1.default.resolve(dest, name)
+                : path_1.default.resolve(cwd, dest, name);
+        }
+        const localFsPath = (0, path_2.convertToLocalFileSystemPath)(filepath);
+        await fetchAndWriteFileStream(accountId, src, localFsPath, mode, options);
+        await queue.onIdle();
+        logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.completedFetch`, {
+            src,
+            version: getAssetVersionIdentifier(options.assetVersion, src),
+            dest,
+        }));
+    }
+    catch (err) {
+        const error = err;
+        if (isHubspot && (0, errors_1.isTimeoutError)(error)) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.assetTimeout`), { cause: error });
+        }
+        else {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchFile`, { src, dest: destPath }), { cause: error });
+        }
+    }
+}
+async function fetchFolderFromApi(accountId, src, mode, options = {}) {
+    const { isRoot, isFolder, isHubspot } = getTypeDataFromPath(src);
+    if (!isFolder) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidFetchFolderRequest`, {
+            src,
+        }));
+    }
+    const srcPath = isRoot ? '@root' : src;
+    const queryValues = getFileMapperQueryValues(mode, options);
+    const { data: node } = isHubspot
+        ? await (0, fileMapper_1.downloadDefault)(accountId, srcPath, queryValues)
+        : await (0, fileMapper_1.download)(accountId, srcPath, queryValues);
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.folderFetch`, { src, accountId }));
+    return node;
+}
+exports.fetchFolderFromApi = fetchFolderFromApi;
+async function downloadFolder(accountId, src, destPath, mode, options = {}) {
+    try {
+        const node = await fetchFolderFromApi(accountId, src, mode, options);
+        if (!node) {
+            return;
+        }
+        const dest = path_1.default.resolve(destPath);
+        const rootPath = dest === (0, path_2.getCwd)()
+            ? (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve(dest, node.name))
+            : dest;
+        let success = true;
+        recurseFolder(node, (childNode, filepath) => {
+            queue.add(async () => {
+                const succeeded = await writeFileMapperNode(accountId, filepath || '', childNode, mode, options);
+                if (succeeded === false) {
+                    success = false;
+                    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchFile`, {
+                        src: childNode.path,
+                        dest: filepath || '',
+                    }));
+                }
+            });
+            return success;
+        }, rootPath);
+        await queue.onIdle();
+        if (success) {
+            logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.completedFolderFetch`, {
+                src,
+                version: getAssetVersionIdentifier(options.assetVersion, src),
+                dest,
+            }));
+        }
+        else {
+            // TODO: Fix this exception. It is triggering the catch block so this error is being rewritten
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.incompleteFetch`, { src }));
+        }
+    }
+    catch (err) {
+        const error = err;
+        if ((0, errors_1.isTimeoutError)(error)) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.assetTimeout`), { cause: error });
+        }
+        else {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchFolder`, { src, dest: destPath }), { cause: err });
+        }
+    }
+}
+/**
+ * Fetch a file/folder and write to local file system.
+ *
+ * @async
+ * @param {FileMapperInputArguments} input
+ * @returns {Promise}
+ */
+async function downloadFileOrFolder(accountId, src, dest, mode, options = {}) {
+    if (!src) {
+        return;
+    }
+    const { isFile } = getTypeDataFromPath(src);
+    if (isFile) {
+        await downloadFile(accountId, src, dest, mode, options);
+    }
+    else {
+        await downloadFolder(accountId, src, dest, mode, options);
+    }
+}
+exports.downloadFileOrFolder = downloadFileOrFolder;

package/lib/fs.d.ts

@@ -0,0 +1,4 @@
+import { FileData } from '../types/Files';
+export declare function getFileInfoAsync(dir: string, file: string): Promise<FileData>;
+export declare function flattenAndRemoveSymlinks(filesData: Array<FileData>): Array<string>;
+export declare function walk(dir: string): Promise<Array<string>>;

package/lib/fs.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walk = exports.flattenAndRemoveSymlinks = exports.getFileInfoAsync = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const files_1 = require("../constants/files");
+const FileSystemError_1 = require("../models/FileSystemError");
+function getFileInfoAsync(dir, file) {
+    return new Promise((resolve, reject) => {
+        const filepath = path_1.default.join(dir, file);
+        fs_1.default.lstat(filepath, (error, stats) => {
+            if (error) {
+                reject(error);
+            }
+            let type = files_1.STAT_TYPES.FILE;
+            if (stats.isSymbolicLink()) {
+                type = files_1.STAT_TYPES.SYMBOLIC_LINK;
+            }
+            else if (stats.isDirectory()) {
+                type = files_1.STAT_TYPES.DIRECTORY;
+            }
+            resolve({ filepath, type });
+        });
+    });
+}
+exports.getFileInfoAsync = getFileInfoAsync;
+function flattenAndRemoveSymlinks(filesData) {
+    return filesData.reduce((acc, fileData) => {
+        switch (fileData.type) {
+            case files_1.STAT_TYPES.FILE:
+                return acc.concat(fileData.filepath);
+            case files_1.STAT_TYPES.DIRECTORY:
+                return acc.concat(fileData.files || []);
+            case files_1.STAT_TYPES.SYMBOLIC_LINK:
+                return acc;
+            default:
+                return acc;
+        }
+    }, []);
+}
+exports.flattenAndRemoveSymlinks = flattenAndRemoveSymlinks;
+const generateRecursiveFilePromise = async (dir, file) => {
+    return getFileInfoAsync(dir, file).then(fileData => {
+        return new Promise(resolve => {
+            if (fileData.type === files_1.STAT_TYPES.DIRECTORY) {
+                walk(fileData.filepath).then(files => {
+                    resolve({ ...fileData, files });
+                });
+            }
+            else {
+                resolve(fileData);
+            }
+        });
+    });
+};
+async function walk(dir) {
+    function processFiles(files) {
+        return Promise.all(files.map(file => generateRecursiveFilePromise(dir, file)));
+    }
+    return fs_1.default.promises
+        .readdir(dir)
+        .then(processFiles)
+        .then(flattenAndRemoveSymlinks)
+        .catch(err => {
+        throw new FileSystemError_1.FileSystemError({ cause: err });
+    });
+}
+exports.walk = walk;