@contrail/cli 1.0.71 → 2.0.1

package/src/types/types-uploader.ts

@@ -1,271 +0,0 @@
-import { Entities, Request } from '@contrail/sdk';
-import { ReducedType } from './interfaces';
-import chalk from 'chalk';
-import fs from 'fs';
-import { authUser } from '../auth/login';
-import * as path from 'path';
-import * as _ from 'lodash';
-
-import yaml from 'js-yaml';
-
-export async function uploadTypes() {
-  try {
-    const userConfig = await authUser();
-    console.log(`%s Getting all types for orgId: ${userConfig.orgId}`, chalk.blue.bold('START'));
-
-    console.log('%s Uploading', chalk.yellow.bold('TYPES'));
-    await uploadReducedTypes();
-    console.log('%s Uploaded', chalk.yellow.bold('TYPES'));
-
-  }
-  catch (e) {
-    console.log(`%s Types Upload Failed. ${e}`, chalk.red.bold('FAIL'));
-    return;
-  }
-
-  console.log('%s Types Upload Complete.', chalk.green.bold('COMPLETE'));
-}
-
-function loadReducedTypes(){
-  const TARGET_DIR = process.cwd();
-  try {
-    const files = fs.readdirSync(path.join(TARGET_DIR, 'types'));
-    const types = [];
-    for(const file of files) {
-      types.push(...yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'types', file), 'utf8')));
-    }
-    return types;
-  } catch (e) {
-    throw new Error(`ERROR PARSING YAML: ${e}`);
-  }
-}
-
-async function uploadReducedTypes() {
-  const types: ReducedType[] = loadReducedTypes();
-
-  const currentTypesWithoutProperties = await new Entities().get({
-    entityName: 'type',
-  });
-
-  const currentTypes = [];
-  for (const currentTypeWithoutProperties of currentTypesWithoutProperties) {
-    const typeWithProperties = await new Entities().get({
-      entityName: 'type',
-      id: currentTypeWithoutProperties.id,
-      relations: ['typeProperties'],
-    });
-    currentTypes.push(typeWithProperties);
-  }
-
-  const currentTypesBySlug = {};
-  for (const currentType of currentTypes) {
-    currentTypesBySlug[currentType.slug] = currentType;
-  }
-
-  const newTypesBySlug = {};
-  for (const type of types) {
-    newTypesBySlug[type.slug] = type;
-  }
-
-  for (const type of types) {
-    try {
-      const found = currentTypesBySlug[type.slug];
-      if (!found) {
-        if (!type.typePath.includes(':')) {
-          console.log('Cannot create a base type. Skipping: ', type.slug);
-          continue;
-        }
-
-        console.log('Creating Type: ', type.slug);
-
-        const createdType = await new Entities().create({
-          entityName: 'type',
-          object: {
-            slug: type.slug,
-            label: type.label,
-            typePath: type.typePath,
-            isArchived: type.isArchived,
-          },
-        });
-
-        await uploadReducedTypeProperties(createdType, [], type.typeProperties);
-      }
-      else
-      {
-        console.log('Updating Type: ', type.slug);
-        const updatedType = await new Entities().update({
-          entityName: 'type',
-          id: found.id,
-          object: {
-            slug: type.slug,
-            label: type.label,
-            typePath: type.typePath,
-            isArchived: type.isArchived,
-          },
-        });
-
-        await uploadReducedTypeProperties(updatedType, found.typeProperties, type.typeProperties);
-      }
-
-    } catch (err) {
-      console.log('Error Uploading Types: ', err);
-    }
-  }
-
-  for (const currentType of currentTypes) {
-    try {
-      const found = newTypesBySlug[currentType.slug];
-      if (!found) {
-        console.log('Deleting Type: ', currentType.slug);
-        await new Entities().delete({
-          entityName: 'type',
-          id: currentType.id,
-        });
-      }
-    } catch (err) {
-      throw new Error(`Error Deleting Types: ${err}`);
-    }
-  }
-
-}
-
-async function uploadReducedTypeProperties(type, currentPropertyTypes, newPropertyTypes) {
-  const currentPropertyTypeBySlug = {};
-  for (const currentPropertyType of currentPropertyTypes) {
-    currentPropertyTypeBySlug[currentPropertyType.slug] = currentPropertyType;
-  }
-
-  const newPropertyTypesBySlug = {};
-  for (const newPropertyType of newPropertyTypes) {
-    newPropertyTypesBySlug[newPropertyType.slug] = newPropertyType;
-  }
-
-  const optionSets = await new Entities().get({
-    entityName: 'type-property-option-set',
-  });
-
-  const optionSetIdByName = {};
-  for (const optionSet of optionSets) {
-    optionSetIdByName[optionSet.name] = optionSet.id;
-  }
-
-  for (const newPropertyType of newPropertyTypes) {
-    try {
-      const found = currentPropertyTypeBySlug[newPropertyType.slug];
-      if (!found && !newPropertyType.inherited) {
-        console.log('Creating Type-Property: ', newPropertyType.slug);
-
-        await Request.request(
-          `/types/${type.id}/type-properties`,
-          {
-            method: 'POST',
-            body: JSON.stringify({
-              isArchived: newPropertyType.isArchived,
-              propertyType: newPropertyType.propertyType,
-              slug: newPropertyType.slug,
-              label: newPropertyType.label,
-              editable: newPropertyType.editable,
-              searchable: newPropertyType.searchable,
-              core: newPropertyType.core,
-              typePropertyOptionSetId: optionSetIdByName[newPropertyType.typePropertyOptionSetName],
-              formula: newPropertyType.formula,
-              referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
-              defaultValue: newPropertyType.defaultValue,
-              propertyLevel: newPropertyType.propertyLevel,
-              formulaFunction: newPropertyType.formulaFunction,
-              validationFunction: newPropertyType.validationFunction,
-            }),
-            headers: {
-              Accept: 'application/json',
-              'Content-Type': 'application/json',
-            },
-          });
-      }
-      else if (found && !newPropertyType.inherited && !typePropertiesEqual(found, newPropertyType, optionSetIdByName)) {
-        console.log('Updating Type-Property: ', newPropertyType.slug);
-        await new Entities().update({
-          entityName: 'type-property',
-          id: found.id,
-          object: {
-            isArchived: newPropertyType.isArchived,
-            propertyType: newPropertyType.propertyType,
-            slug: newPropertyType.slug,
-            label: newPropertyType.label,
-            editable: newPropertyType.editable,
-            searchable: newPropertyType.searchable,
-            core: newPropertyType.core,
-            typePropertyOptionSetId: optionSetIdByName[newPropertyType.typePropertyOptionSetName],
-            formula: newPropertyType.formula,
-            referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
-            defaultValue: newPropertyType.defaultValue,
-            propertyLevel: newPropertyType.propertyLevel,
-            formulaFunction: newPropertyType.formulaFunction,
-            validationFunction: newPropertyType.validationFunction,
-          },
-        });
-      }
-
-    } catch (err) {
-      console.log('Error Creating Properties: ', err);
-    }
-  }
-
-  for (const currentPropertyType of currentPropertyTypes) {
-    try {
-      const found = newPropertyTypesBySlug[currentPropertyType.slug];
-      if (!found && !currentPropertyType.inherited) {
-        console.log('Deleting Type-Property: ', currentPropertyType.slug);
-        await Request.request(
-          `/types/${type.id}/type-properties/${currentPropertyType.id}`,
-          {
-            method: 'DELETE',
-            headers: {
-              Accept: 'application/json',
-              'Content-Type': 'application/json',
-            },
-          });
-      }
-    } catch (err) {
-      throw new Error(`Error Deleting Properties: ${err}`);
-    }
-  }
-}
-
-function typePropertiesEqual(typeProperty1, typeProperty2, optionSetIdByName): boolean {
-
-  const reducedProperty1 = {
-    isArchived: typeProperty1.isArchived,
-    propertyType: typeProperty1.propertyType,
-    slug: typeProperty1.slug,
-    label: typeProperty1.label,
-    editable: typeProperty1.editable,
-    searchable: typeProperty1.searchable,
-    core: typeProperty1.core,
-    typePropertyOptionSetId: optionSetIdByName[typeProperty1.typePropertyOptionSetName],
-    formula: typeProperty1.formula,
-    referencedTypeRootSlug: typeProperty1.referencedTypeRootSlug,
-    defaultValue: typeProperty1.defaultValue,
-    propertyLevel: typeProperty1.propertyLevel,
-    formulaFunction: typeProperty1.formulaFunction,
-    validationFunction: typeProperty1.validationFunction,
-  };
-
-  const reducedProperty2 = {
-    isArchived: typeProperty2.isArchived,
-    propertyType: typeProperty2.propertyType,
-    slug: typeProperty2.slug,
-    label: typeProperty2.label,
-    editable: typeProperty2.editable,
-    searchable: typeProperty2.searchable,
-    core: typeProperty2.core,
-    typePropertyOptionSetId: optionSetIdByName[typeProperty2.typePropertyOptionSetName],
-    formula: typeProperty2.formula,
-    referencedTypeRootSlug: typeProperty2.referencedTypeRootSlug,
-    defaultValue: typeProperty2.defaultValue,
-    propertyLevel: typeProperty2.propertyLevel,
-    formulaFunction: typeProperty2.formulaFunction,
-    validationFunction: typeProperty2.validationFunction,
-  };
-
-  return _.isEqual(reducedProperty1, reducedProperty2);
-}

