@hubspot/cli 6.2.1 → 6.2.2-experimental.0

package/lib/marketplace-validate.d.ts

@@ -0,0 +1,5 @@
+export function kickOffValidation(accountId: any, assetType: any, src: any): Promise<number>;
+export function pollForValidationFinish(accountId: any, validationId: any): Promise<void>;
+export function fetchValidationResults(accountId: any, validationId: any): Promise<import("@hubspot/local-dev-lib/types/MarketplaceValidation").GetValidationResultsResponse>;
+export function processValidationErrors(i18nKey: any, validationResults: any): void;
+export function displayValidationResults(i18nKey: any, validationResults: any): void;

package/lib/marketplace-validate.js

@@ -1,145 +1,122 @@
+"use strict";
 const chalk = require('chalk');
-
 const { logger } = require('@hubspot/local-dev-lib/logger');
-const {
-  requestValidation,
-  getValidationStatus,
-  getValidationResults,
-} = require('@hubspot/local-dev-lib/api/marketplaceValidation');
+const { requestValidation, getValidationStatus, getValidationResults, } = require('@hubspot/local-dev-lib/api/marketplaceValidation');
 const { i18n } = require('./lang');
 const { EXIT_CODES } = require('./enums/exitCodes');
-
 const SLEEP_TIME = 2000;
