@cyklang/cli 0.8.0 → 0.9.0

package/build/CronCommand.d.ts

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

package/build/CronCommand.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronCommand = void 0;
+const commander_1 = require("commander");
+const loglevel_1 = __importDefault(require("loglevel"));
+const Cmd_1 = require("./Cmd");
+const logger = loglevel_1.default.getLogger('CronCommand.ts');
+logger.setLevel('debug');
+class CronCommand extends commander_1.Command {
+    constructor(name) {
+        super(name);
+        this.description('batch scheduling with cron')
+            .addCommand(new CronList('list'))
+            .addCommand(new CronList('l'))
+            .addCommand(new CronAddCmd('add'))
+            .addCommand(new CronAddCmd('a'))
+            .addCommand(new CronDeleteCmd('delete'))
+            .addCommand(new CronDeleteCmd('d'));
+    }
+}
+exports.CronCommand = CronCommand;
+class CronList extends Cmd_1.Cmd {
+    constructor(name) {
+        super(name);
+        this.description('List scheduled batches')
+            .action(async (options) => {
+            await this.commandList(options);
+        });
+    }
+    async commandList(options) {
+        try {
+            await this.prologue(options);
+            const json = await this.dbRemote?.apiServer.get('/api/admin/cron');
+            console.log(json);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+class CronAddCmd extends Cmd_1.Cmd {
+    constructor(name) {
+        super(name);
+        this.description('add a batch scheduling with cron')
+            .option('-s --schedule <schedule>', 'schedule in crontab format')
+            .option('-m --module <module_name>', 'module name')
+            .option('-f --function <function>', 'function called in the module')
+            .option('-p --params <name_value_pairs>', 'URL encoded form without ? (question mark) ie "p1=val1&p2=val2"')
+            .action(async (options) => {
+            await this.commandAdd(options);
+        });
+    }
+    /**
+     *
+     * @param options
+     */
+    async commandAdd(options) {
+        try {
+            await this.prologue(options);
+            if (!this.dbRemote)
+                throw 'dbRemote undefined';
+            const payload = {
+                schedule: options.schedule,
+                module: options.module,
+                function: options.function,
+                params: options.params
+            };
+            const response = await this.dbRemote.apiServer.post('/api/admin/cron', payload);
+            logger.debug(response);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+class CronDeleteCmd extends Cmd_1.Cmd {
+    constructor(name) {
+        super(name);
+        this.description('delete a batch scheduling with cron')
+            .option('-s --schedule <schedule>', 'schedule in crontab format')
+            .option('-m --module <module_name>', 'module name')
+            .option('-f --function <function>', 'function called in the module')
+            .option('-p --params <name_value_pairs>', 'URL encoded form without ? (question mark) ie "p1=val1&p2=val2"')
+            .action(async (options) => {
+            await this.commandDelete(options);
+        });
+    }
+    /**
+     *
+     * @param options
+     */
+    async commandDelete(options) {
+        try {
+            await this.prologue(options);
+            if (!this.dbRemote)
+                throw 'dbRemote undefined';
+            const payload = {
+                schedule: options.schedule,
+                module: options.module,
+                function: options.function,
+                params: options.params
+            };
+            const response = await this.dbRemote.apiServer.delete('/api/admin/cron', payload);
+            logger.debug(response);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}

package/build/QueryCommand.js

@@ -9,6 +9,7 @@ const loglevel_1 = __importDefault(require("loglevel"));
 const Cmd_1 = require("./Cmd");
 const commander_1 = require("commander");
 const DBClient_1 = require("./DBClient");
+const inquirer_1 = __importDefault(require("inquirer"));
 const logger = loglevel_1.default.getLogger("QueryCommand.ts");
 logger.setLevel("debug");
 class QueryCommand extends commander_1.Command {
@@ -17,6 +18,7 @@ class QueryCommand extends commander_1.Command {
         this.description('query management');
         this.addCommand(new QueryList('list', 'list queries'));
         this.addCommand(new QueryList('l', 'list queries'));
+        this.addCommand(new QueryDelete('delete'));
     }
 }
 exports.QueryCommand = QueryCommand;
@@ -40,6 +42,46 @@ class QueryList extends Cmd_1.Cmd {
         dbClient.selectFromTable('List of Queries', 'cyk_query', { fields: 'query_id,query_name,query_auth,query_access,query_description', sort: options.sort || '1' });
     }
 }
+/**
+ * class QueryDelete
+ */
+class QueryDelete extends Cmd_1.Cmd {
+    constructor(name) {
+        super(name);
+        this.description('delete query from cyk_query table')
+            .option('-y --yes', 'confirmation is not required')
+            .argument('<query>', 'query name')
+            .action(async (query, options) => {
+            await this.commandDelete(query, options);
+        });
+    }
+    async commandDelete(query, options) {
+        try {
+            await this.prologue(options);
+            if (!this.dbManager)
+                throw 'dbManager undefined';
+            const dbQuery = await this.dbManager.dbQueryExist(query);
+            if (!dbQuery) {
+                console.log('query ' + query + ' does not exist ');
+                return;
+            }
+            let deleteConfirmed = (options.yes !== undefined);
+            if (deleteConfirmed === false) {
+                const reply = await inquirer_1.default.prompt({ type: 'confirm', name: 'confirm', message: 'Delete query ' + query + '?' });
+                if (reply.confirm) {
+                    deleteConfirmed = true;
+                }
+            }
+            if (deleteConfirmed) {
+                await this.dbManager.dbQueryDelete(dbQuery);
+                console.log('Query ' + query + ' has been deleted');
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
 //--------------------------------------------------------------------------------------------------------------------
 // class queryData
 //--------------------------------------------------------------------------------------------------------------------

package/build/TestCommand.js

@@ -112,7 +112,8 @@ async function testfile(filename) {
             let xmlError = err;
             (0, console_1.errorconsole)(xmlError);
         }
-        console.log(err);
+        else
+            console.log(err);
     }
     let log = fs.readFileSync(logfilename);
     if (fs.existsSync(outfilename) === true) {

package/build/console.js

@@ -41,6 +41,7 @@ function errorconsole(xmlError) {
             msg += ":" + (xmlError.tag.column + 1);
         }
         msg += ") ===============\n";
+        msg += xmlError.message;
         console.log(msg);
     }
 }

package/build/index.js

@@ -43,6 +43,7 @@ const TableDataCommand_1 = require("./TableDataCommand");
 const TestCommand_1 = require("./TestCommand");
 const UninstallCommand_1 = require("./UninstallCommand");
 const UserCommand_1 = require("./UserCommand");
+const CronCommand_1 = require("./CronCommand");
 const logger = loglevel_1.default.getLogger("index.ts");
 logger.setLevel("debug");
 /**
@@ -181,7 +182,7 @@ class StopCommand extends commander_1.Command {
  */
 const program = new commander_1.Command();
 program.name('cyk').description('cyklang CLI')
-    .version('0.7.5');
+    .version('0.8.3');
 program.addCommand(new StartCommand('start'));
 program.addCommand(new StopCommand('stop'));
 program.addCommand(new InstallCommand_1.InstallCommand('install'));
@@ -204,4 +205,6 @@ program.addCommand(new RunCommand_1.RunCommand('run'));
 program.addCommand(new RunCommand_1.RunCommand('r'));
 program.addCommand(new OpenCommand_1.OpenCommand('open'));
 program.addCommand(new OpenCommand_1.OpenCommand('o'));
+program.addCommand(new CronCommand_1.CronCommand('cron'));
+program.addCommand(new CronCommand_1.CronCommand('c'));
 program.parse();

package/clean_test.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+
+cyk table drop -y t_film_actor
+cyk table drop -y t_film
+cyk table drop -y t_actor
+
+
+psql -c "
+do \$\$
+declare next_id int;
+begin
+select max(table_id)+1 from cyk_table into next_id;
+execute 'alter sequence cyk_table_table_id_seq restart with ' || next_id ;
+end \$\$
+"
+
+
+
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@cyklang/cli",
-   "version": "0.8.0",
+   "version": "0.9.0",
    "description": "cyklang CLI",
    "main": "build/index.js",
    "scripts": {
@@ -11,13 +11,13 @@
       "npm:upgrade": "npx npm-check-updates -iu",
       "refresh": "rm -rf ./node_modules ./package-lock.json && npm install",
       "dev": "nodemon -e ts --ignore build --exec \"npm run global\" ",
-      "test": "cyk test test/t*.xml"
+      "test": "./run_test.sh"
    },
    "keywords": [],
    "author": "",
    "license": "ISC",
    "dependencies": {
-      "@cyklang/core": "^0.5.4",
+      "@cyklang/core": "^0.6.2",
       "commander": "^9.4.0",
       "dotenv": "^16.0.1",
       "form-data": "^4.0.0",

package/run_test.sh

@@ -1,11 +1,11 @@
 #!/bin/sh
 
-cyk table drop -y t_film_actor
-cyk table drop -y t_film
-cyk table drop -y t_actor
+./clean_test.sh
 
 cyk module upload test/db/t20.xml
 cyk module upload test/db/t22.xml
 
 cyk test test/db/t*.xml
 
+cyk test test/t*.xml
+

package/src/CronCommand.ts

@@ -0,0 +1,113 @@
+import { Command } from "commander";
+import loglevel from 'loglevel'
+import { Cmd } from "./Cmd";
+const logger = loglevel.getLogger('CronCommand.ts')
+logger.setLevel('debug')
+
+export class CronCommand extends Command {
+    constructor(name: string) {
+        super(name)
+        this.description('batch scheduling with cron')
+        .addCommand(new CronList('list'))
+        .addCommand(new CronList('l'))
+        .addCommand(new CronAddCmd('add'))
+        .addCommand(new CronAddCmd('a'))
+        .addCommand(new CronDeleteCmd('delete'))
+        .addCommand(new CronDeleteCmd('d'))
+    }
+}
+
+class CronList extends Cmd {
+    constructor(name: string) {
+        super(name)
+        this.description('List scheduled batches')
+            .action(async (options: any) => {
+                await this.commandList(options)
+            })
+    }
+
+    async commandList(options: any) {
+        try {
+            await this.prologue(options)
+
+            const json = await this.dbRemote?.apiServer.get('/api/admin/cron')
+            console.log(json)
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+}
+
+class CronAddCmd extends Cmd {
+    constructor(name: string) {
+        super(name)
+        this.description('add a batch scheduling with cron')
+            .option('-s --schedule <schedule>', 'schedule in crontab format')
+            .option('-m --module <module_name>', 'module name')
+            .option('-f --function <function>', 'function called in the module')
+            .option('-p --params <name_value_pairs>', 'URL encoded form without ? (question mark) ie "p1=val1&p2=val2"')
+            .action(async (options: any) => {
+                await this.commandAdd(options)
+            })
+    }
+    /**
+     * 
+     * @param options 
+     */
+    async commandAdd(options: any) {
+        try {
+
+            await this.prologue(options)
+            if (! this.dbRemote) throw 'dbRemote undefined'
+            const payload: any = {
+                schedule: options.schedule,
+                module: options.module,
+                function: options.function,
+                params: options.params
+            }
+            const response = await this.dbRemote.apiServer.post('/api/admin/cron', payload)
+            logger.debug(response)
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+
+}
+
+class CronDeleteCmd extends Cmd {
+    constructor(name: string) {
+        super(name)
+        this.description('delete a batch scheduling with cron')
+            .option('-s --schedule <schedule>', 'schedule in crontab format')
+            .option('-m --module <module_name>', 'module name')
+            .option('-f --function <function>', 'function called in the module')
+            .option('-p --params <name_value_pairs>', 'URL encoded form without ? (question mark) ie "p1=val1&p2=val2"')
+            .action(async (options: any) => {
+                await this.commandDelete(options)
+            })
+    }
+    /**
+     * 
+     * @param options 
+     */
+        async commandDelete(options: any) {
+            try {
+    
+                await this.prologue(options)
+                if (! this.dbRemote) throw 'dbRemote undefined'
+                const payload: any = {
+                    schedule: options.schedule,
+                    module: options.module,
+                    function: options.function,
+                    params: options.params
+                }
+                const response = await this.dbRemote.apiServer.delete('/api/admin/cron', payload)
+                logger.debug(response)
+            }
+            catch (err) {
+                logger.error(err)
+            }
+        }
+}

package/src/QueryCommand.ts

@@ -5,6 +5,7 @@ import loglevel from 'loglevel'
 import { Cmd } from './Cmd'
 import { Command } from 'commander'
 import { DBClient } from "./DBClient"
+import inquirer from 'inquirer'
 const logger = loglevel.getLogger("QueryCommand.ts")
 logger.setLevel("debug")
 
@@ -14,6 +15,7 @@ export class QueryCommand extends Command {
         this.description('query management')
         this.addCommand(new QueryList('list', 'list queries'))
         this.addCommand(new QueryList('l', 'list queries'))
+        this.addCommand(new QueryDelete('delete'))
     }
 }
 
@@ -42,7 +44,47 @@ class QueryList extends Cmd {
     }
 }
 
+/**
+ * class QueryDelete
+ */
+class QueryDelete extends Cmd {
+    constructor(name: string) {
+        super(name)
+        this.description('delete query from cyk_query table')
+        .option('-y --yes', 'confirmation is not required')
+        .argument('<query>', 'query name')
+        .action(async (query, options) => {
+            await this.commandDelete(query, options)
+        })
+    }
 
+    async commandDelete(query: string, options: any) {
+        try {
+            await this.prologue(options)
+            if (! this.dbManager) throw 'dbManager undefined'
+
+            const dbQuery = await this.dbManager.dbQueryExist(query)
+            if (! dbQuery ) {
+                console.log('query ' + query + ' does not exist ')
+                return
+            }
+            let deleteConfirmed = (options.yes !== undefined)
+            if (deleteConfirmed === false) {
+                const reply = await inquirer.prompt({ type: 'confirm', name: 'confirm', message: 'Delete query ' + query + '?' })
+                if (reply.confirm) {
+                    deleteConfirmed = true
+                }
+            }
+            if (deleteConfirmed) {
+                await this.dbManager.dbQueryDelete(dbQuery)
+                console.log('Query ' + query + ' has been deleted')
+            }
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+}
 
 //--------------------------------------------------------------------------------------------------------------------
 // class queryData

package/src/TestCommand.ts

@@ -11,15 +11,15 @@ export class TestCommand extends Cmd {
     constructor() {
         super('test')
         this.description('test script').version('0.1')
-        .argument('<files...>', 'local module file(s) to test run')
-        .action(async(files: any, options: any) => {
-            await this.testRun(files, options)
-        })
+            .argument('<files...>', 'local module file(s) to test run')
+            .action(async (files: any, options: any) => {
+                await this.testRun(files, options)
+            })
     }
     async testRun(files: string[], options: any) {
         try {
             const signinResponse = await this.prologue(options)
-            for (let ind=0; ind < files.length; ind++) {
+            for (let ind = 0; ind < files.length; ind++) {
                 const result = await testfile(files[ind])
                 if (result === false) {
                     logger.debug('*********** FAILURE ' + files[ind] + ' ***************')
@@ -50,12 +50,12 @@ async function testfile(filename: string): Promise<boolean> {
 
     let xml = fs.readFileSync(xmlfilename)
 
-    
+
     fs.writeFileSync(logfilename, "")
     //console.log(xml.toString())
     try {
         if (process.env.DBREMOTE_URL === undefined) throw 'DBREMOTE_URL undefined'
-        logger.trace('DBREMOTE_URL '+process.env.DBREMOTE_URL)
+        logger.trace('DBREMOTE_URL ' + process.env.DBREMOTE_URL)
         const structure = new Structure()
         const nodeCrypto = new NodeCrypto()
         const dbRemote = new DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto)
@@ -67,7 +67,7 @@ async function testfile(filename: string): Promise<boolean> {
         let script = new Script(structure.scope, xmlfilename, xml.toString())
         const user_lang = login.content.user_lang
         if (user_lang && user_lang.trim() !== '') {
-            
+
             const langfilename = filename + "__" + user_lang + ".xml"
 
             if (fs.existsSync(langfilename)) {
@@ -97,11 +97,12 @@ async function testfile(filename: string): Promise<boolean> {
             let xmlError = <XmlError>err
             errorconsole(xmlError)
         }
-        console.log(err)
+        else
+            console.log(err)
     }
 
     let log = fs.readFileSync(logfilename)
-    if (fs.existsSync(outfilename) === true ) {
+    if (fs.existsSync(outfilename) === true) {
         let out = fs.readFileSync(outfilename)
 
         if (log.toString() === out.toString()) {

package/src/console.ts

@@ -17,6 +17,7 @@ export function errorconsole(xmlError: XmlError) {
             msg += ":" + (xmlError.tag.column + 1)
         }
         msg += ") ===============\n"
+        msg += xmlError.message
         console.log(msg)
     }
 }

package/src/index.ts

@@ -15,6 +15,7 @@ import { TableDataCommand } from './TableDataCommand'
 import { TestCommand } from './TestCommand'
 import { UninstallCommand } from './UninstallCommand'
 import { UserCommand } from './UserCommand'
+import { CronCommand } from './CronCommand'
 
 const logger = loglevel.getLogger("index.ts")
 logger.setLevel("debug")
@@ -175,7 +176,7 @@ class StopCommand extends Command {
  */
 const program = new Command()
 program.name('cyk').description('cyklang CLI')
-    .version('0.7.5')
+    .version('0.8.3')
 program.addCommand(new StartCommand('start'))
 program.addCommand(new StopCommand('stop'))
 program.addCommand(new InstallCommand('install'))
@@ -198,5 +199,7 @@ program.addCommand(new RunCommand('run'))
 program.addCommand(new RunCommand('r'))
 program.addCommand(new OpenCommand('open'))
 program.addCommand(new OpenCommand('o'))
+program.addCommand(new CronCommand('cron'))
+program.addCommand(new CronCommand('c'))
 
 program.parse()

package/test/db/schema.xsd

@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+    <xs:element name="query" type="queryType"/>
+    <xs:element name="object" type="declareObject"/>
+
+    <xs:complexType name="declareObject" mixed="true">
+        <xs:group ref="declareVariable" minOccurs="0" maxOccurs="unbounded"/>
+        <xs:attribute name="name" type="xs:string"/>
+        <xs:attribute name="type" type="xs:string"/>
+    </xs:complexType>
+
+    <xs:complexType name="queryType" mixed="true">
+        <xs:group ref="queryTypeChild" minOccurs="1" maxOccurs="unbounded"/>
+        <xs:attribute name="name" type="xs:string"/>
+    </xs:complexType>
+
+    <xs:group name="queryTypeChild">
+        <xs:choice>
+            <xs:element name="string" type="queryStringChild"/>
+            <xs:element name="object" type="queryObjectChild"/>
+        </xs:choice>
+    </xs:group>
+
+    <xs:complexType name="queryStringChild">
+        <xs:simpleContent>
+            <xs:restriction base="stringType">
+                <xs:attribute name="name" use="required">
+                    <xs:simpleType>
+                        <xs:restriction base="xs:string">
+                            <xs:enumeration value="sql"></xs:enumeration>
+                            <xs:enumeration value="fields"></xs:enumeration>
+                            <xs:enumeration value="entities"></xs:enumeration>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:attribute>
+            </xs:restriction>
+        </xs:simpleContent>
+    </xs:complexType>
+    
+    <xs:complexType name="queryObjectChild" mixed="true">
+        <xs:group ref="declareVariable" minOccurs="0" maxOccurs="unbounded"/>
+        <xs:attribute name="name" type="xs:string" fixed="params"/>
+    </xs:complexType>
+
+    <xs:group name="declareVariable">
+        <xs:choice>
+            <xs:element name="number" type="numberType"/>
+            <xs:element name="string" type="stringType"/>
+            <xs:element name="query" type="queryType"/>
+            <xs:element name="object" type="declareObject"/>
+        </xs:choice>
+    </xs:group>
+
+    <xs:complexType name="numberType">
+        <xs:simpleContent>
+            <xs:extension base="xs:string">
+                <xs:attribute name="name" type="xs:string"/>
+            </xs:extension>
+        </xs:simpleContent>
+
+    </xs:complexType>
+
+    <xs:complexType name="stringType">
+        <xs:simpleContent>
+            <xs:extension base="xs:string">
+                <xs:attribute name="name" type="xs:string"/>
+                <xs:attribute name="literal" type="xs:string" fixed=""/>
+            </xs:extension>
+        </xs:simpleContent>
+
+    </xs:complexType>
+
+</xs:schema>