@cyklang/cli 0.2.1 → 0.2.3

package/build/AssetCommand.js

@@ -30,7 +30,8 @@ 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 inquirer_1 = __importDefault(require("inquirer"));
+// import readline from 'readline'
 const core_1 = require("@cyklang/core");
 const form_data_1 = __importDefault(require("form-data"));
 const logger = (0, loglevel_1.getLogger)('AssetCommand.ts');
@@ -75,11 +76,22 @@ class AssetUpload extends Cmd_1.Cmd {
         this.ignorePatterns = ['.git', 'node_modules'];
         this.description(description)
             .option('-d --dest <destination>', 'route of destination')
+            .option('-y --yes', 'upload list is automatically confirmed')
             .argument('[sources...]', 'local files or directories to upload as assets to the server')
             .action(async (sources, options) => {
             await this.commandUpload(sources, options);
         });
     }
+    mimetypeLookup(filename) {
+        let result;
+        if (path_1.default.extname(filename) === '.cyk') {
+            result = 'application/xml';
+        }
+        else {
+            result = mime_types_1.default.lookup(filename);
+        }
+        return result;
+    }
     async commandUpload(sources, options) {
         try {
             await this.prologue(options);
@@ -100,7 +112,7 @@ class AssetUpload extends Cmd_1.Cmd {
                     throw 'source ' + source + ' does not exist';
                 const filestat = fs.lstatSync(source);
                 if (filestat.isDirectory() === true) {
-                    await this.uploadDirectory(source, dest);
+                    await this.uploadDirectory(source, dest, options);
                 }
                 else if (filestat.isFile() === true) {
                     const base = path_1.default.parse(source).base;
@@ -116,7 +128,7 @@ class AssetUpload extends Cmd_1.Cmd {
     //----------------------------------------------------------------------------------------------
     // uploadDirectory
     //----------------------------------------------------------------------------------------------
-    async uploadDirectory(source, dest) {
+    async uploadDirectory(source, dest, options) {
         const localList = [];
         let dirName;
         if (source.substring(source.length - 1) === '/') {
@@ -126,7 +138,7 @@ class AssetUpload extends Cmd_1.Cmd {
         else {
             dirName = source + '/';
         }
-        logger.debug('dirName', dirName);
+        logger.debug('options', options);
         this.scanDir(dirName, localList);
         const remoteList = [];
         await this.scanAssets(remoteList);
@@ -134,15 +146,24 @@ class AssetUpload extends Cmd_1.Cmd {
         // 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;
-            }
+        let uploadConfirmed = (options.yes !== undefined);
+        if (uploadConfirmed === false) {
+            const reply = await inquirer_1.default.prompt({ type: 'confirm', name: 'confirm', message: 'Do you want to upload this(these) ' + uploadList.length + ' file(s) ?' });
+            if (reply.confirm === true)
+                uploadConfirmed = true;
+        }
+        if (uploadConfirmed === true) {
             await this.uploadFiles(dirName, uploadList, dest);
-        });
+        }
+        // const rl = readline.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
@@ -208,7 +229,7 @@ class AssetUpload extends Cmd_1.Cmd {
                 this.scanDir(dirName + fileName + '/', result);
             }
             else {
-                if (mime_types_1.default.lookup(fileName) === false) {
+                if (this.mimetypeLookup(fileName) === false) {
                     logger.info(fileName + ' file extension is unknown and will not be uploaded');
                     continue;
                 }
@@ -241,13 +262,13 @@ class AssetUpload extends Cmd_1.Cmd {
     // uploadAsset
     //----------------------------------------------------------------------------------------------
     async uploadAsset(upload, route) {
-        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + mime_types_1.default.lookup(upload.path));
+        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(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);
+            const mimetype = this.mimetypeLookup(upload.path);
             if (mimetype === false)
                 throw 'mimetype false for ' + upload;
             dbAsset.mimetype = mimetype;

package/build/Cmd.js

@@ -17,19 +17,24 @@ class Cmd extends commander_1.Command {
         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();
-        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, this.dbRemote);
-        await this.dbManager.initialize();
+        try {
+            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('Cmd.DBREMOTE_URL ' + process.env.DBREMOTE_URL);
+            const nodeCrypto = new NodeCrypto_1.NodeCrypto();
+            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, this.dbRemote);
+            await this.dbManager.initialize();
+        }
+        catch (err) {
+            logger.error(err);
+        }
     }
 }
 exports.Cmd = Cmd;

package/build/DBClient.d.ts

@@ -8,4 +8,5 @@ export declare class DBClient {
         where?: string | undefined;
         width?: string | undefined;
     }): Promise<void>;
+    deleteModule(dbname: string): Promise<void>;
 }

package/build/DBClient.js

@@ -76,6 +76,18 @@ class DBClient {
             logger.error(err);
         }
     }
+    async deleteModule(dbname) {
+        try {
+            const dbModule = await this.dbManager.dbModuleExist(dbname);
+            if (dbModule === undefined) {
+                throw ('Module ' + dbname + ' not found');
+            }
+            await this.dbManager.dbModuleDelete(dbModule);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
 }
 exports.DBClient = DBClient;
 class List {

package/build/InitCommand.d.ts

@@ -1,7 +1,13 @@
 import { Command } from "commander";
 export declare class InitCommand extends Command {
+    PGPORT: string;
+    USER_NAME: string;
+    USER_PASSWORD: string;
+    USER_EMAIL: string;
+    CYK_PORT: string;
     constructor(name: string);
     commandInit(options: any): Promise<void>;
+    promptParameters(): Promise<void>;
     getRandomInt(min: number, max: number): number;
     generateToken(): string;
     writeEnvFile(): Promise<void>;

package/build/InitCommand.js

@@ -18,16 +18,25 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.InitCommand = void 0;
 const commander_1 = require("commander");
 const fs = __importStar(require("fs"));
+const inquirer_1 = __importDefault(require("inquirer"));
 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.PGPORT = "5432";
+        this.USER_NAME = "cyk";
+        this.USER_PASSWORD = "cyk";
+        this.USER_EMAIL = "my-email@my-domain";
+        this.CYK_PORT = "3000";
         this.description('initialize a folder with files necessary for a cyklang project')
             .action(async (options) => {
             await this.commandInit(options);
@@ -35,6 +44,7 @@ class InitCommand extends commander_1.Command {
     }
     async commandInit(options) {
         try {
+            await this.promptParameters();
             await this.writeEnvFile();
             await this.writeDockerComposeFile();
         }
@@ -42,6 +52,24 @@ class InitCommand extends commander_1.Command {
             logger.error(err);
         }
     }
+    async promptParameters() {
+        const reply = await inquirer_1.default.prompt([
+            { type: "number", name: 'PGPORT', default: this.PGPORT, message: 'Postgresql Port' },
+            { type: 'number', name: 'CYK_PORT', default: this.CYK_PORT, message: 'NodeJS Port' },
+            { type: 'input', name: 'USER_NAME', default: this.USER_NAME, message: 'Admin User Login' },
+            { type: 'input', name: 'USER_PASSWORD', default: this.USER_PASSWORD, message: 'Admin User Password' },
+            { type: 'input', name: 'USER_EMAIL', default: this.USER_EMAIL, message: 'Admin Use Email' },
+            { type: "confirm", name: 'confirm' }
+        ]);
+        // logger.debug(reply)
+        if (reply.confirm === false)
+            throw 'Command cancelled';
+        this.PGPORT = reply.PGPORT;
+        this.CYK_PORT = reply.CYK_PORT;
+        this.USER_NAME = reply.USER_NAME;
+        this.USER_PASSWORD = reply.USER_PASSWORD;
+        this.USER_EMAIL = reply.USER_EMAIL;
+    }
     // developer.mozilla.org Math.random()
     // On renvoie un entier aléatoire entre une valeur min (incluse)
     // et une valeur max (exclue).
@@ -69,7 +97,7 @@ class InitCommand extends commander_1.Command {
         const content = `# PostgreSql connection
 # used by psql command line utility
 PGHOST="localhost"
-PGPORT="4321"
+PGPORT="${this.PGPORT}"
 PGUSER="postgres"
 PGPASSWORD="postgres"
 
@@ -80,9 +108,9 @@ POSTGRES_PASSWORD="postgres"
 
 # admin user
 # created at database initialization
-ADMIN_NAME=cyk
-ADMIN_PASSWORD=cyk
-ADMIN_EMAIL=my-email@my-domain
+ADMIN_NAME=${this.USER_NAME}
+ADMIN_PASSWORD=${this.USER_PASSWORD}
+ADMIN_EMAIL=${this.USER_EMAIL}
 
 # JWT token generation
 # e.g. https://www.allkeysgenerator.com
@@ -99,10 +127,10 @@ LOGIN_APPLI="index"
 
 # credential used by cyk CLI
 
-USER_NAME=cyk
-USER_PASSWORD=cyk
-CYK_PORT="3000"
-DBREMOTE_URL="http://localhost:3000"        
+USER_NAME=${this.USER_NAME}
+USER_PASSWORD=${this.USER_PASSWORD}
+CYK_PORT="${this.CYK_PORT}"
+DBREMOTE_URL="http://localhost:${this.CYK_PORT}"        
 `;
         fs.writeFileSync(envFilename, content);
         logger.debug('created ' + envFilename);

package/build/ModuleCommand.js

@@ -48,7 +48,9 @@ Otherwise, a new module is inserted in the database. To rename a module, use opt
         // list
         this.addCommand(new ModuleList('list', 'List modules'));
         this.addCommand(new ModuleList('l', 'shortcut for (l)ist'));
-        // rename
+        // rename **TODO**
+        // delete
+        this.addCommand(new ModuleDelete('delete', 'delete module from database'));
     }
 }
 exports.ModuleCommand = ModuleCommand;
@@ -217,6 +219,12 @@ class ModuleDelete extends Cmd_1.Cmd {
                 throw 'dbManager undefined';
             if (files.length === 0)
                 throw 'no module to delete';
+            const dbClient = new DBClient_1.DBClient(this.dbManager);
+            for (let ind = 0; ind < files.length; ind++) {
+                const dbname = files.at(ind);
+                if (dbname !== undefined)
+                    dbClient.deleteModule(dbname);
+            }
         }
         catch (err) {
             logger.error(err);

package/build/TestCommand.js

@@ -46,7 +46,7 @@ class TestCommand extends Cmd_1.Cmd {
             for (let ind = 0; ind < files.length; ind++) {
                 const result = await testfile(files[ind]);
                 if (result === false) {
-                    logger.debug('*********** FAILURE ' + process.argv[ind] + ' ***************');
+                    logger.debug('*********** FAILURE ' + files[ind] + ' ***************');
                 }
             }
         }

package/docker.env

@@ -33,6 +33,6 @@ LOGIN_APPLI="accounting"
 
 USER_NAME=cyk
 USER_PASSWORD=cyk
-CYK_PORT="3000"
-DBREMOTE_URL="http://localhost:3000"
+CYK_PORT="3100"
+DBREMOTE_URL="http://localhost:3100"
 

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@cyklang/cli",
-   "version": "0.2.1",
+   "version": "0.2.3",
    "description": "cyklang CLI",
    "main": "build/index.js",
    "scripts": {
@@ -17,16 +17,18 @@
    "author": "",
    "license": "ISC",
    "dependencies": {
-      "@cyklang/core": "^0.3.6",
+      "@cyklang/core": "^0.4.2",
       "commander": "^9.4.0",
       "dotenv": "^16.0.1",
       "form-data": "^4.0.0",
+      "inquirer": "^8.2.5",
       "loglevel": "^1.8.0",
       "mime-types": "^2.1.35",
       "pako": "^2.0.4",
       "xml": "^1.0.1"
    },
    "devDependencies": {
+      "@types/inquirer": "^8.2.4",
       "@types/mime-types": "^2.1.1",
       "@types/pako": "^2.0.0",
       "@types/sax": "^1.2.4",

package/src/AssetCommand.ts

@@ -5,7 +5,8 @@ import { DBClient } from "./DBClient"
 import * as fs from "fs"
 import path from "path"
 import mime from 'mime-types'
-import readline from 'readline'
+import inquirer from 'inquirer'
+// import readline from 'readline'
 import { DBAsset, DBExecuteRequest, ObjectData, parseXML, PrimitiveData } from "@cyklang/core"
 import FormData from 'form-data'
 
@@ -60,12 +61,24 @@ class AssetUpload extends Cmd {
         super(name)
         this.description(description)
             .option('-d --dest <destination>', 'route of destination')
+            .option('-y --yes', 'upload list is automatically confirmed')
             .argument('[sources...]', 'local files or directories to upload as assets to the server')
             .action(async (sources: any, options: any) => {
                 await this.commandUpload(sources, options)
             })
     }
 
+    mimetypeLookup(filename: string): string | false {
+        let result: string | false
+        if (path.extname(filename) === '.cyk') {
+            result = 'application/xml'
+        }
+        else {
+            result = mime.lookup(filename)
+        }
+        return result
+    }
+
     async commandUpload(sources: string[], options: any) {
 
         try {
@@ -84,12 +97,12 @@ class AssetUpload extends Cmd {
                 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)
+                    await this.uploadDirectory(source, dest, options)
                 }
                 else if (filestat.isFile() === true) {
                     const base = path.parse(source).base
                     logger.debug('upload file ' + source + ' to ' + dest + base)
-                    await this.uploadAsset({path:source, mtime: filestat.mtime}, dest + base)
+                    await this.uploadAsset({ path: source, mtime: filestat.mtime }, dest + base)
                 }
             }
         }
@@ -102,7 +115,7 @@ class AssetUpload extends Cmd {
     // uploadDirectory
     //----------------------------------------------------------------------------------------------
 
-    async uploadDirectory(source: string, dest: string) {
+    async uploadDirectory(source: string, dest: string, options: any) {
 
         const localList: FileDescriptor[] = []
         let dirName: string
@@ -114,7 +127,7 @@ class AssetUpload extends Cmd {
             dirName = source + '/'
         }
 
-        logger.debug('dirName', dirName)
+        logger.debug('options', options)
 
         this.scanDir(dirName, localList)
 
@@ -126,16 +139,27 @@ class AssetUpload extends Cmd {
         // logger.info(fileNames.join('\n'))
         if (uploadList.length === 0) throw 'None file to upload'
 
-        const rl = readline.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
-            }
+        let uploadConfirmed = (options.yes !== undefined)
 
+        if (uploadConfirmed === false) {
+            const reply = await inquirer.prompt({ type: 'confirm', name: 'confirm', message: 'Do you want to upload this(these) ' + uploadList.length + ' file(s) ?' })
+            if (reply.confirm === true) uploadConfirmed = true
+        }
+
+        if (uploadConfirmed === true) {
             await this.uploadFiles(dirName, uploadList, dest)
-        })
+        }
+
+        // const rl = readline.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)
+        // })
     }
 
     //----------------------------------------------------------------------------------------------
@@ -145,26 +169,26 @@ class AssetUpload extends Cmd {
     buildUploadList(dirName: string, dest: string, localList: FileDescriptor[], remoteList: FileDescriptor[]): FileDescriptor[] {
         const result: FileDescriptor[] = []
         const remoteMap = new Map<string, FileDescriptor>()
-        for(let ind = 0; ind < remoteList.length; ind++) {
+        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++ ) {
+        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())
+                else logger.debug('remoteDesc.mtime ' + remoteDesc.mtime.getTime(), 'localDesc.mtime ' + localDesc.mtime.getTime())
                 logger.info(localDesc.path)
                 result.push(localDesc)
             }
         }
         return result
     }
-    
-    
+
+
     //----------------------------------------------------------------------------------------------
     // scanAssets
     //----------------------------------------------------------------------------------------------
@@ -181,13 +205,13 @@ class AssetUpload extends Cmd {
         const tag = parseXML('scanAssets', xmlResult)
         const objResult = await this.dbManager.scope.structure.objectDataType.parseData(tag, this.dbManager.scope) as ObjectData
         const rows = (objResult.variables.getData('cyk_asset') as ObjectData).variables
-        for(let ind = 0; ind < rows.list.length; ind++) {
-            const {variable: row} = rows.list[ind]
+        for (let ind = 0; ind < rows.list.length; ind++) {
+            const { variable: row } = rows.list[ind]
             const record = row.data as ObjectData
             const asset_route = (record.variables.getData('asset_route') as PrimitiveData).value as string
             const asset_last_update = (record.variables.getData('asset_last_update') as PrimitiveData).value as Date
             // logger.debug('asset_route ' + asset_route,'asset_last_update ' + asset_last_update)
-            result.push({path: asset_route, mtime: asset_last_update})
+            result.push({ path: asset_route, mtime: asset_last_update })
         }
     }
 
@@ -205,12 +229,12 @@ class AssetUpload extends Cmd {
                 this.scanDir(dirName + fileName + '/', result)
             }
             else {
-                if (mime.lookup(fileName) === false) {
+                if (this.mimetypeLookup(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})
+                result.push({ path: dirName + fileName, mtime: fstat.mtime })
                 // logger.debug(dirName + '/' + fileName)
             }
         }
@@ -248,14 +272,14 @@ class AssetUpload extends Cmd {
     //----------------------------------------------------------------------------------------------
 
     async uploadAsset(upload: FileDescriptor, route: string) {
-        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + mime.lookup(upload.path))
+        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path))
 
         try {
             let dbAsset: DBAsset | undefined = await this.dbManager?.dbAssetExist(route)
             if (dbAsset === undefined) {
                 dbAsset = new DBAsset()
             }
-            const mimetype = mime.lookup(upload.path)
+            const mimetype = this.mimetypeLookup(upload.path)
             if (mimetype === false) throw 'mimetype false for ' + upload
             dbAsset.mimetype = mimetype
             dbAsset.route = route
@@ -296,7 +320,7 @@ class AssetUpload extends Cmd {
 
             const route = '/upload/cyk_asset/asset_content?asset_id=' + dbAsset.id
             const resp = await this.dbRemote?.apiServer.post(route, form)
-            if ( resp.status === 200 ) {
+            if (resp.status === 200) {
                 logger.info(fileName + ' uploaded')
             }
         }

package/src/Cmd.ts

@@ -17,18 +17,24 @@ export class Cmd extends Command {
  
     async prologue(options: any) {
 
-        const dotenvOutput = dotenv.config({path: options.env})
-        if (dotenvOutput.error !== undefined) throw dotenvOutput.error
+        try {
+            const dotenvOutput = dotenv.config({path: options.env})
+            if (dotenvOutput.error !== undefined) throw dotenvOutput.error
+    
+            const structure = new Structure()
+            if (process.env.DBREMOTE_URL === undefined) throw 'DBREMOTE_URL undefined'
+            logger.debug('Cmd.DBREMOTE_URL ' + process.env.DBREMOTE_URL)
+            const nodeCrypto = new NodeCrypto()
+            this.dbRemote = new 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 DBManager(structure.scope, this.dbRemote)
+            await this.dbManager.initialize()
+        }
+        catch (err) {
+            logger.error(err)
+        }
 
-        const structure = new Structure()
-        if (process.env.DBREMOTE_URL === undefined) throw 'DBREMOTE_URL undefined'
-        logger.debug('DBREMOTE_URL ' + process.env.DBREMOTE_URL)
-        const nodeCrypto = new NodeCrypto()
-        this.dbRemote = new 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 DBManager(structure.scope, this.dbRemote)
-        await this.dbManager.initialize()
     }
 }

package/src/DBClient.ts

@@ -79,6 +79,22 @@ export class DBClient {
             logger.error(err)
         }
     }
+
+    async deleteModule(dbname: string) {
+
+        try {
+            const dbModule = await this.dbManager.dbModuleExist(dbname)
+
+            if (dbModule === undefined) {
+               throw ('Module ' + dbname + ' not found')
+            }
+            await this.dbManager.dbModuleDelete(dbModule)
+        }
+        catch (err) {
+            logger.error(err)
+        }
+
+    }
 }
 
 class List {