@hubspot/cli 7.6.0-beta.1 → 7.6.0-beta.11

package/lib/prompts/__tests__/projectsLogsPrompt.test.js

@@ -0,0 +1,37 @@
+import { projectLogsPrompt } from '../projectsLogsPrompt.js';
+import { promptUser } from '../promptUtils.js';
+import chalk from 'chalk';
+vi.mock('../promptUtils');
+describe('lib/prompts/projectsLogsPrompt', () => {
+    it('should return undefined functionName when functionChoices is undefined', async () => {
+        const actual = await projectLogsPrompt({ functionChoices: undefined });
+        expect(actual).toEqual({});
+        expect(promptUser).not.toHaveBeenCalled();
+    });
+    it('should return the functionName without prompting when there is only one functionChoice', async () => {
+        const functionChoice = 'this-is-the-only-function';
+        const { functionName } = await projectLogsPrompt({
+            functionChoices: [functionChoice],
+        });
+        expect(functionName).toEqual(functionChoice);
+        expect(promptUser).not.toHaveBeenCalled();
+    });
+    it('should prompt the user if there is more than one choice', async () => {
+        const functionChoices = ['choice 1', 'choice 2'];
+        const projectName = 'my cool project';
+        await projectLogsPrompt({
+            functionChoices,
+            projectName,
+        });
+        expect(promptUser).toHaveBeenCalledTimes(1);
+        expect(promptUser).toHaveBeenLastCalledWith(expect.arrayContaining([
+            expect.objectContaining({
+                name: 'functionName',
+                type: 'list',
+                message: `[--function] Select function in ${chalk.bold(projectName)} project`,
+                when: expect.any(Function),
+                choices: functionChoices,
+            }),
+        ]));
+    });
+});

package/lib/prompts/accountNamePrompt.d.ts

