fixes to pos-cli modules download (#666)

* fixes to pos-cli modules download

* fix test

* fix data.test.js

* update tests

* push

Author: Slashek

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 5.4.0
+
+* Improvement: `pos-cli modules download <module>` will by default download version defined in app/pos-modules.lock.json file
+* Improvement: `pos-cli modules download <module>` will automatically download all dependencies defined in module's template-values.json file if they do not exist yet
+* Improvement: Add `--force-dependencies` flag to `pos-cli modules download <module>` command to force re-downloading dependencies
+
 ## 5.3.0
 
 * Feature: `pos-cli modules overwrites` utility commands

bin/pos-cli-modules-download.js

@@ -7,6 +7,8 @@ const downloadFile = require('../lib/downloadFile');
 
 const { unzip } = require('../lib/unzip');
 const Portal = require('../lib/portal');
+const fs = require('fs');
+const path = require('path');
 
 // importing ESM modules in CommonJS project
 let ora;
@@ -18,29 +20,74 @@ const initializeEsmModules = async () => {
   return true;
 }
 
+const downloadModule = async (module, lockData) => {
+  const filename = 'modules.zip';
+  try {
+    if (!module.includes('@') && lockData) {
+      if (lockData[module] === undefined ) {
+        logger.Warn(`Warning: Can't find ${module} in app/pos-modules.lock.json, will download the latest version`);
+      }
+      const moduleVersion = lockData[module];
+      if (moduleVersion) {
+        module = `${module}@${moduleVersion}`;
+      }
+    }
+
+    logger.Info(`Searching for ${module}...`);
+    const moduleVersion = await Portal.moduleVersionsSearch(module);
+    logger.Info(`Downloading ${module}...`);
+    await downloadFile(moduleVersion['public_archive'], filename);
+    logger.Info(`Unzipping ${module}...`);
+    await unzip(filename, `${process.cwd()}/modules`);
+    shell.rm(filename);
+  } catch (error) {
+    if (error.statusCode === 404) {
+      throw `${module}: 404 not found`;
+    } else {
+      throw `${module}: ${error.message}`;
+    }
+  }
+}
+
 program
   .name('pos-cli modules download')
   .arguments('<module>', 'module name, ex. core, [email protected]')
+  .option('--force-dependencies', 'Force downloading dependencies, even if they are already present')
   .action(async (module, params) => {
-    const filename = 'modules.zip';
+    const lockFilePath = path.join('app', 'pos-modules.lock.json');
+    const forceDependencies = params.forceDependencies;
 
     await initializeEsmModules();
-    const spinner = ora({ text: 'Exporting', stream: process.stdout });
-    spinner.start();
-
-    Portal.moduleVersionsSearch(module)
-      .then(moduleVersion => downloadFile(moduleVersion['public_archive'], filename))
-      .then(() => unzip(filename, `${process.cwd()}/modules`))
-      .then(() => shell.rm(filename))
-      .then(() => spinner.succeed('Downloading files'))
-      .catch({ statusCode: 404 }, () => {
-        spinner.fail('Export failed');
-        logger.Error('[404] Module not found');
-      })
-      .catch(e => {
-        spinner.fail('Export failed');
-        logger.Error(e.message);
-      });
+
+    let lockData;
+
+    if (fs.existsSync(lockFilePath)) {
+      lockData = JSON.parse(fs.readFileSync(lockFilePath, 'utf-8'))['modules'];
+    } else {
+      logger.Warn(`Warning: Can't find app/pos-modules.lock.json`);
+    }
+
+    try {
+      await downloadModule(module, lockData);
+      logger.Info("Resolving dependencies...");
+      const templateValuesPath = path.join('modules', module.split('@')[0], 'template-values.json');
+      if (fs.existsSync(templateValuesPath)) {
+        const templateValuesContent = fs.readFileSync(templateValuesPath, 'utf-8');
+        const templateValues = JSON.parse(templateValuesContent);
+        const dependencies = templateValues.dependencies || {};
+
+        for (const depName of Object.keys(dependencies)) {
+          if (forceDependencies || !fs.existsSync(`modules/${depName}`)) {
+            await downloadModule(depName, lockData);
+          }
+        }
+      } else {
+        logger.Warn(`Warning: No template-values.json file for module ${module} - skipping dependencies`);
+      }
+      logger.Success(`Completed downloading ${module}`);
+    } catch (error) {
+      logger.Error(error);
+    }
   });
 
 program.parse(process.argv);

test/fixtures/deploy/modules_user/app/pos-modules.json

@@ -0,0 +1,5 @@
+{
+  "modules": {
+    "user": "3.0.8"
+  }
+}

test/fixtures/deploy/modules_user/app/pos-modules.lock.json

@@ -0,0 +1,6 @@
+{
+  "modules": {
+    "user": "3.0.8",
+    "core": "1.5.5"
+  }
+}

test/modules-download.test.js

@@ -12,34 +12,111 @@ const cwd = name => path.join(process.cwd(), 'test', 'fixtures', name);
 const run = async (fixtureName, options) => await exec(`${cliPath} modules download ${options}`, { cwd: cwd(fixtureName), env: process.env });
 
 describe('Successful download', () => {
-  test('download test module', async () => {
+
+  test('download test module in the correct version', async () => {
+    const pathToModuleJson = `${cwd('deploy/modules_test')}/modules/tests/template-values.json`;
+    const pathToDirectory = `${cwd('deploy/modules_test')}/modules`;
+
+    const { stdout } = await run('deploy/modules_test', 'tests');
+    expect(stdout).toContain('Downloading [email protected]');
+    expect(fs.existsSync(pathToModuleJson)).toBeTruthy();
+
+    const moduleJson = JSON.parse(fs.readFileSync(pathToModuleJson, 'utf8'));
+    expect(moduleJson.version).toBe('0.0.3');
+
+    fs.rm(pathToDirectory, { recursive: true }, (err) => {
+      if(err){
+        console.error(err.message);
+        return;
+      }
+    });
+  });
+
+  test('download test module in a specific version', async () => {
     const pathToModuleJson = `${cwd('deploy/modules_test')}/modules/tests/template-values.json`;
     const pathToDirectory = `${cwd('deploy/modules_test')}/modules`;
 
-    const { stdout, stderr } = await run('deploy/modules_test', 'tests');
-    expect(stdout).toMatch('Downloading files');
+    const { stdout } = await run('deploy/modules_test', 'tests@1.0.0');
+    expect(stdout).toContain('Downloading [email protected]');
     expect(fs.existsSync(pathToModuleJson)).toBeTruthy();
 
+    const moduleJson = JSON.parse(fs.readFileSync(pathToModuleJson, 'utf8'));
+    expect(moduleJson.version).toBe('1.0.0');
+
     fs.rm(pathToDirectory, { recursive: true }, (err) => {
       if(err){
-          console.error(err.message);
-          return;
+        console.error(err.message);
+        return;
       }
     });
   });
+
+  test('download the latest test module if no app/pos-modules.lock.json', async () => {
+    const pathToModuleJson = `${cwd('deploy/empty')}/modules/tests/template-values.json`;
+    const pathToDirectory = `${cwd('deploy/empty')}/modules`;
+
+    const { stdout, stderr } = await run('deploy/empty', 'tests');
+    expect(stdout).toContain('Downloading tests...');
+    expect(stderr).toContain('Warning: Can\'t find app/pos-modules.lock.json');
+    expect(fs.existsSync(pathToModuleJson)).toBeTruthy();
+
+    fs.rm(pathToDirectory, { recursive: true }, (err) => {
+      if(err){
+        console.error(err.message);
+        return;
+      }
+    });
+  });
+
+
+  test('download user module with dependencies', async () => {
+    const pathToUserModuleJson = `${cwd('deploy/modules_user')}/modules/user/template-values.json`;
+    const pathToCoreModuleJson = `${cwd('deploy/modules_user')}/modules/core/template-values.json`;
+    const pathToDirectory = `${cwd('deploy/modules_user')}/modules`;
+
+    const { stdout: stdout1 } = await run('deploy/modules_user', 'user');
+    expect(stdout1).toContain('Downloading [email protected]');
+    expect(fs.existsSync(pathToUserModuleJson)).toBeTruthy();
+    expect(stdout1).toContain('Downloading [email protected]');
+    expect(fs.existsSync(pathToCoreModuleJson)).toBeTruthy();
+
+    const userModuleJson = JSON.parse(fs.readFileSync(pathToUserModuleJson, 'utf8'));
+    expect(userModuleJson.version).toBe('3.0.8');
+    const coreModuleJson = JSON.parse(fs.readFileSync(pathToCoreModuleJson, 'utf8'));
+    expect(coreModuleJson.version).toBe('1.5.5');
+
+    // do not download dependency again
+
+    const { stdout: stdout2 } = await run('deploy/modules_user', 'user');
+    expect(stdout2).toContain('Downloading [email protected]');
+    expect(stdout2).not.toContain('Downloading [email protected]');
+
+    // download again if forced
+
+    const { stdout: stdout3 } = await run('deploy/modules_user', 'user --force-dependencies');
+    expect(stdout3).toContain('Downloading [email protected]');
+    expect(stdout3).toContain('Downloading [email protected]');
+
+    fs.rm(pathToDirectory, { recursive: true }, (err) => {
+      if (err) {
+        console.error(err.message);
+        return;
+      }
+    });
+  }, 20000);
 });
 
 describe('Failed download', () => {
   test('Module not found - non-existing module', async () => {
-    const { stdout, stderr } = await run('deploy/modules_test', 'moduleNotFound');
-    expect(stderr).toMatch('Module not found');
+    const { stderr } = await run('deploy/modules_test', 'moduleNotFound');
+    expect(stderr).toContain('moduleNotFound: 404 not found');
   });
   test('Module not found - no name for module', async () => {
-    const { stdout, stderr } = await run('deploy/modules_test', '');
+    const { stderr } = await run('deploy/modules_test', '');
     expect(stderr).toMatch("error: missing required argument 'module'");
   });
   test('Unescaped characters in request path', async () => {
-    const { stdout, stderr } = await run('deploy/modules_test', 'ąę');
+    const { stderr } = await run('deploy/modules_test', 'ąę');
     expect(stderr).toMatch('[ERR_UNESCAPED_CHARACTERS]: Request path contains unescaped characters');
   });
 });