package/src/types/usage-info-uploader.ts

@@ -1,139 +0,0 @@
-import { Entities } from '@contrail/sdk';
-import fs from 'fs';
-import { authUser } from '../auth/login';
-import chalk from 'chalk';
-import { getTypes } from './types-extractor';
-import * as path from 'path';
-
-const yaml = require('js-yaml');
-
-export async function uploadUsageInfo(args) {
-  try {
-    await authUser();
-
-    console.log('%s Uploading', chalk.yellow.bold('USAGE INFO'));
-    const reducedUsageInfo = await loadUsageInfo();
-    await uploadUsageInfoObjects(reducedUsageInfo);
-    console.log('%s Uploaded', chalk.yellow.bold('USAGE INFO'));
-
-  }
-  catch (e) {
-    console.log(`%s Usage Info Upload Failed. ${e}`, chalk.red.bold('FAIL'));
-    return;
-  }
-
-  console.log('%s Usage Info Upload Complete.', chalk.green.bold('COMPLETE'));
-}
-
-function loadUsageInfo() {
-  const TARGET_DIR = process.cwd();
-  try {
-    const doc = yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'usage-info.yml'), 'utf8'));
-    return doc;
-  } catch (e) {
-    throw new Error(`ERROR PARSING YAML: ${e}`);
-  }
-}
-
-async function uploadUsageInfoObjects(loadedUsageInfo) {
-  const typesWithProperties = await getTypes();
-  const typeProperties = typesWithProperties
-    .filter(t=>!!t.typeProperties)
-    .map(t => t.typeProperties)
-    .reduce((a, b) => a.concat(b));
-
-  const currentUsageInfo = await new Entities().get({
-    entityName: 'type-property-usage-info',
-  });
-
-  const currentUsageInfosHashes = {};
-  for(const currentUI of currentUsageInfo) {
-    const foundType = typesWithProperties.find(t => t.id === currentUI.typeId);
-    const foundTypeProperty = typeProperties.find(tp => tp.id === currentUI.typePropertyId);
-    if(!foundType || !foundTypeProperty) {
-      console.log('skipping unhashable, invalid usage info:', currentUI);
-      continue;
-    }
-    const hash = `${foundType.slug}|${foundTypeProperty.slug}`;
-    currentUsageInfosHashes[hash] = currentUI;
-  }
-
-  const reducedUsageInfoHashes = {};
-  for(const loadedUI of loadedUsageInfo) {
-    const hash = `${loadedUI.typeSlug}|${loadedUI.typePropertySlug}`;
-    reducedUsageInfoHashes[hash] = loadedUI;
-  }
-  console.debug('current usage info:', currentUsageInfo);
-  console.debug('loaded usage info:', loadedUsageInfo);
-
-  for (const loadedUI of loadedUsageInfo) {
-    try {
-      const found = currentUsageInfosHashes[`${loadedUI.typeSlug}|${loadedUI.typePropertySlug}`];
-      if (!found) {
-        if (!transformReducedUI(loadedUI, typesWithProperties, typeProperties)) { continue; }
-        console.debug('Creating: ', loadedUI);
-        await new Entities().create({
-          entityName: 'type-property-usage-info',
-          object: {
-            typePropertyId: loadedUI.typePropertyId,
-            typeId: loadedUI.typeId,
-            editable: loadedUI.editable,
-            used: loadedUI.used,
-            formulaFunction: loadedUI.formulaFunction,
-            validationFunction: loadedUI.validationFunction,
-            numberFormat: loadedUI.numberFormat,
-            defaultValue: loadedUI.defaultValue,
-            label: loadedUI.label,
-          }
-        });
-      } else {
-        if (!transformReducedUI(loadedUI, typesWithProperties, typeProperties)) { continue; }
-        console.log('Updating: ', loadedUI);
-        await new Entities().update({
-          entityName: 'type-property-usage-info',
-          id: found.id,
-          object: {
-            editable: loadedUI.editable,
-            used: loadedUI.used,
-          }
-        });
-      }
-    } catch (err) {
-      throw new Error(`Error Uploading usage info: ${err}`);
-    }
-  }
-
-  for (const [hash, currentUI] of Object.entries(currentUsageInfosHashes)) {
-    try {
-      const found = reducedUsageInfoHashes[hash];
-      if (!found) {
-        console.debug('Deleting: ', hash);
-        await new Entities().delete({
-          entityName: 'type-property-usage-info',
-          id: currentUI['id'],
-        });
-      }
-    } catch (err) {
-      throw new Error(`Error Deleting usage info: ${err}`);
-    }
-  }
-
-}
-
-// transforms the reduced Usage Info from name slugs to ids
-function transformReducedUI(reducedUsageInfo, types, typeProperties) {
-  const foundType = types.find(t => t.slug === reducedUsageInfo.typeSlug);
-  if (!foundType) {
-    console.error('Could not find type with slug', reducedUsageInfo.typeSlug, 'while transforming', reducedUsageInfo);
-    return false;
-  }
-  reducedUsageInfo.typeId = foundType.id;
-
-  const foundTypeProperty = typeProperties.find(tp => tp.slug === reducedUsageInfo.typePropertySlug);
-  if (!foundTypeProperty) {
-    console.error('Could not find type property with slug', reducedUsageInfo.typePropertySlug, 'while transforming', reducedUsageInfo);
-    return false;
-  }
-  reducedUsageInfo.typePropertyId = foundTypeProperty.id;
-  return true;
-}

