@hubspot/local-dev-lib 0.0.4 → 0.0.6

package/lib/fileMapper.js

@@ -0,0 +1,322 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFileOrFolder = exports.getFileMapperQueryValues = 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 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 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;
+}
+function isPathToModule(filepath) {
+    const ext = (0, path_2.getExt)(filepath);
+    return ext === extensions_1.MODULE_EXTENSION;
+}
+function isPathToRoot(filepath) {
+    if (typeof filepath !== 'string')
+        return false;
+    // Root pattern matches empty strings and: / \
+    return /^(\/|\\)?$/.test(filepath.trim());
+}
+function isPathToHubspot(filepath) {
+    if (typeof filepath !== 'string')
+        return false;
+    return /^(\/|\\)?@hubspot/i.test(filepath.trim());
+}
+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;
+    }
+    (0, standardErrors_1.throwTypeErrorWithMessage)('filemapper.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,
+    };
+}
+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;
+}
+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) {
+        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+            filepath,
+            accountId,
+            write: true,
+        });
+    }
+}
+async function skipExisting(filepath, overwrite = false) {
+    if (overwrite) {
+        return false;
+    }
+    if (await fs_extra_1.default.pathExists(filepath)) {
+        return true;
+    }
+    return false;
+}
+const filemapperCallbackKeys = ['skippedExisting', 'wroteFolder'];
+async function fetchAndWriteFileStream(accountId, srcPath, filepath, mode, options = {}, logCallbacks) {
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'filemapper');
+    if (typeof srcPath !== 'string' || !srcPath.trim()) {
+        return;
+    }
+    if (await skipExisting(filepath, options.overwrite)) {
+        logger('skippedExisting', { filepath });
+        return;
+    }
+    if (!(0, path_2.isAllowedExtension)(srcPath)) {
+        (0, standardErrors_1.throwErrorWithMessage)('filemapper.invalidFileType', { srcPath });
+    }
+    try {
+        const node = await (0, fileMapper_1.fetchFileStream)(accountId, srcPath, filepath, getFileMapperQueryValues(mode, options));
+        await writeUtimes(accountId, filepath, node);
+    }
+    catch (err) {
+        (0, apiErrors_1.throwStatusCodeError)(err, {
+            accountId,
+            request: srcPath,
+        });
+    }
+}
+// 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, 'filemapper');
+    const localFilepath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve(filepath));
+    if (await skipExisting(localFilepath, options.overwrite)) {
+        logger('skippedExisting', { filepath: localFilepath });
+        return true;
+    }
+    if (!node.folder) {
+        try {
+            await fetchAndWriteFileStream(accountId, node.path, localFilepath, mode, options, logCallbacks);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    try {
+        await fs_extra_1.default.ensureDir(localFilepath);
+        logger('wroteFolder', { filepath: localFilepath });
+    }
+    catch (err) {
+        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+            filepath: localFilepath,
+            accountId,
+            write: true,
+        });
+        return false;
+    }
+    return true;
+}
+function isTimeout(err) {
+    return !!err && (err.statusCode === 408 || err.code === 'ESOCKETTIMEDOUT');
+}
+async function downloadFile(accountId, src, destPath, mode, options = {}, logCallbacks) {
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'filemapper');
+    const { isFile, isHubspot } = getTypeDataFromPath(src);
+    try {
+        if (!isFile) {
+            throw new Error(`Invalid request for file: "${src}"`);
+        }
+        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, logCallbacks);
+        await queue.onIdle();
+        logger('completedFetch', {
+            src,
+            version: getAssetVersionIdentifier(options.assetVersion, src),
+            dest,
+        });
+    }
+    catch (err) {
+        const error = err;
+        if (isHubspot && isTimeout(err)) {
+            (0, standardErrors_1.throwErrorWithMessage)('filemapper.assetTimeout', {}, error);
+        }
+        else {
+            (0, standardErrors_1.throwErrorWithMessage)('filemapper.failedToFetchFile', { src, dest: destPath }, error);
+        }
+    }
+}
+async function fetchFolderFromApi(accountId, src, mode, options = {}, logCallbacks) {
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'filemapper');
+    const { isRoot, isFolder, isHubspot } = getTypeDataFromPath(src);
+    if (!isFolder) {
+        (0, standardErrors_1.throwErrorWithMessage)('filemapper.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', { src, accountId });
+        return node;
+    }
+    catch (err) {
+        const error = err;
+        if (isHubspot && isTimeout(error)) {
+            (0, standardErrors_1.throwErrorWithMessage)('filemapper.assetTimeout', {}, error);
+        }
+        else {
+            (0, apiErrors_1.throwStatusCodeError)(error, {
+                accountId,
+                request: src,
+            });
+        }
+    }
+}
+async function downloadFolder(accountId, src, destPath, mode, options = {}, logCallbacks) {
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'filemapper');
+    try {
+        const node = await fetchFolderFromApi(accountId, src, mode, options, logCallbacks);
+        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, logCallbacks);
+                if (succeeded === false) {
+                    success = false;
+                }
+            });
+            return success;
+        }, rootPath);
+        await queue.onIdle();
+        if (success) {
+            logger('completedFolderFetch', {
+                src,
+                version: getAssetVersionIdentifier(options.assetVersion, src),
+                dest,
+            });
+        }
+        else {
+            (0, standardErrors_1.throwErrorWithMessage)('filemapper.incompleteFetch', { src });
+        }
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)('filemapper.failedToFetchFolder', { src, dest: destPath }, 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 = {}, logCallbacks) {
+    if (!src) {
+        return;
+    }
+    const { isFile } = getTypeDataFromPath(src);
+    if (isFile) {
+        await downloadFile(accountId, src, dest, mode, options, logCallbacks);
+    }
+    else {
+        await downloadFolder(accountId, src, dest, mode, options, logCallbacks);
+    }
+}
+exports.downloadFileOrFolder = downloadFileOrFolder;

