@contrail/cli 1.0.67 → 1.0.69

package/src/types/types-extractor.ts

@@ -1,369 +1,369 @@
-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, '-');
+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, '-');
 }