@cyklang/cli 0.1.0

package/README.md

@@ -0,0 +1 @@
+# cyk-cli

package/aws-ecs.env

@@ -0,0 +1,38 @@
+# PostgreSql connection
+# used by psql command line utility
+PGHOST="localhost"
+PGPORT="5432"
+PGUSER="postgres"
+PGPASSWORD="postgres"
+
+# at postgresql database initialization
+
+# POSTGRES_USER="postgres"
+POSTGRES_PASSWORD="postgres"
+
+# admin user
+# created at database initialization
+ADMIN_NAME=cyk
+ADMIN_PASSWORD=cyk
+ADMIN_EMAIL=my-email@my-domain
+
+# JWT token generation
+# https://www.allkeysgenerator.com
+# 128 bits Hex 
+
+SECRET_TOKEN="423F4428472B4B6250655368566D5971"
+SECRET_RTOKEN="743777217A25432A46294A404E635266"
+
+# Login Page Config
+LOGIN_IMAGE="https://media.smartbox.com/pim/1000001967971201770883.jpg?thumbor=800x0/filters:quality(90)"
+LOGIN_TITLE="CYK Framework"
+LOGIN_SUBTITLE="Une application pilote du framework CYK"
+LOGIN_APPLI="accounting"
+
+# credential used by cyk CLI
+
+USER_NAME=cyk
+USER_PASSWORD=cyk
+CYK_PORT="3000"
+DBREMOTE_URL="http://localhost:3000"
+

package/build/Cmd.d.ts

@@ -0,0 +1,7 @@
+import { DBManager } from "@cyklang/core";
+import { Command } from "commander";
+export declare class Cmd extends Command {
+    dbManager: DBManager | undefined;
+    constructor(name: string);
+    prologue(options: any): Promise<void>;
+}

package/build/Cmd.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cmd = void 0;
+const core_1 = require("@cyklang/core");
+const commander_1 = require("commander");
+const dotenv_1 = __importDefault(require("dotenv"));
+const loglevel_1 = __importDefault(require("loglevel"));
+const NodeCrypto_1 = require("./NodeCrypto");
+const logger = loglevel_1.default.getLogger('Cmd.ts');
+logger.setLevel('debug');
+class Cmd extends commander_1.Command {
+    constructor(name) {
+        super(name);
+        this.option('--env <env>', 'path to the environment variables file');
+    }
+    async prologue(options) {
+        const dotenvOutput = dotenv_1.default.config({ path: options.env });
+        if (dotenvOutput.error !== undefined)
+            throw dotenvOutput.error;
+        const structure = new core_1.Structure();
+        if (process.env.DBREMOTE_URL === undefined)
+            throw 'DBREMOTE_URL undefined';
+        logger.debug('DBREMOTE_URL ' + process.env.DBREMOTE_URL);
+        const nodeCrypto = new NodeCrypto_1.NodeCrypto();
+        const dbRemote = new core_1.DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto);
+        const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD);
+        // logger.debug(login)
+        this.dbManager = new core_1.DBManager(structure.scope, dbRemote);
+        await this.dbManager.initialize();
+    }
+}
+exports.Cmd = Cmd;

package/build/DBClient.d.ts

@@ -0,0 +1,10 @@
+import { DBManager } from "@cyklang/core";
+export declare class DBClient {
+    dbManager: DBManager;
+    constructor(dbManager: DBManager);
+    selectFromTable(title: string, tableName: string, options: {
+        fields: string;
+        sort?: string | undefined;
+        where?: string | undefined;
+    }): Promise<void>;
+}

