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

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("./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 errors_1 = require("../errors");
+const lang_1 = require("../utils/lang");
+const FileSystemError_1 = require("../models/FileSystemError");
 const i18nKey = 'lib.fileMapper';
-const filemapperCallbackKeys = [
-    'skippedExisting',
-    'wroteFolder',
-    'completedFetch',
-    'folderFetch',
-    'completedFolderFetch',
-];
 const queue = new p_queue_1.default({
     concurrency: 10,
 });
@@ -49,14 +43,14 @@ function isPathToHubspot(filepath) {
     return /^(\/|\\)?@hubspot/i.test(filepath.trim());
 }
 exports.isPathToHubspot = isPathToHubspot;
-function useApiBuffer(mode) {
-    return mode === files_1.MODE.draft;
+function useApiBuffer(cmsPublishMode) {
+    return cmsPublishMode === files_1.CMS_PUBLISH_MODE.draft;
 }
-// Determines API param based on mode an options
-function getFileMapperQueryValues(mode, { staging, assetVersion } = {}) {
+// Determines API param based on publish mode and options
+function getFileMapperQueryValues(cmsPublishMode, { staging, assetVersion } = {}) {
     return {
         params: {
-            buffer: useApiBuffer(mode),
+            buffer: useApiBuffer(cmsPublishMode),
             environmentId: staging ? 2 : 1,
             version: assetVersion,
         },
@@ -82,9 +76,9 @@ function validateFileMapperNode(node) {
     catch (err) {
         json = node;
     }
-    (0, standardErrors_1.throwTypeErrorWithMessage)(`${i18nKey}.errors.invalidNode`, {
+    throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidNode`, {
         json: JSON.stringify(json),
-    });
+    }));
 }
 function getTypeDataFromPath(src) {
     const isModule = isPathToModule(src);
@@ -130,10 +124,10 @@ async function writeUtimes(accountId, filepath, node) {
         await fs_extra_1.default.utimes(filepath, atime, mtime);
     }
     catch (err) {
-        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
             filepath,
             accountId,
-            write: true,
+            operation: 'write',
         });
     }
 }
@@ -147,41 +141,33 @@ 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, cmsPublishMode, 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)) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidFileType`, { srcPath });
-    }
-    let node;
-    try {
-        node = await (0, fileMapper_1.fetchFileStream)(accountId, srcPath, filepath, getFileMapperQueryValues(mode, options));
-    }
-    catch (err) {
-        (0, standardErrors_1.throwError)(err);
+    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(cmsPublishMode, 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 = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function writeFileMapperNode(accountId, filepath, node, cmsPublishMode, 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, cmsPublishMode, options);
             return true;
         }
         catch (err) {
@@ -190,30 +176,25 @@ 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, {
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
             filepath: localFilepath,
             accountId,
-            write: true,
+            operation: 'write',
         });
-        return false;
     }
     return true;
 }
-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, cmsPublishMode, options = {}) {
     const { isFile, isHubspot } = getTypeDataFromPath(src);
+    if (!isFile) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidRequest`, { src }));
+    }
     try {
-        if (!isFile) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidRequest`, { src });
-        }
         const dest = path_1.default.resolve(destPath);
         const cwd = (0, path_2.getCwd)();
         let filepath;
@@ -233,56 +214,43 @@ 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, cmsPublishMode, 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;
-        if (isHubspot && isTimeout(error)) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.assetTimeout`, {}, error);
+        if (isHubspot && (0, errors_1.isTimeoutError)(error)) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.assetTimeout`), { cause: error });
         }
         else {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.failedToFetchFile`, { src, dest: destPath }, error);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchFile`, { src, dest: destPath }), { cause: error });
         }
     }
 }
