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

package/api/github.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { GithubReleaseData, GithubRepoFile, RepoPath } from '../types/Github';
 import { HubSpotPromise } from '../types/Http';
 declare global {

package/api/projects.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { HubSpotPromise, QueryParams } from '../types/Http';
 import { Project, FetchProjectResponse, UploadProjectResponse, ProjectSettings, FetchPlatformVersionResponse, WarnLogsResponse, UploadIRResponse } from '../types/Project';
 import { Build, FetchProjectBuildsResponse } from '../types/Build';

package/config/CLIConfiguration.d.ts

@@ -0,0 +1,65 @@
+import { CLIConfig_NEW, Environment } from '../types/Config';
+import { CLIAccount_NEW, FlatAccountFields_NEW, AccountType } from '../types/Accounts';
+import { CLIOptions } from '../types/CLIOptions';
+import { CmsPublishMode } from '../types/Files';
+declare class _CLIConfiguration {
+    options: CLIOptions;
+    useEnvConfig: boolean;
+    config: CLIConfig_NEW | null;
+    active: boolean;
+    constructor();
+    setActive(isActive: boolean): void;
+    isActive(): boolean;
+    init(options?: CLIOptions): CLIConfig_NEW | null;
+    load(): CLIConfig_NEW | null;
+    configIsEmpty(): boolean;
+    delete(): void;
+    write(updatedConfig?: CLIConfig_NEW): CLIConfig_NEW | null;
+    validate(): boolean;
+    getAccount(nameOrId: string | number | undefined): CLIAccount_NEW | null;
+    isConfigFlagEnabled(flag: keyof CLIConfig_NEW, defaultValue?: boolean): boolean;
+    getAccountId(nameOrId?: string | number): number | null;
+    getDefaultAccount(): string | number | null;
+    getDefaultAccountOverrideFilePath(): string | null;
+    getCWDAccountOverride(): string | number | null;
+    getAccountIndex(accountId: number): number;
+    getConfigForAccount(accountId?: number): CLIAccount_NEW | null;
+    getConfigAccounts(): Array<CLIAccount_NEW> | null;
+    isAccountInConfig(nameOrId: string | number): boolean;
+    getAndLoadConfigIfNeeded(options?: CLIOptions): CLIConfig_NEW;
+    getEnv(nameOrId?: string | number): Environment;
+    getAccountType(accountType?: AccountType | null, sandboxAccountType?: string | null): AccountType;
+    /**
+     * @throws {Error}
+     */
+    addOrUpdateAccount(updatedAccountFields: Partial<FlatAccountFields_NEW>, writeUpdate?: boolean): FlatAccountFields_NEW | null;
+    /**
+     * @throws {Error}
+     */
+    updateDefaultAccount(defaultAccount: string | number): CLIConfig_NEW | null;
+    /**
+     * @throws {Error}
+     */
+    renameAccount(currentName: string, newName: string): void;
+    /**
+     * @throws {Error}
+     * TODO: this does not account for the special handling of sandbox account deletes
+     */
+    removeAccountFromConfig(nameOrId: string | number): boolean;
+    /**
+     * @throws {Error}
+     */
+    updateDefaultCmsPublishMode(defaultCmsPublishMode: CmsPublishMode): CLIConfig_NEW | null;
+    /**
+     * @throws {Error}
+     */
+    updateHttpTimeout(timeout: string): CLIConfig_NEW | null;
+    /**
+     * @throws {Error}
+     */
+    updateAllowUsageTracking(isEnabled: boolean): CLIConfig_NEW | null;
+    isTrackingAllowed(): boolean;
+    handleLegacyCmsPublishMode(config: CLIConfig_NEW | null): CLIConfig_NEW | null;
+}
+export declare const CLIConfiguration: _CLIConfiguration;
+export {};

package/config/CLIConfiguration.js

@@ -0,0 +1,509 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIConfiguration = void 0;
+const fs_1 = __importDefault(require("fs"));
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const path_1 = require("../lib/path");
+const logger_1 = require("../lib/logger");
+const environment_1 = require("./environment");
+const environment_2 = require("../lib/environment");
+const configFile_1 = require("./configFile");
+const text_1 = require("../lib/text");
+const environments_1 = require("../constants/environments");
+const auth_1 = require("../constants/auth");
+const config_1 = require("../constants/config");
+const files_1 = require("../constants/files");
+const lang_1 = require("../utils/lang");
+const i18nKey = 'config.cliConfiguration';
+class _CLIConfiguration {
+    options;
+    useEnvConfig;
+    config;
+    active;
+    constructor() {
+        this.options = {};
+        this.useEnvConfig = false;
+        this.config = null;
+        this.active = false;
+    }
+    setActive(isActive) {
+        this.active = isActive;
+    }
+    isActive() {
+        return this.active;
+    }
+    init(options = {}) {
+        this.options = options;
+        this.load();
+        this.setActive(true);
+        return this.config;
+    }
+    load() {
+        if (this.options.useEnv) {
+            const configFromEnv = (0, environment_1.loadConfigFromEnvironment)();
+            if (configFromEnv) {
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.load.configFromEnv`, {
+                    accountId: configFromEnv.accounts[0].accountId,
+                }));
+                this.useEnvConfig = true;
+                this.config = this.handleLegacyCmsPublishMode(configFromEnv);
+            }
+        }
+        else {
+            const configFromFile = (0, configFile_1.loadConfigFromFile)();
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.load.configFromFile`));
+            if (!configFromFile) {
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.load.empty`));
+                this.config = { accounts: [] };
+            }
+            this.useEnvConfig = false;
+            this.config = this.handleLegacyCmsPublishMode(configFromFile);
+        }
+        return this.config;
+    }
+    configIsEmpty() {
+        if (!(0, configFile_1.configFileExists)() || (0, configFile_1.configFileIsBlank)()) {
+            return true;
+        }
+        else {
+            this.load();
+            if (!!this.config &&
+                Object.keys(this.config).length === 1 &&
+                !!this.config.accounts) {
+                return true;
+            }
+        }
+        return false;
+    }
+    delete() {
+        if (!this.useEnvConfig && this.configIsEmpty()) {
+            (0, configFile_1.deleteConfigFile)();
+            this.config = null;
+        }
+    }
+    write(updatedConfig) {
+        if (!this.useEnvConfig) {
+            if (updatedConfig) {
+                this.config = updatedConfig;
+            }
+            if (this.config) {
+                (0, configFile_1.writeConfigToFile)(this.config);
+            }
+        }
+        return this.config;
+    }
+    validate() {
+        if (!this.config) {
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.noConfig`));
+            return false;
+        }
+        if (!Array.isArray(this.config.accounts)) {
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.noConfigAccounts`));
+            return false;
+        }
+        const accountIdsMap = {};
+        const accountNamesMap = {};
+        return this.config.accounts.every(accountConfig => {
+            if (!accountConfig) {
+                logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.emptyAccountConfig`));
+                return false;
+            }
+            if (!accountConfig.accountId) {
+                logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.noAccountId`));
+                return false;
+            }
+            if (accountIdsMap[accountConfig.accountId]) {
+                logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.duplicateAccountIds`, {
+                    accountId: accountConfig.accountId,
+                }));
+                return false;
+            }
+            if (accountConfig.name) {
+                if (accountNamesMap[accountConfig.name.toLowerCase()]) {
+                    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.duplicateAccountNames`, {
+                        accountName: accountConfig.name,
+                    }));
+                    return false;
+                }
+                if (/\s+/.test(accountConfig.name)) {
+                    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.nameContainsSpaces`, {
+                        accountName: accountConfig.name,
+                    }));
+                    return false;
+                }
+                accountNamesMap[accountConfig.name] = true;
+            }
+            if (!accountConfig.accountType) {
+                this.addOrUpdateAccount({
+                    ...accountConfig,
+                    accountId: accountConfig.accountId,
+                    accountType: this.getAccountType(undefined, accountConfig.sandboxAccountType),
+                });
+            }
+            accountIdsMap[accountConfig.accountId] = true;
+            return true;
+        });
+    }
+    getAccount(nameOrId) {
+        let name = null;
+        let accountId = null;
+        if (!this.config) {
+            return null;
+        }
+        const nameOrIdToCheck = nameOrId ? nameOrId : this.getDefaultAccount();
+        if (!nameOrIdToCheck) {
+            return null;
+        }
+        if (typeof nameOrIdToCheck === 'number') {
+            accountId = nameOrIdToCheck;
+        }
+        else if (/^\d+$/.test(nameOrIdToCheck)) {
+            accountId = parseInt(nameOrIdToCheck, 10);
+        }
+        else {
+            name = nameOrIdToCheck;
+        }
+        if (name) {
+            return this.config.accounts.find(a => a.name === name) || null;
+        }
+        else if (accountId) {
+            return this.config.accounts.find(a => accountId === a.accountId) || null;
+        }
+        return null;
+    }
+    isConfigFlagEnabled(flag, defaultValue = false) {
+        if (this.config && typeof this.config[flag] !== 'undefined') {
+            return Boolean(this.config[flag]);
+        }
+        return defaultValue;
+    }
+    getAccountId(nameOrId) {
+        const account = this.getAccount(nameOrId);
+        return account ? account.accountId : null;
+    }
+    getDefaultAccount() {
+        return this.getCWDAccountOverride() || this.config?.defaultAccount || null;
+    }
+    getDefaultAccountOverrideFilePath() {
+        return (0, findup_sync_1.default)([config_1.DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME], {
+            cwd: (0, path_1.getCwd)(),
+        });
+    }
+    getCWDAccountOverride() {
+        const defaultOverrideFile = this.getDefaultAccountOverrideFilePath();
+        if (!defaultOverrideFile) {
+            return null;
+        }
+        let source;
+        try {
+            source = fs_1.default.readFileSync(defaultOverrideFile, 'utf8');
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.getCWDAccountOverride.readFileError`, {
+                    error: e.message,
+                }));
+            }
+            return null;
+        }
+        const accountId = Number(source);
+        if (isNaN(accountId)) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.getCWDAccountOverride.errorHeader`, {
+                hsAccountFile: defaultOverrideFile,
+            }), {
+                cause: config_1.DEFAULT_ACCOUNT_OVERRIDE_ERROR_INVALID_ID,
+            });
+        }
+        const account = this.config?.accounts?.find(account => account.accountId === accountId);
+        if (!account) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.getCWDAccountOverride.errorHeader`, {
+                hsAccountFile: defaultOverrideFile,
+            }), {
+                cause: config_1.DEFAULT_ACCOUNT_OVERRIDE_ERROR_ACCOUNT_NOT_FOUND,
+            });
+        }
+        return account.name || account.accountId;
+    }
+    getAccountIndex(accountId) {
+        return this.config
+            ? this.config.accounts.findIndex(account => account.accountId === accountId)
+            : -1;
+    }
+    getConfigForAccount(accountId) {
+        if (this.config) {
+            return (this.config.accounts.find(account => account.accountId === accountId) ||
+                null);
+        }
+        return null;
+    }
+    getConfigAccounts() {
+        if (this.config) {
+            return this.config.accounts || null;
+        }
+        return null;
+    }
+    isAccountInConfig(nameOrId) {
+        if (typeof nameOrId === 'string') {
+            return (!!this.config &&
+                this.config.accounts &&
+                !!this.getAccountId(nameOrId.toLowerCase()));
+        }
+        return (!!this.config && this.config.accounts && !!this.getAccountId(nameOrId));
+    }
+    getAndLoadConfigIfNeeded(options) {
+        if (!this.config) {
+            this.init(options);
+        }
+        return this.config;
+    }
+    getEnv(nameOrId) {
+        const accountConfig = this.getAccount(nameOrId);
+        if (accountConfig && accountConfig.accountId && accountConfig.env) {
+            return accountConfig.env;
+        }
+        if (this.config && this.config.env) {
+            return this.config.env;
+        }
+        return environments_1.ENVIRONMENTS.PROD;
+    }
+    // Deprecating sandboxAccountType in favor of accountType
+    getAccountType(accountType, sandboxAccountType) {
+        if (accountType) {
+            return accountType;
+        }
+        if (typeof sandboxAccountType === 'string') {
+            if (sandboxAccountType.toUpperCase() === 'DEVELOPER') {
+                return config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX;
+            }
+            if (sandboxAccountType.toUpperCase() === 'STANDARD') {
+                return config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX;
+            }
+        }
+        return config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD;
+    }
+    /*
+     * Config Update Utils
+     */
+    /**
+     * @throws {Error}
+     */
+    addOrUpdateAccount(updatedAccountFields, writeUpdate = true) {
+        const { accountId, accountType, apiKey, authType, clientId, clientSecret, defaultCmsPublishMode, env, name, parentAccountId, personalAccessKey, sandboxAccountType, scopes, tokenInfo, } = updatedAccountFields;
+        if (!accountId) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateAccount.errors.accountIdRequired`));
+        }
+        if (!this.config) {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateAccount.noConfigToUpdate`));
+            return null;
+        }
+        // Check whether the account is already listed in the config.yml file.
+        const currentAccountConfig = this.getAccount(accountId);
+        // For accounts that are already in the config.yml file, sets the auth property.
+        let auth = (currentAccountConfig && currentAccountConfig.auth) || {};
+        // For accounts not already in the config.yml file, sets the auth property.
+        if (clientId || clientSecret || scopes || tokenInfo) {
+            auth = {
+                ...(currentAccountConfig ? currentAccountConfig.auth : {}),
+                clientId,
+                clientSecret,
+                scopes,
+                tokenInfo,
+            };
+        }
+        const nextAccountConfig = {
+            ...(currentAccountConfig ? currentAccountConfig : {}),
+        };
+        // Allow everything except for 'undefined' values to override the existing values
+        function safelyApplyUpdates(fieldName, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        newValue) {
+            if (typeof newValue !== 'undefined') {
+                nextAccountConfig[fieldName] = newValue;
+            }
+        }
+        const updatedEnv = (0, environment_2.getValidEnv)(env || (currentAccountConfig && currentAccountConfig.env));
+        const updatedDefaultCmsPublishMode = defaultCmsPublishMode &&
+            defaultCmsPublishMode.toLowerCase();
+        const updatedAccountType = accountType || (currentAccountConfig && currentAccountConfig.accountType);
+        safelyApplyUpdates('name', name);
+        safelyApplyUpdates('env', updatedEnv);
+        safelyApplyUpdates('accountId', accountId);
+        safelyApplyUpdates('authType', authType);
+        safelyApplyUpdates('auth', auth);
+        if (nextAccountConfig.authType === auth_1.API_KEY_AUTH_METHOD.value) {
+            safelyApplyUpdates('apiKey', apiKey);
+        }
+        if (typeof updatedDefaultCmsPublishMode !== 'undefined') {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            safelyApplyUpdates('defaultCmsPublishMode', files_1.CMS_PUBLISH_MODE[updatedDefaultCmsPublishMode]);
+        }
+        safelyApplyUpdates('personalAccessKey', personalAccessKey);
+        // Deprecating sandboxAccountType in favor of the more generic accountType
+        safelyApplyUpdates('sandboxAccountType', sandboxAccountType);
+        safelyApplyUpdates('accountType', this.getAccountType(updatedAccountType, sandboxAccountType));
+        safelyApplyUpdates('parentAccountId', parentAccountId);
+        const completedAccountConfig = nextAccountConfig;
+        if (!Object.hasOwn(this.config, 'accounts')) {
+            this.config.accounts = [];
+        }
+        if (currentAccountConfig) {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateAccount.updating`, {
+                accountId,
+            }));
+            const index = this.getAccountIndex(accountId);
+            if (index < 0) {
+                this.config.accounts.push(completedAccountConfig);
+            }
+            else {
+                this.config.accounts[index] = completedAccountConfig;
+            }
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateAccount.addingConfigEntry`, {
+                accountId,
+            }));
+        }
+        else {
+            this.config.accounts.push(completedAccountConfig);
+        }
+        if (writeUpdate) {
+            this.write();
+        }
+        return completedAccountConfig;
+    }
+    /**
+     * @throws {Error}
+     */
+    updateDefaultAccount(defaultAccount) {
+        if (!this.config) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noConfigLoaded`));
+        }
+        if (!defaultAccount ||
+            (typeof defaultAccount !== 'number' && typeof defaultAccount !== 'string')) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateDefaultAccount.errors.invalidInput`));
+        }
+        this.config.defaultAccount = defaultAccount;
+        return this.write();
+    }
+    /**
+     * @throws {Error}
+     */
+    renameAccount(currentName, newName) {
+        if (!this.config) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noConfigLoaded`));
+        }
+        const accountId = this.getAccountId(currentName);
+        let accountConfigToRename = null;
+        if (accountId) {
+            accountConfigToRename = this.getAccount(accountId);
+        }
+        if (!accountConfigToRename) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.renameAccount.errors.invalidName`, {
+                currentName,
+            }));
+        }
+        if (accountId) {
+            this.addOrUpdateAccount({
+                accountId,
+                name: newName,
+                env: this.getEnv(),
+                accountType: accountConfigToRename.accountType,
+            });
+        }
+        if (accountConfigToRename.name === this.getDefaultAccount()) {
+            this.updateDefaultAccount(newName);
+        }
+    }
+    /**
+     * @throws {Error}
+     * TODO: this does not account for the special handling of sandbox account deletes
+     */
+    removeAccountFromConfig(nameOrId) {
+        if (!this.config) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noConfigLoaded`));
+        }
+        const accountId = this.getAccountId(nameOrId);
+        if (!accountId) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.removeAccountFromConfig.errors.invalidId`, {
+                nameOrId,
+            }));
+        }
+        let removedAccountIsDefault = false;
+        const accountConfig = this.getAccount(accountId);
+        if (accountConfig) {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.removeAccountFromConfig.deleting`, { accountId }));
+            const index = this.getAccountIndex(accountId);
+            this.config.accounts.splice(index, 1);
+            if (this.getDefaultAccount() === accountConfig.name) {
+                removedAccountIsDefault = true;
+            }
+            this.write();
+        }
+        return removedAccountIsDefault;
+    }
+    /**
+     * @throws {Error}
+     */
+    updateDefaultCmsPublishMode(defaultCmsPublishMode) {
+        if (!this.config) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noConfigLoaded`));
+        }
+        const ALL_CMS_PUBLISH_MODES = Object.values(files_1.CMS_PUBLISH_MODE);
+        if (!defaultCmsPublishMode ||
+            !ALL_CMS_PUBLISH_MODES.find(m => m === defaultCmsPublishMode)) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateDefaultCmsPublishMode.errors.invalidCmsPublishMode`, {
+                defaultCmsPublishMode,
+                validCmsPublishModes: (0, text_1.commaSeparatedValues)(ALL_CMS_PUBLISH_MODES),
+            }));
+        }
+        this.config.defaultCmsPublishMode = defaultCmsPublishMode;
+        return this.write();
+    }
+    /**
+     * @throws {Error}
+     */
+    updateHttpTimeout(timeout) {
+        if (!this.config) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noConfigLoaded`));
+        }
+        const parsedTimeout = parseInt(timeout);
+        if (isNaN(parsedTimeout) || parsedTimeout < config_1.MIN_HTTP_TIMEOUT) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateHttpTimeout.errors.invalidTimeout`, {
+                timeout,
+                minTimeout: config_1.MIN_HTTP_TIMEOUT,
+            }));
+        }
+        this.config.httpTimeout = parsedTimeout;
+        return this.write();
+    }
+    /**
+     * @throws {Error}
+     */
+    updateAllowUsageTracking(isEnabled) {
+        if (!this.config) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noConfigLoaded`));
+        }
+        if (typeof isEnabled !== 'boolean') {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateAllowUsageTracking.errors.invalidInput`, {
+                isEnabled: `${isEnabled}`,
+            }));
+        }
+        this.config.allowUsageTracking = isEnabled;
+        return this.write();
+    }
+    isTrackingAllowed() {
+        if (!this.config) {
+            return true;
+        }
+        return this.config.allowUsageTracking !== false;
+    }
+    handleLegacyCmsPublishMode(config) {
+        if (config?.defaultMode) {
+            config.defaultCmsPublishMode = config.defaultMode;
+            delete config.defaultMode;
+        }
+        return config;
+    }
+}
+exports.CLIConfiguration = new _CLIConfiguration();

package/config/configFile.d.ts

@@ -0,0 +1,21 @@
+import { CLIConfig_NEW } from '../types/Config';
+export declare function getConfigFilePath(): string;
+export declare function configFileExists(): boolean;
+export declare function configFileIsBlank(): boolean;
+export declare function deleteConfigFile(): void;
+/**
+ * @throws {Error}
+ */
+export declare function readConfigFile(configPath: string): string;
+/**
+ * @throws {Error}
+ */
+export declare function parseConfig(configSource: string): CLIConfig_NEW;
+/**
+ * @throws {Error}
+ */
+export declare function loadConfigFromFile(): CLIConfig_NEW | null;
+/**
+ * @throws {Error}
+ */
+export declare function writeConfigToFile(config: CLIConfig_NEW): void;