@sme.up/kokos-sdk-node 0.0.2 → 0.0.5

package/README.md

@@ -9,4 +9,4 @@
 - hot reload for development environment
 - build
 
-See [official docs](https://docs.smeup.cloud/en/CLS-SU/MURUNT/DOC/MURUNT_15) for all details.
+See [official docs](https://docs.smeup.cloud/en/CLS-SU/MURUNT/OPE/MURUNT_03/sdk-node) for all details.

package/lib/caller/serviceCaller.d.ts

@@ -1,5 +1,6 @@
-import { SmeupDataStructure } from "../types/data-structures/smeupDataStructure.js";
+/// <reference types="node" />
 import { ExecutionContext, Fun } from "../types/general.js";
+import stream from "stream";
 /**
  * PROJECT FILE SYSTEM
  *
@@ -29,4 +30,4 @@ import { ExecutionContext, Fun } from "../types/general.js";
  * @returns
  * @throws ExecutionException
  */
-export declare function serviceCaller(fun: Fun, context: ExecutionContext): Promise<SmeupDataStructure>;
+export declare function serviceCaller(fun: Fun, context: ExecutionContext, out: stream.Writable): Promise<void>;

package/lib/caller/serviceCaller.js

@@ -1,8 +1,10 @@
 import path from "path";
 import url from "url";
 import os from "os";
-import { ExecutionException } from "../types/exceptions/execution.js";
 import { getProjectRoot } from "../utils/path.js";
+import { SmeupDataStructureWriter } from "../utils/smeupDataStructureWriter.js";
+import { SMEUP_MESSAGE_GRAVITY, SMEUP_MESSAGE_MODE, } from "../types/data-structures/smeupDataStructure.js";
+import { LOGGER, clearLoggerContext, createLoggerContext, } from "../logger/logger.js";
 /**
  * PROJECT FILE SYSTEM
  *
@@ -32,9 +34,17 @@ import { getProjectRoot } from "../utils/path.js";
  * @returns
  * @throws ExecutionException
  */
-export async function serviceCaller(fun, context) {
+export async function serviceCaller(fun, context, out) {
+    // setup logger context
+    const loggerContext = {
+        fun: "TODO",
+        sessionId: context.user.sessionId,
+        user: context.user.username,
+        environment: context.user.environment,
+    };
+    createLoggerContext(loggerContext);
     // get service path
-    let servicePath;
+    let servicePath = "";
     if (!process.env.NODE_ENV || process.env.NODE_ENV == "production") {
         servicePath = path.resolve(getProjectRoot(), "lib", "services", `${fun.service}.js`);
     }
@@ -44,6 +54,8 @@ export async function serviceCaller(fun, context) {
     }
     // load service module
     let serviceModule;
+    const writer = new SmeupDataStructureWriter(out);
+    writer.writeDataStructureInitialization(fun);
     try {
         // import service by its name as es module
         if (os.platform() == "win32") {
@@ -52,15 +64,37 @@ export async function serviceCaller(fun, context) {
         else {
             serviceModule = await import(servicePath);
         }
+        // check method
+        if (serviceModule.default.methods[fun.function]) {
+            // call method
+            try {
+                await serviceModule.default.methods[fun.function](fun, context, writer);
+            }
+            catch (error) {
+                LOGGER.error(error);
+                writer.writeMessage({
+                    gravity: SMEUP_MESSAGE_GRAVITY.ERROR,
+                    mode: SMEUP_MESSAGE_MODE.PN,
+                    message: error.message,
+                });
+            }
+        }
+        else {
+            writer.writeMessage({
+                gravity: SMEUP_MESSAGE_GRAVITY.ERROR,
+                mode: SMEUP_MESSAGE_MODE.PN,
+                message: `Method "${fun.function ? fun.function : ""}" not found for service "${fun.service}"`,
+            });
+        }
     }
-    catch (_error) {
-        throw new ExecutionException(`Service "${fun.service}" not found`, _error);
-    }
-    // check method
-    if (serviceModule.default.methods[fun.function]) {
-        return await serviceModule.default.methods[fun.function](fun, context);
-    }
-    else {
-        throw new ExecutionException(`Method "${fun.function ? fun.function : ""}" not found for service "${fun.service}"`);
+    catch (error) {
+        LOGGER.error(error);
+        writer.writeMessage({
+            gravity: SMEUP_MESSAGE_GRAVITY.ERROR,
+            mode: SMEUP_MESSAGE_MODE.PN,
+            message: `Service "${fun.service}" not found: ${error.message}`,
+        });
     }
+    clearLoggerContext();
+    writer.writeDataStructureFinalization(fun);
 }

package/lib/configuration/configuration.d.ts

@@ -0,0 +1,8 @@
+import { MicroExecutorConfiguration } from "../types/general";
+/**
+ * Init micro executor configuration
+ * @param microExecutorId
+ * @param defatultConfigurationClass
+ * @returns
+ */
+export declare function init<T extends MicroExecutorConfiguration>(microExecutorId: string, defatultConfigurationClass: T): T;

package/lib/configuration/configuration.js

@@ -0,0 +1,29 @@
+import path from "path";
+import os from "os";
+import fs from "fs";
+import yaml from "js-yaml";
+const baseDir = path.join(os.homedir(), "etc", "kokos");
+/**
+ * Init micro executor configuration
+ * @param microExecutorId
+ * @param defatultConfigurationClass
+ * @returns
+ */
+export function init(microExecutorId, defatultConfigurationClass) {
+    const microExecutorBaseDir = path.join(baseDir, microExecutorId);
+    const microExecutorConfigFilePath = path.join(microExecutorBaseDir, microExecutorId + ".yaml");
+    // create dir if not exists
+    if (!fs.existsSync(microExecutorBaseDir)) {
+        fs.mkdirSync(microExecutorBaseDir, { recursive: true });
+    }
+    // create config file if not exists
+    if (!fs.existsSync(microExecutorConfigFilePath)) {
+        const yamlData = yaml.dump(defatultConfigurationClass);
+        fs.writeFileSync(microExecutorConfigFilePath, yamlData, "utf8");
+    }
+    // load configuration
+    const yamlData = fs.readFileSync(microExecutorConfigFilePath, "utf8");
+    const yamlObject = yaml.load(yamlData);
+    const configuration = { ...defatultConfigurationClass, ...yamlObject };
+    return configuration;
+}

package/lib/entrypoint/restapi/index.js

@@ -1,110 +1,2 @@
-import express from "express";
-import bodyParser from "body-parser";
-import { plainToInstance } from "class-transformer";
-import { validate } from "class-validator";
-import { ValidationException } from "../../types/exceptions/validation.js";
-import { ExecuteFunPayload } from "../../types/general.js";
-import { serviceCaller } from "../../caller/serviceCaller.js";
-import { fileURLToPath } from 'url';
-import { dirname, normalize } from 'path';
-// constant
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const app = express();
-// body parse middleware
-app.use(bodyParser.json());
-// swagger
-const swaggerPath = normalize(`${__dirname}/../../../swagger`);
-app.use("/swagger", express.static(swaggerPath));
-// docs
-const docsPath = normalize(`${__dirname}/../../../docs`);
-app.use("/docs", express.static(docsPath));
-/**
- * REST API Entrypoint
- */
-/**
- * EXECUTION API
- */
-/**
- * /executeFun API
- */
-app.use("/api/v1/executeFun", validationMiddleware(ExecuteFunPayload), async (req, res, next) => {
-    try {
-        // get body
-        const { fun, context } = req.body;
-        // call service caller
-        const smeupDataStructure = await serviceCaller(fun, context);
-        // return response
-        res.status(200).json(smeupDataStructure);
-    }
-    catch (error) {
-        next(error);
-    }
-});
-/**
- * MONITORING API
- */
-/**
- * /livez API
- */
-app.use("/api/v1/livez", async (req, res) => {
-    res.status(200).send({
-        status: "ok",
-    });
-});
-/**
- * /readyz API
- */
-app.use("/api/v1/readyz", async (req, res) => {
-    res.status(200).send({
-        status: "ok",
-    });
-});
-// error middleware
-app.use(errorMiddleware);
-// start server
-const PORT = process.env.PORT || 3000;
-app.listen(PORT, () => {
-    console.log("App listening on the port " + PORT);
-});
-/**
- * MIDDLEWARES
- */
-/**
- * Validation Middleware
- * Validate request body
- * @param type
- * @param skipMissingProperties
- * @returns
- */
-function validationMiddleware(type) {
-    return (req, res, next) => {
-        validate(plainToInstance(type, req.body)).then((errors) => {
-            if (errors.length > 0) {
-                const message = errors
-                    .map((error) => Object.values(error.constraints))
-                    .join(", ");
-                next(new ValidationException(message));
-            }
-            else {
-                next();
-            }
-        });
-    };
-}
-/**
- * Error Middleware
- * Handle all application error
- * @param error
- * @param request
- * @param response
- */
-function errorMiddleware(error, _request, response, _next) {
-    const status = error.status || 500;
-    const message = error.message || "Something went wrong";
-    console.error(message);
-    response.status(status).json({
-        message: message,
-        status: status,
-    });
-}
+import { startServer } from "./restapi.js";
+startServer("me-node-example");

package/lib/entrypoint/restapi/restapi.d.ts

@@ -0,0 +1,3 @@
+import { MicroExecutorConfiguration } from "../../types/general.js";
+export declare function startServer(microExecutorId: string): void;
+export declare function startServerWithCustomConfig<T extends MicroExecutorConfiguration>(microExecutorId: string, defaultConfigurationClass: T, callback?: (configuration: T) => void): void;

package/lib/entrypoint/restapi/restapi.js

@@ -0,0 +1,145 @@
+import express from "express";
+import bodyParser from "body-parser";
+import { plainToInstance } from "class-transformer";
+import { validate } from "class-validator";
+import { ValidationException } from "../../types/exceptions/validation.js";
+import { ExecuteFunPayload, } from "../../types/general.js";
+import { serviceCaller } from "../../caller/serviceCaller.js";
+import { fileURLToPath } from "url";
+import { dirname, normalize } from "path";
+import stream from "stream";
+import { SMEUP_MESSAGE_GRAVITY, SMEUP_MESSAGE_MODE, } from "../../types/data-structures/smeupDataStructure.js";
+import { init } from "../../configuration/configuration.js";
+import { LOGGER, configureLogger } from "../../logger/logger.js";
+// constant
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export function startServer(microExecutorId) {
+    startServerWithCustomConfig(microExecutorId, {
+        server: {
+            port: 8011,
+        },
+    });
+}
+export function startServerWithCustomConfig(microExecutorId, defaultConfigurationClass, callback) {
+    // load config
+    const configuration = init(microExecutorId, defaultConfigurationClass);
+    if (callback) {
+        // call callback
+        callback(configuration);
+    }
+    configureLogger(configuration.logger?.level, configuration.logger?.format);
+    // create server
+    const app = express();
+    // body parse middleware
+    app.use(bodyParser.json());
+    // swagger
+    const swaggerPath = normalize(`${__dirname}/../../../swagger`);
+    app.use("/swagger", express.static(swaggerPath));
+    // docs
+    const docsPath = normalize(`${__dirname}/../../../docs`);
+    app.use("/docs", express.static(docsPath));
+    /**
+     * REST API Entrypoint
+     */
+    /**
+     * EXECUTION API
+     */
+    /**
+     * /executeFun API
+     */
+    app.use("/api/v1/executeFun", validationMiddleware(ExecuteFunPayload), (req, res, next) => {
+        // get body
+        const { fun, context } = req.body;
+        // set status
+        res.status(200);
+        res.setHeader("Content-Type", "application/json");
+        // create stream
+        const out = new stream.Writable({
+            write(chunk, encoding, callback) {
+                res.write(chunk, encoding);
+                callback();
+            },
+        });
+        // call service caller
+        serviceCaller(fun, context, out)
+            .then(() => {
+            res.end();
+        })
+            .catch((err) => {
+            next(err);
+        });
+    });
+    /**
+     * MONITORING API
+     */
+    /**
+     * /livez API
+     */
+    app.use("/api/v1/livez", async (req, res) => {
+        res.status(200).send({
+            status: "ok",
+        });
+    });
+    /**
+     * /readyz API
+     */
+    app.use("/api/v1/readyz", async (req, res) => {
+        res.status(200).send({
+            status: "ok",
+        });
+    });
+    // error middleware
+    app.use(errorMiddleware);
+    // start server
+    const PORT = configuration.server.port || 3000;
+    app.listen(PORT, () => {
+        LOGGER.info(`App listening on the port ${PORT}`);
+    });
+    /**
+     * MIDDLEWARES
+     */
+    /**
+     * Validation Middleware
+     * Validate request body
+     * @param type
+     * @param skipMissingProperties
+     * @returns
+     */
+    function validationMiddleware(type) {
+        return (req, res, next) => {
+            validate(plainToInstance(type, req.body)).then((errors) => {
+                if (errors.length > 0) {
+                    const message = errors
+                        .map((error) => error.constraints && Object.values(error.constraints))
+                        .join(", ");
+                    next(new ValidationException(message));
+                }
+                else {
+                    next();
+                }
+            });
+        };
+    }
+    /**
+     * Error Middleware
+     * Handle all application error
+     * @param error
+     * @param request
+     * @param response
+     */
+    function errorMiddleware(error, _request, response, _next) {
+        const status = error.status || 500;
+        const message = error.message || "Something went wrong";
+        LOGGER.error(error);
+        response.status(status).json({
+            messages: [
+                {
+                    gravity: SMEUP_MESSAGE_GRAVITY.ERROR,
+                    message: message,
+                    mode: SMEUP_MESSAGE_MODE.PN,
+                },
+            ],
+        });
+    }
+}

package/lib/index.d.ts

@@ -1,9 +1,14 @@
-/**
- * TYPES
- */
+/** TYPES */
 export * from "./types/general.js";
 /** DATA STRUCTURES */
 export * from "./types/data-structures/smeupDataStructure.js";
 export * from "./types/data-structures/smeupObject.js";
 export * from "./types/data-structures/smeupTable.js";
 export * from "./types/data-structures/smeupTree.js";
+/** ENTRYPOINT */
+export * from "./entrypoint/restapi/restapi.js";
+/** LOGGER */
+export * from "./logger/logger.js";
+/** UTILS */
+export * from "./utils/smeupDataStructureWriter.js";
+export * from "./utils/regex.js";

package/lib/index.js

@@ -1,9 +1,14 @@
-/**
- * TYPES
- */
+/** TYPES */
 export * from "./types/general.js";
 /** DATA STRUCTURES */
 export * from "./types/data-structures/smeupDataStructure.js";
 export * from "./types/data-structures/smeupObject.js";
 export * from "./types/data-structures/smeupTable.js";
 export * from "./types/data-structures/smeupTree.js";
+/** ENTRYPOINT */
+export * from "./entrypoint/restapi/restapi.js";
+/** LOGGER */
+export * from "./logger/logger.js";
+/** UTILS */
+export * from "./utils/smeupDataStructureWriter.js";
+export * from "./utils/regex.js";

package/lib/logger/logger.d.ts

@@ -0,0 +1,25 @@
+export interface LoggerContext {
+    fun: string;
+    sessionId: string;
+    user: string;
+    environment: string;
+}
+export declare enum Level {
+    INFO = "INFO",
+    DEBUG = "DEBUG",
+    ERROR = "ERROR"
+}
+export declare enum Format {
+    JSON = "JSON",
+    TXT = "TXT"
+}
+export declare const configureLogger: (level?: Level, format?: Format) => void;
+export declare const createLoggerContext: (context: LoggerContext) => void;
+export declare const clearLoggerContext: () => void;
+declare class Logger {
+    info(message: string): void;
+    error(error: Error): void;
+    private _log;
+}
+export declare const LOGGER: Logger;
+export {};

package/lib/logger/logger.js

@@ -0,0 +1,84 @@
+import async_hooks from "async_hooks";
+export var Level;
+(function (Level) {
+    Level["INFO"] = "INFO";
+    Level["DEBUG"] = "DEBUG";
+    Level["ERROR"] = "ERROR";
+})(Level || (Level = {}));
+export var Format;
+(function (Format) {
+    Format["JSON"] = "JSON";
+    Format["TXT"] = "TXT";
+})(Format || (Format = {}));
+const LOGGER_SETTING = {
+    level: Level.DEBUG,
+    format: Format.TXT,
+};
+const LOGGER_CONTEXT_MAP = {};
+export const configureLogger = (level, format) => {
+    LOGGER_SETTING.level = level ? level : Level.DEBUG;
+    LOGGER_SETTING.format = format ? format : Format.TXT;
+};
+export const createLoggerContext = (context) => {
+    // get the async execution id
+    const id = async_hooks.executionAsyncId();
+    // save to context map
+    LOGGER_CONTEXT_MAP[id] = context;
+};
+export const clearLoggerContext = () => {
+    // get the async execution id
+    const id = async_hooks.executionAsyncId();
+    // delete from context map
+    delete LOGGER_CONTEXT_MAP[id];
+};
+class Logger {
+    info(message) {
+        this._log(Level.INFO, message);
+    }
+    error(error) {
+        this._log(Level.ERROR, error.message, error);
+    }
+    _log(level, message, error) {
+        // logger level
+        if (LOGGER_SETTING.level == Level.INFO && level == Level.DEBUG) {
+            return;
+        }
+        // get the async execution id
+        const id = async_hooks.executionAsyncId();
+        // get context
+        const context = LOGGER_CONTEXT_MAP[id];
+        // create log record
+        const record = {
+            ...context,
+            timestamp: new Date().toISOString(),
+            applicationId: "",
+            message: message,
+            level: level.toString(),
+            applicationReserved: {
+                executionId: id.toString(),
+                stackTrace: error && error.stack ? error.stack : "",
+            },
+        };
+        let stringRecord = "";
+        if (LOGGER_SETTING.format == Format.JSON) {
+            stringRecord = JSON.stringify(record);
+        }
+        else {
+            stringRecord = `${record.timestamp} ${record.applicationReserved.executionId} ${record.level} - ${record.message} ${record.applicationReserved.stackTrace
+                ? record.applicationReserved.stackTrace
+                : ""}`;
+        }
+        switch (level) {
+            case Level.INFO:
+                console.info(stringRecord);
+                break;
+            case Level.DEBUG:
+                console.debug(stringRecord);
+                break;
+            case Level.ERROR:
+                console.error(stringRecord);
+                break;
+        }
+    }
+}
+export const LOGGER = new Logger();

package/lib/services/JS_00_01.js

@@ -1,67 +1,58 @@
-import { SmeupDataStructureType } from "../types/data-structures/smeupDataStructure.js";
 const JS_00_01 = {
     methods: {
         "GET.TRE": getTree,
         "GET.EXB": getTable,
+        "THR.ERR": throwError,
     },
 };
-async function getTree(fun, context) {
-    const tree = {
-        type: SmeupDataStructureType.SmeupTree,
-        children: [
-            {
-                children: [],
-                content: {
+async function getTree(_fun, _context, printer) {
+    printer.writeTreeNode({
+        children: [],
+        content: {
+            tipo: "CN",
+            parametro: "COL",
+            codice: "PIPPO",
+            testo: "Pippo",
+        },
+    });
+}
+async function getTable(_fun, _context, printer) {
+    printer.writeColumns([
+        {
+            code: "COL1",
+            text: "Column 1",
+        },
+        {
+            code: "COL2",
+            text: "Column 2",
+        },
+    ]);
+    printer.writeRow({
+        fields: {
+            COL1: {
+                name: "COL1",
+                tooltip: false,
+                smeupObject: {
                     tipo: "CN",
                     parametro: "COL",
                     codice: "PIPPO",
                     testo: "Pippo",
                 },
             },
-        ],
-    };
-    return tree;
-}
-async function getTable(fun, context) {
-    const table = {
-        type: SmeupDataStructureType.SmeupTable,
-        columns: [
-            {
-                code: "COL1",
-                text: "Column 1",
-            },
-            {
-                code: "COL2",
-                text: "Column 2",
-            },
-        ],
-        rows: [
-            {
-                fields: {
-                    COL1: {
-                        name: "COL1",
-                        tooltip: false,
-                        smeupObject: {
-                            tipo: "CN",
-                            parametro: "COL",
-                            codice: "PIPPO",
-                            testo: "Pippo",
-                        },
-                    },
-                    COL2: {
-                        name: "COL2",
-                        tooltip: false,
-                        smeupObject: {
-                            tipo: "CN",
-                            parametro: "COL",
-                            codice: "PLUTO",
-                            testo: "Pluto",
-                        },
-                    },
+            COL2: {
+                name: "COL2",
+                tooltip: false,
+                smeupObject: {
+                    tipo: "CN",
+                    parametro: "COL",
+                    codice: "PLUTO",
+                    testo: "Pluto",
                 },
             },
-        ],
-    };
-    return table;
+        },
+    });
+}
+async function throwError(_fun, _context, _printer) {
+    throw new Error("Dummy error");
 }
 export default JS_00_01;