@cyklang/cli 0.1.2 → 0.2.0

package/build/AssetCommand.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+export declare class AssetCommand extends Command {
+    constructor(name: string, description: string);
+}

package/build/AssetCommand.js

@@ -0,0 +1,293 @@
+"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.AssetCommand = void 0;
+const commander_1 = require("commander");
+const loglevel_1 = require("loglevel");
+const Cmd_1 = require("./Cmd");
+const DBClient_1 = require("./DBClient");
+const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const mime_types_1 = __importDefault(require("mime-types"));
+const readline_1 = __importDefault(require("readline"));
+const core_1 = require("@cyklang/core");
+const form_data_1 = __importDefault(require("form-data"));
+const logger = (0, loglevel_1.getLogger)('AssetCommand.ts');
+logger.setLevel('debug');
+class AssetCommand extends commander_1.Command {
+    constructor(name, description) {
+        super(name);
+        this.description(description);
+        this.addCommand(new AssetList('list', 'list assets'));
+        this.addCommand(new AssetList('l', '(l)ist assets'));
+        this.addCommand(new AssetUpload('upload', 'upload assets from current directory'));
+        this.addCommand(new AssetUpload('u', '(u)pload assets'));
+    }
+}
+exports.AssetCommand = AssetCommand;
+class AssetList 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 Assets', 'cyk_asset', { fields: 'asset_id,asset_route,asset_last_update,asset_mimetype', sort: options.sort || '1' });
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+class AssetUpload extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        //----------------------------------------------------------------------------------------------
+        // file2exclude
+        //----------------------------------------------------------------------------------------------
+        this.ignorePatterns = ['.git', 'node_modules'];
+        this.description(description)
+            .option('-d --dest <destination>', 'route of destination')
+            .argument('[sources...]', 'local files or directories to upload as assets to the server')
+            .action(async (sources, options) => {
+            await this.commandUpload(sources, options);
+        });
+    }
+    async commandUpload(sources, options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            if (sources.length === 0)
+                throw 'no source to upload';
+            let dest = "/";
+            if (options.dest !== undefined)
+                dest = options.dest;
+            if (dest.substring(0, 1) !== '/')
+                dest = '/' + dest;
+            if (dest.substring(dest.length - 1) !== '/')
+                dest = dest + '/';
+            for (let ind = 0; ind < sources.length; ind++) {
+                const source = sources[ind];
+                if (fs.existsSync(source) === false)
+                    throw 'source ' + source + ' does not exist';
+                const filestat = fs.lstatSync(source);
+                if (filestat.isDirectory() === true) {
+                    await this.uploadDirectory(source, dest);
+                }
+                else if (filestat.isFile() === true) {
+                    const base = path_1.default.parse(source).base;
+                    logger.debug('upload file ' + source + ' to ' + dest + base);
+                    await this.uploadAsset({ path: source, mtime: filestat.mtime }, dest + base);
+                }
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+    //----------------------------------------------------------------------------------------------
+    // uploadDirectory
+    //----------------------------------------------------------------------------------------------
+    async uploadDirectory(source, dest) {
+        const localList = [];
+        let dirName;
+        if (source.substring(source.length - 1) === '/') {
+            // trailing directory separator
+            dirName = source;
+        }
+        else {
+            dirName = source + '/';
+        }
+        logger.debug('dirName', dirName);
+        this.scanDir(dirName, localList);
+        const remoteList = [];
+        await this.scanAssets(remoteList);
+        const uploadList = this.buildUploadList(dirName, dest, localList, remoteList);
+        // logger.info(fileNames.join('\n'))
+        if (uploadList.length === 0)
+            throw 'None file to upload';
+        const rl = readline_1.default.createInterface(process.stdin, process.stdout);
+        rl.question('Do you want to upload this(these) ' + uploadList.length + ' file(s) (Y/N/y/n) ?', async (reply) => {
+            rl.close();
+            if (reply !== 'Y' && reply !== 'y') {
+                logger.info('upload cancelled');
+                return;
+            }
+            await this.uploadFiles(dirName, uploadList, dest);
+        });
+    }
+    //----------------------------------------------------------------------------------------------
+    // buildUploadList
+    //----------------------------------------------------------------------------------------------
+    buildUploadList(dirName, dest, localList, remoteList) {
+        const result = [];
+        const remoteMap = new Map();
+        for (let ind = 0; ind < remoteList.length; ind++) {
+            const remote = remoteList[ind];
+            remoteMap.set(remote.path, remote);
+        }
+        for (let ind = 0; ind < localList.length; ind++) {
+            const localDesc = localList[ind];
+            const route = dest + localDesc.path.substring(dirName.length);
+            const remoteDesc = remoteMap.get(route);
+            if (remoteDesc === undefined || remoteDesc.mtime.getTime() + 1000 < localDesc.mtime.getTime()) {
+                if (remoteDesc === undefined)
+                    logger.debug('remoteDesc undefined');
+                else
+                    logger.debug('remoteDesc.mtime ' + remoteDesc.mtime.getTime(), 'localDesc.mtime ' + localDesc.mtime.getTime());
+                logger.info(localDesc.path);
+                result.push(localDesc);
+            }
+        }
+        return result;
+    }
+    //----------------------------------------------------------------------------------------------
+    // scanAssets
+    //----------------------------------------------------------------------------------------------
+    async scanAssets(result) {
+        if (this.dbManager === undefined)
+            throw 'dbManager undefined';
+        const dbReq = new core_1.DBExecuteRequest();
+        dbReq.selectFromTable = 'cyk_asset';
+        const pFields = dbReq.parameters.addVariable('fields', this.dbManager.scope.structure.stringDataType);
+        pFields.data = new core_1.PrimitiveData(this.dbManager.scope.structure.stringDataType, "asset_id,asset_route,asset_last_update,asset_mimetype");
+        const xmlResult = await this.dbManager.dbExecute(dbReq);
+        if (xmlResult === undefined || xmlResult === null)
+            throw 'xmlResult null or undefined';
+        const tag = (0, core_1.parseXML)('scanAssets', xmlResult);
+        const objResult = await this.dbManager.scope.structure.objectDataType.parseData(tag, this.dbManager.scope);
+        const rows = objResult.variables.getData('cyk_asset').variables;
+        for (let ind = 0; ind < rows.list.length; ind++) {
+            const { variable: row } = rows.list[ind];
+            const record = row.data;
+            const asset_route = record.variables.getData('asset_route').value;
+            const asset_last_update = record.variables.getData('asset_last_update').value;
+            // logger.debug('asset_route ' + asset_route,'asset_last_update ' + asset_last_update)
+            result.push({ path: asset_route, mtime: asset_last_update });
+        }
+    }
+    //----------------------------------------------------------------------------------------------
+    // scanDir
+    //----------------------------------------------------------------------------------------------
+    scanDir(dirName, result) {
+        const files = fs.readdirSync(dirName);
+        for (let ind = 0; ind < files.length; ind++) {
+            const fileName = files[ind];
+            if (this.file2exclude(fileName) === true)
+                continue;
+            const fstat = fs.statSync(dirName + fileName);
+            if (fstat.isDirectory() === true) {
+                this.scanDir(dirName + fileName + '/', result);
+            }
+            else {
+                if (mime_types_1.default.lookup(fileName) === false) {
+                    logger.info(fileName + ' file extension is unknown and will not be uploaded');
+                    continue;
+                }
+                //const dbAssetExist = this.dbManager?.dbAssetExist()
+                result.push({ path: dirName + fileName, mtime: fstat.mtime });
+                // logger.debug(dirName + '/' + fileName)
+            }
+        }
+    }
+    file2exclude(fileName) {
+        let result = false;
+        this.ignorePatterns.forEach((pattern) => {
+            if (fileName === pattern)
+                result = true;
+        });
+        return result;
+    }
+    //----------------------------------------------------------------------------------------------
+    // uploadFiles
+    //----------------------------------------------------------------------------------------------
+    async uploadFiles(dirName, uploadList, dest) {
+        for (let ind = 0; ind < uploadList.length; ind++) {
+            const upload = uploadList[ind];
+            const route = dest + upload.path.substring(dirName.length);
+            logger.debug('upload ' + upload.path + ' to ' + route);
+            await this.uploadAsset(upload, route);
+        }
+    }
+    //----------------------------------------------------------------------------------------------
+    // uploadAsset
+    //----------------------------------------------------------------------------------------------
+    async uploadAsset(upload, route) {
+        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + mime_types_1.default.lookup(upload.path));
+        try {
+            let dbAsset = await this.dbManager?.dbAssetExist(route);
+            if (dbAsset === undefined) {
+                dbAsset = new core_1.DBAsset();
+            }
+            const mimetype = mime_types_1.default.lookup(upload.path);
+            if (mimetype === false)
+                throw 'mimetype false for ' + upload;
+            dbAsset.mimetype = mimetype;
+            dbAsset.route = route;
+            // const fstat = fs.statSync(fileName)
+            dbAsset.last_update = upload.mtime;
+            // const contentBuffer = fs.readFileSync(fileName)
+            // dbAsset.content = contentBuffer
+            // logger.debug('dbAsset.content length ' + dbAsset.content.length)
+            if (dbAsset.id === undefined) {
+                dbAsset.id = await this.dbManager?.dbAssetInsert(dbAsset);
+                logger.info('inserted asset ' + dbAsset.id + ' route ' + dbAsset.route);
+            }
+            else {
+                await this.dbManager?.dbAssetUpdate(dbAsset);
+                logger.info('updated asset ' + dbAsset.route);
+            }
+            await this.uploadAssetContent(dbAsset, upload.path);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+    //----------------------------------------------------------------------------------------------
+    // uploadAssetContent
+    //----------------------------------------------------------------------------------------------
+    async uploadAssetContent(dbAsset, fileName) {
+        logger.debug('uploadAssetContent file ' + fileName + ' to path ' + path_1.default);
+        try {
+            const file = fs.createReadStream(fileName);
+            const form = new form_data_1.default();
+            form.append('uploadFile', file);
+            const route = '/upload/cyk_asset/asset_content?asset_id=' + dbAsset.id;
+            const resp = await this.dbRemote?.apiServer.post(route, form);
+            if (resp.status === 200) {
+                logger.info(fileName + ' uploaded');
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}

package/build/Cmd.d.ts

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

package/build/Cmd.js

@@ -25,10 +25,10 @@ class Cmd extends commander_1.Command {
             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);
+        this.dbRemote = new core_1.DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto);
+        const login = await this.dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD);
         // logger.debug(login)
-        this.dbManager = new core_1.DBManager(structure.scope, dbRemote);
+        this.dbManager = new core_1.DBManager(structure.scope, this.dbRemote);
         await this.dbManager.initialize();
     }
 }

package/build/DBClient.d.ts

@@ -6,5 +6,6 @@ export declare class DBClient {
         fields: string;
         sort?: string | undefined;
         where?: string | undefined;
+        width?: string | undefined;
     }): Promise<void>;
 }