package/src/users/user-exporter.ts

@@ -1,52 +0,0 @@
-import { Entities } from '@contrail/sdk';
-import chalk from 'chalk';
-import fs from 'fs';
-import { authUser } from '../auth/login';
-import { getSeparatorByPlatform } from '../common';
-import yaml from 'js-yaml';
-
-export async function ExportUsers() {
-  try {
-    await authUser();
-    console.log('%s Getting Users.', chalk.blue.bold('START'));
-
-    await exportUsers();
-    console.log('%s Done', chalk.yellow.bold('USERS'));
-
-  }
-  catch (e) {
-    console.log(`%s Users download Failed. ${e}`, chalk.red.bold('FAIL'));
-    return;
-  }
-
-  console.log('%s Users download Complete.', chalk.green.bold('COMPLETE'));
-}
-
-async function exportUsers() {
-  const allUsersInOrg = await new Entities().get({
-    entityName: 'user-org',
-  });
-
-  const users = [];
-  for (const userInOrg of allUsersInOrg) {
-    delete userInOrg.user.id;
-    delete userInOrg.user.updatedBy;
-    delete userInOrg.user.createdBy;
-    if (userInOrg.user.email.includes('@vibeappuser.com')) {
-      continue;
-    }
-    users.push({
-      role: userInOrg.role,
-      ...userInOrg.user
-    });
-  }
-
-  saveData({users: users}, 'users');
-}
-
-function saveData(data, name) {
-  const yamlStr = yaml.dump(data);
-  const CURRENT_DIR = process.cwd();
-  const separator = getSeparatorByPlatform();
-  fs.writeFileSync(CURRENT_DIR + separator + name + '-export.yml', yamlStr, 'utf8');
-}

