@hubspot/cli 7.8.12-experimental.0 → 7.9.0-beta.0

package/commands/testAccount/delete.js

@@ -1,39 +1,180 @@
-import { deleteDeveloperTestAccount } from '@hubspot/local-dev-lib/api/developerTestAccounts';
+import { fetchDeveloperTestAccounts, deleteDeveloperTestAccount, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { uiLogger } from '../../lib/ui/logger.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { commands } from '../../lang/en.js';
-const command = 'delete <test-account-id>';
+import { deleteAccount, getAccountConfig, getAccountId, getConfigPath, loadConfig, updateDefaultAccount, } from '@hubspot/local-dev-lib/config';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import { debugError } from '../../lib/errorHandlers/index.js';
+const command = 'delete [test-account]';
 const describe = commands.testAccount.delete.describe;
-async function handler(args) {
-    const { derivedAccountId, testAccountId } = args;
-    trackCommandUsage('test-account-delete', {}, derivedAccountId);
+async function getAccountPromptOptions(derivedAccountId) {
     try {
-        await deleteDeveloperTestAccount(derivedAccountId, testAccountId, true);
-        uiLogger.success(commands.testAccount.delete.success.testAccountDeleted(testAccountId));
+        const { data } = await fetchDeveloperTestAccounts(derivedAccountId);
+        return data.results.map(testAccount => ({
+            name: `${testAccount.accountName} (${testAccount.id})`,
+            value: testAccount.id,
+        }));
     }
     catch (err) {
-        uiLogger.error(commands.testAccount.delete.errors.failedToDelete);
+        uiLogger.error(commands.testAccount.delete.errors.failedToFetchTestAccounts);
+        throw err;
+    }
+}
+async function accountToDeleteSelectionPrompt(derivedAccountId) {
+    const accountData = await getAccountPromptOptions(derivedAccountId);
+    if (accountData.length === 0) {
+        uiLogger.error(commands.testAccount.delete.errors.noAccountsToDelete(derivedAccountId));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const { testAccountToDelete } = await promptUser([
+        {
+            type: 'list',
+            name: 'testAccountToDelete',
+            pageSize: 20,
+            message: commands.testAccount.delete.prompts.selectTestAccounts,
+            choices: accountData,
+        },
+    ]);
+    return testAccountToDelete;
+}
+async function confirmDeletion() {
+    const { shouldDelete } = await promptUser([
+        {
+            type: 'confirm',
+            name: 'shouldDelete',
+            message: commands.testAccount.delete.prompts.confirmDeletion,
+        },
+    ]);
+    return shouldDelete;
+}
+async function deleteTestAccountInHubSpot(derivedAccountId, accountId) {
+    try {
+        await deleteDeveloperTestAccount(derivedAccountId, accountId, true);
+        uiLogger.success(commands.testAccount.delete.success.testAccountDeletedFromHubSpot(accountId));
+    }
+    catch (e) {
+        debugError(e);
+        uiLogger.error(commands.testAccount.delete.errors.failedToDelete(accountId));
+    }
+}
+async function deleteTestAccountFromConfig(testAccountId, parentAccountName, account) {
+    try {
+        // If the account isn't in the local config then it wasn't auth'd on the local machine
+        if (account && account.name && account.accountType) {
+            // If the deleted test account was the default account, replace the default account with the parent account
+            loadConfig(getConfigPath()); // Get updated version of the config
+            const defaultAccountId = getAccountId(); // We need to get the current default accountId before delete the test account
+            await deleteAccount(account.name);
+            uiLogger.success(commands.testAccount.delete.success.testAccountDeletedFromConfig(testAccountId));
+            if (testAccountId === defaultAccountId) {
+                updateDefaultAccount(parentAccountName);
+                uiLogger.info(commands.testAccount.delete.info.replaceDefaultAccount(testAccountId, parentAccountName));
+            }
+        }
+    }
+    catch (e) {
+        debugError(e);
+        uiLogger.error(commands.testAccount.delete.errors.failedToDeleteFromConfig(testAccountId));
+    }
+}
+async function validateTestAccountConfigs(testAccountId) {
+    if (!testAccountId) {
+        uiLogger.error(commands.testAccount.delete.errors.testAccountNotFound(testAccountId));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const testAccountConfig = getAccountConfig(testAccountId);
+    if (!testAccountConfig) {
+        uiLogger.error(commands.testAccount.delete.errors.testAccountNotFound(testAccountId));
         process.exit(EXIT_CODES.ERROR);
     }
+    const parentAccountConfig = getAccountConfig(testAccountConfig.parentAccountId);
+    if (!parentAccountConfig) {
+        uiLogger.error(commands.testAccount.delete.errors.parentAccountNotFound(testAccountId));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const parentAccountName = parentAccountConfig.name;
+    return { testAccountConfig, parentAccountName };
+}
+async function handler(args) {
+    const { derivedAccountId, testAccount, force } = args;
+    trackCommandUsage('test-account-delete', {}, derivedAccountId);
+    let testAccountIdToDelete = 0;
+    // See if the account exists
+    if (testAccount) {
+        const accountId = getAccountId(testAccount);
+        await validateTestAccountConfigs(accountId);
+        if (accountId) {
+            testAccountIdToDelete = accountId;
+        }
+    }
+    // Prompt for selection when name or id aren't provided
+    if (!testAccountIdToDelete) {
+        try {
+            testAccountIdToDelete =
+                await accountToDeleteSelectionPrompt(derivedAccountId);
+        }
+        catch (err) {
+            debugError(err);
+            uiLogger.error(commands.testAccount.delete.errors.failedToSelectAccount);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    const { testAccountConfig, parentAccountName } = await validateTestAccountConfigs(testAccountIdToDelete);
+    // If --force, don't prompt user; else confirm deletion
+    let shouldDeleteAccount;
+    if (force) {
+        shouldDeleteAccount = true;
+    }
+    else {
+        shouldDeleteAccount = await confirmDeletion();
+    }
+    if (shouldDeleteAccount) {
+        const parentAccountId = testAccountConfig.parentAccountId;
+        await deleteTestAccountInHubSpot(parentAccountId, testAccountIdToDelete);
+        await deleteTestAccountFromConfig(testAccountIdToDelete, parentAccountName, testAccountConfig);
+    }
+    else {
+        uiLogger.info(commands.testAccount.delete.info.deletionCanceled);
+    }
     process.exit(EXIT_CODES.SUCCESS);
 }
 function deleteTestAccountBuilder(yargs) {
-    yargs.positional('test-account-id', {
-        type: 'number',
-        description: commands.testAccount.delete.positionals.testAccountId,
-        required: true,
+    yargs.positional('test-account', {
+        type: 'string',
+        description: commands.testAccount.delete.options.id,
+        required: false,
+    });
+    yargs.option('force', {
+        describe: commands.testAccount.delete.options.force,
+        type: 'boolean',
+        default: false,
     });
     yargs.example([
-        ['$0 delete 1234567890', commands.testAccount.delete.example(1234567890)],
+        [
+            '$0 test-account delete 12345678',
+            commands.testAccount.delete.examples.withPositionalID(12345678),
+        ],
+        [
+            '$0 test-account delete my-test-account',
+            commands.testAccount.delete.examples.withPositionalName('my-test-account'),
+        ],
+        [
+            '$0 test-account delete --test-account=12345678',
+            commands.testAccount.delete.examples.withID(12345678),
+        ],
+        [
+            '$0 test-account delete --test-account=my-test-account',
+            commands.testAccount.delete.examples.withName('my-test-account'),
+        ],
+        ['$0 test-account delete', commands.testAccount.delete.examples.withoutId],
     ]);
     return yargs;
 }
 const builder = makeYargsBuilder(deleteTestAccountBuilder, command, describe, {
     useGlobalOptions: true,
     useEnvironmentOptions: true,
-    useAccountOptions: true,
     useConfigOptions: true,
     useTestingOptions: true,
 });

package/commands/theme/generate-selectors.d.ts

@@ -1,6 +1,4 @@
-import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ThemeSelectorArgs = CommonArgs & {
-    path: string;
-};
-declare const themeSelectorsCommand: YargsCommandModule<unknown, ThemeSelectorArgs>;
-export default themeSelectorsCommand;
+import { YargsCommandModule } from '../../types/Yargs.js';
+import { ThemeSelectorArgs } from '../cms/theme/generate-selectors.js';
+declare const deprecatedGenerateSelectorsCommand: YargsCommandModule<unknown, ThemeSelectorArgs>;
+export default deprecatedGenerateSelectorsCommand;

package/commands/theme/generate-selectors.js

@@ -1,168 +1,30 @@
-import fs from 'fs';
-import { commands } from '../../lang/en.js';
-import { findFieldsJsonPath, combineThemeCss, setPreviewSelectors, generateInheritedSelectors, generateSelectorsMap, getMaxFieldsDepth, } from '../../lib/generateSelectors.js';
-import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { uiCommandRelocatedMessage, uiCommandRenamedDescription, uiDeprecatedTag, } from '../../lib/ui/index.js';
+import generateSelectorsCommand from '../cms/theme/generate-selectors.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-import { uiLogger } from '../../lib/ui/logger.js';
-const HUBL_EXPRESSION_REGEX = new RegExp(/{%\s*(.*)\s*%}/, 'g');
-const HUBL_VARIABLE_NAME_REGEX = new RegExp(/{%\s*set\s*(\w*)/, 'i');
-const HUBL_STATEMENT_REGEX = new RegExp(/{{\s*[\w.(,\d\-\s)|/~]*.*}}/, 'g');
-const HUBL_STATEMENT_PLACEHOLDER_REGEX = new RegExp(/hubl_statement_\d*/, 'g');
-const CSS_VARS_REGEX = new RegExp(/--([\w.(,\d\-)]*):(.*);/, 'g');
-const CSS_VARS_NAME_REGEX = new RegExp(/(--[\w.(,\d\-)]*)/, 'g');
-const CSS_SELECTORS_REGEX = new RegExp(/([\s\w:.,\0-[\]]*){/, 'i');
-const CSS_EXPRESSION_REGEX = new RegExp(/(?!\s)([^}])*(?![.#\s,>])[^}]*}/, 'g');
-const THEME_PATH_REGEX = new RegExp(/=\s*.*(theme\.(\w|\.)*)/, 'i');
+import { commands } from '../../lang/en.js';
 const command = 'generate-selectors <path>';
-const describe = commands.theme.subcommands.generateSelectors.describe;
+const describe = uiDeprecatedTag(generateSelectorsCommand.describe, false);
 async function handler(args) {
-    const { path } = args;
-    const fieldsJsonPath = findFieldsJsonPath(path);
-    if (!fieldsJsonPath) {
-        uiLogger.error(commands.theme.subcommands.generateSelectors.errors.fieldsNotFound);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    let fieldsJson = JSON.parse(fs.readFileSync(fieldsJsonPath, 'utf-8'));
-    let cssString = combineThemeCss(path) ?? '';
-    /**
-     * Creates map of HubL variable names to theme field paths
-     */
-    const HubLExpressions = cssString.match(HUBL_EXPRESSION_REGEX);
-    const hublVariableMap = HubLExpressions
-        ? HubLExpressions.reduce((_hublVariableMap, expression) => {
-            const variableName = expression.match(HUBL_VARIABLE_NAME_REGEX);
-            const themeFieldKey = expression.match(THEME_PATH_REGEX);
-            if (!themeFieldKey || !variableName)
-                return _hublVariableMap;
-            _hublVariableMap[variableName[1]] = themeFieldKey[1];
-            return _hublVariableMap;
-        }, {})
-        : {};
-    /**
-     * Removes HubL variable expressions
-     */
-    cssString = cssString.replace(HUBL_EXPRESSION_REGEX, '');
-    /**
-     * Regex for HubL variable names
-     */
-    const HUBL_EXPRESSIONS = new RegExp(`.*(${Object.keys(hublVariableMap).join('|')}).*`, 'g');
-    /**
-     * Matches all HubL statements in the CSS and replaces them with a placeholder string
-     * This is to prevent the the css expression regex from capturing all the HubL as well
-     */
-    const hublStatements = cssString.match(HUBL_STATEMENT_REGEX) || [];
-    const hublStatementsMap = {};
-    hublStatements.forEach((statement, index) => {
-        const statementKey = `hubl_statement_${index}`;
-        hublStatementsMap[statementKey] = statement;
-        cssString = cssString.replace(statement, statementKey);
-    });
-    /**
-     * Matchs all css variables and determines if there are hubl within those vars.
-     */
-    const cssVars = cssString.match(CSS_VARS_REGEX) || [];
-    const cssVarsMap = cssVars.reduce((acc, expression) => {
-        const cssVarName = expression.match(CSS_VARS_NAME_REGEX);
-        const hublVariables = expression.match(HUBL_STATEMENT_PLACEHOLDER_REGEX);
-        if (!cssVarName || !hublVariables)
-            return acc;
-        cssString = cssString.replace(expression, '');
-        return { ...acc, [cssVarName[0]]: hublVariables };
-    }, {});
-    // replace all css variable references with corresponding hubl placeholder
-    Object.keys(cssVarsMap).forEach(cssVarName => {
-        const hublPlaceholders = cssVarsMap[cssVarName];
-        cssString = cssString.replace(cssVarName, hublPlaceholders.join('  '));
-    });
-    /**
-     * Parses each css string for a HubL statement and tries to map theme field paths to CSS selectors
-     */
-    const cssExpressions = (cssString.match(CSS_EXPRESSION_REGEX) || []).map(exp => exp.replace(/\r?\n/g, ' '));
-    const finalMap = cssExpressions.reduce((themeFieldsSelectorMap, cssExpression) => {
-        const hublStatementsPlaceholderKey = cssExpression.match(HUBL_STATEMENT_PLACEHOLDER_REGEX) || [];
-        hublStatementsPlaceholderKey.forEach(placeholderKey => {
-            let hublStatement;
-            let themeFieldPath;
-            if (placeholderKey in hublStatementsMap) {
-                hublStatement =
-                    hublStatementsMap[placeholderKey].match(HUBL_EXPRESSIONS);
-                themeFieldPath =
-                    hublStatementsMap[placeholderKey].match(/theme\.[\w|.]*/);
-            }
-            const cssSelectors = cssExpression.match(CSS_SELECTORS_REGEX);
-            /**
-             * Try to match a HubL statement to any HubL Variables being used
-             */
-            if (cssSelectors && themeFieldPath) {
-                const cssSelector = cssSelectors[1].replace(/\n/g, ' ');
-                const hublThemePath = themeFieldPath?.[0] ?? '';
-                if (!themeFieldsSelectorMap[hublThemePath]) {
-                    themeFieldsSelectorMap[hublThemePath] = [];
-                }
-                if (!themeFieldsSelectorMap[hublThemePath].includes(cssSelector)) {
-                    themeFieldsSelectorMap[hublThemePath] =
-                        themeFieldsSelectorMap[hublThemePath].concat(cssSelector);
-                }
-            }
-            if (cssSelectors && hublStatement) {
-                const cssSelector = cssSelectors?.[1]?.replace(/\n/g, ' ') ?? '';
-                const hublVariableName = Object.keys(hublVariableMap).find(_hubl => {
-                    return hublStatement && hublStatement[0].includes(_hubl);
-                }) || '';
-                const themeFieldKey = hublVariableName
-                    ? hublVariableMap[hublVariableName]
-                    : undefined;
-                /**
-                 * If the theme path is referenced directly add selectors
-                 */
-                if (themeFieldKey) {
-                    if (!themeFieldsSelectorMap[themeFieldKey]) {
-                        themeFieldsSelectorMap[themeFieldKey] = [];
-                    }
-                    if (!themeFieldsSelectorMap[themeFieldKey].includes(cssSelector)) {
-                        themeFieldsSelectorMap[themeFieldKey] =
-                            themeFieldsSelectorMap[themeFieldKey].concat(cssSelector);
-                    }
-                }
-            }
-        });
-        return themeFieldsSelectorMap;
-    }, {});
-    if (!Object.keys(finalMap).length) {
-        uiLogger.error(commands.theme.subcommands.generateSelectors.errors.noSelectorsFound);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    Object.keys(finalMap).forEach(themeFieldKey => {
-        const fieldKey = themeFieldKey.split('.');
-        const selectors = finalMap[themeFieldKey];
-        fieldsJson = setPreviewSelectors(fieldsJson, fieldKey.splice(1), selectors);
-    });
-    // Because fields can have nested inheritance we generated inherited selectors
-    // multiple times to make sure all inherted selectors are bubbled up.
-    const maxFieldsDepth = getMaxFieldsDepth();
-    for (let i = 0; i < maxFieldsDepth; i += 1) {
-        fieldsJson = generateInheritedSelectors(fieldsJson);
-    }
-    const selectorsMap = generateSelectorsMap(fieldsJson);
-    const selectorsPath = `${path}/editor-preview.json`;
-    fs.writeFileSync(selectorsPath, `${JSON.stringify({ selectors: selectorsMap }, null, 2)}\n`);
-    uiLogger.success(commands.theme.subcommands.generateSelectors.success(path, selectorsPath));
+    uiCommandRelocatedMessage('hs cms theme generate-selectors');
+    await generateSelectorsCommand.handler(args);
 }
-function themeSelectorBuilder(yargs) {
+function deprecatedThemeSelectorBuilder(yargs) {
     yargs.positional('path', {
-        describe: commands.theme.subcommands.generateSelectors.positionals.path,
+        describe: commands.cms.subcommands.theme.subcommands.generateSelectors.positionals
+            .path,
         type: 'string',
         required: true,
     });
     return yargs;
 }
-const builder = makeYargsBuilder(themeSelectorBuilder, command, describe, {
+const verboseDescribe = uiCommandRenamedDescription(generateSelectorsCommand.describe, 'hs cms theme generate-selectors');
+const builder = makeYargsBuilder(deprecatedThemeSelectorBuilder, command, verboseDescribe, {
     useGlobalOptions: true,
 });
-const themeSelectorsCommand = {
-    command,
+const deprecatedGenerateSelectorsCommand = {
+    ...generateSelectorsCommand,
     describe,
     handler,
     builder,
 };
-export default themeSelectorsCommand;
+export default deprecatedGenerateSelectorsCommand;

package/commands/theme/marketplace-validate.d.ts

@@ -1,6 +1,4 @@
-import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ThemeValidateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
-    path: string;
-};
-declare const themeValidateCommand: YargsCommandModule<unknown, ThemeValidateArgs>;
-export default themeValidateCommand;
+import { YargsCommandModule } from '../../types/Yargs.js';
+import { ThemeValidateArgs } from '../cms/theme/marketplace-validate.js';
+declare const deprecatedMarketplaceValidateCommand: YargsCommandModule<unknown, ThemeValidateArgs>;
+export default deprecatedMarketplaceValidateCommand;

package/commands/theme/marketplace-validate.js

@@ -1,44 +1,33 @@
-import SpinniesManager from '../../lib/ui/SpinniesManager.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
-import { kickOffValidation, pollForValidationFinish, fetchValidationResults, processValidationErrors, displayValidationResults, } from '../../lib/marketplaceValidate.js';
-import { commands } from '../../lang/en.js';
+import { uiCommandRelocatedMessage, uiCommandRenamedDescription, uiDeprecatedTag, } from '../../lib/ui/index.js';
+import marketplaceValidateCommand from '../cms/theme/marketplace-validate.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { commands } from '../../lang/en.js';
 const command = 'marketplace-validate <path>';
-const describe = commands.theme.subcommands.marketplaceValidate.describe;
+const describe = uiDeprecatedTag(marketplaceValidateCommand.describe, false);
 async function handler(args) {
-    const { path, derivedAccountId } = args;
-    trackCommandUsage('validate', {}, derivedAccountId);
-    SpinniesManager.init();
-    SpinniesManager.add('marketplaceValidation', {
-        text: commands.theme.subcommands.marketplaceValidate.logs.validatingTheme(path),
-    });
-    const assetType = 'THEME';
-    const validationId = await kickOffValidation(derivedAccountId, assetType, path);
-    await pollForValidationFinish(derivedAccountId, validationId);
-    SpinniesManager.remove('marketplaceValidation');
-    const validationResults = await fetchValidationResults(derivedAccountId, validationId);
-    processValidationErrors(commands.theme.subcommands.marketplaceValidate.errors.invalidPath, validationResults);
-    displayValidationResults(commands.theme.subcommands.marketplaceValidate.results, validationResults);
-    process.exit();
+    uiCommandRelocatedMessage('hs cms theme marketplace-validate');
+    await marketplaceValidateCommand.handler(args);
 }
-function themeValidateBuilder(yargs) {
+function deprecatedThemeValidateBuilder(yargs) {
     yargs.positional('path', {
-        describe: commands.theme.subcommands.marketplaceValidate.positionals.path.describe,
+        describe: commands.cms.subcommands.theme.subcommands.marketplaceValidate.positionals
+            .path.describe,
         type: 'string',
         required: true,
     });
     return yargs;
 }
-const builder = makeYargsBuilder(themeValidateBuilder, command, describe, {
+const verboseDescribe = uiCommandRenamedDescription(marketplaceValidateCommand.describe, 'hs cms theme marketplace-validate');
+const builder = makeYargsBuilder(deprecatedThemeValidateBuilder, command, verboseDescribe, {
     useGlobalOptions: true,
     useConfigOptions: true,
     useAccountOptions: true,
     useEnvironmentOptions: true,
 });
-const themeValidateCommand = {
-    command,
+const deprecatedMarketplaceValidateCommand = {
+    ...marketplaceValidateCommand,
     describe,
     handler,
     builder,
 };
-export default themeValidateCommand;
+export default deprecatedMarketplaceValidateCommand;

package/commands/theme/preview.d.ts

@@ -1,12 +1,4 @@
-import { CommonArgs, ConfigArgs, AccountArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ThemePreviewArgs = CommonArgs & ConfigArgs & AccountArgs & {
-    src: string;
-    dest: string;
-    notify: string;
-    'no-ssl'?: boolean;
-    port?: number;
-    resetSession?: boolean;
-    generateFieldsTypes?: boolean;
-};
-declare const themePreviewCommand: YargsCommandModule<unknown, ThemePreviewArgs>;
-export default themePreviewCommand;
+import { YargsCommandModule } from '../../types/Yargs.js';
+import { ThemePreviewArgs } from '../cms/theme/preview.js';
+declare const deprecatedPreviewCommand: YargsCommandModule<unknown, ThemePreviewArgs>;
+export default deprecatedPreviewCommand;