@hubspot/cli 7.7.0-experimental.2 → 7.7.0

package/lib/sandboxes.js

@@ -1,45 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SANDBOX_API_TYPE_MAP = exports.SANDBOX_TYPE_MAP = exports.SYNC_TYPES = void 0;
-exports.getSandboxTypeAsString = getSandboxTypeAsString;
-exports.getHasSandboxesByType = getHasSandboxesByType;
-exports.getAvailableSyncTypes = getAvailableSyncTypes;
-exports.validateSandboxUsageLimits = validateSandboxUsageLimits;
-exports.handleSandboxCreateError = handleSandboxCreateError;
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const sandboxHubs_1 = require("@hubspot/local-dev-lib/api/sandboxHubs");
-const sandboxSync_1 = require("@hubspot/local-dev-lib/api/sandboxSync");
-const config_1 = require("@hubspot/local-dev-lib/config");
-const urls_1 = require("@hubspot/local-dev-lib/urls");
-const config_2 = require("@hubspot/local-dev-lib/constants/config");
-const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
-const index_1 = require("@hubspot/local-dev-lib/errors/index");
-const lang_1 = require("./lang");
-const ui_1 = require("./ui");
-const index_2 = require("./errorHandlers/index");
-exports.SYNC_TYPES = {
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { fetchTypes } from '@hubspot/local-dev-lib/api/sandboxSync';
+import { getAccountId, getConfigAccounts } 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 { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
+import { i18n } from './lang.js';
+import { uiAccountDescription } from './ui/index.js';
+import { logError } from './errorHandlers/index.js';
+export const SYNC_TYPES = {
     OBJECT_RECORDS: 'object-records',
 };
-exports.SANDBOX_TYPE_MAP = {
-    dev: config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-    developer: config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-    development: config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-    standard: config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+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,
 };
-exports.SANDBOX_API_TYPE_MAP = {
-    [config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 1,
-    [config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 2,
+export const SANDBOX_API_TYPE_MAP = {
+    [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 1,
+    [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 2,
 };
-function getSandboxTypeAsString(accountType) {
-    if (accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
+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';
 }
-function getHasSandboxesByType(parentAccountConfig, type) {
-    const id = (0, getAccountIdentifier_1.getAccountIdentifier)(parentAccountConfig);
-    const parentPortalId = (0, config_1.getAccountId)(id);
-    const accountsList = (0, config_1.getConfigAccounts)() || [];
+export function getHasSandboxesByType(parentAccountConfig, type) {
+    const id = getAccountIdentifier(parentAccountConfig);
+    const parentPortalId = getAccountId(id);
+    const accountsList = getConfigAccounts() || [];
     for (const portal of accountsList) {
         if ((portal.parentAccountId !== null ||
             portal.parentAccountId !== undefined) &&
@@ -52,44 +48,44 @@ function getHasSandboxesByType(parentAccountConfig, type) {
     return false;
 }
 // Fetches available sync types for a given sandbox portal
-async function getAvailableSyncTypes(parentAccountConfig, config) {
-    const parentId = (0, getAccountIdentifier_1.getAccountIdentifier)(parentAccountConfig);
-    const parentPortalId = (0, config_1.getAccountId)(parentId);
-    const id = (0, getAccountIdentifier_1.getAccountIdentifier)(config);
-    const portalId = (0, config_1.getAccountId)(id);
+export async function getAvailableSyncTypes(parentAccountConfig, config) {
+    const parentId = getAccountIdentifier(parentAccountConfig);
+    const parentPortalId = getAccountId(parentId);
+    const id = getAccountIdentifier(config);
+    const portalId = getAccountId(id);
     if (!parentPortalId || !portalId) {
-        throw new Error((0, lang_1.i18n)(`lib.sandbox.sync.failure.syncTypeFetch`));
+        throw new Error(i18n(`lib.sandbox.sync.failure.syncTypeFetch`));
     }
-    const { data: { results: syncTypes }, } = await (0, sandboxSync_1.fetchTypes)(parentPortalId, portalId);
+    const { data: { results: syncTypes }, } = await fetchTypes(parentPortalId, portalId);
     if (!syncTypes) {
-        throw new Error((0, lang_1.i18n)(`lib.sandbox.sync.failure.syncTypeFetch`));
+        throw new Error(i18n(`lib.sandbox.sync.failure.syncTypeFetch`));
     }
     return syncTypes.map(t => ({ type: t.name }));
 }
-async function validateSandboxUsageLimits(accountConfig, sandboxType, env) {
-    const id = (0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig);
-    const accountId = (0, config_1.getAccountId)(id);
+export async function validateSandboxUsageLimits(accountConfig, sandboxType, env) {
+    const id = getAccountIdentifier(accountConfig);
+    const accountId = getAccountId(id);
     if (!accountId) {
-        throw new Error((0, lang_1.i18n)(`lib.sandbox.create.failure.usageLimitFetch`));
+        throw new Error(i18n(`lib.sandbox.create.failure.usageLimitFetch`));
     }
-    const { data: { usage }, } = await (0, sandboxHubs_1.getSandboxUsageLimits)(accountId);
+    const { data: { usage }, } = await getSandboxUsageLimits(accountId);
     if (!usage) {
-        throw new Error((0, lang_1.i18n)(`lib.sandbox.create.failure.usageLimitFetch`));
+        throw new Error(i18n(`lib.sandbox.create.failure.usageLimitFetch`));
     }
-    if (sandboxType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
+    if (sandboxType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
         if (usage['DEVELOPER'].available === 0) {
             const devSandboxLimit = usage['DEVELOPER'].limit;
             const plural = devSandboxLimit !== 1;
-            const hasDevelopmentSandboxes = getHasSandboxesByType(accountConfig, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
+            const hasDevelopmentSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
             if (hasDevelopmentSandboxes) {
-                throw new Error((0, lang_1.i18n)(`lib.sandbox.create.failure.alreadyInConfig.developer.${plural ? 'other' : 'one'}`, {
+                throw new Error(i18n(`lib.sandbox.create.failure.alreadyInConfig.developer.${plural ? 'other' : 'one'}`, {
                     accountName: accountConfig.name || accountId,
                     limit: devSandboxLimit,
                 }));
             }
             else {
-                const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)(env);
-                throw new Error((0, lang_1.i18n)(`lib.sandbox.create.failure.limit.developer.${plural ? 'other' : 'one'}`, {
+                const baseUrl = getHubSpotWebsiteOrigin(env);
+                throw new Error(i18n(`lib.sandbox.create.failure.limit.developer.${plural ? 'other' : 'one'}`, {
                     accountName: accountConfig.name || accountId,
                     limit: devSandboxLimit,
                     link: `${baseUrl}/sandboxes-developer/${accountId}/development`,
@@ -97,20 +93,20 @@ async function validateSandboxUsageLimits(accountConfig, sandboxType, env) {
             }
         }
     }
-    if (sandboxType === config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX) {
+    if (sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX) {
         if (usage['STANDARD'].available === 0) {
             const standardSandboxLimit = usage['STANDARD'].limit;
             const plural = standardSandboxLimit !== 1;
-            const hasStandardSandboxes = getHasSandboxesByType(accountConfig, config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX);
+            const hasStandardSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX);
             if (hasStandardSandboxes) {
-                throw new Error((0, lang_1.i18n)(`lib.sandbox.create.failure.alreadyInConfig.standard.${plural ? 'other' : 'one'}`, {
+                throw new Error(i18n(`lib.sandbox.create.failure.alreadyInConfig.standard.${plural ? 'other' : 'one'}`, {
                     accountName: accountConfig.name || accountId,
                     limit: standardSandboxLimit,
                 }));
             }
             else {
-                const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)(env);
-                throw new Error((0, lang_1.i18n)(`lib.sandbox.create.failure.limit.standard.${plural ? 'other' : 'one'}`, {
+                const baseUrl = getHubSpotWebsiteOrigin(env);
+                throw new Error(i18n(`lib.sandbox.create.failure.limit.standard.${plural ? 'other' : 'one'}`, {
                     accountName: accountConfig.name || accountId,
                     limit: standardSandboxLimit,
                     link: `${baseUrl}/sandboxes-developer/${accountId}/standard`,
@@ -119,45 +115,45 @@ async function validateSandboxUsageLimits(accountConfig, sandboxType, env) {
         }
     }
 }
-function handleSandboxCreateError(err, env, name, accountId) {
-    if ((0, index_1.isMissingScopeError)(err)) {
-        logger_1.logger.error((0, lang_1.i18n)(`lib.sandbox.create.failure.scopes.message`, {
-            accountName: (0, ui_1.uiAccountDescription)(accountId),
+export function handleSandboxCreateError(err, env, name, accountId) {
+    if (isMissingScopeError(err)) {
+        logger.error(i18n(`lib.sandbox.create.failure.scopes.message`, {
+            accountName: uiAccountDescription(accountId),
         }));
-        const websiteOrigin = (0, urls_1.getHubSpotWebsiteOrigin)(env);
+        const websiteOrigin = getHubSpotWebsiteOrigin(env);
         const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-        logger_1.logger.info((0, lang_1.i18n)(`lib.sandbox.create.failure.scopes.instructions`, {
-            accountName: (0, ui_1.uiAccountDescription)(accountId),
+        logger.info(i18n(`lib.sandbox.create.failure.scopes.instructions`, {
+            accountName: uiAccountDescription(accountId),
             url,
         }));
     }
-    else if ((0, index_1.isSpecifiedError)(err, {
+    else if (isSpecifiedError(err, {
         statusCode: 403,
         category: 'BANNED',
         subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
     })) {
-        logger_1.logger.log('');
-        logger_1.logger.error((0, lang_1.i18n)(`lib.sandbox.create.failure.invalidUser`, {
+        logger.log('');
+        logger.error(i18n(`lib.sandbox.create.failure.invalidUser`, {
             accountName: name,
-            parentAccountName: (0, ui_1.uiAccountDescription)(accountId),
+            parentAccountName: uiAccountDescription(accountId),
         }));
-        logger_1.logger.log('');
+        logger.log('');
     }
-    else if ((0, index_1.isSpecifiedError)(err, {
+    else if (isSpecifiedError(err, {
         statusCode: 403,
         category: 'BANNED',
         subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
     })) {
-        logger_1.logger.log('');
-        logger_1.logger.error((0, lang_1.i18n)(`lib.sandbox.create.failure.403Gating`, {
+        logger.log('');
+        logger.error(i18n(`lib.sandbox.create.failure.403Gating`, {
             accountName: name,
-            parentAccountName: (0, ui_1.uiAccountDescription)(accountId),
+            parentAccountName: uiAccountDescription(accountId),
             accountId,
         }));
-        logger_1.logger.log('');
+        logger.log('');
     }
     else {
-        (0, index_2.logError)(err);
+        logError(err);
     }
     throw err;
 }

package/lib/schema.js

@@ -1,30 +1,27 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logSchemas = logSchemas;
-exports.listSchemas = listSchemas;
-const chalk_1 = __importDefault(require("chalk"));
-const table_1 = require("table");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const customObjects_1 = require("@hubspot/local-dev-lib/api/customObjects");
-function logSchemas(schemas) {
+import chalk from 'chalk';
+import { table, getBorderCharacters } from 'table';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { fetchObjectSchemas } from '@hubspot/local-dev-lib/api/customObjects';
+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) {
+        logger.log('No Schemas were found');
+        return;
+    }
     data.unshift([
-        chalk_1.default.bold('Label'),
-        chalk_1.default.bold('Name'),
-        chalk_1.default.bold('objectTypeId'),
+        chalk.bold('Label'),
+        chalk.bold('Name'),
+        chalk.bold('objectTypeId'),
     ]);
     const tableConfig = {
         singleLine: true,
-        border: (0, table_1.getBorderCharacters)('honeywell'),
+        border: getBorderCharacters('honeywell'),
     };
-    logger_1.logger.log(data.length ? (0, table_1.table)(data, tableConfig) : 'No Schemas were found');
+    logger.log(table(data, tableConfig));
 }
-async function listSchemas(accountId) {
-    const { data } = await (0, customObjects_1.fetchObjectSchemas)(accountId);
+export async function listSchemas(accountId) {
+    const { data } = await fetchObjectSchemas(accountId);
     logSchemas(data.results);
 }

package/lib/serverlessLogs.js

@@ -1,23 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tailLogs = tailLogs;
-exports.outputBuildLog = outputBuildLog;
-const https_1 = __importDefault(require("https"));
-const chalk_1 = __importDefault(require("chalk"));
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const index_1 = require("@hubspot/local-dev-lib/errors/index");
-const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
-const config_1 = require("@hubspot/local-dev-lib/config");
-const localDevAuth_1 = require("@hubspot/local-dev-lib/api/localDevAuth");
-const serverlessFunctionLogs_1 = require("./ui/serverlessFunctionLogs");
-const index_2 = require("./errorHandlers/index");
-const SpinniesManager_1 = __importDefault(require("./ui/SpinniesManager"));
-const process_1 = require("./process");
-const exitCodes_1 = require("./enums/exitCodes");
-const lang_1 = require("./lang");
+import https from 'https';
+import chalk from 'chalk';
+import { logger } from '@hubspot/local-dev-lib/logger';
+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 { getAccountConfig } 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 { EXIT_CODES } from './enums/exitCodes.js';
+import { i18n } from './lang.js';
 const TAIL_DELAY = 5000;
 function base64EncodeString(valueToEncode) {
     if (typeof valueToEncode !== 'string') {
@@ -28,51 +21,51 @@ function base64EncodeString(valueToEncode) {
 }
 function handleUserInput() {
     const onTerminate = async () => {
-        SpinniesManager_1.default.remove('tailLogs');
-        SpinniesManager_1.default.remove('stopMessage');
-        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+        SpinniesManager.remove('tailLogs');
+        SpinniesManager.remove('stopMessage');
+        process.exit(EXIT_CODES.SUCCESS);
     };
-    (0, process_1.handleExit)(onTerminate);
-    (0, process_1.handleKeypress)(key => {
+    handleExit(onTerminate);
+    handleKeypress(key => {
         if ((key.ctrl && key.name == 'c') || key.name === 'q') {
             onTerminate();
         }
     });
 }
 async function verifyAccessKeyAndUserAccess(accountId, scopeGroup) {
-    const accountConfig = (0, config_1.getAccountConfig)(accountId);
+    const accountConfig = getAccountConfig(accountId);
     if (!accountConfig) {
         return;
     }
     const { authType } = accountConfig;
-    if (authType !== auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
+    if (authType !== PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
         return;
     }
     let scopesData;
     try {
-        const resp = await (0, localDevAuth_1.fetchScopeData)(accountId, scopeGroup);
+        const resp = await fetchScopeData(accountId, scopeGroup);
         scopesData = resp.data;
     }
     catch (e) {
-        logger_1.logger.debug((0, lang_1.i18n)(`lib.serverless.verifyAccessKeyAndUserAccess.fetchScopeDataError`, {
+        logger.debug(i18n(`lib.serverless.verifyAccessKeyAndUserAccess.fetchScopeDataError`, {
             scopeGroup,
         }));
-        logger_1.logger.debug(e);
+        logger.debug(e);
         return;
     }
     const { portalScopesInGroup, userScopesInGroup } = scopesData;
     if (!portalScopesInGroup.length) {
-        logger_1.logger.error((0, lang_1.i18n)(`lib.serverless.verifyAccessKeyAndUserAccess.portalMissingScope`));
+        logger.error(i18n(`lib.serverless.verifyAccessKeyAndUserAccess.portalMissingScope`));
         return;
     }
     if (!portalScopesInGroup.every(s => userScopesInGroup.includes(s))) {
-        logger_1.logger.error((0, lang_1.i18n)(`lib.serverless.verifyAccessKeyAndUserAccess.userMissingScope`));
+        logger.error(i18n(`lib.serverless.verifyAccessKeyAndUserAccess.userMissingScope`));
     }
     else {
-        logger_1.logger.error((0, lang_1.i18n)(`lib.serverless.verifyAccessKeyAndUserAccess.genericMissingScope`));
+        logger.error(i18n(`lib.serverless.verifyAccessKeyAndUserAccess.genericMissingScope`));
     }
 }
-async function tailLogs(accountId, name, fetchLatest, tailCall, compact = false) {
+export async function tailLogs(accountId, name, fetchLatest, tailCall, compact = false) {
     let initialAfter = '';
     try {
         const { data: latestLog } = await fetchLatest();
@@ -80,12 +73,12 @@ async function tailLogs(accountId, name, fetchLatest, tailCall, compact = false)
     }
     catch (e) {
         // A 404 means no latest log exists(never executed)
-        if ((0, index_1.isHubSpotHttpError)(e) && e.status !== 404) {
-            if ((0, index_1.isMissingScopeError)(e)) {
-                await verifyAccessKeyAndUserAccess(accountId, auth_1.SCOPE_GROUPS.CMS_FUNCTIONS);
+        if (isHubSpotHttpError(e) && e.status !== 404) {
+            if (isMissingScopeError(e)) {
+                await verifyAccessKeyAndUserAccess(accountId, SCOPE_GROUPS.CMS_FUNCTIONS);
             }
             else {
-                await (0, index_2.logError)(e, new index_2.ApiErrorContext({ accountId }));
+                await logError(e, new ApiErrorContext({ accountId }));
             }
         }
     }
@@ -98,15 +91,15 @@ async function tailLogs(accountId, name, fetchLatest, tailCall, compact = false)
             nextAfter = latestLog.paging.next.after;
         }
         catch (e) {
-            if ((0, index_1.isHubSpotHttpError)(e) && e.status !== 404) {
-                (0, index_2.logError)(e, new index_2.ApiErrorContext({
+            if (isHubSpotHttpError(e) && e.status !== 404) {
+                logError(e, new ApiErrorContext({
                     accountId,
                 }));
             }
-            process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+            process.exit(EXIT_CODES.SUCCESS);
         }
         if (latestLog && latestLog.results.length) {
-            (0, serverlessFunctionLogs_1.outputLogs)(latestLog, {
+            outputLogs(latestLog, {
                 compact,
             });
         }
@@ -114,25 +107,25 @@ async function tailLogs(accountId, name, fetchLatest, tailCall, compact = false)
             await tail(nextAfter);
         }, TAIL_DELAY);
     }
-    SpinniesManager_1.default.init();
-    SpinniesManager_1.default.add('tailLogs', {
+    SpinniesManager.init();
+    SpinniesManager.add('tailLogs', {
         text: `Following logs for ${name}`,
     });
-    SpinniesManager_1.default.add('stopMessage', {
-        text: `> Press ${chalk_1.default.bold('q')} to stop following`,
+    SpinniesManager.add('stopMessage', {
+        text: `> Press ${chalk.bold('q')} to stop following`,
         status: 'non-spinnable',
     });
     handleUserInput();
     await tail(initialAfter);
 }
-async function outputBuildLog(buildLogUrl) {
+export async function outputBuildLog(buildLogUrl) {
     if (!buildLogUrl) {
-        logger_1.logger.debug('Unable to display build output. No build log URL was provided.');
+        logger.debug('Unable to display build output. No build log URL was provided.');
         return '';
     }
     return new Promise(resolve => {
         try {
-            https_1.default
+            https
                 .get(buildLogUrl, response => {
                 if (response.statusCode === 404) {
                     resolve('');
@@ -142,16 +135,16 @@ async function outputBuildLog(buildLogUrl) {
                     data += chunk;
                 });
                 response.on('end', () => {
-                    logger_1.logger.log(data);
+                    logger.log(data);
                     resolve(data);
                 });
             })
                 .on('error', () => {
-                logger_1.logger.error('The build log could not be retrieved.');
+                logger.error('The build log could not be retrieved.');
             });
         }
         catch (e) {
-            logger_1.logger.error('The build log could not be retrieved.');
+            logger.error('The build log could not be retrieved.');
             resolve('');
         }
     });

package/lib/testUtils.js

@@ -1,23 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockHubSpotHttpResponse = mockHubSpotHttpResponse;
-exports.mockHubSpotHttpError = mockHubSpotHttpError;
-const axios_1 = require("axios");
-const HubSpotHttpError_1 = require("@hubspot/local-dev-lib/models/HubSpotHttpError");
+import { HubSpotHttpError } from '@hubspot/local-dev-lib/models/HubSpotHttpError';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-function mockHubSpotHttpResponse(data) {
+export function mockHubSpotHttpResponse(data) {
     return Promise.resolve({
         data,
         status: 200,
         statusText: 'OK',
         headers: {},
         config: {
-            headers: new axios_1.AxiosHeaders(),
+            headers: {},
         },
     });
 }
-function mockHubSpotHttpError(message, response) {
-    return new HubSpotHttpError_1.HubSpotHttpError(message, {
+export function mockHubSpotHttpError(message, response) {
+    return new HubSpotHttpError(message, {
         cause: { isAxiosError: true, response },
     });
 }

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

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