package/src/users/user-uploader.ts

@@ -1,58 +0,0 @@
-import { Entities } from '@contrail/sdk';
-import chalk from 'chalk';
-import fs from 'fs';
-import { authUser } from '../auth/login';
-import * as path from 'path';
-
-import yaml from 'js-yaml';
-
-export async function UploadUsers() {
-  try {
-    await authUser();
-    console.log('%s Uploading Users.', chalk.blue.bold('START'));
-
-    console.log('%s Uploading', chalk.yellow.bold('USER'));
-    await uploadUsers();
-    console.log('%s Uploaded', chalk.yellow.bold('USER'));
-
-  }
-  catch (e) {
-    console.log(`%s User Upload Failed. ${e}`, chalk.red.bold('FAIL'));
-    return;
-  }
-
-  console.log('%s User Upload Complete.', chalk.green.bold('COMPLETE'));
-}
-
-function getUsersFile(){
-  const CURRENT_DIR = process.cwd();
-  try {
-    const fullPath = path.join(CURRENT_DIR, 'users.yml');
-    console.log('Getting file from path: ', fullPath);
-
-    const doc = yaml.load(fs.readFileSync(fullPath, 'utf8'));
-    return doc.users;
-  } catch (e) {
-    throw new Error(`ERROR PARSING YAML: ${e}`);
-  }
-}
-
-async function uploadUsers() {
-  const users = getUsersFile();
-
-  for (const user of users) {
-    const role = user.role;
-    const email = user.email;
-    delete user.role;
-    delete user.email;
-
-    await new Entities().create({
-      entityName: 'user-org',
-      object: {
-        role: role,
-        userEmail: email,
-        ...user
-      }
-    });
-  }
-}

package/src/workflow-template-definitions/workflow-template-definition-commands.ts

@@ -1,13 +0,0 @@
-
-import { authUser } from '../auth/login';
-import { WorkflowTemplateDefinitionDeployer } from './workflow-template-definition-deployer';
-
-export async function cliInstallWorkflowTemplateDefinitions() {
-  await authUser();
-  await new WorkflowTemplateDefinitionDeployer().cliInstallWorkflowTemplateDefinitions();
-}
-
-export async function listWorkflowTemplateDefinitions() {
-  await authUser();
-  await new WorkflowTemplateDefinitionDeployer().listWorkflowTemplateDefinitions();
-}