@adinsure-ops/ops-cli 4.0.0-rc10

package/lib/commands/prepare-content.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const cli_ux_1 = require("cli-ux");
+const fs = require("fs-extra");
+const path = require("path");
+const command_base_1 = require("../command.base");
+class CopyTransformation {
+    constructor(srcPath, dstPath) {
+        this.name = this.constructor.name;
+        this.srcPath = srcPath;
+        this.dstPath = dstPath;
+    }
+    transform() {
+        try {
+            fs.accessSync(this.srcPath, fs.constants.R_OK);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                throw new Error(`${this.name}: source file does not exist <${this.srcPath}>`);
+            }
+            else {
+                throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+            }
+        }
+        cli_ux_1.default.log(`Copying from ${this.srcPath} to ${this.dstPath}`);
+        try {
+            fs.copySync(this.srcPath, this.dstPath, { overwrite: true });
+        }
+        catch (err) {
+            throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+        }
+    }
+}
+class JavascriptTransformation {
+    constructor(srcPath, dstPath, javascriptFile, functionName) {
+        this.name = this.constructor.name;
+        this.srcPath = srcPath;
+        this.dstPath = dstPath;
+        this.jsFile = path.resolve(javascriptFile);
+        this.functionName = functionName;
+    }
+    importTransformationModule() {
+        try {
+            return require(this.jsFile);
+        }
+        catch (err) {
+            if (err.code === 'MODULE_NOT_FOUND') {
+                throw new Error(`${this.name}: module file ${this.jsFile} not found <${this.srcPath}>`);
+            }
+            else if (err instanceof SyntaxError) {
+                throw new Error(`${this.name}: ${err} in \'${this.jsFile}\' <${this.srcPath}>`);
+            }
+            throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+        }
+    }
+    executeTransformationFunction(transformationModule) {
+        try {
+            let result = transformationModule[this.functionName](this.srcPath);
+            if (typeof (result) !== 'string') {
+                throw new Error(`${this.name}: transformation functions must return string, ${this.functionName} returned ${typeof (result)} <${this.srcPath}>`);
+            }
+            return result;
+        }
+        catch (err) {
+            if (err instanceof TypeError) {
+                throw new Error(`${this.name}: invalid function \'${this.functionName}\' in ${this.jsFile} <${this.srcPath}>`);
+            }
+            /*
+            Rethrow anything errors that were thrown in the above try block
+            */
+            if (err.message && err.message.search(`${this.name}`.length > 0)) {
+                throw err;
+            }
+            throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+        }
+    }
+    transform() {
+        // Check if source exists, if not, issue a warning
+        try {
+            fs.accessSync(this.srcPath);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                let errMsg = `${this.name}: source does not exist, relying on transformation to find proper source file <${this.srcPath}>`;
+                cli_ux_1.default.log(`${chalk_1.default.yellow(errMsg)}`);
+            }
+            else {
+                throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+            }
+        }
+        cli_ux_1.default.log(`Transforming from ${this.srcPath} to ${this.dstPath} using ${this.jsFile} function ${this.functionName}`);
+        // Import transformation module
+        let transModule = this.importTransformationModule();
+        // Execute transformation function
+        let transResult = this.executeTransformationFunction(transModule);
+        // Write output to destination file
+        try {
+            fs.outputFileSync(this.dstPath, transResult, { encoding: 'utf-8', mode: 0o644, flag: 'w' });
+        }
+        catch (err) {
+            throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+        }
+    }
+}
+class RemovalTransformation {
+    constructor(srcPath) {
+        this.name = this.constructor.name;
+        this.srcPath = srcPath;
+    }
+    transform() {
+        try {
+            fs.accessSync(this.srcPath, fs.constants.W_OK);
+            cli_ux_1.default.log(`Removing ${this.srcPath}.`);
+            fs.removeSync(this.srcPath);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                let errMsg = `${this.name}: target does not exist, skipping removal <${this.srcPath}>`;
+                cli_ux_1.default.log(`${chalk_1.default.yellow(errMsg)}`);
+            }
+            else {
+                throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+            }
+        }
+    }
+}
+class PrepareContent extends command_base_1.default {
+    async parseDotfileLine(line, sourceDirectory) {
+        const re = RegExp('^([!#]{1})?(.+?)({.*?})?$');
+        let m = line.match(re);
+        let dotfileLine = {
+            prefix: m[1],
+            source: path.join(sourceDirectory, path.normalize(m[2].trim())),
+            transformData: m[3]
+        };
+        /*
+        Sanity check on source file name. Should not contain "{", ":", or "}" characters
+        */
+        const valRe = RegExp('[{:}]+');
+        let vm = dotfileLine.source.match(valRe);
+        if (vm !== null) {
+            throw new SyntaxError(`<${PrepareContent.dotfile}> source file name '${dotfileLine.source}' contains invalid character '${vm[0]}'`);
+        }
+        return dotfileLine;
+    }
+    async readDotfile(sourceDirectory) {
+        let file_content;
+        try {
+            file_content = fs.readFileSync(path.join(sourceDirectory, PrepareContent.dotfile), 'utf-8');
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                let errMsg = `.opsprepare file not found in ${path.resolve(sourceDirectory)}`;
+                throw new Error(errMsg);
+            }
+            throw new Error(err.message);
+        }
+        let lines = file_content.split(/\r?\n/).filter(line => line.length !== 0);
+        const lineParse = lines.map(line => {
+            return this.parseDotfileLine(line.trim(), sourceDirectory);
+        });
+        const parsedLines = Promise.all(lineParse).then(lines => lines.filter(line => line.prefix !== '#'));
+        return parsedLines;
+    }
+    async getTransformation(lineData, baseSourcedir, baseDestinationDir) {
+        const targetPath = path.join(baseDestinationDir, lineData.source);
+        /*
+        Anything prefixed with ! is a removal
+        */
+        if (lineData.prefix === '!') {
+            return new RemovalTransformation(targetPath);
+        }
+        /*
+        In case transformation data is present, prepare transformations based on requested plugin.
+        */
+        if (lineData.transformData) {
+            const re = RegExp('^{(.+?):.*}$');
+            const transformType = lineData.transformData.match(re)[1];
+            switch (transformType) {
+                case 'cp': {
+                    const rePath = RegExp('^{cp:([^:]+)}$');
+                    const mPath = lineData.transformData.match(rePath);
+                    if (!mPath) {
+                        throw new SyntaxError(`<${PrepareContent.dotfile}> syntax '${lineData.transformData}' is invalid for 'cp' transformation type`);
+                    }
+                    const tPath = path.join(baseDestinationDir, path.dirname(lineData.source), mPath[1]);
+                    return new CopyTransformation(lineData.source, tPath);
+                }
+                case 'js': {
+                    /* TODO: Some sanity checking will be required after regex matching
+                             to make sure everything was matched and is defined
+                    */
+                    // Parse transformation data
+                    const reData = RegExp('^{js:(.+?):(.+)}$');
+                    const mData = lineData.transformData.match(reData);
+                    if (!mData) {
+                        throw new SyntaxError(`<${PrepareContent.dotfile}> syntax '${lineData.transformData}' is invalid for 'js' transformation type`);
+                    }
+                    const jsFile = path.join(baseSourcedir, mData[1]);
+                    const jsFunc = mData[2];
+                    // File path absolute. Should it be relative to the transformation function?
+                    const filePath = path.resolve(lineData.source);
+                    return new JavascriptTransformation(filePath, targetPath, jsFile, jsFunc);
+                }
+                default: {
+                    const p = lineData.prefix ? lineData.prefix : '';
+                    const s = lineData.source;
+                    const t = lineData.transformData ? lineData.transformData : '';
+                    this.error(`No valid transformation can be extrapolated from ${p}${s}${t}`);
+                }
+            }
+        }
+        /*
+        Return default transformation
+        */
+        return new CopyTransformation(lineData.source, targetPath);
+    }
+    async prepareTransformations(linesData, baseSourceDir, baseDestinationDir) {
+        const transformations = linesData.map(line => {
+            return this.getTransformation(line, baseSourceDir, baseDestinationDir);
+        });
+        return Promise.all(transformations);
+    }
+    /*
+    This function divides transformations into execution groups based on their class
+    and runs transformations for each group
+    */
+    async runTransformations(transformations) {
+        let copyTransformList = [];
+        let modlueTransformList = [];
+        let excludeList = [];
+        // Sort transformation into two lists
+        transformations.forEach(t => {
+            if (t instanceof CopyTransformation) {
+                copyTransformList.push(t);
+            }
+            else if (t instanceof RemovalTransformation) {
+                excludeList.push(t);
+            }
+            else {
+                modlueTransformList.push(t);
+            }
+        });
+        const t = async (transformation) => {
+            try {
+                transformation.transform();
+            }
+            catch (err) {
+                return Promise.reject(err.message);
+            }
+        };
+        const doCopyTransform = copyTransformList.map(t);
+        const doModuleTransform = modlueTransformList.map(t);
+        const doExclude = excludeList.map(t);
+        /* Copy first, then transform and finally remove files. This should
+           ensure that transformations can overwrite previous copies. Removals
+           can still erase transformations though. If needed, we can remove
+           before transforming.
+        */
+        await Promise.all(doCopyTransform);
+        await Promise.all(doModuleTransform);
+        await Promise.all(doExclude);
+    }
+    /*
+    Validates file system on source repository by checking if files or directories exist
+    */
+    /*
+    async validate(arr: string[][], source: string): Promise<boolean> {
+        //this.log(`${chalk.blue('Validating if files and directories exist.')}`);
+        cli.action.start(`${chalk.blue('Validating if files and directories exist')}`, '', {stdout: true});
+        for (let a of arr[0]) {
+            let element_path = path.join(source, a);
+            if(!(fs.existsSync(path.join(element_path)))) {
+                this.log(`${chalk.red('File or directory: ' + path.join(element_path) + ' could not be found')}`);
+                return false;
+            }
+        }
+        for (let a of arr[1]) {
+            let element_path = path.join(source, a);
+            if(!(fs.existsSync(element_path))) {
+                this.log(`${chalk.red('File or directory: ' + element_path + ' could not be found')}`);
+                return false;
+            }
+        }
+
+        //this.log(`${chalk.green('Validation done.')}`);
+        cli.action.stop(`${chalk.green('done')}`);
+        return true;
+    }
+    */
+    /*
+    This function copies elements and removes excluded ones.
+    */
+    /*
+    async copyWorkspace(arr: string[][], dest: string, source: string): Promise<any> {
+        if (await this.validate(arr, source)) {
+            cli.action.start(`${chalk.blue('Preparing content')}`, '', {stdout: true});
+            arr[0].forEach(a => {
+                this.log('Copying: ', path.join(source, a));
+                fs.copySync(path.join(source, a), path.join(dest, a), {overwrite: true});
+            });
+            this.log(`${chalk.green('Copying done.')}`);
+            this.log(`${chalk.blue('Removing excluded elements.')}`);
+            arr[1].forEach(a => {
+                let curPath = path.join(dest, a);
+                if (fs.pathExistsSync(curPath)) {
+                    if (fs.lstatSync(curPath).isFile()) {
+                        try {
+                            fs.removeSync(curPath);
+                            this.log('Removing file: ', curPath);
+                        } catch (error) {
+                            cli.action.stop(`${chalk.red('failed')}`);
+                            this.error(error.message);
+                        }
+                    } else if (fs.lstatSync(curPath).isDirectory()) {
+                        try {
+                            fs.removeSync(curPath);
+                            this.log('Removing dir: ', curPath);
+                        } catch (error) {
+                            cli.action.stop(`${chalk.red('failed')}`);
+                            this.error(error.message);
+                        }
+                    } else {
+                        cli.action.stop(`${chalk.red('error')}`);
+                        this.error('Type not file or directory');
+                    }
+                }
+            });
+            this.log(`${chalk.green('Removing done.')}`);
+            cli.action.stop(`${chalk.green('done')}`);
+        } else {
+            cli.action.stop(`${chalk.red('error')}`);
+            this.error('Content validation failed.');
+        }
+    }
+    */
+    async run() {
+        const { flags } = this.parse(PrepareContent);
+        // read the flags and set paths relative to execution directory
+        let source = path.relative(process.cwd(), flags.source);
+        source = source ? source : '.';
+        let dest = flags.destination;
+        try {
+            let dotfileLines = await this.readDotfile(source);
+            this.log(`${chalk_1.default.blue('Content transformation started.')}`);
+            let transformations = await this.prepareTransformations(dotfileLines, source, dest);
+            await this.runTransformations(transformations);
+            this.log(`${chalk_1.default.green('Content prepared at: ', dest)}`);
+        }
+        catch (err) {
+            this.log(`${chalk_1.default.red(err)}`);
+            /*
+            In test mode, exit with status 0
+            */
+            if (process.env.OPS_TEST_MODE === 'true') {
+                this.exit(0);
+            }
+            this.exit(1);
+        }
+    }
+}
+exports.default = PrepareContent;
+PrepareContent.dotfile = '.opsprepare';
+PrepareContent.description = `copies files as described in ${PrepareContent.dotfile} which is at root of source directory`;
+PrepareContent.usage = 'prepare-content -d <destination> [-s <source>]';
+PrepareContent.examples = [
+    `$ ops prepare-content -d .\\my_workspace`,
+    `$ ops prepare-content -d .\\my_workspace -s .\\my_repository`,
+    `$ ops prepare-content -d C:\\git\\my_workspace`,
+    `$ ops prepare-content -d C:\\git\\my_workspace -s C:\\git\\my_repository\\my_repository`
+];
+PrepareContent.flags = {
+    destination: command_1.flags.string({
+        char: 'd',
+        description: 'where to copy the workspace files',
+        required: true
+    }),
+    source: command_1.flags.string({
+        char: 's',
+        description: '[optional] source directory, default: current dir',
+        required: false,
+        default: '.'
+    })
+};

