@cyklang/cli 0.1.0

package/build/module.js

@@ -0,0 +1,290 @@
+#!/usr/bin/env ts-node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@cyklang/core");
+const fs = __importStar(require("fs"));
+const loglevel_1 = __importDefault(require("loglevel"));
+const path_1 = __importDefault(require("path"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const commander_1 = require("commander");
+const NodeCrypto_1 = require("./NodeCrypto");
+const logger = loglevel_1.default.getLogger("cykmodule.ts");
+logger.setLevel("debug");
+const program = new commander_1.Command();
+program.name('cyk').description('manage modules in cyk_module table')
+    .version('0.2');
+program.command('add').description('add modules')
+    .argument('<files...>', 'local module file(s) to upload to the server')
+    .option('-n --name <dbname>', 'module dbname')
+    .option('-d --desc <description>', 'description')
+    .option('-a --access <access>', 'access control list')
+    .option('-e --env <env>', 'path to the environment variables file')
+    .action(async (files, options) => {
+    await commandAdd(files, options);
+});
+program.command('update').description('update module')
+    .option('-i --id <id>', 'module ID')
+    .option('-n --name <dbname>', 'module dbname')
+    .option('-d --desc <description>', 'description')
+    .option('-a --access <access>', 'access control list')
+    .option('-e --env <env>', 'path to the environment variables file')
+    .argument('[files...]', 'local module file(s) to upload to the server')
+    .action(async (files, options) => {
+    await commandUpdate(files, options);
+});
+program.command('run').description('execute/run a local module file')
+    .argument('<file>', 'local module file to run')
+    .option('-e --env <env>', 'path to the environment variables file')
+    .action(async (file, options) => {
+    await commandRun(file, options);
+});
+const getDBManager = async () => {
+    const structure = new core_1.Structure();
+    if (process.env.DBREMOTE_URL === undefined)
+        throw 'DBREMOTE_URL undefined';
+    logger.debug('DBREMOTE_URL ' + process.env.DBREMOTE_URL);
+    const nodeCrypto = new NodeCrypto_1.NodeCrypto();
+    const dbRemote = new core_1.DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto);
+    const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD);
+    // logger.debug(login)
+    const dbManager = new core_1.DBManager(structure.scope, dbRemote);
+    await dbManager.initialize();
+    return dbManager;
+};
+const commandAdd = async (files, options) => {
+    // logger.debug('options : ', options, ', files : ', files)
+    try {
+        const dotenvOutput = dotenv_1.default.config({ path: options.env });
+        if (dotenvOutput.error !== undefined)
+            throw dotenvOutput.error;
+        const dbManager = await getDBManager();
+        if (options.id !== undefined)
+            throw '--id option is not available';
+        if (files.length === 0)
+            throw 'file(s) name(s) missing';
+        if (files.length > 1 && (options.name !== undefined))
+            throw '--name option cannot be specified with more than 1 file';
+        for (let ind = 0; ind < files.length; ind++) {
+            const file = files[ind];
+            const dbModule = new core_1.DBModule();
+            dbModule.source = fs.readFileSync(file).toString();
+            dbModule.dbname = path_1.default.basename(file, '.xml');
+            if (options.name !== undefined)
+                dbModule.dbname = options.name;
+            if (options.desc !== undefined)
+                dbModule.description = options.desc;
+            if (options.access !== undefined)
+                dbModule.access = options.access;
+            const moduleExist = await dbManager.dbModuleExist(dbModule.dbname);
+            if (moduleExist !== undefined)
+                throw 'module ' + moduleExist.dbname + ' already exists with id ' + moduleExist.id;
+            const id = await dbManager.dbModuleInsert(dbModule);
+            logger.info('module ' + dbModule.dbname + ' added with id ' + id);
+        }
+    }
+    catch (err) {
+        logger.error(err);
+    }
+};
+const commandUpdate = async (files, options) => {
+    // logger.debug('files : ', files, ', options : ', options)
+    try {
+        const dotenvOutput = dotenv_1.default.config({ path: options.env });
+        if (dotenvOutput.error !== undefined)
+            throw dotenvOutput.error;
+        const dbManager = await getDBManager();
+        if (options.id !== undefined) {
+            if (files.length > 1)
+                throw 'with --id option you can only specify 1 local file';
+            const dbModule = await dbManager.getModule(options.id);
+            if (options.name !== undefined)
+                dbModule.dbname = options.name;
+            if (options.desc !== undefined)
+                dbModule.description = options.desc;
+            if (options.access !== undefined)
+                dbModule.access = options.access;
+            if (files.length === 1) {
+                dbModule.source = fs.readFileSync(files[0]).toString();
+            }
+            await dbManager.dbModuleUpdate(dbModule);
+        }
+        else {
+            if (files.length === 0)
+                throw 'without --id option you need to specify at least 1 local file';
+            for (let ind = 0; ind < files.length; ind++) {
+                const file = files[ind];
+                const dbname = path_1.default.basename(file, '.xml');
+                const dbModule = await dbManager.dbModuleExist(dbname);
+                if (dbModule === undefined) {
+                    logger.info('local file ' + file + ', module ' + dbname + ' not found');
+                    continue;
+                }
+                dbModule.source = fs.readFileSync(file).toString();
+                logger.debug('dbModule update from ' + file);
+                if (options.desc !== undefined)
+                    dbModule.description = options.desc;
+                if (options.access !== undefined)
+                    dbModule.access = options.access;
+                await dbManager.dbModuleUpdate(dbModule);
+            }
+        }
+    }
+    catch (err) {
+        logger.error(err);
+    }
+};
+const commandRun = async (file, options) => {
+    try {
+        logger.debug('options', options);
+        const dotenvOutput = dotenv_1.default.config({ path: options.env });
+        if (dotenvOutput.error !== undefined)
+            throw dotenvOutput.error;
+        const dbManager = await getDBManager();
+        const source = fs.readFileSync(file).toString();
+        const tag = (0, core_1.parseXML)(file, source);
+        const moduleInstruction = new core_1.ModuleInstruction(tag, dbManager);
+        const scopeRun = new core_1.Scope(dbManager.scope.structure, dbManager.scope, undefined);
+        await moduleInstruction.parseInstructions(tag, scopeRun);
+        await moduleInstruction.execute(scopeRun);
+    }
+    catch (err) {
+        logger.error(err);
+    }
+};
+program.parse();
+// const main = async () => {
+//     const { command, filepath, basename } = parseCommandLine()
+//     const xmlSource = fs.readFileSync(filepath).toString()
+//     let dbModule: DBModule | undefined
+//     let tag = parseXmlFile(filepath, basename, xmlSource)
+//     if (command === Command.Test || command === Command.TestSave) {
+//         dbModule = await testXml(structure, tag)
+//     }
+//     else if (command === Command.Save) {
+//         dbModule = await dbManager.dbModuleExist(tag.attributes.DBNAME)
+//         if (dbModule === undefined) {
+//             dbModule = new DBModule(tag.attributes.DBNAME)
+//         }
+//     }
+//     if (dbModule !== undefined && (command === Command.Save || command === Command.TestSave)) {
+//         dbModule.source = xmlSource
+//         await saveModule(dbManager, dbModule)
+//     }
+// }
+// main().then(() => logger.debug('finished'))
+// enum Command {
+//     Test = 'test',
+//     Save = 'save',
+//     TestSave = 'testsave'
+// }
+// function syntax() {
+//     console.log(`
+//     ----------------------------------------------------------------------------------
+//     cykmodule writes a module file to the server (DBREMOTE_URL environment variable)
+//     syntax :
+//     cykmodule [ save | test | testsave ] filename
+//     cykmodule filename ( option testsave if omitted )
+//     ----------------------------------------------------------------------------------
+//     `)
+// }
+// function parseCommandLine(): { command: Command, filepath: string, basename: string } {
+//     let command = Command.TestSave
+//     let filepath
+//     if (process.argv.length < 3 || process.argv.length > 4) {
+//         syntax()
+//         throw Error('nb of command line arguments : ' + process.argv.length)
+//     }
+//     if (process.argv.length === 3) {
+//         filepath = process.argv[2]
+//         command = Command.TestSave
+//     }
+//     else {
+//         const option = process.argv[2].toLowerCase()
+//         if ( option === 'test' || option === 'save' || option === 'testsave') {
+//             command = <Command> option
+//         }
+//         else {
+//             syntax()
+//             throw Error('command unknown ' + process.argv[2])
+//         }
+//         filepath = process.argv[3]
+//     }
+//     logger.trace('dbmodule filepath : ' + filepath)
+//     const basename = path.basename(filepath)
+//     const extname = path.extname(filepath)
+//     logger.trace('basename ' + basename + ', extname ' + extname)
+//     if (extname.toLowerCase() !== '.xml') {
+//         throw Error('filepath argument ' + filepath + ' should have xml extension')
+//     }
+//     return { command, filepath, basename }
+// }
+function parseXmlFile(filepath, basename, xmlSource) {
+    const tag = (0, core_1.parseXML)(filepath, xmlSource);
+    if (tag.name !== 'MODULE') {
+        throw Error('tag ' + tag.name + ', should be <module>');
+    }
+    const dbname = tag.attributes.DBNAME;
+    // if (dbname === undefined) {
+    //     throw Error('dbname attribute is missing')
+    // }
+    if (dbname !== undefined && basename !== dbname + '.xml') {
+        throw Error('filename ' + filepath + ' and dbname ' + dbname + ' do not correspond');
+    }
+    return tag;
+}
+async function testXml(structure, tag) {
+    let result;
+    try {
+        logger.debug('testXml dbname : ' + tag.attributes.DBNAME);
+        // structure.setInstructionType("print", new PrintInstructionType(logfilename))
+        const moduleInstructionType = structure.scope.getInstructionType('module');
+        if (moduleInstructionType === undefined) {
+            throw Error('moduleInstructionType not found');
+        }
+        const scopeParse = new core_1.Scope(structure, structure.scope, undefined);
+        const moduleInst = await moduleInstructionType.parseInstruction(tag, scopeParse);
+        const scopeExecute = new core_1.Scope(structure, structure.scope, undefined);
+        await moduleInst.execute(scopeExecute);
+        result = moduleInst.dbModule;
+        // if (result === undefined) {
+        //     throw Error('moduleInst.dbModule undefined')
+        // }
+    }
+    catch (err) {
+        logger.error(err);
+    }
+    return result;
+}
+async function saveModule(dbManager, dbModule) {
+    logger.debug('saveModule ' + dbModule.dbname + ', description ; ' + dbModule.description);
+    if (dbModule.id === undefined) {
+        // dbModuleInsert
+        await dbManager.dbModuleInsert(dbModule);
+    }
+    else {
+        // dbModuleUpdate
+        await dbManager.dbModuleUpdate(dbModule);
+    }
+}