package/build/DBClient.js

@@ -56,6 +56,8 @@ class DBClient {
             const dbTable = new core_1.DBTable(tagDBTable);
             const fields = options.fields.split(',');
             const list = new List();
+            if (options.width !== undefined)
+                list.width = options.width;
             for (let ind = 0; ind < fields.length; ind++) {
                 const field = fields[ind];
                 const dbColumn = dbTable.columns.filter((dbColumn) => dbColumn.name === field)[0];
@@ -78,6 +80,7 @@ class DBClient {
 exports.DBClient = DBClient;
 class List {
     constructor() {
+        this.width = "0";
         this.columns = [];
         this.rows = [];
         this.lines = [];
@@ -102,21 +105,40 @@ class List {
         this.rows.push(new Row(cells));
     }
     renderList(title) {
-        // calculate column.width
+        // parse width option
+        const colws = [];
+        const colws_ = this.width.split(',');
+        for (let ind = 0; ind < colws_.length; ind++) {
+            const colw = Number.parseInt(colws_[ind]);
+            if (isNaN(colw)) {
+                const msg = '--width incorrect format : ' + this.width;
+                throw msg;
+            }
+            colws.push(colw);
+        }
+        logger.debug('colws', colws.join(','));
+        // calculate column.actualWidth
         let total_width = 0;
         for (let indi = 0; indi < this.columns.length; indi++) {
             const column = this.columns[indi];
-            column.width = column.label.length;
+            if (indi < colws.length)
+                column.width = colws[indi];
+            else
+                column.width = colws[colws.length - 1];
+            column.actualWidth = 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 (renderedCell.length > column.actualWidth) {
+                    if (column.width === 0 || renderedCell.length < column.width)
+                        column.actualWidth = renderedCell.length;
+                    else
+                        column.actualWidth = column.width;
                 }
             });
             if (total_width > 0)
                 total_width += 3;
-            total_width += column.width;
+            total_width += column.actualWidth;
         }
         // title
         this.lines.push(this.renderCell(title, total_width, 'center'));
@@ -128,6 +150,8 @@ class List {
             const row = this.rows[indj];
             this.lines.push(this.renderRow(row));
         }
+        this.lines.push(this.renderSeparator());
+        this.lines.push('Number of lines : ' + this.rows.length);
         return this.lines.join('\n');
     }
     renderHeaderRow() {
@@ -136,7 +160,7 @@ class List {
             const column = this.columns[indi];
             if (result !== '')
                 result += ' | ';
-            result += this.renderCell(column.label, column.width, 'center');
+            result += this.renderCell(column.label, column.actualWidth, 'center');
         }
         return result;
     }
@@ -150,7 +174,7 @@ class List {
             }
             if (result !== '')
                 result += ' | ';
-            result += this.renderCell(row.cells[indi], column.width, justify);
+            result += this.renderCell(row.cells[indi], column.actualWidth, justify);
         }
         return result;
     }
@@ -160,7 +184,7 @@ class List {
             const column = this.columns[indi];
             if (result !== '')
                 result += '-+-';
-            result += '-'.repeat(column.width);
+            result += '-'.repeat(column.actualWidth);
         }
         return result;
     }