-async function fetchFolderFromApi(accountId, src, mode, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function fetchFolderFromApi(accountId, src, cmsPublishMode, options = {}) {
     const { isRoot, isFolder, isHubspot } = getTypeDataFromPath(src);
     if (!isFolder) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidFetchFolderRequest`, {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidFetchFolderRequest`, {
             src,
-        });
-    }
-    try {
-        const srcPath = isRoot ? '@root' : src;
-        const queryValues = getFileMapperQueryValues(mode, options);
-        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 });
-        return node;
-    }
-    catch (err) {
-        const error = err;
-        if (isHubspot && isTimeout(error)) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.assetTimeout`, {}, error);
-        }
-        else {
-            (0, standardErrors_1.throwError)(error);
-        }
+        }));
     }
+    const srcPath = isRoot ? '@root' : src;
+    const queryValues = getFileMapperQueryValues(cmsPublishMode, 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 = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function downloadFolder(accountId, src, destPath, cmsPublishMode, options = {}) {
     try {
-        const node = await fetchFolderFromApi(accountId, src, mode, options, logCallbacks);
+        const node = await fetchFolderFromApi(accountId, src, cmsPublishMode, options);
         if (!node) {
             return;
         }
@@ -293,27 +261,38 @@ 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, cmsPublishMode, 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('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 });
+            // 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) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.failedToFetchFolder`, { src, dest: destPath }, 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 });
+        }
     }
 }
 /**
@@ -323,16 +302,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, cmsPublishMode, options = {}) {
     if (!src) {
         return;
     }
     const { isFile } = getTypeDataFromPath(src);
     if (isFile) {
-        await downloadFile(accountId, src, dest, mode, options, logCallbacks);
+        await downloadFile(accountId, src, dest, cmsPublishMode, options);
     }
     else {
-        await downloadFolder(accountId, src, dest, mode, options, logCallbacks);
+        await downloadFolder(accountId, src, dest, cmsPublishMode, options);
     }
 }
 exports.downloadFileOrFolder = downloadFileOrFolder;

package/lib/fs.d.ts

@@ -1,4 +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>>;
+export declare function walk(dir: string, ignoreDirs?: string[]): Promise<Array<string>>;

package/lib/fs.js

@@ -7,7 +7,7 @@ exports.walk = exports.flattenAndRemoveSymlinks = exports.getFileInfoAsync = voi
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const files_1 = require("../constants/files");
-const standardErrors_1 = require("../errors/standardErrors");
+const FileSystemError_1 = require("../models/FileSystemError");
 function getFileInfoAsync(dir, file) {
     return new Promise((resolve, reject) => {
         const filepath = path_1.default.join(dir, file);
@@ -42,11 +42,11 @@ function flattenAndRemoveSymlinks(filesData) {
     }, []);
 }
 exports.flattenAndRemoveSymlinks = flattenAndRemoveSymlinks;
-const generateRecursiveFilePromise = async (dir, file) => {
+const generateRecursiveFilePromise = async (dir, file, ignoreDirs) => {
     return getFileInfoAsync(dir, file).then(fileData => {
         return new Promise(resolve => {
             if (fileData.type === files_1.STAT_TYPES.DIRECTORY) {
-                walk(fileData.filepath).then(files => {
+                walk(fileData.filepath, ignoreDirs).then(files => {
                     resolve({ ...fileData, files });
                 });
             }
@@ -56,16 +56,20 @@ const generateRecursiveFilePromise = async (dir, file) => {
         });
     });
 };
-async function walk(dir) {
+async function walk(dir, ignoreDirs) {
     function processFiles(files) {
-        return Promise.all(files.map(file => generateRecursiveFilePromise(dir, file)));
+        // If the directory is in the ignore list, return an empty array to skip the directory contents
+        if (ignoreDirs?.some(ignored => dir.includes(ignored))) {
+            return [];
+        }
+        return Promise.all(files.map(file => generateRecursiveFilePromise(dir, file, ignoreDirs)));
     }
     return fs_1.default.promises
         .readdir(dir)
         .then(processFiles)
         .then(flattenAndRemoveSymlinks)
         .catch(err => {
-        (0, standardErrors_1.throwError)(err);
+        throw new FileSystemError_1.FileSystemError({ cause: err });
     });
 }
 exports.walk = walk;

package/lib/github.d.ts

@@ -1,17 +1,15 @@
 /// <reference types="node" />
-import { GithubReleaseData } from '../types/Github';
-import { LogCallbacksArg } from '../types/LogCallbacks';
-declare const cloneGithubRepoCallbackKeys: readonly ["success"];
-type RepoPath = `${string}/${string}`;
-export declare function fetchFileFromRepository(repoPath: RepoPath, filePath: string, ref: string): Promise<Buffer>;
+import { GithubReleaseData, GithubRepoFile, RepoPath, CloneGithubRepoOptions } from '../types/Github';
+/**
+ * @deprecated Use `fetchRepoFile` instead - this util is a thin wrapper around it
+ */
+export declare function fetchFileFromRepository<T = Buffer>(repoPath: RepoPath, filePath: string, ref: string): Promise<T>;
 export declare function fetchReleaseData(repoPath: RepoPath, tag?: string): Promise<GithubReleaseData>;
