@hubspot/cli 7.7.0-experimental.2 → 7.7.0

package/lib/prompts/projectNameAndDestPrompt.d.ts

@@ -0,0 +1,3 @@
+import { PromptOptionsArg, ProjectNameAndDestPromptResponse } from './selectProjectTemplatePrompt.js';
+export declare function projectNameAndDestPrompt(promptOptions: PromptOptionsArg): Promise<ProjectNameAndDestPromptResponse>;
+export declare function validateProjectDirectory(input?: string): string | boolean;

package/lib/prompts/projectNameAndDestPrompt.js

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+import { sanitizeFileName, getCwd, untildify, isValidPath, } from '@hubspot/local-dev-lib/path';
+import { lib } from '../../lang/en.js';
+import { promptUser } from './promptUtils.js';
+import { PROJECT_CONFIG_FILE } from '../constants.js';
+export async function projectNameAndDestPrompt(promptOptions) {
+    const result = await promptUser([
+        {
+            name: 'name',
+            message: lib.prompts.projectNameAndDestPrompt.enterName,
+            when: !promptOptions.name,
+            validate: (input) => {
+                if (!input) {
+                    return lib.prompts.projectNameAndDestPrompt.errors.nameRequired;
+                }
+                return true;
+            },
+        },
+        {
+            name: 'dest',
+            message: lib.prompts.projectNameAndDestPrompt.enterDest,
+            when: !promptOptions.dest,
+            default: (answers) => {
+                const projectName = sanitizeFileName(promptOptions.name || answers.name);
+                return path.resolve(getCwd(), projectName);
+            },
+            validate: validateProjectDirectory,
+            filter: (input) => {
+                return untildify(input);
+            },
+        },
+    ]);
+    if (!result.name) {
+        result.name = promptOptions.name;
+    }
+    if (!result.dest) {
+        result.dest = promptOptions.dest;
+    }
+    return result;
+}
+export function validateProjectDirectory(input) {
+    if (!input) {
+        return lib.prompts.projectNameAndDestPrompt.errors.destRequired;
+    }
+    if (fs.existsSync(path.resolve(getCwd(), path.join(input, PROJECT_CONFIG_FILE)))) {
+        return lib.prompts.projectNameAndDestPrompt.errors.invalidDest;
+    }
+    if (!isValidPath(input)) {
+        return lib.prompts.projectNameAndDestPrompt.errors.invalidCharacters;
+    }
+    return true;
+}

package/lib/prompts/projectNamePrompt.js

