@onereach/orest-input-cli/lib/status.js

The tool for creating, serving, and publishing OREST Inputs

const fs = require('fs');
const getMeta = require('./getMeta');
const checkPublished = require('./checkPublished');
const { getProfiles, addProfile } = require('./profiles/profileService');
const prepareAuth = require('./prepareAuth');
const { verify: verifyPackageType } = require('../lib/packageType');
const StoreApi = require('./api/storeApi');

function isString(value) {
  return typeof value === 'string' || value instanceof String;
}

function isBypassed(options) {
  return isString(options.userToken) && isString(options.storeApiUrl);
}

async function main(options) {
  if (options.deprecate) {
    console.log('Deprecating is not implemented yet.');
    process.exit(1);
  }

  let packageType;
  let userToken;
  let storeApiUrl;

  const repository = options.pde ? 'pde' : 'account';
  const status = options.release ? 'RELEASED' : 'BETA';

  if (isBypassed(options)) {
    userToken = options.userToken;
    storeApiUrl = options.storeApiUrl;
  } else {
    const profiles = await getProfiles();

    if (!profiles || !profiles[options.profile]) {
      await addProfile(options.profile);
    }

    const { answers, userToken: token } = await prepareAuth(options);
    userToken = token;
    storeApiUrl = answers.storeApiUrl;
  }

  if (options.type) {
    verifyPackageType(options.type, true);
    packageType = options.type;
  }

  console.log();

  let dirs = options?.directory?.length ? options.directory : [''];

  if (options?.directory === true) {
    dirs = fs
      .readdirSync(process.cwd(), { withFileTypes: true })
      .filter(dirent => dirent.isDirectory())
      .map(dirent => dirent.name);
  }

  for (let i = 0; i < dirs.length; i++) {
    const relDirPath = dirs[i];
    const meta = await getMeta(relDirPath);

    if (meta.packageType) {
      packageType = meta.packageType;
    }

    verifyPackageType(packageType, true); // throw error if empty, etc.

    const storeApi = new StoreApi({
      userToken,
      storeApiUrl,
      packageType,
    });

    const isPublished = await checkPublished(
      {
        id: meta.packageName,
        version: meta.packageVersion,
      },
      { storeApi }
    );

    if (!isPublished) {
      console.log(`${meta.packageName}@${meta.packageVersion}`);
      console.log(
        '  Package is not published yet. Use "publish" command first.'
      );
      console.log();

      continue;
    }

    if (!options.pde && !options.release) {
      const packageStatusDetails = await storeApi.getVersions({
        id: meta.packageName,
      });

      if (options.all) {
        logStatusDetails(packageStatusDetails, meta.packageName);
      } else {
        logStatusDetails(
          packageStatusDetails,
          meta.packageName,
          meta.packageVersion
        );
      }
    } else {
      await storeApi.setReleaseStatus({
        id: meta.packageName,
        version: meta.packageVersion,
        repository,
        status,
      });

      console.log(`${meta.packageName}@${meta.packageVersion}`);
      console.log(`  ${repository}: ${status}`);
      console.log();
    }
  }
}

function logStatusDetails(packageStatusDetails, packageName, packageVersion) {
  console.log();

  if (packageVersion) {
    const versionStatusDetails = packageStatusDetails.find(
      ({ version }) => version === packageVersion
    );

    if (versionStatusDetails) {
      logVersionStatusDetails(
        versionStatusDetails.statusDetails,
        packageName,
        packageVersion
      );
    } else {
      console.log(`${packageName}@${packageVersion}`);
      console.log();
    }
  } else {
    packageStatusDetails.forEach(({ statusDetails, version }) => {
      logVersionStatusDetails(statusDetails, packageName, version);
    });
  }
}

function logVersionStatusDetails({ release }, packageName, packageVersion) {
  console.log(`${packageName}@${packageVersion}`);

  if (release?.pde?.status) {
    console.log('  PDE:', parseStatus(release.pde.status));
  }
  if (release?.account?.status) {
    console.log('  Account:', parseStatus(release.account.status));
  }

  console.log();
}

function parseStatus(statuses) {
  if (statuses.includes('DEPRECATED')) {
    return 'DEPRECATED';
  }
  if (statuses.includes('RELEASED')) {
    return 'RELEASED';
  }
  if (statuses.includes('BETA')) {
    return 'BETA';
  }
}

module.exports = (...args) => {
  main(...args).catch(err => {
    console.error(err);
    process.exit(1);
  });
};