@hubspot/local-dev-lib 4.0.4 → 5.0.0-beta.1

package/lib/fs.js

@@ -1,51 +1,43 @@
-"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) {
+import fs from 'fs';
+import path from 'path';
+import { STAT_TYPES } from '../constants/files.js';
+import { FileSystemError } from '../models/FileSystemError.js';
+export function getFileInfoAsync(dir, file) {
     return new Promise((resolve, reject) => {
-        const filepath = path_1.default.join(dir, file);
-        fs_1.default.lstat(filepath, (error, stats) => {
+        const filepath = path.join(dir, file);
+        fs.lstat(filepath, (error, stats) => {
             if (error) {
                 reject(error);
             }
-            let type = files_1.STAT_TYPES.FILE;
+            let type = STAT_TYPES.FILE;
             if (stats.isSymbolicLink()) {
-                type = files_1.STAT_TYPES.SYMBOLIC_LINK;
+                type = STAT_TYPES.SYMBOLIC_LINK;
             }
             else if (stats.isDirectory()) {
-                type = files_1.STAT_TYPES.DIRECTORY;
+                type = STAT_TYPES.DIRECTORY;
             }
             resolve({ filepath, type });
         });
     });
 }
-exports.getFileInfoAsync = getFileInfoAsync;
-function flattenAndRemoveSymlinks(filesData) {
+export function flattenAndRemoveSymlinks(filesData) {
     return filesData.reduce((acc, fileData) => {
         switch (fileData.type) {
-            case files_1.STAT_TYPES.FILE:
+            case STAT_TYPES.FILE:
                 return acc.concat(fileData.filepath);
-            case files_1.STAT_TYPES.DIRECTORY:
+            case STAT_TYPES.DIRECTORY:
                 return acc.concat(fileData.files || []);
-            case files_1.STAT_TYPES.SYMBOLIC_LINK:
+            case STAT_TYPES.SYMBOLIC_LINK:
                 return acc;
             default:
                 return acc;
         }
     }, []);
 }
-exports.flattenAndRemoveSymlinks = flattenAndRemoveSymlinks;
 const generateRecursiveFilePromise = async (dir, file, ignoreDirs) => {
     return getFileInfoAsync(dir, file).then(fileData => {
         return new Promise(resolve => {
-            if (fileData.type === files_1.STAT_TYPES.DIRECTORY) {
+            if (fileData.type === STAT_TYPES.DIRECTORY) {
                 walk(fileData.filepath, ignoreDirs).then(files => {
                     resolve({ ...fileData, files });
                 });
@@ -56,7 +48,7 @@ const generateRecursiveFilePromise = async (dir, file, ignoreDirs) => {
         });
     });
 };
-async function walk(dir, ignoreDirs) {
+export async function walk(dir, ignoreDirs) {
     function processFiles(files) {
         // If the directory is in the ignore list, return an empty array to skip the directory contents
         if (ignoreDirs?.some(ignored => dir.includes(ignored))) {
@@ -64,12 +56,11 @@ async function walk(dir, ignoreDirs) {
         }
         return Promise.all(files.map(file => generateRecursiveFilePromise(dir, file, ignoreDirs)));
     }
-    return fs_1.default.promises
+    return fs.promises
         .readdir(dir)
         .then(processFiles)
         .then(flattenAndRemoveSymlinks)
         .catch(err => {
-        throw new FileSystemError_1.FileSystemError({ cause: err });
+        throw new FileSystemError({ cause: err });
     });
 }
-exports.walk = walk;

package/lib/github.d.ts

@@ -1,6 +1,4 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { GithubReleaseData, GithubRepoFile, RepoPath, CloneGithubRepoOptions } from '../types/Github';
+import { GithubReleaseData, GithubRepoFile, RepoPath, CloneGithubRepoOptions } from '../types/Github.js';
 /**
  * @deprecated Use `fetchRepoFile` instead - this util is a thin wrapper around it
  */

package/lib/github.js

@@ -1,38 +1,31 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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 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");
+import path from 'path';
+import fs from 'fs-extra';
+import { extractZipArchive } from './archive.js';
+import { logger } from './logger.js';
+import { fetchRepoFile, fetchRepoFileByDownloadUrl, fetchRepoAsZip, fetchRepoReleaseData, fetchRepoContents, } from '../api/github.js';
+import { i18n } from '../utils/lang.js';
+import { isGithubRateLimitError, isHubSpotHttpError, isSystemError, } from '../errors/index.js';
 const i18nKey = 'lib.github';
 /**
  * @deprecated Use `fetchRepoFile` instead - this util is a thin wrapper around it
  */
-async function fetchFileFromRepository(repoPath, filePath, ref) {
+export async function fetchFileFromRepository(repoPath, filePath, ref) {
     try {
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.fetchFileFromRepository.fetching`, {
+        logger.debug(i18n(`${i18nKey}.fetchFileFromRepository.fetching`, {
             path: `${repoPath}/${ref}/${filePath}`,
         }));
-        const { data } = await (0, github_1.fetchRepoFile)(repoPath, filePath, ref);
+        const { data } = await fetchRepoFile(repoPath, filePath, ref);
         return data;
     }
     catch (err) {
         checkGithubRateLimit(err);
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.fetchFileFromRepository.errors.fetchFail`), {
+        throw new Error(i18n(`${i18nKey}.fetchFileFromRepository.errors.fetchFail`), {
             cause: err,
         });
     }
 }
-exports.fetchFileFromRepository = fetchFileFromRepository;
 // Fetches information about a specific release (Defaults to latest)
-async function fetchReleaseData(repoPath, tag) {
+export async function fetchReleaseData(repoPath, tag) {
     if (tag) {
         tag = tag.trim().toLowerCase();
         if (tag.length && tag[0] !== 'v') {
@@ -40,17 +33,16 @@ async function fetchReleaseData(repoPath, tag) {
         }
     }
     try {
-        const { data } = await (0, github_1.fetchRepoReleaseData)(repoPath, tag);
+        const { data } = await fetchRepoReleaseData(repoPath, tag);
         return data;
     }
     catch (err) {
         checkGithubRateLimit(err);
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.fetchReleaseData.errors.fetchFail`, {
+        throw new Error(i18n(`${i18nKey}.fetchReleaseData.errors.fetchFail`, {
             tag: tag || 'latest',
         }), { cause: err });
     }
 }
-exports.fetchReleaseData = fetchReleaseData;
 async function downloadGithubRepoZip(repoPath, isRelease = false, options = {}) {
     const { branch, tag } = options;
     try {
@@ -61,48 +53,47 @@ async function downloadGithubRepoZip(repoPath, isRelease = false, options = {})
             const releaseData = await fetchReleaseData(repoPath, tag);
             zipUrl = releaseData.zipball_url;
             const { name } = releaseData;
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoZip.fetchingName`, { name }));
+            logger.debug(i18n(`${i18nKey}.downloadGithubRepoZip.fetchingName`, { name }));
         }
         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 }));
+            logger.debug(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`));
+        const { data } = await fetchRepoAsZip(zipUrl);
+        logger.debug(i18n(`${i18nKey}.downloadGithubRepoZip.completed`));
         return data;
     }
     catch (err) {
         checkGithubRateLimit(err);
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoZip.errors.fetchFail`), {
+        throw new Error(i18n(`${i18nKey}.downloadGithubRepoZip.errors.fetchFail`), {
             cause: err,
         });
     }
 }
-async function cloneGithubRepo(repoPath, dest, options = {}) {
+export async function cloneGithubRepo(repoPath, dest, options = {}) {
     const { tag, isRelease, branch, sourceDir, type, hideLogs, handleCollision } = options;
     const zip = await downloadGithubRepoZip(repoPath, isRelease, {
         tag,
         branch,
     });
     const repoName = repoPath.split('/')[1];
-    const success = await (0, archive_1.extractZipArchive)(zip, repoName, dest, {
+    const success = await extractZipArchive(zip, repoName, dest, {
         sourceDir,
         hideLogs,
         handleCollision,
     });
     if (success && !hideLogs) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.cloneGithubRepo.success`, {
+        logger.log(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);
+export async function fetchGitHubRepoContentFromDownloadUrl(dest, downloadUrl) {
+    const resp = await fetchRepoFileByDownloadUrl(downloadUrl);
     const contentType = resp.headers['content-type'];
     let fileContents;
     if (contentType.startsWith('text')) {
@@ -111,30 +102,29 @@ async function fetchGitHubRepoContentFromDownloadUrl(dest, downloadUrl) {
     else {
         fileContents = resp.data;
     }
-    fs_extra_1.default.outputFileSync(dest, fileContents);
+    fs.outputFileSync(dest, fileContents);
 }
-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));
+export async function downloadGithubRepoContents(repoPath, contentPath, dest, ref, filter) {
+    fs.ensureDirSync(path.dirname(dest));
     try {
-        const { data: contentsResp } = await (0, github_1.fetchRepoContents)(repoPath, contentPath, ref);
+        const { data: contentsResp } = await fetchRepoContents(repoPath, contentPath, ref);
         const downloadContent = async (contentPiece) => {
             const { path: contentPiecePath, download_url, type: contentPieceType, } = contentPiece;
-            const downloadPath = path_1.default.join(dest, contentPiecePath.replace(contentPath, ''));
+            const downloadPath = path.join(dest, contentPiecePath.replace(contentPath, ''));
             if (filter && !filter(contentPiecePath, downloadPath)) {
                 return Promise.resolve();
             }
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoContents.downloading`, {
+            logger.debug(i18n(`${i18nKey}.downloadGithubRepoContents.downloading`, {
                 contentPiecePath,
                 downloadUrl: download_url,
                 downloadPath,
             }));
             if (contentPieceType === 'dir') {
-                const { data: innerDirContent } = await (0, github_1.fetchRepoContents)(repoPath, contentPiecePath, ref);
+                const { data: innerDirContent } = await fetchRepoContents(repoPath, contentPiecePath, ref);
                 await Promise.all(innerDirContent.map(downloadContent));
                 return Promise.resolve();
             }
@@ -151,19 +141,18 @@ async function downloadGithubRepoContents(repoPath, contentPath, dest, ref, filt
     }
     catch (e) {
         checkGithubRateLimit(e);
-        if ((0, errors_1.isSystemError)(e) && e?.error?.message) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoContents.errors.fetchFail`, {
+        if (isSystemError(e) && e?.error?.message) {
+            throw new Error(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) {
+export async function listGithubRepoContents(repoPath, contentPath, fileFilter) {
     try {
-        const { data: contentsResp } = await (0, github_1.fetchRepoContents)(repoPath, contentPath);
+        const { data: contentsResp } = await fetchRepoContents(repoPath, contentPath);
         const filteredFiles = fileFilter && fileFilter != undefined
             ? contentsResp.filter(item => item.type === fileFilter)
             : contentsResp;
@@ -171,18 +160,17 @@ async function listGithubRepoContents(repoPath, contentPath, fileFilter) {
     }
     catch (e) {
         checkGithubRateLimit(e);
-        if ((0, errors_1.isHubSpotHttpError)(e) && e.data.message) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoContents.errors.fetchFail`, {
+        if (isHubSpotHttpError(e) && e.data.message) {
+            throw new Error(i18n(`${i18nKey}.downloadGithubRepoContents.errors.fetchFail`, {
                 errorMessage: e.data.message,
             }));
         }
         throw e;
     }
 }
-exports.listGithubRepoContents = listGithubRepoContents;
 function checkGithubRateLimit(err) {
-    if ((0, errors_1.isGithubRateLimitError)(err)) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.rateLimitError`), {
+    if (isGithubRateLimitError(err)) {
+        throw new Error(i18n(`${i18nKey}.rateLimitError`), {
             cause: err,
         });
     }

package/lib/gitignore.d.ts

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

package/lib/gitignore.js

@@ -1,49 +1,41 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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 lang_1 = require("../utils/lang");
+import fs from 'fs-extra';
+import path from 'path';
+import { isConfigPathInGitRepo, getGitignoreFiles, configFilenameIsIgnoredByGitignore, } from '../utils/git.js';
+import { DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME } from '../constants/config.js';
+import { i18n } from '../utils/lang.js';
 const i18nKey = 'lib.gitignore';
 const GITIGNORE_FILE = '.gitignore';
-function checkAndAddConfigToGitignore(configPath) {
+export function checkAndAddConfigToGitignore(configPath) {
     try {
         const { configIgnored, gitignoreFiles } = checkGitInclusion(configPath);
         if (configIgnored)
             return;
         let gitignoreFilePath = gitignoreFiles && gitignoreFiles.length ? gitignoreFiles[0] : null;
         if (!gitignoreFilePath) {
-            gitignoreFilePath = path_1.default.join(path_1.default.dirname(configPath), GITIGNORE_FILE);
-            (0, fs_extra_1.writeFileSync)(gitignoreFilePath, '');
+            gitignoreFilePath = path.join(path.dirname(configPath), GITIGNORE_FILE);
+            fs.writeFileSync(gitignoreFilePath, '');
         }
-        const gitignoreContents = (0, fs_extra_1.readFileSync)(gitignoreFilePath).toString();
-        const updatedContents = `${gitignoreContents.trim()}\n\n# HubSpot config file\n${config_1.DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME}\n`;
-        (0, fs_extra_1.writeFileSync)(gitignoreFilePath, updatedContents);
+        const gitignoreContents = fs.readFileSync(gitignoreFilePath).toString();
+        const updatedContents = `${gitignoreContents.trim()}\n\n# HubSpot config file\n${DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME}\n`;
+        fs.writeFileSync(gitignoreFilePath, updatedContents);
     }
     catch (e) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.configIgnore`), { cause: e });
+        throw new Error(i18n(`${i18nKey}.errors.configIgnore`), { cause: e });
     }
 }
-exports.checkAndAddConfigToGitignore = checkAndAddConfigToGitignore;
-function checkGitInclusion(configPath) {
+export function checkGitInclusion(configPath) {
     const result = {
         inGit: false,
         configIgnored: false,
         gitignoreFiles: [],
     };
-    if ((0, git_1.isConfigPathInGitRepo)(configPath)) {
+    if (isConfigPathInGitRepo(configPath)) {
         result.inGit = true;
-        result.gitignoreFiles = (0, git_1.getGitignoreFiles)(configPath);
-        if ((0, git_1.configFilenameIsIgnoredByGitignore)(result.gitignoreFiles, configPath)) {
+        result.gitignoreFiles = getGitignoreFiles(configPath);
+        if (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,5 +1,5 @@
 import { AxiosResponse } from 'axios';
-import { Row, Table } from '../types/Hubdb';
+import { Row, Table } from '../types/Hubdb.js';
 export declare function addRowsToHubDbTable(accountId: number, tableId: string, rows?: Array<Row>): Promise<{
     tableId: string;
     rowCount: number;

package/lib/hubdb.js

@@ -1,37 +1,31 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearHubDbTableRows = exports.downloadHubDbTable = exports.updateHubDbTable = exports.createHubDbTable = exports.addRowsToHubDbTable = void 0;
-const path_1 = __importDefault(require("path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const prettier_1 = __importDefault(require("prettier"));
-const hubdb_1 = require("../api/hubdb");
-const path_2 = require("./path");
-const lang_1 = require("../utils/lang");
+import path from 'path';
+import fs from 'fs-extra';
+import { format } from 'prettier';
+import { createTable, updateTable, createRows, fetchTable, fetchRows, publishTable, deleteRows, } from '../api/hubdb.js';
+import { getCwd } from './path.js';
+import { i18n } from '../utils/lang.js';
 const i18nKey = 'lib.hubdb';
 function validateJsonPath(src) {
-    if (path_1.default.extname(src) !== '.json') {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidJsonPath`));
+    if (path.extname(src) !== '.json') {
+        throw new Error(i18n(`${i18nKey}.errors.invalidJsonPath`));
     }
 }
 function validateJsonFile(src) {
     let stats;
     try {
-        stats = fs_extra_1.default.statSync(src);
+        stats = fs.statSync(src);
     }
     catch (err) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidJsonFile`, { src }), {
+        throw new Error(i18n(`${i18nKey}.errors.invalidJsonFile`, { src }), {
             cause: err,
         });
     }
     if (!stats.isFile()) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidJsonFile`, { src }));
+        throw new Error(i18n(`${i18nKey}.errors.invalidJsonFile`, { src }));
     }
     validateJsonPath(src);
 }
-async function addRowsToHubDbTable(accountId, tableId, rows = []) {
+export async function addRowsToHubDbTable(accountId, tableId, rows = []) {
     const rowsToUpdate = rows.map(row => {
         const values = row.values;
         return {
@@ -42,30 +36,27 @@ async function addRowsToHubDbTable(accountId, tableId, rows = []) {
         };
     });
     if (rowsToUpdate.length > 0) {
-        await (0, hubdb_1.createRows)(accountId, tableId, rowsToUpdate);
+        await createRows(accountId, tableId, rowsToUpdate);
     }
-    const { data: { rowCount }, } = await (0, hubdb_1.publishTable)(accountId, tableId);
+    const { data: { rowCount }, } = await publishTable(accountId, tableId);
     return {
         tableId,
         rowCount,
     };
 }
-exports.addRowsToHubDbTable = addRowsToHubDbTable;
-async function createHubDbTable(accountId, src) {
+export async function createHubDbTable(accountId, src) {
     validateJsonFile(src);
-    const table = fs_extra_1.default.readJsonSync(src);
+    const table = fs.readJsonSync(src);
     const { rows, ...schema } = table;
-    const { data: { id }, } = await (0, hubdb_1.createTable)(accountId, schema);
+    const { data: { id }, } = await createTable(accountId, schema);
     return addRowsToHubDbTable(accountId, id, rows);
 }
-exports.createHubDbTable = createHubDbTable;
-async function updateHubDbTable(accountId, tableId, src) {
+export async function updateHubDbTable(accountId, tableId, src) {
     validateJsonFile(src);
-    const table = fs_extra_1.default.readJsonSync(src);
+    const table = fs.readJsonSync(src);
     const { ...schema } = table;
-    return (0, hubdb_1.updateTable)(accountId, tableId, schema);
+    return updateTable(accountId, tableId, schema);
 }
-exports.updateHubDbTable = updateHubDbTable;
 function convertToJSON(table, rows) {
     const { allowChildTables, allowPublicApiAccess, columns, dynamicMetaTags, enableChildTablePages, label, name, useForPages, } = table;
     const cleanedColumns = columns
@@ -98,17 +89,17 @@ async function fetchAllRows(accountId, tableId) {
     let rows = [];
     let after = null;
     do {
-        const axiosResponse = await (0, hubdb_1.fetchRows)(accountId, tableId, after ? { after } : undefined);
+        const axiosResponse = await fetchRows(accountId, tableId, after ? { after } : undefined);
         const { paging, results } = axiosResponse.data;
         rows = rows.concat(results);
         after = paging && paging.next ? paging.next.after : null;
     } while (after !== null);
     return rows;
 }
-async function downloadHubDbTable(accountId, tableId, dest) {
-    const { data: table } = await (0, hubdb_1.fetchTable)(accountId, tableId);
-    dest = path_1.default.resolve((0, path_2.getCwd)(), dest || `${table.name}.hubdb.json`);
-    if (fs_extra_1.default.pathExistsSync(dest)) {
+export async function downloadHubDbTable(accountId, tableId, dest) {
+    const { data: table } = await fetchTable(accountId, tableId);
+    dest = path.resolve(getCwd(), dest || `${table.name}.hubdb.json`);
+    if (fs.pathExistsSync(dest)) {
         validateJsonFile(dest);
     }
     else {
@@ -116,18 +107,16 @@ async function downloadHubDbTable(accountId, tableId, dest) {
     }
     const rows = await fetchAllRows(accountId, tableId);
     const tableToWrite = JSON.stringify(convertToJSON(table, rows));
-    const tableJson = await prettier_1.default.format(tableToWrite, {
+    const tableJson = await format(tableToWrite, {
         parser: 'json',
     });
-    await fs_extra_1.default.outputFile(dest, tableJson);
+    await fs.outputFile(dest, tableJson);
     return { filePath: dest };
 }
-exports.downloadHubDbTable = downloadHubDbTable;
-async function clearHubDbTableRows(accountId, tableId) {
+export async function clearHubDbTableRows(accountId, tableId) {
     const rows = await fetchAllRows(accountId, tableId);
-    await (0, hubdb_1.deleteRows)(accountId, tableId, rows.map(row => row.id));
+    await deleteRows(accountId, tableId, rows.map(row => row.id));
     return {
         deletedRowCount: rows.length,
     };
 }
-exports.clearHubDbTableRows = clearHubDbTableRows;

package/lib/ignoreRules.js

@@ -1,36 +1,30 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ignoreFile = exports.createIgnoreFilter = exports.shouldIgnoreFile = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const ignore_1 = __importDefault(require("ignore"));
-const findup_sync_1 = __importDefault(require("findup-sync"));
+import fs from 'fs';
+import path from 'path';
+import ignore from 'ignore';
+import findup from 'findup-sync';
 const ignoreList = [
     'fields.output.json',
     'hubspot.config.yml',
     'hubspot.config.yaml',
-    'node_modules',
-    '.*',
-    '*.log',
-    '*.swp',
-    '.env',
+    'node_modules', // dependencies
+    '.*', // hidden files/folders
+    '*.log', // Error log for npm
+    '*.swp', // Swap file for vim state
+    '.env', // Dotenv file
     // # macOS
-    'Icon\\r',
-    '__MACOSX',
+    'Icon\\r', // Custom Finder icon: http://superuser.com/questions/298785/icon-file-on-os-x-desktop
+    '__MACOSX', // Resource fork
     // # Linux
-    '~',
+    '~', // Backup file
     // # Emacs
-    '*~',
+    '*~', // Backup file
     // # Windows
-    'Thumbs.db',
-    'ehthumbs.db',
-    'Desktop.ini',
+    'Thumbs.db', // Image file cache
+    'ehthumbs.db', // Folder config file
+    'Desktop.ini', // Stores custom folder attributes
     '@eaDir', // Synology Diskstation "hidden" folder where the server stores thumbnails
 ];
-const ignoreRules = (0, ignore_1.default)().add(ignoreList);
+const ignoreRules = ignore().add(ignoreList);
 let searchDomain = null;
 let loaded = false;
 function loadIgnoreConfig(isInProject = false) {
@@ -42,28 +36,25 @@ function loadIgnoreConfig(isInProject = false) {
     if (!isInProject) {
         ignoreRules.add('package-lock.json');
     }
-    const file = (0, findup_sync_1.default)('.hsignore');
+    const file = findup('.hsignore');
     if (file) {
-        if (fs_1.default.existsSync(file)) {
-            ignoreRules.add(fs_1.default.readFileSync(file).toString());
-            searchDomain = path_1.default.dirname(file);
+        if (fs.existsSync(file)) {
+            ignoreRules.add(fs.readFileSync(file).toString());
+            searchDomain = path.dirname(file);
         }
     }
     loaded = true;
 }
-function shouldIgnoreFile(file, isInProject = false) {
+export function shouldIgnoreFile(file, isInProject = false) {
     loadIgnoreConfig(isInProject);
     const relativeTo = searchDomain || '/';
-    const relativePath = path_1.default.relative(relativeTo, file);
+    const relativePath = path.relative(relativeTo, file);
     return !!relativePath && ignoreRules.ignores(relativePath);
 }
-exports.shouldIgnoreFile = shouldIgnoreFile;
-function createIgnoreFilter(isInProject) {
+export function createIgnoreFilter(isInProject) {
     loadIgnoreConfig(isInProject);
     return (file) => !shouldIgnoreFile(file);
 }
-exports.createIgnoreFilter = createIgnoreFilter;
-function ignoreFile(filePath) {
+export function ignoreFile(filePath) {
     ignoreRules.add(filePath);
 }
-exports.ignoreFile = ignoreFile;

package/lib/isDeepEqual.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDeepEqual = void 0;
-function isDeepEqual(object1, object2, ignoreKeys) {
+export function isDeepEqual(object1, object2, ignoreKeys) {
     if (object1 === object2) {
         return true;
     }
@@ -32,4 +29,3 @@ function isDeepEqual(object1, object2, ignoreKeys) {
     }
     return true;
 }
-exports.isDeepEqual = isDeepEqual;