@@ -1,27 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectNamePrompt = projectNamePrompt;
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-const ensureProjectExists_1 = require("../projects/ensureProjectExists");
-const ui_1 = require("../ui");
-async function projectNamePrompt(accountId, options = {}) {
-    const result = await (0, promptUtils_1.promptUser)({
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+import { ensureProjectExists } from '../projects/ensureProjectExists.js';
+import { uiAccountDescription } from '../ui/index.js';
+export async function projectNamePrompt(accountId, options = {}) {
+    const result = await promptUser({
         name: 'projectName',
-        message: (0, lang_1.i18n)(`lib.prompts.projectNamePrompt.enterName`),
+        message: i18n(`lib.prompts.projectNamePrompt.enterName`),
         when: !options.project,
         validate: async (val) => {
             if (typeof val !== 'string' || !val) {
-                return (0, lang_1.i18n)(`lib.prompts.projectNamePrompt.errors.invalidName`);
+                return i18n(`lib.prompts.projectNamePrompt.errors.invalidName`);
             }
-            const { projectExists } = await (0, ensureProjectExists_1.ensureProjectExists)(accountId, val, {
+            const { projectExists } = await ensureProjectExists(accountId, val, {
                 allowCreate: false,
                 noLogs: true,
             });
             if (!projectExists) {
-                return (0, lang_1.i18n)(`lib.prompts.projectNamePrompt.errors.projectDoesNotExist`, {
+                return i18n(`lib.prompts.projectNamePrompt.errors.projectDoesNotExist`, {
                     projectName: val,
-                    accountIdentifier: (0, ui_1.uiAccountDescription)(accountId),
+                    accountIdentifier: uiAccountDescription(accountId),
                 });
             }
             return true;

package/lib/prompts/projectsLogsPrompt.js

@@ -1,20 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectLogsPrompt = projectLogsPrompt;
-const lang_1 = require("../lang");
-const promptUtils_1 = require("./promptUtils");
-async function projectLogsPrompt({ functionChoices, promptOptions, projectName = '', }) {
+import { i18n } from '../lang.js';
+import { promptUser } from './promptUtils.js';
+export async function projectLogsPrompt({ functionChoices, promptOptions, projectName = '', }) {
     if (!functionChoices) {
         return {};
     }
     if (functionChoices.length === 1) {
         return { functionName: functionChoices[0] };
     }
-    return (0, promptUtils_1.promptUser)([
+    return promptUser([
         {
             name: 'functionName',
             type: 'list',
-            message: (0, lang_1.i18n)(`lib.prompts.projectLogsPrompt.functionName`, {
+            message: i18n(`lib.prompts.projectLogsPrompt.functionName`, {
                 projectName,
             }),
             when: () => (!promptOptions || !promptOptions.function) &&

package/lib/prompts/promptUtils.d.ts

@@ -1,13 +1,21 @@
-import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts';
+import { Separator as _Separator } from '@inquirer/prompts';
+import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts.js';
+export declare const Separator: _Separator;
+export declare const PROMPT_THEME: {
+    prefix: {
+        idle: string;
+    };
+};
 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, }: {
+export declare function listPrompt<T = string>(message: string, { choices, when, defaultAnswer, validate, loop, }: {
     choices: PromptChoices<T>;
     when?: PromptWhen;
     defaultAnswer?: string | number | boolean;
+    validate?: (input: T[]) => (boolean | string) | Promise<boolean | string>;
+    loop?: boolean;
 }): Promise<T>;
 export declare function inputPrompt(message: string, { when, validate, defaultAnswer, }?: {
     when?: boolean | (() => boolean);

package/lib/prompts/promptUtils.js

@@ -1,50 +1,201 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptUser = promptUser;
-exports.confirmPrompt = confirmPrompt;
-exports.listPrompt = listPrompt;
-exports.inputPrompt = inputPrompt;
-const inquirer = require('inquirer');
-const promptModule = inquirer.createPromptModule();
-function promptUser(config) {
-    return promptModule(config);
-}
-async function confirmPrompt(message, options = {}) {
-    const { defaultAnswer = true, when } = options;
-    const { choice } = await promptUser([
-        {
-            name: 'choice',
-            type: 'confirm',
-            message,
-            default: defaultAnswer,
-            when,
-        },
-    ]);
-    return choice;
+import { confirm, Separator as _Separator, select, input, checkbox, password, number, } from '@inquirer/prompts';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import chalk from 'chalk';
+export const Separator = new _Separator();
+export const PROMPT_THEME = { prefix: { idle: chalk.green('?') } };
+function isUserCancellationError(error) {
+    return error instanceof Error && error.name === 'ExitPromptError';
+}
+function mapPromptChoicesToChoices(choices) {
+    return (choices?.map(choice => {
+        if (typeof choice === 'string') {
+            return { value: choice, name: choice };
+        }
+        else if (choice instanceof _Separator) {
+            return choice;
+        }
+        return {
+            value: choice.value,
+            name: choice.name,
+            disabled: choice.disabled,
+            checked: choice.checked,
+        };
+    }) || []);
+}
+async function handleArrayConfig(config) {
+    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;
+}
+export async function promptUser(config) {
+    try {
+        if (Array.isArray(config)) {
+            return await 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 await handleSelectPrompt(config);
+            case 'input':
+                return await handleInputPrompt(config);
+            case 'confirm':
+                return await handleConfirmPrompt(config);
+            case 'checkbox':
+                return await handleCheckboxPrompt(config);
+            case 'password':
+                return await handlePasswordPrompt(config);
+            case 'number':
+                return await handleNumberPrompt(config);
+            case 'rawlist':
+                return await handleRawListPrompt(config);
+            default:
+                return await handleInputPrompt(config);
+        }
+    }
+    catch (error) {
+        if (isUserCancellationError(error)) {
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        throw error;
+    }
+}
+function handleRawListPrompt(config) {
+    const choices = mapPromptChoicesToChoices(config.choices);
+    choices.map((choice, index) => {
+        if (!(choice instanceof _Separator)) {
+            choice.name = `${index + 1}) ${choice.name}`;
+        }
+    });
+    return select({
+        message: config.message,
+        choices: choices,
+        pageSize: config.pageSize,
+        default: config.default,
+        loop: config.loop,
+        theme: PROMPT_THEME,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleNumberPrompt(config) {
+    return number({
+        message: config.message,
+        default: config.default,
+        validate: config.validate,
+        theme: PROMPT_THEME,
+    }).then(resp => ({ [config.name]: resp }));
 }
-async function listPrompt(message, { choices, when, defaultAnswer, }) {
-    const { choice } = await promptUser([
-        {
-            name: 'choice',
-            type: 'list',
-            message,
-            choices,
-            when,
-            default: defaultAnswer,
+function handlePasswordPrompt(config) {
+    return password({
+        message: config.message,
+        mask: '*',
+        validate: config.validate,
+        theme: PROMPT_THEME,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleCheckboxPrompt(config) {
+    const choices = mapPromptChoicesToChoices(config.choices);
+    return checkbox({
+        message: config.message,
+        choices: choices,
+        pageSize: config.pageSize,
+        validate: config.validate,
+        loop: config.loop,
+        theme: PROMPT_THEME,
+        shortcuts: {
+            invert: null,
         },
-    ]);
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleConfirmPrompt(config) {
+    return confirm({
+        message: config.message,
+        default: config.default,
+        theme: PROMPT_THEME,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleInputPrompt(config) {
+    return input({
+        message: config.message,
+        default: config.default,
+        validate: config.validate,
+        transformer: config.transformer,
+        theme: PROMPT_THEME,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleSelectPrompt(config) {
+    const choices = mapPromptChoicesToChoices(config.choices);
+    return select({
+        message: config.message,
+        choices: choices,
+        default: config.default,
+        pageSize: config.pageSize,
+        loop: config.loop,
+        theme: PROMPT_THEME,
+    }).then(resp => ({ [config.name]: resp }));
+}
+export async function confirmPrompt(message, options = {}) {
+    const { defaultAnswer = true } = options;
+    const { confirm: result } = await promptUser({
+        name: 'confirm',
+        type: 'confirm',
+        message,
+        default: defaultAnswer,
+    });
+    return result;
+}
+export async function listPrompt(message, { choices, when, defaultAnswer, validate, loop, }) {
+    const { choice } = await promptUser({
+        name: 'choice',
+        type: 'list',
+        message,
+        choices,
+        when,
+        default: defaultAnswer,
+        validate,
+        loop,
+    });
     return choice;
 }
-async function inputPrompt(message, { when, validate, defaultAnswer, } = {}) {
-    const { input } = await promptUser([
-        {
-            name: 'input',
-            type: 'input',
-            default: defaultAnswer,
-            message,
-            when,
-            validate,
-        },
-    ]);
+export async function inputPrompt(message, { when, validate, defaultAnswer, } = {}) {
+    const { input } = await promptUser({
+        name: 'input',
+        type: 'input',
+        default: defaultAnswer,
+        message,
+        when,
+        validate,
+    });
     return input;
 }

package/lib/prompts/sandboxesPrompt.d.ts

@@ -1,4 +1,4 @@
-import { SandboxAccountType } from '../../types/Sandboxes';
+import { SandboxAccountType } from '../../types/Sandboxes.js';
 type SandboxTypePromptResponse = {
     type: SandboxAccountType;
 };

package/lib/prompts/sandboxesPrompt.js

@@ -1,68 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sandboxTypePrompt = sandboxTypePrompt;
-exports.deleteSandboxPrompt = deleteSandboxPrompt;
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-const ui_1 = require("../ui");
-const config_1 = require("@hubspot/local-dev-lib/constants/config");
-const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
-const accountTypes_1 = require("../accountTypes");
-const config_2 = require("@hubspot/local-dev-lib/config");
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+import { uiAccountDescription } from '../ui/index.js';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { isSandbox } from '../accountTypes.js';
+import { getConfigDefaultAccount, getConfigAccounts, } from '@hubspot/local-dev-lib/config';
 function mapSandboxAccountChoices(portals) {
     return (portals
-        ?.filter(p => (0, accountTypes_1.isSandbox)(p))
+        ?.filter(p => isSandbox(p))
         .map(p => ({
-        name: (0, ui_1.uiAccountDescription)((0, getAccountIdentifier_1.getAccountIdentifier)(p), false),
-        value: p.name || (0, getAccountIdentifier_1.getAccountIdentifier)(p),
+        name: uiAccountDescription(getAccountIdentifier(p), false),
+        value: p.name || getAccountIdentifier(p),
     })) || []);
 }
 function mapNonSandboxAccountChoices(portals) {
     return (portals
-        ?.filter(p => !(0, accountTypes_1.isSandbox)(p))
+        ?.filter(p => !isSandbox(p))
         .map(p => ({
-        name: `${p.name} (${(0, getAccountIdentifier_1.getAccountIdentifier)(p)})`,
-        value: p.name || (0, getAccountIdentifier_1.getAccountIdentifier)(p),
+        name: `${p.name} (${getAccountIdentifier(p)})`,
+        value: p.name || getAccountIdentifier(p),
     })) || []);
 }
-async function sandboxTypePrompt() {
-    return (0, promptUtils_1.promptUser)([
+export async function sandboxTypePrompt() {
+    return promptUser([
         {
             name: 'type',
-            message: (0, lang_1.i18n)(`lib.prompts.sandboxesPrompt.type.message`),
+            message: i18n(`lib.prompts.sandboxesPrompt.type.message`),
             type: 'list',
             choices: [
                 {
-                    name: (0, lang_1.i18n)(`lib.prompts.sandboxesPrompt.type.developer`),
-                    value: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                    name: i18n(`lib.prompts.sandboxesPrompt.type.developer`),
+                    value: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
                 },
                 {
-                    name: (0, lang_1.i18n)(`lib.prompts.sandboxesPrompt.type.standard`),
-                    value: config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+                    name: i18n(`lib.prompts.sandboxesPrompt.type.standard`),
+                    value: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
                 },
             ],
-            default: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+            default: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
         },
     ]);
 }
-function deleteSandboxPrompt(promptParentAccount = false) {
-    const accountsList = (0, config_2.getConfigAccounts)();
+export function deleteSandboxPrompt(promptParentAccount = false) {
+    const accountsList = getConfigAccounts();
     const choices = promptParentAccount
         ? mapNonSandboxAccountChoices(accountsList)
         : mapSandboxAccountChoices(accountsList);
     if (!choices.length) {
         return Promise.resolve(undefined);
     }
-    return (0, promptUtils_1.promptUser)([
+    return promptUser([
         {
             name: 'account',
-            message: (0, lang_1.i18n)(promptParentAccount
+            message: i18n(promptParentAccount
                 ? `lib.prompts.sandboxesPrompt.selectParentAccountName`
                 : `lib.prompts.sandboxesPrompt.selectAccountName`),
             type: 'list',
             pageSize: 20,
             choices,
-            default: (0, config_2.getConfigDefaultAccount)(),
+            default: getConfigDefaultAccount(),
         },
     ]);
 }

package/lib/prompts/secretPrompt.js

@@ -1,31 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.secretValuePrompt = secretValuePrompt;
-exports.secretNamePrompt = secretNamePrompt;
-exports.secretListPrompt = secretListPrompt;
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-function secretValuePrompt() {
-    return (0, promptUtils_1.promptUser)([
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+export function secretValuePrompt() {
+    return promptUser([
         {
             name: 'secretValue',
             type: 'password',
             mask: '*',
-            message: (0, lang_1.i18n)(`lib.prompts.secretPrompt.enterValue`),
+            message: i18n(`lib.prompts.secretPrompt.enterValue`),
         },
     ]);
 }
-function secretNamePrompt() {
-    return (0, promptUtils_1.promptUser)([
+export function secretNamePrompt() {
+    return promptUser([
         {
             name: 'secretName',
             type: 'input',
-            message: (0, lang_1.i18n)(`lib.prompts.secretPrompt.enterName`),
+            message: i18n(`lib.prompts.secretPrompt.enterName`),
         },
     ]);
 }
-function secretListPrompt(secrets, message) {
-    return (0, promptUtils_1.promptUser)([
+export function secretListPrompt(secrets, message) {
+    return promptUser([
         {
             name: 'secretToModify',
             type: 'list',

package/lib/prompts/selectAppPrompt.js

@@ -1,24 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectAppPrompt = selectAppPrompt;
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const appsDev_1 = require("@hubspot/local-dev-lib/api/appsDev");
-const index_1 = require("../errorHandlers/index");
-const en_1 = require("../../lang/en");
-const promptUtils_1 = require("../prompts/promptUtils");
-async function selectAppPrompt(accountId, appId) {
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { debugError } from '../errorHandlers/index.js';
+import { lib } from '../../lang/en.js';
+import { listPrompt } from '../prompts/promptUtils.js';
+export async function selectAppPrompt(accountId, appId) {
     let availableApps = [];
     try {
-        const appsResponse = await (0, appsDev_1.fetchPublicAppsForPortal)(accountId);
+        const appsResponse = await fetchPublicAppsForPortal(accountId);
         if (appsResponse.data.results) {
             availableApps = appsResponse.data.results;
         }
     }
     catch (err) {
-        (0, index_1.debugError)(err);
+        debugError(err);
     }
     if (availableApps.length === 0) {
-        logger_1.logger.error(en_1.lib.prompts.selectAppPrompt.errors.noApps);
+        logger.error(lib.prompts.selectAppPrompt.errors.noApps);
         return null;
     }
     if (appId) {
@@ -27,10 +24,10 @@ async function selectAppPrompt(accountId, appId) {
             return targetApp;
         }
         else {
-            logger_1.logger.error(en_1.lib.prompts.selectAppPrompt.errors.invalidAppId);
+            logger.error(lib.prompts.selectAppPrompt.errors.invalidAppId);
         }
     }
-    const appPromptValue = await (0, promptUtils_1.listPrompt)(en_1.lib.prompts.selectAppPrompt.selectAppId, {
+    const appPromptValue = await listPrompt(lib.prompts.selectAppPrompt.selectAppId, {
         choices: availableApps.map(app => ({
             name: `${app.name} (${app.id})`,
             value: app,