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

package/lib/prompts/uploadPrompt.js

@@ -1,32 +0,0 @@
-import path from 'path';
-import { getCwd } from '@hubspot/local-dev-lib/path';
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-export async function uploadPrompt(promptOptions = {}) {
-    return promptUser([
-        {
-            name: 'src',
-            message: lib.prompts.uploadPrompt.enterSrc,
-            when: !promptOptions.src,
-            default: '.',
-            validate: (input) => {
-                if (!input) {
-                    return lib.prompts.uploadPrompt.errors.srcRequired;
-                }
-                return true;
-            },
-        },
-        {
-            name: 'dest',
-            message: lib.prompts.uploadPrompt.enterDest,
-            when: !promptOptions.dest,
-            default: path.basename(getCwd()),
-            validate: (input) => {
-                if (!input) {
-                    return lib.prompts.uploadPrompt.errors.destRequired;
-                }
-                return true;
-            },
-        },
-    ]);
-}

package/lib/sandboxSync.d.ts

@@ -1,4 +0,0 @@
-import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
-import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
-import { SandboxSyncTask } from '../types/Sandboxes.js';
-export declare function syncSandbox(accountConfig: HubSpotConfigAccount, parentAccountConfig: HubSpotConfigAccount, env: Environment, syncTasks: Array<SandboxSyncTask>, slimInfoMessage?: boolean): Promise<void>;

package/lib/sandboxSync.js

@@ -1,102 +0,0 @@
-import SpinniesManager from './ui/SpinniesManager.js';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { uiLogger } from './ui/logger.js';
-import { initiateSync } from '@hubspot/local-dev-lib/api/sandboxSync';
-import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
-import { lib } from '../lang/en.js';
-import { getAvailableSyncTypes, getSandboxTypeAsString } from './sandboxes.js';
-import { debugError, logError, ApiErrorContext, } from './errorHandlers/index.js';
-import { uiAccountDescription, uiLine, uiCommandDisabledBanner, } from './ui/index.js';
-import { isDevelopmentSandbox } from './accountTypes.js';
-export async function syncSandbox(accountConfig, parentAccountConfig, env, syncTasks, slimInfoMessage = false) {
-    const accountId = accountConfig.accountId;
-    const parentAccountId = parentAccountConfig.accountId;
-    const isDevSandbox = isDevelopmentSandbox(accountConfig);
-    if (!accountId || !parentAccountId) {
-        throw new Error(lib.sandbox.sync.failure.invalidUser(uiAccountDescription(accountId), uiAccountDescription(parentAccountId)));
-    }
-    SpinniesManager.init({
-        succeedColor: 'white',
-    });
-    let availableSyncTasks = syncTasks;
-    const baseUrl = getHubSpotWebsiteOrigin(env);
-    const syncStatusUrl = `${baseUrl}/sandboxes-developer/${parentAccountId}/${getSandboxTypeAsString(accountConfig.accountType)}`;
-    try {
-        // If no sync tasks exist, fetch sync types based on default account. Parent account required for fetch
-        if (!availableSyncTasks ||
-            (typeof availableSyncTasks === 'object' &&
-                availableSyncTasks.length === 0)) {
-            availableSyncTasks = await getAvailableSyncTypes(parentAccountConfig, accountConfig);
-        }
-        SpinniesManager.add('sandboxSync', {
-            text: lib.sandbox.sync.loading.startSync,
-        });
-        await initiateSync(parentAccountId, accountId, availableSyncTasks, accountId);
-        const spinniesText = isDevSandbox
-            ? lib.sandbox.sync.loading.succeedDevSb(accountId)
-            : lib.sandbox.sync.loading.succeed(accountId);
-        SpinniesManager.succeed('sandboxSync', {
-            text: slimInfoMessage
-                ? lib.sandbox.sync.loading.successDevSbInfo(accountId, syncStatusUrl)
-                : spinniesText,
-        });
-    }
-    catch (err) {
-        debugError(err);
-        SpinniesManager.fail('sandboxSync', {
-            text: lib.sandbox.sync.loading.fail(accountId),
-        });
-        uiLogger.log('');
-        if (isSpecifiedError(err, {
-            statusCode: 403,
-            category: 'BANNED',
-            subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USER',
-        })) {
-            uiLogger.error(lib.sandbox.sync.failure.invalidUser(uiAccountDescription(accountId), uiAccountDescription(parentAccountId)));
-        }
-        else if (isSpecifiedError(err, {
-            statusCode: 429,
-            category: 'RATE_LIMITS',
-            subCategory: 'sandboxes-sync-api.SYNC_IN_PROGRESS',
-        })) {
-            uiLogger.error(lib.sandbox.sync.failure.syncInProgress(`${baseUrl}/sandboxes-developer/${parentAccountId}/syncactivitylog`));
-        }
-        else if (isSpecifiedError(err, {
-            statusCode: 403,
-            category: 'BANNED',
-            subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USERID',
-        })) {
-            // This will only trigger if a user is not a super admin of the target account.
-            uiLogger.error(lib.sandbox.sync.failure.notSuperAdmin(accountId));
-        }
-        else if (isSpecifiedError(err, {
-            statusCode: 404,
-            category: 'OBJECT_NOT_FOUND',
-            subCategory: 'SandboxErrors.SANDBOX_NOT_FOUND',
-        })) {
-            uiLogger.error(lib.sandbox.sync.failure.objectNotFound(accountId));
-        }
-        else if (isSpecifiedError(err, {
-            statusCode: 404,
-        })) {
-            uiCommandDisabledBanner('hs sandbox sync', 'https://developers.hubspot.com/docs/developer-tooling/local-development/hubspot-cli/project-commands');
-        }
-        else {
-            logError(err, new ApiErrorContext({
-                accountId: parentAccountId,
-                request: 'sandbox sync',
-            }));
-        }
-        uiLogger.log('');
-        throw err;
-    }
-    if (!slimInfoMessage) {
-        uiLogger.log('');
-        uiLine();
-        uiLogger.info(isDevSandbox
-            ? lib.sandbox.sync.info.syncMessageDevSb(syncStatusUrl)
-            : lib.sandbox.sync.info.syncMessage(syncStatusUrl));
-        uiLine();
-        uiLogger.log('');
-    }
-}

