refactor

Author: Slashek

bin/pos-cli-sync.js

@@ -50,6 +50,8 @@ program
     // Continue with watch mode
     const { watcher, liveReloadServer } = await watchStart(env, params.directAssetsUpload, params.livereload);
 
+    setupGracefulShutdown({ watcher, liveReloadServer, context: 'Sync' });
+
     if (params.open) {
       try {
         const open = (await import('open')).default;
@@ -62,8 +64,6 @@ program
         }
       }
     }
-
-    setupGracefulShutdown({ watcher, liveReloadServer, context: 'Sync' });
   });
 
 program.parse(process.argv);

lib/archive.js

@@ -8,7 +8,7 @@ import logger from './logger.js';
 import dir from './directories.js';
 import prepareArchive from './prepareArchive.js';
 
-const isEmpty = d => shell.ls(d).length == 0;
+const isEmpty = d => shell.ls(d).length === 0;
 
 const addModulesToArchive = async (archive, withoutAssets) => {
   if (!fs.existsSync(dir.MODULES)) {
@@ -27,7 +27,7 @@ const addModuleToArchive = async (module, archive, withoutAssets, pattern = '**/
   const moduleTemplateData = loadSettingsFileForModule(module);
 
   for (const f of files) {
-    if (withoutAssets && (f.startsWith('public/assets/') || f.startsWith('private/assets'))) {
+    if (withoutAssets && (f.startsWith('public/assets/') || f.startsWith('private/assets/'))) {
       continue;
     }
     const realPath = path.join(dir.MODULES, module, f);
@@ -75,8 +75,7 @@ const makeArchive = async (env, { withoutAssets }) => {
   const appFiles = await glob(['**/*', '!**/*.zip'], {
     cwd: directory,
     onlyFiles: true,
-    ignore: withoutAssets ? ['assets/**'] : [],
-    dot: true
+    ignore: withoutAssets ? ['assets/**'] : []
   });
 
   for (const f of appFiles) {

lib/assets/packAssets.js

@@ -36,7 +36,7 @@ const packAssets = async outputPath => {
   const archive = prepareArchive(outputPath);
 
   if (fs.existsSync(`${appDirectory}/assets`)) {
-    const assetFiles = await glob('**/*', { cwd: `${appDirectory}/assets`, onlyFiles: true, dot: true });
+    const assetFiles = await glob('**/*', { cwd: `${appDirectory}/assets`, onlyFiles: true });
     for (const f of assetFiles) {
       archive.addFile(path.join(appDirectory, 'assets', f), f);
     }

lib/check.js

@@ -28,6 +28,7 @@ const checkThemeCheck = async () => {
 const validatePath = async (checkPath) => {
   if (!fs.existsSync(checkPath)) {
     await logger.Error(`Path does not exist: ${checkPath}`);
+    return;
   }
 
   const stats = fs.statSync(checkPath);
@@ -367,7 +368,6 @@ const run = async (opts) => {
 
   try {
     // Run checks with progress callback
-    let fileCount = 0;
     const result = await themeCheck.themeCheckRun(checkPath, undefined, (message) => {
       if (spinner && message) {
         spinner.text = message;
@@ -376,10 +376,10 @@ const run = async (opts) => {
 
     offenses = result.offenses;
     theme = result.theme;
-    fileCount = theme.length;
 
     // Update spinner with completion info if it's still running
     if (spinner && spinner.isSpinning) {
+      const fileCount = theme.length;
       spinner.text = `Checked ${fileCount} file${fileCount === 1 ? '' : 's'}`;
     }
 
@@ -414,7 +414,7 @@ const run = async (opts) => {
   }
 
   if (offenses.length > 0) {
-    process.exit(1);
+    process.exitCode = 1;
   }
 };
 

lib/deploy/directAssetsUploadStrategy.js

@@ -34,14 +34,14 @@ const strategy = async ({ env, authData, _params }) => {
     spinner.start();
 
     const t0 = performance.now();
-    await deployAndUploadAssets(authData);
-
     if (numberOfFiles > 0) {
       await uploadArchive(env);
     } else {
       logger.Warn('There are no files in release file, skipping.');
     }
 
+    await deployAndUploadAssets(authData);
+
     spinner.succeed(`Deploy succeeded after ${duration(t0, performance.now())}`);
   } catch (e) {
     if (ServerError.isNetworkError(e)) {

lib/modules.js

@@ -39,33 +39,32 @@ const moduleConfigFilePath = async (moduleName='*') => {
 };
 
 const createArchive = async (moduleName) => {
+  if (!fs.existsSync(moduleConfigFileName) && !fs.existsSync(`modules/${moduleName}/`)) {
+    throw new Error(`There is no directory modules/${moduleName} - please double check the machine_name property in ${filePath}`);
+  }
+
   const archive = prepareArchive(archivePath, true);
 
   if (fs.existsSync(moduleConfigFileName) && !fs.existsSync('modules/')) {
     logger.Warn(`Cannot find modules/${moduleName}, creating archive with the current directory.`);
     const moduleFiles = await glob(['**/**', moduleConfigFileName], {
       ignore: ['**/node_modules/**', '**/tmp/**', 'app/**'],
-      onlyFiles: true,
-      dot: true
+      onlyFiles: true
     });
     for (const f of moduleFiles) {
       archive.addFile(f, `${moduleName}/${f}`);
     }
-  } else if (fs.existsSync(`modules/${moduleName}/`)) {
+  } else {
     logger.Info(`Creating archive for modules/${moduleName}`);
     const moduleDir = path.join(process.cwd(), 'modules', moduleName);
     const moduleFiles = await glob(['**/**', moduleConfigFileName], {
       ignore: ['**/node_modules/**', '**/tmp/**'],
       cwd: moduleDir,
-      onlyFiles: true,
-      dot: true
+      onlyFiles: true
     });
     for (const f of moduleFiles) {
       archive.addFile(path.join('modules', moduleName, f), `${moduleName}/${f}`);
     }
-  } else {
-    archive.finalize();
-    throw new Error(`There is no directory modules/${moduleName} - please double check the machine_name property in ${filePath}`);
   }
 
   archive.finalize();

lib/watch.js

@@ -69,7 +69,9 @@ const pushFile = async (gateway, syncedFilePath) => {
       logger.Warn('[Sync] WARNING: Data schema was updated. It will take a while for the change to be applied.');
     }
 
-    logger.Success(`[Sync] Synced: ${filePath}`);
+    if (body) {
+      logger.Success(`[Sync] Synced: ${filePath}`);
+    }
   } catch (e) {
     // Handle validation errors (422) with custom formatting
     if (e.statusCode === 422 && e.response && e.response.body) {

test/utils/waitForOutput.js

@@ -1,22 +1,23 @@
-const waitForOutput = (child, pattern, timeout = 15000) => {
+const waitForOutput = (child, pattern, { timeout = 15000, stream = 'stdout' } = {}) => {
   return new Promise((resolve, reject) => {
     let buffer = '';
+    const source = child[stream];
 
     const onData = (chunk) => {
       buffer += chunk.toString();
       if (pattern.test(buffer)) {
         clearTimeout(timer);
-        child.stdout.off('data', onData);
+        source.off('data', onData);
         resolve();
       }
     };
 
     const timer = setTimeout(() => {
-      child.stdout.off('data', onData);
-      reject(new Error(`Timeout (${timeout}ms) waiting for output: ${pattern}`));
+      source.off('data', onData);
+      reject(new Error(`Timeout (${timeout}ms) waiting for ${stream} output: ${pattern}`));
     }, timeout);
 
-    child.stdout.on('data', onData);
+    source.on('data', onData);
   });
 };