@hubspot/local-dev-lib 1.13.0 → 2.0.0

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,12 +1,8 @@
 "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 config_1 = require("../config");
@@ -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;

package/lib/personalAccessKey.js

@@ -7,33 +7,22 @@ exports.updateConfigWithAccessToken = exports.scopesOnAccessToken = exports.enab
 const moment_1 = __importDefault(require("moment"));
 const environments_1 = require("../constants/environments");
 const auth_1 = require("../constants/auth");
-const standardErrors_1 = require("../errors/standardErrors");
 const localDevAuth_1 = require("../api/localDevAuth");
 const sandboxHubs_1 = require("../api/sandboxHubs");
 const config_1 = require("../config");
 const config_2 = require("../constants/config");
 const developerTestAccounts_1 = require("../api/developerTestAccounts");
 const logger_1 = require("./logger");
-const apiErrors_1 = require("../errors/apiErrors");
+const lang_1 = require("../utils/lang");
+const errors_1 = require("../errors");
 const i18nKey = 'lib.personalAccessKey';
 const refreshRequests = new Map();
 function getRefreshKey(personalAccessKey, expiration) {
     return `${personalAccessKey}-${expiration || 'fresh'}`;
 }
 async function getAccessToken(personalAccessKey, env = environments_1.ENVIRONMENTS.PROD, accountId) {
-    let response;
-    try {
-        response = await (0, localDevAuth_1.fetchAccessToken)(personalAccessKey, env, accountId);
-    }
-    catch (e) {
-        const error = e;
-        if (error.response) {
-            (0, standardErrors_1.throwAuthErrorWithMessage)(`${i18nKey}.errors.invalidPersonalAccessKey`, { errorMessage: error.response.data.message || '' }, error);
-        }
-        else {
-            (0, standardErrors_1.throwError)(e);
-        }
-    }
+    const axiosResponse = await (0, localDevAuth_1.fetchAccessToken)(personalAccessKey, env, accountId);
+    const response = axiosResponse.data;
     return {
         portalId: response.hubId,
         accessToken: response.oauthAccessToken,
@@ -86,7 +75,7 @@ async function getNewAccessToken(accountId, personalAccessKey, expiresAt, env) {
 async function getNewAccessTokenByAccountId(accountId) {
     const account = (0, config_1.getAccountConfig)(accountId);
     if (!account) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.accountNotFound`, { accountId });
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.accountNotFound`, { accountId }));
     }
     const { auth, personalAccessKey, env } = account;
     const accessTokenResponse = await getNewAccessToken(accountId, personalAccessKey, auth?.tokenInfo?.expiresAt, env);
@@ -95,7 +84,7 @@ async function getNewAccessTokenByAccountId(accountId) {
 async function accessTokenForPersonalAccessKey(accountId, forceRefresh = false) {
     const account = (0, config_1.getAccountConfig)(accountId);
     if (!account) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.accountNotFound`, { accountId });
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.accountNotFound`, { accountId }));
     }
     const { auth, personalAccessKey, env } = account;
     const authTokenInfo = auth && auth.tokenInfo;