package/lib/sandboxes.d.ts

@@ -1,22 +0,0 @@
-import { AccountType, HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
-import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
-import { SandboxSyncTask, SandboxAccountType } from '../types/Sandboxes.js';
-export declare const SYNC_TYPES: {
-    readonly OBJECT_RECORDS: "object-records";
-};
-export declare const SANDBOX_TYPE_MAP: {
-    [key: string]: SandboxAccountType;
-};
-export declare const SANDBOX_API_TYPE_MAP: {
-    readonly STANDARD_SANDBOX: 1;
-    readonly DEVELOPMENT_SANDBOX: 2;
-};
-export declare const SANDBOX_TYPE_MAP_V2: {
-    readonly STANDARD_SANDBOX: "STANDARD";
-    readonly DEVELOPMENT_SANDBOX: "DEVELOPER";
-};
-export declare function getSandboxTypeAsString(accountType?: AccountType): string;
-export declare function getHasSandboxesByType(parentAccountConfig: HubSpotConfigAccount, type: AccountType): boolean;
-export declare function getAvailableSyncTypes(parentAccountConfig: HubSpotConfigAccount, config: HubSpotConfigAccount): Promise<Array<SandboxSyncTask>>;
-export declare function validateSandboxUsageLimits(accountConfig: HubSpotConfigAccount, sandboxType: AccountType, env: Environment): Promise<void>;
-export declare function handleSandboxCreateError(err: unknown, env: Environment, name: string, accountId: number): never;

package/lib/sandboxes.js

@@ -1,126 +0,0 @@
-import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { fetchTypes } from '@hubspot/local-dev-lib/api/sandboxSync';
-import { getAllConfigAccounts } from '@hubspot/local-dev-lib/config';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
-import { uiLogger } from './ui/logger.js';
-import { lib } from '../lang/en.js';
-import { logError } from './errorHandlers/index.js';
-import { uiAccountDescription } from './ui/index.js';
-export const SYNC_TYPES = {
-    OBJECT_RECORDS: 'object-records',
-};
-export const SANDBOX_TYPE_MAP = {
-    dev: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-    developer: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-    development: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-    standard: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
-};
-export const SANDBOX_API_TYPE_MAP = {
-    [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 1,
-    [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 2,
-};
-export const SANDBOX_TYPE_MAP_V2 = {
-    [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 'STANDARD',
-    [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 'DEVELOPER',
-};
-export function getSandboxTypeAsString(accountType) {
-    if (accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
-        return 'development'; // Only place we're using this specific name
-    }
-    return 'standard';
-}
-export function getHasSandboxesByType(parentAccountConfig, type) {
-    const parentPortalId = parentAccountConfig.accountId;
-    const accountsList = getAllConfigAccounts();
-    for (const portal of accountsList) {
-        if ((portal.parentAccountId !== null ||
-            portal.parentAccountId !== undefined) &&
-            portal.parentAccountId === parentPortalId &&
-            portal.accountType &&
-            portal.accountType === type) {
-            return true;
-        }
-    }
-    return false;
-}
-// Fetches available sync types for a given sandbox portal
-export async function getAvailableSyncTypes(parentAccountConfig, config) {
-    const parentPortalId = parentAccountConfig.accountId;
-    const portalId = config.accountId;
-    if (!parentPortalId || !portalId) {
-        throw new Error(lib.sandbox.sync.failure.syncTypeFetch);
-    }
-    const { data: { results: syncTypes }, } = await fetchTypes(parentPortalId, portalId);
-    if (!syncTypes) {
-        throw new Error(lib.sandbox.sync.failure.syncTypeFetch);
-    }
-    return syncTypes.map(t => ({ type: t.name }));
-}
-export async function validateSandboxUsageLimits(accountConfig, sandboxType, env) {
-    const accountId = accountConfig.accountId;
-    if (!accountId) {
-        throw new Error(lib.sandbox.create.failure.usageLimitsFetch);
-    }
-    const { data: { usage }, } = await getSandboxUsageLimits(accountId);
-    if (!usage) {
-        throw new Error(lib.sandbox.create.failure.usageLimitsFetch);
-    }
-    if (sandboxType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
-        if (usage['DEVELOPER'].available === 0) {
-            const devSandboxLimit = usage['DEVELOPER'].limit;
-            const hasDevelopmentSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
-            if (hasDevelopmentSandboxes) {
-                throw new Error(lib.sandbox.create.developer.failure.alreadyInConfig(accountId, devSandboxLimit));
-            }
-            else {
-                const baseUrl = getHubSpotWebsiteOrigin(env);
-                throw new Error(lib.sandbox.create.developer.failure.limit(accountId, devSandboxLimit, `${baseUrl}/sandboxes-developer/${accountId}/development`));
-            }
-        }
-    }
-    if (sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX) {
-        if (usage['STANDARD'].available === 0) {
-            const standardSandboxLimit = usage['STANDARD'].limit;
-            const hasStandardSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX);
-            if (hasStandardSandboxes) {
-                throw new Error(lib.sandbox.create.standard.failure.alreadyInConfig(accountId, standardSandboxLimit));
-            }
-            else {
-                const baseUrl = getHubSpotWebsiteOrigin(env);
-                throw new Error(lib.sandbox.create.standard.failure.limit(accountId, standardSandboxLimit, `${baseUrl}/sandboxes-developer/${accountId}/standard`));
-            }
-        }
-    }
-}
-export function handleSandboxCreateError(err, env, name, accountId) {
-    if (isMissingScopeError(err)) {
-        uiLogger.error(lib.sandbox.create.failure.scopes.message);
-        const websiteOrigin = getHubSpotWebsiteOrigin(env);
-        const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-        uiLogger.info(lib.sandbox.create.failure.scopes.instructions(uiAccountDescription(accountId), url));
-    }
-    else if (isSpecifiedError(err, {
-        statusCode: 403,
-        category: 'BANNED',
-        subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
-    })) {
-        uiLogger.log('');
-        uiLogger.error(lib.sandbox.create.failure.invalidUser(name, accountId));
-        uiLogger.log('');
-    }
-    else if (isSpecifiedError(err, {
-        statusCode: 403,
-        category: 'BANNED',
-        subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
-    })) {
-        uiLogger.log('');
-        uiLogger.error(lib.sandbox.create.failure['403Gating'](name, accountId));
-        uiLogger.log('');
-    }
-    else {
-        logError(err);
-    }
-    throw err;
-}

package/lib/schema.d.ts

@@ -1,3 +0,0 @@
-import { Schema } from '@hubspot/local-dev-lib/types/Schemas';
-export declare function logSchemas(schemas: Array<Schema>): void;
-export declare function listSchemas(accountId: number): Promise<void>;

package/lib/schema.js

@@ -1,27 +0,0 @@
-import chalk from 'chalk';
-import { table, getBorderCharacters } from 'table';
-import { fetchObjectSchemas } from '@hubspot/local-dev-lib/api/customObjects';
-import { uiLogger } from './ui/logger.js';
-export function logSchemas(schemas) {
-    const data = schemas
-        .map(r => [r.labels.singular, r.name, r.objectTypeId || ''])
-        .sort((a, b) => (a[1] > b[1] ? 1 : -1));
-    if (data.length === 0) {
-        uiLogger.log('No Schemas were found');
-        return;
-    }
-    data.unshift([
-        chalk.bold('Label'),
-        chalk.bold('Name'),
-        chalk.bold('objectTypeId'),
-    ]);
-    const tableConfig = {
-        singleLine: true,
-        border: getBorderCharacters('honeywell'),
-    };
-    uiLogger.log(table(data, tableConfig));
-}
-export async function listSchemas(accountId) {
-    const { data } = await fetchObjectSchemas(accountId);
-    logSchemas(data.results);
-}

package/lib/serverlessLogs.d.ts

@@ -1,4 +0,0 @@
-import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
-import { FunctionLog, GetFunctionLogsResponse } from '@hubspot/local-dev-lib/types/Functions';
-export declare function tailLogs(accountId: number, name: string, fetchLatest: () => HubSpotPromise<FunctionLog>, tailCall: (after?: string) => HubSpotPromise<GetFunctionLogsResponse>, compact?: boolean): Promise<void>;
-export declare function outputBuildLog(buildLogUrl: string): Promise<string>;

package/lib/serverlessLogs.js

@@ -1,154 +0,0 @@
-import https from 'https';
-import chalk from 'chalk';
-import { uiLogger } from './ui/logger.js';
-import { isHubSpotHttpError, isMissingScopeError, } from '@hubspot/local-dev-lib/errors/index';
-import { SCOPE_GROUPS, PERSONAL_ACCESS_KEY_AUTH_METHOD, } from '@hubspot/local-dev-lib/constants/auth';
-import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
-import { fetchScopeData } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { outputLogs } from './ui/serverlessFunctionLogs.js';
-import { logError, ApiErrorContext } from './errorHandlers/index.js';
-import SpinniesManager from './ui/SpinniesManager.js';
-import { handleExit, handleKeypress } from './process.js';
-import { lib } from '../lang/en.js';
-const TAIL_DELAY = 5000;
-function base64EncodeString(valueToEncode) {
-    if (typeof valueToEncode !== 'string') {
-        return valueToEncode;
-    }
-    const stringBuffer = Buffer.from(valueToEncode);
-    return encodeURIComponent(stringBuffer.toString('base64'));
-}
-async function verifyAccessKeyAndUserAccess(accountId, scopeGroup) {
-    const accountConfig = getConfigAccountById(accountId);
-    if (!accountConfig) {
-        return;
-    }
-    const { authType } = accountConfig;
-    if (authType !== PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
-        return;
-    }
-    let scopesData;
-    try {
-        const resp = await fetchScopeData(accountId, scopeGroup);
-        scopesData = resp.data;
-    }
-    catch (e) {
-        uiLogger.debug(lib.serverless.verifyAccessKeyAndUserAccess.fetchScopeDataError(scopeGroup));
-        uiLogger.debug(e);
-        return;
-    }
-    const { portalScopesInGroup, userScopesInGroup } = scopesData;
-    if (!portalScopesInGroup.length) {
-        uiLogger.error(lib.serverless.verifyAccessKeyAndUserAccess.portalMissingScope);
-        return;
-    }
-    if (!portalScopesInGroup.every(s => userScopesInGroup.includes(s))) {
-        uiLogger.error(lib.serverless.verifyAccessKeyAndUserAccess.userMissingScope);
-    }
-    else {
-        uiLogger.error(lib.serverless.verifyAccessKeyAndUserAccess.genericMissingScope);
-    }
-}
-export async function tailLogs(accountId, name, fetchLatest, tailCall, compact = false) {
-    let initialAfter = '';
-    try {
-        const { data: latestLog } = await fetchLatest();
-        initialAfter = latestLog && base64EncodeString(latestLog.id);
-    }
-    catch (e) {
-        // A 404 means no latest log exists(never executed)
-        if (isHubSpotHttpError(e) && e.status !== 404) {
-            if (isMissingScopeError(e)) {
-                await verifyAccessKeyAndUserAccess(accountId, SCOPE_GROUPS.CMS_FUNCTIONS);
-            }
-            else {
-                await logError(e, new ApiErrorContext({ accountId }));
-            }
-        }
-    }
-    return new Promise(resolve => {
-        function cleanup() {
-            SpinniesManager.remove('tailLogs');
-            SpinniesManager.remove('stopMessage');
-        }
-        let resolved = false;
-        const onTerminate = async () => {
-            if (resolved)
-                return;
-            resolved = true;
-            cleanup();
-            resolve();
-        };
-        handleExit(onTerminate);
-        handleKeypress(key => {
-            if ((key.ctrl && key.name == 'c') || key.name === 'q') {
-                onTerminate();
-            }
-        });
-        async function tail(after) {
-            let latestLog;
-            let nextAfter;
-            try {
-                const { data } = await tailCall(after);
-                latestLog = data;
-                nextAfter = latestLog.paging.next.after;
-            }
-            catch (e) {
-                if (isHubSpotHttpError(e) && e.status !== 404) {
-                    logError(e, new ApiErrorContext({
-                        accountId,
-                    }));
-                }
-                await onTerminate();
-                return;
-            }
-            if (latestLog && latestLog.results.length) {
-                outputLogs(latestLog, {
-                    compact,
-                });
-            }
-            setTimeout(async () => {
-                await tail(nextAfter);
-            }, TAIL_DELAY);
-        }
-        SpinniesManager.add('tailLogs', {
-            text: `Following logs for ${name}`,
-        });
-        SpinniesManager.add('stopMessage', {
-            text: `> Press ${chalk.bold('q')} to stop following`,
-            status: 'non-spinnable',
-        });
-        tail(initialAfter);
-    });
-}
-export async function outputBuildLog(buildLogUrl) {
-    if (!buildLogUrl) {
-        uiLogger.debug('Unable to display build output. No build log URL was provided.');
-        return '';
-    }
-    return new Promise(resolve => {
-        try {
-            https
-                .get(buildLogUrl, response => {
-                if (response.statusCode === 404) {
-                    resolve('');
-                }
-                let data = '';
-                response.on('data', chunk => {
-                    data += chunk;
-                });
-                response.on('end', () => {
-                    uiLogger.log(data);
-                    resolve(data);
-                });
-            })
-                .on('error', () => {
-                uiLogger.error('The build log could not be retrieved.');
-            });
-        }
-        catch (e) {
-            uiLogger.error('The build log could not be retrieved.');
-            resolve('');
-        }
-    });
-}

package/lib/testUtils.d.ts

@@ -1,14 +0,0 @@
-import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
-import { HubSpotHttpError } from '@hubspot/local-dev-lib/models/HubSpotHttpError';
-type MockErrorResponse = {
-    status: number;
-    data: {
-        message?: string;
-        errorType?: string;
-        category?: string;
-        subCategory?: string;
-    };
-};
-export declare function mockHubSpotHttpResponse<T>(data?: any): HubSpotPromise<T>;
-export declare function mockHubSpotHttpError(message: string, response: MockErrorResponse): HubSpotHttpError;
-export {};

package/lib/testUtils.js

@@ -1,18 +0,0 @@
-import { HubSpotHttpError } from '@hubspot/local-dev-lib/models/HubSpotHttpError';
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function mockHubSpotHttpResponse(data) {
-    return Promise.resolve({
-        data,
-        status: 200,
-        statusText: 'OK',
-        headers: {},
-        config: {
-            headers: {},
-        },
-    });
-}
-export function mockHubSpotHttpError(message, response) {
-    return new HubSpotHttpError(message, {
-        cause: { isAxiosError: true, response },
-    });
-}

package/lib/theme/__tests__/migrate.test.d.ts

@@ -1 +0,0 @@
-export {};