@contrail/cli 1.0.71 → 2.0.1

package/src/types/types-extractor.ts

@@ -1,369 +0,0 @@
-import { Entities } from '@contrail/sdk';
-import { ReducedType, ReducedTypeProperty } from './interfaces';
-import chalk from 'chalk';
-import fs from 'fs';
-import { authUser } from '../auth/login';
-import * as path from 'path';
-import pLimit from 'p-limit';
-const limit = pLimit(30);
-
-const yaml = require('js-yaml');
-interface StoreFunction
-{
-    (data: ReducedDataHolder, dir: string): void;
-}
-
-export interface DataHolder {
-  types: any[],
-  optionSets: any[],
-  optionSetHierarchies: any[],
-  ruleSets: any[],
-  ruleSetLinks: any[],
-  usageInfo: any[],
-  typePropertyPolicies: any[],
-  typePropertyPolicyLinks: any[],
-}
-
-export interface ReducedDataHolder {
-  reducedTypes: any[],
-  reducedOptionSets: any[],
-  reducedOptionSetHierarchies: any[],
-  reducedRuleSets: any[],
-  reducedRuleSetLinks: any[],
-  reducedUsageInfo: any[],
-  reducedTypePropertyPolicies: any[],
-  reducedTypePropertyPolicyLinks: any[],
-}
-
-export async function getAll(args) {
-  try {
-    const userConfig = await authUser();
-    console.log(`%s Getting all types for orgId: ${userConfig.orgId}`, chalk.blue.bold('START'));
-
-    // make directory to house exports
-    const dir = `./contrail-export-${Date.now()}`;
-    fs.mkdirSync(dir);
-
-    const data: DataHolder = {
-      types: await getTypes(),
-      optionSets: await getOptionSets(),
-      optionSetHierarchies: await getOptionSetHierarchies(),
-      ruleSets: await getRuleSets(),
-      ruleSetLinks: await getRuleSetLinks(),
-      usageInfo: await getUsageInfo(),
-      typePropertyPolicies: await getTypePropertyPolicies(),
-      typePropertyPolicyLinks: await getTypePropertyPolicyLinks(),
-    };
-    const reducedData = reduceData(data);
-    saveData(reducedData, dir);
-
-    console.log('%s Retrieved', chalk.yellow.bold('TYPES'));
-  }
-  catch (e) {
-    console.log(`%s Types Retrieval Failed. ${e}`, chalk.red.bold('FAIL'));
-    return;
-  }
-
-  console.log('%s Types Retrieval Complete.', chalk.green.bold('COMPLETE'));
-}
-
-/**
- *  stores reduced option sets and returns full option sets */
-export async function getOptionSets() {
-  console.log('%s Retrieving', chalk.yellow.bold('OPTION SETS'));
-  const optionSets = await new Entities().get({
-    entityName: 'type-property-option-set',
-  });
-  console.log('%s Retrieved', chalk.yellow.bold('OPTION SETS'));
-  return optionSets;
-}
-
-export async function getTypes() {
-  console.log('%s Retrieving', chalk.yellow.bold('TYPES'));
-  const entitiesClient = new Entities();
-  const types = await entitiesClient.get({
-    entityName: 'type',
-  });
-  console.log(`${chalk.yellow.bold('TYPES')} Found ${types.length} types`);
-  const typesWithProperties = [];
-  const promises = [];
-  for (const type of types) {
-    const promise = limit(async () => {
-      const t = await entitiesClient.get({
-        entityName: 'type',
-        id: type.id,
-        relations: ['typeProperties'],
-      });
-      typesWithProperties.push(t);
-    });
-    promises.push(promise);
-  }
-  await Promise.all(promises);
-  return typesWithProperties;
-}
-
-async function getOptionSetHierarchies() {
-  const entitiesClient = new Entities();
-  return await entitiesClient.get({
-    entityName: 'option-set-hierarchy',
-  });
-}
-
-async function getRuleSets() {
-  const entitiesClient = new Entities();
-  return await entitiesClient.get({
-    entityName: 'type-rule-set',
-  });
-}
-
-async function getRuleSetLinks() {
-  const entitiesClient = new Entities();
-  return await entitiesClient.get({
-    entityName: 'type-rule-set-link',
-  });
-}
-
-async function getUsageInfo() {
-  const entitiesClient = new Entities();
-  return await entitiesClient.get({
-    entityName: 'type-property-usage-info',
-  });
-}
-
-async function getTypePropertyPolicies() {
-  const entitiesClient = new Entities();
-  return await entitiesClient.get({
-    entityName: 'type-property-policy',
-  });
-}
-async function getTypePropertyPolicyLinks() {
-  const entitiesClient = new Entities();
-  return await entitiesClient.get({
-    entityName: 'type-property-policy-link',
-  });
-}
-
-function reduceTypePropertyPolicies(data: DataHolder) {
-  return data?.typePropertyPolicies?.map(x => {
-    return {
-      label: x.label,
-      policy: {
-        version: x.policy.version,
-        statements: x.policy.statements,
-      }
-    };
-  });
-}
-
-function reduceTypePropertyPolicyLinks(data: DataHolder) {
-  const typeProperties = data?.types?.map(x => x.typeProperties).reduce((x, y) => x.concat(y));
-  return data?.typePropertyPolicyLinks?.map(x => {
-    return {
-      typePropertySlug: typeProperties.find(y => y.id === x.typePropertyId)?.slug,
-      typePropertyPolicyLabel: data.typePropertyPolicies.find(y => y.id === x.typePropertyPolicyId)?.label,
-    };
-  });
-}
-
-function reduceUsageInfo(data: DataHolder) {
-  const typeProperties = data?.types?.map(x => x.typeProperties).reduce((x, y) => x.concat(y));
-  return data?.usageInfo?.map(x => {
-    return {
-      used: x.used,
-      editable: x.editable,
-      formulaFunction: x.formulaFunction,
-      validationFunction: x.validationFunction,
-      numberFormat: x.numberFormat,
-      defaultValue: x.defaultValue,
-      label: x.label,
-      typeSlug: data.types.find(y => y.id === x.typeId)?.slug,
-      typePropertySlug: typeProperties.find(y => y.id === x.typePropertyId)?.slug,
-    };
-  });
-}
-
-function reduceRuleSetLinks(data: DataHolder) {
-  const reducedRuleSetLinks = [];
-  if (!data?.ruleSetLinks.length) {
-    return [];
-  }
-  for (const ruleSetLink of data.ruleSetLinks) {
-    const ruleSet = data?.ruleSets?.find(x => x.id === ruleSetLink.typeRuleSetId);
-    const type = data?.types?.find(x => x.id === ruleSetLink.typeId);
-
-    if (!ruleSet || !type) {
-      console.log('%s Skipping bad rule set link', ruleSetLink.id, chalk.red.bold('TYPES'));
-    }
-    reducedRuleSetLinks.push({
-      ruleSet: ruleSet.name,
-      type: type.slug
-    });
-  }
-  return reducedRuleSetLinks;
-}
-
-function reduceRuleSets(data: DataHolder) {
-  return data?.ruleSets?.map(x => {
-    return {
-      ruleSet: x.ruleSet,
-      name: x.name,
-    };
-  });
-}
-
-function reduceOptionSets(data: DataHolder) {
-  return data.optionSets?.map(optionSet => {
-    return {
-      name: optionSet.name,
-      isArchived: optionSet.isArchived,
-      optionSet: optionSet.optionSet,
-    };
-  });
-}
-
-function reduceOptionSetHierarchies(data: DataHolder) {
-  return data.optionSetHierarchies?.map(x => {
-    const hierarchyByName = x.hierarchy.map(
-      optionSetId => data.optionSets?.find(x => x.id === optionSetId)?.name
-    );
-    return {
-      hierarchy: hierarchyByName,
-      options: x.options,
-      name: x.name
-    };
-  });
-}
-
-export function reduceTypes(dataHolder: DataHolder) {
-  console.log('Found types: ', dataHolder.types.length);
-
-  let reducedTypes = [];
-  const optionSetNameById = {};
-  for (const optionSet of dataHolder.optionSets) {
-    optionSetNameById[optionSet.id] = optionSet.name;
-  }
-  for (const type of dataHolder.types) {
-    const reducedTypeProperties = [];
-    for (const typeProperty of type.typeProperties) {
-      const reducedTypeProperty: ReducedTypeProperty = {
-        slug: typeProperty.slug,
-        id: typeProperty.id,
-        isArchived: typeProperty.isArchived,
-        propertyType: typeProperty.propertyType,
-        label: typeProperty.label,
-        editable: typeProperty.editable,
-        searchable: typeProperty.searchable,
-        core: typeProperty.core,
-        typePropertyOptionSetName: optionSetNameById[typeProperty.typePropertyOptionSetId],
-        formula: typeProperty.formula,
-        referencedTypeRootSlug: typeProperty.referencedTypeRootSlug,
-        defaultValue: typeProperty.defaultValue,
-        propertyLevel: typeProperty.propertyLevel,
-        inherited: typeProperty.inherited,
-        formulaFunction: typeProperty.formulaFunction,
-        validationFunction: typeProperty.validationFunction,
-        numberFormat: typeProperty.numberFormat,
-      };
-
-      reducedTypeProperties.push(reducedTypeProperty);
-    }
-
-    const reducedType: ReducedType = {
-      typePath: type.typePath,
-      slug: type.slug,
-      label: type.label,
-      isArchived: type.isArchived,
-      typeProperties: reducedTypeProperties,
-    };
-
-    reducedTypes.push(reducedType);
-  }
-
-  reducedTypes = reducedTypes.sort((one, two) => (one.typePath < two.typePath ? -1 : 1));
-  return reducedTypes;
-}
-
-export function reduceData(data: DataHolder): ReducedDataHolder {
-  return {
-    reducedTypes: reduceTypes(data),
-    reducedOptionSets: reduceOptionSets(data),
-    reducedOptionSetHierarchies: reduceOptionSetHierarchies(data),
-    reducedRuleSets: reduceRuleSets(data),
-    reducedRuleSetLinks: reduceRuleSetLinks(data),
-    reducedUsageInfo: reduceUsageInfo(data),
-    reducedTypePropertyPolicies: reduceTypePropertyPolicies(data),
-    reducedTypePropertyPolicyLinks: reduceTypePropertyPolicyLinks(data),
-  };
-}
-
-const saveTypesFunction: StoreFunction = function (data: ReducedDataHolder, dir: string) {
-  const roots = {};
-  for(const type of data.reducedTypes) {
-    const typePathParts = type.typePath.split(':');
-    if(!typePathParts) {
-      console.warn('skipping bad type with no path', type);
-    }
-    const root = typePathParts[0];
-    if(roots[root]) {
-      roots[root].push(type);
-    } else {
-      roots[root] = [type];
-    }
-  }
-  for(const [root, types] of Object.entries(roots)) {
-    const CURRENT_DIR = process.cwd();
-    const subDir = path.join(CURRENT_DIR, dir, 'types');
-    if(!fs.existsSync(subDir)) {
-      fs.mkdirSync(subDir);
-    }
-    const yamlStr = yaml.dump(types);
-    const fileLabel = root;
-    if(!fileLabel) {
-      console.warn('skipping bad type root:', root);
-    }
-    fs.writeFileSync(path.join(subDir, `${removeSlash(fileLabel)}.yml`), yamlStr, 'utf8');
-  }
-
-};
-
-function saveData(reducedData, dir: string) {
-
-  const propertyToFolderMap = {
-    reducedTypes: { filename: 'types', split: false, fileLabel: 'slug', saveFunction:  saveTypesFunction},
-    reducedOptionSets: { filename: 'option-sets', split: true, fileLabel: 'name' },
-    reducedOptionSetHierarchies: { filename: 'option-set-hierarchies', split: true, fileLabel: 'name' },
-    reducedRuleSets: { filename: 'rule-sets', split: true, fileLabel: 'name' },
-    reducedRuleSetLinks: { filename: 'rule-set-links', split: false, fileLabel: '' },
-    reducedUsageInfo: { filename: 'usage-info', split: false, fileLabel: '' },
-    reducedTypePropertyPolicies: { filename: 'type-property-policies', split: true, fileLabel: 'label' },
-    reducedTypePropertyPolicyLinks: { filename: 'type-property-policy-links', split: false, fileLabel: '' },
-  };
-  for(const [key, folder] of Object.entries(propertyToFolderMap)) {
-    const CURRENT_DIR = process.cwd();
-    if(folder['saveFunction']) {
-      folder['saveFunction'](reducedData, dir);
-    } else if(folder.split) {
-      const subDir = path.join(CURRENT_DIR, dir, folder.filename);
-      if(!fs.existsSync(subDir)) {
-        fs.mkdirSync(subDir);
-      }
-      for(const item of reducedData[key]) {
-        const yamlStr = yaml.dump(item);
-        const fileLabel = item[folder.fileLabel];
-        if(!fileLabel) {
-          console.warn('skipping bad data:', item);
-        }
-        fs.writeFileSync(path.join(subDir, `${removeSlash(fileLabel)}.yml`), yamlStr, 'utf8');
-      }
-    } else {
-      const yamlStr = yaml.dump(reducedData[key]);
-      fs.writeFileSync(path.join(CURRENT_DIR, dir, `${folder.filename}.yml`), yamlStr, 'utf8');
-    }
-
-  }
-}
-
-function removeSlash(string) {
-  const re = /\//gi;
-  return string.replace(re, '-');
-}