@@ -1,4 +1,4 @@
-import { PromptConfig } from '../../types/Prompts';
+import { PromptConfig } from '../../types/Prompts.js';
 import { AccountType } from '@hubspot/local-dev-lib/types/Accounts';
 export type AccountNamePromptResponse = {
     name: string;

package/lib/prompts/accountNamePrompt.js

@@ -1,69 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCliAccountNamePromptConfig = getCliAccountNamePromptConfig;
-exports.cliAccountNamePrompt = cliAccountNamePrompt;
-exports.hubspotAccountNamePrompt = hubspotAccountNamePrompt;
-const config_1 = require("@hubspot/local-dev-lib/config");
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-const config_2 = require("@hubspot/local-dev-lib/constants/config");
-function getCliAccountNamePromptConfig(defaultName) {
+import { accountNameExistsInConfig } from '@hubspot/local-dev-lib/config';
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+export function getCliAccountNamePromptConfig(defaultName) {
     return {
         name: 'name',
-        message: (0, lang_1.i18n)(`lib.prompts.accountNamePrompt.enterAccountName`),
+        message: i18n(`lib.prompts.accountNamePrompt.enterAccountName`),
         default: defaultName,
         validate(val) {
             if (typeof val !== 'string') {
-                return (0, lang_1.i18n)(`lib.prompts.accountNamePrompt.errors.invalidName`);
+                return i18n(`lib.prompts.accountNamePrompt.errors.invalidName`);
             }
             else if (!val.length) {
-                return (0, lang_1.i18n)(`lib.prompts.accountNamePrompt.errors.nameRequired`);
+                return i18n(`lib.prompts.accountNamePrompt.errors.nameRequired`);
             }
             else if (val.indexOf(' ') >= 0) {
-                return (0, lang_1.i18n)(`lib.prompts.accountNamePrompt.errors.spacesInName`);
+                return i18n(`lib.prompts.accountNamePrompt.errors.spacesInName`);
             }
-            return (0, config_1.accountNameExistsInConfig)(val)
-                ? (0, lang_1.i18n)(`lib.prompts.accountNamePrompt.errors.accountNameExists`, {
+            return accountNameExistsInConfig(val)
+                ? i18n(`lib.prompts.accountNamePrompt.errors.accountNameExists`, {
                     name: val,
                 })
                 : true;
         },
     };
 }
-function cliAccountNamePrompt(defaultName) {
-    return (0, promptUtils_1.promptUser)(getCliAccountNamePromptConfig(defaultName));
+export function cliAccountNamePrompt(defaultName) {
+    return promptUser(getCliAccountNamePromptConfig(defaultName));
 }
-function hubspotAccountNamePrompt({ accountType, currentPortalCount = 0, }) {
-    const isDevelopmentSandbox = accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX;
-    const isSandbox = accountType === config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX ||
+export function hubspotAccountNamePrompt({ accountType, currentPortalCount = 0, }) {
+    const isDevelopmentSandbox = accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX;
+    const isSandbox = accountType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX ||
         isDevelopmentSandbox;
-    const isDeveloperTestAccount = accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST;
+    const isDeveloperTestAccount = accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST;
     let promptMessageString;
     let defaultName;
     if (isSandbox) {
         promptMessageString = isDevelopmentSandbox
-            ? (0, lang_1.i18n)(`lib.prompts.accountNamePrompt.enterDevelopmentSandboxName`)
-            : (0, lang_1.i18n)(`lib.prompts.accountNamePrompt.enterStandardSandboxName`);
+            ? i18n(`lib.prompts.accountNamePrompt.enterDevelopmentSandboxName`)
+            : i18n(`lib.prompts.accountNamePrompt.enterStandardSandboxName`);
     }
     else if (isDeveloperTestAccount) {
-        promptMessageString = (0, lang_1.i18n)(`lib.prompts.accountNamePrompt.enterDeveloperTestAccountName`);
-        defaultName = (0, lang_1.i18n)(`lib.prompts.accountNamePrompt.developerTestAccountDefaultName`, {
+        promptMessageString = i18n(`lib.prompts.accountNamePrompt.enterDeveloperTestAccountName`);
+        defaultName = i18n(`lib.prompts.accountNamePrompt.developerTestAccountDefaultName`, {
             count: currentPortalCount + 1,
         });
     }
-    return (0, promptUtils_1.promptUser)([
+    return promptUser([
         {
             name: 'name',
             message: promptMessageString,
             validate(val) {
                 if (typeof val !== 'string') {
-                    return (0, lang_1.i18n)(`lib.prompts.accountNamePrompt.errors.invalidName`);
+                    return i18n(`lib.prompts.accountNamePrompt.errors.invalidName`);
                 }
                 else if (!val.trim().length) {
-                    return (0, lang_1.i18n)(`lib.prompts.accountNamePrompt.errors.nameRequired`);
+                    return i18n(`lib.prompts.accountNamePrompt.errors.nameRequired`);
                 }
-                return (0, config_1.accountNameExistsInConfig)(val)
-                    ? (0, lang_1.i18n)(`lib.prompts.accountNamePrompt.errors.accountNameExists`, {
+                return accountNameExistsInConfig(val)
+                    ? i18n(`lib.prompts.accountNamePrompt.errors.accountNameExists`, {
                         name: val,
                     })
                     : true;

package/lib/prompts/accountsPrompt.js

@@ -1,26 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectAccountFromConfig = selectAccountFromConfig;
-const config_1 = require("@hubspot/local-dev-lib/config");
-const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-const ui_1 = require("../ui");
+import { getConfigDefaultAccount, getConfigAccounts, } from '@hubspot/local-dev-lib/config';
+import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+import { uiAccountDescription } from '../ui/index.js';
 function mapAccountChoices(portals) {
     return (portals?.map(p => ({
-        name: (0, ui_1.uiAccountDescription)((0, getAccountIdentifier_1.getAccountIdentifier)(p), false),
-        value: String(p.name || (0, getAccountIdentifier_1.getAccountIdentifier)(p)),
+        name: uiAccountDescription(getAccountIdentifier(p), false),
+        value: String(p.name || getAccountIdentifier(p)),
     })) || []);
 }
-async function selectAccountFromConfig(prompt = '') {
-    const accountsList = (0, config_1.getConfigAccounts)();
-    const defaultAccount = (0, config_1.getConfigDefaultAccount)();
-    const { default: selectedDefault } = await (0, promptUtils_1.promptUser)([
+export async function selectAccountFromConfig(prompt = '') {
+    const accountsList = getConfigAccounts();
+    const defaultAccount = getConfigDefaultAccount();
+    const { default: selectedDefault } = await promptUser([
         {
             type: 'list',
             name: 'default',
             pageSize: 20,
-            message: prompt || (0, lang_1.i18n)(`commands.account.subcommands.use.promptMessage`),
+            message: prompt || i18n(`commands.account.subcommands.use.promptMessage`),
             choices: mapAccountChoices(accountsList),
             default: defaultAccount ?? undefined,
         },

package/lib/prompts/cmsFieldPrompt.js

@@ -1,22 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fieldsJsPrompt = fieldsJsPrompt;
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-const escapeRegExp_1 = require("@hubspot/local-dev-lib/escapeRegExp");
+import path from 'path';
+import fs from 'fs';
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+import { escapeRegExp } from '@hubspot/local-dev-lib/escapeRegExp';
 const FIELDS_FILES = ['fields.json', 'fields.js', 'fields.cjs', 'fields.mjs'];
-async function fieldsJsPrompt(filePath, projectDir, skipFiles = []) {
-    const dirName = path_1.default.dirname(filePath);
+export async function fieldsJsPrompt(filePath, projectDir, skipFiles = []) {
+    const dirName = path.dirname(filePath);
     // Get a list of all field files in the directory, resolve their absolute path, and remove the ones that we already skipped.
-    const fileChoices = fs_1.default
+    const fileChoices = fs
         .readdirSync(dirName)
         .filter(file => FIELDS_FILES.includes(file))
-        .map(file => path_1.default.resolve(dirName, file))
+        .map(file => path.resolve(dirName, file))
         .filter(file => !skipFiles.includes(file));
     if (!fileChoices.length)
         return [filePath, []];
@@ -24,15 +18,15 @@ async function fieldsJsPrompt(filePath, projectDir, skipFiles = []) {
         return [fileChoices[0], []];
     // We get the directory above the project one so that relative paths are printed with the root of the project dir attached.
     projectDir = projectDir.substring(0, projectDir.lastIndexOf('/'));
-    const projectDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(projectDir)}`);
-    const fileDir = path_1.default.dirname(fileChoices[0]).replace(projectDirRegex, '');
+    const projectDirRegex = new RegExp(`^${escapeRegExp(projectDir)}`);
+    const fileDir = path.dirname(fileChoices[0]).replace(projectDirRegex, '');
     const selection = fileChoices.map(fileChoice => ({
         name: fileChoice.replace(projectDirRegex, ''),
         value: fileChoice,
     }));
-    const promptVal = await (0, promptUtils_1.promptUser)([
+    const promptVal = await promptUser([
         {
-            message: (0, lang_1.i18n)(`lib.prompts.uploadPrompt.fieldsPrompt`, { dir: fileDir }),
+            message: i18n(`lib.prompts.uploadPrompt.fieldsPrompt`, { dir: fileDir }),
             type: 'list',
             name: 'filePathChoice',
             choices: selection,

package/lib/prompts/confirmImportDataPrompt.d.ts

@@ -0,0 +1 @@
+export declare function confirmImportDataPrompt(targetAccountId: number, dataFileNames: string[]): Promise<boolean>;

package/lib/prompts/confirmImportDataPrompt.js

@@ -0,0 +1,12 @@
+import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+export async function confirmImportDataPrompt(targetAccountId, dataFileNames) {
+    const account = getAccountConfig(targetAccountId);
+    const { confirmImportData } = await promptUser({
+        type: 'confirm',
+        name: 'confirmImportData',
+        message: lib.prompts.confirmImportDataPrompt.message(dataFileNames, account),
+    });
+    return confirmImportData;
+}

package/lib/prompts/createApiSamplePrompt.d.ts

@@ -1,4 +1,4 @@
-import { ApiSampleConfig } from '../../types/Cms';
+import { ApiSampleConfig } from '../../types/Cms.js';
 type SampleTypePromptResponse = {
     sampleType?: string;
 };

package/lib/prompts/createApiSamplePrompt.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createApiSamplePrompt = createApiSamplePrompt;
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
 function getSampleTypesPrompt(choices) {
     return {
         type: 'rawlist',
         name: 'sampleType',
-        message: (0, lang_1.i18n)(`lib.prompts.createApiSamplePrompt.selectApiSampleApp`),
+        message: i18n(`lib.prompts.createApiSamplePrompt.selectApiSampleApp`),
         choices: choices.map(choice => ({
             name: `${choice.name} - ${choice.description}`,
             value: choice.id,
@@ -18,7 +15,7 @@ function getSampleTypesPrompt(choices) {
                     resolve(true);
                 }
                 else {
-                    reject((0, lang_1.i18n)(`lib.prompts.createApiSamplePrompt.errors.apiSampleAppRequired`));
+                    reject(i18n(`lib.prompts.createApiSamplePrompt.errors.apiSampleAppRequired`));
                 }
             });
         },
@@ -28,7 +25,7 @@ function getLanguagesPrompt(choices) {
     return {
         type: 'rawlist',
         name: 'sampleLanguage',
-        message: (0, lang_1.i18n)(`lib.prompts.createApiSamplePrompt.selectLanguage`),
+        message: i18n(`lib.prompts.createApiSamplePrompt.selectLanguage`),
         choices: choices.map(choice => ({
             name: choice,
             value: choice,
@@ -38,18 +35,18 @@ function getLanguagesPrompt(choices) {
                 if (input && input.length > 0) {
                     resolve(true);
                 }
-                reject((0, lang_1.i18n)(`lib.prompts.createApiSamplePrompt.errors.languageRequired`));
+                reject(i18n(`lib.prompts.createApiSamplePrompt.errors.languageRequired`));
             });
         },
     };
 }
-async function createApiSamplePrompt(samplesConfig) {
+export async function createApiSamplePrompt(samplesConfig) {
     try {
         const { samples } = samplesConfig;
-        const sampleTypeAnswer = await (0, promptUtils_1.promptUser)(getSampleTypesPrompt(samples));
+        const sampleTypeAnswer = await promptUser(getSampleTypesPrompt(samples));
         const chosenSample = samples.find(sample => sample.id === sampleTypeAnswer.sampleType);
         const { languages } = chosenSample;
-        const languagesAnswer = await (0, promptUtils_1.promptUser)(getLanguagesPrompt(languages));
+        const languagesAnswer = await promptUser(getLanguagesPrompt(languages));
         return {
             ...sampleTypeAnswer,
             ...languagesAnswer,

package/lib/prompts/createDeveloperTestAccountConfigPrompt.d.ts

@@ -1,17 +1,18 @@
-import { DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts';
+import { AccountLevel, DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
 declare const hubs: {
-    readonly MARKETING: "marketingLevel";
-    readonly OPS: "opsLevel";
-    readonly SERVICE: "serviceLevel";
-    readonly SALES: "salesLevel";
-    readonly CONTENT: "contentLevel";
+    MARKETING: string;
+    OPS: string;
+    SERVICE: string;
+    SALES: string;
+    CONTENT: string;
 };
 type HubName = keyof typeof hubs;
-type HubTier = 'STARTER' | 'PROFESSIONAL' | 'ENTERPRISE';
-export type HubConfig = `${HubName}:${HubTier}`;
+export type HubConfig = {
+    hub: HubName;
+    tier: AccountLevel;
+};
 export declare function createDeveloperTestAccountConfigPrompt(args?: {
     name?: string;
     description?: string;
-    tiers?: HubConfig[];
-}): Promise<DeveloperTestAccountConfig>;
+}, supportFlags?: boolean): Promise<DeveloperTestAccountConfig>;
 export {};

package/lib/prompts/createDeveloperTestAccountConfigPrompt.js

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDeveloperTestAccountConfigPrompt = createDeveloperTestAccountConfigPrompt;
-const en_1 = require("../../lang/en");
-const promptUtils_1 = require("./promptUtils");
+import { Separator } from '@inquirer/prompts';
+import { lib } from '../../lang/en.js';
+import { promptUser } from './promptUtils.js';
 const hubs = {
     MARKETING: 'marketingLevel',
     OPS: 'opsLevel',
@@ -10,65 +8,110 @@ const hubs = {
     SALES: 'salesLevel',
     CONTENT: 'contentLevel',
 };
+const AccountTiers = {
+    FREE: 'FREE',
+    STARTER: 'STARTER',
+    PROFESSIONAL: 'PROFESSIONAL',
+    ENTERPRISE: 'ENTERPRISE',
+};
+const makeHubTiers = (hubKey) => {
+    const hubTypeKey = hubKey.toLowerCase();
+    const hubName = lib.prompts.createDeveloperTestAccountConfigPrompt.hubTypes[hubTypeKey];
+    return [
+        {
+            name: `${hubName} [${AccountTiers.FREE}]`,
+            value: { hub: hubKey, tier: AccountTiers.FREE },
+        },
+        {
+            name: `${hubName} [${AccountTiers.STARTER}]`,
+            value: { hub: hubKey, tier: AccountTiers.STARTER },
+        },
+        {
+            name: `${hubName} [${AccountTiers.PROFESSIONAL}]`,
+            value: { hub: hubKey, tier: AccountTiers.PROFESSIONAL },
+        },
+        {
+            name: `${hubName} [${AccountTiers.ENTERPRISE}]`,
+            value: { hub: hubKey, tier: AccountTiers.ENTERPRISE },
+        },
+    ];
+};
 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 Separator(),
+    ...makeHubTiers('OPS'),
+    new Separator(),
+    ...makeHubTiers('SERVICE'),
+    new Separator(),
+    ...makeHubTiers('SALES'),
+    new Separator(),
+    ...makeHubTiers('CONTENT'),
+    new Separator(),
 ];
-async function createDeveloperTestAccountConfigPrompt(args = {}) {
-    const { name, description, tiers } = args;
+export async function createDeveloperTestAccountConfigPrompt(args = {}, supportFlags = true) {
+    const { name, description } = args;
     let accountName = name;
     let accountDescription = description;
-    let accountLevelsArray = tiers;
+    let accountLevelsArray = [];
     if (!accountName) {
-        const namePromptResult = await (0, promptUtils_1.promptUser)({
+        const namePromptResult = await promptUser({
             name: 'accountName',
-            message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.namePrompt,
+            message: lib.prompts.createDeveloperTestAccountConfigPrompt.namePrompt(supportFlags),
             type: 'input',
+            validate: value => {
+                if (!value) {
+                    return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
+                        .nameRequired;
+                }
+                return true;
+            },
         });
         accountName = namePromptResult.accountName;
     }
     if (!accountDescription) {
-        const descriptionPromptResult = await (0, promptUtils_1.promptUser)({
+        const descriptionPromptResult = await promptUser({
             name: 'description',
-            message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.descriptionPrompt,
+            message: lib.prompts.createDeveloperTestAccountConfigPrompt.descriptionPrompt(supportFlags),
             type: 'input',
         });
         accountDescription = descriptionPromptResult.description;
     }
-    if (!accountLevelsArray) {
-        const accountLevelsPromptResult = await (0, promptUtils_1.promptUser)({
+    const useDefaultAccountLevelsPromptResult = await promptUser({
+        name: 'useDefaultAccountLevels',
+        message: lib.prompts.createDeveloperTestAccountConfigPrompt
+            .useDefaultAccountLevelsPrompt.message,
+        type: 'list',
+        choices: [
+            {
+                name: lib.prompts.createDeveloperTestAccountConfigPrompt
+                    .useDefaultAccountLevelsPrompt.default,
+                value: 'default',
+            },
+            {
+                name: lib.prompts.createDeveloperTestAccountConfigPrompt
+                    .useDefaultAccountLevelsPrompt.manual,
+                value: 'manual',
+            },
+        ],
+    });
+    if (useDefaultAccountLevelsPromptResult.useDefaultAccountLevels === 'manual') {
+        const accountLevelsPromptResult = await promptUser({
             name: 'testAccountLevels',
-            message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.tiersPrompt,
+            message: lib.prompts.createDeveloperTestAccountConfigPrompt.tiersPrompt,
             type: 'checkbox',
+            pageSize: 13,
             choices: TEST_ACCOUNT_TIERS,
             validate: choices => {
-                if (choices?.length > 1) {
+                if (choices?.length < Object.keys(hubs).length) {
+                    return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
+                        .allHubsRequired;
+                }
+                else {
                     const hubMap = {};
                     for (const choice of choices) {
-                        const hub = choice.split(':')[0];
+                        const { hub } = choice.value;
                         if (hubMap[hub]) {
-                            return en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.errors
+                            return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
                                 .tiersError;
                         }
                         hubMap[hub] = true;
@@ -79,11 +122,8 @@ async function createDeveloperTestAccountConfigPrompt(args = {}) {
         });
         accountLevelsArray = accountLevelsPromptResult.testAccountLevels;
     }
-    if (!accountLevelsArray) {
-        accountLevelsArray = [];
-    }
     const accountLevels = accountLevelsArray.reduce((acc, level) => {
-        const [hubName, hubTier] = level.split(':');
+        const { hub: hubName, tier: hubTier } = level;
         const hubLevel = hubs[hubName];
         acc[hubLevel] = hubTier;
         return acc;

package/lib/prompts/createFunctionPrompt.d.ts

@@ -1,8 +1,9 @@
+import { CreateArgs } from '../../types/Cms.js';
 type CreateFunctionPromptResponse = {
     functionsFolder: string;
     filename: string;
     endpointMethod: string;
     endpointPath: string;
 };
-export declare function createFunctionPrompt(): Promise<CreateFunctionPromptResponse>;
+export declare function createFunctionPrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateFunctionPromptResponse>;
 export {};

package/lib/prompts/createFunctionPrompt.js

@@ -1,36 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFunctionPrompt = createFunctionPrompt;
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
 const FUNCTIONS_FOLDER_PROMPT = {
     name: 'functionsFolder',
-    message: (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.enterFolder`),
+    message: i18n(`lib.prompts.createFunctionPrompt.enterFolder`),
     validate(val) {
         if (typeof val !== 'string') {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.invalid`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.invalid`);
         }
         else if (!val.length) {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.blank`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.blank`);
         }
         else if (val.indexOf(' ') >= 0) {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.space`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.space`);
         }
         return true;
     },
 };
 const FUNCTION_FILENAME_PROMPT = {
     name: 'filename',
-    message: (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.enterFilename`),
+    message: i18n(`lib.prompts.createFunctionPrompt.enterFilename`),
     validate(val) {
         if (typeof val !== 'string') {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.invalid`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.invalid`);
         }
         else if (!val.length) {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.blank`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.blank`);
         }
         else if (val.indexOf(' ') >= 0) {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.space`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.space`);
         }
         return true;
     },
@@ -38,31 +35,60 @@ const FUNCTION_FILENAME_PROMPT = {
 const ENDPOINT_METHOD_PROMPT = {
     type: 'list',
     name: 'endpointMethod',
-    message: (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.selectEndpointMethod`),
+    message: i18n(`lib.prompts.createFunctionPrompt.selectEndpointMethod`),
     default: 'GET',
     choices: ['DELETE', 'GET', 'PATCH', 'POST', 'PUT'],
 };
 const ENDPOINT_PATH_PROMPT = {
     name: 'endpointPath',
-    message: (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.enterEndpointPath`),
+    message: i18n(`lib.prompts.createFunctionPrompt.enterEndpointPath`),
     validate(val) {
         if (typeof val !== 'string') {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.invalid`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.invalid`);
         }
         else if (!val.length) {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.blank`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.blank`);
         }
         else if (val.indexOf(' ') >= 0) {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.space`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.space`);
         }
         return true;
     },
 };
-function createFunctionPrompt() {
-    return (0, promptUtils_1.promptUser)([
-        FUNCTIONS_FOLDER_PROMPT,
-        FUNCTION_FILENAME_PROMPT,
-        ENDPOINT_METHOD_PROMPT,
-        ENDPOINT_PATH_PROMPT,
-    ]);
+export function createFunctionPrompt(commandArgs = {}) {
+    // Check if all required parameters are provided (endpointMethod has default)
+    const hasAllRequired = commandArgs.functionsFolder &&
+        commandArgs.filename &&
+        commandArgs.endpointPath;
+    if (hasAllRequired) {
+        return Promise.resolve({
+            functionsFolder: commandArgs.functionsFolder,
+            filename: commandArgs.filename,
+            endpointMethod: commandArgs.endpointMethod || 'GET',
+            endpointPath: commandArgs.endpointPath,
+        });
+    }
+    const prompts = [];
+    // Only prompt for missing parameters
+    if (!commandArgs.functionsFolder) {
+        prompts.push(FUNCTIONS_FOLDER_PROMPT);
+    }
+    if (!commandArgs.filename) {
+        prompts.push(FUNCTION_FILENAME_PROMPT);
+    }
+    if (!commandArgs.endpointMethod) {
+        prompts.push(ENDPOINT_METHOD_PROMPT);
+    }
+    if (!commandArgs.endpointPath) {
+        prompts.push(ENDPOINT_PATH_PROMPT);
+    }
+    return promptUser(prompts).then(promptResponse => {
+        // Merge prompted values with provided commandArgs
+        return {
+            functionsFolder: commandArgs.functionsFolder || promptResponse.functionsFolder,
+            filename: commandArgs.filename || promptResponse.filename,
+            endpointMethod: commandArgs.endpointMethod || promptResponse.endpointMethod || 'GET',
+            endpointPath: commandArgs.endpointPath || promptResponse.endpointPath,
+        };
+    });
 }