@bigcommerce/stencil-cli 8.3.0 → 8.4.0

package/lib/stencil-push.utils.js

@@ -1,26 +1,23 @@
-const _ = require('lodash');
-const async = require('async');
-const Inquirer = require('inquirer');
-const ProgressBar = require('progress');
-const uuid = require('uuid4');
-const os = require('os');
-
-const { THEME_PATH } = require('../constants');
-const Bundle = require('./stencil-bundle');
-const themeApiClient = require('./theme-api-client');
-const ThemeConfig = require('./theme-config');
-const StencilConfigManager = require('./StencilConfigManager');
+import * as _ from 'lodash-es';
+import async from 'async';
+import Inquirer from 'inquirer';
+import ProgressBar from 'progress';
+import uuid from 'uuid4';
+import os from 'os';
+import { THEME_PATH } from '../constants.js';
+import Bundle from './stencil-bundle.js';
+import themeApiClient from './theme-api-client.js';
+import ThemeConfig from './theme-config.js';
+import StencilConfigManager from './StencilConfigManager.js';
 
 const themeConfigManager = ThemeConfig.getInstance(THEME_PATH);
 const stencilConfigManager = new StencilConfigManager();
 const utils = {};
-
 const bar = new ProgressBar('Processing [:bar] :percent; ETA: :etas', {
     complete: '=',
     incomplete: ' ',
     total: 100,
 });