package/src/types/types-properties-merger.ts

@@ -1,90 +0,0 @@
-import { DataHolder, getOptionSets, getTypes, reduceData } from './types-extractor';
-import { ReducedTypeProperty, ReducedType } from './interfaces';
-import fs from 'fs';
-import { getSeparatorByPlatform } from '../common';
-import { authUser } from '../auth/login';
-import chalk from 'chalk';
-const yaml = require('js-yaml');
-
-export async function MergeTypeProperties(args) {
-  try {
-    if (args?.length < 5) {
-      throw new Error('File name must be included along with a type path.');
-    }
-    console.log('%s Importing local file', chalk.yellow.bold('TYPE PROPERTIES MERGE'));
-    const fileLocation = args[3];
-    console.log('Using File: ', fileLocation);
-
-    const typePaths = (args as Array<string>).slice(4);
-    console.log('Using TypePaths: ', typePaths);
-
-    await mergeTypeProperties(fileLocation, typePaths);
-    console.log('%s Merged', chalk.yellow.bold('TYPE PROPERTIES MERGE'));
-
-  }
-  catch (e) {
-    console.log(`%s Merge Failed. ${e}`, chalk.red.bold('FAIL'));
-    return;
-  }
-
-  console.log('%s Merge Complete.', chalk.green.bold('COMPLETE'));
-}
-
-function loadTypeProperties(fileLocation) {
-  const TARGET_DIR = process.cwd();
-  try {
-    const separator = getSeparatorByPlatform();
-
-    const fullPath = TARGET_DIR + separator + fileLocation;
-    console.log('Getting file from path: ', fullPath);
-
-    const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + fileLocation, 'utf8'));
-    return doc.typeProperties;
-  } catch (e) {
-    throw new Error(`ERROR PARSING YAML: ${e}`);
-  }
-}
-
-async function mergeTypeProperties(fileLocation, typePaths) {
-  const uploadedTypeProperties: ReducedTypeProperty[] = loadTypeProperties(fileLocation);
-
-  await authUser();
-
-  const data: DataHolder = {
-    types: await getTypes(),
-    optionSets: await getOptionSets(),
-    optionSetHierarchies: [],
-    ruleSets: [],
-    ruleSetLinks: [],
-    usageInfo: [],
-    typePropertyPolicies: [],
-    typePropertyPolicyLinks: [],
-  };
-  const reducedData = await reduceData(data);
-
-  for (const typePath of typePaths) {
-    const foundType = reducedData.reducedTypes.find(reducedTypes => reducedTypes.typePath === typePath);
-    if (!foundType){
-      console.log(`%s No Type found for: ${typePath}`, chalk.red.bold('WARNING'));
-    }
-    mergeType(foundType, uploadedTypeProperties);
-  }
-
-  saveData({types: reducedData.reducedTypes});
-}
-
-function mergeType(reducedType: ReducedType, typePropertiesToAdd: ReducedTypeProperty[]) {
-  for (const typeProperty of typePropertiesToAdd) {
-    const found = reducedType.typeProperties.find(tp => tp.slug === typeProperty.slug);
-    if (!found) {
-      reducedType.typeProperties.push(typeProperty);
-    }
-  }
-}
-
-function saveData(data) {
-  const yamlStr = yaml.dump(data);
-  const CURRENT_DIR = process.cwd();
-  const separator = getSeparatorByPlatform();
-  fs.writeFileSync(CURRENT_DIR + separator + 'merged_types.yml', yamlStr, 'utf8');
-}