@pega/custom-dx-components 24.2.15 → 25.1.10-alpha-0.1

package/src/util.js

@@ -8,6 +8,7 @@ import { createRequire } from 'module';
 import {jwtDecode} from 'jwt-decode';
 import archiver from 'archiver';
 import {unarchive} from 'unarchive';
+import ora from 'ora';
 
 import chalk from 'chalk';
 import mustache from 'mustache';
@@ -22,18 +23,22 @@ import {
   TASKS_CONFIG_JSON_FILENAME,
   INPUT_CONFIG_JSON_FILENAME,
   PACKAGE_JSON_FILENAME,
+  PACKAGE_LOCK_JSON_FILENAME,
   TOKEN_PATH,
   OOTB_COMPONENT_SERVICE_REST_ENDPOINT,
   DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
   LP_DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
+  DELETE_COMPONENT_LIBRARY_SERVICE_REST_ENDPOINT,
   OOTB_COMPONENTS,
   USE_PROMOTED_WEB_PACK,
   BOOTSTRAP_CONFIG,
   LIBRARY_BASED,
+  LIBRARY_BASED_CL,
   USE_INPUT_CONFIG,
   SHARED_DIRECTORY,
   SHOW_DEBUG,
   COMPONENTS_PATH,
+  COMPONENT_SCHEMA,
   ARCHIVES_PATH,
   BIN_ARCHIVES_PATH,
   TEMP_PATH,
@@ -43,6 +48,7 @@ import {
 } from './constants.js';
 
 
+
 const access = promisify(fs.access);
 
 let showDebug = false;
@@ -55,6 +61,7 @@ let addAboutData = true;
 let defaultConfigs = {
   serverType: "",
   isLibraryBased: false,
+  isLibraryBasedCL: false,
   devBuild: true,
   library: "",
   organization: "",
@@ -111,6 +118,7 @@ export const setUpDefaults = async () => {
   let retrievedConfigData = {
     serverType: "",
     isLibraryBased: false,
+    isLibraryBasedCL: false,
     devBuild: true,
     library: "",
     organization: "",
@@ -139,22 +147,30 @@ export const setUpDefaults = async () => {
       retrievedConfigData.importRelativePath = data[IMPORT_RELATIVE_PATH];
     }
 
-
     if (data[EXPORT_RELATIVE_PATH]) {
       retrievedConfigData.exportRelativePath = data[EXPORT_RELATIVE_PATH];
     }
 
-    if (data[LIBRARY_BASED]) {
-      retrievedConfigData.isLibraryBased = data[LIBRARY_BASED];
-    }
-
     if (data[USE_INPUT_CONFIG]) {
       retrievedConfigData.useInputConfig = data[USE_INPUT_CONFIG];
     }
 
+    if (data[LIBRARY_BASED]) {
+      retrievedConfigData.isLibraryBased = data[LIBRARY_BASED];
+    }
+
     retrievedConfigData.library = data.component.library;
     retrievedConfigData.version = data.component.version;
 
+    if (data[LIBRARY_BASED_CL]) {
+      retrievedConfigData.isLibraryBasedCL = data[LIBRARY_BASED_CL];
+
+      // if this is true, then force librarybased to true, so it doesn't have to be set
+      if (retrievedConfigData.isLibraryBasedCL) {
+        retrievedConfigData.isLibraryBased = retrievedConfigData.isLibraryBasedCL;
+      }
+    }
+
 
     const { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
     retrievedConfigData.organization = organization;
@@ -181,7 +197,6 @@ export const setUpDefaults = async () => {
   return JSON.parse(JSON.stringify(retrievedConfigData));
 }
 
-
 export const convertYNToBoolean = (inputYN) => {
   switch (inputYN) {
     case 'Y':
@@ -199,46 +214,45 @@ export const convertYNToBoolean = (inputYN) => {
 }
 
 export const getInputConfigForCommand = async (commandName) => {
-    // retrievedConfigData
-    const currentDirectory = process.cwd();
-    const inputConfigJsonPath = join(currentDirectory, INPUT_CONFIG_JSON_FILENAME);
-    const isLibraryBased = getLibraryBased();
+  // retrievedConfigData
+  const currentDirectory = process.cwd();
+  const inputConfigJsonPath = join(currentDirectory, INPUT_CONFIG_JSON_FILENAME);
+  const isLibraryBased = getLibraryBased();
 
-    try {
-      // force to throw error and not console log
-      await checkPathAccess(inputConfigJsonPath, {}, true);
+  try {
+    // force to throw error and not console log
+    await checkPathAccess(inputConfigJsonPath, {}, true);
 
-      let data = fs.readFileSync(inputConfigJsonPath, { encoding: 'utf8' });
-      data = JSON.parse(data);
+    let data = fs.readFileSync(inputConfigJsonPath, { encoding: 'utf8' });
+    data = JSON.parse(data);
 
-      if (isLibraryBased) {
-        const libraryCommands = data["libraryMode"];
+    if (isLibraryBased) {
+      const libraryCommands = data["libraryMode"];
 
-        if (libraryCommands[commandName]) {
-          return libraryCommands[commandName];
+      if (libraryCommands[commandName]) {
+        return libraryCommands[commandName];
 
-        }
       }
-      else {
-        const standardCommands = data["standard"];
-
-        if (standardCommands[commandName]) {
-          return standardCommands[commandName];
+    }
+    else {
+      const standardCommands = data["standard"];
 
-        }
+      if (standardCommands[commandName]) {
+        return standardCommands[commandName];
 
       }
-    }
-    catch (ex) {
-      // when can't find it, always be false, assume no library based.
-      // This is IMPORTANT for init (npx install)
-      return {};
-    }
 
+    }
+  }
+  catch (ex) {
+    // when can't find it, always be false, assume no library based.
+    // This is IMPORTANT for init (npx install)
     return {};
+  }
 
-}
+  return {};
 
+}
 
 // initialize
 // await setUpDefaults();
@@ -330,7 +344,7 @@ if (showDebug) addDebugLog("updateUseWebPackPromotion", "", "");
 }
 
 export const getAboutData = async (currentOrgLib, buildVersion, dateStamp) => {
-if (showDebug) addDebugLog("getAboutData", `currentOrgLib: ${currentOrgLib}, buildVersion: ${buildVersion}, dateStamp: ${dateStamp}`)
+if (showDebug) addDebugLog("getAboutData", `currentOrgLib: ${currentOrgLib}, buildVersion: ${buildVersion}, dateStamp: ${dateStamp}`,"");
   const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
 
   if (tokenAndStaticServer.C11NB2S === undefined) {
@@ -345,8 +359,51 @@ if (showDebug) addDebugLog("getAboutData", `currentOrgLib: ${currentOrgLib}, bui
   return `${currentOrgLib} ${buildVersion}, ${dateStamp}, ${infinityVersion}`;
 }
 
+export const applyPegaData = async (configJson) => {
+if (showDebug) addDebugLog("applyPegaData", "", "");
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+  const currentDirectory = process.cwd()
+  // const currentPackagePath = join(currentDirectory, PACKAGE_JSON_FILENAME);
+  const currentPackageLockPath = join(currentDirectory, PACKAGE_LOCK_JSON_FILENAME);
+  // let currentPackageData;
+  let currentPackageLockData;
+
+  try {
+    currentPackageLockData = fs.readFileSync(currentPackageLockPath);
+  }
+  catch (ex) {
+    console.log(chalk.red(`\nUnable to retrieve current package-lock.json.`));
+    process.exit(1);
+  }
+
+  // const cData = JSON.parse(currentPackageData);
+  // const cosmosVersion = cData.dependencies["@pega/cosmos-react-core"];
+
+  const cData = JSON.parse(currentPackageLockData);
+  const cosmosReact = cData.packages["node_modules/@pega/cosmos-react-core"];
+  const cosmosVersion = cosmosReact.version;
+
+  let infinityVersion = "";
+
+  if (tokenAndStaticServer.C11NB2S === undefined) {
+  }
+  else {
+    const jwt = jwtDecode(tokenAndStaticServer.C11NB2S);
+    infinityVersion= jwt.infinity_version;
+    // don't remove "8." from infinity version so can do a comparison
+  }
+
+  // apply info to config.json
+  configJson.infinityVersion = infinityVersion;
+  configJson.packageCosmosVersion = cosmosVersion;
+
+
+}
+
 export const checkJWTExpiration = async () => {
   const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+  const isLibraryBased = getLibraryBased();
+  const isLibraryBasedCL = getLibraryBasedCL();
 
   if (tokenAndStaticServer.C11NB2S === undefined) {
     console.log(chalk.redBright("Need to authenticate, missing services token.\nBuilding a library requires authentication to acquire a token to build."));
@@ -360,46 +417,64 @@ export const checkJWTExpiration = async () => {
     process.exit(1);
   }
 
-  // check that there is customer_org
-  if (!customer_org || customer_org === "") {
-    console.log(chalk.red(`PegaInfinity server DSS setting ${chalk.redBright.bold(`C11nCCv2CustomerOrg`)} is NOT set.`));
-    console.log(chalk.red("Please update DSS setting, save and then reauthenticate."));
+
+  // only check if older isLibraryBased
+  if (!isLibraryBasedCL && isLibraryBased) {
+    // check that there is customer_org
+    if (!customer_org || customer_org === "") {
+      console.log(chalk.red(`PegaInfinity server DSS setting ${chalk.redBright.bold(`C11nCCv2CustomerOrg`)} is NOT set.`));
+      console.log(chalk.red("Please update DSS setting, save and then reauthenticate."));
+      process.exit(1);
+    }
+
+  }
+
+
+}
+
+export const checkAccessTokenExpiration = async() => {
+
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+  if (tokenAndStaticServer.access_token === undefined) {
+    console.log(chalk.redBright("Need to authenticate, missing token.\n"));
+    process.exit(1);
+  }
+
+  const jwt = jwtDecode(tokenAndStaticServer.access_token);
+  const  { exp, customer_org } = jwt;
+  if (exp < (new Date().getTime() + 1) / 1000) {
+    console.log(chalk.redBright("Authentication token has expired, please reauthenticate."));
+    process.exit(1);
+  }
+
+
+}
+
+export const getApplicationAndVersionFromToken = async() => {
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+  if (tokenAndStaticServer.access_token === undefined) {
+    console.log(chalk.redBright("Need to authenticate, missing token.\n"));
     process.exit(1);
   }
 
+  const jwt = jwtDecode(tokenAndStaticServer.access_token);
+  const { app_name, app_version } = jwt;
+  return { app_name, app_version };
+
 }
 
 export const getLibraryBased = () => {
 if (showDebug) addDebugLog("getLibraryBased", "", "");
-//   const currentDirectory = process.cwd();
-//   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
-
-//   try {
-//     // force to throw error and not console log
-//     await checkPathAccess(pegaConfigJsonPath, {}, true);
-//   }
-//   catch (ex) {
-//     // when can't find it, always be false, assume no library based.
-//     // This is IMPORTANT for init (npx install)
-//     return false;
-//   }
-
-//   let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
-//   data = JSON.parse(data);
-
-//   if (data[LIBRARY_BASED]) {
-// if (showDebug) addDebugLog("getLibraryBased", `based: ${data[LIBRARY_BASED]}`, "");
-// if (showDebug) addDebugLog("getLibraryBased", "END", "-");
-//     return data[LIBRARY_BASED];
-//   }
-//   else {
-// if (showDebug) addDebugLog("getLibraryBased", "END", "-");
-//     return false;
-//   }
-
   return defaultConfigs.isLibraryBased;
 }
 
+export const getLibraryBasedCL = () => {
+if (showDebug) addDebugLog("getLibraryBasedCL", "", "");
+  return defaultConfigs.isLibraryBasedCL;
+}
+
 export const getUseInputConfig = () => {
 if (showDebug) addDebugLog("getUseInputConfig", "", "");
 
@@ -407,8 +482,6 @@ if (showDebug) addDebugLog("getUseInputConfig", "", "");
   return defaultConfigs.useInputConfig;
 }
 
-
-
 export const setLibraryBased = async (isLibraryBased) => {
 if (showDebug) addDebugLog("setLibraryBased", "", "");
   const currentDirectory = process.cwd();
@@ -449,27 +522,57 @@ if (showDebug) addDebugLog("setLibraryBased", "", "");
 
 }
 
+export const setLibraryBasedCL = async (isLibraryBasedCL) => {
+  if (showDebug) addDebugLog("setLibraryBased", "", "");
+    const currentDirectory = process.cwd();
+    const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+    try {
+      // force to throw error and not console log
+      await checkPathAccess(pegaConfigJsonPath, {}, true);
+    }
+    catch (ex) {
+      // when can't find it, always be false, assume no library based.
+      // This is IMPORTANT for init (npx install)
+      return false;
+    }
+
+    let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+    data = JSON.parse(data);
+
+    if (data[LIBRARY_BASED_CL] != undefined) {
+      data[LIBRARY_BASED_CL] = isLibraryBasedCL;
+
+      // if not undefined, force this as well
+      if (data[LIBRARY_BASED] != undefined) {
+        data[LIBRARY_BASED] = isLibraryBasedCL;
+      }
+
+      // update file
+      // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+      try {
+        fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(data, null, 4), { encoding: 'utf8',flag:'w' });
+      }
+      catch (err) {
+        console.error(err);
+      }
+      //await forceDefaultsUpdate();
+      defaultConfigs.isLibraryBasedCL = isLibraryBasedCL;
+
+      // force libraryBased if isLibraryBasedCL is true
+      defaultConfigs.isLibraryBased = isLibraryBasedCL;
+
+
+      // reset
+      pegaData = null;
+      pegaConfig = null;
+
+    }
+
+  }
+
 export const getShowDebug = () => {
-  // const currentDirectory = process.cwd();
-  // const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
-
-  // try {
-  //   // force to throw error and not console log
-  //   await checkPathAccess(pegaConfigJsonPath, {}, true);
-  // }
-  // catch (ex) {
-  //   // when can't find it, always be false, assume no library based.
-  //   // This is IMPORTANT for init (npx install)
-  //   return false;
-  // }
-
-  // let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
-  // data = JSON.parse(data);
-
-  // if (data[SHOW_DEBUG]) {
-  //   return data[SHOW_DEBUG];
-  // }
-  // else return false;
+
   return defaultConfigs.showDebug;
 
 }
@@ -640,7 +743,6 @@ if (showDebug) addDebugLog("removeTopLevelConfigFiles", `directory: ${directory}
       if (configF !== "package-lock.json" &&
           configF !== "package.json" &&
           configF !== "tasks.config.json" &&
-          configF !== "input.config.json" &&
           configF !== ".gitignore" &&
           configF !== ".npmrc" &&
           configF !== ".prettierignore") {
@@ -850,11 +952,15 @@ if (showDebug) addDebugLog("getPegaServerConfig", "", "+");
 
       if (OAuthData) {
         const oOAuthData = JSON.parse(OAuthData);
-        const isolationId = oOAuthData["isolation-ids"].write;
-        pegaConfig['server-config'].isolationId = isolationId[0];
+        if (oOAuthData["isolation-ids"]) {
+          const isolationId = oOAuthData["isolation-ids"].write;
+          pegaConfig['server-config'].isolationId = isolationId[0];
+        }
+
       }
 
     }
+
     sPegaServerConfig = JSON.stringify(pegaConfig['server-config']);
   }
 
@@ -1049,7 +1155,8 @@ if (showDebug) addDebugLog("updateConfigVersion", `componentKey: ${componentKey}
   data.version = buildVersion;
 
   if (addAboutData) {
-    data.buildDate = dateStamp;
+    data.buildDate = currentDate;
+    await applyPegaData(data);
   }
 
 
@@ -1191,12 +1298,6 @@ export const showVersion = async () => {
     process.exit(1);
   }
 
-  // const hasGit = checkGit(process.cwd());
-
-  // if (!hasGit) {
-  //   console.log(chalk.redBright('DX Component Builder - Git needs to be installed.'));
-  //   process.exit(1);
-  // }
 };
 
 export const getOOTBComponents = async () => {
@@ -1331,6 +1432,96 @@ if (showDebug) addDebugLog("deleteInfinityServerComponent", `componentKey: ${com
   }
 };
 
+export const deleteInfinityServerComponentLibrary = async (libraryName, rulesetName, rulesetVersion) => {
+if (showDebug) addDebugLog("deleteInfinityServerComponentLibrary", `componentKey: ${componentKey}, rulesetName: ${rulesetName}, rulesetVersion: ${rulesetVersion}`, "");
+  const serverConfig = await getPegaServerConfig();
+  const { server } = serverConfig;
+  const url = constructCompleteUrl(server, DELETE_COMPONENT_LIBRARY_SERVICE_REST_ENDPOINT);
+  const deleteUrl = `${url}/${libraryName}/rulesetname/${rulesetName}/rulesetversion/${rulesetVersion}`;
+  try {
+    const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+
+    let status = 500;
+
+    if (OauthData) {
+      const { access_token: accessToken, token_type: tokenType } = JSON.parse(OauthData);
+      let spinner;
+
+      console.log();
+      spinner = ora(chalk.green.bold('Deleting component library...')).start();
+
+      const response = await fetch(deleteUrl, {
+        method: 'DELETE',
+        agent: getHttpsAgent(serverConfig),
+        headers: {
+          Authorization: `${tokenType} ${accessToken}`
+        }
+      });
+
+      spinner.stop();
+      console.log();
+
+      status = response.status;
+      if (!response.ok) {
+        if (status === 401) {
+          throw new Error(
+            'Error occurred in authentication. Please regenerate using authenticate'
+          );
+          // console.log(accessTokenUri, refreshToken);
+          /* TODO - Handle refresh_token */
+        }
+        else if (status === 404){
+          throw new Error('404: Server resource not found');
+        }
+        else if (status === 405){
+          throw new Error('405: Server method not allowed');
+        }
+        else if (status === 408){
+          throw new Error('408: Server timed out');
+        }
+        else if (response.status === 403) {
+          throw new Error(
+            'Error forbidden: User does not have privileges to Publish.'
+          );
+        }
+
+      }
+
+      try {
+        const respData = await response.json();
+        const message = respData.message;
+        status = parseInt(respData.status);
+
+        if (status === 200) {
+          console.log(
+            chalk.bold.green(`${message}`)
+          );
+        }
+
+        if (status === 500) {
+          status = 999;
+          throw new Error(message);
+        }
+      }
+      catch (err) {
+        if (status === 500) {
+            throw new Error(
+              `Error occurred in authentication. Please regenerate using authenticate`
+            );
+        }
+        else if (status === 999) {
+          throw new Error (err);
+        }
+      }
+
+    }
+  } catch (error) {
+
+    throw new Error(error);
+  }
+};
+
+
 export const deleteLaunchpadServerComponent = async componentKey => {
 if (showDebug) addDebugLog("deleteLaunchpadServerComponent", `componentKey: ${componentKey}`, "");
   const { server, isolationId } = await getPegaServerConfig();
@@ -1482,10 +1673,10 @@ if (showDebug) addDebugLog("getC11NB2STokenAndStaticServer", "", "");
   }
 
   if (OAuthData) {
-    const { C11NB2S, appStaticContentServer } = JSON.parse(OAuthData)
+    const { C11NB2S, appStaticContentServer, access_token } = JSON.parse(OAuthData)
 
     if (C11NB2S) {
-      return ({ C11NB2S, appStaticContentServer});
+      return ({ C11NB2S, appStaticContentServer, access_token});
     }
 
   }
@@ -1607,7 +1798,7 @@ if (showDebug) addDebugLog("deletePublishExtras", `libraryName: ${libraryName},
   // check if .DS_store file exists in Library, if so delete it because causes issue with services
 
   const currentDirectory = process.cwd();
-  const zipFile = libraryName.concat(".zip");
+  const zipFile = libraryName.concat(".arch.zip");
 
   // delete zip file
   const zipPath = join(currentDirectory, zipFile);
@@ -1691,7 +1882,7 @@ if (showDebug) addDebugLog("zipVersionAndArchive", `orgLibName: ${orgLibName}, v
   const srcDirectoryPath = join(currentDirectory, "src");
   const tasksConfig = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
   const packageJson = join(currentDirectory, PACKAGE_JSON_FILENAME);
-  const archiveFileName = `${orgLibName}_${version}.zip`;
+  const archiveFileName = `${orgLibName}_${version}.arch.zip`;
 
 
   // const configContent = Buffer.from(fs.readFileSync(configJson)).toString();
@@ -1761,6 +1952,164 @@ if (showDebug) addDebugLog("zipVersionAndArchive", `orgLibName: ${orgLibName}, v
 
 };
 
+
+
+
+export const zipVersionAndArchiveAndReturnBuffer = async (orgLibName, version, currentDirectory = "") => {
+if (showDebug) addDebugLog("zipVersionAndArchive", `orgLibName: ${orgLibName}, version: ${version}`, "");
+  // const srcDirectoryPath = await getSrcDirectoryPath();
+  if (currentDirectory === "") {
+    currentDirectory = process.cwd();
+  }
+  const srcDirectoryPath = join(currentDirectory, "src");
+  const tasksConfig = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+  const packageJson = join(currentDirectory, PACKAGE_JSON_FILENAME);
+  const archiveFileName = `${orgLibName}_${version}.arch.zip`;
+
+
+  // const configContent = Buffer.from(fs.readFileSync(configJson)).toString();
+  const mainDirectory = process.cwd();
+  const archiveDirectory = join (mainDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
+  if (!fs.existsSync(archiveDirectory)) {
+    fs.mkdirSync(archiveDirectory, { recursive: true });
+  }
+
+  // create componentsconfig.json
+  await createComponentsConfigFile(archiveDirectory, join(srcDirectoryPath, "components"));
+
+  const archiveFile = join(archiveDirectory, archiveFileName);
+  if (fs.existsSync(orgLibName)) {
+
+  }
+
+  const output = fs.createWriteStream(archiveFile);
+  const archive = archiver('zip', {
+    zlib: { level: 9 } // Sets the compression level.
+  });
+
+  const zipChunks = [];
+  archive.on('data', chunk => zipChunks.push(chunk));
+
+
+  // Add src directory
+  archive.directory(srcDirectoryPath, 'src');
+
+  // grab all files (not directories and archive)
+  const configFiles = await getTopLevelConfigFiles(currentDirectory);
+  if (configFiles && configFiles.length > 0) {
+    for (const configF of configFiles) {
+      if (configF !== "package-lock.json") {
+        archive.file(
+          join(currentDirectory, configF), { name: configF });
+      }
+
+    }
+  }
+
+  // pipe archive data to the file
+  archive.pipe(output);
+
+  output.on('end', function() {
+    console.log('Data has been drained');
+  });
+
+
+  // good practice to catch warnings (ie stat failures and other non-blocking errors)
+  archive.on('warning', function(err) {
+    if (err.code === 'ENOENT') {
+      // log warning
+    } else {
+      // throw error
+      throw err;
+    }
+  });
+
+  // good practice to catch this error explicitly
+  archive.on('error', function(err) {
+    throw err;
+  });
+
+  await archive.finalize();
+
+  const zipBuffer = Buffer.concat(zipChunks);
+  const zipContent = zipBuffer.toString('base64');
+
+  return { output, zipContent};
+
+};
+
+export const zipUnArchiveToTempAndReturnBuffer = async(orgLibName, version) => {
+
+  // unarchive to temp
+  const currentDirectory = process.cwd();
+  const tempDirectory = join (currentDirectory, TEMP_PATH);
+  const srcDirectoryPath = join(tempDirectory, "src");
+
+  const archiveFileName = `${orgLibName}_${version}.arch.zip`;
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
+  const archFileName = join(archiveDirectory, archiveFileName);
+
+  await unZipFromArchive(archFileName);
+
+  // archive is in temp directory
+  const archiveFile = join(tempDirectory, archiveFileName);
+
+  const output = fs.createWriteStream(archiveFile);
+  const archive = archiver('zip', {
+    zlib: { level: 9 } // Sets the compression level.
+  });
+
+  const zipChunks = [];
+  archive.on('data', chunk => zipChunks.push(chunk));
+
+  // Add src directory
+  archive.directory(srcDirectoryPath, 'src');
+
+  // grab all files (not directories and archive)
+  const configFiles = await getTopLevelConfigFiles(tempDirectory);
+  if (configFiles && configFiles.length > 0) {
+    for (const configF of configFiles) {
+      if (configF !== "package-lock.json") {
+        archive.file(
+          join(tempDirectory, configF), { name: configF });
+      }
+
+    }
+  }
+
+  // pipe archive data to the file
+  archive.pipe(output);
+
+  output.on('end', function() {
+    console.log('Data has been drained');
+  });
+
+
+  // good practice to catch warnings (ie stat failures and other non-blocking errors)
+  archive.on('warning', function(err) {
+    if (err.code === 'ENOENT') {
+      // log warning
+    } else {
+      // throw error
+      throw err;
+    }
+  });
+
+  // good practice to catch this error explicitly
+  archive.on('error', function(err) {
+    throw err;
+  });
+
+  await archive.finalize();
+
+  const zipBuffer = Buffer.concat(zipChunks);
+  const zipContent = zipBuffer.toString('base64');
+
+  return { output, zipContent};
+
+
+}
+
 export const zipVersionAndArchiveCL = async (orgLibName, version, currentDirectory = "") => {
 if (showDebug) addDebugLog("zipVersionAndArchiveCL", `orgLibName: ${orgLibName}, version: ${version}, currentDirectory: ${currentDirectory}`, "");
   // const srcDirectoryPath = await getSrcDirectoryPath();
@@ -2095,8 +2444,12 @@ if (showDebug) addDebugLog("restoreFromArchive", `fileName: ${fileName}, orgLibN
   const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
   const archFileName = join(archiveDirectory, fileName);
 
-  await unZipFromArchive(archFileName);
 
+  if (!fs.existsSync(archiveDirectory)) {
+    throw new Error (`Archive ${orgLibName}/${version} does NOT exist.`);
+  }
+
+  await unZipFromArchive(archFileName);
 
   const tempPackagePath = join (tempDirectory, PACKAGE_JSON_FILENAME);
   const currentPackagePath = join(currentDirectory, PACKAGE_JSON_FILENAME);
@@ -2211,21 +2564,6 @@ if (showDebug) addDebugLog("checkLibraryAndArchives", ``, "");
 
 export const hasLibraryAndVersion = async (libraryName, version, devBuild) => {
 if (showDebug) addDebugLog("hasLibraryAndVersion", `libraryName: ${libraryName}, version: ${version}, devBuild: ${devBuild}`, "");
-  // const orgLib = getConfigDefaults();
-  // const currentOrgLib = `${orgLib.organization}_${libraryName}`;
-  // const libFiles = await getLibraryArchivesFiles(currentOrgLib);
-  // let currentVersion = version;
-  // if (devBuild) {
-  //   currentVersion = currentVersion.concat("-dev");
-  // }
-  // const fileName = `${currentOrgLib}_${currentVersion}.zip`;
-  // if (libFiles && libFiles.length > 0) {
-  //   if (libFiles.includes(fileName)) {
-  //     return true;
-  //   }
-  // }
-
-  // return false;
 
   const orgLib = getConfigDefaults();
   const currentOrgLib = `${orgLib.organization}_${libraryName}`;
@@ -2360,6 +2698,20 @@ if (showDebug) addDebugLog("getJestFunctionalTestList", ``, "");
 
 }
 
+export const getSubTypeLabel = (type, subtype) => {
+  const subTypeList = COMPONENT_SCHEMA.subtype;
+  const typeList = subTypeList[type.toLowerCase()];
+
+  for (let i in typeList) {
+    if (typeList[i]['value'] === subtype) {
+      const label = typeList[i]['name'].replace("&", "and");
+      return label;
+    }
+  }
+
+  return "";
+}
+
 
 // init
 await forceDefaultsUpdate();