-
 const kickOffValidation = async (accountId, assetType, src) => {
-  const requestGroup = 'EXTERNAL_DEVELOPER';
-  try {
-    const { data: requestResult } = await requestValidation(accountId, {
-      path: src,
-      assetType,
-      requestGroup,
-    });
-    return requestResult;
-  } catch (err) {
-    logger.debug(err);
-    process.exit(EXIT_CODES.ERROR);
-  }
+    const requestGroup = 'EXTERNAL_DEVELOPER';
+    try {
+        const { data: requestResult } = await requestValidation(accountId, {
+            path: src,
+            assetType,
+            requestGroup,
+        });
+        return requestResult;
+    }
+    catch (err) {
+        logger.debug(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
 };
-
 const pollForValidationFinish = async (accountId, validationId) => {
-  try {
-    const checkValidationStatus = async () => {
-      const { data: validationStatus } = await getValidationStatus(accountId, {
-        validationId,
-      });
-
-      if (validationStatus === 'REQUESTED') {
-        await new Promise(resolve => setTimeout(resolve, SLEEP_TIME));
+    try {
+        const checkValidationStatus = async () => {
+            const { data: validationStatus } = await getValidationStatus(accountId, {
+                validationId,
+            });
+            if (validationStatus === 'REQUESTED') {
+                await new Promise(resolve => setTimeout(resolve, SLEEP_TIME));
+                await checkValidationStatus();
+            }
+        };
         await checkValidationStatus();
-      }
-    };
-    await checkValidationStatus();
-  } catch (err) {
-    logger.debug(err);
-    process.exit(EXIT_CODES.ERROR);
-  }
+    }
+    catch (err) {
+        logger.debug(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
 };
-
 const fetchValidationResults = async (accountId, validationId) => {
-  try {
-    const { data: validationResults } = await getValidationResults(accountId, {
-      validationId,
-    });
-    return validationResults;
-  } catch (err) {
-    logger.debug(err);
-    process.exit(EXIT_CODES.ERROR);
-  }
+    try {
+        const { data: validationResults } = await getValidationResults(accountId, {
+            validationId,
+        });
+        return validationResults;
+    }
+    catch (err) {
+        logger.debug(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
 };
-
 const processValidationErrors = (i18nKey, validationResults) => {
-  if (validationResults.errors.length) {
-    const { assetPath, errors } = validationResults;
-
-    errors.forEach(err => {
-      if (err.failureReasonType === 'DOWNLOAD_EMPTY') {
-        logger.error(
-          i18n(`${i18nKey}.errors.invalidPath`, {
-            path: assetPath,
-          })
-        );
-      } else {
-        logger.error(`${err.context}`);
-      }
-    });
-    process.exit(EXIT_CODES.ERROR);
-  }
+    if (validationResults.errors.length) {
+        const { assetPath, errors } = validationResults;
+        errors.forEach(err => {
+            if (err.failureReasonType === 'DOWNLOAD_EMPTY') {
+                logger.error(i18n(`${i18nKey}.errors.invalidPath`, {
+                    path: assetPath,
+                }));
+            }
+            else {
+                logger.error(`${err.context}`);
+            }
+        });
+        process.exit(EXIT_CODES.ERROR);
+    }
 };
-
 const displayValidationResults = (i18nKey, validationResults) => {
-  const displayResults = checks => {
-    const displayFileInfo = (file, line) => {
-      if (file) {
-        logger.log(
-          i18n(`${i18nKey}.results.warnings.file`, {
-            file,
-          })
-        );
-      }
-      if (line) {
-        logger.log(
-          i18n(`${i18nKey}.results.warnings.lineNumber`, {
-            line,
-          })
-        );
-      }
-      return null;
+    const displayResults = checks => {
+        const displayFileInfo = (file, line) => {
+            if (file) {
+                logger.log(i18n(`${i18nKey}.results.warnings.file`, {
+                    file,
+                }));
+            }
+            if (line) {
+                logger.log(i18n(`${i18nKey}.results.warnings.lineNumber`, {
+                    line,
+                }));
+            }
+            return null;
+        };
+        if (checks) {
+            const { status, results } = checks;
+            if (status === 'FAIL') {
+                const failedValidations = results.filter(test => test.status === 'FAIL');
+                const warningValidations = results.filter(test => test.status === 'WARN');
+                failedValidations.forEach(val => {
+                    logger.error(`${val.message}`);
+                    displayFileInfo(val.file, val.line);
+                });
+                warningValidations.forEach(val => {
+                    logger.warn(`${val.message}`);
+                    displayFileInfo(val.file, val.line);
+                });
+            }
+            if (status === 'PASS') {
+                logger.success(i18n(`${i18nKey}.results.noErrors`));
+                results.forEach(test => {
+                    if (test.status === 'WARN') {
+                        logger.warn(`${test.message}`);
+                        displayFileInfo(test.file, test.line);
+                    }
+                });
+            }
+        }
+        return null;
     };
-
-    if (checks) {
-      const { status, results } = checks;
-
-      if (status === 'FAIL') {
-        const failedValidations = results.filter(
-          test => test.status === 'FAIL'
-        );
-        const warningValidations = results.filter(
-          test => test.status === 'WARN'
-        );
-        failedValidations.forEach(val => {
-          logger.error(`${val.message}`);
-          displayFileInfo(val.file, val.line);
-        });
-        warningValidations.forEach(val => {
-          logger.warn(`${val.message}`);
-          displayFileInfo(val.file, val.line);
-        });
-      }
-      if (status === 'PASS') {
-        logger.success(i18n(`${i18nKey}.results.noErrors`));
-
-        results.forEach(test => {
-          if (test.status === 'WARN') {
-            logger.warn(`${test.message}`);
-            displayFileInfo(test.file, test.line);
-          }
-        });
-      }
-    }
-    return null;
-  };
-
-  Object.keys(validationResults.results).forEach(type => {
-    logger.log(chalk.bold(i18n(`${i18nKey}.results.${type.toLowerCase()}`)));
-    displayResults(validationResults.results[type]);
-    logger.log();
-  });
+    Object.keys(validationResults.results).forEach(type => {
+        logger.log(chalk.bold(i18n(`${i18nKey}.results.${type.toLowerCase()}`)));
+        displayResults(validationResults.results[type]);
+        logger.log();
+    });
 };
-
 module.exports = {
-  kickOffValidation,
-  pollForValidationFinish,
-  fetchValidationResults,
-  processValidationErrors,
-  displayValidationResults,
+    kickOffValidation,
+    pollForValidationFinish,
+    fetchValidationResults,
+    processValidationErrors,
+    displayValidationResults,
 };

package/lib/oauth.d.ts

@@ -0,0 +1 @@
+export function authenticateWithOauth(configData: any): Promise<void>;

package/lib/oauth.js

@@ -1,106 +1,90 @@
+"use strict";
 const express = require('express');
 const open = require('open');
-const {
-  OAuth2Manager,
-} = require('@hubspot/local-dev-lib/models/OAuth2Manager');
+const { OAuth2Manager, } = require('@hubspot/local-dev-lib/models/OAuth2Manager');
 const { getAccountConfig } = require('@hubspot/local-dev-lib/config');
 const { addOauthToAccountConfig } = require('@hubspot/local-dev-lib/oauth');
 const { handleExit } = require('./process');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
 const { logger } = require('@hubspot/local-dev-lib/logger');
-const {
-  ENVIRONMENTS,
-} = require('@hubspot/local-dev-lib/constants/environments');
-
+const { ENVIRONMENTS, } = require('@hubspot/local-dev-lib/constants/environments');
 const PORT = 3000;
 const redirectUri = `http://localhost:${PORT}/oauth-callback`;
-
 const buildAuthUrl = oauthManager => {
-  return (
-    `${getHubSpotWebsiteOrigin(oauthManager.account.env)}/oauth/${
-      oauthManager.account.accountId
-    }/authorize` +
-    `?client_id=${encodeURIComponent(oauthManager.account.clientId)}` + // app's client ID
-    `&scope=${encodeURIComponent(oauthManager.account.scopes.join(' '))}` + // scopes being requested by the app
-    `&redirect_uri=${encodeURIComponent(redirectUri)}` // where to send the user after the consent page
-  );
+    return (`${getHubSpotWebsiteOrigin(oauthManager.account.env)}/oauth/${oauthManager.account.accountId}/authorize` +
+        `?client_id=${encodeURIComponent(oauthManager.account.clientId)}` + // app's client ID
+        `&scope=${encodeURIComponent(oauthManager.account.scopes.join(' '))}` + // scopes being requested by the app
+        `&redirect_uri=${encodeURIComponent(redirectUri)}` // where to send the user after the consent page
+    );
 };
-
 const handleServerOnProcessEnd = server => {
-  const shutdownServerIfRunning = () => {
-    server && server.close();
-  };
-
-  handleExit(shutdownServerIfRunning);
+    const shutdownServerIfRunning = () => {
+        server && server.close();
+    };
+    handleExit(shutdownServerIfRunning);
 };
-
-const authorize = async oauthManager => {
-  if (process.env.BROWSER !== 'none') {
-    open(buildAuthUrl(oauthManager), { url: true });
-  }
-
-  // eslint-disable-next-line no-async-promise-executor
-  return new Promise(async (resolve, reject) => {
-    let server;
-    const app = express();
-
-    app.get('/oauth-callback', async (req, res) => {
-      if (req.query.code) {
-        const authCodeProof = {
-          grant_type: 'authorization_code',
-          client_id: oauthManager.account.clientId,
-          client_secret: oauthManager.account.clientSecret,
-          redirect_uri: redirectUri,
-          code: req.query.code,
-        };
-        try {
-          await oauthManager.exchangeForTokens(authCodeProof);
-          res.send(`
+const authorize = async (oauthManager) => {
+    if (process.env.BROWSER !== 'none') {
+        open(buildAuthUrl(oauthManager), { url: true });
+    }
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise(async (resolve, reject) => {
+        let server;
+        const app = express();
+        app.get('/oauth-callback', async (req, res) => {
+            if (req.query.code) {
+                const authCodeProof = {
+                    grant_type: 'authorization_code',
+                    client_id: oauthManager.account.clientId,
+                    client_secret: oauthManager.account.clientSecret,
+                    redirect_uri: redirectUri,
+                    code: req.query.code,
+                };
+                try {
+                    await oauthManager.exchangeForTokens(authCodeProof);
+                    res.send(`
           <body>
             <h2>Authorization succeeded (you can close this page)</h2>
           </body>
           `);
-        } catch (e) {
-          res.send(`
+                }
+                catch (e) {
+                    res.send(`
           <body>
             <h2>Authorization failed (you can close this page)</h2>
           </body>
           `);
-        }
-      }
-      if (server) {
-        server.close();
-        server = null;
-      }
-      if (req.query.code) {
-        resolve();
-      } else {
-        reject();
-      }
+                }
+            }
+            if (server) {
+                server.close();
+                server = null;
+            }
+            if (req.query.code) {
+                resolve();
+            }
+            else {
+                reject();
+            }
+        });
+        server = app.listen(PORT, () => logger.log(`Waiting for authorization...`));
+        handleServerOnProcessEnd(server);
     });
-
-    server = app.listen(PORT, () => logger.log(`Waiting for authorization...`));
-
-    handleServerOnProcessEnd(server);
-  });
 };
-
 const setupOauth = accountConfig => {
-  const accountId = parseInt(accountConfig.portalId, 10);
-  const config = getAccountConfig(accountId) || {};
-  return new OAuth2Manager({
-    ...accountConfig,
-    environment: accountConfig.env || config.env || ENVIRONMENTS.PROD,
-  });
+    const accountId = parseInt(accountConfig.portalId, 10);
+    const config = getAccountConfig(accountId) || {};
+    return new OAuth2Manager({
+        ...accountConfig,
+        environment: accountConfig.env || config.env || ENVIRONMENTS.PROD,
+    });
 };
-
-const authenticateWithOauth = async configData => {
-  const oauthManager = setupOauth(configData);
-  logger.log('Authorizing');
-  await authorize(oauthManager);
-  addOauthToAccountConfig(oauthManager);
+const authenticateWithOauth = async (configData) => {
+    const oauthManager = setupOauth(configData);
+    logger.log('Authorizing');
+    await authorize(oauthManager);
+    addOauthToAccountConfig(oauthManager);
 };
-
 module.exports = {
-  authenticateWithOauth,
+    authenticateWithOauth,
 };

package/lib/polling.d.ts

@@ -0,0 +1 @@
+export function poll(callback: any, accountId: any, taskId: any): Promise<any>;

package/lib/polling.js

@@ -1,31 +1,29 @@
+"use strict";
 const { POLLING_DELAY, POLLING_STATUS } = require('./constants');
-
 const poll = (callback, accountId, taskId) => {
-  return new Promise((resolve, reject) => {
-    const pollInterval = setInterval(async () => {
-      try {
-        const { data: pollResp } = await callback(accountId, taskId);
-        const { status } = pollResp;
-
-        if (status === POLLING_STATUS.SUCCESS) {
-          clearInterval(pollInterval);
-          resolve(pollResp);
-        } else if (
-          status === POLLING_STATUS.ERROR ||
-          status === POLLING_STATUS.REVERTED ||
-          status === POLLING_STATUS.FAILURE
-        ) {
-          clearInterval(pollInterval);
-          reject(pollResp);
-        }
-      } catch (error) {
-        clearInterval(pollInterval);
-        reject(error);
-      }
-    }, POLLING_DELAY);
-  });
+    return new Promise((resolve, reject) => {
+        const pollInterval = setInterval(async () => {
+            try {
+                const { data: pollResp } = await callback(accountId, taskId);
+                const { status } = pollResp;
+                if (status === POLLING_STATUS.SUCCESS) {
+                    clearInterval(pollInterval);
+                    resolve(pollResp);
+                }
+                else if (status === POLLING_STATUS.ERROR ||
+                    status === POLLING_STATUS.REVERTED ||
+                    status === POLLING_STATUS.FAILURE) {
+                    clearInterval(pollInterval);
+                    reject(pollResp);
+                }
+            }
+            catch (error) {
+                clearInterval(pollInterval);
+                reject(error);
+            }
+        }, POLLING_DELAY);
+    });
 };
-
 module.exports = {
-  poll,
+    poll,
 };

package/lib/process.d.ts

@@ -0,0 +1,2 @@
+export function handleExit(callback: any): void;
+export function handleKeypress(callback: any): void;

package/lib/process.js

@@ -1,64 +1,50 @@
+"use strict";
 const readline = require('readline');
-const {
-  logger,
-  setLogLevel,
-  LOG_LEVEL,
-} = require('@hubspot/local-dev-lib/logger');
+const { logger, setLogLevel, LOG_LEVEL, } = require('@hubspot/local-dev-lib/logger');
 const { i18n } = require('./lang');
-
 const i18nKey = 'lib.process';
-
 const handleExit = callback => {
-  const terminationSignals = [
-    'beforeExit',
-    'SIGINT', // Terminal trying to interrupt (Ctrl + C)
-    'SIGUSR1', // Start Debugger User-defined signal 1
-    'SIGUSR2', // User-defined signal 2
-    'uncaughtException',
-    'SIGTERM', // Represents a graceful termination
-    'SIGHUP', // Parent terminal has been closed
-  ];
-  let exitInProgress = false;
-
-  terminationSignals.forEach(signal => {
-    process.removeAllListeners(signal);
-
-    process.on(signal, async () => {
-      // Prevent duplicate exit handling
-      if (!exitInProgress) {
-        exitInProgress = true;
-        const isSIGHUP = signal === 'SIGHUP';
-
-        // Prevent logs when terminal closes
-        if (isSIGHUP) {
-          setLogLevel(LOG_LEVEL.NONE);
-        }
-
-        logger.debug(i18n(`${i18nKey}.exitDebug`, { signal }));
-        await callback({ isSIGHUP });
-      }
+    const terminationSignals = [
+        'beforeExit',
+        'SIGINT', // Terminal trying to interrupt (Ctrl + C)
+        'SIGUSR1', // Start Debugger User-defined signal 1
+        'SIGUSR2', // User-defined signal 2
+        'uncaughtException',
+        'SIGTERM', // Represents a graceful termination
+        'SIGHUP', // Parent terminal has been closed
+    ];
+    let exitInProgress = false;
+    terminationSignals.forEach(signal => {
+        process.removeAllListeners(signal);
+        process.on(signal, async () => {
+            // Prevent duplicate exit handling
+            if (!exitInProgress) {
+                exitInProgress = true;
+                const isSIGHUP = signal === 'SIGHUP';
+                // Prevent logs when terminal closes
+                if (isSIGHUP) {
+                    setLogLevel(LOG_LEVEL.NONE);
+                }
+                logger.debug(i18n(`${i18nKey}.exitDebug`, { signal }));
+                await callback({ isSIGHUP });
+            }
+        });
     });
-  });
 };
-
 const handleKeypress = callback => {
-  readline.createInterface(process.stdin, process.stdout);
-  readline.emitKeypressEvents(process.stdin);
-
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(true);
-  }
-
-  process.stdin.removeAllListeners('keypress');
-
-  process.stdin.on('keypress', (str, key) => {
-    if (key) {
-      callback(key);
+    readline.createInterface(process.stdin, process.stdout);
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
     }
-  });
+    process.stdin.removeAllListeners('keypress');
+    process.stdin.on('keypress', (str, key) => {
+        if (key) {
+            callback(key);
+        }
+    });
 };
-
 module.exports = {
-  handleExit,
-  handleKeypress,
+    handleExit,
+    handleKeypress,
 };

package/lib/projectLogsManager.d.ts

@@ -0,0 +1,19 @@
+declare const _exports: ProjectLogsManager;
+export = _exports;
+declare class ProjectLogsManager {
+    reset(): void;
+    init(accountId: any): Promise<void>;
+    projectName: any;
+    accountId: any;
+    functions: any[] | undefined;
+    projectId: any;
+    fetchFunctionDetails(): Promise<void>;
+    getFunctionNames(): any[];
+    setFunction(functionName: any): void;
+    selectedFunction: any;
+    functionName: any;
+    appId: any;
+    endpointName: any;
+    method: any;
+    isPublicFunction: boolean | undefined;
+}