@@ -124,7 +113,7 @@ async function updateConfigWithAccessToken(token, personalAccessKey, env, name,
     try {
         if (accountType === config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX ||
             accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
-            const sandboxDataResponse = await (0, sandboxHubs_1.fetchSandboxHubData)(accessToken, portalId, accountEnv);
+            const { data: sandboxDataResponse } = await (0, sandboxHubs_1.fetchSandboxHubData)(accessToken, portalId, accountEnv);
             if (sandboxDataResponse.parentHubId) {
                 parentAccountId = sandboxDataResponse.parentHubId;
             }
@@ -132,11 +121,14 @@ async function updateConfigWithAccessToken(token, personalAccessKey, env, name,
     }
     catch (err) {
         // Log error but do not throw
-        logger_1.logger.debug((0, apiErrors_1.getAxiosErrorWithContext)(err).message);
+        if ((0, errors_1.isHubSpotHttpError)(err)) {
+            logger_1.logger.debug(err.message);
+        }
+        logger_1.logger.debug(err);
     }
     try {
         if (accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST) {
-            const developerTestAccountResponse = await (0, developerTestAccounts_1.fetchDeveloperTestAccountData)(accessToken, portalId, accountEnv);
+            const { data: developerTestAccountResponse } = await (0, developerTestAccounts_1.fetchDeveloperTestAccountData)(accessToken, portalId, accountEnv);
             if (developerTestAccountResponse) {
                 parentAccountId = developerTestAccountResponse.parentPortalId;
             }
@@ -144,7 +136,10 @@ async function updateConfigWithAccessToken(token, personalAccessKey, env, name,
     }
     catch (err) {
         // Log error but do not throw
-        logger_1.logger.debug((0, apiErrors_1.getAxiosErrorWithContext)(err).message);
+        if ((0, errors_1.isHubSpotHttpError)(err)) {
+            logger_1.logger.debug(err.message);
+        }
+        logger_1.logger.debug(err);
     }
     const updatedConfig = (0, config_1.updateAccountConfig)({
         accountId: portalId,

package/lib/portManager.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.portManagerHasActiveServers = exports.deleteServerInstance = exports.requestPorts = exports.stopPortManagerServer = exports.startPortManagerServer = exports.BASE_URL = void 0;
 const axios_1 = __importDefault(require("axios"));
-const PortManagerServer_1 = __importDefault(require("../utils/PortManagerServer"));
+const PortManagerServer_1 = require("../utils/PortManagerServer");
 const detectPort_1 = require("../utils/detectPort");
 const ports_1 = require("../constants/ports");
 exports.BASE_URL = `http://localhost:${ports_1.PORT_MANAGER_SERVER_PORT}`;
@@ -16,7 +16,7 @@ async function isPortManagerServerRunning() {
 async function startPortManagerServer() {
     const isRunning = await isPortManagerServerRunning();
     if (!isRunning) {
-        await PortManagerServer_1.default.init();
+        await PortManagerServer_1.PortManagerServer.init();
     }
 }
 exports.startPortManagerServer = startPortManagerServer;

package/lib/trackUsage.js

@@ -7,7 +7,7 @@ exports.trackUsage = void 0;
 const axios_1 = __importDefault(require("axios"));
 const getAxiosConfig_1 = require("../http/getAxiosConfig");
 const logger_1 = require("./logger");
-const http_1 = __importDefault(require("../http"));
+const http_1 = require("../http");
 const config_1 = require("../config");
 const fileMapper_1 = require("../api/fileMapper");
 const lang_1 = require("../utils/lang");
@@ -38,11 +38,17 @@ async function trackUsage(eventName, eventClass, meta = {}, accountId) {
     const accountConfig = accountId && (0, config_1.getAccountConfig)(accountId);
     if (accountConfig && accountConfig.authType === 'personalaccesskey') {
         logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.sendingEventAuthenticated`));
-        return http_1.default.post(accountId, {
-            url: `${path}/authenticated`,
-            data: usageEvent,
-            resolveWithFullResponse: true,
-        });
+        try {
+            await http_1.http.post(accountId, {
+                url: `${path}/authenticated`,
+                data: usageEvent,
+                resolveWithFullResponse: true,
+            });
+            return;
+        }
+        catch (e) {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.retryingEventUnauthenticated`));
+        }
     }
     const env = (0, config_1.getEnv)(accountId);
     const axiosConfig = (0, getAxiosConfig_1.getAxiosConfig)({

package/models/FileSystemError.d.ts

@@ -0,0 +1,6 @@
+import { FileSystemErrorContext } from '../types/Error';
+export declare class FileSystemError extends Error {
+    private context;
+    constructor(options?: ErrorOptions, context?: FileSystemErrorContext);
+    toString(): string;
+}

package/models/FileSystemError.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemError = void 0;
+const lang_1 = require("../utils/lang");
+const errors_1 = require("../errors");
+const i18nKey = 'errors.fileSystemErrors';
+class FileSystemError extends Error {
+    context;
+    constructor(options, context) {
+        super('', options);
+        this.name = 'FileSystemError';
+        this.context = context;
+        if (context) {
+            let fileAction = '';
+            if (context.operation === 'read') {
+                fileAction = (0, lang_1.i18n)(`${i18nKey}.readAction`);
+            }
+            else if (context.operation === 'write') {
+                fileAction = (0, lang_1.i18n)(`${i18nKey}.writeAction`);
+            }
+            else {
+                fileAction = (0, lang_1.i18n)(`${i18nKey}.otherAction`);
+            }
+            const filepath = context.filepath
+                ? `"${context.filepath}"`
+                : (0, lang_1.i18n)(`${i18nKey}.unknownFilepath`);
+            const messages = [
+                (0, lang_1.i18n)(`${i18nKey}.baseMessage`, { fileAction, filepath }),
+            ];
+            // Many `fs` errors will be `SystemError`s
+            if ((0, errors_1.isSystemError)(options?.cause)) {
+                messages.push((0, lang_1.i18n)(`${i18nKey}.baseMessage`, {
+                    errorMessage: options?.cause?.message || '',
+                }));
+            }
+            this.message = messages.join(' ');
+        }
+    }
+    toString() {
+        let baseString = `${this.name}: ${this.message}`;
+        if (this.context) {
+            baseString = `${baseString} context: ${this.context}`;
+        }
+        return baseString;
+    }
+}
+exports.FileSystemError = FileSystemError;

package/models/HubSpotHttpError.d.ts

@@ -0,0 +1,24 @@
+import { HubSpotHttpErrorContext } from '../types/Error';
+export declare class HubSpotHttpError<T = any> extends Error {
+    status?: number;
+    code?: string;
+    statusText?: string;
+    data?: T;
+    headers?: {
+        [key: string]: unknown;
+    };
+    method: string | undefined;
+    context: HubSpotHttpErrorContext | undefined;
+    derivedContext: HubSpotHttpErrorContext | undefined;
+    validationErrors: string[] | undefined;
+    detailedMessage?: string;
+    private divider;
+    cause: ErrorOptions['cause'];
+    constructor(message?: string, options?: ErrorOptions, context?: HubSpotHttpErrorContext);
+    updateContext(context: Partial<HubSpotHttpErrorContext>): void;
+    toString(): string;
+    formattedValidationErrors(): string;
+    private extractDerivedContext;
+    private parseValidationErrors;
+    private joinErrorMessages;
+}

package/models/HubSpotHttpError.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HubSpotHttpError = void 0;
+const axios_1 = require("axios");
+const api_1 = require("../constants/api");
+const lang_1 = require("../utils/lang");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class HubSpotHttpError extends Error {
+    status;
+    code;
+    statusText;
+    data;
+    headers;
+    method;
+    context;
+    derivedContext;
+    validationErrors;
+    detailedMessage;
+    divider = `\n- `;
+    cause;
+    constructor(message, options, context) {
+        super(message, options);
+        this.name = 'HubSpotHttpError';
+        this.context = context;
+        this.cause = options?.cause;
+        if (options && (0, axios_1.isAxiosError)(options.cause)) {
+            this.extractDerivedContext(options.cause);
+            const { response, config, code } = options.cause;
+            this.message = this.joinErrorMessages(options.cause, {
+                accountId: this.context?.accountId || this.derivedContext?.accountId,
+            });
+            this.detailedMessage = this.joinErrorMessages(options.cause, this.context);
+            this.code = code;
+            this.method = config?.method;
+            // Pull the request fields to the top level
+            if (response) {
+                this.status = response.status;
+                this.statusText = response.statusText;
+                this.data = response.data;
+                this.headers = response.headers;
+                this.parseValidationErrors(response.data);
+            }
+        }
+        else if (options && options.cause instanceof Error) {
+            const messages = options.cause.name !== 'Error' ? [`${options.cause.name}:`] : [];
+            if (options.cause.message) {
+                messages.push(options.cause.message);
+            }
+            if ('reason' in options.cause && options.cause.reason) {
+                messages.push(`${options.cause.reason}`);
+            }
+            this.message = messages.join(' ');
+        }
+    }
+    updateContext(context) {
+        this.context = { ...this.context, ...context };
+        // Update the error messages when the context is updated
+        if ((0, axios_1.isAxiosError)(this.cause)) {
+            this.message = this.joinErrorMessages(this.cause, this.context);
+        }
+    }
+    toString() {
+        const messages = [
+            `${this.name}: ${this.divider}message: ${this.detailedMessage}`,
+        ];
+        ['status', 'statusText', 'method', 'code'].forEach(field => {
+            if (Object.hasOwn(this, field)) {
+                // @ts-expect-error this[field] exists, so we know it is a property of this
+                messages.push(`${field}: ${this[field]}`);
+            }
+        });
+        if (this.validationErrors && this.validationErrors.length > 0) {
+            messages.push(`errors: ${this.formattedValidationErrors()}`);
+        }
+        if (this.context) {
+            messages.push(`context: ${JSON.stringify(this.context, undefined, 2)}`);
+        }
+        if (this.derivedContext) {
+            messages.push(`derivedContext: ${JSON.stringify(this.derivedContext, undefined, 2)}`);
+        }
+        return messages.join(this.divider);
+    }
+    formattedValidationErrors() {
+        if (!this.validationErrors || this.validationErrors?.length === 0) {
+            return '';
+        }
+        return this.validationErrors?.join(this.divider);
+    }
+    extractDerivedContext(cause) {
+        const generatedContext = {};
+        if (!cause) {
+            return;
+        }
+        generatedContext.accountId = cause.config?.params?.portalId;
+        generatedContext.payload = JSON.stringify(cause.config?.data);
+        // This will just be the url path
+        generatedContext.request = cause.config?.url;
+        // Allow the provided context to override the generated context
+        this.derivedContext = { ...this.derivedContext, ...generatedContext };
+    }
+    parseValidationErrors(responseData = { errors: [], message: '' }) {
+        if (!responseData) {
+            return;
+        }
+        const errorMessages = [];
+        const { errors, message } = responseData;
+        if (message) {
+            errorMessages.push(message);
+        }
+        if (errors) {
+            const specificErrors = errors.map(error => {
+                let errorMessage = error.message;
+                if (error.context?.requiredScopes) {
+                    // Sometimes the scopes come back with duplicates
+                    const scopes = new Set(error.context.requiredScopes);
+                    scopes.forEach(item => {
+                        errorMessage = `${errorMessage}\n  - ${item}`;
+                    });
+                }
+                else if (error.errorTokens && error.errorTokens.line) {
+                    errorMessage = `line ${error.errorTokens.line}: ${errorMessage}`;
+                }
+                return errorMessage;
+            });
+            errorMessages.push(...specificErrors);
+        }
+        this.validationErrors = errorMessages;
+    }
+    joinErrorMessages(error, context = {}) {
+        const i18nKey = 'errors.apiErrors';
+        const status = error.response?.status;
+        const method = error.config?.method;
+        let messageDetail;
+        if (context.accountId) {
+            const action = (method && api_1.HTTP_METHOD_VERBS[method]) || api_1.HTTP_METHOD_VERBS.get;
+            const preposition = (method && api_1.HTTP_METHOD_PREPOSITIONS[method]) ||
+                api_1.HTTP_METHOD_PREPOSITIONS.get;
+            const requestName = context.request
+                ? `${action} ${preposition} '${context.request}'`
+                : action;
+            messageDetail = (0, lang_1.i18n)(`${i18nKey}.messageDetail`, {
+                accountId: context.accountId,
+                requestName,
+            });
+        }
+        else {
+            messageDetail = (0, lang_1.i18n)(`${i18nKey}.genericMessageDetail`);
+        }
+        const errorMessage = [];
+        if ((method === 'put' || method === 'post') && context.payload) {
+            errorMessage.push((0, lang_1.i18n)(`${i18nKey}.unableToUpload`, { payload: context.payload }));
+        }
+        switch (status) {
+            case 400:
+                errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.400`, { messageDetail }));
+                break;
+            case 401:
+                errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.401`, { messageDetail }));
+                break;
+            case 403:
+                break;
+            case 404:
+                errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.404`, { messageDetail }));
+                break;
+            case 429:
+                errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.429`, { messageDetail }));
+                break;
+            case 503:
+                errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.503`, { messageDetail }));
+                break;
+            default:
+                if (status && status >= 500 && status < 600) {
+                    errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.500Generic`, { messageDetail }));
+                }
+                else if (status && status >= 400 && status < 500) {
+                    errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.400Generic`, { messageDetail }));
+                }
+                else {
+                    errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.generic`, { messageDetail }));
+                }
+                break;
+        }
+        if (error?.response?.data) {
+            const { message, errors } = error.response.data;
+            if (message) {
+                errorMessage.push(message);
+            }
+            (errors || []).forEach(err => {
+                if (err.message) {
+                    errorMessage.push(`${this.divider}${err.message}`);
+                }
+            });
+        }
+        return errorMessage.join(' ');
+    }
+}
+exports.HubSpotHttpError = HubSpotHttpError;

