@hubspot/cli 7.7.19-experimental.0 → 7.7.19-experimental.1

package/lib/prompts/createDeveloperTestAccountConfigPrompt.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDeveloperTestAccountConfigPrompt = createDeveloperTestAccountConfigPrompt;
+const prompts_1 = require("@inquirer/prompts");
 const en_1 = require("../../lang/en");
 const promptUtils_1 = require("./promptUtils");
 const hubs = {
@@ -10,32 +11,43 @@ const hubs = {
     SALES: 'salesLevel',
     CONTENT: 'contentLevel',
 };
+const AccountTiers = {
+    FREE: 'FREE',
+    STARTER: 'STARTER',
+    PROFESSIONAL: 'PROFESSIONAL',
+    ENTERPRISE: 'ENTERPRISE',
+};
+const makeHubTiers = (hubKey) => {
+    const langKey = hubKey.toLowerCase();
+    const langObj = en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.tiers[langKey];
+    return [
+        {
+            name: langObj.free,
+            value: `${hubKey.toUpperCase()}:${AccountTiers.FREE}`,
+        },
+        {
+            name: langObj.starter,
+            value: `${hubKey.toUpperCase()}:${AccountTiers.STARTER}`,
+        },
+        {
+            name: langObj.professional,
+            value: `${hubKey.toUpperCase()}:${AccountTiers.PROFESSIONAL}`,
+        },
+    ];
+};
 const TEST_ACCOUNT_TIERS = [
-    { name: 'Marketing STARTER', value: 'MARKETING:STARTER' },
-    {
-        name: 'Marketing PROFESSIONAL',
-        value: 'MARKETING:PROFESSIONAL',
-    },
-    { name: 'Marketing ENTERPRISE', value: 'MARKETING:ENTERPRISE' },
-    promptUtils_1.Separator,
-    { name: 'Ops STARTER', value: 'OPS:STARTER' },
-    { name: 'Ops PROFESSIONAL', value: 'OPS:PROFESSIONAL' },
-    { name: 'Ops ENTERPRISE', value: 'OPS:ENTERPRISE' },
-    promptUtils_1.Separator,
-    { name: 'Service STARTER', value: 'SERVICE:STARTER' },
-    { name: 'Service PROFESSIONAL', value: 'SERVICE:PROFESSIONAL' },
-    { name: 'Service ENTERPRISE', value: 'SERVICE:ENTERPRISE' },
-    promptUtils_1.Separator,
-    { name: 'Sales STARTER', value: 'SALES:STARTER' },
-    { name: 'Sales PROFESSIONAL', value: 'SALES:PROFESSIONAL' },
-    { name: 'Sales ENTERPRISE', value: 'SALES:ENTERPRISE' },
-    promptUtils_1.Separator,
-    { name: 'Content STARTER', value: 'CONTENT:STARTER' },
-    { name: 'Content PROFESSIONAL', value: 'CONTENT:PROFESSIONAL' },
-    { name: 'Content ENTERPRISE', value: 'CONTENT:ENTERPRISE' },
-    promptUtils_1.Separator,
+    ...makeHubTiers('MARKETING'),
+    new prompts_1.Separator(),
+    ...makeHubTiers('OPS'),
+    new prompts_1.Separator(),
+    ...makeHubTiers('SERVICE'),
+    new prompts_1.Separator(),
+    ...makeHubTiers('SALES'),
+    new prompts_1.Separator(),
+    ...makeHubTiers('CONTENT'),
+    new prompts_1.Separator(),
 ];
-async function createDeveloperTestAccountConfigPrompt(args = {}) {
+async function createDeveloperTestAccountConfigPrompt(args = {}, supportFlags = true) {
     const { name, description, tiers } = args;
     let accountName = name;
     let accountDescription = description;
@@ -43,7 +55,7 @@ async function createDeveloperTestAccountConfigPrompt(args = {}) {
     if (!accountName) {
         const namePromptResult = await (0, promptUtils_1.promptUser)({
             name: 'accountName',
-            message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.namePrompt,
+            message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.namePrompt(supportFlags),
             type: 'input',
         });
         accountName = namePromptResult.accountName;
@@ -51,43 +63,70 @@ async function createDeveloperTestAccountConfigPrompt(args = {}) {
     if (!accountDescription) {
         const descriptionPromptResult = await (0, promptUtils_1.promptUser)({
             name: 'description',
-            message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.descriptionPrompt,
+            message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.descriptionPrompt(supportFlags),
             type: 'input',
         });
         accountDescription = descriptionPromptResult.description;
     }
     if (!accountLevelsArray) {
-        const accountLevelsPromptResult = await (0, promptUtils_1.promptUser)({
-            name: 'testAccountLevels',
-            message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.tiersPrompt,
-            type: 'checkbox',
-            choices: TEST_ACCOUNT_TIERS,
-            validate: choices => {
-                if (choices?.length > 1) {
-                    const hubMap = {};
-                    for (const choice of choices) {
-                        const hub = choice.split(':')[0];
-                        if (hubMap[hub]) {
-                            return en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.errors
-                                .tiersError;
+        const useDefaultAccountLevelsPromptResult = await (0, promptUtils_1.promptUser)({
+            name: 'useDefaultAccountLevels',
+            message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt
+                .useDefaultAccountLevelsPrompt.message,
+            type: 'list',
+            choices: [
+                {
+                    name: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt
+                        .useDefaultAccountLevelsPrompt.default,
+                    value: 'default',
+                },
+                {
+                    name: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt
+                        .useDefaultAccountLevelsPrompt.manual,
+                    value: 'manual',
+                },
+            ],
+        });
+        if (useDefaultAccountLevelsPromptResult.useDefaultAccountLevels === 'manual') {
+            const accountLevelsPromptResult = await (0, promptUtils_1.promptUser)({
+                name: 'testAccountLevels',
+                message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.tiersPrompt(supportFlags),
+                pageSize: 10,
+                type: 'checkbox',
+                choices: TEST_ACCOUNT_TIERS,
+                validate: choices => {
+                    if (choices?.length > 1) {
+                        const hubMap = {};
+                        for (const choice of choices) {
+                            const hub = choice.value.split(':')[0];
+                            if (hubMap[hub]) {
+                                return en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.errors
+                                    .tiersError;
+                            }
+                            hubMap[hub] = true;
                         }
-                        hubMap[hub] = true;
                     }
-                }
-                return true;
-            },
-        });
-        accountLevelsArray = accountLevelsPromptResult.testAccountLevels;
+                    return true;
+                },
+            });
+            accountLevelsArray = accountLevelsPromptResult.testAccountLevels;
+        }
     }
     if (!accountLevelsArray) {
         accountLevelsArray = [];
     }
     const accountLevels = accountLevelsArray.reduce((acc, level) => {
-        const [hubName, hubTier] = level.split(':');
-        const hubLevel = hubs[hubName];
+        const [hubKey, hubTier] = level.split(':');
+        const hubLevel = hubs[hubKey];
         acc[hubLevel] = hubTier;
         return acc;
     }, {});
+    Object.values(hubs).forEach(hubLevel => {
+        if (!accountLevels[hubLevel]) {
+            accountLevels[hubLevel] = AccountTiers.ENTERPRISE;
+        }
+    });
+    console.log('accountLevels', accountLevels);
     return {
         accountName: accountName,
         description: accountDescription,

package/lib/prompts/createModulePrompt.js

@@ -26,9 +26,8 @@ const CONTENT_TYPES_PROMPT = {
     type: 'checkbox',
     name: 'contentTypes',
     message: (0, lang_1.i18n)(`lib.prompts.createModulePrompt.selectContentType`),
-    default: ['ANY'],
     choices: [
-        { name: 'Any', value: 'ANY' },
+        { name: 'Any', value: 'ANY', checked: true },
         { name: 'Landing page', value: 'LANDING_PAGE' },
         { name: 'Site page', value: 'SITE_PAGE' },
         { name: 'Blog post', value: 'BLOG_POST' },

package/lib/prompts/projectAddPrompt.d.ts

@@ -1,3 +1,4 @@
+import { Separator } from '@inquirer/prompts';
 import { ComponentTemplate, ComponentTemplateChoice } from '../../types/Projects';
 type ProjectAddPromptResponse = {
     componentTemplate: ComponentTemplate;
@@ -10,5 +11,5 @@ export declare function projectAddPrompt(components: ComponentTemplate[], prompt
     name?: string;
     type?: string;
 }): Promise<ProjectAddPromptResponse>;
-export declare function projectAddPromptV3(components: ComponentTemplateChoice[], selectedFeatures: string[] | undefined): Promise<ProjectAddPromptResponseV3>;
+export declare function projectAddPromptV3(components: (ComponentTemplateChoice | Separator)[], selectedFeatures: string[] | undefined): Promise<ProjectAddPromptResponseV3>;
 export {};

package/lib/prompts/projectAddPrompt.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectAddPrompt = projectAddPrompt;
 exports.projectAddPromptV3 = projectAddPromptV3;
+const prompts_1 = require("@inquirer/prompts");
 const promptUtils_1 = require("./promptUtils");
 const en_1 = require("../../lang/en");
 function findComponentByPathOrLabel(components, componentPathOrLabel) {
@@ -51,7 +52,7 @@ async function projectAddPromptV3(components, selectedFeatures) {
     const selectedComponents = [];
     if (selectedFeatures) {
         components.forEach(template => {
-            if (!template.value) {
+            if (template instanceof prompts_1.Separator || !template.value) {
                 return;
             }
             if (selectedFeatures?.includes(template.value.type)) {

package/lib/prompts/promptUtils.d.ts

@@ -1,9 +1,9 @@
+import { Separator as _Separator } from '@inquirer/prompts';
 import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts';
-export declare const Separator: any;
+export declare const Separator: _Separator;
 export declare function promptUser<T extends GenericPromptResponse>(config: PromptConfig<T> | PromptConfig<T>[]): Promise<T>;
 export declare function confirmPrompt(message: string, options?: {
     defaultAnswer?: boolean;
-    when?: PromptWhen;
 }): Promise<boolean>;
 export declare function listPrompt<T = string>(message: string, { choices, when, defaultAnswer, validate, }: {
     choices: PromptChoices<T>;

package/lib/prompts/promptUtils.js

@@ -5,49 +5,175 @@ exports.promptUser = promptUser;
 exports.confirmPrompt = confirmPrompt;
 exports.listPrompt = listPrompt;
 exports.inputPrompt = inputPrompt;
-const inquirer = require('inquirer');
-const promptModule = inquirer.createPromptModule();
-exports.Separator = new inquirer.Separator();
+const prompts_1 = require("@inquirer/prompts");
+exports.Separator = new prompts_1.Separator();
+function mapPromptChoicesToChoices(choices) {
+    return (choices?.map(choice => {
+        if (typeof choice === 'string') {
+            return { value: choice, name: choice };
+        }
+        else if (choice instanceof prompts_1.Separator) {
+            return choice;
+        }
+        return {
+            value: choice.value,
+            name: choice.name,
+            disabled: choice.disabled,
+            checked: choice.checked,
+        };
+    }) || []);
+}
+function handleArrayConfig(config) {
+    return (async () => {
+        const result = {};
+        for (const prompt of config) {
+            if (prompt.when !== undefined) {
+                const shouldPrompt = typeof prompt.when === 'function'
+                    ? prompt.when()
+                    : (prompt.when ?? true);
+                if (!shouldPrompt) {
+                    continue;
+                }
+            }
+            if (typeof prompt.message === 'function') {
+                prompt.message = prompt.message(result);
+            }
+            // Pass the accumulated results to each prompt
+            const promptWithAnswers = {
+                ...prompt,
+                default: typeof prompt.default === 'function'
+                    ? (answers) => {
+                        const mergedAnswers = { ...answers, ...result };
+                        return prompt.default(mergedAnswers);
+                    }
+                    : prompt.default,
+            };
+            const response = await promptUser(promptWithAnswers);
+            Object.assign(result, response);
+        }
+        return result;
+    })();
+}
 function promptUser(config) {
-    return promptModule(config);
+    if (Array.isArray(config)) {
+        return handleArrayConfig(config);
+    }
+    else {
+        if (config.when !== undefined) {
+            const shouldPrompt = typeof config.when === 'function'
+                ? config.when()
+                : (config.when ?? true);
+            if (!shouldPrompt) {
+                return Promise.resolve({});
+            }
+        }
+    }
+    switch (config.type) {
+        case 'list':
+            return handleSelectPrompt(config);
+        case 'input':
+            return handleInputPrompt(config);
+        case 'confirm':
+            return handleConfirmPrompt(config);
+        case 'checkbox':
+            return handleCheckboxPrompt(config);
+        case 'password':
+            return handlePasswordPrompt(config);
+        case 'number':
+            return handleNumberPrompt(config);
+        case 'rawlist':
+            return handleRawListPrompt(config);
+        default:
+            return handleInputPrompt(config);
+    }
+}
+function handleRawListPrompt(config) {
+    const choices = mapPromptChoicesToChoices(config.choices);
+    choices.map((choice, index) => {
+        if (!(choice instanceof prompts_1.Separator)) {
+            choice.name = `${index + 1}) ${choice.name}`;
+        }
+    });
+    return (0, prompts_1.select)({
+        message: config.message,
+        choices: choices,
+        pageSize: config.pageSize,
+        default: config.default,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleNumberPrompt(config) {
+    return (0, prompts_1.number)({
+        message: config.message,
+        default: config.default,
+        validate: config.validate,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handlePasswordPrompt(config) {
+    return (0, prompts_1.password)({
+        message: config.message,
+        mask: '*',
+        validate: config.validate,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleCheckboxPrompt(config) {
+    const choices = mapPromptChoicesToChoices(config.choices);
+    return (0, prompts_1.checkbox)({
+        message: config.message,
+        choices: choices,
+        pageSize: config.pageSize,
+        validate: config.validate,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleConfirmPrompt(config) {
+    return confirmPrompt(config.message, {
+        defaultAnswer: config.default,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleInputPrompt(config) {
+    return (0, prompts_1.input)({
+        message: config.message,
+        default: config.default,
+        validate: config.validate,
+        transformer: config.transformer,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleSelectPrompt(config) {
+    const choices = mapPromptChoicesToChoices(config.choices);
+    return (0, prompts_1.select)({
+        message: config.message,
+        choices: choices,
+        default: config.default,
+        pageSize: config.pageSize,
+    }).then(resp => ({ [config.name]: resp }));
 }
 async function confirmPrompt(message, options = {}) {
-    const { defaultAnswer = true, when } = options;
-    const { choice } = await promptUser([
-        {
-            name: 'choice',
-            type: 'confirm',
-            message,
-            default: defaultAnswer,
-            when,
-        },
-    ]);
+    const { defaultAnswer = true } = options;
+    const choice = await (0, prompts_1.confirm)({
+        message,
+        default: defaultAnswer,
+    });
     return choice;
 }
 async function listPrompt(message, { choices, when, defaultAnswer, validate, }) {
-    const { choice } = await promptUser([
-        {
-            name: 'choice',
-            type: 'list',
-            message,
-            choices,
-            when,
-            default: defaultAnswer,
-            validate,
-        },
-    ]);
+    const { choice } = await promptUser({
+        name: 'choice',
+        type: 'list',
+        message,
+        choices,
+        when,
+        default: defaultAnswer,
+        validate,
+    });
     return choice;
 }
 async function inputPrompt(message, { when, validate, defaultAnswer, } = {}) {
-    const { input } = await promptUser([
-        {
-            name: 'input',
-            type: 'input',
-            default: defaultAnswer,
-            message,
-            when,
-            validate,
-        },
-    ]);
+    const { input } = await promptUser({
+        name: 'input',
+        type: 'input',
+        default: defaultAnswer,
+        message,
+        when,
+        validate,
+    });
     return input;
 }

package/lib/prompts/selectProjectTemplatePrompt.d.ts

@@ -1,3 +1,4 @@
+import { Separator } from '@inquirer/prompts';
 import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplate } from '../../types/Projects';
 export type SelectProjectTemplatePromptResponse = {
     projectTemplate?: ProjectTemplate;
@@ -22,5 +23,5 @@ export type PromptOptionsArg = {
     features?: string[];
 };
 export declare function selectProjectTemplatePrompt(promptOptions: PromptOptionsArg, projectTemplates?: ProjectTemplate[], componentTemplates?: undefined): Promise<SelectProjectTemplatePromptResponseProjectTemplate>;
-export declare function selectProjectTemplatePrompt(promptOptions: PromptOptionsArg, projectTemplates?: undefined, componentTemplates?: ComponentTemplateChoice[]): Promise<SelectProjectTemplatePromptResponseComponentTemplates>;
+export declare function selectProjectTemplatePrompt(promptOptions: PromptOptionsArg, projectTemplates?: undefined, componentTemplates?: (ComponentTemplateChoice | Separator)[]): Promise<SelectProjectTemplatePromptResponseComponentTemplates>;
 export {};

package/lib/prompts/selectProjectTemplatePrompt.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.selectProjectTemplatePrompt = selectProjectTemplatePrompt;
+const prompts_1 = require("@inquirer/prompts");
 const promptUtils_1 = require("./promptUtils");
 const en_1 = require("../../lang/en");
 function findTemplateByNameOrLabel(projectTemplates, templateNameOrLabel) {
@@ -12,7 +13,7 @@ async function selectProjectTemplatePrompt(promptOptions, projectTemplates, comp
     const selectedComponents = [];
     if (createProjectFromComponents && promptOptions.features) {
         componentTemplates.forEach(template => {
-            if (!template.value) {
+            if (template instanceof prompts_1.Separator || !template.value) {
                 return;
             }
             if (promptOptions.features?.includes(template.value.type)) {

package/lib/usageTracking.d.ts

@@ -13,9 +13,9 @@ type Meta = {
     file?: boolean;
     successful?: boolean;
 };
-export declare function trackCommandUsage(command: string, meta?: Meta, accountId?: number): void;
-export declare function trackHelpUsage(command: string): void;
-export declare function trackConvertFieldsUsage(command: string): void;
-export declare function trackAuthAction(command: string, authType: string, step: string, accountId?: number): void;
-export declare function trackCommandMetadataUsage(command: string, meta?: Meta, accountId?: number): void;
+export declare function trackCommandUsage(command: string, meta?: Meta, accountId?: number): Promise<void>;
+export declare function trackHelpUsage(command: string): Promise<void>;
+export declare function trackConvertFieldsUsage(command: string): Promise<void>;
+export declare function trackAuthAction(command: string, authType: string, step: string, accountId?: number): Promise<void>;
+export declare function trackCommandMetadataUsage(command: string, meta?: Meta, accountId?: number): Promise<void>;
 export {};