-
 function validateOptions(options = {}, fields = []) {
     for (const field of fields) {
         if (!_.has(options, field)) {
@@ -28,7 +25,6 @@ function validateOptions(options = {}, fields = []) {
         }
     }
 }
-
 utils.readStencilConfigFile = async (options) => {
     try {
         const config = await stencilConfigManager.read();
@@ -38,41 +34,31 @@ utils.readStencilConfigFile = async (options) => {
         throw err;
     }
 };
-
 utils.getStoreHash = async (options) => {
     validateOptions(options, ['config.normalStoreUrl']);
-
     const storeHash = await themeApiClient.getStoreHash({
         storeUrl: options.config.normalStoreUrl,
     });
-
     return { ...options, storeHash };
 };
-
 utils.getThemes = async (options) => {
     const {
         config: { accessToken },
         storeHash,
     } = options;
-
     const apiHost = options.apiHost || options.config.apiHost;
-
     const themes = await themeApiClient.getThemes({ accessToken, apiHost, storeHash });
-
     return { ...options, themes };
 };
-
 utils.generateBundle = async (options) => {
     if (options.bundleZipPath) {
         return options;
     }
-
     const output = options.saveBundleName
         ? { dest: THEME_PATH, name: options.saveBundleName }
         : { dest: os.tmpdir(), name: uuid() };
     const rawConfig = await themeConfigManager.getRawConfig();
     const bundle = new Bundle(THEME_PATH, themeConfigManager, rawConfig, output);
-
     try {
         const bundleZipPath = await bundle.initBundle();
         return { ...options, bundleZipPath };
@@ -81,7 +67,6 @@ utils.generateBundle = async (options) => {
         throw err;
     }
 };
-
 utils.uploadBundle = async (options) => {
     const {
         config: { accessToken },
@@ -89,9 +74,7 @@ utils.uploadBundle = async (options) => {
         storeHash,
         uploadBundleAgain,
     } = options;
-
     const apiHost = options.apiHost || options.config.apiHost;
-
     try {
         const result = await themeApiClient.postTheme({
             accessToken,
@@ -110,7 +93,6 @@ utils.uploadBundle = async (options) => {
         throw err;
     }
 };
-
 utils.notifyUserOfThemeLimitReachedIfNecessary = async (options) => {
     if (options.themeLimitReached && !options.deleteOldest) {
         console.log(
@@ -119,15 +101,12 @@ utils.notifyUserOfThemeLimitReachedIfNecessary = async (options) => {
                 "In order to proceed, you'll need to delete at least one theme.",
         );
     }
-
     return options;
 };
-
 utils.promptUserToDeleteThemesIfNecessary = async (options) => {
     if (!options.themeLimitReached) {
         return options;
     }
-
     if (options.deleteOldest) {
         const oldestTheme = options.themes
             .filter((theme) => theme.is_private && !theme.is_active)
@@ -136,10 +115,8 @@ utils.promptUserToDeleteThemesIfNecessary = async (options) => {
                 updated_at: new Date(theme.updated_at).valueOf(),
             }))
             .reduce((prev, current) => (prev.updated_at < current.updated_at ? prev : current));
-
         return { ...options, themeIdsToDelete: [oldestTheme.uuid] };
     }
-
     const questions = [
         {
             choices: options.themes.map((theme) => ({
@@ -159,10 +136,8 @@ utils.promptUserToDeleteThemesIfNecessary = async (options) => {
         },
     ];
     const answers = await Inquirer.prompt(questions);
-
     return { ...options, ...answers };
 };
-
 utils.deleteThemesIfNecessary = async (options) => {
     const {
         config: { accessToken },
@@ -170,13 +145,10 @@ utils.deleteThemesIfNecessary = async (options) => {
         themeLimitReached,
         themeIdsToDelete,
     } = options;
-
     const apiHost = options.apiHost || options.config.apiHost;
-
     if (!themeLimitReached) {
         return options;
     }
-
     try {
         const promises = themeIdsToDelete.map((themeId) =>
             themeApiClient.deleteThemeById({ accessToken, apiHost, storeHash, themeId }),
@@ -186,10 +158,8 @@ utils.deleteThemesIfNecessary = async (options) => {
         err.name = 'ThemeDeletionError';
         throw err;
     }
-
     return options;
 };
-
 utils.checkIfDeletionIsComplete = () => {
     return async.retryable(
         {
@@ -206,7 +176,6 @@ utils.checkIfDeletionIsComplete = () => {
         utils.checkIfThemeIsDeleted(),
     );
 };
-
 utils.checkIfThemeIsDeleted = () => async (options) => {
     const {
         themeLimitReached,
@@ -214,47 +183,34 @@ utils.checkIfThemeIsDeleted = () => async (options) => {
         storeHash,
         themeIdsToDelete,
     } = options;
-
     if (!themeLimitReached) {
         return options;
     }
-
     const apiHost = options.apiHost || options.config.apiHost;
-
     const result = await themeApiClient.getThemes({ accessToken, apiHost, storeHash });
-
     const themeStillExists = result.some((theme) => themeIdsToDelete.includes(theme.uuid));
-
     if (themeStillExists) {
         throw new Error('ThemeStillExists');
     }
-
     return options;
 };
-
 utils.uploadBundleAgainIfNecessary = async (options) => {
     if (!options.themeLimitReached) {
         return options;
     }
-
     return utils.uploadBundle({ ...options, uploadThemeAgain: true });
 };
-
 utils.notifyUserOfThemeUploadCompletion = async (options) => {
     console.log(`${'ok'.green} -- Theme Upload Finished`);
-
     return options;
 };
-
 utils.markJobProgressPercentage = (percentComplete) => {
     bar.update(percentComplete / 100);
 };
-
 utils.markJobComplete = () => {
     utils.markJobProgressPercentage(100);
     console.log(`${'ok'.green} -- Theme Processing Finished`);
 };
-
 utils.pollForJobCompletion = (resultFilter) => {
     return async.retryable(
         {
@@ -264,7 +220,6 @@ utils.pollForJobCompletion = (resultFilter) => {
                     utils.markJobProgressPercentage(err.message);
                     return true;
                 }
-
                 return false;
             },
             times: Number.POSITIVE_INFINITY,
@@ -272,7 +227,6 @@ utils.pollForJobCompletion = (resultFilter) => {
         utils.checkIfJobIsComplete(resultFilter),
     );
 };
-
 utils.checkIfJobIsComplete = (resultFilter) => async (options) => {
     const {
         config: { accessToken },
@@ -280,9 +234,7 @@ utils.checkIfJobIsComplete = (resultFilter) => async (options) => {
         bundleZipPath,
         jobId,
     } = options;
-
     const apiHost = options.apiHost || options.config.apiHost;
-
     const result = await themeApiClient.getJob({
         accessToken,
         apiHost,
@@ -291,17 +243,13 @@ utils.checkIfJobIsComplete = (resultFilter) => async (options) => {
         jobId,
         resultFilter,
     });
-
     utils.markJobComplete();
-
     return { ...options, ...result };
 };
-
 utils.promptUserWhetherToApplyTheme = async (options) => {
     if (options.activate) {
         return { ...options, applyTheme: true };
     }
-
     const questions = [
         {
             type: 'confirm',
@@ -311,10 +259,8 @@ utils.promptUserWhetherToApplyTheme = async (options) => {
         },
     ];
     const answers = await Inquirer.prompt(questions);
-
     return { ...options, ...answers };
 };
-
 utils.getChannels = async (options) => {
     const {
         config: { accessToken },
@@ -323,22 +269,17 @@ utils.getChannels = async (options) => {
         storeHash,
         applyTheme,
     } = options;
-
     const apiHost = options.apiHost || options.config.apiHost;
-
     if (!applyTheme || channelIds || channelId) {
         return options;
     }
-
     const channels = await themeApiClient.getStoreChannels({
         accessToken,
         apiHost,
         storeHash,
     });
-
     return { ...options, channels };
 };
-
 utils.getVariations = async (options) => {
     const {
         config: { accessToken },
@@ -347,20 +288,16 @@ utils.getVariations = async (options) => {
         applyTheme,
         activate,
     } = options;
-
     const apiHost = options.apiHost || options.config.apiHost;
-
     if (!applyTheme) {
         return options;
     }
-
     const variations = await themeApiClient.getVariationsByThemeId({
         accessToken,
         apiHost,
         themeId,
         storeHash,
     });
-
     // Activate the default variation
     if (activate === true) {
         return { ...options, variationId: variations[0].uuid };
@@ -368,42 +305,33 @@ utils.getVariations = async (options) => {
     // Activate the specified variation
     if (activate !== undefined) {
         const foundVariation = variations.find((item) => item.name === activate);
-
         if (!foundVariation || !foundVariation.uuid) {
             const availableOptionsStr = variations.map((item) => `${item.name}`).join(', ');
             throw new Error(
                 `Invalid theme variation provided! Available options: ${availableOptionsStr}.`,
             );
         }
-
         return { ...options, variationId: foundVariation.uuid };
     }
-
     // Didn't specify a variation explicitly, will ask the user later
     return { ...options, variations };
 };
-
 utils.promptUserForChannels = async (options) => {
     const { applyTheme, channelIds, channels, allChannels } = options;
-
     if (!applyTheme || channelIds) {
         return options;
     }
-
     if (allChannels) {
         const allIds = channels.map((chanel) => chanel.channel_id);
         return { ...options, channelIds: allIds };
     }
-
     const selectedChannelIds = await utils.promptUserToSelectChannels(channels);
     return { ...options, channelIds: selectedChannelIds };
 };
-
 utils.promptUserToSelectChannels = async (channels) => {
     if (channels.length < 2) {
         return [channels[0].channel_id];
     }
-
     const questions = [
         {
             type: 'checkbox',
@@ -415,27 +343,21 @@ utils.promptUserToSelectChannels = async (channels) => {
             })),
         },
     ];
-
     const answer = await Inquirer.prompt(questions);
     return answer.channelIds;
 };
-
 utils.promptUserForChannel = async (options) => {
     const { applyTheme, channelId, channels } = options;
-
     if (!applyTheme || channelId) {
         return options;
     }
-
     const selectedChannelId = await utils.promptUserToSelectChannel(channels);
     return { ...options, channelId: selectedChannelId };
 };
-
 utils.promptUserToSelectChannel = async (channels) => {
     if (channels.length < 2) {
         return channels[0].channel_id;
     }
-
     const questions = [
         {
             type: 'list',
@@ -447,16 +369,13 @@ utils.promptUserToSelectChannel = async (channels) => {
             })),
         },
     ];
-
     const answer = await Inquirer.prompt(questions);
     return answer.channelId;
 };
-
 utils.promptUserForVariation = async (options) => {
     if (!options.applyTheme || options.variationId) {
         return options;
     }
-
     const questions = [
         {
             type: 'list',
@@ -469,10 +388,8 @@ utils.promptUserForVariation = async (options) => {
         },
     ];
     const answers = await Inquirer.prompt(questions);
-
     return { ...options, ...answers };
 };
-
 utils.requestToApplyVariationWithRetrys = () => {
     return async.retryable(
         {
@@ -482,7 +399,6 @@ utils.requestToApplyVariationWithRetrys = () => {
                     console.log(`${'warning'.yellow} -- Theme Activation Timed Out; Retrying...`);
                     return true;
                 }
-
                 return false;
             },
             times: 3,
@@ -490,7 +406,6 @@ utils.requestToApplyVariationWithRetrys = () => {
         utils.requestToApplyVariation,
     );
 };
-
 utils.requestToApplyVariation = async (options) => {
     const {
         config: { accessToken },
@@ -498,9 +413,7 @@ utils.requestToApplyVariation = async (options) => {
         variationId,
         channelIds,
     } = options;
-
     const apiHost = options.apiHost || options.config.apiHost;
-
     if (options.applyTheme) {
         await themeApiClient.activateThemeByVariationId({
             variationId,
@@ -510,12 +423,9 @@ utils.requestToApplyVariation = async (options) => {
             accessToken,
         });
     }
-
     return options;
 };
-
 utils.notifyUserOfCompletion = (options, callback) => {
     callback(null, `Stencil Push Finished. Variation ID: ${options.variationId}`);
 };
-
-module.exports = utils;
+export default utils;

package/lib/stencil-start.js

@@ -1,22 +1,21 @@
-require('colors');
-const BrowserSync = require('browser-sync');
-const { promisify } = require('util');
-const path = require('path');
-
-const Cycles = require('./Cycles');
-const templateAssemblerModule = require('./template-assembler');
-const { PACKAGE_INFO, THEME_PATH } = require('../constants');
-const Server = require('../server');
-const StencilConfigManager = require('./StencilConfigManager');
-const ThemeConfig = require('./theme-config');
-const BuildConfigManager = require('./BuildConfigManager');
-const fsUtilsModule = require('./utils/fsUtils');
-const stencilPushUtilsModule = require('./stencil-push.utils');
-const cliCommonModule = require('./cliCommon');
-const themeApiClientModule = require('./theme-api-client');
-const storeSettingsApiClientModule = require('./store-settings-api-client');
-const LangHelper = require('./lang-helper');
-const LangValidator = require('./lang/validator');
+import 'colors';
+import BrowserSync from 'browser-sync';
+import { promisify } from 'util';
+import path from 'path';
+import Cycles from './Cycles.js';
+import templateAssemblerModule from './template-assembler.js';
+import { PACKAGE_INFO, THEME_PATH } from '../constants.js';
+import Server from '../server/index.js';
+import StencilConfigManager from './StencilConfigManager.js';
+import ThemeConfig from './theme-config.js';
+import BuildConfigManager from './BuildConfigManager.js';
+import fsUtilsModule from './utils/fsUtils.js';
+import stencilPushUtilsModule from './stencil-push.utils.js';
+import cliCommonModule from './cliCommon.js';
+import themeApiClientModule from './theme-api-client.js';
+import storeSettingsApiClientModule from './store-settings-api-client.js';
+import LangHelper from './lang-helper.js';
+import LangValidator from './lang/validator.js';
 
 class StencilStart {
     constructor({
@@ -53,16 +52,13 @@ class StencilStart {
 
     async run(cliOptions) {
         this.runBasicChecks(cliOptions);
-
         if (cliOptions.variation) {
             await this._themeConfigManager.setVariationByName(cliOptions.variation);
         }
         const initialStencilConfig = await this._stencilConfigManager.read();
         // Use initial (before updates) port for BrowserSync
         const browserSyncPort = initialStencilConfig.port;
-
         const channelUrl = await this.getChannelUrl(initialStencilConfig, cliOptions);
-
         const storeInfoFromAPI = await this._themeApiClient.checkCliVersion({
             storeUrl: channelUrl,
         });
@@ -70,16 +66,12 @@ class StencilStart {
             initialStencilConfig,
             storeInfoFromAPI,
         );
-
         this._storeSettingsLocale = await this.getStoreSettingsLocale(
             cliOptions,
             updatedStencilConfig,
         );
-
         await this.startLocalServer(cliOptions, updatedStencilConfig);
-
         this._logger.log(this.getStartUpInfo(updatedStencilConfig));
-
         await this.startBrowserSync(cliOptions, updatedStencilConfig, browserSyncPort);
     }
 
@@ -104,11 +96,9 @@ class StencilStart {
             accessToken,
             apiHost,
         });
-
         const channelId = cliOptions.channelId
             ? cliOptions.channelId
             : await this._stencilPushUtils.promptUserToSelectChannel(channels);
-
         const foundChannel = channels.find(
             (channel) => channel.channel_id === parseInt(channelId, 10),
         );
@@ -120,7 +110,6 @@ class StencilStart {
      */
     runBasicChecks(cliOptions) {
         this._cliCommon.checkNodeVersion();
-
         if (!this._fsUtils.existsSync(this._themeConfigManager.configPath)) {
             throw new Error(
                 'You must have a '.red +
@@ -128,7 +117,6 @@ class StencilStart {
                     'file in your top level theme directory.',
             );
         }
-
         // If the value is true it means that no variation was passed in.
         if (cliOptions.variation === true) {
             throw new Error('You have to specify a value for -v or --variation'.red);
@@ -165,7 +153,6 @@ class StencilStart {
         const DEFAULT_WATCH_IGNORED = ['/assets/scss', '/assets/css'];
         const { themePath, configPath } = this._themeConfigManager;
         const { watchOptions } = this._buildConfigManager;
-
         // Watch sccs directory and automatically reload all css files if a file changes
         const stylesPath = path.join(themePath, 'assets/scss');
         this._browserSync.watch(stylesPath, (event) => {
@@ -173,14 +160,12 @@ class StencilStart {
                 this._browserSync.reload('*.css');
             }
         });
-
         this._browserSync.watch(configPath, (event) => {
             if (event === 'change') {
                 this._themeConfigManager.resetVariationSettings();
                 this._browserSync.reload();
             }
         });
-
         const storefrontConfigPath = path.join(themePath, '.config/storefront.json');
         this._browserSync.watch(storefrontConfigPath, (event, file) => {
             if (event === 'change') {
@@ -193,7 +178,6 @@ class StencilStart {
                 this._browserSync.reload();
             }
         });
-
         const templatesPath = path.join(themePath, 'templates');
         this._browserSync.watch(templatesPath, { ignoreInitial: true }, async () => {
             try {
@@ -203,7 +187,6 @@ class StencilStart {
                 this._logger.error(e);
             }
         });
-
         const langsPath = path.join(themePath, 'lang');
         this._browserSync.watch(langsPath, async (event) => {
             try {
@@ -217,7 +200,6 @@ class StencilStart {
                 this._logger.error(e);
             }
         });
-
         // tunnel value should be true/false or a string with name
         // https://browsersync.io/docs/options#option-tunnel
         // convert undefined/true -> false/true
@@ -225,7 +207,6 @@ class StencilStart {
             typeof cliOptions.tunnel === 'string' ? cliOptions.tunnel : Boolean(cliOptions.tunnel);
         const watchFiles = (watchOptions && watchOptions.files) || DEFAULT_WATCH_FILES;
         const watchIgnored = (watchOptions && watchOptions.ignored) || DEFAULT_WATCH_IGNORED;
-
         this._browserSync.init({
             open: !!cliOptions.open,
             port: browserSyncPort,
@@ -237,24 +218,20 @@ class StencilStart {
             proxy: `localhost:${stencilConfig.port}`,
             tunnel,
         });
-
         // Handle manual reloading of browsers by typing 'rs';
         // Borrowed from https://github.com/remy/nodemon
         process.stdin.resume();
         process.stdin.setEncoding('utf8');
         process.stdin.on('data', (data) => {
             const normalizedData = `${data}`.trim().toLowerCase();
-
             // if the keys entered match the restartable value, then restart!
             if (normalizedData === 'rs') {
                 this._browserSync.reload();
             }
         });
-
         if (this._buildConfigManager.development) {
             this._buildConfigManager.initWorker().development(this._browserSync);
         }
-
         await this.checkLangFiles(langsPath, this._storeSettingsLocale.default_shopper_language);
     }
 
@@ -269,7 +246,6 @@ class StencilStart {
         const templateNames = filesPaths.map((file) =>
             file.replace(templatesPath + path.sep, '').replace('.html', ''),
         );
-
         return Promise.all(
             templateNames.map(async (templateName) =>
                 promisify(this._templateAssembler.assemble)(templatesPath, templateName),
@@ -282,7 +258,6 @@ class StencilStart {
         const isDefaultLanguagePresent = filesPaths.some((file) =>
             file.includes(defaultShopperLanguage),
         );
-
         if (!isDefaultLanguagePresent) {
             this._logger.log(
                 `${
@@ -312,21 +287,17 @@ class StencilStart {
             secretsFileName,
         } = this._stencilConfigManager;
         let information = '\n';
-
         information += '-----------------Startup Information-------------\n'.gray;
         information += '\n';
         information += `${configFileName} location: ${configPath.cyan}\n`;
         information += `${secretsFileName} location: ${secretsPath.cyan}\n`;
         information += `config.json location: ${this._themeConfigManager.configPath.cyan}\n`;
         information += `Store URL: ${stencilConfig.normalStoreUrl.cyan}\n`;
-
         information += `SSL Store URL: ${stencilConfig.storeUrl.cyan}\n`;
         information += `Node Version: ${process.version.cyan}\n`;
         information += '\n';
         information += '-------------------------------------------------\n'.gray;
-
         return information;
     }
 }
-
-module.exports = StencilStart;
+export default StencilStart;