package/docker-compose.ecs.yml

@@ -0,0 +1,44 @@
+version: "3.9"
+
+services:
+
+  postgres:
+    image: postgres
+    environment:
+      POSTGRES_USER: ${POSTGRES_USER:-postgres}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+    ports:
+      - "${PGPORT}:5432"
+    volumes:
+      - db:/var/lib/postgresql/data
+
+  nodejs:
+    image: pchaneyo/cyk-nodejs
+    environment:
+      ADMIN_NAME: ${ADMIN_NAME}
+      ADMIN_PASSWORD: ${ADMIN_PASSWORD}
+      ADMIN_EMAIL: ${ADMIN_EMAIL}
+      # DATABASE_URL: "postgres://postgres:postgres@postgres:5432/postgres?sslmode=disable"
+      PGHOST: "postgres"
+      PGPORT: "5432"
+      PGUSER: ${POSTGRES_USER:-postgres}
+      PGPASSWORD: ${POSTGRES_PASSWORD}
+      SECRET_TOKEN: ${SECRET_TOKEN? SECRET_TOKEN environment variable is missing}
+      SECRET_RTOKEN: ${SECRET_RTOKEN? SECRET_RTOKEN environment variable is missing}
+      # Login Page Config
+      LOGIN_IMAGE: ${LOGIN_IMAGE}
+      LOGIN_TITLE: ${LOGIN_TITLE}
+      LOGIN_SUBTITLE: ${LOGIN_SUBTITLE}
+      LOGIN_APPLI: ${LOGIN_APPLI}
+      # PGSSLMODE: "disable"
+    depends_on:
+      - postgres
+    ports:
+      - "${CYK_PORT}:3000"
+
+volumes:
+  db:
+
+
+
+

