@hubspot/local-dev-lib 1.13.1 → 2.0.1

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;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/local-dev-lib",
-    "version": "1.13.1",
+    "version": "2.0.1",
     "description": "Provides library functionality for HubSpot local development tooling, including the HubSpot CLI",
     "main": "lib/index.js",
     "repository": {
@@ -41,6 +41,7 @@
         "@typescript-eslint/eslint-plugin": "^5.54.0",
         "@typescript-eslint/parser": "^5.59.7",
         "eslint": "^8.35.0",
+        "eslint-plugin-import": "^2.29.1",
         "husky": "^8.0.0",
         "jest": "^29.5.0",
         "ts-jest": "^29.0.5",

package/types/Error.d.ts

@@ -16,19 +16,21 @@ export interface ValidationError extends BaseError {
     errorTokens?: {
         line: number;
     };
+    context?: {
+        requiredScopes?: string[];
+    };
 }
 export type FileSystemErrorContext = {
     filepath?: string;
-    write?: boolean;
-    read?: boolean;
+    operation?: 'write' | 'read';
     accountId?: number;
     dest?: string;
 };
-export type AxiosErrorContext = {
-    accountId?: number;
+export interface HubSpotHttpErrorContext extends FileSystemErrorContext {
     request?: string;
     payload?: string;
-};
+    projectName?: string;
+}
 export type OptionalError = BaseError | null | undefined;
 export type ErrorContext = {
     accountId?: number;

package/types/Files.d.ts

@@ -1,8 +1,8 @@
-import { AxiosError } from 'axios';
 import { ValueOf } from '../types/Utils';
 import { STAT_TYPES, FILE_TYPES, FILE_UPLOAD_RESULT_TYPES } from '../constants/files';
 import { MODE } from '../constants/files';
 import { HttpOptions } from './Http';
+import { AxiosError } from 'axios';
 export type StatType = ValueOf<typeof STAT_TYPES>;
 export type FileData = {
     filepath: string;
@@ -29,7 +29,7 @@ export type FileType = ValueOf<typeof FILE_TYPES>;
 type ResultType = ValueOf<typeof FILE_UPLOAD_RESULT_TYPES>;
 export type UploadFolderResults = {
     resultType: ResultType;
-    error: AxiosError | null;
+    error: unknown;
     file: string;
 };
 export type FileTree = {
@@ -51,9 +51,9 @@ export type CommandOptions = {
     saveOutput?: boolean;
     onAttemptCallback?: (file: string | undefined, destPath: string) => void;
     onSuccessCallback?: (file: string | undefined, destPath: string) => void;
-    onFirstErrorCallback?: (file: string, destPath: string, error: AxiosError) => void;
+    onFirstErrorCallback?: (file: string, destPath: string, error: unknown) => void;
     onRetryCallback?: (file: string, destPath: string) => void;
-    onFinalErrorCallback?: (accountId: number, file: string, destPath: string, error: AxiosError) => void;
+    onFinalErrorCallback?: (accountId: number, file: string, destPath: string, error: unknown) => void;
 };
 export type FilePathsByType = {
     [key: string]: Array<string>;

package/types/Http.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
+import { ResponseType } from 'axios';
 import { ReadStream } from 'fs';
 import { Stream } from 'stream';
 export type Data = {
@@ -9,24 +10,19 @@ export type Data = {
 export type QueryParams = {
     [key: string]: string | number | boolean | undefined;
 };
-export type AxiosConfigOptions = {
+export type FormData = {
+    [key: string]: string | ReadStream;
+};
+export type HttpOptions = {
     baseURL?: string;
     url: string;
     env?: string;
     localHostOverride?: boolean;
-    params?: QueryParams;
     data?: Data | string | ArrayBuffer | ArrayBufferView | URLSearchParams | Stream | Buffer;
     resolveWithFullResponse?: boolean;
-    timeout?: number;
-    headers?: Data;
-};
-export type FormData = {
-    [key: string]: string | ReadStream;
-};
-export type HttpOptions = AxiosConfigOptions & {
     params?: QueryParams;
     timeout?: number;
-    responseType?: string;
+    responseType?: ResponseType;
     headers?: {
         [header: string]: string | string[] | undefined;
     };

package/types/Sandbox.d.ts

@@ -47,11 +47,6 @@ type MutationError = {
         };
     };
 };
-export type SyncTaskStatusType = {
-    status: string;
-    result?: string;
-    tasks: Pick<CompositeSyncTask, 'type' | 'status'>[];
-};
 type SyncMutationData = {
     numRequests: number;
     numSuccesses: number;

package/utils/PortManagerServer.d.ts

@@ -2,7 +2,7 @@
 import { Express, Request, Response } from 'express';
 import { Server } from 'http';
 import { RequestPortsData, ServerPortMap } from '../types/PortManager';
-declare class PortManagerServer {
+declare class _PortManagerServer {
     app?: Express;
     server?: Server;
     serverPortMap: ServerPortMap;
@@ -22,5 +22,5 @@ declare class PortManagerServer {
     deleteServerInstance: (req: Request, res: Response) => void;
     closeServer: (req: Request, res: Response) => void;
 }
-declare const _default: PortManagerServer;
-export default _default;
+export declare const PortManagerServer: _PortManagerServer;
+export {};

package/utils/PortManagerServer.js

@@ -3,15 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortManagerServer = void 0;
 const express_1 = __importDefault(require("express"));
 const cors_1 = __importDefault(require("cors"));
 const detectPort_1 = require("./detectPort");
 const ports_1 = require("../constants/ports");
-const standardErrors_1 = require("../errors/standardErrors");
+const errors_1 = require("../errors");
 const logger_1 = require("../lib/logger");
 const lang_1 = require("./lang");
 const i18nKey = 'utils.PortManagerServer';
-class PortManagerServer {
+class _PortManagerServer {
     app;
     server;
     serverPortMap;
@@ -20,7 +21,7 @@ class PortManagerServer {
     }
     async init() {
         if (this.app) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.duplicateInstance`);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.duplicateInstance`));
         }
         this.app = (0, express_1.default)();
         this.app.use(express_1.default.json());
@@ -30,13 +31,12 @@ class PortManagerServer {
             this.server = await this.listen();
         }
         catch (e) {
-            const error = e;
-            if (error.code === 'EADDRINUSE') {
-                (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.portInUse`, {
+            if ((0, errors_1.isSystemError)(e) && e.code === 'EADDRINUSE') {
+                throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.portInUse`, {
                     port: ports_1.PORT_MANAGER_SERVER_PORT,
-                }, error);
+                }), { cause: e });
             }
-            throw error;
+            throw e;
         }
     }
     reset() {
@@ -155,4 +155,4 @@ class PortManagerServer {
         }
     };
 }
-exports.default = new PortManagerServer();
+exports.PortManagerServer = new _PortManagerServer();

package/utils/cms/modules.js

@@ -7,7 +7,7 @@ exports.isModuleFolderChild = exports.isModuleFolder = exports.isPathInput = voi
 const path_1 = __importDefault(require("path"));
 const path_2 = require("../../lib/path");
 const extensions_1 = require("../../constants/extensions");
-const standardErrors_1 = require("../../errors/standardErrors");
+const lang_1 = require("../lang");
 const i18nKey = 'utils.cms.modules';
 const isBool = (x) => !!x === x;
 function isPathInput(pathInput) {
@@ -19,7 +19,7 @@ exports.isPathInput = isPathInput;
 function throwInvalidPathInput(pathInput) {
     if (isPathInput(pathInput))
         return;
-    (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.throwInvalidPathInput`);
+    throw new Error((0, lang_1.i18n)(`${i18nKey}.throwInvalidPathInput`));
 }
 function isModuleFolder(pathInput) {
     throwInvalidPathInput(pathInput);

package/utils/detectPort.js

@@ -30,15 +30,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectPort = void 0;
 const net_1 = __importDefault(require("net"));
 const address_1 = require("address");
-const standardErrors_1 = require("../errors/standardErrors");
 const ports_1 = require("../constants/ports");
+const lang_1 = require("./lang");
 const i18nKey = 'utils.detectPort';
 function detectPort(port, exclude = []) {
     if (port && (port < ports_1.MIN_PORT_NUMBER || port > ports_1.MAX_PORT_NUMBER)) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidPort`, {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidPort`, {
             minPort: ports_1.MIN_PORT_NUMBER,
             maxPort: ports_1.MAX_PORT_NUMBER,
-        });
+        }));
     }
     const portToUse = port || 0;
     const maxPort = Math.min(portToUse + 10, ports_1.MAX_PORT_NUMBER);

package/errors/apiErrors.d.ts

@@ -1,25 +0,0 @@
-import { AxiosError } from 'axios';
-import { AxiosErrorContext, ValidationError } from '../types/Error';
-import { HubSpotAuthError } from '../models/HubSpotAuthError';
-export declare function isSpecifiedError(err: unknown, { statusCode, category, subCategory, errorType, code, }: {
-    statusCode?: number;
-    category?: string;
-    subCategory?: string;
-    errorType?: string;
-    code?: string;
-}): boolean;
-export declare function isMissingScopeError(err: unknown): boolean;
-export declare function isGatingError(err: unknown): boolean;
-export declare function isTimeoutError(err: unknown): boolean;
-export declare function isApiUploadValidationError(err: unknown): boolean;
-export declare function isSpecifiedHubSpotAuthError(err: unknown, { status, category, subCategory }: Partial<HubSpotAuthError>): err is HubSpotAuthError;
-export declare function parseValidationErrors(responseData?: {
-    errors?: Array<ValidationError>;
-    message?: string;
-}): Array<string>;
-export declare function getAxiosErrorWithContext(error: AxiosError<any>, context?: AxiosErrorContext): Error;
-/**
- * @throws
- */
-export declare function throwApiError(error: unknown, context?: AxiosErrorContext): never;
-export declare function throwApiUploadError(error: AxiosError, context?: AxiosErrorContext): never;