@hubspot/local-dev-lib 0.2.1 → 0.2.2-experimental.0

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,34 +1,12 @@
-import { FlatAccountFields, OAuthAccount, TokenInfo } from '../types/Accounts';
-type WriteTokenInfoFunction = (tokenInfo: TokenInfo) => void;
-type RefreshTokenResponse = {
-    refresh_token: string;
-    access_token: string;
-    expires_in: string;
-};
-type ExchangeProof = {
-    grant_type: string;
-    client_id?: string;
-    client_secret?: string;
-    refresh_token?: string;
-};
-declare class OAuth2Manager {
-    account: OAuthAccount;
-    writeTokenInfo: WriteTokenInfoFunction;
+import { FlatAccountFields, OAuth2ManagerAccountConfig, WriteTokenInfoFunction, RefreshTokenResponse, ExchangeProof } from '../types/Accounts';
+export declare class OAuth2Manager {
+    account: OAuth2ManagerAccountConfig;
+    writeTokenInfo?: WriteTokenInfoFunction;
     refreshTokenRequest: Promise<RefreshTokenResponse> | null;
-    constructor(account: OAuthAccount, writeTokenInfo: WriteTokenInfoFunction);
+    constructor(account: OAuth2ManagerAccountConfig, writeTokenInfo?: WriteTokenInfoFunction);
     accessToken(): Promise<string | undefined>;
     fetchAccessToken(exchangeProof: ExchangeProof): Promise<void>;
     exchangeForTokens(exchangeProof: ExchangeProof): Promise<void>;
     refreshAccessToken(): Promise<void>;
-    toObj(): {
-        env: import("../types/Config").Environment;
-        clientSecret: string | undefined;
-        clientId: string | undefined;
-        scopes: string[] | undefined;
-        tokenInfo: TokenInfo | undefined;
-        name: string | undefined;
-        accountId: number;
-    };
     static fromConfig(accountConfig: FlatAccountFields, writeTokenInfo: WriteTokenInfoFunction): OAuth2Manager;
 }
-export default OAuth2Manager;

package/models/OAuth2Manager.js

@@ -3,14 +3,15 @@ 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");
 const environment_1 = require("../lib/environment");
-const logger_1 = require("../utils/logger");
-const getAccountIdentifier_1 = require("../utils/getAccountIdentifier");
+const logger_1 = require("../lib/logger");
+const getAccountIdentifier_1 = require("../config/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 {
     account;
@@ -25,104 +26,80 @@ class OAuth2Manager {
         }
     }
     async accessToken() {
-        if (!this.account.auth.tokenInfo?.refreshToken) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.missingRefreshToken`, {
+        if (!this.account.tokenInfo?.refreshToken) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.missingRefreshToken`, {
                 accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
-            });
+            }));
         }