package/build/DBClient.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBClient = void 0;
+const core_1 = require("@cyklang/core");
+const loglevel_1 = __importDefault(require("loglevel"));
+const logger = loglevel_1.default.getLogger('DBClient.ts');
+logger.setLevel('debug');
+// DBManager wrapper class
+class DBClient {
+    constructor(dbManager) {
+        this.dbManager = dbManager;
+    }
+    async selectFromTable(title, tableName, options) {
+        try {
+            const objectDataType = this.dbManager.scope.structure.objectDataType;
+            const stringDataType = this.dbManager.scope.structure.stringDataType;
+            const request = new core_1.DBExecuteRequest();
+            request.selectFromTable = tableName;
+            request.parameters.addVariable('fields', stringDataType).data = new core_1.PrimitiveData(stringDataType, options.fields);
+            request.parameters.addVariable('where', stringDataType).data = new core_1.PrimitiveData(stringDataType, options.where);
+            if (options.sort !== undefined) {
+                const colnames = options.fields.split(',');
+                const sortcols = options.sort.split(',');
+                let order_by = '';
+                for (let ind = 0; ind < sortcols.length; ind++) {
+                    const coli = sortcols[ind];
+                    const colname = colnames[Number(coli)];
+                    if (order_by !== '')
+                        order_by += ',';
+                    order_by += colname;
+                }
+                logger.debug('order_by ' + order_by);
+                request.parameters.addVariable('order_by', stringDataType).data = new core_1.PrimitiveData(stringDataType, order_by);
+            }
+            // if (options !== undefined) {
+            //     Object.entries(options).forEach(([key, value]) => {
+            //         const data = new PrimitiveData(stringDataType, value)
+            //         request.parameters.addVariable(key, stringDataType).data = data
+            //     })
+            // }
+            const xmlResult = await this.dbManager.dbExecute(request);
+            if (xmlResult === undefined)
+                throw 'xmlResult undefined';
+            const tagXmlResult = (0, core_1.parseXML)('xmlResult', xmlResult);
+            const objXmlResult = (await objectDataType.parseData(tagXmlResult, this.dbManager.scope));
+            const objectMeta = (objXmlResult.variables.getData('meta'));
+            if (objectMeta === undefined)
+                throw 'objectMeta not found';
+            const xmlMeta = objectMeta.variables.getString(tableName);
+            if (xmlMeta === undefined)
+                throw 'meta does not have ' + tableName + ' description';
+            const tagDBTable = (0, core_1.parseXML)('dbTable', xmlMeta);
+            const dbTable = new core_1.DBTable(tagDBTable);
+            const fields = options.fields.split(',');
+            const list = new List();
+            for (let ind = 0; ind < fields.length; ind++) {
+                const field = fields[ind];
+                const dbColumn = dbTable.columns.filter((dbColumn) => dbColumn.name === field)[0];
+                if (dbColumn === undefined)
+                    throw 'field ' + field + ' not found';
+                list.addDBColumn(dbColumn);
+            }
+            const objDataset = objXmlResult.variables.getData(tableName);
+            for (let ind = 0; ind < objDataset.variables.length(); ind++) {
+                const record = objDataset.variables.at(ind)?.data;
+                list.addObjectData(record);
+            }
+            logger.info(list.renderList(title));
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+exports.DBClient = DBClient;
+class List {
+    constructor() {
+        this.columns = [];
+        this.rows = [];
+        this.lines = [];
+        this.currentLine = '';
+    }
+    addDBColumn(dbColumn) {
+        const col = new Column(dbColumn.name);
+        col.label = dbColumn.label || dbColumn.name;
+        col.dbColumn = dbColumn;
+        this.columns.push(col);
+    }
+    addObjectData(objectData) {
+        const cells = [];
+        this.columns.forEach((column) => {
+            let cell = undefined;
+            const data = objectData.variables.getData(column.name);
+            if (data !== undefined && data !== null) {
+                cell = data.value;
+            }
+            cells.push(cell);
+        });
+        this.rows.push(new Row(cells));
+    }
+    renderList(title) {
+        // calculate column.width
+        let total_width = 0;
+        for (let indi = 0; indi < this.columns.length; indi++) {
+            const column = this.columns[indi];
+            column.width = column.label.length;
+            this.rows.forEach((row) => {
+                const cell = row.cells[indi];
+                const renderedCell = this.renderCell(cell);
+                if (renderedCell.length > column.width) {
+                    column.width = renderedCell.length;
+                }
+            });
+            if (total_width > 0)
+                total_width += 3;
+            total_width += column.width;
+        }
+        // title
+        this.lines.push(this.renderCell(title, total_width, 'center'));
+        // header
+        this.lines.push(this.renderHeaderRow());
+        this.lines.push(this.renderSeparator());
+        // rows
+        for (let indj = 0; indj < this.rows.length; indj++) {
+            const row = this.rows[indj];
+            this.lines.push(this.renderRow(row));
+        }
+        return this.lines.join('\n');
+    }
+    renderHeaderRow() {
+        let result = '';
+        for (let indi = 0; indi < this.columns.length; indi++) {
+            const column = this.columns[indi];
+            if (result !== '')
+                result += ' | ';
+            result += this.renderCell(column.label, column.width, 'center');
+        }
+        return result;
+    }
+    renderRow(row) {
+        let result = '';
+        for (let indi = 0; indi < this.columns.length; indi++) {
+            const column = this.columns[indi];
+            let justify = 'left';
+            if (column.dbColumn?.dataTypeName === 'number' || column?.type === 'number') {
+                justify = 'right';
+            }
+            if (result !== '')
+                result += ' | ';
+            result += this.renderCell(row.cells[indi], column.width, justify);
+        }
+        return result;
+    }
+    renderSeparator() {
+        let result = '';
+        for (let indi = 0; indi < this.columns.length; indi++) {
+            const column = this.columns[indi];
+            if (result !== '')
+                result += '-+-';
+            result += '-'.repeat(column.width);
+        }
+        return result;
+    }
+    renderCell(value, width, justify) {
+        let result;
+        if (value === undefined) {
+            result = '';
+        }
+        else if (value === null) {
+            result = 'null';
+        }
+        else {
+            result = value.toString();
+        }
+        if (width !== undefined && result.length < width) {
+            if (justify === undefined || justify === 'left') {
+                result += ' '.repeat(width - result.length);
+            }
+            else if (justify === 'right') {
+                result = ' '.repeat(width - result.length) + result;
+            }
+            else {
+                // justify === center
+                const before = Math.floor((width - result.length) / 2);
+                result = ' '.repeat(before) + result + ' '.repeat(width - result.length - before);
+            }
+        }
+        return result;
+    }
+}
+class Column {
+    constructor(name) {
+        this.label = '';
+        this.width = 0;
+        this.name = name;
+    }
+}
+class Row {
+    constructor(cells) {
+        this.cells = cells;
+    }
+}

package/build/InitCommand.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+export declare class InitCommand extends Command {
+    constructor(name: string);
+    commandInit(options: any): Promise<void>;
+    getRandomInt(min: number, max: number): number;
+    generateToken(): string;
+    writeEnvFile(): Promise<void>;
+    writeDockerComposeFile(): Promise<void>;
+}

package/build/InitCommand.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitCommand = void 0;
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const loglevel_1 = require("loglevel");
+const logger = (0, loglevel_1.getLogger)('InitCommand.ts');
+logger.setLevel('debug');
+class InitCommand extends commander_1.Command {
+    constructor(name) {
+        super(name);
+        this.description('initialize a folder with files necessary for a cyklang project')
+            .action(async (options) => {
+            await this.commandInit(options);
+        });
+    }
+    async commandInit(options) {
+        try {
+            await this.writeEnvFile();
+            await this.writeDockerComposeFile();
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+    // developer.mozilla.org Math.random()
+    // On renvoie un entier aléatoire entre une valeur min (incluse)
+    // et une valeur max (exclue).
+    // Attention : si on utilisait Math.round(), on aurait une distribution
+    // non uniforme !
+    getRandomInt(min, max) {
+        min = Math.ceil(min);
+        max = Math.floor(max);
+        return Math.floor(Math.random() * (max - min)) + min;
+    }
+    generateToken() {
+        let result = '';
+        for (let ind = 0; ind < 32; ind++) {
+            result += this.getRandomInt(0, 15).toString(16);
+        }
+        return result;
+    }
+    async writeEnvFile() {
+        const envFilename = '.env';
+        if (fs.existsSync(envFilename) === true) {
+            logger.info(envFilename + ' file already exists. Remove it before launching init command');
+            return;
+        }
+        Math.random();
+        const content = `# PostgreSql connection
+# used by psql command line utility
+PGHOST="localhost"
+PGPORT="4321"
+PGUSER="postgres"
+PGPASSWORD="postgres"
+
+# at postgresql database initialization
+
+# POSTGRES_USER="postgres"
+POSTGRES_PASSWORD="postgres"
+
+# admin user
+# created at database initialization
+ADMIN_NAME=cyk
+ADMIN_PASSWORD=cyk
+ADMIN_EMAIL=my-email@my-domain
+
+# JWT token generation
+# e.g. https://www.allkeysgenerator.com
+# 128 bits Hex 
+
+SECRET_TOKEN="${this.generateToken()}"
+SECRET_RTOKEN="${this.generateToken()}"
+
+# Login Page Config
+LOGIN_IMAGE="https://media.smartbox.com/pim/1000001967971201770883.jpg?thumbor=800x0/filters:quality(90)"
+LOGIN_TITLE="CYK Framework"
+LOGIN_SUBTITLE="Une application pilote du framework CYK"
+LOGIN_APPLI="accounting"
+
+# credential used by cyk CLI
+
+USER_NAME=cyk
+USER_PASSWORD=cyk
+CYK_PORT="3000"
+DBREMOTE_URL="http://localhost:3000"        
+`;
+        fs.writeFileSync(envFilename, content);
+        logger.debug('created ' + envFilename);
+    }
+    async writeDockerComposeFile() {
+        const dockerComposeFilename = 'docker-compose.yml';
+        if (fs.existsSync(dockerComposeFilename) === true) {
+            logger.info(dockerComposeFilename + ' already exists. Remove it before launching init command');
+            return;
+        }
+        const modelFilename = __dirname + '/../' + dockerComposeFilename;
+        const content = fs.readFileSync(modelFilename);
+        fs.writeFileSync(dockerComposeFilename, content);
+        logger.debug('created ' + dockerComposeFilename);
+    }
+}
+exports.InitCommand = InitCommand;

package/build/ModuleCommand.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env ts-node
+import { Command } from 'commander';
+export declare class ModuleCommand extends Command {
+    constructor(name: string);
+}

package/build/ModuleCommand.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env ts-node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleCommand = void 0;
+const core_1 = require("@cyklang/core");
+const fs = __importStar(require("fs"));
+const loglevel_1 = __importDefault(require("loglevel"));
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const Cmd_1 = require("./Cmd");
+const DBClient_1 = require("./DBClient");
+const logger = loglevel_1.default.getLogger("ModuleCommand.ts");
+logger.setLevel("debug");
+class ModuleCommand extends commander_1.Command {
+    constructor(name) {
+        super(name);
+        this.description('manage modules');
+        // upload
+        this.addCommand(new ModuleUpload('upload', `Upload local module file(s) to the database.
+Module name is the base name of the file. If a module with the same name already exists, it will be updated.
+Otherwise, a new module is inserted in the database. To rename a module, use option --id to indicate the module you want to rename`));
+        this.addCommand(new ModuleUpload('u', 'shortcut for (u)pload'));
+        // download
+        this.addCommand(new ModuleDownload('download', 'download module files to the current directory'));
+        this.addCommand(new ModuleDownload('d', 'shortcut for (d)ownload'));
+        // list
+        this.addCommand(new ModuleList('list', 'List modules'));
+        this.addCommand(new ModuleList('l', 'shortcut for (l)ist'));
+        // rename
+    }
+}
+exports.ModuleCommand = ModuleCommand;
+function getModuleDBName(filePath) {
+    let result;
+    if (filePath.endsWith('.xml') === false)
+        throw filePath + ' does not have .xml extension';
+    result = path_1.default.basename(filePath, '.xml');
+    const identifierRegex = /^[_a-zA-Z][_a-zA-Z0-9]*$/;
+    if (result.match(identifierRegex) === null)
+        throw 'filename ' + result + ' does not match identifier syntax';
+    return result;
+}
+class ModuleUpload extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .option('-i --id <id>', 'module ID to download')
+            .argument('[files...]', 'local module file(s) to upload to the server')
+            .action(async (files, options) => {
+            await this.commandUpload(files, options);
+        });
+    }
+    async commandUpload(files, options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            if (files.length === 0)
+                throw 'file(s) argument is missing';
+            if (options.id !== undefined) {
+                if (files.length > 1)
+                    throw 'with --id option you can only specify 1 local file';
+                const dbModule = await this.dbManager.getModule(options.id);
+                dbModule.source = fs.readFileSync(files[0]).toString();
+                dbModule.dbname = getModuleDBName(files[0]);
+                const tag = (0, core_1.parseXML)(dbModule.dbname, dbModule.source);
+                dbModule.access = tag.attributes.ACCESS;
+                dbModule.description = tag.attributes.DESCRIPTION;
+                await this.dbManager.dbModuleUpdate(dbModule);
+            }
+            else {
+                for (let ind = 0; ind < files.length; ind++) {
+                    const file = files[ind];
+                    const dbname = getModuleDBName(file);
+                    const source = fs.readFileSync(file).toString();
+                    const tag = (0, core_1.parseXML)(dbname, source);
+                    const dbModuleExist = await this.dbManager.dbModuleExist(dbname);
+                    if (dbModuleExist === undefined) {
+                        // insert
+                        const dbModule = new core_1.DBModule();
+                        dbModule.source = source;
+                        dbModule.dbname = dbname;
+                        dbModule.access = tag.attributes.ACCESS;
+                        dbModule.description = tag.attributes.DESCRIPTION;
+                        logger.debug('module insert ' + dbname + ' access ' + dbModule.access + ' description ' + dbModule.description);
+                        const id = await this.dbManager.dbModuleInsert(dbModule);
+                        logger.info('module ' + dbname + ' added with ID ' + id);
+                    }
+                    else {
+                        // update
+                        dbModuleExist.access = tag.attributes.ACCESS;
+                        dbModuleExist.description = tag.attributes.DESCRIPTION;
+                        logger.debug('module update ' + dbname + ' access ' + dbModuleExist.access + ' description ' + dbModuleExist.description);
+                        await this.dbManager.dbModuleUpdate(dbModuleExist);
+                        logger.info('module ' + dbname + ' updated');
+                    }
+                }
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+class ModuleDownload extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .option('-i --id <id>', 'module ID')
+            .option('-a --all', 'download all the modules')
+            .argument('[files...]', 'module(s) name(s) are derived as the basename(s) of the file(s) path')
+            .action(async (files, options) => {
+            await this.commandDownload(files, options);
+        });
+    }
+    async commandDownload(files, options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            if (options.id !== undefined) {
+                const dbModule = await this.dbManager.getModule(options.id);
+                await this.downloadModule(dbModule.dbname || '', dbModule);
+            }
+            else if (options.all !== undefined) {
+                const modules = await this.dbManager.getModules(undefined);
+                for (let ind = 0; ind < modules.length; ind++) {
+                    const dbModule = modules[ind];
+                    await this.downloadModule(dbModule.dbname || '', dbModule);
+                }
+            }
+            else {
+                for (let ind = 0; ind < files.length; ind++) {
+                    await this.downloadModule(getModuleDBName(files[ind]));
+                }
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+    async downloadModule(dbname, dbModule) {
+        logger.debug('downloadModule ' + dbname);
+        if (dbModule === undefined) {
+            dbModule = await this.dbManager?.dbModuleExist(dbname);
+            if (dbModule === undefined)
+                throw 'module not found : ' + dbname;
+        }
+        const filePath = dbname + '.xml';
+        if (fs.existsSync(filePath) === true) {
+            logger.info('file ' + filePath + ' already exists and will not be overwritten ');
+        }
+        else {
+            fs.writeFileSync(filePath, dbModule.source || '');
+            logger.info('module ' + dbname + ' has been downloaded and file ' + filePath + ' has been created');
+        }
+    }
+}
+class ModuleList extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .option('-s --sort <columns>', 'sort list by column numbers (begins by 0) separated by comma')
+            .action(async (options) => {
+            await this.commandList(options);
+        });
+    }
+    async commandList(options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            const dbClient = new DBClient_1.DBClient(this.dbManager);
+            dbClient.selectFromTable('List of Modules', 'cyk_module', { fields: 'module_id,module_dbname,module_access,module_description', sort: options.sort || '1' });
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}

package/build/NodeCrypto.d.ts

@@ -0,0 +1,5 @@
+import { CryptoEngine } from '@cyklang/core';
+export declare class NodeCrypto implements CryptoEngine {
+    encrypt(plain: string): Promise<string>;
+    decrypt(encoded: string): Promise<string>;
+}