@hubspot/local-dev-lib 0.0.4 → 0.0.6

package/errors/apiErrors.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwApiUploadError = exports.throwApiError = exports.throwApiStatusCodeError = exports.throwStatusCodeError = exports.isSpecifiedHubSpotAuthError = exports.isGatingError = exports.isMissingScopeError = void 0;
+const api_1 = require("../constants/api");
+const lang_1 = require("../utils/lang");
+const standardErrors_1 = require("./standardErrors");
+function isApiStatusCodeError(err) {
+    return (err.name === 'StatusCodeError' ||
+        (err.statusCode && err.statusCode >= 100 && err.statusCode < 600));
+}
+function isMissingScopeError(err) {
+    return Boolean(err.name === 'StatusCodeError' &&
+        err.statusCode === 403 &&
+        err.error &&
+        err.error.category === 'MISSING_SCOPES');
+}
+exports.isMissingScopeError = isMissingScopeError;
+function isGatingError(err) {
+    return Boolean(err.name === 'StatusCodeError' &&
+        err.statusCode === 403 &&
+        err.error &&
+        err.error.category === 'GATED');
+}
+exports.isGatingError = isGatingError;
+function isApiUploadValidationError(err) {
+    return Boolean(err.statusCode === 400 &&
+        err.response &&
+        err.response.body &&
+        (err.response.body.message || err.response.body.errors));
+}
+function isSpecifiedHubSpotAuthError(err, { statusCode, category, subCategory }) {
+    const statusCodeErr = !statusCode || err.statusCode === statusCode;
+    const categoryErr = !category || err.category === category;
+    const subCategoryErr = !subCategory || err.subCategory === subCategory;
+    return (err.name === 'HubSpotAuthError' &&
+        statusCodeErr &&
+        categoryErr &&
+        subCategoryErr);
+}
+exports.isSpecifiedHubSpotAuthError = isSpecifiedHubSpotAuthError;
+function parseValidationErrors(responseBody = { errors: [], message: '' }) {
+    const errorMessages = [];
+    const { errors, message } = responseBody;
+    if (message) {
+        errorMessages.push(message);
+    }
+    if (errors) {
+        const specificErrors = errors.map(error => {
+            let errorMessage = error.message;
+            if (error.errorTokens && error.errorTokens.line) {
+                errorMessage = `line ${error.errorTokens.line}: ${errorMessage}`;
+            }
+            return errorMessage;
+        });
+        errorMessages.push(...specificErrors);
+    }
+    return errorMessages;
+}
+function logValidationErrors(error) {
+    const { response = { body: undefined } } = error;
+    const validationErrorMessages = parseValidationErrors(response.body);
+    if (validationErrorMessages.length) {
+        (0, standardErrors_1.throwError)(new Error(validationErrorMessages.join(' '), { cause: error }));
+    }
+}
+function throwStatusCodeError(error, context = {}) {
+    const { statusCode, message, response } = error;
+    const errorData = JSON.stringify({
+        statusCode,
+        message,
+        url: response.request.href,
+        method: response.request.method,
+        response: response.body,
+        headers: response.headers,
+        context,
+    });
+    throw new Error(errorData, { cause: error });
+}
+exports.throwStatusCodeError = throwStatusCodeError;
+function throwApiStatusCodeError(error, context) {
+    const i18nKey = 'errors.api';
+    const { statusCode } = error;
+    const { method } = error.options || {};
+    const { projectName } = context;
+    const isPutOrPost = method === 'PUT' || method === 'POST';
+    const action = method && (api_1.HTTP_METHOD_VERBS[method] || api_1.HTTP_METHOD_VERBS.DEFAULT);
+    const preposition = (method && api_1.HTTP_METHOD_PREPOSITIONS[method]) ||
+        api_1.HTTP_METHOD_PREPOSITIONS.DEFAULT;
+    const request = context.request
+        ? `${action} ${preposition} "${context.request}"`
+        : action;
+    const messageDetail = request && context.accountId
+        ? (0, lang_1.i18n)(`${i18nKey}.messageDetail`, {
+            request,
+            accountId: context.accountId,
+        })
+        : 'request';
+    const errorMessage = [];
+    if (isPutOrPost && context.payload) {
+        errorMessage.push((0, lang_1.i18n)(`${i18nKey}.unableToUpload`, { payload: context.payload }));
+    }
+    const isProjectMissingScopeError = isMissingScopeError(error) && projectName;
+    const isProjectGatingError = isGatingError(error) && projectName;
+    switch (statusCode) {
+        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:
+            if (isProjectMissingScopeError) {
+                errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.403MissingScope`, {
+                    accountId: context.accountId || '',
+                }));
+            }
+            else if (isProjectGatingError) {
+                errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.403Gating`, {
+                    accountId: context.accountId || '',
+                }));
+            }
+            else {
+                errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.403`, { messageDetail }));
+            }
+            break;
+        case 404:
+            if (context.request) {
+                errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.404Request`, {
+                    action: action || 'request',
+                    request: context.request,
+                    account: context.accountId || '',
+                }));
+            }
+            else {
+                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 (statusCode && statusCode >= 500 && statusCode < 600) {
+                errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.500Generic`, { messageDetail }));
+            }
+            else if (statusCode && statusCode >= 400 && statusCode < 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?.error?.message &&
+        !isProjectMissingScopeError &&
+        !isProjectGatingError) {
+        errorMessage.push(error.error.message);
+    }
+    if (error.error && error.error.errors) {
+        error.error.errors.forEach(err => {
+            errorMessage.push('\n- ' + err.message);
+        });
+    }
+    (0, standardErrors_1.throwError)(new Error(errorMessage.join(' '), { cause: error }));
+}
+exports.throwApiStatusCodeError = throwApiStatusCodeError;
+function throwApiError(error, context) {
+    if (isApiStatusCodeError(error)) {
+        throwApiStatusCodeError(error, context);
+    }
+    (0, standardErrors_1.throwError)(error);
+}
+exports.throwApiError = throwApiError;
+function throwApiUploadError(error, context) {
+    if (isApiUploadValidationError(error)) {
+        logValidationErrors(error);
+    }
+    throwApiError(error, context);
+}
+exports.throwApiUploadError = throwApiUploadError;

package/errors/errors_DEPRECATED.d.ts

@@ -0,0 +1,7 @@
+import { BaseError, FileSystemErrorContext } from '../types/Error';
+type ErrorContext = {
+    accountId?: number;
+};
+export declare function logErrorInstance(error: BaseError, context?: ErrorContext): void;
+export declare function logFileSystemErrorInstance(error: BaseError, context: FileSystemErrorContext): void;
+export {};

package/errors/errors_DEPRECATED.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logFileSystemErrorInstance = exports.logErrorInstance = void 0;
+function isSystemError(err) {
+    return err.errno != null && err.code != null && err.syscall != null;
+}
+function debugErrorAndContext(error, context) {
+    if (error.name === 'StatusCodeError') {
+        const { statusCode, message, response } = error;
+        console.debug('Error: %o', {
+            statusCode,
+            message,
+            url: response.request.href,
+            method: response.request.method,
+            response: response.body,
+            headers: response.headers,
+        });
+    }
+    else {
+        console.debug('Error: %o', error);
+    }
+    console.debug('Context: %o', context);
+}
+function logErrorInstance(error, context) {
+    // SystemError
+    if (isSystemError(error)) {
+        console.error(`A system error has occurred: ${error.message}`);
+        debugErrorAndContext(error, context);
+        return;
+    }
+    if (error instanceof Error ||
+        error.message ||
+        error.reason) {
+        // Error or Error subclass
+        const name = error.name || 'Error';
+        const message = [`A ${name} has occurred.`];
+        [error.message, error.reason].forEach(msg => {
+            if (msg) {
+                message.push(msg);
+            }
+        });
+        console.error(message.join(' '));
+    }
+    else {
+        // Unknown errors
+        console.error(`An unknown error has occurred.`);
+    }
+    debugErrorAndContext(error, context);
+}
+exports.logErrorInstance = logErrorInstance;
+function logFileSystemErrorInstance(error, context) {
+    let fileAction = '';
+    if (context.read) {
+        fileAction = 'reading from';
+    }
+    else if (context.write) {
+        fileAction = 'writing to';
+    }
+    else {
+        fileAction = 'accessing';
+    }
+    const filepath = context.filepath
+        ? `"${context.filepath}"`
+        : 'a file or folder';
+    const message = [`An error occurred while ${fileAction} ${filepath}.`];
+    // Many `fs` errors will be `SystemError`s
+    if (isSystemError(error)) {
+        message.push(`This is the result of a system error: ${error.message}`);
+    }
+    console.error(message.join(' '));
+    debugErrorAndContext(error, context);
+}
+exports.logFileSystemErrorInstance = logFileSystemErrorInstance;

package/errors/fileSystemErrors.d.ts

@@ -1,8 +1,2 @@
-import { BaseError } from '../types/Error';
-type FileSystemErrorContext = {
-    filepath: string;
-    write?: boolean;
-    read?: boolean;
-};
+import { BaseError, FileSystemErrorContext } from '../types/Error';
 export declare function throwFileSystemError(error: BaseError, context: FileSystemErrorContext): void;
-export {};

package/errors/standardErrors.d.ts

@@ -1,4 +1,4 @@
-import { BaseError } from '../types/Error';
+import { BaseError, StatusCodeError } from '../types/Error';
 export declare function isSystemError(err: BaseError): boolean;
 export declare function isFatalError(err: BaseError): boolean;
 /**
@@ -13,6 +13,12 @@ export declare function throwErrorWithMessage(identifier: string, interpolation?
 export declare function throwTypeErrorWithMessage(identifier: string, interpolation?: {
     [key: string]: string | number;
 }, cause?: BaseError): never;
+/**
+ * @throws
+ */
+export declare function throwAuthErrorWithMessage(identifier: string, interpolation?: {
+    [key: string]: string | number;
+}, cause?: StatusCodeError): never;
 /**
  * @throws
  */

package/errors/standardErrors.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.throwError = exports.throwTypeErrorWithMessage = exports.throwErrorWithMessage = exports.isFatalError = exports.isSystemError = void 0;
+exports.throwError = exports.throwAuthErrorWithMessage = exports.throwTypeErrorWithMessage = exports.throwErrorWithMessage = exports.isFatalError = exports.isSystemError = void 0;
 const HubSpotAuthError_1 = require("./HubSpotAuthError");
 const lang_1 = require("../utils/lang");
+const apiErrors_1 = require("./apiErrors");
 function isSystemError(err) {
     return err.errno != null && err.code != null && err.syscall != null;
 }
@@ -11,46 +12,42 @@ function isFatalError(err) {
     return err instanceof HubSpotAuthError_1.HubSpotAuthError;
 }
 exports.isFatalError = isFatalError;
+function genericThrowErrorWithMessage(ErrorType, identifier, interpolation, cause) {
+    const message = (0, lang_1.i18n)(`errors.${identifier}`, interpolation);
+    if (cause) {
+        throw new ErrorType(message, { cause });
+    }
+    throw new ErrorType(message);
+}
 /**
  * @throws
  */
 function throwErrorWithMessage(identifier, interpolation, cause) {
-    const message = (0, lang_1.i18n)(`errors.${identifier}`, interpolation);
-    if (cause) {
-        throw new Error(message, { cause });
-    }
-    throw new Error(message);
+    genericThrowErrorWithMessage(Error, identifier, interpolation, cause);
 }
 exports.throwErrorWithMessage = throwErrorWithMessage;
 /**
  * @throws
  */
 function throwTypeErrorWithMessage(identifier, interpolation, cause) {
-    const message = (0, lang_1.i18n)(`errors.${identifier}`, interpolation);
-    if (cause) {
-        throw new TypeError(message, { cause });
-    }
-    throw new TypeError(message);
+    genericThrowErrorWithMessage(TypeError, identifier, interpolation, cause);
 }
 exports.throwTypeErrorWithMessage = throwTypeErrorWithMessage;
-function throwStatusCodeError(error) {
-    const { statusCode, message, response } = error;
-    const errorData = JSON.stringify({
-        statusCode,
-        message,
-        url: response.request.href,
-        method: response.request.method,
-        response: response.body,
-        headers: response.headers,
-    });
-    throw new Error(errorData, { cause: error });
+/**
+ * @throws
+ */
+function throwAuthErrorWithMessage(identifier, interpolation, cause) {
+    genericThrowErrorWithMessage(
+    // @ts-expect-error HubSpotAuthError is not callable
+    HubSpotAuthError_1.HubSpotAuthError, identifier, interpolation, cause);
 }
+exports.throwAuthErrorWithMessage = throwAuthErrorWithMessage;
 /**
  * @throws
  */
 function throwError(error) {
     if (error.name === 'StatusCodeError') {
-        throwStatusCodeError(error);
+        (0, apiErrors_1.throwStatusCodeError)(error);
     }
     else {
         // Error or Error subclass

package/http/getAxiosConfig.d.ts

@@ -0,0 +1,6 @@
+import { AxiosConfigOptions } from '../types/Http';
+import { AxiosRequestConfig } from 'axios';
+export declare const DEFAULT_USER_AGENT_HEADERS: {
+    'User-Agent': string;
+};
+export declare function getAxiosConfig(options: AxiosConfigOptions): AxiosRequestConfig;

package/http/getAxiosConfig.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAxiosConfig = exports.DEFAULT_USER_AGENT_HEADERS = void 0;
+const package_json_1 = require("../package.json");
+const config_1 = require("../config");
+const urls_1 = require("../lib/urls");
+exports.DEFAULT_USER_AGENT_HEADERS = {
+    'User-Agent': `HubSpot Local Dev Lib/${package_json_1.version}`,
+};
+function getAxiosConfig(options) {
+    const { env, localHostOverride, ...rest } = options;
+    const { httpTimeout, httpUseLocalhost } = (0, config_1.getAndLoadConfigIfNeeded)();
+    return {
+        baseURL: (0, urls_1.getHubSpotApiOrigin)(env, localHostOverride ? false : httpUseLocalhost),
+        headers: {
+            ...exports.DEFAULT_USER_AGENT_HEADERS,
+        },
+        timeout: httpTimeout || 15000,
+        ...rest,
+    };
+}
+exports.getAxiosConfig = getAxiosConfig;

package/http/index.d.ts

@@ -0,0 +1,18 @@
+import { LogCallbacksArg } from '../types/LogCallbacks';
+import { HttpOptions } from '../types/Http';
+import { AxiosResponse } from 'axios';
+declare function getRequest<T>(accountId: number, options: HttpOptions): Promise<T>;
+declare function postRequest<T>(accountId: number, options: HttpOptions): Promise<T>;
+declare function putRequest<T>(accountId: number, options: HttpOptions): Promise<T>;
+declare function patchRequest<T>(accountId: number, options: HttpOptions): Promise<T>;
+declare function deleteRequest<T>(accountId: number, options: HttpOptions): Promise<T>;
+declare const getRequestStreamCallbackKeys: string[];
+declare const http: {
+    get: typeof getRequest;
+    post: typeof postRequest;
+    put: typeof putRequest;
+    patch: typeof patchRequest;
+    delete: typeof deleteRequest;
+    getOctetStream: (accountId: number, options: HttpOptions, destPath: string, logCallbacks?: LogCallbacksArg<typeof getRequestStreamCallbackKeys>) => Promise<AxiosResponse>;
+};
+export default http;

package/http/index.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const content_disposition_1 = __importDefault(require("content-disposition"));
+const config_1 = require("../config");
+const getAxiosConfig_1 = require("./getAxiosConfig");
+const personalAccessKey_1 = require("../lib/personalAccessKey");
+const oauth_1 = require("../lib/oauth");
+const standardErrors_1 = require("../errors/standardErrors");
+const logger_1 = require("../utils/logger");
+const axios_1 = __importDefault(require("axios"));
+async function withOauth(accountId, accountConfig, axiosConfig) {
+    const { headers } = axiosConfig;
+    const oauth = (0, oauth_1.getOauthManager)(accountId, accountConfig);
+    if (!oauth) {
+        (0, standardErrors_1.throwErrorWithMessage)('http.index.withOauth', { accountId });
+    }
+    const accessToken = await oauth.accessToken();
+    return {
+        ...axiosConfig,
+        headers: {
+            ...headers,
+            Authorization: `Bearer ${accessToken}`,
+        },
+    };
+}
+async function withPersonalAccessKey(accountId, axiosConfig) {
+    const { headers } = axiosConfig;
+    const accessToken = await (0, personalAccessKey_1.accessTokenForPersonalAccessKey)(accountId);
+    return {
+        ...axiosConfig,
+        headers: {
+            ...headers,
+            Authorization: `Bearer ${accessToken}`,
+        },
+    };
+}
+function withPortalId(portalId, axiosConfig) {
+    const { params } = axiosConfig;
+    return {
+        ...axiosConfig,
+        params: {
+            ...params,
+            portalId,
+        },
+    };
+}
+async function withAuth(accountId, options) {
+    const accountConfig = (0, config_1.getAccountConfig)(accountId);
+    if (!accountConfig) {
+        (0, standardErrors_1.throwErrorWithMessage)('http.index.withAuth', { accountId });
+    }
+    const { env, authType, apiKey } = accountConfig;
+    const axiosConfig = withPortalId(accountId, (0, getAxiosConfig_1.getAxiosConfig)({ env, ...options }));
+    if (authType === 'personalaccesskey') {
+        return withPersonalAccessKey(accountId, axiosConfig);
+    }
+    if (authType === 'oauth2') {
+        return withOauth(accountId, accountConfig, axiosConfig);
+    }
+    const { params } = axiosConfig;
+    return {
+        ...axiosConfig,
+        params: {
+            ...params,
+            hapikey: apiKey,
+        },
+    };
+}
+function addQueryParams(configOptions, queryParams = {}) {
+    const { params } = configOptions;
+    return {
+        ...configOptions,
+        params: {
+            ...queryParams,
+            ...params,
+        },
+    };
+}
+async function getRequest(accountId, options) {
+    const { query, ...rest } = options;
+    const axiosConfig = addQueryParams(rest, query);
+    const configWithAuth = await withAuth(accountId, axiosConfig);
+    const { data } = await (0, axios_1.default)(configWithAuth);
+    return data;
+}
+async function postRequest(accountId, options) {
+    const configWithAuth = await withAuth(accountId, options);
+    const { data } = await (0, axios_1.default)({ ...configWithAuth, method: 'post' });
+    return data;
+}
+async function putRequest(accountId, options) {
+    const configWithAuth = await withAuth(accountId, options);
+    const { data } = await (0, axios_1.default)({ ...configWithAuth, method: 'put' });
+    return data;
+}
+async function patchRequest(accountId, options) {
+    const configWithAuth = await withAuth(accountId, options);
+    const { data } = await (0, axios_1.default)({ ...configWithAuth, method: 'put' });
+    return data;
+}
+async function deleteRequest(accountId, options) {
+    const configWithAuth = await withAuth(accountId, options);
+    const { data } = await (0, axios_1.default)({ ...configWithAuth, method: 'delete' });
+    return data;
+}
+const getRequestStreamCallbackKeys = ['onWrite'];
+function createGetRequestStream(contentType) {
+    return async (accountId, options, destPath, logCallbacks) => {
+        const { query, ...rest } = options;
+        const axiosConfig = addQueryParams(rest, query);
+        const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'http.index.createGetRequestStream');
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve, reject) => {
+            try {
+                const { headers, ...opts } = await withAuth(accountId, axiosConfig);
+                const res = await (0, axios_1.default)({
+                    ...opts,
+                    headers: {
+                        ...headers,
+                        accept: contentType,
+                    },
+                    responseType: 'stream',
+                });
+                if (res.status >= 200 && res.status < 300) {
+                    let filepath = destPath;
+                    if (fs_extra_1.default.existsSync(destPath)) {
+                        const stat = fs_extra_1.default.statSync(destPath);
+                        if (stat.isDirectory()) {
+                            const { parameters } = content_disposition_1.default.parse(res.headers['content-disposition'] || '');
+                            filepath = path_1.default.join(destPath, parameters.filename);
+                        }
+                    }
+                    try {
+                        fs_extra_1.default.ensureFileSync(filepath);
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                    const writeStream = fs_extra_1.default.createWriteStream(filepath, {
+                        encoding: 'binary',
+                    });
+                    res.data.pipe(writeStream);
+                    writeStream.on('error', err => {
+                        reject(err);
+                    });
+                    writeStream.on('close', async () => {
+                        logger('onWrite', { filepath });
+                        resolve(res);
+                    });
+                }
+                else {
+                    reject(res);
+                }
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    };
+}
+const getOctetStream = createGetRequestStream('application/octet-stream');
+const http = {
+    get: getRequest,
+    post: postRequest,
+    put: putRequest,
+    patch: patchRequest,
+    delete: deleteRequest,
+    getOctetStream,
+};
+exports.default = http;