@hubspot/local-dev-lib 0.0.1-experimental.0

package/lib/notify.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triggerNotify = void 0;
+const fs_1 = __importDefault(require("fs"));
+const moment_1 = __importDefault(require("moment"));
+const debounce_1 = __importDefault(require("debounce"));
+const lang_1 = require("../utils/lang");
+const i18nKey = 'utils.notify';
+const notifyQueue = [];
+const notifyPromises = [];
+const debouncedWaitForActionsToCompleteAndWriteQueueToFile = (0, debounce_1.default)(waitForActionsToCompleteAndWriteQueueToFile, 500);
+// Collects actions that have been taken on files and the corresponding Promise
+// for the remote action that is in-process
+function triggerNotify(filePathToNotify, actionType, filePath, actionPromise) {
+    if (filePathToNotify) {
+        notifyQueue.push(`${(0, moment_1.default)().toISOString()} ${actionType}: ${filePath}\n`);
+        notifyPromises.push(actionPromise);
+        debouncedWaitForActionsToCompleteAndWriteQueueToFile(filePathToNotify);
+    }
+}
+exports.triggerNotify = triggerNotify;
+// Clears both the notifyQueue and notifyPromises array, generates the output
+// string that will be eventually logged, and waits for all promises currently
+// in the notifyPromises array to resolve before logging the output
+function waitForActionsToCompleteAndWriteQueueToFile(filePathToNotify) {
+    const actionOutput = notifyQueue.splice(0, notifyQueue.length).join('');
+    const allNotifyPromisesResolution = Promise.all(notifyPromises.splice(0, notifyPromises.length));
+    allNotifyPromisesResolution.then(() => notifyFilePath(filePathToNotify, actionOutput));
+}
+// Logs output to the "notify" file
+function notifyFilePath(filePathToNotify, outputToWrite) {
+    if (filePathToNotify) {
+        try {
+            fs_1.default.appendFileSync(filePathToNotify, outputToWrite);
+        }
+        catch (e) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.filePath`, { filePath: filePathToNotify }), { cause: e });
+        }
+    }
+}

package/lib/oauth.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOauthToAccountConfig = exports.getOauthManager = void 0;
+const OAuth2Manager_1 = require("../models/OAuth2Manager");
+const auth_1 = require("../constants/auth");
+const logger_1 = require("./logger");
+const getAccountIdentifier_1 = require("../config/getAccountIdentifier");
+const config_1 = require("../config");
+const lang_1 = require("../utils/lang");
+const i18nKey = 'lib.oauth';
+const oauthManagers = new Map();
+function writeOauthTokenInfo(accountConfig) {
+    const accountId = (0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig);
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.writeTokenInfo`, { portalId: accountId || '' }));
+    (0, config_1.updateAccountConfig)(accountConfig);
+    (0, config_1.writeConfig)();
+}
+function getOauthManager(accountId, accountConfig) {
+    if (!oauthManagers.has(accountId)) {
+        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`));
+    (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/path.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import path from 'path';
+export declare function convertToUnixPath(_path: string): string;
+export declare function convertToLocalFileSystemPath(_path: string): string;
+export declare function splitLocalPath(filepath: string, pathImplementation?: path.PlatformPath): Array<string>;
+export declare function splitHubSpotPath(filepath: string): Array<string>;
+export declare function getCwd(): string;
+export declare function getExt(filepath: string): string;
+export declare function getAllowedExtensions(allowList?: Array<string>): Set<string>;
+export declare function isAllowedExtension(filepath: string, allowList?: Array<string>): boolean;
+export declare function getAbsoluteFilePath(_path: string): string;
+export declare function sanitizeFileName(fileName: string): string;
+export declare function isValidPath(_path: string): boolean;
+export declare function untildify(pathWithTilde: string): string;

package/lib/path.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.untildify = exports.isValidPath = exports.sanitizeFileName = exports.getAbsoluteFilePath = exports.isAllowedExtension = exports.getAllowedExtensions = exports.getExt = exports.getCwd = exports.splitHubSpotPath = exports.splitLocalPath = exports.convertToLocalFileSystemPath = exports.convertToUnixPath = void 0;
+const path_1 = __importDefault(require("path"));
+const unixify_1 = __importDefault(require("unixify"));
+const extensions_1 = require("../constants/extensions");
+const os_1 = __importDefault(require("os"));
+function convertToUnixPath(_path) {
+    return (0, unixify_1.default)(path_1.default.normalize(_path));
+}
+exports.convertToUnixPath = convertToUnixPath;
+function convertToWindowsPath(_path) {
+    const rgx = new RegExp(`\\${path_1.default.posix.sep}`, 'g');
+    return path_1.default.normalize(_path).replace(rgx, path_1.default.win32.sep);
+}
+function convertToLocalFileSystemPath(_path) {
+    switch (path_1.default.sep) {
+        case path_1.default.posix.sep:
+            return convertToUnixPath(_path);
+        case path_1.default.win32.sep:
+            return convertToWindowsPath(_path);
+        default:
+            return path_1.default.normalize(_path);
+    }
+}
+exports.convertToLocalFileSystemPath = convertToLocalFileSystemPath;
+function removeTrailingSlashFromSplits(parts) {
+    if (parts.length > 1 && parts[parts.length - 1] === '') {
+        return parts.slice(0, parts.length - 1);
+    }
+    return parts;
+}
+// Splits a filepath for local file system sources.
+function splitLocalPath(filepath, pathImplementation = path_1.default) {
+    if (!filepath)
+        return [];
+    const { sep } = pathImplementation;
+    const rgx = new RegExp(`\\${sep}+`, 'g');
+    const parts = pathImplementation.normalize(filepath).split(rgx);
+    // Restore posix root if present
+    if (sep === path_1.default.posix.sep && parts[0] === '') {
+        parts[0] = '/';
+    }
+    return removeTrailingSlashFromSplits(parts);
+}
+exports.splitLocalPath = splitLocalPath;
+// Splits a filepath for remote sources (HubSpot).
+function splitHubSpotPath(filepath) {
+    if (!filepath)
+        return [];
+    const rgx = new RegExp(`\\${path_1.default.posix.sep}+`, 'g');
+    const parts = convertToUnixPath(filepath).split(rgx);
+    // Restore root if present
+    if (parts[0] === '') {
+        parts[0] = '/';
+    }
+    return removeTrailingSlashFromSplits(parts);
+}
+exports.splitHubSpotPath = splitHubSpotPath;
+function getCwd() {
+    if (process.env.INIT_CWD) {
+        return process.env.INIT_CWD;
+    }
+    return process.cwd();
+}
+exports.getCwd = getCwd;
+function getExt(filepath) {
+    if (typeof filepath !== 'string')
+        return '';
+    const ext = path_1.default.extname(filepath).trim().toLowerCase();
+    return ext[0] === '.' ? ext.slice(1) : ext;
+}
+exports.getExt = getExt;
+function getAllowedExtensions(allowList = []) {
+    return new Set([...Array.from(extensions_1.ALLOWED_EXTENSIONS), ...allowList]);
+}
+exports.getAllowedExtensions = getAllowedExtensions;
+function isAllowedExtension(filepath, allowList = []) {
+    const ext = getExt(filepath);
+    const allowedExtensions = getAllowedExtensions(allowList);
+    return allowedExtensions.has(ext);
+}
+exports.isAllowedExtension = isAllowedExtension;
+function getAbsoluteFilePath(_path) {
+    return path_1.default.resolve(getCwd(), _path);
+}
+exports.getAbsoluteFilePath = getAbsoluteFilePath;
+// Reserved names (Windows specific)
+const reservedNames = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i;
+// Based on the node-sanitize-filename package: https://github.com/parshap/node-sanitize-filename/blob/master/index.js
+function sanitizeFileName(fileName) {
+    // Windows invalid/control characters
+    // eslint-disable-next-line no-control-regex
+    const invalidChars = /[<>:"/|?*\x00-\x1F]/g;
+    //Replace invalid characters with dash
+    let sanitizedFileName = fileName.replace(invalidChars, '-');
+    // Removes trailing periods and spaces for Windows
+    sanitizedFileName = sanitizedFileName.replace(/[. ]+$/, '');
+    //Reserved names check for Windows
+    if (reservedNames.test(sanitizedFileName)) {
+        sanitizedFileName = `-${sanitizedFileName}`;
+    }
+    return sanitizedFileName;
+}
+exports.sanitizeFileName = sanitizeFileName;
+// Based on the node-sanitize-filename package: https://github.com/parshap/node-sanitize-filename/blob/master/index.js
+function isValidPath(_path) {
+    // Invalid characters excluding forward slash
+    // eslint-disable-next-line no-control-regex
+    const invalidChars = /[<>:"|?*\x00-\x1F]/;
+    const baseName = path_1.default.basename(_path);
+    if (invalidChars.test(baseName)) {
+        return false;
+    }
+    if (reservedNames.test(baseName)) {
+        return false;
+    }
+    return true;
+}
+exports.isValidPath = isValidPath;
+// Based on the untildify package: https://github.com/sindresorhus/untildify/blob/main/index.js
+function untildify(pathWithTilde) {
+    const homeDirectory = os_1.default.homedir();
+    if (typeof pathWithTilde !== 'string') {
+        throw new TypeError(`Expected a string, got ${typeof pathWithTilde}`);
+    }
+    return homeDirectory
+        ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory)
+        : pathWithTilde;
+}
+exports.untildify = untildify;

package/lib/personalAccessKey.d.ts

@@ -0,0 +1,10 @@
+import { CLIAccount } from '../types/Accounts';
+import { Environment } from '../types/Config';
+import { AccessToken } from '../types/Accounts';
+export declare function getAccessToken(personalAccessKey: string, env?: Environment, accountId?: number): Promise<AccessToken>;
+export declare function accessTokenForPersonalAccessKey(accountId: number, forceRefresh?: boolean): Promise<string | undefined>;
+export declare function enabledFeaturesForPersonalAccessKey(accountId: number): Promise<{
+    [key: string]: number;
+} | undefined>;
+export declare function scopesOnAccessToken(accountId: number): Promise<Array<string>>;
+export declare function updateConfigWithAccessToken(token: AccessToken, personalAccessKey: string, env?: Environment, name?: string, makeDefault?: boolean): Promise<CLIAccount | null>;

package/lib/personalAccessKey.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateConfigWithAccessToken = exports.scopesOnAccessToken = exports.enabledFeaturesForPersonalAccessKey = exports.accessTokenForPersonalAccessKey = exports.getAccessToken = void 0;
+const moment_1 = __importDefault(require("moment"));
+const environments_1 = require("../constants/environments");
+const auth_1 = require("../constants/auth");
+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 CLIConfiguration_1 = require("../config/CLIConfiguration");
+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) {
+    const axiosResponse = await (0, localDevAuth_1.fetchAccessToken)(personalAccessKey, env, accountId);
+    const response = axiosResponse.data;
+    return {
+        portalId: response.hubId,
+        accessToken: response.oauthAccessToken,
+        expiresAt: (0, moment_1.default)(response.expiresAtMillis).toISOString(),
+        scopeGroups: response.scopeGroups,
+        enabledFeatures: response.enabledFeatures,
+        encodedOAuthRefreshToken: response.encodedOAuthRefreshToken,
+        hubName: response.hubName,
+        accountType: response.accountType,
+    };
+}
+exports.getAccessToken = getAccessToken;
+async function refreshAccessToken(personalAccessKey, env = environments_1.ENVIRONMENTS.PROD, accountId) {
+    const accessTokenResponse = await getAccessToken(personalAccessKey, env, accountId);
+    const { accessToken, expiresAt } = accessTokenResponse;
+    const config = (0, config_1.getAccountConfig)(accountId);
+    (0, config_1.updateAccountConfig)({
+        env,
+        ...config,
+        accountId,
+        tokenInfo: {
+            accessToken,
+            expiresAt: expiresAt,
+        },
+    });
+    (0, config_1.writeConfig)();
+    return accessTokenResponse;
+}
+async function getNewAccessToken(accountId, personalAccessKey, expiresAt, env) {
+    const key = getRefreshKey(personalAccessKey, expiresAt);
+    if (refreshRequests.has(key)) {
+        return refreshRequests.get(key);
+    }
+    let accessTokenResponse;
+    try {
+        const refreshAccessPromise = refreshAccessToken(personalAccessKey, env, accountId);
+        if (key) {
+            refreshRequests.set(key, refreshAccessPromise);
+        }
+        accessTokenResponse = await refreshAccessPromise;
+    }
+    catch (e) {
+        if (key) {
+            refreshRequests.delete(key);
+        }
+        throw e;
+    }
+    return accessTokenResponse;
+}
+async function getNewAccessTokenByAccountId(accountId) {
+    const account = (0, config_1.getAccountConfig)(accountId);
+    if (!account) {
+        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);
+    return accessTokenResponse;
+}
+async function accessTokenForPersonalAccessKey(accountId, forceRefresh = false) {
+    const account = (0, config_1.getAccountConfig)(accountId);
+    if (!account) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.accountNotFound`, { accountId }));
+    }
+    const { auth, personalAccessKey, env } = account;
+    const authTokenInfo = auth && auth.tokenInfo;
+    const authDataExists = authTokenInfo && auth?.tokenInfo?.accessToken;
+    if (!authDataExists ||
+        forceRefresh ||
+        (0, moment_1.default)().add(5, 'minutes').isAfter((0, moment_1.default)(authTokenInfo.expiresAt))) {
+        return getNewAccessToken(accountId, personalAccessKey, authTokenInfo && authTokenInfo.expiresAt, env).then(tokenInfo => tokenInfo.accessToken);
+    }
+    return auth?.tokenInfo?.accessToken;
+}
+exports.accessTokenForPersonalAccessKey = accessTokenForPersonalAccessKey;
+async function enabledFeaturesForPersonalAccessKey(accountId) {
+    const accessTokenResponse = await getNewAccessTokenByAccountId(accountId);
+    return accessTokenResponse?.enabledFeatures;
+}
+exports.enabledFeaturesForPersonalAccessKey = enabledFeaturesForPersonalAccessKey;
+async function scopesOnAccessToken(accountId) {
+    return (await getNewAccessTokenByAccountId(accountId)).scopeGroups;
+}
+exports.scopesOnAccessToken = scopesOnAccessToken;
+async function updateConfigWithAccessToken(token, personalAccessKey, env, name, makeDefault = false) {
+    const { portalId, accessToken, expiresAt, accountType } = token;
+    const accountEnv = env || (0, config_1.getEnv)(name);
+    let parentAccountId;
+    try {
+        if (accountType === config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX ||
+            accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
+            const { data: sandboxDataResponse } = await (0, sandboxHubs_1.fetchSandboxHubData)(accessToken, portalId, accountEnv);
+            if (sandboxDataResponse.parentHubId) {
+                parentAccountId = sandboxDataResponse.parentHubId;
+            }
+        }
+    }
+    catch (err) {
+        // Log error but do not throw
+        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 { data: developerTestAccountResponse } = await (0, developerTestAccounts_1.fetchDeveloperTestAccountData)(accessToken, portalId, accountEnv);
+            if (developerTestAccountResponse) {
+                parentAccountId = developerTestAccountResponse.parentPortalId;
+            }
+        }
+    }
+    catch (err) {
+        // Log error but do not throw
+        if ((0, errors_1.isHubSpotHttpError)(err)) {
+            logger_1.logger.debug(err.message);
+        }
+        logger_1.logger.debug(err);
+    }
+    const updatedAccount = (0, config_1.updateAccountConfig)({
+        accountId: portalId,
+        accountType,
+        personalAccessKey,
+        name,
+        authType: auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value,
+        tokenInfo: { accessToken, expiresAt },
+        parentAccountId,
+        env: accountEnv,
+    });
+    if (!CLIConfiguration_1.CLIConfiguration.isActive()) {
+        (0, config_1.writeConfig)();
+    }
+    if (makeDefault && name) {
+        (0, config_1.updateDefaultAccount)(name);
+    }
+    return updatedAccount;
+}
+exports.updateConfigWithAccessToken = updateConfigWithAccessToken;

