@hubspot/cli 7.7.0-experimental.3 → 7.7.0

package/commands/testAccount/create.js

@@ -1,113 +1,125 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const developerTestAccounts_1 = require("@hubspot/local-dev-lib/api/developerTestAccounts");
-const yargsUtils_1 = require("../../lib/yargsUtils");
-const promptUtils_1 = require("../../lib/prompts/promptUtils");
-const exitCodes_1 = require("../../lib/enums/exitCodes");
-const logger_1 = require("../../lib/ui/logger");
-const command = 'create [name]';
-const describe = 'Create a test account';
-const hubs = {
-    MARKETING: 'marketingLevel',
-    OPS: 'opsLevel',
-    SERVICE: 'serviceLevel',
-    SALES: 'salesLevel',
-    CONTENT: 'contentLevel',
-};
-const TEST_ACCOUNT_TIERS = [
-    { name: 'Marketing STARTER', value: 'MARKETING:STARTER' },
-    { name: 'Marketing PRO', value: 'MARKETING:PRO' },
-    { name: 'Marketing ENTERPRISE', value: 'MARKETING:ENTERPRISE' },
-    promptUtils_1.Separator,
-    { name: 'Ops STARTER', value: 'OPS:STARTER' },
-    { name: 'Ops PRO', value: 'OPS:PRO' },
-    { name: 'Ops ENTERPRISE', value: 'OPS:ENTERPRISE' },
-    promptUtils_1.Separator,
-    { name: 'Service STARTER', value: 'SERVICE:STARTER' },
-    { name: 'Service PRO', value: 'SERVICE:PRO' },
-    { name: 'Service ENTERPRISE', value: 'SERVICE:ENTERPRISE' },
-    promptUtils_1.Separator,
-    { name: 'Sales STARTER', value: 'SALES:STARTER' },
-    { name: 'Sales PRO', value: 'SALES:PRO' },
-    { name: 'Sales ENTERPRISE', value: 'SALES:ENTERPRISE' },
-    promptUtils_1.Separator,
-    { name: 'Content STARTER', value: 'CONTENT:STARTER' },
-    { name: 'Content PRO', value: 'CONTENT:PRO' },
-    { name: 'Content ENTERPRISE', value: 'CONTENT:ENTERPRISE' },
-    promptUtils_1.Separator,
-];
+import fs from 'fs-extra';
+import path from 'path';
+import { getValidEnv } from '@hubspot/local-dev-lib/environment';
+import { getEnv } from '@hubspot/local-dev-lib/config';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { promptUser, listPrompt } from '../../lib/prompts/promptUtils.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { fileExists } from '../../lib/validation.js';
+import { commands } from '../../lang/en.js';
+import { createDeveloperTestAccountConfigPrompt } from '../../lib/prompts/createDeveloperTestAccountConfigPrompt.js';
+import { debugError, logError } from '../../lib/errorHandlers/index.js';
+import SpinniesManager from '../../lib/ui/SpinniesManager.js';
+import { createDeveloperTestAccountV3, saveAccountToConfig, } from '../../lib/buildAccount.js';
+const command = 'create';
+const describe = commands.testAccount.create.describe;
 async function handler(args) {
-    const { derivedAccountId, name, tiers } = args;
-    // trackCommandUsage('test-account-create', {}, derivedAccountId);
-    let accountName = name;
-    let accountLevelsArray = tiers;
-    if (!name) {
-        const namePromptResult = await (0, promptUtils_1.promptUser)({
-            name: 'accountName',
-            message: 'What is the name of the test account?',
-            type: 'input',
+    const { derivedAccountId, configPath, formatOutputAsJson } = args;
+    trackCommandUsage('test-account-create', {}, derivedAccountId);
+    const env = getValidEnv(getEnv(derivedAccountId));
+    let accountConfigPath = configPath;
+    let testAccountConfig;
+    if (!accountConfigPath) {
+        const createTestAccountFromConfig = await listPrompt(commands.testAccount.create.createTestAccountFromConfigPrompt, {
+            choices: [
+                {
+                    name: commands.testAccount.create.createFromConfigOption,
+                    value: true,
+                },
+                {
+                    name: commands.testAccount.create.createFromScratchOption,
+                    value: false,
+                },
+            ],
         });
-        accountName = namePromptResult.accountName;
+        if (createTestAccountFromConfig) {
+            const configPathPromptResult = await promptUser({
+                name: 'configPath',
+                message: commands.testAccount.create.configPathPrompt,
+                type: 'input',
+            });
+            accountConfigPath = configPathPromptResult.configPath;
+        }
     }
-    if (!accountLevelsArray) {
-        const accountLevelsPromptResult = await (0, promptUtils_1.promptUser)({
-            name: 'testAccountLevels',
-            message: '[--tiers] Which tiers should the test account have?',
-            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 'Cannot have more than one tier per hub';
-                        }
-                        hubMap[hub] = true;
-                    }
-                }
-                return true;
-            },
-        });
-        accountLevelsArray = accountLevelsPromptResult.testAccountLevels;
+    if (accountConfigPath) {
+        const absoluteConfigPath = path.resolve(getCwd(), accountConfigPath);
+        if (!fileExists(absoluteConfigPath)) {
+            uiLogger.error(commands.testAccount.create.errors.configFileNotFound(absoluteConfigPath));
+            process.exit(EXIT_CODES.ERROR);
+        }
+        try {
+            testAccountConfig = JSON.parse(fs.readFileSync(absoluteConfigPath, 'utf8'));
+        }
+        catch (err) {
+            uiLogger.error(commands.testAccount.create.errors.configFileParseFailed(absoluteConfigPath));
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    else {
+        testAccountConfig = await createDeveloperTestAccountConfigPrompt();
     }
-    const accountLevels = accountLevelsArray.reduce((acc, level) => {
-        const parts = level.split(':');
-        const hubName = hubs[parts[0]];
-        const hubTier = parts[1];
-        acc[hubName] = hubTier;
-        return acc;
-    }, {});
+    const resultJson = {};
+    SpinniesManager.init({
+        succeedColor: 'white',
+    });
+    SpinniesManager.add('createTestAccount', {
+        text: commands.testAccount.create.polling.start(testAccountConfig.accountName),
+    });
     try {
-        const { data } = await (0, developerTestAccounts_1.createDeveloperTestAccount)(derivedAccountId, accountName, true, accountLevels);
-        // @ts-expect-error - testPortalId is not typed
-        logger_1.uiLogger.log(`Test account created: ${data.testPortalId}`);
+        const createResult = await createDeveloperTestAccountV3(derivedAccountId, testAccountConfig);
+        resultJson.accountName = createResult.accountName;
+        resultJson.accountId = createResult.accountId;
+        resultJson.personalAccessKey = createResult.personalAccessKey;
     }
     catch (err) {
-        logger_1.uiLogger.error('Failed to create test account');
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        logError(err);
+        SpinniesManager.fail('createTestAccount', {
+            text: commands.testAccount.create.polling.createFailure,
+        });
+        process.exit(EXIT_CODES.ERROR);
+    }
+    SpinniesManager.succeed('createTestAccount', {
+        text: commands.testAccount.create.polling.success(testAccountConfig.accountName, resultJson.accountId),
+    });
+    if (formatOutputAsJson) {
+        uiLogger.json(resultJson);
     }
-    process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    else {
+        // Only save to config if not using json output
+        try {
+            await saveAccountToConfig(resultJson.accountId, testAccountConfig.accountName, env, resultJson.personalAccessKey);
+        }
+        catch (e) {
+            debugError(e);
+            uiLogger.error(commands.testAccount.create.errors.saveAccountToConfigFailure(testAccountConfig.accountName));
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    process.exit(EXIT_CODES.SUCCESS);
 }
 function createTestAccountBuilder(yargs) {
-    yargs.positional('name', {
+    yargs.option('config-path', {
         type: 'string',
-        description: 'The name of the test account',
-    });
-    yargs.option('tiers', {
-        type: 'array',
-        description: 'The tiers of the test account',
+        description: commands.testAccount.create.options.configPath,
     });
     yargs.example([
         [
-            '$0 create my-account --tiers MARKETING:STARTER OPS:PRO',
-            'Create a test account with the name "my-account" and the tiers "Marketing - STARTER, OPS - PRO"',
+            '$0 create --config-path ./test-account-config.json',
+            commands.testAccount.create.example('./test-account-config.json'),
         ],
     ]);
     return yargs;
 }
-const builder = (0, yargsUtils_1.makeYargsBuilder)(createTestAccountBuilder, command, describe, {
+const builder = makeYargsBuilder(createTestAccountBuilder, command, describe, {
     useGlobalOptions: true,
+    useEnvironmentOptions: true,
+    useAccountOptions: true,
+    useConfigOptions: true,
+    useTestingOptions: true,
+    useJSONOutputOptions: true,
 });
 const createTestAccountCommand = {
     command,
@@ -115,4 +127,4 @@ const createTestAccountCommand = {
     handler,
     builder,
 };
-exports.default = createTestAccountCommand;
+export default createTestAccountCommand;

package/commands/testAccount/createConfig.d.ts

@@ -0,0 +1,8 @@
+import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
+type CreateTestAccountConfigArgs = CommonArgs & {
+    name?: string;
+    description?: string;
+    path?: string;
+};
+declare const createTestAccountConfigCommand: YargsCommandModule<unknown, CreateTestAccountConfigArgs>;
+export default createTestAccountConfigCommand;

package/commands/testAccount/createConfig.js

@@ -0,0 +1,92 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { commands } from '../../lang/en.js';
+import { createDeveloperTestAccountConfigPrompt } from '../../lib/prompts/createDeveloperTestAccountConfigPrompt.js';
+import { fileExists } from '../../lib/validation.js';
+const command = 'create-config';
+const describe = commands.testAccount.createConfig.describe;
+async function handler(args) {
+    const { derivedAccountId, name, description, path: configPath } = args;
+    trackCommandUsage('test-account-create-config', {}, derivedAccountId);
+    let accountConfigPath = configPath;
+    const testAccountConfig = await createDeveloperTestAccountConfigPrompt({
+        name,
+        description,
+    });
+    if (!accountConfigPath) {
+        const pathPromptResult = await promptUser({
+            name: 'path',
+            message: commands.testAccount.createConfig.pathPrompt,
+            type: 'input',
+            default: testAccountConfig.accountName.toLowerCase().replace(/\s+/g, '-') +
+                '.json',
+            validate: path => {
+                if (!path) {
+                    return commands.testAccount.createConfig.errors.pathError;
+                }
+                else if (!path.endsWith('.json')) {
+                    return commands.testAccount.createConfig.errors.pathFormatError;
+                }
+                else if (fileExists(path)) {
+                    return commands.testAccount.createConfig.errors.pathExistsError;
+                }
+                return true;
+            },
+        });
+        accountConfigPath = pathPromptResult.path;
+    }
+    if (!accountConfigPath) {
+        uiLogger.error(commands.testAccount.createConfig.errors.pathError);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (fileExists(accountConfigPath)) {
+        uiLogger.error(commands.testAccount.createConfig.errors.pathExistsError);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        fs.writeFileSync(path.resolve(getCwd(), accountConfigPath), JSON.stringify(testAccountConfig, null, 2), 'utf8');
+    }
+    catch (err) {
+        uiLogger.error(commands.testAccount.createConfig.errors.failedToCreate);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    uiLogger.success(commands.testAccount.createConfig.success.configFileCreated(accountConfigPath));
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function createTestAccountConfigBuilder(yargs) {
+    yargs.option('name', {
+        type: 'string',
+        description: commands.testAccount.createConfig.options.name,
+    });
+    yargs.option('description', {
+        type: 'string',
+        description: commands.testAccount.createConfig.options.description,
+    });
+    yargs.option('path', {
+        type: 'string',
+        description: commands.testAccount.createConfig.options.path,
+    });
+    yargs.example([
+        [
+            '$0 test-account create-config --name my-account',
+            commands.testAccount.createConfig.example('my-account'),
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(createTestAccountConfigBuilder, command, describe, {
+    useGlobalOptions: true,
+});
+const createTestAccountConfigCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default createTestAccountConfigCommand;

package/commands/testAccount/delete.d.ts

@@ -1,6 +1,7 @@
-import { CommonArgs, YargsCommandModule } from '../../types/Yargs';
-type DeleteTestAccountArgs = CommonArgs & {
-    testAccountId: number;
+import { CommonArgs, ConfigArgs, EnvironmentArgs, TestingArgs, YargsCommandModule } from '../../types/Yargs.js';
+type DeleteTestAccountArgs = CommonArgs & ConfigArgs & TestingArgs & EnvironmentArgs & {
+    testAccount?: string | number;
+    force?: boolean;
 };
 declare const deleteTestAccountCommand: YargsCommandModule<unknown, DeleteTestAccountArgs>;
 export default deleteTestAccountCommand;

package/commands/testAccount/delete.js

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

package/commands/testAccount/importData.d.ts

@@ -0,0 +1,9 @@
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+export declare const command = "import-data";
+export declare const describe: "Import data into the CRM";
+type CrmImportDataArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    filePath: string | undefined;
+    skipConfirm: boolean | undefined;
+};
+declare const crmImportDataCommand: YargsCommandModule<unknown, CrmImportDataArgs>;
+export default crmImportDataCommand;

package/commands/testAccount/importData.js

@@ -0,0 +1,61 @@
+import { getImportDataRequest } from '@hubspot/local-dev-lib/crm';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { importDataFilePathPrompt } from '../../lib/prompts/importDataFilePathPrompt.js';
+import { handleImportData, handleTargetTestAccountSelectionFlow, } from '../../lib/importData.js';
+import { confirmImportDataPrompt } from '../../lib/prompts/confirmImportDataPrompt.js';
+import { commands } from '../../lang/en.js';
+export const command = 'import-data';
+export const describe = commands.testAccount.subcommands.importData.describe;
+async function handler(args) {
+    const { derivedAccountId, userProvidedAccount, filePath: providedFilePath, skipConfirm, } = args;
+    trackCommandUsage('crm-import-data', {}, derivedAccountId);
+    let targetAccountId;
+    try {
+        targetAccountId = await handleTargetTestAccountSelectionFlow(derivedAccountId, userProvidedAccount);
+        const filePath = providedFilePath || (await importDataFilePathPrompt());
+        const { importRequest, dataFileNames } = getImportDataRequest(filePath);
+        const confirmImportData = skipConfirm ||
+            (await confirmImportDataPrompt(targetAccountId, dataFileNames));
+        if (!confirmImportData) {
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        await handleImportData(targetAccountId, dataFileNames, importRequest);
+    }
+    catch (error) {
+        logError(error);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function crmImportDataBuilder(yargs) {
+    yargs.example([['$0 test-account import-data']]);
+    yargs.options({
+        'file-path': {
+            type: 'string',
+            describe: commands.testAccount.subcommands.importData.options.filePath.describe,
+            positional: false,
+        },
+        'skip-confirm': {
+            type: 'boolean',
+            describe: commands.testAccount.subcommands.importData.options.skipConfirm
+                .describe,
+        },
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(crmImportDataBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const crmImportDataCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default crmImportDataCommand;

package/commands/testAccount.d.ts

@@ -1,3 +1,3 @@
-import { YargsCommandModuleBucket } from '../types/Yargs';
+import { YargsCommandModuleBucket } from '../types/Yargs.js';
 declare const testAccountCommand: YargsCommandModuleBucket;
 export default testAccountCommand;