@hubspot/cli 6.4.0 → 7.0.0-beta.0

package/lib/prompts/previewPrompt.js

@@ -1,47 +1,51 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const path = require('path');
-const { getCwd } = require('@hubspot/local-dev-lib/path');
-const { promptUser } = require('./promptUtils');
-const { i18n } = require('../lang');
+exports.previewPrompt = previewPrompt;
+exports.previewProjectPrompt = previewProjectPrompt;
+const path_1 = __importDefault(require("path"));
+const path_2 = require("@hubspot/local-dev-lib/path");
+const promptUtils_1 = require("./promptUtils");
+const lang_1 = require("../lang");
 const i18nKey = 'lib.prompts.previewPrompt';
-const previewPrompt = (promptOptions = {}) => {
-    return promptUser([
+async function previewPrompt(promptOptions = {}) {
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'src',
-            message: i18n(`${i18nKey}.enterSrc`),
+            message: (0, lang_1.i18n)(`${i18nKey}.enterSrc`),
             when: !promptOptions.src,
             default: '.',
-            validate: input => {
+            validate: (input) => {
                 if (!input) {
-                    return i18n(`${i18nKey}.errors.srcRequired`);
+                    return (0, lang_1.i18n)(`${i18nKey}.errors.srcRequired`);
                 }
                 return true;
             },
         },
         {
             name: 'dest',
-            message: i18n(`${i18nKey}.enterDest`),
+            message: (0, lang_1.i18n)(`${i18nKey}.enterDest`),
             when: !promptOptions.dest,
-            default: path.basename(getCwd()),
-            validate: input => {
+            default: path_1.default.basename((0, path_2.getCwd)()),
+            validate: (input) => {
                 if (!input) {
-                    return i18n(`${i18nKey}.errors.destRequired`);
+                    return (0, lang_1.i18n)(`${i18nKey}.errors.destRequired`);
                 }
                 return true;
             },
         },
     ]);
-};
-const previewProjectPrompt = async (themeComponents) => {
-    return promptUser([
+}
+async function previewProjectPrompt(themeComponents) {
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'themeComponentPath',
-            message: i18n(`${i18nKey}.themeProjectSelect`),
+            message: (0, lang_1.i18n)(`${i18nKey}.themeProjectSelect`),
             type: 'list',
             choices: themeComponents.map(t => {
-                const themeName = path.basename(t.path);
+                const themeName = path_1.default.basename(t.path);
                 return {
                     name: themeName,
                     value: t.path,
@@ -49,8 +53,4 @@ const previewProjectPrompt = async (themeComponents) => {
             }),
         },
     ]);
-};
-module.exports = {
-    previewPrompt,
-    previewProjectPrompt,
-};
+}

package/lib/prompts/projectAddPrompt.d.ts

@@ -1 +1,10 @@
+import { ProjectAddComponentData } from '../../types/Projects';
+type ProjectAddPromptResponse = {
+    component: ProjectAddComponentData;
+    name: string;
+};
+export declare function projectAddPrompt(components: ProjectAddComponentData[], promptOptions?: {
+    name?: string;
+    type?: string;
+}): Promise<ProjectAddPromptResponse>;
 export {};

package/lib/prompts/projectAddPrompt.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const { promptUser } = require('./promptUtils');
-const { i18n } = require('../lang');
+exports.projectAddPrompt = projectAddPrompt;
+const promptUtils_1 = require("./promptUtils");
+const lang_1 = require("../lang");
 const i18nKey = 'lib.prompts.projectAddPrompt';
-const projectAddPrompt = async (components, promptOptions = {}) => {
-    return promptUser([
+async function projectAddPrompt(components, promptOptions = {}) {
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'component',
             message: () => {
                 return promptOptions.type &&
                     !components.find(t => t.path === promptOptions.type)
-                    ? i18n(`${i18nKey}.errors.invalidType`, {
+                    ? (0, lang_1.i18n)(`${i18nKey}.errors.invalidType`, {
                         type: promptOptions.type,
                     })
-                    : i18n(`${i18nKey}.selectType`);
+                    : (0, lang_1.i18n)(`${i18nKey}.selectType`);
             },
             when: !promptOptions.type ||
                 !components.find(t => t.path === promptOptions.type),
@@ -28,17 +28,14 @@ const projectAddPrompt = async (components, promptOptions = {}) => {
         },
         {
             name: 'name',
-            message: i18n(`${i18nKey}.enterName`),
+            message: (0, lang_1.i18n)(`${i18nKey}.enterName`),
             when: !promptOptions.name,
-            validate: input => {
+            validate: (input) => {
                 if (!input) {
-                    return i18n(`${i18nKey}.errors.nameRequired`);
+                    return (0, lang_1.i18n)(`${i18nKey}.errors.nameRequired`);
                 }
                 return true;
             },
         },
     ]);
-};
-module.exports = {
-    projectAddPrompt,
-};
+}

package/lib/prompts/projectDevTargetAccountPrompt.d.ts

@@ -1 +1,6 @@
-export {};
+import { CLIAccount, AccountType } from '@hubspot/local-dev-lib/types/Accounts';
+import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts';
+export declare function selectSandboxTargetAccountPrompt(accounts: CLIAccount[], defaultAccountConfig: CLIAccount): Promise<DeveloperTestAccount | CLIAccount>;
+export declare function selectDeveloperTestTargetAccountPrompt(accounts: CLIAccount[], defaultAccountConfig: CLIAccount): Promise<DeveloperTestAccount | CLIAccount>;
+export declare function confirmDefaultAccountPrompt(accountName: string, accountType: AccountType): Promise<boolean>;
+export declare function confirmUseExistingDeveloperTestAccountPrompt(account: DeveloperTestAccount): Promise<boolean>;

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -1,51 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const { promptUser } = require('./promptUtils');
-const { i18n } = require('../lang');
-const { uiAccountDescription, uiCommandReference } = require('../ui');
-const { isSandbox } = require('../accountTypes');
-const { getAccountId } = require('@hubspot/local-dev-lib/config');
-const { getSandboxUsageLimits, } = require('@hubspot/local-dev-lib/api/sandboxHubs');
-const { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } = require('@hubspot/local-dev-lib/constants/config');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { fetchDeveloperTestAccounts, } = require('@hubspot/local-dev-lib/api/developerTestAccounts');
+exports.selectSandboxTargetAccountPrompt = selectSandboxTargetAccountPrompt;
+exports.selectDeveloperTestTargetAccountPrompt = selectDeveloperTestTargetAccountPrompt;
+exports.confirmDefaultAccountPrompt = confirmDefaultAccountPrompt;
+exports.confirmUseExistingDeveloperTestAccountPrompt = confirmUseExistingDeveloperTestAccountPrompt;
+const promptUtils_1 = require("./promptUtils");
+const lang_1 = require("../lang");
+const ui_1 = require("../ui");
+const accountTypes_1 = require("../accountTypes");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const sandboxHubs_1 = require("@hubspot/local-dev-lib/api/sandboxHubs");
+const config_2 = require("@hubspot/local-dev-lib/constants/config");
+const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const developerTestAccounts_1 = require("@hubspot/local-dev-lib/api/developerTestAccounts");
+const exitCodes_1 = require("../enums/exitCodes");
 const i18nKey = 'lib.prompts.projectDevTargetAccountPrompt';
-const mapNestedAccount = accountConfig => ({
-    name: uiAccountDescription(accountConfig.portalId, false),
-    value: {
-        targetAccountId: getAccountId(accountConfig.name),
-        createNestedAccount: false,
-        parentAccountId: accountConfig.parentAccountId,
-    },
-});
-const getNonConfigDeveloperTestAccountName = account => {
-    return `${account.accountName} [${HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]}] (${account.id})`;
-};
-const selectSandboxTargetAccountPrompt = async (accounts, defaultAccountConfig) => {
-    const defaultAccountId = getAccountId(defaultAccountConfig.name);
+function mapNestedAccount(accountConfig) {
+    const parentAccountId = accountConfig.parentAccountId ?? null;
+    return {
+        name: (0, ui_1.uiAccountDescription)((0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig), false),
+        value: {
+            targetAccountId: (0, config_1.getAccountId)(accountConfig.name),
+            createNestedAccount: false,
+            parentAccountId,
+        },
+    };
+}
+function getNonConfigDeveloperTestAccountName(account) {
+    return `${account.accountName} [${config_2.HUBSPOT_ACCOUNT_TYPE_STRINGS[config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]}] (${account.id})`;
+}
+async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig) {
+    const defaultAccountId = (0, config_1.getAccountId)(defaultAccountConfig.name);
     let choices = [];
-    let sandboxUsage = {};
+    let sandboxUsage = {
+        STANDARD: { used: 0, available: 0, limit: 0 },
+        DEVELOPER: { used: 0, available: 0, limit: 0 },
+    };
     try {
-        const { data } = await getSandboxUsageLimits(defaultAccountId);
-        sandboxUsage = data.usage;
+        if (defaultAccountId) {
+            const { data } = await (0, sandboxHubs_1.getSandboxUsageLimits)(defaultAccountId);
+            sandboxUsage = data.usage;
+        }
+        else {
+            logger_1.logger.error(`${i18nKey}.noAccountId`);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
     }
     catch (err) {
-        logger.debug('Unable to fetch sandbox usage limits: ', err);
+        logger_1.logger.debug('Unable to fetch sandbox usage limits: ', err);
     }
     const sandboxAccounts = accounts
         .reverse()
-        .filter(config => isSandbox(config) && config.parentAccountId === defaultAccountId);
+        .filter(config => (0, accountTypes_1.isSandbox)(config) && config.parentAccountId === defaultAccountId);
     let disabledMessage = false;
     if (sandboxUsage['DEVELOPER'] && sandboxUsage['DEVELOPER'].available === 0) {
         if (sandboxAccounts.length < sandboxUsage['DEVELOPER'].limit) {
-            disabledMessage = i18n(`${i18nKey}.sandboxLimitWithSuggestion`, {
-                authCommand: uiCommandReference('hs auth'),
+            disabledMessage = (0, lang_1.i18n)(`${i18nKey}.sandboxLimitWithSuggestion`, {
+                authCommand: (0, ui_1.uiCommandReference)('hs auth'),
                 limit: sandboxUsage['DEVELOPER'].limit,
             });
         }
         else {
-            disabledMessage = i18n(`${i18nKey}.sandboxLimit`, {
+            disabledMessage = (0, lang_1.i18n)(`${i18nKey}.sandboxLimit`, {
                 limit: sandboxUsage['DEVELOPER'].limit,
             });
         }
@@ -53,13 +70,13 @@ const selectSandboxTargetAccountPrompt = async (accounts, defaultAccountConfig)
     // Order choices by Developer Sandbox -> Standard Sandbox
     choices = [
         ...sandboxAccounts
-            .filter(a => a.accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)
+            .filter(a => a.accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)
             .map(mapNestedAccount),
         ...sandboxAccounts
-            .filter(a => a.accountType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)
+            .filter(a => a.accountType === config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)
             .map(mapNestedAccount),
         {
-            name: i18n(`${i18nKey}.createNewSandboxOption`),
+            name: (0, lang_1.i18n)(`${i18nKey}.createNewSandboxOption`),
             value: {
                 targetAccountId: null,
                 createNestedAccount: true,
@@ -67,7 +84,7 @@ const selectSandboxTargetAccountPrompt = async (accounts, defaultAccountConfig)
             disabled: disabledMessage,
         },
         {
-            name: i18n(`${i18nKey}.chooseDefaultAccountOption`),
+            name: (0, lang_1.i18n)(`${i18nKey}.chooseDefaultAccountOption`),
             value: {
                 targetAccountId: defaultAccountId,
                 createNestedAccount: false,
@@ -75,37 +92,43 @@ const selectSandboxTargetAccountPrompt = async (accounts, defaultAccountConfig)
         },
     ];
     return selectTargetAccountPrompt(defaultAccountId, 'sandbox account', choices);
-};
-const selectDeveloperTestTargetAccountPrompt = async (accounts, defaultAccountConfig) => {
-    const defaultAccountId = getAccountId(defaultAccountConfig.name);
-    let devTestAccountsResponse = undefined;
+}
+async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountConfig) {
+    const defaultAccountId = (0, config_1.getAccountId)(defaultAccountConfig.name);
+    let devTestAccountsResponse;
     try {
-        const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
-        devTestAccountsResponse = data;
+        if (defaultAccountId) {
+            const { data } = await (0, developerTestAccounts_1.fetchDeveloperTestAccounts)(defaultAccountId);
+            devTestAccountsResponse = data;
+        }
+        else {
+            logger_1.logger.error(`${i18nKey}.noAccountId`);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
     }
     catch (err) {
-        logger.debug('Unable to fetch developer test account usage limits: ', err);
+        logger_1.logger.debug('Unable to fetch developer test account usage limits: ', err);
     }
     let disabledMessage = false;
     if (devTestAccountsResponse &&
         devTestAccountsResponse.results.length >=
             devTestAccountsResponse.maxTestPortals) {
-        disabledMessage = i18n(`${i18nKey}.developerTestAccountLimit`, {
-            authCommand: uiCommandReference('hs auth'),
+        disabledMessage = (0, lang_1.i18n)(`${i18nKey}.developerTestAccountLimit`, {
+            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
             limit: devTestAccountsResponse.maxTestPortals,
         });
     }
     const devTestAccounts = [];
     if (devTestAccountsResponse && devTestAccountsResponse.results) {
-        const accountIds = accounts.map(account => account.portalId);
+        const accountIds = accounts.map(account => (0, getAccountIdentifier_1.getAccountIdentifier)(account));
         devTestAccountsResponse.results.forEach(acct => {
             const inConfig = accountIds.includes(acct.id);
             devTestAccounts.push({
                 name: getNonConfigDeveloperTestAccountName(acct),
                 value: {
                     targetAccountId: acct.id,
-                    createdNestedAccount: false,
-                    parentAccountId: defaultAccountId,
+                    createNestedAccount: false,
+                    parentAccountId: defaultAccountId ?? null,
                     notInConfigAccount: inConfig ? null : acct,
                 },
             });
@@ -114,7 +137,7 @@ const selectDeveloperTestTargetAccountPrompt = async (accounts, defaultAccountCo
     const choices = [
         ...devTestAccounts,
         {
-            name: i18n(`${i18nKey}.createNewDeveloperTestAccountOption`),
+            name: (0, lang_1.i18n)(`${i18nKey}.createNewDeveloperTestAccountOption`),
             value: {
                 targetAccountId: null,
                 createNestedAccount: true,
@@ -122,50 +145,45 @@ const selectDeveloperTestTargetAccountPrompt = async (accounts, defaultAccountCo
             disabled: disabledMessage,
         },
     ];
-    return selectTargetAccountPrompt(defaultAccountId, HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST], choices);
-};
-const selectTargetAccountPrompt = async (defaultAccountId, accountType, choices) => {
-    const { targetAccountInfo } = await promptUser([
+    return selectTargetAccountPrompt(defaultAccountId, config_2.HUBSPOT_ACCOUNT_TYPE_STRINGS[config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST], choices);
+}
+async function selectTargetAccountPrompt(defaultAccountId, accountType, choices) {
+    const accountId = defaultAccountId;
+    const { targetAccountInfo } = await (0, promptUtils_1.promptUser)([
         {
             name: 'targetAccountInfo',
             type: 'list',
-            message: i18n(`${i18nKey}.promptMessage`, {
-                accountIdentifier: uiAccountDescription(defaultAccountId),
+            message: (0, lang_1.i18n)(`${i18nKey}.promptMessage`, {
+                accountIdentifier: (0, ui_1.uiAccountDescription)(accountId),
                 accountType,
             }),
             choices,
         },
     ]);
     return targetAccountInfo;
-};
-const confirmDefaultAccountPrompt = async (accountName, accountType) => {
-    const { useDefaultAccount } = await promptUser([
+}
+async function confirmDefaultAccountPrompt(accountName, accountType) {
+    const { useDefaultAccount } = await (0, promptUtils_1.promptUser)([
         {
             name: 'useDefaultAccount',
             type: 'confirm',
-            message: i18n(`${i18nKey}.confirmDefaultAccount`, {
+            message: (0, lang_1.i18n)(`${i18nKey}.confirmDefaultAccount`, {
                 accountName,
                 accountType,
             }),
         },
     ]);
     return useDefaultAccount;
-};
-const confirmUseExistingDeveloperTestAccountPrompt = async (account) => {
-    const { confirmUseExistingDeveloperTestAccount } = await promptUser([
+}
+async function confirmUseExistingDeveloperTestAccountPrompt(account) {
+    const { confirmUseExistingDeveloperTestAccount } = await (0, promptUtils_1.promptUser)([
         {
             name: 'confirmUseExistingDeveloperTestAccount',
             type: 'confirm',
-            message: i18n(`${i18nKey}.confirmUseExistingDeveloperTestAccount`, {
+            message: (0, lang_1.i18n)(`${i18nKey}.confirmUseExistingDeveloperTestAccount`, {
                 accountName: getNonConfigDeveloperTestAccountName(account),
             }),
         },
     ]);
     return confirmUseExistingDeveloperTestAccount;
-};
-module.exports = {
-    selectSandboxTargetAccountPrompt,
-    selectDeveloperTestTargetAccountPrompt,
-    confirmDefaultAccountPrompt,
-    confirmUseExistingDeveloperTestAccountPrompt,
-};
+}

package/lib/prompts/projectsLogsPrompt.d.ts

@@ -1 +1,12 @@
+type ProjectLogsPromptOptions = {
+    functionChoices?: string[];
+    promptOptions?: {
+        function?: string;
+    };
+    projectName?: string;
+};
+type ProjectLogsPromptResponse = {
+    functionName?: string;
+};
+export declare function projectLogsPrompt({ functionChoices, promptOptions, projectName, }: ProjectLogsPromptOptions): Promise<ProjectLogsPromptResponse>;
 export {};

package/lib/prompts/projectsLogsPrompt.js

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

package/lib/prompts/promptUtils.d.ts

@@ -1,12 +1,13 @@
-export declare const promptUser: any;
+import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts';
+export declare function promptUser<T extends GenericPromptResponse>(config: PromptConfig<T> | PromptConfig<T>[]): Promise<T>;
 export declare function confirmPrompt(message: string, options?: {
     defaultAnswer?: boolean;
-    when?: boolean | (() => boolean);
+    when?: PromptWhen;
 }): Promise<boolean>;
 export declare function listPrompt(message: string, { choices, when, }: {
-    choices: Array<{
-        name: string;
-        value: string;
-    }>;
+    choices: PromptChoices;
+    when?: PromptWhen;
+}): Promise<string>;
+export declare function inputPrompt(message: string, { when, }?: {
     when?: boolean | (() => boolean);
 }): Promise<string>;

package/lib/prompts/promptUtils.js

@@ -1,27 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptUser = void 0;
+exports.promptUser = promptUser;
 exports.confirmPrompt = confirmPrompt;
 exports.listPrompt = listPrompt;
+exports.inputPrompt = inputPrompt;
 const inquirer = require('inquirer');
-// NOTE: we can eventually delete this and directly use inquirer.prompt when the files support imports
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-exports.promptUser = inquirer.createPromptModule();
+const promptModule = inquirer.createPromptModule();
+function promptUser(config) {
+    return promptModule(config);
+}
 async function confirmPrompt(message, options = {}) {
-    const { defaultAnswer, when } = options;
-    const { choice } = await (0, exports.promptUser)([
+    const { defaultAnswer = true, when } = options;
+    const { choice } = await promptUser([
         {
             name: 'choice',
             type: 'confirm',
             message,
-            default: defaultAnswer || true,
+            default: defaultAnswer,
             when,
         },
     ]);
     return choice;
 }
 async function listPrompt(message, { choices, when, }) {
-    const { choice } = await (0, exports.promptUser)([
+    const { choice } = await promptUser([
         {
             name: 'choice',
             type: 'list',
@@ -32,3 +34,14 @@ async function listPrompt(message, { choices, when, }) {
     ]);
     return choice;
 }
+async function inputPrompt(message, { when, } = {}) {
+    const { input } = await promptUser([
+        {
+            name: 'input',
+            type: 'input',
+            message,
+            when,
+        },
+    ]);
+    return input;
+}

package/lib/prompts/sandboxesPrompt.d.ts

@@ -1 +1,9 @@
+type SandboxTypePromptResponse = {
+    type: string;
+};
+type DeleteSandboxPromptResponse = {
+    account: string;
+};
+export declare function sandboxTypePrompt(): Promise<SandboxTypePromptResponse>;
+export declare function deleteSandboxPrompt(promptParentAccount?: boolean): Promise<DeleteSandboxPromptResponse> | void;
 export {};