@hubspot/cli 8.0.10-experimental.6 → 8.0.10-experimental.7

package/commands/cms/lint.js

@@ -0,0 +1,83 @@
+import { lint } from '@hubspot/local-dev-lib/cms/validate';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { commands } from '../../lang/en.js';
+import { resolveLocalPath } from '../../lib/filesystem.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+const command = 'lint <path>';
+// Hiding since this command is still experimental
+const describe = undefined; //'Lint a file or folder for HubL syntax';
+function getErrorsFromHublValidationObject(validation) {
+    return ((validation && validation.meta && validation.meta.template_errors) || []);
+}
+function printHublValidationError(err) {
+    const { severity, message, lineno, startPosition } = err;
+    if (severity === 'FATAL') {
+        uiLogger.error(`[${lineno}, ${startPosition}]: ${message}`);
+    }
+    else {
+        uiLogger.warn(`[${lineno}, ${startPosition}]: ${message}`);
+    }
+}
+function printHublValidationResult({ file, validation }) {
+    let count = 0;
+    if (!validation) {
+        return count;
+    }
+    const errors = getErrorsFromHublValidationObject(validation);
+    if (!errors.length) {
+        return count;
+    }
+    uiLogger.group(file);
+    errors.forEach(err => {
+        if (err.reason !== 'SYNTAX_ERROR') {
+            return;
+        }
+        ++count;
+        printHublValidationError(err);
+    });
+    uiLogger.groupEnd();
+    return count;
+}
+async function handler(args) {
+    const { path: lintPath, derivedAccountId } = args;
+    const localPath = resolveLocalPath(lintPath);
+    const groupName = commands.cms.subcommands.lint.groupName(localPath);
+    trackCommandUsage('lint', undefined, derivedAccountId);
+    uiLogger.group(groupName);
+    let count = 0;
+    try {
+        await lint(derivedAccountId, localPath, (result) => {
+            return (count += printHublValidationResult(result));
+        });
+    }
+    catch (err) {
+        uiLogger.groupEnd();
+        logError(err, { accountId: derivedAccountId });
+        process.exit(EXIT_CODES.ERROR);
+    }
+    uiLogger.groupEnd();
+    uiLogger.log(commands.cms.subcommands.lint.issuesFound(count));
+}
+function lintBuilder(yargs) {
+    yargs.positional('path', {
+        describe: commands.cms.subcommands.lint.positionals.path.describe,
+        required: true,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(lintBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+});
+const lintCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default lintCommand;

package/commands/cms/list.d.ts

@@ -0,0 +1,6 @@
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type ListArgs = CommonArgs & ConfigArgs & EnvironmentArgs & AccountArgs & {
+    path: string;
+};
+declare const cmsListCommand: YargsCommandModule<unknown, ListArgs>;
+export default cmsListCommand;

package/commands/cms/list.js

@@ -0,0 +1,96 @@
+import chalk from 'chalk';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { isPathFolder } from '../../lib/filesystem.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { getDirectoryContentsByPath } from '@hubspot/local-dev-lib/api/fileMapper';
+import { HUBSPOT_FOLDER, MARKETPLACE_FOLDER } from '../../lib/constants.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { commands } from '../../lang/en.js';
+function addColorToContents(fileOrFolder) {
+    if (!isPathFolder(fileOrFolder)) {
+        return chalk.reset.cyan(fileOrFolder);
+    }
+    if (fileOrFolder === HUBSPOT_FOLDER || fileOrFolder === MARKETPLACE_FOLDER) {
+        return chalk.reset.bold.blue(fileOrFolder);
+    }
+    return chalk.reset.blue(fileOrFolder);
+}
+function sortContents(a, b) {
+    // Pin @hubspot folder to top
+    if (a === HUBSPOT_FOLDER) {
+        return -1;
+    }
+    else if (b === HUBSPOT_FOLDER) {
+        return 1;
+    }
+    // Pin @marketplace folder to top
+    if (a === MARKETPLACE_FOLDER) {
+        return -1;
+    }
+    else if (b === MARKETPLACE_FOLDER) {
+        return 1;
+    }
+    return a.localeCompare(b);
+}
+const command = ['list [path]', 'ls [path]'];
+const describe = commands.cms.subcommands.list.describe;
+async function handler(args) {
+    const { path, derivedAccountId } = args;
+    const directoryPath = path || '/';
+    let contentsResp;
+    trackCommandUsage('list', undefined, derivedAccountId);
+    uiLogger.debug(commands.cms.subcommands.list.gettingPathContents(directoryPath));
+    try {
+        const { data } = await getDirectoryContentsByPath(derivedAccountId, directoryPath);
+        contentsResp = data;
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (!contentsResp.folder) {
+        uiLogger.info(commands.cms.subcommands.list.noFilesFoundAtPath(directoryPath));
+        return;
+    }
+    // getDirectoryContentsByPath omits @hubspot
+    const contents = directoryPath === '/'
+        ? ['@hubspot', ...contentsResp.children]
+        : contentsResp.children;
+    if (contents.length === 0) {
+        uiLogger.info(commands.cms.subcommands.list.noFilesFoundAtPath(directoryPath));
+        return;
+    }
+    const folderContentsOutput = contents
+        .map(addColorToContents)
+        .sort(sortContents)
+        .join('\n');
+    uiLogger.log(folderContentsOutput);
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function cmsListBuilder(yargs) {
+    yargs.positional('path', {
+        describe: commands.cms.subcommands.list.positionals.path.describe,
+        type: 'string',
+    });
+    yargs.example([
+        ['$0 cms list'],
+        ['$0 cms list /'],
+        ['$0 cms list my-modules'],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(cmsListBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const cmsListCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default cmsListCommand;

package/commands/cms/module/create.d.ts

@@ -0,0 +1,11 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../../types/Yargs.js';
+type ModuleCreateArgs = CommonArgs & ConfigArgs & {
+    name?: string;
+    dest?: string;
+    moduleLabel?: string;
+    reactType?: boolean;
+    contentTypes?: string;
+    global?: boolean;
+};
+declare const moduleCreateCommand: YargsCommandModule<unknown, ModuleCreateArgs>;
+export default moduleCreateCommand;

package/commands/cms/module/create.js

@@ -0,0 +1,84 @@
+import fs from 'fs-extra';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { resolveLocalPath } from '../../../lib/filesystem.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { commands } from '../../../lang/en.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { CONTENT_TYPES } from '../../../types/Cms.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import assets from '../../../lib/cmsAssets/index.js';
+const command = 'create <name> [dest]';
+const describe = commands.cms.subcommands.module.subcommands.create.describe;
+async function handler(args) {
+    const { derivedAccountId, name, dest } = args;
+    const assetType = 'module';
+    trackCommandUsage('create', { assetType }, derivedAccountId);
+    const asset = assets[assetType];
+    const argsToPass = {
+        commandArgs: args,
+        assetType,
+        name,
+        dest,
+    };
+    if (!argsToPass.dest) {
+        argsToPass.dest = resolveLocalPath(asset.dest(argsToPass));
+    }
+    try {
+        await fs.ensureDir(argsToPass.dest);
+    }
+    catch (e) {
+        uiLogger.error(commands.cms.subcommands.module.subcommands.create.errors.unusablePath(argsToPass.dest));
+        logError(e);
+        return;
+    }
+    if (asset.validate && !asset.validate(argsToPass))
+        return;
+    try {
+        await asset.execute(argsToPass);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function moduleCreateBuilder(yargs) {
+    yargs.positional('name', {
+        describe: commands.cms.subcommands.module.subcommands.create.positionals.name,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.module.subcommands.create.positionals.dest,
+        type: 'string',
+    });
+    yargs.option('module-label', {
+        describe: commands.cms.subcommands.module.subcommands.create.options.moduleLabel,
+        type: 'string',
+    });
+    yargs.option('react-type', {
+        describe: commands.cms.subcommands.module.subcommands.create.options.reactType,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('content-types', {
+        describe: commands.cms.subcommands.module.subcommands.create.options.contentTypes(CONTENT_TYPES),
+        type: 'string',
+    });
+    yargs.option('global', {
+        describe: commands.cms.subcommands.module.subcommands.create.options.global,
+        type: 'boolean',
+        default: false,
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(moduleCreateBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const moduleCreateCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default moduleCreateCommand;

package/commands/cms/module/marketplace-validate.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule } from '../../../types/Yargs.js';
+export type MarketplaceValidateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    src: string;
+};
+declare const marketplaceValidateCommand: YargsCommandModule<unknown, MarketplaceValidateArgs>;
+export default marketplaceValidateCommand;

package/commands/cms/module/marketplace-validate.js

@@ -0,0 +1,62 @@
+import SpinniesManager from '../../../lib/ui/SpinniesManager.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { kickOffValidation, pollForValidationFinish, fetchValidationResults, hasProcessValidationErrors, displayValidationResults, } from '../../../lib/marketplaceValidate.js';
+import { commands } from '../../../lang/en.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { logError } from '../../../lib/errorHandlers/index.js';
+const command = 'marketplace-validate <src>';
+const describe = commands.cms.subcommands.module.subcommands.marketplaceValidate.describe;
+async function handler(args) {
+    const { src, derivedAccountId } = args;
+    trackCommandUsage('validate', undefined, derivedAccountId);
+    SpinniesManager.add('marketplaceValidation', {
+        text: commands.cms.subcommands.module.subcommands.marketplaceValidate.logs.validatingModule(src),
+    });
+    const assetType = 'MODULE';
+    let validationId;
+    try {
+        validationId = await kickOffValidation(derivedAccountId, assetType, src);
+        await pollForValidationFinish(derivedAccountId, validationId);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    SpinniesManager.remove('marketplaceValidation');
+    let validationResults;
+    try {
+        validationResults = await fetchValidationResults(derivedAccountId, validationId);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const hasErrors = hasProcessValidationErrors(commands.cms.subcommands.module.subcommands.marketplaceValidate.errors
+        .invalidPath, validationResults);
+    if (hasErrors) {
+        process.exit(EXIT_CODES.ERROR);
+    }
+    displayValidationResults(commands.cms.subcommands.module.subcommands.marketplaceValidate.results, validationResults);
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function marketplaceValidateBuilder(yargs) {
+    yargs.positional('src', {
+        describe: commands.cms.subcommands.module.subcommands.marketplaceValidate
+            .positionals.src,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(marketplaceValidateBuilder, command, describe, {
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const marketplaceValidateCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default marketplaceValidateCommand;

package/commands/cms/module.d.ts

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

package/commands/cms/module.js

@@ -0,0 +1,21 @@
+import createCommand from './module/create.js';
+import marketplaceValidateCommand from './module/marketplace-validate.js';
+import { commands } from '../../lang/en.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = 'module';
+const describe = commands.cms.subcommands.module.describe;
+function moduleBuilder(yargs) {
+    yargs
+        .command(createCommand)
+        .command(marketplaceValidateCommand)
+        .demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(moduleBuilder, command, describe);
+const moduleCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default moduleCommand;

package/commands/cms/mv.d.ts

@@ -0,0 +1,7 @@
+import { CommonArgs, ConfigArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type MvArgs = CommonArgs & ConfigArgs & EnvironmentArgs & {
+    srcPath: string;
+    destPath: string;
+};
+declare const cmsMvCommand: YargsCommandModule<unknown, MvArgs>;
+export default cmsMvCommand;

package/commands/cms/mv.js

@@ -0,0 +1,60 @@
+import { moveFile } from '@hubspot/local-dev-lib/api/fileMapper';
+import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
+import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { isPathFolder } from '../../lib/filesystem.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { commands } from '../../lang/en.js';
+function getCorrectedDestPath(srcPath, destPath) {
+    if (!isPathFolder(srcPath)) {
+        return destPath;
+    }
+    // Makes sure that nested folders are moved independently
+    return `${destPath}/${srcPath.split('/').pop()}`;
+}
+const command = 'mv <srcPath> <destPath>';
+const describe = commands.cms.subcommands.mv.describe;
+async function handler(args) {
+    const { srcPath, destPath, derivedAccountId } = args;
+    trackCommandUsage('mv', undefined, derivedAccountId);
+    try {
+        await moveFile(derivedAccountId, srcPath, getCorrectedDestPath(srcPath, destPath));
+        uiLogger.success(commands.cms.subcommands.mv.move(srcPath, destPath, derivedAccountId));
+    }
+    catch (error) {
+        uiLogger.error(commands.cms.subcommands.mv.errors.moveFailed(srcPath, destPath, derivedAccountId));
+        if (isSpecifiedError(error, { statusCode: 409 })) {
+            uiLogger.error(commands.cms.subcommands.mv.errors.sourcePathExists(srcPath, destPath));
+        }
+        else {
+            logError(error, new ApiErrorContext({
+                accountId: derivedAccountId,
+            }));
+        }
+    }
+}
+function cmsMvBuilder(yargs) {
+    yargs.positional('srcPath', {
+        describe: commands.cms.subcommands.mv.positionals.srcPath.describe,
+        type: 'string',
+    });
+    yargs.positional('destPath', {
+        describe: commands.cms.subcommands.mv.positionals.destPath.describe,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(cmsMvBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const cmsMvCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default cmsMvCommand;

package/commands/cms/template/create.d.ts

@@ -0,0 +1,9 @@
+import { TemplateType } from '../../../types/Cms.js';
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../../types/Yargs.js';
+type TemplateCreateArgs = CommonArgs & ConfigArgs & {
+    name?: string;
+    dest?: string;
+    templateType?: TemplateType;
+};
+declare const templateCreateCommand: YargsCommandModule<unknown, TemplateCreateArgs>;
+export default templateCreateCommand;

package/commands/cms/template/create.js

@@ -0,0 +1,72 @@
+import fs from 'fs-extra';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { resolveLocalPath } from '../../../lib/filesystem.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { commands } from '../../../lang/en.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { TEMPLATE_TYPES, } from '../../../types/Cms.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import assets from '../../../lib/cmsAssets/index.js';
+const command = 'create <name> [dest]';
+const describe = commands.cms.subcommands.template.subcommands.create.describe;
+async function handler(args) {
+    const { derivedAccountId, name, dest } = args;
+    const assetType = 'template';
+    trackCommandUsage('create', { assetType }, derivedAccountId);
+    const asset = assets[assetType];
+    const argsToPass = {
+        commandArgs: args,
+        assetType,
+        name,
+        dest,
+        getInternalVersion: false,
+    };
+    if (!argsToPass.dest) {
+        argsToPass.dest = resolveLocalPath(asset.dest(argsToPass));
+    }
+    try {
+        await fs.ensureDir(argsToPass.dest);
+    }
+    catch (e) {
+        uiLogger.error(commands.cms.subcommands.template.subcommands.create.errors.unusablePath(argsToPass.dest));
+        logError(e);
+        return;
+    }
+    if (asset.validate && !asset.validate(argsToPass))
+        return;
+    try {
+        await asset.execute(argsToPass);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function templateCreateBuilder(yargs) {
+    yargs.positional('name', {
+        describe: commands.cms.subcommands.template.subcommands.create.positionals.name,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.template.subcommands.create.positionals.dest,
+        type: 'string',
+    });
+    yargs.option('template-type', {
+        describe: commands.cms.subcommands.template.subcommands.create.options.templateType,
+        type: 'string',
+        choices: [...TEMPLATE_TYPES],
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(templateCreateBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const templateCreateCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default templateCreateCommand;

package/commands/cms/template.d.ts

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

package/commands/cms/template.js

@@ -0,0 +1,17 @@
+import createCommand from './template/create.js';
+import { commands } from '../../lang/en.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = 'template';
+const describe = commands.cms.subcommands.template.describe;
+function templateBuilder(yargs) {
+    yargs.command(createCommand).demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(templateBuilder, command, describe);
+const templateCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default templateCommand;

package/commands/cms/theme/create.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../../types/Yargs.js';
+type ThemeCreateArgs = CommonArgs & ConfigArgs & {
+    dest?: string;
+};
+declare const themeCreateCommand: YargsCommandModule<unknown, ThemeCreateArgs>;
+export default themeCreateCommand;

package/commands/cms/theme/create.js

@@ -0,0 +1,58 @@
+import fs from 'fs-extra';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { resolveLocalPath } from '../../../lib/filesystem.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { commands } from '../../../lang/en.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import assets from '../../../lib/cmsAssets/index.js';
+const command = 'create [dest]';
+const describe = commands.cms.subcommands.theme.subcommands.create.describe;
+async function handler(args) {
+    const { derivedAccountId, dest } = args;
+    const assetType = 'website-theme';
+    trackCommandUsage('create', { assetType }, derivedAccountId);
+    const asset = assets[assetType];
+    const argsToPass = {
+        commandArgs: args,
+        assetType,
+        dest,
+    };
+    if (!argsToPass.dest) {
+        argsToPass.dest = resolveLocalPath(asset.dest(argsToPass));
+    }
+    try {
+        await fs.ensureDir(argsToPass.dest);
+    }
+    catch (e) {
+        uiLogger.error(commands.cms.subcommands.theme.subcommands.create.errors.unusablePath(argsToPass.dest));
+        logError(e);
+        return;
+    }
+    try {
+        await asset.execute(argsToPass);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function themeCreateBuilder(yargs) {
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.theme.subcommands.create.positionals.dest,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(themeCreateBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const themeCreateCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default themeCreateCommand;

package/commands/cms/theme/generate-selectors.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, YargsCommandModule } from '../../../types/Yargs.js';
+export type ThemeSelectorArgs = CommonArgs & {
+    path: string;
+};
+declare const themeSelectorsCommand: YargsCommandModule<unknown, ThemeSelectorArgs>;
+export default themeSelectorsCommand;