package/lib/portManager.d.ts

@@ -0,0 +1,10 @@
+import { RequestPortsData } from '../types/PortManager';
+export declare const BASE_URL: string;
+export declare function isPortManagerServerRunning(): Promise<boolean>;
+export declare function startPortManagerServer(): Promise<void>;
+export declare function stopPortManagerServer(): Promise<void>;
+export declare function requestPorts(portData: Array<RequestPortsData>): Promise<{
+    [instanceId: string]: number;
+}>;
+export declare function deleteServerInstance(serverInstanceId: string): Promise<void>;
+export declare function portManagerHasActiveServers(): Promise<boolean>;

package/lib/portManager.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.portManagerHasActiveServers = exports.deleteServerInstance = exports.requestPorts = exports.stopPortManagerServer = exports.startPortManagerServer = exports.isPortManagerServerRunning = exports.BASE_URL = void 0;
+const axios_1 = __importDefault(require("axios"));
+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}`;
+async function isPortManagerServerRunning() {
+    const port = await (0, detectPort_1.detectPort)(ports_1.PORT_MANAGER_SERVER_PORT);
+    return port !== ports_1.PORT_MANAGER_SERVER_PORT;
+}
+exports.isPortManagerServerRunning = isPortManagerServerRunning;
+async function startPortManagerServer() {
+    const isRunning = await isPortManagerServerRunning();
+    if (!isRunning) {
+        await PortManagerServer_1.PortManagerServer.init();
+    }
+}
+exports.startPortManagerServer = startPortManagerServer;
+async function stopPortManagerServer() {
+    const isRunning = await isPortManagerServerRunning();
+    if (isRunning) {
+        await axios_1.default.post(`${exports.BASE_URL}/close`);
+    }
+}
+exports.stopPortManagerServer = stopPortManagerServer;
+async function requestPorts(portData) {
+    const { data } = await axios_1.default.post(`${exports.BASE_URL}/servers`, {
+        portData: portData,
+    });
+    return data.ports;
+}
+exports.requestPorts = requestPorts;
+async function deleteServerInstance(serverInstanceId) {
+    await axios_1.default.delete(`${exports.BASE_URL}/servers/${serverInstanceId}`);
+}
+exports.deleteServerInstance = deleteServerInstance;
+async function portManagerHasActiveServers() {
+    const { data } = await axios_1.default.get(`${exports.BASE_URL}/servers`);
+    return data.count > 0;
+}
+exports.portManagerHasActiveServers = portManagerHasActiveServers;

package/lib/text.d.ts

@@ -0,0 +1,2 @@
+export declare function commaSeparatedValues(arr: Array<string>, conjunction?: null | string, ifempty?: string): string;
+export declare function toKebabCase(str: string): string;

package/lib/text.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toKebabCase = exports.commaSeparatedValues = void 0;
+function commaSeparatedValues(arr, conjunction = 'and', ifempty = '') {
+    const l = arr.length;
+    if (!l)
+        return ifempty;
+    if (l < 2)
+        return arr[0];
+    if (l < 3)
+        return arr.join(` ${conjunction} `);
+    arr = arr.slice();
+    arr[l - 1] = `${conjunction} ${arr[l - 1]}`;
+    return arr.join(', ');
+}
+exports.commaSeparatedValues = commaSeparatedValues;
+function toKebabCase(str) {
+    return (str
+        .replace(/[.,/#!$%^&*;:{}=\-_'"`~()]/g, '')
+        .match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g) || [])
+        .join('-')
+        .toLowerCase();
+}
+exports.toKebabCase = toKebabCase;