@@ -172,20 +196,29 @@ class List {
         else if (value === null) {
             result = 'null';
         }
+        else if (value instanceof Date) {
+            const d = value;
+            result = d.toISOString();
+        }
         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;
+        if (width !== undefined && width !== 0) {
+            if (result.length >= width) {
+                result = result.substring(0, width);
             }
             else {
-                // justify === center
-                const before = Math.floor((width - result.length) / 2);
-                result = ' '.repeat(before) + result + ' '.repeat(width - result.length - before);
+                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;
@@ -195,6 +228,7 @@ class Column {
     constructor(name) {
         this.label = '';
         this.width = 0;
+        this.actualWidth = 0;
         this.name = name;
     }
 }

package/build/ModuleCommand.js

@@ -53,10 +53,10 @@ Otherwise, a new module is inserted in the database. To rename a module, use opt
 }
 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');
+    // let result
+    // if (filePath.endsWith('.xml') === false) throw filePath + ' does not have .xml extension'
+    // result = path.basename(filePath, '.xml')
+    const result = path_1.default.parse(filePath).name;
     const identifierRegex = /^[_a-zA-Z][_a-zA-Z0-9]*$/;
     if (result.match(identifierRegex) === null)
         throw 'filename ' + result + ' does not match identifier syntax';
@@ -66,7 +66,7 @@ class ModuleUpload extends Cmd_1.Cmd {
     constructor(name, description) {
         super(name);
         this.description(description)
-            .option('-i --id <id>', 'module ID to download')
+            .option('-i --id <id>', 'module ID to upload')
             .argument('[files...]', 'local module file(s) to upload to the server')
             .action(async (files, options) => {
             await this.commandUpload(files, options);
@@ -171,7 +171,7 @@ class ModuleDownload extends Cmd_1.Cmd {
         }
         const filePath = dbname + '.xml';
         if (fs.existsSync(filePath) === true) {
-            logger.info('file ' + filePath + ' already exists and will not be overwritten ');
+            logger.info('file ' + filePath + ' already exists. Remove it before launching the command if you want to overwrite.');
         }
         else {
             fs.writeFileSync(filePath, dbModule.source || '');