@hubspot/cli 7.8.12-experimental.0 → 7.9.0-beta.0

package/commands/cms/function/list.js

@@ -0,0 +1,60 @@
+import moment from 'moment';
+import { getRoutes } from '@hubspot/local-dev-lib/api/functions';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { logError, ApiErrorContext } from '../../../lib/errorHandlers/index.js';
+import { getTableContents, getTableHeader } from '../../../lib/ui/table.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { commands } from '../../../lang/en.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+const command = ['list', 'ls'];
+const describe = commands.cms.subcommands.function.subcommands.list.describe;
+async function handler(args) {
+    const { derivedAccountId } = args;
+    trackCommandUsage('function-list', undefined, derivedAccountId);
+    uiLogger.debug(commands.cms.subcommands.function.subcommands.list.debug.gettingFunctions);
+    const { data: routesResp } = await getRoutes(derivedAccountId).catch(async (e) => {
+        logError(e, new ApiErrorContext({ accountId: derivedAccountId }));
+        process.exit(EXIT_CODES.SUCCESS);
+    });
+    if (!routesResp.objects.length) {
+        return uiLogger.info(commands.cms.subcommands.function.subcommands.list.info.noFunctions);
+    }
+    if (args.json) {
+        return uiLogger.json(routesResp.objects);
+    }
+    const functionsAsArrays = routesResp.objects.map(func => {
+        const { route, method, created, updated, secretNames } = func;
+        return [
+            route,
+            method,
+            secretNames.join(', '),
+            moment(created).format(),
+            moment(updated).format(),
+        ];
+    });
+    functionsAsArrays.unshift(getTableHeader(['Route', 'Method', 'Secrets', 'Created', 'Updated']));
+    return uiLogger.log(getTableContents(functionsAsArrays));
+}
+function functionListBuilder(yargs) {
+    yargs.options({
+        json: {
+            describe: commands.cms.subcommands.function.subcommands.list.options.json
+                .describe,
+            type: 'boolean',
+        },
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(functionListBuilder, command, describe, {
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const functionListCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default functionListCommand;

package/commands/cms/function/logs.d.ts

@@ -0,0 +1,10 @@
+import { CommonArgs, ConfigArgs, AccountArgs, YargsCommandModule, EnvironmentArgs } from '../../../types/Yargs.js';
+export type LogsArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    endpoint?: string;
+    latest?: boolean;
+    compact?: boolean;
+    follow?: boolean;
+    limit?: number;
+};
+declare const logsCommand: YargsCommandModule<unknown, LogsArgs>;
+export default logsCommand;

package/commands/cms/function/logs.js

@@ -0,0 +1,135 @@
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { outputLogs } from '../../../lib/ui/serverlessFunctionLogs.js';
+import { getFunctionLogs, getLatestFunctionLog, } from '@hubspot/local-dev-lib/api/functions';
+import { tailLogs } from '../../../lib/serverlessLogs.js';
+import { promptUser } from '../../../lib/prompts/promptUtils.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { commands } from '../../../lang/en.js';
+const handleLogsError = (e, accountId, functionPath) => {
+    if (isHubSpotHttpError(e) && (e.status === 404 || e.status == 400)) {
+        uiLogger.error(commands.cms.subcommands.function.subcommands.logs.errors.noLogsFound(functionPath, accountId));
+    }
+};
+const endpointLog = async (accountId, functionPath, options) => {
+    const { limit, latest, follow, compact } = options;
+    const requestParams = {
+        limit,
+        latest,
+        follow,
+        endpoint: functionPath,
+    };
+    uiLogger.debug(commands.cms.subcommands.function.subcommands.logs.gettingLogs(latest, functionPath));
+    let logsResp;
+    if (follow) {
+        const tailCall = (after) => getFunctionLogs(accountId, functionPath, { after });
+        const fetchLatest = () => {
+            try {
+                return getLatestFunctionLog(accountId, functionPath);
+            }
+            catch (e) {
+                handleLogsError(e, accountId, functionPath);
+                return Promise.reject(e);
+            }
+        };
+        await tailLogs(accountId, functionPath, fetchLatest, tailCall, compact);
+    }
+    else if (latest) {
+        try {
+            const { data } = await getLatestFunctionLog(accountId, functionPath);
+            logsResp = data;
+        }
+        catch (e) {
+            handleLogsError(e, accountId, functionPath);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    else {
+        try {
+            const { data } = await getFunctionLogs(accountId, functionPath, requestParams);
+            logsResp = data;
+        }
+        catch (e) {
+            handleLogsError(e, accountId, functionPath);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    if (logsResp) {
+        return outputLogs(logsResp, { compact });
+    }
+};
+const command = 'logs [endpoint]';
+const describe = commands.cms.subcommands.function.subcommands.logs.describe;
+const handler = async (options) => {
+    const { endpoint: endpointArgValue, latest, derivedAccountId } = options;
+    trackCommandUsage('logs', latest ? { action: 'latest' } : {}, derivedAccountId);
+    const { endpointPromptValue } = await promptUser({
+        name: 'endpointPromptValue',
+        message: commands.cms.subcommands.function.subcommands.logs.endpointPrompt,
+        when: !endpointArgValue,
+    });
+    await endpointLog(derivedAccountId, endpointArgValue || endpointPromptValue, options);
+};
+function logsBuilder(yargs) {
+    yargs.positional('endpoint', {
+        describe: commands.cms.subcommands.function.subcommands.logs.positionals.endpoint
+            .describe,
+        type: 'string',
+    });
+    yargs
+        .options({
+        latest: {
+            alias: 'l',
+            describe: commands.cms.subcommands.function.subcommands.logs.options.latest
+                .describe,
+            type: 'boolean',
+        },
+        compact: {
+            describe: commands.cms.subcommands.function.subcommands.logs.options.compact
+                .describe,
+            type: 'boolean',
+        },
+        follow: {
+            alias: ['f'],
+            describe: commands.cms.subcommands.function.subcommands.logs.options.follow
+                .describe,
+            type: 'boolean',
+        },
+        limit: {
+            describe: commands.cms.subcommands.function.subcommands.logs.options.limit
+                .describe,
+            type: 'number',
+        },
+    })
+        .conflicts('follow', 'limit');
+    yargs.example([
+        [
+            '$0 logs my-endpoint',
+            commands.cms.subcommands.function.subcommands.logs.examples.default,
+        ],
+        [
+            '$0 logs my-endpoint --limit=10',
+            commands.cms.subcommands.function.subcommands.logs.examples.limit,
+        ],
+        [
+            '$0 logs my-endpoint --follow',
+            commands.cms.subcommands.function.subcommands.logs.examples.follow,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(logsBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const logsCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default logsCommand;

package/commands/cms/function/server.d.ts

@@ -0,0 +1,10 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule } from '../../../types/Yargs.js';
+export type FunctionServerArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    path: string;
+    port?: string;
+    contact?: boolean;
+    watch?: boolean;
+    'log-output'?: boolean;
+};
+declare const functionServerCommand: YargsCommandModule<unknown, FunctionServerArgs>;
+export default functionServerCommand;

package/commands/cms/function/server.js

@@ -0,0 +1,69 @@
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+// This package is not typed, so we need to use require
+import { start as startTestServer } from '@hubspot/serverless-dev-runtime';
+import { commands } from '../../../lang/en.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+const command = 'server <path>';
+const describe = undefined;
+async function handler(args) {
+    const { path: functionPath, derivedAccountId } = args;
+    trackCommandUsage('functions-server', undefined, derivedAccountId);
+    uiLogger.debug(commands.cms.subcommands.function.subcommands.server.debug.startingServer(functionPath));
+    startTestServer({
+        accountId: derivedAccountId,
+        ...args,
+    });
+}
+function functionServerBuilder(yargs) {
+    yargs.positional('path', {
+        describe: commands.cms.subcommands.function.subcommands.server.positionals.path
+            .describe,
+        type: 'string',
+    });
+    yargs.options({
+        port: {
+            describe: commands.cms.subcommands.function.subcommands.server.options.port
+                .describe,
+            type: 'string',
+            default: 5432,
+        },
+        contact: {
+            describe: commands.cms.subcommands.function.subcommands.server.options.contact
+                .describe,
+            type: 'boolean',
+            default: true,
+        },
+        watch: {
+            describe: commands.cms.subcommands.function.subcommands.server.options.watch
+                .describe,
+            type: 'boolean',
+            default: true,
+        },
+        'log-output': {
+            describe: commands.cms.subcommands.function.subcommands.server.options.logOutput
+                .describe,
+            type: 'boolean',
+            default: false,
+        },
+    });
+    yargs.example([
+        [
+            '$0 functions server ./tmp/myFunctionFolder.functions',
+            commands.cms.subcommands.function.subcommands.server.examples.default,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(functionServerBuilder, command, describe, {
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const functionServerCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default functionServerCommand;

package/commands/cms/function.d.ts

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

package/commands/cms/function.js

@@ -0,0 +1,27 @@
+import createCommand from './function/create.js';
+import listCommand from './function/list.js';
+import deployCommand from './function/deploy.js';
+import serverCommand from './function/server.js';
+import logsCommand from './function/logs.js';
+import { commands } from '../../lang/en.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = ['function', 'functions'];
+const describe = commands.cms.subcommands.function.describe;
+function functionBuilder(yargs) {
+    yargs
+        .command(createCommand)
+        .command(listCommand)
+        .command(deployCommand)
+        .command(serverCommand)
+        .command(logsCommand)
+        .demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(functionBuilder, command, describe);
+const functionCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default functionCommand;

package/commands/cms/getReactModule.js

@@ -1,16 +1,16 @@
 import fs from 'fs';
 import path from 'path';
 import { getCwd } from '@hubspot/local-dev-lib/path';
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { retrieveDefaultModule } from '@hubspot/local-dev-lib/cms/modules';
-import { i18n } from '../../lib/lang.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
 import { logError } from '../../lib/errorHandlers/index.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { listPrompt } from '../../lib/prompts/promptUtils.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 const command = 'get-react-module [name] [dest]';
-const describe = i18n(`commands.cms.subcommands.getReactModule.describe`);
+const describe = commands.cms.subcommands.getReactModule.describe;
 async function handler(args) {
     const { name, dest } = args;
     trackCommandUsage('get-react-modules');
@@ -26,7 +26,7 @@ async function handler(args) {
         if (!availableModules) {
             process.exit(EXIT_CODES.ERROR);
         }
-        const moduleChoice = await listPrompt(i18n(`commands.cms.subcommands.getReactModule.selectModulePrompt`), {
+        const moduleChoice = await listPrompt(commands.cms.subcommands.getReactModule.selectModulePrompt, {
             choices: availableModules.map(module => module.name),
         });
         moduleToRetrieve = moduleChoice;
@@ -35,22 +35,17 @@ async function handler(args) {
         ? path.join(path.resolve(getCwd(), dest), `${moduleToRetrieve}`)
         : path.join(getCwd(), `${moduleToRetrieve}`);
     if (fs.existsSync(destPath)) {
-        logger.error(i18n(`commands.cms.subcommands.getReactModule.errors.pathExists`, {
-            path: destPath,
-        }));
+        uiLogger.error(commands.cms.subcommands.getReactModule.errors.pathExists(destPath));
         process.exit(EXIT_CODES.ERROR);
     }
     try {
         await retrieveDefaultModule(moduleToRetrieve, destPath);
-        logger.success(i18n(`commands.cms.subcommands.getReactModule.success.moduleDownloaded`, {
-            moduleName: moduleToRetrieve,
-            path: destPath,
-        }));
+        uiLogger.success(commands.cms.subcommands.getReactModule.success.moduleDownloaded(moduleToRetrieve, destPath));
     }
     catch (e) {
         const isBadRequestError = e?.cause?.code === 'ERR_BAD_REQUEST';
         if (isBadRequestError) {
-            logger.error(i18n(`commands.cms.subcommands.getReactModule.errors.invalidName`));
+            uiLogger.error(commands.cms.subcommands.getReactModule.errors.invalidName);
         }
         else {
             logError(e);
@@ -61,11 +56,11 @@ async function handler(args) {
 }
 function cmsGetReactModuleBuilder(yargs) {
     yargs.positional('name', {
-        describe: i18n(`commands.cms.subcommands.getReactModule.positionals.name.describe`),
+        describe: commands.cms.subcommands.getReactModule.positionals.name.describe,
         type: 'string',
     });
     yargs.positional('dest', {
-        describe: i18n(`commands.cms.subcommands.getReactModule.positionals.dest.describe`),
+        describe: commands.cms.subcommands.getReactModule.positionals.dest.describe,
         type: 'string',
     });
     return yargs;

package/commands/cms/lighthouseScore.js

@@ -1,8 +1,8 @@
 import SpinniesManager from '../../lib/ui/SpinniesManager.js';
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { getTableContents, getTableHeader } from '../../lib/ui/table.js';
 import { promptUser } from '../../lib/prompts/promptUtils.js';
-import { i18n } from '../../lib/lang.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
 import { fetchThemes } from '@hubspot/local-dev-lib/api/designManager';
 import { requestLighthouseScore, getLighthouseScoreStatus, getLighthouseScore, } from '@hubspot/local-dev-lib/api/lighthouseScore';
 import { HUBSPOT_FOLDER, MARKETPLACE_FOLDER } from '../../lib/constants.js';
@@ -45,14 +45,14 @@ async function selectTheme(accountId) {
         }
     }
     catch (err) {
-        logger.error(i18n(`commands.cms.subcommands.lighthouseScore.errors.failedToFetchThemes`));
+        uiLogger.error(commands.cms.subcommands.lighthouseScore.errors.failedToFetchThemes);
         process.exit(EXIT_CODES.ERROR);
     }
     const { theme: selectedTheme } = await promptUser([
         {
             type: 'list',
             name: 'theme',
-            message: i18n(`commands.cms.subcommands.lighthouseScore.info.promptMessage`),
+            message: commands.cms.subcommands.lighthouseScore.info.promptMessage,
             choices: themes,
         },
     ]);
@@ -75,15 +75,13 @@ async function handler(args) {
             isValidTheme = false;
         }
         if (!isValidTheme) {
-            logger.error(i18n(`commands.cms.subcommands.lighthouseScore.errors.themeNotFound`, {
-                theme: themeToCheck,
-            }));
+            uiLogger.error(commands.cms.subcommands.lighthouseScore.errors.themeNotFound(themeToCheck));
             process.exit(EXIT_CODES.ERROR);
         }
     }
     else {
         themeToCheck = await selectTheme(derivedAccountId);
-        logger.log();
+        uiLogger.log('');
     }
     // Kick off the scoring
     let requestResult;
@@ -94,17 +92,17 @@ async function handler(args) {
         requestResult = data;
     }
     catch (err) {
-        logger.debug(err);
+        uiLogger.debug(err);
     }
     if (!requestResult || !requestResult.mobileId || !requestResult.desktopId) {
-        logger.error(i18n(`commands.cms.subcommands.lighthouseScore.errors.failedToGetLighthouseScore`));
+        uiLogger.error(commands.cms.subcommands.lighthouseScore.errors.failedToGetLighthouseScore);
         process.exit(EXIT_CODES.ERROR);
     }
     // Poll till scoring is finished
     try {
         SpinniesManager.init();
         SpinniesManager.add('lighthouseScore', {
-            text: i18n(`commands.cms.subcommands.lighthouseScore.info.generatingScore`, { theme: themeToCheck }),
+            text: commands.cms.subcommands.lighthouseScore.info.generatingScore(themeToCheck),
         });
         async function checkScoreStatus() {
             let desktopScoreStatus = 'COMPLETED';
@@ -131,7 +129,7 @@ async function handler(args) {
         SpinniesManager.remove('lighthouseScore');
     }
     catch (err) {
-        logger.debug(err);
+        uiLogger.debug(err);
         process.exit(EXIT_CODES.ERROR);
     }
     // Fetch the scoring results
@@ -166,16 +164,17 @@ async function handler(args) {
         }
     }
     catch (err) {
-        logger.error(i18n(`commands.cms.subcommands.lighthouseScore.errors.failedToGetLighthouseScore`));
+        uiLogger.error(commands.cms.subcommands.lighthouseScore.errors.failedToGetLighthouseScore);
         process.exit(EXIT_CODES.ERROR);
     }
     if (verbose) {
         const scoreResult = target === 'desktop' ? desktopScoreResult : mobileScoreResult;
         if (!verboseViewAverageScoreResult || !scoreResult) {
-            logger.error(i18n(`commands.cms.subcommands.lighthouseScore.errors.failedToGetLighthouseScore`));
+            uiLogger.error(commands.cms.subcommands.lighthouseScore.errors
+                .failedToGetLighthouseScore);
             process.exit(EXIT_CODES.ERROR);
         }
-        logger.log(`${themeToCheck} ${target} scores`);
+        uiLogger.log(commands.cms.subcommands.lighthouseScore.info.themeToCheckTitle(themeToCheck, target));
         const tableHeader = getTableHeader(DEFAULT_TABLE_HEADER);
         const scores = verboseViewAverageScoreResult.scores
             ? verboseViewAverageScoreResult.scores[0]
@@ -187,10 +186,10 @@ async function handler(args) {
             scores.pwaScore,
             scores.seoScore,
         ];
-        logger.log(getTableContents([tableHeader, averageTableData], {
+        uiLogger.log(getTableContents([tableHeader, averageTableData], {
             border: { bodyLeft: '  ' },
         }));
-        logger.log(i18n(`commands.cms.subcommands.lighthouseScore.info.pageTemplateScoreTitle`));
+        uiLogger.log(commands.cms.subcommands.lighthouseScore.info.pageTemplateScoreTitle);
         const table2Header = getTableHeader([
             'Template path',
             ...DEFAULT_TABLE_HEADER,
@@ -205,29 +204,27 @@ async function handler(args) {
                 score.seoScore,
             ];
         });
-        logger.log(getTableContents([table2Header, ...templateTableData], {
+        uiLogger.log(getTableContents([table2Header, ...templateTableData], {
             border: { bodyLeft: '  ' },
         }));
-        logger.log(i18n(`commands.cms.subcommands.lighthouseScore.info.lighthouseLinksTitle`));
+        uiLogger.log(commands.cms.subcommands.lighthouseScore.info.lighthouseLinksTitle);
         scoreResult.scores.forEach(score => {
             if (score.templatePath && score.link) {
-                logger.log(' ', uiLink(score.templatePath, score.link));
+                uiLogger.log(` ${uiLink(score.templatePath, score.link)}`);
             }
         });
         if (scoreResult.failedTemplatePaths.length) {
-            logger.log();
-            logger.error(i18n(`commands.cms.subcommands.lighthouseScore.info.failedTemplatePathsTitle`));
+            uiLogger.log('');
+            uiLogger.error(commands.cms.subcommands.lighthouseScore.info.failedTemplatePathsTitle);
             scoreResult.failedTemplatePaths.forEach(failedTemplatePath => {
-                logger.log(' ', failedTemplatePath);
+                uiLogger.log(` ${failedTemplatePath}`);
             });
         }
-        logger.log();
-        logger.info(i18n(`commands.cms.subcommands.lighthouseScore.info.targetDeviceNote`, {
-            target,
-        }));
+        uiLogger.log('');
+        uiLogger.info(commands.cms.subcommands.lighthouseScore.info.targetDeviceNote(target));
     }
     else {
-        logger.log(`Theme: ${themeToCheck}`);
+        uiLogger.log(commands.cms.subcommands.lighthouseScore.info.themeTitle(themeToCheck));
         const tableHeader = getTableHeader(['Target', ...DEFAULT_TABLE_HEADER]);
         const getTableData = (target, scoreResult) => {
             const scores = scoreResult?.scores ? scoreResult.scores[0] : EMPTY_SCORE;
@@ -244,35 +241,35 @@ async function handler(args) {
             getTableData('desktop', desktopScoreResult),
             getTableData('mobile', mobileScoreResult),
         ];
-        logger.log(getTableContents([tableHeader, ...tableData], {
+        uiLogger.log(getTableContents([tableHeader, ...tableData], {
             border: { bodyLeft: '  ' },
         }));
-        logger.info(i18n(`commands.cms.subcommands.lighthouseScore.info.verboseOptionNote`));
+        uiLogger.info(commands.cms.subcommands.lighthouseScore.info.verboseOptionNote);
     }
-    logger.log();
-    logger.log(`Powered by ${uiLink('Google Lighthouse', 'https://developer.chrome.com/docs/lighthouse/overview/')}.`);
+    uiLogger.log('');
+    uiLogger.log(commands.cms.subcommands.lighthouseScore.info.poweredByLink);
     process.exit(EXIT_CODES.SUCCESS);
 }
 function cmslighthouseScoreBuilder(yargs) {
     yargs.option('theme', {
-        describe: i18n(`commands.cms.subcommands.lighthouseScore.options.theme.describe`),
+        describe: commands.cms.subcommands.lighthouseScore.options.theme.describe,
         type: 'string',
     });
     yargs.option('target', {
-        describe: i18n(`commands.cms.subcommands.lighthouseScore.options.target.describe`),
+        describe: commands.cms.subcommands.lighthouseScore.options.target.describe,
         type: 'string',
         choices: ['desktop', 'mobile'],
         default: 'desktop',
     });
     yargs.option('verbose', {
-        describe: i18n(`commands.cms.subcommands.lighthouseScore.options.verbose.describe`),
+        describe: commands.cms.subcommands.lighthouseScore.options.verbose.describe,
         boolean: true,
         default: false,
     });
     yargs.example([
         [
             '$0 cms lighthouse-score --theme=my-theme',
-            i18n(`commands.cms.subcommands.lighthouseScore.examples.default`),
+            commands.cms.subcommands.lighthouseScore.examples.default,
         ],
     ]);
     return yargs;

package/commands/cms/lint.d.ts

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

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;