-type CloneGithubRepoOptions = {
-    isRelease?: boolean;
-    type?: string;
-    branch?: string;
-    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 fetchGitHubRepoContentFromDownloadUrl(dest: string, downloadUrl: string): Promise<void>;
+/**
+ * Writes files from a public repository to the destination folder
+  @deprecated - This method fetches all the files individually, which can hit rate limits for unauthorized requests. Use `cloneGithubRepo` instead.
+ */
 export declare function downloadGithubRepoContents(repoPath: RepoPath, contentPath: string, dest: string, ref?: string, filter?: (contentPiecePath: string, downloadPath: string) => boolean): Promise<void>;
-export {};
+export declare function listGithubRepoContents(repoPath: RepoPath, contentPath: string, fileFilter?: 'file' | 'dir'): Promise<GithubRepoFile[]>;

package/lib/github.js

@@ -3,25 +3,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadGithubRepoContents = exports.cloneGithubRepo = exports.fetchReleaseData = exports.fetchFileFromRepository = void 0;
+exports.listGithubRepoContents = exports.downloadGithubRepoContents = exports.fetchGitHubRepoContentFromDownloadUrl = exports.cloneGithubRepo = exports.fetchReleaseData = exports.fetchFileFromRepository = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
-const logger_1 = require("../utils/logger");
-const standardErrors_1 = require("../errors/standardErrors");
 const archive_1 = require("./archive");
+const logger_1 = require("./logger");
 const github_1 = require("../api/github");
+const lang_1 = require("../utils/lang");
+const errors_1 = require("../errors");
 const i18nKey = 'lib.github';
-const cloneGithubRepoCallbackKeys = ['success'];
+/**
+ * @deprecated Use `fetchRepoFile` instead - this util is a thin wrapper around it
+ */
 async function fetchFileFromRepository(repoPath, filePath, ref) {
     try {
-        (0, logger_1.debug)(`${i18nKey}.fetchFileFromRepository.fetching`, {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.fetchFileFromRepository.fetching`, {
             path: `${repoPath}/${ref}/${filePath}`,
-        });
+        }));
         const { data } = await (0, github_1.fetchRepoFile)(repoPath, filePath, ref);
         return data;
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.fetchFileFromRepository.errors.fetchFail`, {}, err);
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.fetchFileFromRepository.errors.fetchFail`), {
+            cause: err,
+        });
     }
 }
 exports.fetchFileFromRepository = fetchFileFromRepository;
@@ -38,8 +43,9 @@ async function fetchReleaseData(repoPath, tag) {
         return data;
     }
     catch (err) {
-        const error = err;
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.fetchReleaseData.errors.fetchFail`, { tag: tag || 'latest' }, error);
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.fetchReleaseData.errors.fetchFail`, {
+            tag: tag || 'latest',
+        }), { cause: err });
     }
 }
 exports.fetchReleaseData = fetchReleaseData;
@@ -53,48 +59,61 @@ async function downloadGithubRepoZip(repoPath, isRelease = false, options = {})
             const releaseData = await fetchReleaseData(repoPath, tag);
             zipUrl = releaseData.zipball_url;
             const { name } = releaseData;
-            (0, logger_1.debug)(`${i18nKey}.downloadGithubRepoZip.fetchingName`, { name });
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoZip.fetchingName`, { name }));
         }
         else {
             // If downloading a repository, manually construct the zip url. This url supports both branches and tags as refs
-            (0, logger_1.debug)(`${i18nKey}.downloadGithubRepoZip.fetching`, { repoPath });
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoZip.fetching`, { repoPath }));
             const ref = branch || tag;
             zipUrl = `https://api.github.com/repos/${repoPath}/zipball${ref ? `/${ref}` : ''}`;
         }
         const { data } = await (0, github_1.fetchRepoAsZip)(zipUrl);