package/lib/trackUsage.d.ts

@@ -0,0 +1 @@
+export declare function trackUsage(eventName: string, eventClass: string, meta?: {}, accountId?: number): Promise<void>;

package/lib/trackUsage.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackUsage = void 0;
+const axios_1 = __importDefault(require("axios"));
+const getAxiosConfig_1 = require("../http/getAxiosConfig");
+const logger_1 = require("./logger");
+const http_1 = require("../http");
+const config_1 = require("../config");
+const fileMapper_1 = require("../api/fileMapper");
+const lang_1 = require("../utils/lang");
+const i18nKey = 'lib.trackUsage';
+async function trackUsage(eventName, eventClass, meta = {}, accountId) {
+    const usageEvent = {
+        accountId,
+        eventName,
+        eventClass,
+        meta,
+    };
+    const EVENT_TYPES = {
+        VSCODE_EXTENSION_INTERACTION: 'vscode-extension-interaction',
+        CLI_INTERACTION: 'cli-interaction',
+    };
+    let analyticsEndpoint;
+    switch (eventName) {
+        case EVENT_TYPES.CLI_INTERACTION:
+            analyticsEndpoint = 'cms-cli-usage';
+            break;
+        case EVENT_TYPES.VSCODE_EXTENSION_INTERACTION:
+            analyticsEndpoint = 'vscode-extension-usage';
+            break;
+        default:
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.invalidEvent`, { eventName }));
+    }
+    const path = `${fileMapper_1.FILE_MAPPER_API_PATH}/${analyticsEndpoint}`;
+    const accountConfig = accountId && (0, config_1.getAccountConfig)(accountId);
+    if (accountConfig && accountConfig.authType === 'personalaccesskey') {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.sendingEventAuthenticated`));
+        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)({
+        env,
+        url: path,
+        data: usageEvent,
+        resolveWithFullResponse: true,
+    });
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.sendingEventUnauthenticated`));
+    return (0, axios_1.default)({ ...axiosConfig, method: 'post' });
+}
+exports.trackUsage = trackUsage;

package/lib/urls.d.ts

@@ -0,0 +1,2 @@
+export declare const getHubSpotWebsiteOrigin: (env: string) => string;
+export declare function getHubSpotApiOrigin(env?: string, useLocalHost?: boolean): string;

package/lib/urls.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHubSpotApiOrigin = exports.getHubSpotWebsiteOrigin = void 0;
+const environments_1 = require("../constants/environments");
+function getEnvUrlString(env) {
+    if (typeof env !== 'string') {
+        return '';
+    }
+    return env.toLowerCase() === environments_1.ENVIRONMENTS.QA ? environments_1.ENVIRONMENTS.QA : '';
+}
+const getHubSpotWebsiteOrigin = (env) => `https://app.hubspot${getEnvUrlString(env)}.com`;
+exports.getHubSpotWebsiteOrigin = getHubSpotWebsiteOrigin;
+function getHubSpotApiOrigin(env, useLocalHost) {
+    let domain;
+    const domainOverride = process.env.HUBAPI_DOMAIN_OVERRIDE;
+    if (domainOverride && typeof domainOverride === 'string') {
+        domain = `${domainOverride}${getEnvUrlString(env)}`;
+    }
+    if (!domain || typeof domain !== 'string') {
+        domain = `${useLocalHost ? 'local' : 'api'}.hubapi${getEnvUrlString(env)}`;
+    }
+    return `https://${domain}.com`;
+}
+exports.getHubSpotApiOrigin = getHubSpotApiOrigin;

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;