package/models/OAuth2Manager.d.ts

@@ -1,5 +1,5 @@
 import { FlatAccountFields, OAuth2ManagerAccountConfig, WriteTokenInfoFunction, RefreshTokenResponse, ExchangeProof } from '../types/Accounts';
-declare class OAuth2Manager {
+export declare class OAuth2Manager {
     account: OAuth2ManagerAccountConfig;
     writeTokenInfo?: WriteTokenInfoFunction;
     refreshTokenRequest: Promise<RefreshTokenResponse> | null;
@@ -10,4 +10,3 @@ declare class OAuth2Manager {
     refreshAccessToken(): Promise<void>;
     static fromConfig(accountConfig: FlatAccountFields, writeTokenInfo: WriteTokenInfoFunction): OAuth2Manager;
 }
-export default OAuth2Manager;

package/models/OAuth2Manager.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuth2Manager = void 0;
 const axios_1 = __importDefault(require("axios"));
 const moment_1 = __importDefault(require("moment"));
 const urls_1 = require("../lib/urls");
@@ -10,7 +11,6 @@ const environment_1 = require("../lib/environment");
 const logger_1 = require("../lib/logger");
 const getAccountIdentifier_1 = require("../utils/getAccountIdentifier");
 const auth_1 = require("../constants/auth");
-const standardErrors_1 = require("../errors/standardErrors");
 const lang_1 = require("../utils/lang");
 const i18nKey = 'models.OAuth2Manager';
 class OAuth2Manager {
@@ -27,9 +27,9 @@ class OAuth2Manager {
     }
     async accessToken() {
         if (!this.account.tokenInfo?.refreshToken) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.missingRefreshToken`, {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.missingRefreshToken`, {
                 accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
-            });
+            }));
         }
         if (!this.account.tokenInfo?.accessToken ||
             (0, moment_1.default)()
@@ -68,36 +68,21 @@ class OAuth2Manager {
                 }));
                 this.writeTokenInfo(this.account.tokenInfo);
             }