-        (0, logger_1.debug)(`${i18nKey}.downloadGithubRepoZip.completed`);
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoZip.completed`));
         return data;
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.downloadGithubRepoZip.errors.fetchFail`, {}, err);
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoZip.errors.fetchFail`), {
+            cause: err,
+        });
     }
 }
-async function cloneGithubRepo(repoPath, dest, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
-    const { tag, isRelease, branch, sourceDir, type } = options;
+async function cloneGithubRepo(repoPath, dest, options = {}) {
+    const { tag, isRelease, branch, sourceDir, type, hideLogs } = options;
     const zip = await downloadGithubRepoZip(repoPath, isRelease, {
         tag,
         branch,
     });
     const repoName = repoPath.split('/')[1];
-    const success = await (0, archive_1.extractZipArchive)(zip, repoName, dest, { sourceDir });
-    if (success) {
-        logger('success', `${i18nKey}.cloneGithubRepo.success`, {
+    const success = await (0, archive_1.extractZipArchive)(zip, repoName, dest, {
+        sourceDir,
+        hideLogs,
+    });
+    if (success && !hideLogs) {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.cloneGithubRepo.success`, {
             type: type || '',
             dest,
-        });
+        }));
     }
     return success;
 }
 exports.cloneGithubRepo = cloneGithubRepo;
 async function fetchGitHubRepoContentFromDownloadUrl(dest, downloadUrl) {
     const resp = await (0, github_1.fetchRepoFileByDownloadUrl)(downloadUrl);
-    const fileContents = typeof resp.data === 'string'
-        ? resp.data
-        : JSON.stringify(resp.data, null, 2);
-    fs_extra_1.default.outputFileSync(dest, fileContents, 'utf8');
+    const contentType = resp.headers['content-type'];
+    let fileContents;
+    if (contentType.startsWith('text')) {
+        fileContents = Buffer.from(resp.data).toString('utf8');
+    }
+    else {
+        fileContents = resp.data;
+    }
+    fs_extra_1.default.outputFileSync(dest, fileContents);
 }
-// Writes files from a public repository to the destination folder
+exports.fetchGitHubRepoContentFromDownloadUrl = fetchGitHubRepoContentFromDownloadUrl;
+/**
+ * Writes files from a public repository to the destination folder
+  @deprecated - This method fetches all the files individually, which can hit rate limits for unauthorized requests. Use `cloneGithubRepo` instead.
+ */
 async function downloadGithubRepoContents(repoPath, contentPath, dest, ref, filter) {
     fs_extra_1.default.ensureDirSync(path_1.default.dirname(dest));
     try {
@@ -105,11 +124,11 @@ async function downloadGithubRepoContents(repoPath, contentPath, dest, ref, filt
             if (filter && !filter(contentPiecePath, downloadPath)) {
                 return Promise.resolve();
             }
-            (0, logger_1.debug)(`${i18nKey}.downloadGithubRepoContents.downloading`, {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoContents.downloading`, {
                 contentPiecePath,
                 downloadUrl: download_url,
                 downloadPath,
-            });
+            }));
             if (contentPieceType === 'dir') {
                 const { data: innerDirContent } = await (0, github_1.fetchRepoContents)(repoPath, contentPiecePath, ref);
                 await Promise.all(innerDirContent.map(downloadContent));
@@ -127,15 +146,31 @@ async function downloadGithubRepoContents(repoPath, contentPath, dest, ref, filt
         await Promise.all(contentPromises);
     }
     catch (e) {
-        const error = e;
-        if (error?.error?.message) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.downloadGithubRepoContents.errors.fetchFail`, {
-                errorMessage: error.error.message,
-            }, error);
-        }
-        else {
-            (0, standardErrors_1.throwError)(error);
+        if ((0, errors_1.isSystemError)(e) && e?.error?.message) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoContents.errors.fetchFail`, {
+                errorMessage: e.error.message,
+            }), { cause: e });
         }
+        throw e;
     }
 }
 exports.downloadGithubRepoContents = downloadGithubRepoContents;
+// Lists content from a public repository at the specified path
+async function listGithubRepoContents(repoPath, contentPath, fileFilter) {
+    try {
+        const { data: contentsResp } = await (0, github_1.fetchRepoContents)(repoPath, contentPath);
+        const filteredFiles = fileFilter && fileFilter != undefined
+            ? contentsResp.filter(item => item.type === fileFilter)
+            : contentsResp;
+        return filteredFiles;
+    }
+    catch (e) {
+        if ((0, errors_1.isHubSpotHttpError)(e) && e.data.message) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoContents.errors.fetchFail`, {
+                errorMessage: e.data.message,
+            }));
+        }
+        throw e;
+    }
+}
+exports.listGithubRepoContents = listGithubRepoContents;