-        if (!this.account.auth.tokenInfo?.accessToken ||
+        if (!this.account.tokenInfo?.accessToken ||
             (0, moment_1.default)()
                 .add(5, 'minutes')
-                .isAfter((0, moment_1.default)(this.account.auth?.tokenInfo.expiresAt))) {
+                .isAfter((0, moment_1.default)(new Date(this.account.tokenInfo.expiresAt || '')))) {
             await this.refreshAccessToken();
         }
-        return this.account.auth?.tokenInfo.accessToken;
+        return this.account.tokenInfo.accessToken;
     }
     async fetchAccessToken(exchangeProof) {
-        (0, logger_1.debug)(`${i18nKey}.fetchingAccessToken`, {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.fetchingAccessToken`, {
             accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
-            clientId: this.account.auth.clientId || '',
-        });
+            clientId: this.account.clientId || '',
+        }));
         try {
-            const { data } = await axios_1.default.post(`${(0, urls_1.getHubSpotApiOrigin)((0, environment_1.getValidEnv)(this.account.env))}/oauth/v1/token`, {
-                form: exchangeProof,
-                json: true,
+            const { data } = await (0, axios_1.default)({
+                url: `${(0, urls_1.getHubSpotApiOrigin)((0, environment_1.getValidEnv)(this.account.env))}/oauth/v1/token`,
+                method: 'post',
+                data: exchangeProof,
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
             });
             this.refreshTokenRequest = data;
             const { refresh_token: refreshToken, access_token: accessToken, expires_in: expiresIn, } = data;
-            if (!this.account.auth.tokenInfo) {
-                this.account.auth.tokenInfo = {};
+            if (!this.account.tokenInfo) {
+                this.account.tokenInfo = {};
             }
-            this.account.auth.tokenInfo.refreshToken = refreshToken;
-            this.account.auth.tokenInfo.accessToken = accessToken;
-            this.account.auth.tokenInfo.expiresAt = (0, moment_1.default)()
+            this.account.tokenInfo.refreshToken = refreshToken;
+            this.account.tokenInfo.accessToken = accessToken;
+            this.account.tokenInfo.expiresAt = (0, moment_1.default)()
                 .add(Math.round(parseInt(expiresIn) * 0.75), 'seconds')
                 .toString();
             if (this.writeTokenInfo) {
-                (0, logger_1.debug)(`${i18nKey}.updatingTokenInfo`, {
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updatingTokenInfo`, {
                     accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
-                    clientId: this.account.auth.clientId || '',
-                });
-                this.writeTokenInfo(this.account.auth.tokenInfo);
+                    clientId: this.account.clientId || '',
+                }));
+                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) {
-                (0, logger_1.debug)(`${i18nKey}.refreshingAccessToken`, {
-                    accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
-                    clientId: this.account.auth.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() {
         const refreshTokenProof = {
             grant_type: 'refresh_token',
-            client_id: this.account.auth.clientId,
-            client_secret: this.account.auth.clientSecret,
-            refresh_token: this.account.auth.tokenInfo?.refreshToken,
+            client_id: this.account.clientId,
+            client_secret: this.account.clientSecret,
+            refresh_token: this.account.tokenInfo?.refreshToken,
         };
         await this.exchangeForTokens(refreshTokenProof);
     }
-    toObj() {
-        return {
-            env: this.account.env,
-            clientSecret: this.account.auth.clientSecret,
-            clientId: this.account.auth.clientId,
-            scopes: this.account.auth.scopes,
-            tokenInfo: this.account.auth.tokenInfo,
-            name: this.account.name,
-            accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
-        };
-    }
     static fromConfig(accountConfig, writeTokenInfo) {
         return new OAuth2Manager({
             ...accountConfig,
             authType: auth_1.AUTH_METHODS.oauth.value,
-            auth: accountConfig.auth || {},
+            ...(accountConfig.auth || {}),
         }, writeTokenInfo);
     }
 }
-exports.default = OAuth2Manager;
+exports.OAuth2Manager = OAuth2Manager;

package/package.json

@@ -1,8 +1,7 @@
 {
     "name": "@hubspot/local-dev-lib",
-    "version": "0.2.1",
+    "version": "0.2.2-experimental.0",
     "description": "Provides library functionality for HubSpot local development tooling, including the HubSpot CLI",
-    "main": "lib/index.js",
     "repository": {
         "type": "git",
         "url": "https://github.com/HubSpot/hubspot-local-dev-lib"
@@ -12,22 +11,16 @@
         "access": "public"
     },
     "scripts": {
-        "build": "rm -rf ./dist/ && tsc --rootDir . --outdir dist && yarn copy-files && yarn clear-postinstall",
-        "check-main": "branch=$(git rev-parse --abbrev-ref HEAD) && [ $branch = main ] || (echo 'Error: New release can only be published on main branch' && exit 1)",
-        "clear-postinstall": "cd dist && npm pkg delete scripts.postinstall",
-        "copy-files": "cp -r lang dist/lang",
-        "lint": "eslint --max-warnings=0 . && prettier --check ./**/*.ts",
+        "build": "ts-node ./scripts/build.ts",
+        "lint": "eslint --max-warnings=0 . && prettier . --check",
         "local-dev": "yarn build && cd dist && yarn link && cd .. && tsc --watch --rootDir . --outdir dist",
-        "prettier:write": "prettier --write ./**/*.{ts,js,json}",
-        "pub": "cd dist && npm publish --tag latest && cd ..",
-        "push": "git push --atomic origin main v$npm_package_version",
-        "release:major": "yarn check-main && yarn version --major && yarn build && yarn pub && yarn push",
-        "release:minor": "yarn check-main && yarn version --minor && yarn build && yarn pub && yarn push",
-        "release:patch": "yarn check-main && yarn version --patch && yarn build && yarn pub && yarn push",
-        "test": "node --experimental-vm-modules ./node_modules/.bin/jest"
+        "prettier:write": "prettier . --write",
+        "release": "ts-node ./scripts/release.ts release",
+        "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ./node_modules/.bin/jest"
     },
     "license": "Apache-2.0",
     "devDependencies": {
+        "@inquirer/prompts": "^7.0.1",
         "@types/content-disposition": "^0.5.5",
         "@types/cors": "^2.8.15",
         "@types/debounce": "^1.2.1",
@@ -37,44 +30,51 @@
         "@types/jest": "^29.5.0",
         "@types/js-yaml": "^4.0.5",
         "@types/node": "^18.14.2",
-        "@types/prettier": "^3.0.0",
         "@types/unixify": "^1.0.0",
         "@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",
+        "open": "^8.4.2",
         "ts-jest": "^29.0.5",
-        "typescript": "^4.9.5"
+        "ts-node": "^10.9.2",
+        "typescript": "^4.9.5",
+        "yargs": "^17.7.2"
     },
     "exports": {
         "./*": "./lib/*.js",
         "./api/*": "./api/*.js",
         "./errors/*": "./errors/*.js",
         "./http": "./http/index.js",
+        "./http/*": "./http/*.js",
+        "./config/getAccountIdentifier": "./config/getAccountIdentifier.js",
+        "./config/migrate": "./config/migrate.js",
         "./config": "./config/index.js",
         "./constants/*": "./constants/*.js",
-        "./logger": "./lib/logging/logger.js"
+        "./models/*": "./models/*.js",
+        "./types/*": "./types/*.d.ts"
     },
     "dependencies": {
-        "address": "^2.0.1",
-        "axios": "^1.3.5",
-        "chalk": "^2.4.2",
-        "chokidar": "^3.5.3",
-        "content-disposition": "^0.5.4",
-        "cors": "^2.8.5",
-        "express": "^4.18.2",
-        "extract-zip": "^2.0.1",
-        "findup-sync": "^5.0.0",
-        "fs-extra": "^11.1.0",
-        "ignore": "^5.1.4",
-        "js-yaml": "^4.1.0",
-        "moment": "^2.29.4",
-        "p-queue": "^6.0.2",
-        "prettier": "^3.0.3",
-        "semver": "^6.3.0",
-        "table": "^6.8.1",
-        "unixify": "^1.0.0"
+        "address": "2.0.2",
+        "axios": "1.7.2",
+        "chalk": "2.4.2",
+        "chokidar": "3.6.0",
+        "content-disposition": "0.5.4",
+        "cors": "2.8.5",
+        "debounce": "1.2.1",
+        "express": "4.19.2",
+        "extract-zip": "2.0.1",
+        "findup-sync": "5.0.0",
+        "fs-extra": "11.2.0",
+        "ignore": "5.3.1",
+        "js-yaml": "4.1.0",
+        "moment": "2.30.1",
+        "p-queue": "6.6.2",
+        "prettier": "3.3.1",
+        "semver": "6.3.1",
+        "unixify": "1.0.0"
     },
     "engines": {
         "node": ">=16.20.0"