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

package/commands/cms/function/logs.js

@@ -0,0 +1,136 @@
+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);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    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.d.ts

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

package/commands/cms/getReactModule.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { retrieveDefaultModule } from '@hubspot/local-dev-lib/cms/modules';
+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 = commands.cms.subcommands.getReactModule.describe;
+async function handler(args) {
+    const { name, dest } = args;
+    trackCommandUsage('get-react-modules');
+    let moduleToRetrieve = name;
+    if (!moduleToRetrieve) {
+        let availableModules;
+        try {
+            availableModules = await retrieveDefaultModule();
+        }
+        catch (e) {
+            logError(e);
+        }
+        if (!availableModules) {
+            process.exit(EXIT_CODES.ERROR);
+        }
+        const moduleChoice = await listPrompt(commands.cms.subcommands.getReactModule.selectModulePrompt, {
+            choices: availableModules.map(module => module.name),
+        });
+        moduleToRetrieve = moduleChoice;
+    }
+    const destPath = dest
+        ? path.join(path.resolve(getCwd(), dest), `${moduleToRetrieve}`)
+        : path.join(getCwd(), `${moduleToRetrieve}`);
+    if (fs.existsSync(destPath)) {
+        uiLogger.error(commands.cms.subcommands.getReactModule.errors.pathExists(destPath));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        await retrieveDefaultModule(moduleToRetrieve, destPath);
+        uiLogger.success(commands.cms.subcommands.getReactModule.success.moduleDownloaded(moduleToRetrieve, destPath));
+    }
+    catch (e) {
+        const isBadRequestError = e?.cause?.code === 'ERR_BAD_REQUEST';
+        if (isBadRequestError) {
+            uiLogger.error(commands.cms.subcommands.getReactModule.errors.invalidName);
+        }
+        else {
+            logError(e);
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function cmsGetReactModuleBuilder(yargs) {
+    yargs.positional('name', {
+        describe: commands.cms.subcommands.getReactModule.positionals.name.describe,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.getReactModule.positionals.dest.describe,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(cmsGetReactModuleBuilder, command, describe, {
+    useGlobalOptions: true,
+});
+const cmsGetReactModuleCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default cmsGetReactModuleCommand;

package/commands/cms/lighthouseScore.d.ts

@@ -0,0 +1,8 @@
+import { AccountArgs, CommonArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+type LighthouseScoreArgs = CommonArgs & AccountArgs & EnvironmentArgs & {
+    theme?: string;
+    target: string;
+    verbose: boolean;
+};
+declare const cmslighthouseScoreCommand: YargsCommandModule<unknown, LighthouseScoreArgs>;
+export default cmslighthouseScoreCommand;

package/commands/cms/lighthouseScore.js

@@ -0,0 +1,281 @@
+import SpinniesManager from '../../lib/ui/SpinniesManager.js';
+import { promptUser } from '../../lib/prompts/promptUtils.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';
+import { uiLink } from '../../lib/ui/index.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { renderTable } from '../../ui/render.js';
+const DEFAULT_TABLE_HEADER = [
+    'Accessibility',
+    'Best practices',
+    'Performace',
+    'PWA',
+    'SEO',
+];
+const EMPTY_SCORE = {
+    accessibilityScore: 0,
+    bestPracticesScore: 0,
+    performanceScore: 0,
+    pwaScore: 0,
+    seoScore: 0,
+    runWarnings: [],
+    auditDetails: null,
+    emulatedFormFactor: '',
+    templatePath: null,
+    link: null,
+};
+const command = 'lighthouse-score [--theme]';
+const describe = undefined;
+async function selectTheme(accountId) {
+    let themes = [];
+    try {
+        const { data: result } = await fetchThemes(accountId, {
+            limit: 500,
+            sorting: 'MOST_USED',
+        });
+        if (result && result.objects) {
+            themes = result.objects
+                .map(({ theme }) => theme.path)
+                .filter(themePath => !themePath.startsWith(HUBSPOT_FOLDER) &&
+                !themePath.startsWith(MARKETPLACE_FOLDER));
+        }
+    }
+    catch (err) {
+        uiLogger.error(commands.cms.subcommands.lighthouseScore.errors.failedToFetchThemes);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const { theme: selectedTheme } = await promptUser([
+        {
+            type: 'list',
+            name: 'theme',
+            message: commands.cms.subcommands.lighthouseScore.info.promptMessage,
+            choices: themes,
+        },
+    ]);
+    return selectedTheme;
+}
+async function handler(args) {
+    const { target, verbose, theme, derivedAccountId } = args;
+    const includeDesktopScore = target === 'desktop' || !verbose;
+    const includeMobileScore = target === 'mobile' || !verbose;
+    let themeToCheck = theme;
+    if (themeToCheck) {
+        let isValidTheme = false;
+        try {
+            const { data: result } = await fetchThemes(derivedAccountId);
+            if (result && result.objects) {
+                isValidTheme = result.objects.some(({ theme }) => theme.path === themeToCheck);
+            }
+        }
+        catch (err) {
+            isValidTheme = false;
+        }
+        if (!isValidTheme) {
+            uiLogger.error(commands.cms.subcommands.lighthouseScore.errors.themeNotFound(themeToCheck));
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    else {
+        themeToCheck = await selectTheme(derivedAccountId);
+        uiLogger.log('');
+    }
+    // Kick off the scoring
+    let requestResult;
+    try {
+        const { data } = await requestLighthouseScore(derivedAccountId, {
+            themePath: themeToCheck,
+        });
+        requestResult = data;
+    }
+    catch (err) {
+        uiLogger.debug(err);
+    }
+    if (!requestResult || !requestResult.mobileId || !requestResult.desktopId) {
+        uiLogger.error(commands.cms.subcommands.lighthouseScore.errors.failedToGetLighthouseScore);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Poll till scoring is finished
+    try {
+        SpinniesManager.add('lighthouseScore', {
+            text: commands.cms.subcommands.lighthouseScore.info.generatingScore(themeToCheck),
+        });
+        async function checkScoreStatus() {
+            let desktopScoreStatus = 'COMPLETED';
+            if (includeDesktopScore) {
+                const { data } = await getLighthouseScoreStatus(derivedAccountId, {
+                    themeId: requestResult.desktopId,
+                });
+                desktopScoreStatus = data;
+            }
+            let mobileScoreStatus = 'COMPLETED';
+            if (includeDesktopScore) {
+                const { data } = await getLighthouseScoreStatus(derivedAccountId, {
+                    themeId: requestResult.mobileId,
+                });
+                mobileScoreStatus = data;
+            }
+            if (desktopScoreStatus === 'REQUESTED' ||
+                mobileScoreStatus === 'REQUESTED') {
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                await checkScoreStatus();
+            }
+        }
+        await checkScoreStatus();
+        SpinniesManager.remove('lighthouseScore');
+    }
+    catch (err) {
+        uiLogger.debug(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Fetch the scoring results
+    let desktopScoreResult;
+    let mobileScoreResult;
+    let verboseViewAverageScoreResult;
+    try {
+        const params = { isAverage: !verbose };
+        if (includeDesktopScore) {
+            const { data } = await getLighthouseScore(derivedAccountId, {
+                ...params,
+                desktopId: requestResult.desktopId,
+            });
+            desktopScoreResult = data;
+        }
+        if (includeMobileScore) {
+            const { data } = await getLighthouseScore(derivedAccountId, {
+                ...params,
+                mobileId: requestResult.mobileId,
+            });
+            mobileScoreResult = data;
+        }
+        // This is needed to show the average scores above the verbose output
+        if (verbose) {
+            const { data } = await getLighthouseScore(derivedAccountId, {
+                ...params,
+                isAverage: true,
+                desktopId: includeDesktopScore ? requestResult.desktopId : undefined,
+                mobileId: includeMobileScore ? requestResult.mobileId : undefined,
+            });
+            verboseViewAverageScoreResult = data;
+        }
+    }
+    catch (err) {
+        uiLogger.error(commands.cms.subcommands.lighthouseScore.errors.failedToGetLighthouseScore);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (verbose) {
+        const scoreResult = target === 'desktop' ? desktopScoreResult : mobileScoreResult;
+        if (!verboseViewAverageScoreResult || !scoreResult) {
+            uiLogger.error(commands.cms.subcommands.lighthouseScore.errors
+                .failedToGetLighthouseScore);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        uiLogger.log(commands.cms.subcommands.lighthouseScore.info.themeToCheckTitle(themeToCheck, target));
+        const scores = verboseViewAverageScoreResult.scores
+            ? verboseViewAverageScoreResult.scores[0]
+            : EMPTY_SCORE;
+        const averageTableData = [
+            [
+                scores.accessibilityScore,
+                scores.bestPracticesScore,
+                scores.performanceScore,
+                scores.pwaScore,
+                scores.seoScore,
+            ],
+        ];
+        renderTable(DEFAULT_TABLE_HEADER, averageTableData);
+        uiLogger.log('');
+        uiLogger.log(commands.cms.subcommands.lighthouseScore.info.pageTemplateScoreTitle);
+        const templateTableData = scoreResult.scores.map(score => {
+            return [
+                score.templatePath,
+                score.accessibilityScore,
+                score.bestPracticesScore,
+                score.performanceScore,
+                score.pwaScore,
+                score.seoScore,
+            ];
+        });
+        renderTable(['Template path', ...DEFAULT_TABLE_HEADER], templateTableData);
+        uiLogger.log('');
+        uiLogger.log(commands.cms.subcommands.lighthouseScore.info.lighthouseLinksTitle);
+        scoreResult.scores.forEach(score => {
+            if (score.templatePath && score.link) {
+                uiLogger.log(` ${uiLink(score.templatePath, score.link)}`);
+            }
+        });
+        if (scoreResult.failedTemplatePaths.length) {
+            uiLogger.log('');
+            uiLogger.error(commands.cms.subcommands.lighthouseScore.info.failedTemplatePathsTitle);
+            scoreResult.failedTemplatePaths.forEach(failedTemplatePath => {
+                uiLogger.log(` ${failedTemplatePath}`);
+            });
+        }
+        uiLogger.log('');
+        uiLogger.info(commands.cms.subcommands.lighthouseScore.info.targetDeviceNote(target));
+    }
+    else {
+        uiLogger.log(commands.cms.subcommands.lighthouseScore.info.themeTitle(themeToCheck));
+        const getTableData = (target, scoreResult) => {
+            const scores = scoreResult?.scores ? scoreResult.scores[0] : EMPTY_SCORE;
+            return [
+                target,
+                scores.accessibilityScore,
+                scores.bestPracticesScore,
+                scores.performanceScore,
+                scores.pwaScore,
+                scores.seoScore,
+            ];
+        };
+        const tableData = [
+            getTableData('desktop', desktopScoreResult),
+            getTableData('mobile', mobileScoreResult),
+        ];
+        renderTable(['Target', ...DEFAULT_TABLE_HEADER], tableData);
+        uiLogger.log('');
+        uiLogger.info(commands.cms.subcommands.lighthouseScore.info.verboseOptionNote);
+    }
+    uiLogger.log('');
+    uiLogger.log(commands.cms.subcommands.lighthouseScore.info.poweredByLink);
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function cmslighthouseScoreBuilder(yargs) {
+    yargs.option('theme', {
+        describe: commands.cms.subcommands.lighthouseScore.options.theme.describe,
+        type: 'string',
+    });
+    yargs.option('target', {
+        describe: commands.cms.subcommands.lighthouseScore.options.target.describe,
+        type: 'string',
+        choices: ['desktop', 'mobile'],
+        default: 'desktop',
+    });
+    yargs.option('verbose', {
+        describe: commands.cms.subcommands.lighthouseScore.options.verbose.describe,
+        boolean: true,
+        default: false,
+    });
+    yargs.example([
+        [
+            '$0 cms lighthouse-score --theme=my-theme',
+            commands.cms.subcommands.lighthouseScore.examples.default,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(cmslighthouseScoreBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const cmslighthouseScoreCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default cmslighthouseScoreCommand;

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;