package/lib/commands/sql.d.ts

@@ -0,0 +1,24 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../command.base';
+export default class Sql extends CommandBase {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        description: string;
+        options: string[];
+    }[];
+    static flags: {
+        version: flags.IOptionFlag<string | undefined>;
+        layer: flags.IOptionFlag<string | undefined>;
+    };
+    private readonly _moduleTypes;
+    private readonly _dbmsType;
+    /**
+     * Get unique scriptID by specified version
+     */
+    getScriptId(version: string): Promise<string>;
+    handleLayer(scriptDbmsFolder: string, scriptLayer: string, scriptType: string, dbmsFormat: string): Promise<string>;
+    run(): Promise<void>;
+}

package/lib/commands/sql.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const fs = require("fs-extra");
+const inquirer = require("inquirer");
+const path = require("path");
+const request = require("request-promise");
+const command_base_1 = require("../command.base");
+class Sql extends command_base_1.default {
+    constructor() {
+        super(...arguments);
+        this._moduleTypes = {
+            acc: 'Accounting',
+            claims: 'Claims',
+            core: 'Core',
+            pas: 'PAS',
+            reins: 'Reinsurance',
+            shared: 'Shared'
+        };
+        this._dbmsType = ['sql', 'oradc'];
+    }
+    /**
+     * Get unique scriptID by specified version
+     */
+    async getScriptId(version) {
+        let options = {
+            uri: `https://ops.adinsure.com/api/script/next?version=${version}`,
+            headers: {
+                Authorization: 'Bearer ' + await this.security.getToken()
+            }
+        };
+        return request.get(options);
+    }
+    async handleLayer(scriptDbmsFolder, scriptLayer, scriptType, dbmsFormat) {
+        let scriptFolder = path.resolve(scriptDbmsFolder, scriptLayer, scriptType);
+        let layerFolder = path.resolve(scriptDbmsFolder, scriptLayer);
+        if (!await fs.pathExists(layerFolder)) {
+            let layers = '';
+            // printout only layer folders
+            for (let layer of fs.readdirSync(scriptDbmsFolder)) {
+                if (layer.toLowerCase() !== 'schema' && layer.toLowerCase() !== 'data') {
+                    layers = layers + '\n' + layer;
+                }
+            }
+            if (layers.length > 0) {
+                this.log(`Layer ${scriptLayer} for ${dbmsFormat} does not exist, did you mean: ${layers}`);
+            }
+            else {
+                this.log(`Layer ${scriptLayer} for ${dbmsFormat} does not exist.`);
+            }
+        }
+        return scriptFolder;
+    }
+    async run() {
+        const { args, flags } = this.parse(Sql);
+        // Validation of input parameters
+        let scriptType = args.type;
+        if (!scriptType) {
+            let responses = await inquirer.prompt([{
+                    name: 'type',
+                    message: 'select a sql type',
+                    type: 'list',
+                    choices: [{ name: 'schema' }, { name: 'data' }, { name: 'migration' }],
+                }]);
+            scriptType = responses.type;
+        }
+        let scriptModule = args.module;
+        if (!scriptModule && scriptType === 'data') {
+            let responses = await inquirer.prompt([{
+                    name: 'module',
+                    message: 'select a sql module for data type',
+                    type: 'list',
+                    choices: [{ name: 'acc' }, { name: 'claims' }, { name: 'core' }, { name: 'pas' }, { name: 'reins' }, { name: 'shared' }],
+                }]);
+            scriptModule = responses.module;
+        }
+        let scriptLayer = flags.layer;
+        this.log(`Generating on SQL script layer:'${scriptLayer}'`);
+        const fullVersion = flags.version || await this.getVersion('PLATFORM_VERSION', 'VERSION');
+        let version = fullVersion.split('-')[0];
+        let versionRegex = /\d+\.\d+\.\d+/;
+        if (!(versionRegex.test(version))) {
+            this.error(`Version in incorrect format. Got version: '${version}'`);
+        }
+        let scriptsRootFolder = path.resolve(await this.getGitRoot(), 'database');
+        if (!await fs.pathExists(scriptsRootFolder)) {
+            this.error(`Could not resolve database scripts folder: ${scriptsRootFolder}`);
+        }
+        let scriptFolderLocations = [];
+        for (let dbmsFormat of this._dbmsType) {
+            let scriptDbmsFolder = path.resolve(scriptsRootFolder, dbmsFormat);
+            if (await fs.pathExists(scriptDbmsFolder)) {
+                let scriptFolder = path.resolve(scriptDbmsFolder, scriptType);
+                if (scriptLayer !== undefined) {
+                    scriptFolder = await this.handleLayer(scriptDbmsFolder, scriptLayer, scriptType, dbmsFormat);
+                }
+                if (scriptModule !== undefined) {
+                    scriptFolder = path.resolve(scriptFolder, this._moduleTypes[scriptModule]);
+                }
+                if (!await fs.pathExists(scriptFolder)) {
+                    this.warn(`Could not resolve existing database scripts folder. Creating folder: ${scriptFolder}`);
+                    await fs.mkdir(scriptFolder);
+                }
+                scriptFolderLocations.push(scriptFolder);
+            }
+        }
+        // Validation of parameters succeed. Requesting new SQL script ID and creating file.
+        this.log(`Requesting new id for '${version}'`);
+        let scriptId = await this.getScriptId(version);
+        this.log(`Got: '${chalk_1.default.green(scriptId)}'`);
+        for (let scriptFolder of scriptFolderLocations) {
+            let scriptsFilePath = path.resolve(scriptFolder, `${scriptId}.sql`);
+            await fs.writeFile(scriptsFilePath, '');
+            this.log(`${chalk_1.default.yellow(scriptsFilePath)}`);
+        }
+    }
+}
+exports.default = Sql;
+Sql.description = 'creates a new database script';
+Sql.usage = 'sql <type> <module> [flags]';
+Sql.examples = [
+    `$ ops sql schema `,
+    `$ ops sql data shared --layer basic`
+];
+Sql.args = [
+    {
+        name: 'type',
+        description: 'Type of database scripts',
+        options: ['schema', 'data', 'migration']
+    },
+    {
+        name: 'module',
+        description: 'Module of data database scripts',
+        options: ['acc', 'claims', 'core', 'pas', 'reins', 'shared']
+    }
+];
+Sql.flags = {
+    version: command_1.flags.string({
+        char: 'v',
+        description: 'version for which you\'re generating database script'
+    }),
+    layer: command_1.flags.string({
+        char: 'l',
+        description: 'name of the configuration layer for which you are generating database script'
+    })
+};

package/lib/commands/translate.d.ts

@@ -0,0 +1,37 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../command.base';
+export default class Translate extends CommandBase {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+    }[];
+    static flags: {
+        format: flags.IOptionFlag<string>;
+        module: flags.IOptionFlag<string | undefined>;
+        output: flags.IOptionFlag<string>;
+        filename: flags.IOptionFlag<string | undefined>;
+        respectServerFilename: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    getFormat(format: string): string;
+    /**
+     * Gets resources, checks a response and returns a response stream.
+     * @param languages list of translations to download
+     * @param format format of translations
+     * @param modules list of modules to download
+     * @returns arhive as an byte array response stream
+     */
+    getTranslations(languages: string, format: string, modules: string | undefined): Promise<any>;
+    /**
+     * Read from response stream and extract files into output directory.
+     * @param content zip file or a stream
+     * @param dest final destination to extract files
+     * @returns void
+     * @throws error message
+     */
+    extractFiles(content: any, destinationDir: string, xmlFilename?: string): Promise<any>;
+    run(): Promise<void>;
+}