package/lib/gitignore.d.ts

@@ -1 +1,3 @@
+import { GitInclusionResult } from '../types/Config';
 export declare function checkAndAddConfigToGitignore(configPath: string): void;
+export declare function checkGitInclusion(configPath: string): GitInclusionResult;

package/lib/gitignore.js

@@ -3,17 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkAndAddConfigToGitignore = void 0;
+exports.checkGitInclusion = exports.checkAndAddConfigToGitignore = void 0;
 const fs_extra_1 = require("fs-extra");
 const path_1 = __importDefault(require("path"));
 const git_1 = require("../utils/git");
 const config_1 = require("../constants/config");
-const standardErrors_1 = require("../errors/standardErrors");
+const lang_1 = require("../utils/lang");
 const i18nKey = 'lib.gitignore';
 const GITIGNORE_FILE = '.gitignore';
 function checkAndAddConfigToGitignore(configPath) {
     try {
-        const { configIgnored, gitignoreFiles } = (0, git_1.checkGitInclusion)(configPath);
+        const { configIgnored, gitignoreFiles } = checkGitInclusion(configPath);
         if (configIgnored)
             return;
         let gitignoreFilePath = gitignoreFiles && gitignoreFiles.length ? gitignoreFiles[0] : null;
@@ -26,7 +26,24 @@ function checkAndAddConfigToGitignore(configPath) {
         (0, fs_extra_1.writeFileSync)(gitignoreFilePath, updatedContents);
     }
     catch (e) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.configIgnore`, {}, e);
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.configIgnore`), { cause: e });
     }
 }
 exports.checkAndAddConfigToGitignore = checkAndAddConfigToGitignore;
+function checkGitInclusion(configPath) {
+    const result = {
+        inGit: false,
+        configIgnored: false,
+        gitignoreFiles: [],
+    };
+    if ((0, git_1.isConfigPathInGitRepo)(configPath)) {
+        result.inGit = true;
+        result.gitignoreFiles = (0, git_1.getGitignoreFiles)(configPath);
+        if ((0, git_1.configFilenameIsIgnoredByGitignore)(result.gitignoreFiles, configPath)) {
+            // Found ignore statement in .gitignore that matches config filename
+            result.configIgnored = true;
+        }
+    }
+    return result;
+}
+exports.checkGitInclusion = checkGitInclusion;

package/lib/hubdb.d.ts

@@ -1,4 +1,5 @@
-import { Row } from '../types/Hubdb';
+import { AxiosResponse } from 'axios';
+import { Row, Table } from '../types/Hubdb';
 export declare function addRowsToHubDbTable(accountId: number, tableId: string, rows?: Array<Row>): Promise<{
     tableId: string;
     rowCount: number;
@@ -7,7 +8,7 @@ export declare function createHubDbTable(accountId: number, src: string): Promis
     tableId: string;
     rowCount: number;
 }>;
-export declare function updateHubDbTable(accountId: number, tableId: string, src: string): Promise<unknown>;
+export declare function updateHubDbTable(accountId: number, tableId: string, src: string): Promise<AxiosResponse<Table, any>>;
 export declare function downloadHubDbTable(accountId: number, tableId: string, dest: string): Promise<{
     filePath: string;
 }>;