@hubspot/local-dev-lib 0.3.15 → 0.4.0-experimental.1

package/lib/fileMapper.js

@@ -11,12 +11,11 @@ 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 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,
@@ -44,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,
         },
@@ -77,9 +76,9 @@ function validateFileMapperNode(node) {
     catch (err) {
         json = node;
     }
-    (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidNode`, {
+    throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidNode`, {
         json: JSON.stringify(json),
-    });
+    }));
 }
 function getTypeDataFromPath(src) {
     const isModule = isPathToModule(src);
@@ -125,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',
         });
     }
 }
@@ -142,7 +141,7 @@ async function skipExisting(filepath, overwrite = false) {
     }
     return false;
 }
-async function fetchAndWriteFileStream(accountId, srcPath, filepath, mode, options = {}) {
+async function fetchAndWriteFileStream(accountId, srcPath, filepath, cmsPublishMode, options = {}) {
     if (typeof srcPath !== 'string' || !srcPath.trim()) {
         return;
     }
@@ -150,21 +149,15 @@ async function fetchAndWriteFileStream(accountId, srcPath, filepath, mode, optio
         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 = {}) {
+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_1.logger.log((0, lang_1.i18n)(`${i18nKey}.skippedExisting`, {
@@ -174,7 +167,7 @@ async function writeFileMapperNode(accountId, filepath, node, mode, options = {}
     }
     if (!node.folder) {
         try {
-            await fetchAndWriteFileStream(accountId, node.path, localFilepath, mode, options);
+            await fetchAndWriteFileStream(accountId, node.path, localFilepath, cmsPublishMode, options);
             return true;
         }
         catch (err) {
@@ -188,21 +181,20 @@ async function writeFileMapperNode(accountId, filepath, node, mode, options = {}
         }));
     }
     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;
 }
-async function downloadFile(accountId, src, destPath, mode, options = {}) {
+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;
@@ -222,7 +214,7 @@ async function downloadFile(accountId, src, destPath, mode, options = {}) {
                 : path_1.default.resolve(cwd, dest, name);
         }
         const localFsPath = (0, path_2.convertToLocalFileSystemPath)(filepath);
-        await fetchAndWriteFileStream(accountId, src, localFsPath, mode, options);
+        await fetchAndWriteFileStream(accountId, src, localFsPath, cmsPublishMode, options);
         await queue.onIdle();
         logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.completedFetch`, {
             src,
@@ -232,33 +224,33 @@ async function downloadFile(accountId, src, destPath, mode, options = {}) {
     }
     catch (err) {
         const error = err;
-        if (isHubspot && (0, apiErrors_1.isTimeoutError)(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 = {}) {
+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,
-        });
+        }));
     }
     const srcPath = isRoot ? '@root' : src;
-    const queryValues = getFileMapperQueryValues(mode, options);
-    const node = isHubspot
+    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 = {}) {
+async function downloadFolder(accountId, src, destPath, cmsPublishMode, options = {}) {
     try {
-        const node = await fetchFolderFromApi(accountId, src, mode, options);
+        const node = await fetchFolderFromApi(accountId, src, cmsPublishMode, options);
         if (!node) {
             return;
         }
@@ -269,9 +261,13 @@ async function downloadFolder(accountId, src, destPath, mode, options = {}) {
         let success = true;
         recurseFolder(node, (childNode, filepath) => {
             queue.add(async () => {
-                const succeeded = await writeFileMapperNode(accountId, filepath || '', childNode, mode, options);
+                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;
@@ -285,16 +281,17 @@ async function downloadFolder(accountId, src, destPath, mode, options = {}) {
             }));
         }
         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) {
         const error = err;
-        if ((0, apiErrors_1.isTimeoutError)(error)) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.assetTimeout`, {}, error);
+        if ((0, errors_1.isTimeoutError)(error)) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.assetTimeout`), { cause: error });
         }
         else {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.failedToFetchFolder`, { src, dest: destPath }, err);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchFolder`, { src, dest: destPath }), { cause: err });
         }
     }
 }
@@ -305,16 +302,16 @@ async function downloadFolder(accountId, src, destPath, mode, options = {}) {
  * @param {FileMapperInputArguments} input
  * @returns {Promise}
  */
-async function downloadFileOrFolder(accountId, src, dest, mode, options = {}) {
+async function downloadFileOrFolder(accountId, src, dest, cmsPublishMode, options = {}) {
     if (!src) {
         return;
     }
     const { isFile } = getTypeDataFromPath(src);
     if (isFile) {
-        await downloadFile(accountId, src, dest, mode, options);
+        await downloadFile(accountId, src, dest, cmsPublishMode, options);
     }
     else {
-        await downloadFolder(accountId, src, dest, mode, options);
+        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,16 +1,16 @@
 /// <reference types="node" />
-import { GithubReleaseData, GithubRepoFile } from '../types/Github';
-type RepoPath = `${string}/${string}`;
-export declare function fetchFileFromRepository(repoPath: RepoPath, filePath: string, ref: string): Promise<Buffer>;
+/// <reference types="node" />
+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): 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 declare function listGithubRepoContents(repoPath: RepoPath, contentPath: string, fileFilter?: 'file' | 'dir'): Promise<GithubRepoFile[]>;
-export {};

package/lib/github.js

@@ -3,15 +3,18 @@ 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.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 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';
+/**
+ * @deprecated Use `fetchRepoFile` instead - this util is a thin wrapper around it
+ */
 async function fetchFileFromRepository(repoPath, filePath, ref) {
     try {
         logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.fetchFileFromRepository.fetching`, {
@@ -21,7 +24,9 @@ async function fetchFileFromRepository(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;
@@ -66,18 +72,23 @@ async function downloadGithubRepoZip(repoPath, isRelease = false, options = {})
         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 = {}) {
-    const { tag, isRelease, branch, sourceDir, type } = 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) {
+    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,
@@ -88,12 +99,21 @@ async function cloneGithubRepo(repoPath, dest, options = {}) {
 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 {
@@ -126,15 +146,12 @@ 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;
@@ -148,15 +165,12 @@ async function listGithubRepoContents(repoPath, contentPath, fileFilter) {
         return filteredFiles;
     }
     catch (e) {
-        const error = e;
-        if (error?.response?.data?.message) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.downloadGithubRepoContents.errors.fetchFail`, {
-                errorMessage: error.response.data.message,
-            });
-        }
-        else {
-            (0, standardErrors_1.throwError)(error);
+        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,8 +1,3 @@
+import { GitInclusionResult } from '../types/Config';
 export declare function checkAndAddConfigToGitignore(configPath: string): void;
-type GitInclusionResult = {
-    inGit: boolean;
-    configIgnored: boolean;
-    gitignoreFiles: Array<string>;
-};
 export declare function checkGitInclusion(configPath: string): GitInclusionResult;
-export {};

package/lib/gitignore.js

@@ -8,7 +8,7 @@ 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) {
@@ -26,7 +26,7 @@ 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;

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;
 }>;

package/lib/hubdb.js

@@ -9,11 +9,11 @@ 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 standardErrors_1 = require("../errors/standardErrors");
+const lang_1 = require("../utils/lang");
 const i18nKey = 'lib.hubdb';
 function validateJsonPath(src) {
     if (path_1.default.extname(src) !== '.json') {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidJsonPath`);
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidJsonPath`));
     }
 }
 function validateJsonFile(src) {
@@ -22,10 +22,12 @@ function validateJsonFile(src) {
         stats = fs_extra_1.default.statSync(src);
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidJsonFile`, { src }, err);
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidJsonFile`, { src }), {
+            cause: err,
+        });
     }
     if (!stats.isFile()) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidJsonFile`, { src });
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidJsonFile`, { src }));
     }
     validateJsonPath(src);
 }
@@ -42,7 +44,7 @@ async function addRowsToHubDbTable(accountId, tableId, rows = []) {
     if (rowsToUpdate.length > 0) {
         await (0, hubdb_1.createRows)(accountId, tableId, rowsToUpdate);
     }
-    const { rowCount } = await (0, hubdb_1.publishTable)(accountId, tableId);
+    const { data: { rowCount }, } = await (0, hubdb_1.publishTable)(accountId, tableId);
     return {
         tableId,
         rowCount,
@@ -53,7 +55,7 @@ async function createHubDbTable(accountId, src) {
     validateJsonFile(src);
     const table = fs_extra_1.default.readJsonSync(src);
     const { rows, ...schema } = table;
-    const { id } = await (0, hubdb_1.createTable)(accountId, schema);
+    const { data: { id }, } = await (0, hubdb_1.createTable)(accountId, schema);
     return addRowsToHubDbTable(accountId, id, rows);
 }
 exports.createHubDbTable = createHubDbTable;
@@ -96,15 +98,15 @@ async function fetchAllRows(accountId, tableId) {
     let rows = [];
     let after = null;
     do {
-        const response = await (0, hubdb_1.fetchRows)(accountId, tableId, after ? { after } : undefined);
-        const { paging, results } = response;
+        const axiosResponse = await (0, hubdb_1.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 table = await (0, hubdb_1.fetchTable)(accountId, tableId);
+    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)) {
         validateJsonFile(dest);

package/lib/notify.js

@@ -7,7 +7,7 @@ exports.triggerNotify = void 0;
 const fs_1 = __importDefault(require("fs"));
 const moment_1 = __importDefault(require("moment"));
 const debounce_1 = __importDefault(require("debounce"));
-const standardErrors_1 = require("../errors/standardErrors");
+const lang_1 = require("../utils/lang");
 const i18nKey = 'utils.notify';
 const notifyQueue = [];
 const notifyPromises = [];
@@ -37,7 +37,7 @@ function notifyFilePath(filePathToNotify, outputToWrite) {
             fs_1.default.appendFileSync(filePathToNotify, outputToWrite);
         }
         catch (e) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.filePath`, { filePath: filePathToNotify }, e);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.filePath`, { filePath: filePathToNotify }), { cause: e });
         }
     }
 }

package/lib/oauth.d.ts

@@ -1,4 +1,4 @@
-import OAuth2Manager from '../models/OAuth2Manager';
+import { OAuth2Manager } from '../models/OAuth2Manager';
 import { FlatAccountFields } from '../types/Accounts';
 export declare function getOauthManager(accountId: number, accountConfig: FlatAccountFields): OAuth2Manager | undefined;
 export declare function addOauthToAccountConfig(oauth: OAuth2Manager): void;

package/lib/oauth.js

@@ -1,14 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addOauthToAccountConfig = exports.getOauthManager = void 0;
-const OAuth2Manager_1 = __importDefault(require("../models/OAuth2Manager"));
+const OAuth2Manager_1 = require("../models/OAuth2Manager");
 const auth_1 = require("../constants/auth");
-const standardErrors_1 = require("../errors/standardErrors");
 const logger_1 = require("./logger");
-const getAccountIdentifier_1 = require("../utils/getAccountIdentifier");
+const getAccountIdentifier_1 = require("../config/getAccountIdentifier");
 const config_1 = require("../config");
 const lang_1 = require("../utils/lang");
 const i18nKey = 'lib.oauth';
@@ -21,23 +17,18 @@ function writeOauthTokenInfo(accountConfig) {
 }
 function getOauthManager(accountId, accountConfig) {
     if (!oauthManagers.has(accountId)) {
-        oauthManagers.set(accountId, OAuth2Manager_1.default.fromConfig(accountConfig, () => writeOauthTokenInfo(accountConfig)));
+        oauthManagers.set(accountId, OAuth2Manager_1.OAuth2Manager.fromConfig(accountConfig, () => writeOauthTokenInfo(accountConfig)));
     }
     return oauthManagers.get(accountId);
 }
 exports.getOauthManager = getOauthManager;
 function addOauthToAccountConfig(oauth) {
     logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.addOauthToAccountConfig.init`));
-    try {
-        (0, config_1.updateAccountConfig)({
-            ...oauth.account,
-            authType: auth_1.AUTH_METHODS.oauth.value,
-        });
-        (0, config_1.writeConfig)();
-        logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.addOauthToAccountConfig.success`));
-    }
-    catch (err) {
-        (0, standardErrors_1.throwError)(err);
-    }
+    (0, config_1.updateAccountConfig)({
+        ...oauth.account,
+        authType: auth_1.AUTH_METHODS.oauth.value,
+    });
+    (0, config_1.writeConfig)();
+    logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.addOauthToAccountConfig.success`));
 }
 exports.addOauthToAccountConfig = addOauthToAccountConfig;