@cyklang/cli 0.5.5 → 0.6.0

package/build/AssetCommand.js

@@ -354,11 +354,9 @@ function buildUploadList(dirName, dest, localList, remoteList) {
         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);
+            // 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);
         }
     }
@@ -417,7 +415,7 @@ async function uploadFiles(dirName, uploadList, dest, dbManager, dbRemote, auth)
     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);
+        // logger.debug('upload ' + upload.path + ' to ' + route)
         await uploadAsset(upload, route, dbManager, dbRemote, auth);
     }
 }
@@ -451,7 +449,7 @@ async function uploadAsset(upload, route, dbManager, dbRemote, auth) {
         // logger.debug('dbAsset.content length ' + dbAsset.content.length)
         if (dbAsset.id === undefined) {
             dbAsset.id = await dbManager?.dbAssetInsert(dbAsset);
-            logger.info('inserted asset ' + dbAsset.id + ' route ' + dbAsset.route);
+            logger.info('inserted asset ' + dbAsset.route);
         }
         else {
             await dbManager?.dbAssetUpdate(dbAsset);
@@ -486,7 +484,7 @@ function mimetypeLookup(filename) {
  * @param dbRemote
  */
 async function uploadAssetContent(dbAsset, fileName, dbRemote) {
-    logger.debug('uploadAssetContent file ' + fileName + ' to path ' + path_1.default);
+    // logger.debug('uploadAssetContent file ' + fileName + ' to path ' + path)
     try {
         const file = fs.createReadStream(fileName);
         const form = new form_data_1.default();

package/build/InstallCommand.js

@@ -72,7 +72,7 @@ async function installPackage(node_package, dbManager, dbRemote) {
     /**
      * install the Node Package
      */
-    await installNodePackage(node_package, dbManager);
+    await installNodePackage(node_package, dbManager, dbRemote);
     const installScript = await lookupInstallScript(node_package);
     if (installScript) {
         /**
@@ -117,8 +117,6 @@ async function uploadPackageAssets(node_package, dbManager, dbRemote) {
     }
     console.log();
     console.log('upload assets to server ...');
-    if (!dbManager)
-        throw 'dbManager undefined';
     const items = fs.readdirSync(assetFolder);
     for (let ind = 0; ind < items.length; ind++) {
         const item = items[ind];
@@ -168,7 +166,7 @@ async function uploadPackageModules(node_package, dbManager) {
  * method installNodePackage
  * @param node_package
  */
-async function installNodePackage(node_package, dbManager) {
+async function installNodePackage(node_package, dbManager, dbRemote) {
     try {
         const packageJson = await (0, Cmd_1.readPackageJson)();
         if (packageJson.devDependencies && packageJson.devDependencies[node_package]
@@ -176,7 +174,7 @@ async function installNodePackage(node_package, dbManager) {
             console.log(node_package + ' already installed. We uninstall it first');
             if (!dbManager)
                 throw 'dbManager undefined';
-            await (0, UninstallCommand_1.uninstallPackage)(node_package, dbManager);
+            await (0, UninstallCommand_1.uninstallPackage)(node_package, dbManager, dbRemote);
         }
         await (0, Cmd_1.runShellCommand)('npm', ['install', '--save-dev', node_package]);
     }

package/build/TableCommand.d.ts

@@ -1,5 +1,14 @@
 #!/usr/bin/env ts-node
+import { DBManager } from "@cyklang/core";
+import loglevel from 'loglevel';
 import { Command } from "commander";
+export declare const logger: loglevel.Logger;
 export declare class TableCommand extends Command {
     constructor(name: string);
 }
+/**
+ * function dropTable
+ * @param table
+ * @param dbManager
+ */
+export declare function dropTable(table: string, dbManager: DBManager): Promise<void>;

package/build/TableCommand.js

@@ -27,7 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableCommand = void 0;
+exports.dropTable = exports.TableCommand = exports.logger = void 0;
 const fs = __importStar(require("fs"));
 const loglevel_1 = __importDefault(require("loglevel"));
 const commander_1 = require("commander");
@@ -35,8 +35,9 @@ const child_process_1 = require("child_process");
 const Cmd_1 = require("./Cmd");
 const DBClient_1 = require("./DBClient");
 const form_data_1 = __importDefault(require("form-data"));
-const logger = loglevel_1.default.getLogger("TableCommand.ts");
-logger.setLevel("debug");
+const inquirer_1 = __importDefault(require("inquirer"));
+exports.logger = loglevel_1.default.getLogger("TableCommand.ts");
+exports.logger.setLevel("debug");
 class TableCommand extends commander_1.Command {
     constructor(name) {
         super(name);
@@ -45,8 +46,7 @@ class TableCommand extends commander_1.Command {
         this.addCommand(new TableImportCmd());
         this.addCommand(new TableList('list', 'list database tables'));
         this.addCommand(new TableList('l', '(l)ist database tables'));
-        this.addCommand(new TableData('data', 'table (d)ata'));
-        this.addCommand(new TableData('d', 'table (d)ata'));
+        this.addCommand(new TableDropCommand('drop', 'drop table'));
         this.addCommand(new TableUpdate('update', 'update table properties'));
         this.addCommand(new TableUpdate('u', 'shortcut for (u)pdate table properties'));
     }
@@ -84,7 +84,7 @@ class TableUpdate extends Cmd_1.Cmd {
             await this.updateAuthAccess('cyk_table', 'table', dbTable.id || '', options);
         }
         catch (err) {
-            logger.error(err);
+            exports.logger.error(err);
         }
     }
 }
@@ -115,7 +115,7 @@ class TableExportCmd extends Cmd_1.Cmd {
                 const tableName = tables[indi];
                 const dbTable = await this.dbManager.dbTableExist(tableName);
                 if (dbTable === undefined) {
-                    logger.info('table ' + tableName + ' not found');
+                    exports.logger.info('table ' + tableName + ' not found');
                     continue;
                 }
                 const filename = buildFilename(dbTable.name, options);
@@ -123,7 +123,7 @@ class TableExportCmd extends Cmd_1.Cmd {
             }
         }
         catch (err) {
-            logger.error(err);
+            exports.logger.error(err);
         }
     }
     async copyTo(dbTable, filename) {
@@ -134,15 +134,15 @@ class TableExportCmd extends Cmd_1.Cmd {
             const response = await this.dbRemote.apiServer.get('/admin/export/' + dbTable.name, { responseType: 'stream' });
             const stream = response;
             stream.on('data', (data) => {
-                logger.debug('**** DATA ****', data.length);
+                exports.logger.debug('**** DATA ****', data.length);
                 const textDecoder = new TextDecoder();
                 const chunk = (textDecoder.decode(data));
                 writeStream.write(chunk);
             });
-            stream.on('end', () => logger.debug('**** DONE ****'));
+            stream.on('end', () => exports.logger.debug('**** DONE ****'));
         }
         catch (err) {
-            logger.error(err);
+            exports.logger.error(err);
         }
     }
 }
@@ -173,7 +173,7 @@ class TableImportCmd extends Cmd_1.Cmd {
                 const tableName = tables[indi];
                 const dbTable = await this.dbManager.dbTableExist(tableName);
                 if (dbTable === undefined) {
-                    logger.info('table ' + tableName + ' not found');
+                    exports.logger.info('table ' + tableName + ' not found');
                     continue;
                 }
                 const filename = buildFilename(dbTable.name, options);
@@ -181,7 +181,7 @@ class TableImportCmd extends Cmd_1.Cmd {
             }
         }
         catch (err) {
-            logger.error(err);
+            exports.logger.error(err);
         }
     }
     async copyFrom(dbTable, filename) {
@@ -194,11 +194,11 @@ class TableImportCmd extends Cmd_1.Cmd {
             const route = '/admin/import/' + dbTable.name;
             const resp = await this.dbRemote.apiServer.post(route, form);
             if (resp.status === 200) {
-                logger.debug(filename + ' uploaded');
+                exports.logger.debug(filename + ' uploaded');
             }
         }
         catch (err) {
-            logger.error(err);
+            exports.logger.error(err);
         }
     }
 }
@@ -226,7 +226,7 @@ function buildFilename(tableName, options) {
     return filename;
 }
 const commandImportExport = async (dbManager, direction, tables, options) => {
-    logger.debug('tables : ', tables, 'options : ', options);
+    exports.logger.debug('tables : ', tables, 'options : ', options);
     try {
         if (options.file === undefined && options.dir === undefined)
             throw '--file or --dir mandatory';
@@ -240,14 +240,14 @@ const commandImportExport = async (dbManager, direction, tables, options) => {
             const tableName = tables[indi];
             const dbTable = await dbManager.dbTableExist(tableName);
             if (dbTable === undefined) {
-                logger.info('table ' + tableName + ' not found');
+                exports.logger.info('table ' + tableName + ' not found');
                 continue;
             }
             psqlCmd(dbTable, direction, options);
         }
     }
     catch (err) {
-        logger.error(err);
+        exports.logger.error(err);
     }
 };
 //--------------------------------------------------------------------------------------------------------------------
@@ -282,7 +282,7 @@ function psqlCmd(dbTable, direction, options) {
     else if (fs.existsSync(options.dir) === false)
         throw 'directory ' + options.dir + ' does not exist';
     else if (fs.lstatSync(options.dir).isFile()) {
-        logger.debug("--dir " + options.dir + " is a file ");
+        exports.logger.debug("--dir " + options.dir + " is a file ");
     }
     else {
         let directory = options.dir.trim();
@@ -293,7 +293,7 @@ function psqlCmd(dbTable, direction, options) {
     }
     let copy_cmd = "\\copy " + dbTable.name + lcols + direction + " '" + filename + "' csv header";
     const shell_cmd = psql_cmd + '"' + copy_cmd + '"';
-    logger.debug(shell_cmd);
+    exports.logger.debug(shell_cmd);
     const child = (0, child_process_1.spawn)(shell_cmd.trim(), { stdio: 'inherit', shell: true });
 }
 //--------------------------------------------------------------------------------------------------------------------
@@ -316,57 +316,43 @@ class TableList extends Cmd_1.Cmd {
         dbClient.selectFromTable('List of Tables', 'cyk_table', { fields: 'table_id,table_name,table_auth,table_access,table_description', sort: options.sort || '1' });
     }
 }
-//--------------------------------------------------------------------------------------------------------------------
-// class TableData
-//--------------------------------------------------------------------------------------------------------------------
-class TableData extends Cmd_1.Cmd {
+class TableDropCommand extends Cmd_1.Cmd {
     constructor(name, description) {
         super(name);
         this.description(description)
             .argument('<table>', 'table name')
-            .option('--where <clause_where_sql>', 'criteria in SQL syntax')
-            .option('-s --sort <columns>', 'sort by columns positions (begins by 0) separated by comma')
-            .option('-w --width <colwidth>', 'columns widths separated by comma')
             .action(async (table, options) => {
-            this.commandData(table, options);
+            await this.commandDrop(table, options);
         });
     }
-    async commandData(table, options) {
+    async commandDrop(table, options) {
         try {
             await this.prologue(options);
-            if (this.dbManager === undefined)
+            if (!this.dbManager)
                 throw 'dbManager undefined';
             const dbTable = await this.dbManager.dbTableExist(table);
-            if (dbTable === undefined)
-                throw 'table ' + table + ' not found';
-            let fields = '';
-            for (let ind = 0; ind < dbTable.columns.length; ind++) {
-                const dbColumn = dbTable.columns[ind];
-                let ok = false;
-                let fieldName = dbColumn.name;
-                if (dbColumn.dbType === 'text' || dbColumn.dbType === 'bytea') {
-                    ok = false;
-                    fieldName = 'length(' + dbColumn.name + ')';
-                }
-                else {
-                    ok = true;
-                }
-                if (ok === true) {
-                    if (fields !== '')
-                        fields += ',';
-                    fields += fieldName;
-                }
+            if (!dbTable) {
+                console.log('table ' + table + ' does not exist');
+                return;
             }
-            logger.debug('commandQuery', table);
-            const dbClient = new DBClient_1.DBClient(this.dbManager);
-            let title = 'Table ' + table;
-            if (options.where !== undefined) {
-                title += ' where ' + options.where;
+            const reply = await inquirer_1.default.prompt({ type: 'confirm', name: 'confirm', message: 'Drop table ' + table + '?' });
+            if (reply.confirm && this.dbManager) {
+                await dropTable(table, this.dbManager);
             }
-            dbClient.selectFromTable(title, table, { fields: fields, width: options.width, sort: options.sort || '1', where: options.where });
         }
         catch (err) {
-            logger.error(err);
+            exports.logger.error(err);
         }
     }
 }
+/**
+ * function dropTable
+ * @param table
+ * @param dbManager
+ */
+async function dropTable(table, dbManager) {
+    const dbTable = await dbManager.dbTableExist(table);
+    if (dbTable)
+        await dbManager.dbTableDelete(dbTable);
+}
+exports.dropTable = dropTable;

package/build/TableData.d.ts

@@ -0,0 +1,5 @@
+import { Cmd } from "./Cmd";
+export declare class TableDataCommand extends Cmd {
+    constructor(name: string, description: string);
+    commandData(table: string, options: any): Promise<void>;
+}

package/build/TableData.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableDataCommand = void 0;
+const Cmd_1 = require("./Cmd");
+const DBClient_1 = require("./DBClient");
+const TableCommand_1 = require("./TableCommand");
+//--------------------------------------------------------------------------------------------------------------------
+// class TableData
+//--------------------------------------------------------------------------------------------------------------------
+class TableDataCommand extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .argument('<table>', 'table name')
+            .option('--where <clause_where_sql>', 'criteria in SQL syntax')
+            .option('-s --sort <columns>', 'sort by columns positions (begins by 0) separated by comma')
+            .option('-w --width <colwidth>', 'columns widths separated by comma')
+            .action(async (table, options) => {
+            this.commandData(table, options);
+        });
+    }
+    async commandData(table, options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            const dbTable = await this.dbManager.dbTableExist(table);
+            if (dbTable === undefined)
+                throw 'table ' + table + ' not found';
+            let fields = '';
+            for (let ind = 0; ind < dbTable.columns.length; ind++) {
+                const dbColumn = dbTable.columns[ind];
+                let ok = false;
+                let fieldName = dbColumn.name;
+                if (dbColumn.dbType === 'text' || dbColumn.dbType === 'bytea') {
+                    ok = false;
+                    fieldName = 'length(' + dbColumn.name + ')';
+                }
+                else {
+                    ok = true;
+                }
+                if (ok === true) {
+                    if (fields !== '')
+                        fields += ',';
+                    fields += fieldName;
+                }
+            }
+            TableCommand_1.logger.debug('commandQuery', table);
+            const dbClient = new DBClient_1.DBClient(this.dbManager);
+            let title = 'Table ' + table;
+            if (options.where !== undefined) {
+                title += ' where ' + options.where;
+            }
+            dbClient.selectFromTable(title, table, { fields: fields, width: options.width, sort: options.sort || '1', where: options.where });
+        }
+        catch (err) {
+            TableCommand_1.logger.error(err);
+        }
+    }
+}
+exports.TableDataCommand = TableDataCommand;

package/build/TableDataCommand.d.ts

@@ -0,0 +1,5 @@
+import { Cmd } from "./Cmd";
+export declare class TableDataCommand extends Cmd {
+    constructor(name: string, description: string);
+    commandData(table: string, options: any): Promise<void>;
+}

package/build/TableDataCommand.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableDataCommand = void 0;
+const Cmd_1 = require("./Cmd");
+const DBClient_1 = require("./DBClient");
+const TableCommand_1 = require("./TableCommand");
+//--------------------------------------------------------------------------------------------------------------------
+// class TableData
+//--------------------------------------------------------------------------------------------------------------------
+class TableDataCommand extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .argument('<table>', 'table name')
+            .option('--where <clause_where_sql>', 'criteria in SQL syntax')
+            .option('-s --sort <columns>', 'sort by columns positions (begins by 0) separated by comma')
+            .option('-w --width <colwidth>', 'columns widths separated by comma')
+            .action(async (table, options) => {
+            this.commandData(table, options);
+        });
+    }
+    async commandData(table, options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            const dbTable = await this.dbManager.dbTableExist(table);
+            if (dbTable === undefined)
+                throw 'table ' + table + ' not found';
+            let fields = '';
+            for (let ind = 0; ind < dbTable.columns.length; ind++) {
+                const dbColumn = dbTable.columns[ind];
+                let ok = false;
+                let fieldName = dbColumn.name;
+                if (dbColumn.dbType === 'text' || dbColumn.dbType === 'bytea') {
+                    ok = false;
+                    fieldName = 'length(' + dbColumn.name + ')';
+                }
+                else {
+                    ok = true;
+                }
+                if (ok === true) {
+                    if (fields !== '')
+                        fields += ',';
+                    fields += fieldName;
+                }
+            }
+            TableCommand_1.logger.debug('commandQuery', table);
+            const dbClient = new DBClient_1.DBClient(this.dbManager);
+            let title = 'Table ' + table;
+            if (options.where !== undefined) {
+                title += ' where ' + options.where;
+            }
+            dbClient.selectFromTable(title, table, { fields: fields, width: options.width, sort: options.sort || '1', where: options.where });
+        }
+        catch (err) {
+            TableCommand_1.logger.error(err);
+        }
+    }
+}
+exports.TableDataCommand = TableDataCommand;

package/build/UninstallCommand.d.ts

@@ -1,5 +1,5 @@
 import { Cmd } from "./Cmd";
-import { DBManager } from "@cyklang/core";
+import { DBManager, DBRemote } from "@cyklang/core";
 export declare class UninstallCommand extends Cmd {
     /**
      * constructor
@@ -17,4 +17,4 @@ export declare class UninstallCommand extends Cmd {
  * function uninstallPackage
  * @param node_package
  */
-export declare function uninstallPackage(node_package: string, dbManager: DBManager): Promise<void>;
+export declare function uninstallPackage(node_package: string, dbManager: DBManager, dbRemote: DBRemote): Promise<void>;

package/build/UninstallCommand.js

@@ -56,9 +56,9 @@ class UninstallCommand extends Cmd_1.Cmd {
     async uninstall(node_package, options) {
         try {
             await this.prologue(options);
-            if (this.dbManager === undefined)
-                throw 'dbManager undefined';
-            await uninstallPackage(node_package, this.dbManager);
+            if (!this.dbManager || !this.dbRemote)
+                throw 'dbManager or dbRemote undefined';
+            await uninstallPackage(node_package, this.dbManager, this.dbRemote);
         }
         catch (err) {
             logger.error(err);
@@ -70,7 +70,7 @@ exports.UninstallCommand = UninstallCommand;
  * function uninstallPackage
  * @param node_package
  */
-async function uninstallPackage(node_package, dbManager) {
+async function uninstallPackage(node_package, dbManager, dbRemote) {
     const uninstallScript = await lookupUninstallScript(node_package);
     if (uninstallScript) {
         /**
@@ -83,7 +83,7 @@ async function uninstallPackage(node_package, dbManager) {
         /**
          * default uninstall :
          */
-        await defaultUninstallScript(node_package, dbManager);
+        await defaultUninstallScript(node_package, dbManager, dbRemote);
     }
     /**
      * uninstall the node package
@@ -95,13 +95,60 @@ exports.uninstallPackage = uninstallPackage;
  * method defaultUninstallScript
  * @param node_package
  */
-async function defaultUninstallScript(node_package, dbManager) {
+async function defaultUninstallScript(node_package, dbManager, dbRemote) {
     console.log();
     console.log('Default uninstall script');
     /**
      * delete package modules from server
      */
     await deletePackageModules(node_package, dbManager);
+    /**
+     * delete package assets from server
+     */
+    await deletePackageAssets(node_package, dbManager, dbRemote);
+}
+/**
+ * function deletePackageAssets
+ * @param node_package
+ * @param dbManager
+ * @param dbRemote
+ */
+async function deletePackageAssets(node_package, dbManager, dbRemote) {
+    const assetFolder = path.join('node_modules', node_package, 'asset');
+    if (!fs.existsSync(assetFolder) || !fs.statSync(assetFolder).isDirectory()) {
+        return;
+    }
+    console.log();
+    console.log('delete assets from server ...');
+    await browseFolder(assetFolder, async (filePath) => {
+        const route = '/' + path.relative(assetFolder, filePath);
+        const dbAsset = await dbManager.dbAssetExist(route);
+        if (!dbAsset) {
+            logger.info('asset ' + route + ' not found');
+            return;
+        }
+        await dbManager.dbAssetDelete(dbAsset);
+        logger.info('asset ' + route + ' deleted');
+    });
+    console.log((0, kolorist_1.green)('*') + ' delete assets from server');
+}
+/**
+ * browseFolder
+ * @param folder
+ * @param treatment
+ */
+async function browseFolder(folder, treatment) {
+    const files = fs.readdirSync(folder);
+    for (let ind = 0; ind < files.length; ind++) {
+        const file = files[ind];
+        const pathName = folder + '/' + file;
+        if (fs.statSync(pathName).isDirectory()) {
+            await browseFolder(pathName, treatment);
+        }
+        else {
+            await treatment(pathName);
+        }
+    }
 }
 /**
  * function deletePackageModules

package/build/index.js

@@ -16,11 +16,12 @@ const InstallCommand_1 = require("./InstallCommand");
 const AssetCommand_1 = require("./AssetCommand");
 const OpenCommand_1 = require("./OpenCommand");
 const UninstallCommand_1 = require("./UninstallCommand");
+const TableDataCommand_1 = require("./TableDataCommand");
 const logger = loglevel_1.default.getLogger("index.ts");
 logger.setLevel("debug");
 const program = new commander_1.Command();
 program.name('cyk').description('cyklang CLI')
-    .version('0.5.5');
+    .version('0.6.0');
 program.addCommand(new InstallCommand_1.InstallCommand('install'));
 program.addCommand(new InstallCommand_1.InstallCommand('i'));
 program.addCommand(new UninstallCommand_1.UninstallCommand('uninstall'));
@@ -34,6 +35,8 @@ program.addCommand(new QueryCommand_1.QueryCommand('query'));
 program.addCommand(new QueryCommand_1.QueryCommand('q'));
 program.addCommand(new TableCommand_1.TableCommand('table'));
 program.addCommand(new TableCommand_1.TableCommand('t'));
+program.addCommand(new TableDataCommand_1.TableDataCommand('data', 'show table data'));
+program.addCommand(new TableDataCommand_1.TableDataCommand('d', 'show table data'));
 program.addCommand(new TestCommand_1.TestCommand());
 program.addCommand(new RunCommand_1.RunCommand('run'));
 program.addCommand(new RunCommand_1.RunCommand('r'));

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@cyklang/cli",
-   "version": "0.5.5",
+   "version": "0.6.0",
    "description": "cyklang CLI",
    "main": "build/index.js",
    "scripts": {
@@ -17,7 +17,7 @@
    "author": "",
    "license": "ISC",
    "dependencies": {
-      "@cyklang/core": "^0.5.3",
+      "@cyklang/core": "^0.5.4",
       "commander": "^9.4.0",
       "dotenv": "^16.0.1",
       "form-data": "^4.0.0",

package/src/AssetCommand.ts

@@ -366,9 +366,9 @@ function buildUploadList(dirName: string, dest: string, localList: FileDescripto
         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)
+            // 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)
         }
     }
@@ -426,7 +426,7 @@ async function uploadFiles(dirName: string, uploadList: FileDescriptor[], 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)
+        // logger.debug('upload ' + upload.path + ' to ' + route)
         await uploadAsset(upload, route, dbManager, dbRemote, auth)
     }
 }
@@ -463,7 +463,7 @@ export async function uploadAsset(upload: FileDescriptor, route: string, dbManag
 
         if (dbAsset.id === undefined) {
             dbAsset.id = await dbManager?.dbAssetInsert(dbAsset)
-            logger.info('inserted asset ' + dbAsset.id + ' route ' + dbAsset.route)
+            logger.info('inserted asset ' + dbAsset.route)
         }
         else {
             await dbManager?.dbAssetUpdate(dbAsset)
@@ -500,7 +500,7 @@ function mimetypeLookup(filename: string): string | false {
  * @param dbRemote 
  */
 async function uploadAssetContent(dbAsset: DBAsset, fileName: string, dbRemote: DBRemote | undefined) {
-    logger.debug('uploadAssetContent file ' + fileName + ' to path ' + path)
+    // logger.debug('uploadAssetContent file ' + fileName + ' to path ' + path)
     try {
         const file = fs.createReadStream(fileName)
         const form = new FormData()

package/src/InstallCommand.ts

@@ -48,7 +48,7 @@ export async function installPackage(node_package: string, dbManager: DBManager,
     /**
      * install the Node Package
      */
-    await installNodePackage(node_package, dbManager)
+    await installNodePackage(node_package, dbManager, dbRemote)
 
     const installScript = await lookupInstallScript(node_package)
 
@@ -100,7 +100,6 @@ async function uploadPackageAssets(node_package: string, dbManager: DBManager, d
     console.log()
     console.log('upload assets to server ...')
     
-    if (!dbManager) throw 'dbManager undefined'
     const items = fs.readdirSync(assetFolder)
     for (let ind = 0; ind < items.length; ind++) {
         const item = items[ind]
@@ -153,7 +152,7 @@ async function uploadPackageModules(node_package: string, dbManager: DBManager)
  * method installNodePackage
  * @param node_package 
  */
-async function installNodePackage(node_package: string, dbManager: DBManager) {
+async function installNodePackage(node_package: string, dbManager: DBManager, dbRemote: DBRemote) {
 
     try {
         const packageJson = await readPackageJson()
@@ -161,7 +160,7 @@ async function installNodePackage(node_package: string, dbManager: DBManager) {
             || packageJson.dependencies && packageJson.dependencies[node_package]) {
             console.log(node_package + ' already installed. We uninstall it first')
             if (!dbManager) throw 'dbManager undefined'
-            await uninstallPackage(node_package, dbManager)
+            await uninstallPackage(node_package, dbManager, dbRemote)
         }
 
         await runShellCommand('npm', ['install', '--save-dev', node_package])

package/src/TableCommand.ts

@@ -8,8 +8,10 @@ import { Cmd } from "./Cmd"
 import { DBClient } from "./DBClient"
 import { Stream } from "form-data"
 import FormData from 'form-data'
+import inquirer from 'inquirer'
+import { TableDataCommand } from "./TableDataCommand"
 
-const logger = loglevel.getLogger("TableCommand.ts")
+export const logger = loglevel.getLogger("TableCommand.ts")
 logger.setLevel("debug")
 
 export class TableCommand extends Command {
@@ -20,8 +22,7 @@ export class TableCommand extends Command {
         this.addCommand(new TableImportCmd())
         this.addCommand(new TableList('list', 'list database tables'))
         this.addCommand(new TableList('l', '(l)ist database tables'))
-        this.addCommand(new TableData('data', 'table (d)ata'))
-        this.addCommand(new TableData('d', 'table (d)ata'))
+        this.addCommand(new TableDropCommand('drop', 'drop table'))
         this.addCommand(new TableUpdate('update', 'update table properties'))
         this.addCommand(new TableUpdate('u', 'shortcut for (u)pdate table properties'))
     }
@@ -40,12 +41,12 @@ class TableUpdate extends Cmd {
     constructor(name: string, description: string) {
         super(name)
         this.description(description)
-        .option('-n --name <table_name>', 'name of the table whose properties are to be changed')
-        .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
-        .option('--access <access>', 'access rights required')
-        .action(async (options: any) => {
-            await this.commandUpdate(options)
-        })
+            .option('-n --name <table_name>', 'name of the table whose properties are to be changed')
+            .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
+            .option('--access <access>', 'access rights required')
+            .action(async (options: any) => {
+                await this.commandUpdate(options)
+            })
     }
 
     async commandUpdate(options: any) {
@@ -53,10 +54,10 @@ class TableUpdate extends Cmd {
             await this.prologue(options)
             if (this.dbManager === undefined) throw 'dbManager undefined'
 
-            if ( ! options.name ) throw '<table_name> is missing'
+            if (!options.name) throw '<table_name> is missing'
 
             const dbTable = await this.dbManager.dbTableExist(options.name)
-            if ( ! dbTable ) throw 'Table ' + options.name + ' not found'
+            if (!dbTable) throw 'Table ' + options.name + ' not found'
 
             await this.updateAuthAccess('cyk_table', 'table', dbTable.id || '', options)
         }
@@ -319,63 +320,46 @@ class TableList extends Cmd {
     }
 }
 
-//--------------------------------------------------------------------------------------------------------------------
-// class TableData
-//--------------------------------------------------------------------------------------------------------------------
-
-class TableData extends Cmd {
-
+class TableDropCommand extends Cmd {
     constructor(name: string, description: string) {
         super(name)
         this.description(description)
             .argument('<table>', 'table name')
-            .option('--where <clause_where_sql>', 'criteria in SQL syntax')
-            .option('-s --sort <columns>', 'sort by columns positions (begins by 0) separated by comma')
-            .option('-w --width <colwidth>', 'columns widths separated by comma')
             .action(async (table, options) => {
-                this.commandData(table, options)
+                await this.commandDrop(table, options)
             })
     }
 
-    async commandData(table: string, options: any) {
+    async commandDrop(table: string, options: any) {
         try {
             await this.prologue(options)
-            if (this.dbManager === undefined) throw 'dbManager undefined'
-
+            if (!this.dbManager) throw 'dbManager undefined'
+            
             const dbTable = await this.dbManager.dbTableExist(table)
-            if (dbTable === undefined) throw 'table ' + table + ' not found'
-
-            let fields = ''
-
-            for (let ind = 0; ind < dbTable.columns.length; ind++) {
-                const dbColumn = dbTable.columns[ind]
-                let ok = false
-                let fieldName = dbColumn.name
-                if (dbColumn.dbType === 'text' || dbColumn.dbType === 'bytea') {
-                    ok = false
-                    fieldName = 'length(' + dbColumn.name + ')'
-                }
-                else {
-                    ok = true
-                }
-                if (ok === true) {
-                    if (fields !== '') fields += ','
-                    fields += fieldName
-                }
+            if (!dbTable) {
+                console.log('table ' + table + ' does not exist')
+                return
             }
-
-            logger.debug('commandQuery', table)
-            const dbClient = new DBClient(this.dbManager)
-            let title = 'Table ' + table
-            if (options.where !== undefined) {
-                title += ' where ' + options.where
+            const reply = await inquirer.prompt({ type: 'confirm', name: 'confirm', message: 'Drop table ' + table + '?' })
+            if (reply.confirm && this.dbManager) {
+                await dropTable(table, this.dbManager)
             }
-            dbClient.selectFromTable(title, table,
-                { fields: fields, width: options.width, sort: options.sort || '1', where: options.where })
         }
-        catch (err) {
+        catch(err) {
             logger.error(err)
         }
     }
 }
 
+/**
+ * function dropTable
+ * @param table 
+ * @param dbManager 
+ */
+export async function dropTable(table: string, dbManager: DBManager) {
+    const dbTable = await dbManager.dbTableExist(table)
+    if (dbTable)
+        await dbManager.dbTableDelete(dbTable)
+}
+
+

package/src/TableDataCommand.ts

@@ -0,0 +1,62 @@
+import { Cmd } from "./Cmd";
+import { DBClient } from "./DBClient";
+import { logger } from "./TableCommand";
+
+//--------------------------------------------------------------------------------------------------------------------
+// class TableData
+//--------------------------------------------------------------------------------------------------------------------
+export class TableDataCommand extends Cmd {
+
+    constructor(name: string, description: string) {
+        super(name);
+        this.description(description)
+            .argument('<table>', 'table name')
+            .option('--where <clause_where_sql>', 'criteria in SQL syntax')
+            .option('-s --sort <columns>', 'sort by columns positions (begins by 0) separated by comma')
+            .option('-w --width <colwidth>', 'columns widths separated by comma')
+            .action(async (table, options) => {
+                this.commandData(table, options);
+            });
+    }
+
+    async commandData(table: string, options: any) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined) throw 'dbManager undefined';
+
+            const dbTable = await this.dbManager.dbTableExist(table);
+            if (dbTable === undefined) throw 'table ' + table + ' not found';
+
+            let fields = '';
+
+            for (let ind = 0; ind < dbTable.columns.length; ind++) {
+                const dbColumn = dbTable.columns[ind];
+                let ok = false;
+                let fieldName = dbColumn.name;
+                if (dbColumn.dbType === 'text' || dbColumn.dbType === 'bytea') {
+                    ok = false;
+                    fieldName = 'length(' + dbColumn.name + ')';
+                }
+                else {
+                    ok = true;
+                }
+                if (ok === true) {
+                    if (fields !== '') fields += ',';
+                    fields += fieldName;
+                }
+            }
+
+            logger.debug('commandQuery', table);
+            const dbClient = new DBClient(this.dbManager);
+            let title = 'Table ' + table;
+            if (options.where !== undefined) {
+                title += ' where ' + options.where;
+            }
+            dbClient.selectFromTable(title, table,
+                { fields: fields, width: options.width, sort: options.sort || '1', where: options.where });
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}

package/src/UninstallCommand.ts

@@ -5,7 +5,7 @@ import { green, red, bold } from 'kolorist'
 
 import loglevel from 'loglevel'
 import { deleteModule } from "./ModuleCommand";
-import { DBManager } from "@cyklang/core";
+import { DBManager, DBRemote } from "@cyklang/core";
 const logger = loglevel.getLogger('UninstallCommand.ts')
 logger.setLevel('debug')
 
@@ -31,9 +31,9 @@ export class UninstallCommand extends Cmd {
     async uninstall(node_package: string, options: any) {
         try {
             await this.prologue(options)
-            if (this.dbManager === undefined) throw 'dbManager undefined'
+            if (! this.dbManager || ! this.dbRemote) throw 'dbManager or dbRemote undefined'
 
-            await uninstallPackage(node_package, this.dbManager)
+            await uninstallPackage(node_package, this.dbManager, this.dbRemote)
         }
         catch (err) {
             logger.error(err)
@@ -45,7 +45,7 @@ export class UninstallCommand extends Cmd {
  * function uninstallPackage
  * @param node_package 
  */
-export async function uninstallPackage(node_package: string, dbManager: DBManager) {
+export async function uninstallPackage(node_package: string, dbManager: DBManager, dbRemote: DBRemote) {
 
     const uninstallScript = await lookupUninstallScript(node_package)
     if (uninstallScript) {
@@ -59,7 +59,7 @@ export async function uninstallPackage(node_package: string, dbManager: DBManage
         /**
          * default uninstall : 
          */
-        await defaultUninstallScript(node_package, dbManager)
+        await defaultUninstallScript(node_package, dbManager, dbRemote)
     }
 
     /**
@@ -72,14 +72,65 @@ export async function uninstallPackage(node_package: string, dbManager: DBManage
  * method defaultUninstallScript
  * @param node_package 
  */
-async function defaultUninstallScript(node_package: string, dbManager: DBManager) {
+async function defaultUninstallScript(node_package: string, dbManager: DBManager, dbRemote: DBRemote) {
     console.log()
     console.log('Default uninstall script')
     /**
      * delete package modules from server
      */
     await deletePackageModules(node_package, dbManager)
+    /**
+     * delete package assets from server
+     */
+    await deletePackageAssets(node_package, dbManager, dbRemote)
+
+}
+
+/**
+ * function deletePackageAssets
+ * @param node_package 
+ * @param dbManager 
+ * @param dbRemote 
+ */
+async function deletePackageAssets(node_package: string, dbManager: DBManager, dbRemote: DBRemote) {
+    const assetFolder = path.join('node_modules', node_package, 'asset')
+    if (!fs.existsSync(assetFolder) || !fs.statSync(assetFolder).isDirectory()) {
+        return
+    }
+    console.log()
+    console.log('delete assets from server ...')
+
+    await browseFolder(assetFolder, async (filePath: string) => {
+        const route = '/' + path.relative(assetFolder, filePath)
+        const dbAsset = await dbManager.dbAssetExist(route)
+        if (!dbAsset) {
+            logger.info('asset ' + route + ' not found')
+            return
+        }
+        await dbManager.dbAssetDelete(dbAsset)
+        logger.info('asset ' + route + ' deleted')
+    })
 
+    console.log(green('*') + ' delete assets from server')
+}
+
+/**
+ * browseFolder
+ * @param folder 
+ * @param treatment 
+ */
+async function browseFolder(folder: string, treatment: (filePath: string) => Promise<void>) {
+    const files = fs.readdirSync(folder)
+    for(let ind = 0; ind < files.length; ind++) {
+        const file = files[ind]
+        const pathName = folder + '/' + file
+        if (fs.statSync(pathName).isDirectory()) {
+            await browseFolder(pathName, treatment)
+        }
+        else {
+            await treatment(pathName)
+        }
+    }
 }
 
 /**

package/src/index.ts

@@ -11,12 +11,13 @@ import { InstallCommand } from './InstallCommand'
 import { AssetCommand } from './AssetCommand'
 import { OpenCommand } from './OpenCommand'
 import { UninstallCommand } from './UninstallCommand'
+import { TableDataCommand } from './TableDataCommand'
 const logger = loglevel.getLogger("index.ts")
 logger.setLevel("debug")
 
 const program = new Command()
 program.name('cyk').description('cyklang CLI')
-    .version('0.5.5')
+    .version('0.6.0')
 
 program.addCommand(new InstallCommand('install'))
 program.addCommand(new InstallCommand('i'))
@@ -31,6 +32,8 @@ program.addCommand(new QueryCommand('query'))
 program.addCommand(new QueryCommand('q'))
 program.addCommand(new TableCommand('table'))
 program.addCommand(new TableCommand('t'))
+program.addCommand(new TableDataCommand('data', 'show table data'))
+program.addCommand(new TableDataCommand('d', 'show table data'))
 program.addCommand(new TestCommand())
 program.addCommand(new RunCommand('run'))
 program.addCommand(new RunCommand('r'))