@hubspot/local-dev-lib 0.0.11 → 0.1.0-experimental.0

package/lib/fileMapper.js

@@ -1,4 +1,5 @@
 "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 };
 };
@@ -8,13 +9,13 @@ 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 apiErrors_1 = require("../errors/apiErrors");
-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 queue = new p_queue_1.default({
     concurrency: 10,
@@ -42,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,
         },
@@ -75,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);
@@ -123,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',
         });
     }
 }
@@ -140,45 +141,33 @@ async function skipExisting(filepath, overwrite = false) {
     }
     return false;
 }
-const filemapperCallbackKeys = ['skippedExisting', 'wroteFolder'];
-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, apiErrors_1.throwStatusCodeError)(err, {
-            accountId,
-            request: srcPath,
-        });
+    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) {
@@ -187,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;
@@ -230,59 +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(err)) {
-            (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, apiErrors_1.throwStatusCodeError)(error, {
-                accountId,
-                request: src,
-            });
-        }
+        }));
     }
+    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.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);
@@ -65,7 +65,7 @@ async function walk(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,20 +1,8 @@
-import { GITHUB_RELEASE_TYPES } from '../constants/github';
-import { GithubReleaseData } from '../types/Github';
-import { ValueOf } from '../types/Utils';
-import { LogCallbacksArg } from '../types/LogCallbacks';
-declare global {
-    var githubToken: string;
-}
-type RepoPath = `${string}/${string}`;
-export declare function fetchJsonFromRepository(repoPath: RepoPath, filePath: string, ref: string): Promise<JSON>;
+/// <reference types="node" />
+import { GithubReleaseData, GithubRepoFile, RepoPath, CloneGithubRepoOptions } from '../types/Github';
+export declare function fetchFileFromRepository(repoPath: RepoPath, filePath: string, ref: string): Promise<Buffer>;
 export declare function fetchReleaseData(repoPath: RepoPath, tag?: string): Promise<GithubReleaseData>;
-type CloneGithubRepoOptions = {
-    themeVersion?: string;
-    projectVersion?: string;
-    releaseType?: ValueOf<typeof GITHUB_RELEASE_TYPES>;
-    ref?: string;
-};
-declare const cloneGithubRepoCallbackKeys: string[];
-export declare function cloneGithubRepo(dest: string, type: string, repoPath: RepoPath, sourceDir: 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>;
 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,123 +3,128 @@ 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.fetchJsonFromRepository = void 0;
-const axios_1 = __importDefault(require("axios"));
+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 github_1 = require("../constants/github");
-const getAxiosConfig_1 = require("../http/getAxiosConfig");
+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 GITHUB_AUTH_HEADERS = {
-    authorization: global && global.githubToken ? `Bearer ${global.githubToken}` : null,
-};
-async function fetchJsonFromRepository(repoPath, filePath, ref) {
+async function fetchFileFromRepository(repoPath, filePath, ref) {
     try {
-        const URL = `https://raw.githubusercontent.com/${repoPath}/${ref}/${filePath}`;
-        (0, logger_1.debug)(`${i18nKey}.fetchJsonFromRepository.fetching`, { url: URL });
-        const { data } = await axios_1.default.get(URL, {
-            headers: { ...getAxiosConfig_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
-        });
+        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}.fetchJsonFromRepository.errors.fetchFail`, {}, err);
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.fetchFileFromRepository.errors.fetchFail`), {
+            cause: err,
+        });
     }
 }
-exports.fetchJsonFromRepository = fetchJsonFromRepository;
-async function fetchReleaseData(repoPath, tag = '') {
-    tag = tag.trim().toLowerCase();
-    if (tag.length && tag[0] !== 'v') {
-        tag = `v${tag}`;
+exports.fetchFileFromRepository = fetchFileFromRepository;
+// Fetches information about a specific release (Defaults to latest)
+async function fetchReleaseData(repoPath, tag) {
+    if (tag) {
+        tag = tag.trim().toLowerCase();
+        if (tag.length && tag[0] !== 'v') {
+            tag = `v${tag}`;
+        }
     }
-    const URI = tag
-        ? `https://api.github.com/repos/${repoPath}/releases/tags/${tag}`
-        : `https://api.github.com/repos/${repoPath}/releases/latest`;
     try {
-        const { data } = await axios_1.default.get(URI, {
-            headers: { ...getAxiosConfig_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
-        });
+        const { data } = await (0, github_1.fetchRepoReleaseData)(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;
-async function downloadGithubRepoZip(repoPath, tag = '', releaseType = github_1.GITHUB_RELEASE_TYPES.RELEASE, ref) {
+async function downloadGithubRepoZip(repoPath, isRelease = false, options = {}) {
+    const { branch, tag } = options;
     try {
         let zipUrl;
-        if (releaseType === github_1.GITHUB_RELEASE_TYPES.REPOSITORY) {
-            (0, logger_1.debug)(`${i18nKey}.downloadGithubRepoZip.fetching`, {
-                releaseType,
-                repoPath,
-            });
-            zipUrl = `https://api.github.com/repos/${repoPath}/zipball${ref ? `/${ref}` : ''}`;
-        }
-        else {
+        if (isRelease) {
+            // If downloading a release, first get the release info using fetchReleaseData().
+            // Supports a custom tag, but will default to the latest release
             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 }));
         }
-        const { data } = await axios_1.default.get(zipUrl, {
-            headers: { ...getAxiosConfig_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
-        });
-        (0, logger_1.debug)(`${i18nKey}.downloadGithubRepoZip.completed`);
+        else {
+            // If downloading a repository, manually construct the zip url. This url supports both branches and tags as refs
+            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);
+        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,
+        });
     }
 }
-const cloneGithubRepoCallbackKeys = ['success'];
-async function cloneGithubRepo(dest, type, repoPath, sourceDir, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
-    const { themeVersion, projectVersion, releaseType, ref } = options;
-    const tag = projectVersion || themeVersion;
-    const zip = await downloadGithubRepoZip(repoPath, tag, releaseType, ref);
+async function cloneGithubRepo(repoPath, dest, options = {}) {
+    const { tag, isRelease, branch, sourceDir, type } = 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`, { type, dest });
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.cloneGithubRepo.success`, {
+            type: type || '',
+            dest,
+        }));
     }
     return success;
 }
 exports.cloneGithubRepo = cloneGithubRepo;
-async function getGitHubRepoContentsAtPath(repoPath, path, ref) {
-    const refQuery = ref ? `?ref=${ref}` : '';
-    const contentsRequestUrl = `https://api.github.com/repos/${repoPath}/contents/${path}${refQuery}`;
-    const response = await axios_1.default.get(contentsRequestUrl, {
-        headers: { ...getAxiosConfig_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
-    });
-    return response.data;
-}
 async function fetchGitHubRepoContentFromDownloadUrl(dest, downloadUrl) {
-    const resp = await axios_1.default.get(downloadUrl, {
-        headers: { ...getAxiosConfig_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
-    });
-    fs_extra_1.default.writeFileSync(dest, resp.data, 'utf8');
+    const resp = await (0, github_1.fetchRepoFileByDownloadUrl)(downloadUrl);
+    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);
 }
+exports.fetchGitHubRepoContentFromDownloadUrl = fetchGitHubRepoContentFromDownloadUrl;
 // Writes files from a public repository to the destination folder
 async function downloadGithubRepoContents(repoPath, contentPath, dest, ref, filter) {
     fs_extra_1.default.ensureDirSync(path_1.default.dirname(dest));
     try {
-        const contentsResp = await getGitHubRepoContentsAtPath(repoPath, contentPath, ref);
+        const { data: contentsResp } = await (0, github_1.fetchRepoContents)(repoPath, contentPath, ref);
         const downloadContent = async (contentPiece) => {
-            const { path: contentPiecePath, download_url } = contentPiece;
+            const { path: contentPiecePath, download_url, type: contentPieceType, } = contentPiece;
             const downloadPath = path_1.default.join(dest, contentPiecePath.replace(contentPath, ''));
             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));
+                return Promise.resolve();
+            }
             return fetchGitHubRepoContentFromDownloadUrl(downloadPath, download_url);
         };
         let contentPromises;
@@ -129,18 +134,34 @@ async function downloadGithubRepoContents(repoPath, contentPath, dest, ref, filt
         else {
             contentPromises = [downloadContent(contentsResp)];
         }
-        Promise.all(contentPromises);
+        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;