package/docker-compose.yml

@@ -0,0 +1,43 @@
+version: "3.9"
+
+services:
+
+  postgres:
+    image: postgres
+    environment:
+      POSTGRES_USER: ${POSTGRES_USER:-postgres}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+    ports:
+      - "${PGPORT}:5432"
+    volumes:
+      - db:/var/lib/postgre
+  nodejs:
+    image: pchaneyo/cyk-nodejs
+    environment:
+      ADMIN_NAME: ${ADMIN_NAME}
+      ADMIN_PASSWORD: ${ADMIN_PASSWORD}
+      ADMIN_EMAIL: ${ADMIN_EMAIL}
+      # DATABASE_URL: "postgres://postgres:postgres@postgres:5432/postgres?sslmode=disable"
+      PGHOST: "postgres"
+      PGPORT: "5432"
+      PGUSER: ${POSTGRES_USER:-postgres}
+      PGPASSWORD: ${POSTGRES_PASSWORD}
+      SECRET_TOKEN: ${SECRET_TOKEN? SECRET_TOKEN environment variable is missing}
+      SECRET_RTOKEN: ${SECRET_RTOKEN? SECRET_RTOKEN environment variable is missing}
+      # Login Page Config
+      LOGIN_IMAGE: ${LOGIN_IMAGE}
+      LOGIN_TITLE: ${LOGIN_TITLE}
+      LOGIN_SUBTITLE: ${LOGIN_SUBTITLE}
+      LOGIN_APPLI: ${LOGIN_APPLI}
+      # PGSSLMODE: "disable"
+    depends_on:
+      - postgres
+    ports:
+      - "${CYK_PORT}:3000"
+
+volumes:
+  db:
+
+
+
+