-            this.refreshTokenRequest = null;
         }
-        catch (e) {
+        finally {
             this.refreshTokenRequest = null;
-            (0, standardErrors_1.throwError)(e);
         }
     }
     async exchangeForTokens(exchangeProof) {
-        try {
-            if (this.refreshTokenRequest) {
-                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.refreshingAccessToken`, {
-                    accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
-                    clientId: this.account.clientId || '',
-                }));
-                await this.refreshTokenRequest;
-            }
-            else {
-                await this.fetchAccessToken(exchangeProof);
-            }
+        if (this.refreshTokenRequest) {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.refreshingAccessToken`, {
+                accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
+                clientId: this.account.clientId || '',
+            }));
+            await this.refreshTokenRequest;
         }
-        catch (e) {
-            const error = e;
-            if (error.response) {
-                (0, standardErrors_1.throwAuthErrorWithMessage)(`${i18nKey}.errors.auth`, {
-                    token: error.response.data.message || '',
-                }, error);
-            }
-            else {
-                (0, standardErrors_1.throwError)(error);
-            }
+        else {
+            await this.fetchAccessToken(exchangeProof);
         }
     }
     async refreshAccessToken() {
@@ -117,4 +102,4 @@ class OAuth2Manager {
         }, writeTokenInfo);
     }
 }
-exports.default = OAuth2Manager;
+exports.OAuth2Manager = OAuth2Manager;