package/lib/github.d.ts

@@ -1,10 +1,13 @@
 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;
 }
-export declare function fetchJsonFromRepository(repoName: string, filePath: string): Promise<JSON>;
+type RepoPath = `${string}/${string}`;
+export declare function fetchJsonFromRepository(repoPath: RepoPath, filePath: string, ref: string): Promise<JSON>;
+export declare function fetchReleaseData(repoPath: RepoPath, tag?: string): Promise<GithubReleaseData>;
 type CloneGithubRepoOptions = {
     themeVersion?: string;
     projectVersion?: string;
@@ -12,6 +15,6 @@ type CloneGithubRepoOptions = {
     ref?: string;
 };
 declare const cloneGithubRepoCallbackKeys: string[];
-export declare function cloneGithubRepo(dest: string, type: string, repoName: string, sourceDir: string, options?: CloneGithubRepoOptions, logCallbacks?: LogCallbacksArg<typeof cloneGithubRepoCallbackKeys>): Promise<boolean>;
-export declare function downloadGithubRepoContents(repoName: string, contentPath: string, dest: string, filter?: (contentPiecePath: string, downloadPath: string) => boolean): Promise<void>;
+export declare function cloneGithubRepo(dest: string, type: string, repoPath: RepoPath, sourceDir: string, options?: CloneGithubRepoOptions, logCallbacks?: LogCallbacksArg<typeof cloneGithubRepoCallbackKeys>): Promise<boolean>;
+export declare function downloadGithubRepoContents(repoPath: RepoPath, contentPath: string, dest: string, ref?: string, filter?: (contentPiecePath: string, downloadPath: string) => boolean): Promise<void>;
 export {};

package/lib/github.js

@@ -3,7 +3,7 @@ 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.fetchJsonFromRepository = void 0;
+exports.downloadGithubRepoContents = exports.cloneGithubRepo = exports.fetchReleaseData = exports.fetchJsonFromRepository = void 0;
 const axios_1 = __importDefault(require("axios"));
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
@@ -11,16 +11,16 @@ const logger_1 = require("../utils/logger");
 const standardErrors_1 = require("../errors/standardErrors");
 const archive_1 = require("./archive");
 const github_1 = require("../constants/github");
-const requestOptions_1 = require("../http/requestOptions");
+const getAxiosConfig_1 = require("../http/getAxiosConfig");
 const GITHUB_AUTH_HEADERS = {
     authorization: global && global.githubToken ? `Bearer ${global.githubToken}` : null,
 };
-async function fetchJsonFromRepository(repoName, filePath) {
+async function fetchJsonFromRepository(repoPath, filePath, ref) {
     try {
-        const URI = `https://raw.githubusercontent.com/HubSpot/${repoName}/${filePath}`;
-        (0, logger_1.debug)('github.fetchJsonFromRepository', { uri: URI });
-        const { data } = await axios_1.default.get(URI, {
-            headers: { ...requestOptions_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
+        const URL = `https://raw.githubusercontent.com/${repoPath}/${ref}/${filePath}`;
+        (0, logger_1.debug)('github.fetchJsonFromRepository', { url: URL });
+        const { data } = await axios_1.default.get(URL, {
+            headers: { ...getAxiosConfig_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
         });
         return data;
     }
@@ -29,17 +29,17 @@ async function fetchJsonFromRepository(repoName, filePath) {
     }
 }
 exports.fetchJsonFromRepository = fetchJsonFromRepository;
-async function fetchReleaseData(repoName, tag = '') {
+async function fetchReleaseData(repoPath, tag = '') {
     tag = tag.trim().toLowerCase();
     if (tag.length && tag[0] !== 'v') {
         tag = `v${tag}`;
     }
     const URI = tag
-        ? `https://api.github.com/repos/HubSpot/${repoName}/releases/tags/${tag}`
-        : `https://api.github.com/repos/HubSpot/${repoName}/releases/latest`;
+        ? `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: { ...requestOptions_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
+            headers: { ...getAxiosConfig_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
         });
         return data;
     }
@@ -48,21 +48,22 @@ async function fetchReleaseData(repoName, tag = '') {
         (0, standardErrors_1.throwErrorWithMessage)('github.fetchReleaseData', { tag: tag || 'latest' }, error);
     }
 }
-async function downloadGithubRepoZip(repoName, tag = '', releaseType = github_1.GITHUB_RELEASE_TYPES.RELEASE, ref) {
+exports.fetchReleaseData = fetchReleaseData;
+async function downloadGithubRepoZip(repoPath, tag = '', releaseType = github_1.GITHUB_RELEASE_TYPES.RELEASE, ref) {
     try {
         let zipUrl;
         if (releaseType === github_1.GITHUB_RELEASE_TYPES.REPOSITORY) {
-            (0, logger_1.debug)('github.downloadGithubRepoZip.fetching', { releaseType, repoName });
-            zipUrl = `https://api.github.com/repos/HubSpot/${repoName}/zipball${ref ? `/${ref}` : ''}`;
+            (0, logger_1.debug)('github.downloadGithubRepoZip.fetching', { releaseType, repoPath });
+            zipUrl = `https://api.github.com/repos/${repoPath}/zipball${ref ? `/${ref}` : ''}`;
         }
         else {
-            const releaseData = await fetchReleaseData(repoName, tag);
+            const releaseData = await fetchReleaseData(repoPath, tag);
             zipUrl = releaseData.zipball_url;
             const { name } = releaseData;
             (0, logger_1.debug)('github.downloadGithubRepoZip.fetchingName', { name });
         }
         const { data } = await axios_1.default.get(zipUrl, {
-            headers: { ...requestOptions_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
+            headers: { ...getAxiosConfig_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
         });
         (0, logger_1.debug)('github.downloadGithubRepoZip.completed');
         return data;
@@ -72,11 +73,12 @@ async function downloadGithubRepoZip(repoName, tag = '', releaseType = github_1.
     }
 }
 const cloneGithubRepoCallbackKeys = ['success'];
-async function cloneGithubRepo(dest, type, repoName, sourceDir, options = {}, logCallbacks) {
+async function cloneGithubRepo(dest, type, repoPath, sourceDir, options = {}, logCallbacks) {
     const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'github.cloneGithubRepo');
     const { themeVersion, projectVersion, releaseType, ref } = options;
     const tag = projectVersion || themeVersion;
-    const zip = await downloadGithubRepoZip(repoName, tag, releaseType, ref);
+    const zip = await downloadGithubRepoZip(repoPath, tag, releaseType, ref);
+    const repoName = repoPath.split('/')[1];
     const success = await (0, archive_1.extractZipArchive)(zip, repoName, dest, { sourceDir });
     if (success) {
         logger('success', { type, dest });
@@ -84,24 +86,25 @@ async function cloneGithubRepo(dest, type, repoName, sourceDir, options = {}, lo
     return success;
 }
 exports.cloneGithubRepo = cloneGithubRepo;
-async function getGitHubRepoContentsAtPath(repoName, path) {
-    const contentsRequestUrl = `https://api.github.com/repos/HubSpot/${repoName}/contents/${path}`;
+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: { ...requestOptions_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
+        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: { ...requestOptions_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
+        headers: { ...getAxiosConfig_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
     });
     fs_extra_1.default.writeFileSync(dest, resp.data, 'utf8');
 }
-// Writes files from a HubSpot public repository to the destination folder
-async function downloadGithubRepoContents(repoName, contentPath, dest, filter) {
+// 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(repoName, contentPath);
+        const contentsResp = await getGitHubRepoContentsAtPath(repoPath, contentPath, ref);
         const downloadContent = async (contentPiece) => {
             const { path: contentPiecePath, download_url } = contentPiece;
             const downloadPath = path_1.default.join(dest, contentPiecePath.replace(contentPath, ''));
@@ -115,12 +118,18 @@ async function downloadGithubRepoContents(repoName, contentPath, dest, filter) {
             });
             return fetchGitHubRepoContentFromDownloadUrl(downloadPath, download_url);
         };
-        const contentPromises = contentsResp.map(downloadContent);
+        let contentPromises;
+        if (Array.isArray(contentsResp)) {
+            contentPromises = contentsResp.map(downloadContent);
+        }
+        else {
+            contentPromises = [downloadContent(contentsResp)];
+        }
         Promise.all(contentPromises);
     }
     catch (e) {
         const error = e;
-        if (error.error.message) {
+        if (error?.error?.message) {
             (0, standardErrors_1.throwErrorWithMessage)('github.downloadGithubRepoContents', {
                 errorMessage: error.error.message,
             }, error);

package/lib/gitignore.js

@@ -6,58 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkAndAddConfigToGitignore = void 0;
 const fs_extra_1 = require("fs-extra");
 const path_1 = __importDefault(require("path"));
-const findup_sync_1 = __importDefault(require("findup-sync"));
 const git_1 = require("../utils/git");
 const config_1 = require("../constants/config");
 const standardErrors_1 = require("../errors/standardErrors");
 const GITIGNORE_FILE = '.gitignore';
-// Get all .gitignore files since they can cascade down directory structures
-function getGitignoreFiles(configPath) {
-    const gitDir = (0, git_1.getGitComparisonDir)();
-    const files = [];
-    if (!gitDir) {
-        // Not in git
-        return files;
-    }
-    // Start findup from config dir
-    let cwd = configPath && path_1.default.dirname(configPath);
-    while (cwd) {
-        const ignorePath = (0, findup_sync_1.default)(GITIGNORE_FILE, { cwd });
-        const ignorePathComparisonDir = (0, git_1.makeComparisonDir)(ignorePath);
-        const gitComparisonDir = (0, git_1.makeComparisonDir)(gitDir);
-        if (ignorePath &&
-            ignorePathComparisonDir &&
-            gitComparisonDir &&
-            ignorePathComparisonDir.startsWith(gitComparisonDir)) {
-            const file = path_1.default.resolve(ignorePath);
-            files.push(file);
-            cwd = path_1.default.resolve(path_1.default.dirname(file) + '..');
-        }
-        else {
-            cwd = null;
-        }
-    }
-    return files;
-}
-function checkGitInclusion(configPath) {
-    const result = {
-        inGit: false,
-        configIgnored: false,
-        gitignoreFiles: [],
-    };
-    if ((0, git_1.isConfigPathInGitRepo)(configPath)) {
-        result.inGit = true;
-        result.gitignoreFiles = getGitignoreFiles(configPath);
-        if ((0, git_1.configFilenameIsIgnoredByGitignore)(result.gitignoreFiles, configPath)) {
-            // Found ignore statement in .gitignore that matches config filename
-            result.configIgnored = true;
-        }
-    }
-    return result;
-}
 function checkAndAddConfigToGitignore(configPath) {
     try {
-        const { configIgnored, gitignoreFiles } = checkGitInclusion(configPath);
+        const { configIgnored, gitignoreFiles } = (0, git_1.checkGitInclusion)(configPath);
         if (configIgnored)
             return;
         let gitignoreFilePath = gitignoreFiles && gitignoreFiles.length ? gitignoreFiles[0] : null;

package/lib/hubdb.d.ts

@@ -0,0 +1,16 @@
+import { Row } from '../types/Hubdb';
+export declare function addRowsToHubDbTable(accountId: number, tableId: string, rows: Array<Row>): Promise<{
+    tableId: string;
+    rowCount: number;
+}>;
+export declare function createHubDbTable(accountId: number, src: string): Promise<{
+    tableId: string;
+    rowCount: number;
+}>;
+export declare function updateHubDbTable(accountId: number, tableId: string, src: string): Promise<unknown>;
+export declare function downloadHubDbTable(accountId: number, tableId: string, dest: string): Promise<{
+    filePath: string;
+}>;
+export declare function clearHubDbTableRows(accountId: number, tableId: string): Promise<{
+    deletedRowCount: number;
+}>;