@platformos/pos-cli/lib/archive.js

Manage your platformOS application

const fs = require('fs');
const shell = require('shelljs');
const glob = require('fast-glob');

const templates = require('../lib/templates');
const logger = require('../lib/logger');
const settings = require('../lib/settings');
const dir = require('../lib/directories');
const prepareArchive = require('../lib/prepareArchive');

const isEmpty = dir => shell.ls(dir).length == 0;

const addModulesToArchive = async (archive, withoutAssets) => {
  if (!fs.existsSync(dir.MODULES)) {
    return Promise.resolve(true);
  }
  const modules = await glob('*', { cwd: dir.MODULES, onlyFiles: false });
  return Promise.all(modules.map(module => addModuleToArchive(module, archive, withoutAssets)));
};

const addModuleToArchive = (module, archive, withoutAssets, pattern = '**/{private,public}/**') => {
  return new Promise((resolve, reject) => {
    glob(pattern, {
      cwd: `${dir.MODULES}/${module}`,
      filesOnly: true
    })
      .then(files => {
        const moduleTemplateData = settings.loadSettingsFileForModule(module);

        return Promise.all(
          files
            .filter(file => {
              return !withoutAssets || !(file.startsWith('public/assets/') || file.startsWith('private/assets'));
            })
            .map(f => {
              const path = `${dir.MODULES}/${module}/${f}`;
              return new Promise((resolve, reject) => {
                fs.lstat(path, (err, stat) => {
                  if (!stat.isDirectory()) {
                    const filledTemplate = templates.fillInTemplateValues(path, moduleTemplateData);
                    archive.append(filledTemplate, { name: path });
                  }
                  resolve();
                });
              });
            })
        ).then(() => resolve());
      })
      .catch(e => {
        logger.Error(e);
      });
  });
};

const findAppDirectory = () => {
  let appDirectory = dir.APP;
  if (dir.toWatch().length === 0) {
    return logger.Error(
      `Could not find any directory to deploy. Looked for ${dir.APP}, ${dir.LEGACY_APP} and ${dir.MODULES}`,
      { exit: false }
    );
  }

  if (!fs.existsSync(dir.APP) && fs.existsSync(dir.LEGACY_APP)) {
    logger.Debug(`${dir.APP} not found, but ${dir.LEGACY_APP} is present. Setting ${dir.LEGACY_APP} as app dir.`);
    logger.Warn(`Falling back to legacy app directory name. Please consider renaming ${dir.LEGACY_APP} to ${dir.APP}`);
    appDirectory = dir.LEGACY_APP;
  }
  return appDirectory;
};

const makeArchive = async (env, { withoutAssets }) => {
  const path = env.TARGET || './tmp/release.zip';
  const directory = findAppDirectory();
  if (!directory) return false;
  if (dir.available().length === 0) {
    return logger.Error(`At least one of ${dir.ALLOWED.join(', ')} directories is needed to deploy`, {
      hideTimestamp: true,
      exit: false
    });
  }

  if (isEmpty(dir.currentApp()) && !withoutAssets) {
    return logger.Error(
      `${dir.currentApp()} can't be empty if the deploy is not partial - it would remove all the files from the instance`,
      { hideTimestamp: true, exit: false }
    );
  }
  const options = {
    cwd: directory,
    ignore: withoutAssets ? ['assets/**'] : []
  };

  return new Promise(async (resolve, reject) => {
    const releaseArchive = prepareArchive(path, resolve, !withoutAssets);
    releaseArchive.glob('**/*', options, { prefix: directory });
    await addModulesToArchive(releaseArchive, withoutAssets);
    await releaseArchive.finalize();
  });
};

module.exports = {
  makeArchive: makeArchive
};