@contrail/cli 1.0.11 → 1.0.15

package/src/auth/login.ts

@@ -1,14 +1,37 @@
 const AmazonCognitoIdentity = require('amazon-cognito-identity-js');
 import inquirer from 'inquirer';
-import { Request, setConfig } from '@contrail/sdk';
+import { Request, setConfig as setSdkConfig } from '@contrail/sdk';
 import { Auth, AuthContext } from './auth';
+import { getConfig, storeConfig } from '../config/config';
 
 const CONFIGURATION = {
     userPoolId: 'us-east-1_x8hXZUsL6',
     clientId: process.env.CONTRAIL_COGNITO_CLIENT_ID || '2oubek96sue5rsncovtqhs3scm',
 };
 
-export async function authUser(): Promise<AuthContext>{
+export async function authUser(): Promise<AuthContext> {
+    console.debug("authorizing user")
+    const config = await getConfig();
+    if (
+        config &&
+        config.apiUserToken &&
+        config.apiGateway &&
+        config.orgSlug
+    ) {
+        console.debug("populating auth config from fs config")
+        Auth.config = {
+            apiUserToken: config.apiUserToken,
+            apiGateway: config.apiGateway,
+            orgSlug: config.orgSlug,
+        };
+        setSdkConfig(Auth.config);
+        try {
+            return await refreshCurrentUserOrg();
+        } catch (e) {
+            console.log("Token expired. Requesting auth credentials...")
+        }
+
+    }
     const questions = [];
     if (!process.env.CONTRAIL_CLI_EMAIL) {
         questions.push({
@@ -41,7 +64,7 @@ export async function authUser(): Promise<AuthContext>{
         password: process.env.CONTRAIL_CLI_PASSWORD || answers.password,
         orgSlug: process.env.CONTRAIL_CLI_ORGSLUG || answers.orgSlug,
     };
-    if (!params.email || !params.password){
+    if (!params.email || !params.password) {
         throw new Error('Email and Password required');
     }
 
@@ -64,7 +87,7 @@ export async function authUser(): Promise<AuthContext>{
 
     const cognitoUser = new AmazonCognitoIdentity.CognitoUser(userData);
 
-    return new Promise( (resolve, reject) => {
+    return new Promise((resolve, reject) => {
         cognitoUser.authenticateUser(authDetails, {
             onSuccess: async (result) => {
                 const user = result;
@@ -80,21 +103,20 @@ export async function authUser(): Promise<AuthContext>{
 }
 
 async function setAuthContext(user, params): Promise<AuthContext> {
-
-    // TODO Dont allow user to set this - they could set dev
-    const questions = [];
-    questions.push({
-        type: 'list',
-        name: 'environment',
-        message: 'Which environment would you like to use?',
-        choices: ['Dev', 'Prod'],
-        default: 'Dev',
-    });
-
+    const config = await getConfig();
     let apiGateway;
-    const answers = await inquirer.prompt(questions);
-    if (answers.environment === 'Dev') {
-        apiGateway = 'https://api.vibeiq.com/dev/api';
+    console.log(config.environments)
+    if(config.environments) {
+        const questions = [];
+        questions.push({
+            type: 'list',
+            name: 'environment',
+            message: 'Which environment would you like to use?',
+            choices: Object.keys(config.environments),
+            default: Object.keys(config.environments)[0],
+        });
+        const answers = await inquirer.prompt(questions);
+        apiGateway = config.environments[answers.environment]
     } else {
         apiGateway = 'https://api.vibeiq.com/prod/api';
     }
@@ -106,8 +128,13 @@ async function setAuthContext(user, params): Promise<AuthContext> {
         orgSlug: params.orgSlug,
     };
     // SET SDK CONFIG
-    setConfig(Auth.config);
+    setSdkConfig(Auth.config);
 
+    return refreshCurrentUserOrg();
+}
+
+async function refreshCurrentUserOrg() {
+    console.debug("refreshing current user org")
     const currentUser = await Request.request('/users/current', {
         method: 'GET',
         headers: {
@@ -122,6 +149,7 @@ async function setAuthContext(user, params): Promise<AuthContext> {
     if (org) {
         Auth.config.orgId = org.orgId || org.id;
     }
-
+    // cache config in the fs
+    storeConfig(Object.assign({}, Auth.config))
     return Object.assign({}, Auth.config);
 }

package/src/cli.ts

@@ -3,7 +3,11 @@ import { create } from './apps/create-app/create';
 import { deployApp, removeApp } from './apps/deploy-app/deploy';
 import { getTypes } from './types/types-extractor';
 import { uploadTypes } from './types/types-uploader';
-import { parseOptionSet } from './types/parse-optionSet';
+import { UploadOptionSets } from './types/option-set-uploader';
+import { MergeOptionSets } from './types/option-set-merger';
+import { MergeTypeProperties } from './types/types-properties-merger';
+import { ParseTypesFromFiles, ParseTypesFromLocalFiles } from './types/parse-types';
+
 const cliUsage = require('command-line-usage');
 
 /**
@@ -15,6 +19,10 @@ export async function cli(args) {
   const fullCommand = args[2];
   let domain;
   let command;
+  if(!fullCommand) {
+    printIllegalCommand();
+    return;
+  }
   const commandParts = fullCommand.split('.');
 
   if (!commandParts?.length) {
@@ -57,12 +65,28 @@ export async function cli(args) {
           getTypes(args);
           break;
         }
-        case 'upload': {
+        case 'uploadTypes': {
           uploadTypes(args);
           break;
         }
-        case 'parseOptionSet': {
-          parseOptionSet(args);
+        case 'uploadOptionSets': {
+          UploadOptionSets(args);
+          break;
+        }
+        case 'parseTypesFromLocalFiles': {
+          ParseTypesFromLocalFiles(args);
+          break;
+        }
+        case 'parseTypesFromFiles': {
+          ParseTypesFromFiles(args);
+          break;
+        }
+        case 'mergeOptionSets': {
+          MergeOptionSets(args);
+          break;
+        }
+        case 'mergeTypeProperties': {
+          MergeTypeProperties(args);
           break;
         }
         default: {
@@ -125,8 +149,22 @@ const helpSections = [
     header: 'Type Commands - Domain: types',
     content: [
       'getAll                       Get all OptionSets and Types for your Org.',
-      'upload                       Upload OptionSets and Types for your Org.',
-      'parseOptionSet <File Path>   Parse a CSV file into OptionSets.',
+      'uploadTypes                  Upload Types for your Org.',
+      '.                            Types are uploaded from types.yml\n',
+      'uploadOptionSets             Upload OptionSets for your Org.',
+      '.                            OptionSets are loaded from option_sets.yml\n',
+      'parseTypesFromLocalFiles <File Paths>   Parse CSV files into Types and ',
+      '.                                       OptionSets from local files.\n',
+      'parseTypesFromFiles <fileIds>           Parse CSV files into Types and ',
+      '.                                       OptionSets from VibeIQ Files.\n',
+      'mergeOptionSets <File Path>             Merge the OptionSets from an existing',
+      '.                                       org and the OptionSets passed in.', 
+      '.                                       File must be .yml\n',
+      'mergeTypeProperties <File Path> <TypePaths> ', 
+      '.                                       Merge the TypeProperties from an existing',
+      '.                                       org and the TypeProperties passed in.',
+      '.                                       Add to Types via TypePath', 
+      '.                                       File must be .yml\n',
     ],
   },
 ];

package/src/config/config.ts

@@ -0,0 +1,65 @@
+import { readFileSync, access, promises as fsPromises, write } from 'fs';
+import { join } from 'path';
+import {homedir} from  'os';
+const userHomeDir = homedir();
+const configDirectoryLocation = join(userHomeDir, '.vibeiq');
+const configFileLocation = join(configDirectoryLocation, 'config.json');
+
+export async function initializeVibeIQConfig() {
+  try{
+    await fsPromises.mkdir(configDirectoryLocation, {recursive: true})
+  } catch (e) {
+    console.error("could not initialize vibeiq directory")
+    throw e
+  }
+
+  try {
+    await fsPromises.writeFile(configFileLocation, '{}');
+  } catch (e) {
+    console.error(`could not initialize config file (${configFileLocation}).`)
+    throw e;
+  }
+}
+export async function readVibeIQConfig() {
+  let fileContent;
+  try {
+    fileContent = await fsPromises.readFile(configFileLocation);
+  } catch (e) {
+    console.debug(`failed to open config file (${configFileLocation}) for reading.`);
+    console.debug('trying to initialize config file');
+    await initializeVibeIQConfig();
+    console.error(`Could not open config file (${configFileLocation}) for reading.`);
+    throw e
+  }
+
+  try {
+    return JSON.parse(fileContent);
+  } catch (e) {
+    console.error(`Could not parse local vibeiq config. The file (${configFileLocation}) might be malformed`);
+  }
+}
+
+
+export async function writeVibeIQConfig(config: Object) {
+  try {
+    await fsPromises.writeFile(configFileLocation, JSON.stringify(config, null, 2));
+  } catch (e) {
+    console.error(`Could not open config file (${configFileLocation}) for writing.`);
+    throw e
+  }
+}
+
+export async function getConfig() {
+  console.debug("getting config from file system")
+  return await readVibeIQConfig();
+}
+
+export async function storeConfig(incomingConfig: Object) {
+  const config = await readVibeIQConfig();
+  const newConfig = {
+    ...config,
+    ...incomingConfig
+  };
+  await writeVibeIQConfig(newConfig);
+}
+

package/src/types/interfaces.ts

@@ -3,10 +3,10 @@ export interface ReducedType {
   label: string;
   typePath: string;
   isArchived: boolean;
-  typeProperties: ReducedType[];
+  typeProperties: ReducedTypeProperty[];
 }
 
-export interface ReducedTypeProperties {
+export interface ReducedTypeProperty {
   id: string;
   isArchived: boolean;
   propertyType: PropertyType;

package/src/types/option-set-merger.ts

@@ -0,0 +1,123 @@
+import { Entities } from '@contrail/sdk';
+import { ReducedOptionSet } 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 MergeOptionSets(args) {
+  try {
+    if (args?.length < 4) {
+      throw new Error('File name must be included.');
+    }
+    console.log(`%s Importing local file`, chalk.yellow.bold('OPTION SET MERGE'));
+    const fileLocation = args[3];
+    console.log('Using File: ', fileLocation);
+
+    await mergeOptionSets(fileLocation);
+    console.log(`%s Merged`, chalk.yellow.bold('OPTION SET MERGE'));
+
+  }
+  catch (e) {
+    console.log(`%s Merge Failed. ${e}`, chalk.red.bold('FAIL'));
+    return;
+  }
+
+  console.log('%s Merge Complete.', chalk.green.bold('COMPLETE'));
+}
+function loadOptionSets(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.optionSets;
+  } catch (e) {
+    throw new Error(`ERROR PARSING YAML: ${e}`);
+  }
+}
+
+async function mergeOptionSets(fileLocation) {
+  const uploadedOptionSets: ReducedOptionSet[] = loadOptionSets(fileLocation);
+
+  await authUser();
+
+  const currentOptionSetsFull: any[] = await new Entities().get({
+    entityName: 'type-property-option-set',
+  });
+
+  const currentOptionSets = currentOptionSetsFull.map(os => Object.assign({}, {
+    name: os.name,
+    isArchived: os.isArchived,
+    optionSet: os.optionSet,
+  }));
+
+  const currentOptionSetsByName = {};
+  for (const currentOptionSet of currentOptionSets) {
+    currentOptionSetsByName[currentOptionSet.name] = currentOptionSet;
+  }
+
+  const uploadedOptionSetsByName = {};
+  for (const optionSet of uploadedOptionSets) {
+    uploadedOptionSetsByName[optionSet.name] = optionSet;
+  }
+
+  const mergedOptionSets: any[] = []
+  for (const uploadedOptionSet of uploadedOptionSets) {
+    const existing = currentOptionSetsByName[uploadedOptionSet.name];
+    if (!existing) {
+      if (!uploadedOptionSet.optionSet) {
+        console.log('No OptionSet for: ', uploadedOptionSet.name);
+        continue;
+      }
+      console.log('Adding New: ', uploadedOptionSet.name);
+      mergedOptionSets.push(uploadedOptionSet);
+    }
+    else {
+      console.log('Merging: ', uploadedOptionSet.name);
+      mergedOptionSets.push(mergeOptionSet(existing, uploadedOptionSet));
+    }
+  }
+
+  for (const currentOptionSet of currentOptionSets) {
+    const found = uploadedOptionSetsByName[currentOptionSet.name];
+    if (!found) {
+      console.log('Adding Existing: ', currentOptionSet.name);
+      mergedOptionSets.push(currentOptionSet);
+    }
+  }
+
+  saveData({optionSets: mergedOptionSets})
+}
+
+function mergeOptionSet(existingOptionSet: ReducedOptionSet, uploadedOptionSet: ReducedOptionSet) {
+  const merged = {
+    name: uploadedOptionSet.name,
+    optionSet: uploadedOptionSet.optionSet,
+    isArchived: uploadedOptionSet.isArchived,
+  }
+
+  for (const keyVal of existingOptionSet.optionSet) {
+    const value = keyVal.value
+    const display = keyVal.display
+
+    const found = merged.optionSet.find(keyVal => keyVal.value === value)
+    if (!found) {
+      merged.optionSet.push({value, display})
+    }
+
+  }
+
+  return merged;
+}
+
+function saveData(data) {
+  const yamlStr = yaml.dump(data);
+  const CURRENT_DIR = process.cwd();
+  const separator = getSeparatorByPlatform();
+  fs.writeFileSync(CURRENT_DIR + separator + 'merged_optionSets.yml', yamlStr, 'utf8');
+}

package/src/types/option-set-uploader.ts

@@ -2,9 +2,29 @@ import { Entities } from '@contrail/sdk';
 import { ReducedOptionSet } 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 UploadOptionSets(args) {
+  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('OPTION SETS'));
+    await uploadOptionSets();
+    console.log(`%s Uploaded`, chalk.yellow.bold('OPTION SETS'));
+
+  }
+  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 loadOptionSets(){
   const TARGET_DIR = process.cwd();
   try {
@@ -16,7 +36,7 @@ function loadOptionSets(){
   }
 }
 
-export async function uploadOptionSets() {
+async function uploadOptionSets() {
   const optionSets: ReducedOptionSet[] = loadOptionSets();
 
   const currentOptionSets = await new Entities().get({

package/src/types/parse-types.ts

@@ -0,0 +1,104 @@
+import { TypeProcessor } from '@contrail/sdk';
+import chalk from 'chalk';
+import fs from 'fs';
+import { getSeparatorByPlatform } from '../common';
+import * as csvToJson from 'csvtojson';
+import { authUser } from '../auth/login';
+
+const yaml = require('js-yaml');
+
+export async function ParseTypesFromLocalFiles(args) {
+  try {
+    if (args?.length < 4) {
+      throw new Error('File names must be included.');
+    }
+    console.log(`%s Parsing`, chalk.yellow.bold('TYPES AND OPTION SETS'));
+    const fileLocations = (args as Array<string>).slice(3);
+    console.log('Using File Location(s): ', fileLocations);
+
+    await parseTypesFromLocalFiles(fileLocations);
+    console.log(`%s Parsed`, chalk.yellow.bold('TYPES AND OPTION SETS'));
+
+  }
+  catch (e) {
+    console.log(`%s Parsing Failed. ${e}`, chalk.red.bold('FAIL'));
+    return;
+  }
+
+  console.log('%s Parsing Complete.', chalk.green.bold('COMPLETE'));
+}
+
+export async function ParseTypesFromFiles(args) {
+  try {
+    if (args?.length < 4) {
+      throw new Error('File ids must be included.');
+    }
+    console.log(`%s Parsing`, chalk.yellow.bold('TYPES AND OPTION SETS'));
+    const fileIds = (args as Array<string>).slice(3);
+    console.log('Using FileId(s): ', fileIds);
+
+    await parseTypesFromFiles(fileIds);
+    console.log(`%s Parsed`, chalk.yellow.bold('TYPES AND OPTION SETS'));
+
+  }
+  catch (e) {
+    console.log(`%s Parsing Failed. ${e}`, chalk.red.bold('FAIL'));
+    return;
+  }
+
+  console.log('%s Parsing Complete.', chalk.green.bold('COMPLETE'));
+}
+
+async function loadDataFromCSV(fileName) {
+  const CURRENT_DIR = process.cwd();
+  try {
+    const separator = getSeparatorByPlatform();
+    const fullPath = CURRENT_DIR + separator + fileName;
+
+    console.log('Getting file from path: ', fullPath);
+    const csvData = await csvToJson.default().fromFile(fullPath);
+
+    return csvData;
+  } catch (e) {
+    throw new Error(`ERROR PARSING CSV: ${e}`);
+  }
+}
+
+async function parseTypesFromLocalFiles(fileLocations: string[]) {
+
+  const csvJSONData: any[] = [];
+  for (const fileLocation of fileLocations) {
+    try {
+      console.log('Getting data for fileLocation: ', fileLocation);
+      const csvData = await loadDataFromCSV(fileLocation);
+
+      console.log(`CSV import was successful. ${csvData?.length} rows found. Adding to total rows.`);
+      csvJSONData.push(...csvData);
+    }
+    catch (e) {
+      console.log('Error importing csv data.', e);
+      throw e;
+    }
+  }
+
+  console.log(`CSV imports were successful. ${csvJSONData?.length} total rows found.`);
+  const suggestions = await new TypeProcessor().GetSuggestedTypes(csvJSONData)
+  saveData({optionSets: suggestions.OptionSets}, 'parsed_optionSets.yml');
+  saveData({typeProperties: suggestions.TypeProperties}, 'parsed_typeProperties.yml');
+}
+
+async function parseTypesFromFiles(fileIds: string[]) {
+  await authUser();
+
+  const suggestions = await new TypeProcessor().GetSuggestedTypesFromFiles({loadFileIds: fileIds})
+
+  saveData({optionSets: suggestions.OptionSets}, 'parsed_optionSets.yml');
+  saveData({typeProperties: suggestions.TypeProperties}, 'parsed_typeProperties.yml');
+}
+
+function saveData(data, name) {
+  const yamlStr = yaml.dump(data);
+  const CURRENT_DIR = process.cwd();
+  const separator = getSeparatorByPlatform();
+  fs.writeFileSync(CURRENT_DIR + separator + name, yamlStr, 'utf8');
+}

package/src/types/types-extractor.ts

@@ -1,5 +1,5 @@
 import { Entities } from '@contrail/sdk';
-import { ReducedType, ReducedOptionSet, ReducedTypeProperties } from './interfaces';
+import { ReducedType, ReducedOptionSet, ReducedTypeProperty } from './interfaces';
 import chalk from 'chalk';
 import fs from 'fs';
 import { authUser } from '../auth/login';
@@ -21,7 +21,11 @@ export async function getTypes(args) {
     console.log(`%s Retrieved`, chalk.yellow.bold('OPTION SETS'));
     console.log(`%s Retrieving`, chalk.yellow.bold('TYPES'));
 
-    await getReducedTypes(optionSets);
+    const reducedTypes = await getReducedTypes(optionSets);
+    const typesHolder = {
+      types: reducedTypes,
+    };
+    saveData(typesHolder)
 
     console.log(`%s Retrieved`, chalk.yellow.bold('TYPES'));
 
@@ -59,7 +63,7 @@ async function getOptionSets(optionSets) {
   fs.writeFileSync(CURRENT_DIR + separator + 'option_sets.yml', yamlStr, 'utf8');
 }
 
-async function getReducedTypes(optionSets) {
+export async function getReducedTypes(optionSets) {
   const types = await new Entities().get({
     entityName: 'type',
   });
@@ -81,7 +85,7 @@ async function getReducedTypes(optionSets) {
 
     const reducedTypeProperties = [];
     for (const typeProperty of typeWithProperties.typeProperties) {
-      const reducedTypeProperty: ReducedTypeProperties = {
+      const reducedTypeProperty: ReducedTypeProperty = {
         slug: typeProperty.slug,
         id: typeProperty.id,
         isArchived: typeProperty.isArchived,
@@ -114,14 +118,12 @@ async function getReducedTypes(optionSets) {
   }
 
   reducedTypes = reducedTypes.sort((one, two) => (one.typePath < two.typePath ? -1 : 1));
+  return reducedTypes;
+}
 
-  const typesHolder = {
-    types: reducedTypes,
-  };
-
+function saveData(data) {
+  const yamlStr = yaml.dump(data);
   const CURRENT_DIR = process.cwd();
   const separator = getSeparatorByPlatform();
-
-  const yamlStr = yaml.dump(typesHolder);
   fs.writeFileSync(CURRENT_DIR + separator + 'types.yml', yamlStr, 'utf8');
 }

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

@@ -0,0 +1,85 @@
+import { Entities } from '@contrail/sdk';
+import { getReducedTypes } 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 optionSets = await new Entities().get({
+    entityName: 'type-property-option-set',
+  });
+
+  const reducedTypes = await getReducedTypes(optionSets);
+
+  for (const typePath of typePaths) {
+    const foundType = 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: 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');
+}