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

package/commands/cms/function/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 { HTTP_METHODS } 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.function.subcommands.create.describe;
+async function handler(args) {
+    const { derivedAccountId, name, dest } = args;
+    const assetType = 'function';
+    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.function.subcommands.create.errors.unusablePath(argsToPass.dest));
+        logError(e);
+        return;
+    }
+    try {
+        await asset.execute(argsToPass);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function functionCreateBuilder(yargs) {
+    yargs.positional('name', {
+        describe: commands.cms.subcommands.function.subcommands.create.positionals.name,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.function.subcommands.create.positionals.dest,
+        type: 'string',
+    });
+    yargs.option('functions-folder', {
+        describe: commands.cms.subcommands.function.subcommands.create.options
+            .functionsFolder,
+        type: 'string',
+    });
+    yargs.option('filename', {
+        describe: commands.cms.subcommands.function.subcommands.create.options.filename,
+        type: 'string',
+    });
+    yargs.option('endpoint-method', {
+        describe: commands.cms.subcommands.function.subcommands.create.options
+            .endpointMethod,
+        type: 'string',
+        choices: [...HTTP_METHODS],
+        default: 'GET',
+    });
+    yargs.option('endpoint-path', {
+        describe: commands.cms.subcommands.function.subcommands.create.options.endpointPath,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(functionCreateBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const functionCreateCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default functionCreateCommand;

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

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

package/commands/cms/function/deploy.js

@@ -0,0 +1,89 @@
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { buildPackage, getBuildStatus, } from '@hubspot/local-dev-lib/api/functions';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import SpinniesManager from '../../../lib/ui/SpinniesManager.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { logError, ApiErrorContext } from '../../../lib/errorHandlers/index.js';
+import { uiAccountDescription } from '../../../lib/ui/index.js';
+import { poll } from '../../../lib/polling.js';
+import { outputBuildLog } from '../../../lib/serverlessLogs.js';
+import { commands } from '../../../lang/en.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+function isFunctionBuildError(e) {
+    return (typeof e === 'object' && e !== null && 'status' in e && e.status === 'ERROR');
+}
+const command = 'deploy <path>';
+const describe = undefined; // Hidden command
+async function handler(args) {
+    const { path: functionPath, derivedAccountId } = args;
+    const splitFunctionPath = functionPath.split('.');
+    trackCommandUsage('function-deploy', undefined, derivedAccountId);
+    if (!splitFunctionPath.length ||
+        splitFunctionPath[splitFunctionPath.length - 1] !== 'functions') {
+        uiLogger.error(commands.cms.subcommands.function.subcommands.deploy.errors.notFunctionsFolder(functionPath));
+        return;
+    }
+    uiLogger.debug(commands.cms.subcommands.function.subcommands.deploy.debug.startingBuildAndDeploy(functionPath));
+    SpinniesManager.init();
+    SpinniesManager.add('loading', {
+        text: commands.cms.subcommands.function.subcommands.deploy.loading(functionPath, uiAccountDescription(derivedAccountId)),
+    });
+    try {
+        const { data: buildId } = await buildPackage(derivedAccountId, functionPath);
+        const successResp = await poll(() => getBuildStatus(derivedAccountId, Number(buildId)));
+        if (successResp) {
+            const buildTimeSeconds = successResp.buildTime
+                ? (successResp.buildTime / 1000).toFixed(2)
+                : 0;
+            SpinniesManager.succeed('loading');
+            if (successResp.cdnUrl) {
+                await outputBuildLog(successResp.cdnUrl);
+            }
+            uiLogger.success(commands.cms.subcommands.function.subcommands.deploy.success.deployed(functionPath, derivedAccountId, buildTimeSeconds));
+        }
+    }
+    catch (e) {
+        SpinniesManager.fail('loading', {
+            text: commands.cms.subcommands.function.subcommands.deploy.loadingFailed(functionPath, uiAccountDescription(derivedAccountId)),
+        });
+        if (isHubSpotHttpError(e) && e.status === 404) {
+            uiLogger.error(commands.cms.subcommands.function.subcommands.deploy.errors.noPackageJson(functionPath));
+        }
+        else if (isFunctionBuildError(e)) {
+            await outputBuildLog(e.cdnUrl);
+            uiLogger.error(commands.cms.subcommands.function.subcommands.deploy.errors.buildError(String(e.errorReason)));
+        }
+        else {
+            logError(e, new ApiErrorContext({
+                accountId: derivedAccountId,
+                request: functionPath,
+            }));
+        }
+    }
+}
+function functionDeployBuilder(yargs) {
+    yargs.positional('path', {
+        describe: commands.cms.subcommands.function.subcommands.deploy.positionals.path
+            .describe,
+        type: 'string',
+    });
+    yargs.example([
+        [
+            '$0 functions deploy myFunctionFolder.functions',
+            commands.cms.subcommands.function.subcommands.deploy.examples.default,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(functionDeployBuilder, command, describe, {
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const functionDeployCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default functionDeployCommand;

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

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule } from '../../../types/Yargs.js';
+export type FunctionListArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    json?: boolean;
+};
+declare const functionListCommand: YargsCommandModule<unknown, FunctionListArgs>;
+export default functionListCommand;

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/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;

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;