package/docker.env

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

package/package.json

@@ -0,0 +1,38 @@
+{
+   "name": "@cyklang/cli",
+   "version": "0.1.0",
+   "description": "cyklang CLI",
+   "main": "build/index.js",
+   "scripts": {
+      "build": "tsc",
+      "global": "npm run build && npm i -g",
+      "local": "sudo npm uninstall -g && sudo npm install -g && cyk",
+      "npm:format": "npx prettier-package-json --write package.json",
+      "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": "sudo npm i -g && cyk"
+   },
+   "keywords": [],
+   "author": "",
+   "license": "ISC",
+   "dependencies": {
+      "@cyklang/core": "^0.3.4",
+      "commander": "^9.4.0",
+      "dotenv": "^16.0.1",
+      "loglevel": "^1.8.0",
+      "pako": "^2.0.4",
+      "xml": "^1.0.1"
+   },
+   "devDependencies": {
+      "@types/pako": "^2.0.0",
+      "@types/sax": "^1.2.4",
+      "@types/xml": "^1.0.8",
+      "nodemon": "^2.0.16",
+      "ts-node": "^10.7.0",
+      "typescript": "4.5.2"
+   },
+   "bin": {
+      "cyk": "build/index.js"
+   }
+}

package/src/Cmd.ts

@@ -0,0 +1,33 @@
+import { DBManager, DBRemote, Structure } from "@cyklang/core";
+import { Command } from "commander";
+import dotenv from 'dotenv'
+import loglevel from 'loglevel'
+import { NodeCrypto } from "./NodeCrypto";
+const logger = loglevel.getLogger('Cmd.ts')
+logger.setLevel('debug')
+
+export class Cmd extends Command {
+    dbManager: DBManager | undefined
+
+    constructor(name: string) {
+        super(name);
+        this.option('--env <env>', 'path to the environment variables file')
+    }
+ 
+    async prologue(options: any) {
+
+        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('DBREMOTE_URL ' + process.env.DBREMOTE_URL)
+        const nodeCrypto = new NodeCrypto()
+        const dbRemote = new DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto)
+        const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD)
+        // logger.debug(login)
+        
+        this.dbManager = new DBManager(structure.scope, dbRemote)
+        await this.dbManager.initialize()
+    }
+}