@contrail/cli 1.0.71 → 2.0.1

package/dist/commands/types/parseOptionSetsLocalFiles.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLabelsInColumn = exports.ParseOptionSetsToFolderStructure = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const types_1 = require("@contrail/types");
+const util_1 = require("@contrail/util");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const csv = require('csvtojson');
+const yaml = require('js-yaml');
+const core_1 = require("@oclif/core");
+class ParseOptionSetsLocalFiles extends core_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(ParseOptionSetsLocalFiles);
+        try {
+            this.log('%s Importing local file', chalk_1.default.yellow.bold('OPTION SET PARSE'));
+            this.log('Using File: ', args.file);
+            await parseOptionSetsLocalFiles(args.file, flags.csvStyle);
+            this.log('%s Parsed', chalk_1.default.yellow.bold('OPTION SET PARSE'));
+        }
+        catch (e) {
+            this.log(`%s PARSE Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+            return;
+        }
+        this.log('%s PARSE Complete.', chalk_1.default.green.bold('COMPLETE'));
+    }
+}
+exports.default = ParseOptionSetsLocalFiles;
+ParseOptionSetsLocalFiles.description = 'Parse CSV files into OptionSets. Style denotes the format the csv is in. If the csv file has a column for name and label, use "NameAndLabel". If the file has one column for each option set with the rows being the label value use "LabelsInColumn"';
+ParseOptionSetsLocalFiles.examples = [
+    `$ contrail types parseOptionSetsLocalFiles <File Paths> <style>
+`,
+];
+ParseOptionSetsLocalFiles.flags = {
+    csvStyle: core_1.Flags.string({ options: ['NameAndLabel', 'LabelsInColumn'], required: true })
+};
+ParseOptionSetsLocalFiles.args = {
+    file: core_1.Args.string({ description: 'File to parse', required: true }),
+};
+async function ParseOptionSetsToFolderStructure(args) {
+    try {
+        if ((args === null || args === void 0 ? void 0 : args.length) < 4) {
+            throw new Error('File name must be included.');
+        }
+        console.log('%s Importing local file', chalk_1.default.yellow.bold('OPTION SET PARSE'));
+        const fileLocation = args[3];
+        console.log('Using File: ', fileLocation);
+        await parseOptionSetsToFolderStructure(fileLocation);
+        console.log('%s Parsed', chalk_1.default.yellow.bold('OPTION SET PARSE'));
+    }
+    catch (e) {
+        console.log(`%s PARSE Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s PARSE Complete.', chalk_1.default.green.bold('COMPLETE'));
+}
+exports.ParseOptionSetsToFolderStructure = ParseOptionSetsToFolderStructure;
+async function loadOptionSetCSV(fileLocation) {
+    const TARGET_DIR = process.cwd();
+    try {
+        const fullPath = path.resolve(path.join(TARGET_DIR, fileLocation));
+        console.log('Getting file from path: ', fullPath);
+        return await csv().fromFile(fullPath);
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING CSV: ${e}`);
+    }
+}
+function loadOptionSets(fileLocation) {
+    const TARGET_DIR = process.cwd();
+    try {
+        const fullPath = path.resolve(path.join(TARGET_DIR, fileLocation));
+        console.log('Getting file from path: ', fullPath);
+        const doc = yaml.load(fs_1.default.readFileSync(fullPath, 'utf8'));
+        return doc;
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+async function parseOptionSetsLocalFiles(fileLocation, csvStyle) {
+    const uploadedOptionData = await loadOptionSetCSV(fileLocation);
+    if (csvStyle === 'NameAndLabel') {
+        const parsedOptionSets = (0, types_1.parseOptionSets)(uploadedOptionData);
+        saveData(parsedOptionSets);
+    }
+    if (csvStyle === 'LabelsInColumn') {
+        const parsedOptionSets = parseLabelsInColumn(uploadedOptionData);
+        saveData(parsedOptionSets);
+    }
+}
+async function parseOptionSetsToFolderStructure(fileLocation) {
+    const uploadedOptionData = await loadOptionSets(fileLocation);
+    saveDataInFolders(uploadedOptionData);
+}
+function saveData(data) {
+    const yamlStr = yaml.dump(data);
+    const CURRENT_DIR = process.cwd();
+    fs_1.default.writeFileSync(path.resolve(path.join(CURRENT_DIR, 'parsed_local_optionSets.yml')), yamlStr, 'utf8');
+}
+function saveDataInFolders(data) {
+    const folder = { filename: 'option-sets', split: true, fileLabel: 'name' };
+    const dir = 'merged_option_sets';
+    const CURRENT_DIR = process.cwd();
+    const subDir = path.join(CURRENT_DIR, dir, folder.filename);
+    if (!fs_1.default.existsSync(subDir)) {
+        fs_1.default.mkdirSync(subDir, { recursive: true });
+    }
+    for (const item of data) {
+        const yamlStr = yaml.dump(item);
+        const fileLabel = item[folder.fileLabel];
+        if (!fileLabel) {
+            console.warn('skipping bad data:', item);
+        }
+        fs_1.default.writeFileSync(path.join(subDir, `${removeSlash(fileLabel)}.yml`), yamlStr, 'utf8');
+    }
+}
+function removeSlash(string) {
+    const re = /\//gi;
+    return string.replace(re, '-');
+}
+function parseLabelsInColumn(uploadedOptionData) {
+    const optionSets = [];
+    const optionSetNames = Object.keys(uploadedOptionData[0]);
+    for (const optionSetName of optionSetNames) {
+        const uniqueOptionSetValues = new Set();
+        for (const data of uploadedOptionData) {
+            const label = data[optionSetName];
+            uniqueOptionSetValues.add(label);
+        }
+        const optionSet = [];
+        if (uniqueOptionSetValues) {
+            for (const entry of uniqueOptionSetValues.values()) {
+                if (entry === '') {
+                    continue;
+                }
+                optionSet.push({
+                    value: util_1.StringUtil.convertToCamelCase(entry),
+                    display: entry,
+                });
+            }
+        }
+        const reducedOptionSet = {
+            name: optionSetName,
+            isArchived: false,
+            optionSet,
+        };
+        optionSets.push(reducedOptionSet);
+    }
+    return optionSets;
+}
+exports.parseLabelsInColumn = parseLabelsInColumn;

package/dist/commands/types/parseOptionSetsToFolderStructure.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class ParseOptionSetsToFolderStructure extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        file: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}
+export declare function parseLabelsInColumn(uploadedOptionData: any): any[];

package/dist/commands/types/parseOptionSetsToFolderStructure.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLabelsInColumn = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const util_1 = require("@contrail/util");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const csv = require('csvtojson');
+const yaml = require('js-yaml');
+const core_1 = require("@oclif/core");
+class ParseOptionSetsToFolderStructure extends core_1.Command {
+    async run() {
+        const { args } = await this.parse(ParseOptionSetsToFolderStructure);
+        try {
+            console.log('%s Importing local file', chalk_1.default.yellow.bold('OPTION SET PARSE'));
+            console.log('Using File: ', args.file);
+            await parseOptionSetsToFolderStructure(args.file);
+            console.log('%s Parsed', chalk_1.default.yellow.bold('OPTION SET PARSE'));
+        }
+        catch (e) {
+            console.log(`%s PARSE Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+            return;
+        }
+        console.log('%s PARSE Complete.', chalk_1.default.green.bold('COMPLETE'));
+    }
+}
+exports.default = ParseOptionSetsToFolderStructure;
+ParseOptionSetsToFolderStructure.description = 'Parse CSV files into OptionSets. Style denotes the format the csv is in. If the csv file has a column for name and label, use "NameAndLabel". If the file has one column for each option set with the rows being the label value use "LabelsInColumn"';
+ParseOptionSetsToFolderStructure.examples = [
+    `$ contrail types parseOptionSetsLocalFiles <File Paths> <style>
+`,
+];
+ParseOptionSetsToFolderStructure.args = {
+    file: core_1.Args.string({ description: 'File to parse', required: true }),
+};
+function loadOptionSets(fileLocation) {
+    const TARGET_DIR = process.cwd();
+    try {
+        const fullPath = path.resolve(path.join(TARGET_DIR, fileLocation));
+        console.log('Getting file from path: ', fullPath);
+        const doc = yaml.load(fs_1.default.readFileSync(fullPath, 'utf8'));
+        return doc;
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+async function parseOptionSetsToFolderStructure(fileLocation) {
+    const uploadedOptionData = await loadOptionSets(fileLocation);
+    saveDataInFolders(uploadedOptionData);
+}
+function saveDataInFolders(data) {
+    const folder = { filename: 'option-sets', split: true, fileLabel: 'name' };
+    const dir = 'merged_option_sets';
+    const CURRENT_DIR = process.cwd();
+    const subDir = path.join(CURRENT_DIR, dir, folder.filename);
+    if (!fs_1.default.existsSync(subDir)) {
+        fs_1.default.mkdirSync(subDir, { recursive: true });
+    }
+    for (const item of data) {
+        const yamlStr = yaml.dump(item);
+        const fileLabel = item[folder.fileLabel];
+        if (!fileLabel) {
+            console.warn('skipping bad data:', item);
+        }
+        fs_1.default.writeFileSync(path.join(subDir, `${removeSlash(fileLabel)}.yml`), yamlStr, 'utf8');
+    }
+}
+function removeSlash(string) {
+    const re = /\//gi;
+    return string.replace(re, '-');
+}
+function parseLabelsInColumn(uploadedOptionData) {
+    const optionSets = [];
+    const optionSetNames = Object.keys(uploadedOptionData[0]);
+    for (const optionSetName of optionSetNames) {
+        const uniqueOptionSetValues = new Set();
+        for (const data of uploadedOptionData) {
+            const label = data[optionSetName];
+            uniqueOptionSetValues.add(label);
+        }
+        const optionSet = [];
+        if (uniqueOptionSetValues) {
+            for (const entry of uniqueOptionSetValues.values()) {
+                if (entry === '') {
+                    continue;
+                }
+                optionSet.push({
+                    value: util_1.StringUtil.convertToCamelCase(entry),
+                    display: entry,
+                });
+            }
+        }
+        const reducedOptionSet = {
+            name: optionSetName,
+            isArchived: false,
+            optionSet,
+        };
+        optionSets.push(reducedOptionSet);
+    }
+    return optionSets;
+}
+exports.parseLabelsInColumn = parseLabelsInColumn;

package/dist/commands/types/parseTypesFromFiles.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class ParseTypesFromFiles extends Command {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    static args: {
+        typePaths: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/types/parseTypesFromFiles.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const type_parser_1 = require("../../helpers/types/type-parser");
+class ParseTypesFromFiles extends core_1.Command {
+    async run() {
+        const { argv } = await this.parse(ParseTypesFromFiles);
+        try {
+            console.log('%s Parsing', chalk_1.default.yellow.bold('TYPES AND OPTION SETS'));
+            const fileIds = argv;
+            console.log('Using FileId(s): ', fileIds);
+            await (0, type_parser_1.parseTypesFromFiles)(fileIds);
+            console.log('%s Parsed', chalk_1.default.yellow.bold('TYPES AND OPTION SETS'));
+        }
+        catch (e) {
+            console.log(`%s Parsing Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+            return;
+        }
+        console.log('%s Parsing Complete.', chalk_1.default.green.bold('COMPLETE'));
+    }
+}
+exports.default = ParseTypesFromFiles;
+ParseTypesFromFiles.description = 'Parse CSV files into Types and OptionSets from VibeIQ Files.\n File must be .yml.';
+ParseTypesFromFiles.examples = [
+    `$ contrail types parseTypesFromFiles <fileIds>
+    `,
+];
+// variable argument length
+ParseTypesFromFiles.strict = false;
+ParseTypesFromFiles.args = {
+    typePaths: core_1.Args.string({ description: 'A list of the VibeIQ file IDs to parse', required: true }),
+};

package/dist/commands/types/parseTypesFromLocalFiles.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class ParseTypesFromLocalFiles extends Command {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    static args: {
+        typePaths: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/types/parseTypesFromLocalFiles.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const core_1 = require("@oclif/core");
+const type_parser_1 = require("../../helpers/types/type-parser");
+class ParseTypesFromLocalFiles extends core_1.Command {
+    async run() {
+        const { argv } = await this.parse(ParseTypesFromLocalFiles);
+        try {
+            console.log('%s Parsing', chalk_1.default.yellow.bold('TYPES AND OPTION SETS'));
+            const fileLocations = argv;
+            console.log('Using File Location(s): ', fileLocations);
+            await (0, type_parser_1.parseTypesFromLocalFiles)(fileLocations);
+            console.log('%s Parsed', chalk_1.default.yellow.bold('TYPES AND OPTION SETS'));
+        }
+        catch (e) {
+            console.log(`%s Parsing Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+            return;
+        }
+        console.log('%s Parsing Complete.', chalk_1.default.green.bold('COMPLETE'));
+    }
+}
+exports.default = ParseTypesFromLocalFiles;
+ParseTypesFromLocalFiles.description = 'Parse CSV files into Types and OptionSets from local files.';
+ParseTypesFromLocalFiles.examples = [
+    `$ contrail types parseTypesFromLocalFiles <File Paths>
+    `,
+];
+// variable argument length
+ParseTypesFromLocalFiles.strict = false;
+ParseTypesFromLocalFiles.args = {
+    typePaths: core_1.Args.string({ description: 'A list of the files to parse', required: true }),
+};

package/dist/commands/types/parseTypesFromTemplateAndDataFromLocalFiles.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class ParseTypesFromTemplateAndDataFromLocalFiles extends Command {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    static args: {
+        templateFile: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+        filePaths: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/types/parseTypesFromTemplateAndDataFromLocalFiles.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const core_1 = require("@oclif/core");
+const type_parser_1 = require("../../helpers/types/type-parser");
+class ParseTypesFromTemplateAndDataFromLocalFiles extends core_1.Command {
+    async run() {
+        const { args, argv } = await this.parse(ParseTypesFromTemplateAndDataFromLocalFiles);
+        try {
+            console.log('%s Parsing', chalk_1.default.yellow.bold('TYPES AND OPTION SETS'));
+            const templateFileLocation = args.templateFile;
+            const dataFileLocations = argv.slice(1);
+            console.log('Using Template File Location: ', templateFileLocation);
+            console.log('Using Data File Location: ', dataFileLocations);
+            await (0, type_parser_1.parseTypesFromTemplateAndDataFromLocalFiles)(templateFileLocation, dataFileLocations);
+            console.log('%s Parsed', chalk_1.default.yellow.bold('TYPES AND OPTION SETS'));
+        }
+        catch (e) {
+            console.log(`%s Parsing Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+            return;
+        }
+        console.log('%s Parsing Complete.', chalk_1.default.green.bold('COMPLETE'));
+    }
+}
+exports.default = ParseTypesFromTemplateAndDataFromLocalFiles;
+ParseTypesFromTemplateAndDataFromLocalFiles.description = 'Parse CSV files into Types and OptionSets from local type template files.';
+ParseTypesFromTemplateAndDataFromLocalFiles.examples = [
+    `$ contrail types parseTypesFromTemplateAndDataFromLocalFiles <Template Path> <File Paths>
+    `,
+];
+ParseTypesFromTemplateAndDataFromLocalFiles.strict = false;
+ParseTypesFromTemplateAndDataFromLocalFiles.args = {
+    templateFile: core_1.Args.string({ description: 'The template file to use', required: true }),
+    filePaths: core_1.Args.string({ description: 'A list of data file to use', required: true }),
+};

package/dist/commands/types/parseTypesFromTemplateFromLocalFiles.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class ParseTypesFromTemplateFromLocalFiles extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        templateFile: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+        filePath: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/types/parseTypesFromTemplateFromLocalFiles.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const core_1 = require("@oclif/core");
+const type_parser_1 = require("../../helpers/types/type-parser");
+class ParseTypesFromTemplateFromLocalFiles extends core_1.Command {
+    async run() {
+        const { args, } = await this.parse(ParseTypesFromTemplateFromLocalFiles);
+        try {
+            console.log('%s Parsing', chalk_1.default.yellow.bold('TYPES AND OPTION SETS'));
+            const templateFileLocation = args.templateFile;
+            const dataFileLocation = args.filePath;
+            console.log('Using Template File Location: ', templateFileLocation);
+            console.log('Using Data File Location: ', dataFileLocation);
+            await (0, type_parser_1.parseTypesFromTemplateFromLocalFiles)(templateFileLocation, dataFileLocation);
+            console.log('%s Parsed', chalk_1.default.yellow.bold('TYPES AND OPTION SETS'));
+        }
+        catch (e) {
+            console.log(`%s Parsing Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+            return;
+        }
+        console.log('%s Parsing Complete.', chalk_1.default.green.bold('COMPLETE'));
+    }
+}
+exports.default = ParseTypesFromTemplateFromLocalFiles;
+ParseTypesFromTemplateFromLocalFiles.description = 'Parse CSV files into Types and OptionSets from local type template files.';
+ParseTypesFromTemplateFromLocalFiles.examples = [
+    `$ contrail types parseTypesFromTemplateFromLocalFiles <Template File> <Data File>
+    `,
+];
+ParseTypesFromTemplateFromLocalFiles.args = {
+    templateFile: core_1.Args.string({ description: 'The template file to use', required: true }),
+    filePath: core_1.Args.string({ description: 'The data file to use', required: true }),
+};

package/dist/commands/types/uploadOptionSetHierarchies.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@oclif/core';
+export default class UploadOptionSetHierarchies extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}
+export declare function uploadOptionSetHierarchies(): Promise<void>;