@sme.up/kokos-sdk-node 0.0.3 → 0.0.6

package/lib/entrypoint/restapi/restapi.js

@@ -0,0 +1,149 @@
+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 { Format, LOGGER, Level, 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,
+        },
+        logger: {
+            format: Format.TXT,
+            level: Level.DEBUG,
+        },
+    });
+}
+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,26 @@
+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;
+    debug(message: string): void;
+    error(error: Error): void;
+    private _log;
+}
+export declare const LOGGER: Logger;
+export {};

package/lib/logger/logger.js

@@ -0,0 +1,87 @@
+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);
+    }
+    debug(message) {
+        this._log(Level.DEBUG, 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,91 +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,
-        messages: [
-            {
-                gravity: "INFO",
-                message: "Info message. CN;COL;PIPPO",
-                mode: "TN",
-            }
-        ],
-        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,
-        messages: [
-            {
-                gravity: "INFO",
-                message: "Info message. CN;COL;PIPPO",
-                mode: "TN",
-            },
-            {
-                gravity: "WARNING",
-                message: "Warning message. CN;COL;PLUTO",
-                mode: "PM",
-            },
-            {
-                gravity: "ERROR",
-                message: "Error message.",
-                mode: "PN",
-            }
-        ],
-        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;

package/lib/types/data-structures/smeupDataStructure.d.ts

@@ -1,9 +1,11 @@
+import { Fun } from "../general.js";
 /**
  * Smeup data structure
  */
 export interface SmeupDataStructure {
     type: SmeupDataStructureType;
     messages: SmeupMessage[];
+    debugInfo: DebugInfo;
 }
 /**
  * SmeupDataStructure types
@@ -12,7 +14,16 @@ export declare enum SmeupDataStructureType {
     /** Smeup table (EXB) */
     SmeupTable = "SmeupTable",
     /** Smeup tree node (TRE) */
-    SmeupTree = "SmeupTreeNode"
+    SmeupTree = "SmeupTreeNode",
+    /** Smeup feedback (FBK) */
+    SmeupFeedback = "SmeupFeedback"
+}
+export declare function getSmeupDataStructureType(fun: Fun): SmeupDataStructureType;
+/**
+ * Smeup data structure
+ */
+export interface SmeupFeedback extends SmeupDataStructure {
+    type: SmeupDataStructureType.SmeupFeedback;
 }
 /**
  * SmeupMessage type
@@ -30,4 +41,18 @@ export declare const SMEUP_MESSAGE_GRAVITY: {
     readonly ERROR: "ERROR";
     readonly WARNING: "WARNING";
 };
-export type SmeupMessageGravity = typeof SMEUP_MESSAGE_GRAVITY[keyof typeof SMEUP_MESSAGE_GRAVITY];
+type SmeupMessageGravity = (typeof SMEUP_MESSAGE_GRAVITY)[keyof typeof SMEUP_MESSAGE_GRAVITY];
+/**
+ * SmeupMessage Mode
+ */
+export declare const SMEUP_MESSAGE_MODE: {
+    readonly PM: "PM";
+    readonly PN: "PN";
+    readonly TN: "TN";
+};
+export interface DebugInfo {
+    executionTime_ms: number;
+    initialTimestamp: string;
+    finalTimestamp: string;
+}
+export {};

package/lib/types/data-structures/smeupDataStructure.js

@@ -7,8 +7,21 @@ export var SmeupDataStructureType;
     SmeupDataStructureType["SmeupTable"] = "SmeupTable";
     /** Smeup tree node (TRE) */
     SmeupDataStructureType["SmeupTree"] = "SmeupTreeNode";
+    /** Smeup feedback (FBK) */
+    SmeupDataStructureType["SmeupFeedback"] = "SmeupFeedback";
 })(SmeupDataStructureType || (SmeupDataStructureType = {}));
-;
+export function getSmeupDataStructureType(fun) {
+    switch (fun.component) {
+        case "TRE":
+            return SmeupDataStructureType.SmeupTree;
+        case "EXB":
+            return SmeupDataStructureType.SmeupTable;
+        case "FBK":
+            return SmeupDataStructureType.SmeupFeedback;
+        default:
+            throw new Error(`${fun.component} not correspond to a valid SmeupDataStrcuture type`);
+    }
+}
 /**
  * SmeupMessage Gravity
  */
@@ -17,3 +30,11 @@ export const SMEUP_MESSAGE_GRAVITY = {
     ERROR: "ERROR",
     WARNING: "WARNING",
 };
+/**
+ * SmeupMessage Mode
+ */
+export const SMEUP_MESSAGE_MODE = {
+    PM: "PM",
+    PN: "PN",
+    TN: "TN",
+};

package/lib/types/data-structures/smeupObject.d.ts

@@ -3,9 +3,9 @@
  */
 export interface SmeupObject {
     /** type (T) */
-    tipo: string;
+    tipo?: string;
     /** parameter (P) */
-    parametro: string;
+    parametro?: string;
     /** code (K) */
     codice: string;
     /** text (D) */

package/lib/types/data-structures/smeupTree.d.ts

@@ -14,7 +14,7 @@ export interface SmeupTree extends SmeupDataStructure {
  * Smeup Tree Node (child node)
  */
 export interface SmeupTreeNode {
-    children: SmeupTreeNode[];
+    children?: SmeupTreeNode[];
     content: SmeupObject;
     columns?: SmeupColumn[];
     row?: SmeupRow;

package/lib/types/general.d.ts

@@ -1,4 +1,21 @@
-import { SmeupDataStructure } from "./data-structures/smeupDataStructure.js";
+import { SmeupDataStructureWriter } from "../utils/smeupDataStructureWriter.js";
+import { Format, Level } from "../logger/logger.js";
+export declare class ErrorWithStatus extends Error {
+    status: number;
+    constructor(message: string, status: number);
+}
+/**
+ * Micro Executor base config. To personalize the configuration you can extend this interface
+ */
+export interface MicroExecutorConfiguration {
+    server: {
+        port: 8011 | number;
+    };
+    logger: {
+        format: Format;
+        level: Level;
+    };
+}
 /**
  * Fun Object
  */
@@ -61,5 +78,5 @@ export interface KokosService {
  * Kokos Service Method
  */
 export interface KokosServiceMethods {
-    [key: string]: (fun: Fun, context: ExecutionContext) => Promise<SmeupDataStructure>;
+    [key: string]: (fun: Fun, context: ExecutionContext, printer: SmeupDataStructureWriter) => Promise<void>;
 }

package/lib/types/general.js

@@ -8,6 +8,13 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { IsObject, IsOptional, IsString, ValidateNested, } from "class-validator";
+export class ErrorWithStatus extends Error {
+    status = 500;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
 /**
  * Fun Object
  */

package/lib/utils/fun.d.ts

@@ -0,0 +1,3 @@
+import { Fun, FunObject } from "../types/general";
+export declare function funToString(fun: Fun): string;
+export declare function funObjectToString(obj: FunObject): string;

package/lib/utils/fun.js

@@ -0,0 +1,6 @@
+export function funToString(fun) {
+    return `F(${fun.component};${fun.service};${fun.function}) ${fun.obj1 && "1(" + funObjectToString(fun.obj1) + ")"} ${fun.obj2 && "2(" + funObjectToString(fun.obj2) + ")"} ${fun.obj3 && "3(" + funObjectToString(fun.obj3) + ")"} ${fun.obj4 && "4(" + funObjectToString(fun.obj4) + ")"} ${fun.obj5 && "5(" + funObjectToString(fun.obj5) + ")"} ${fun.obj6 && "6(" + funObjectToString(fun.obj6) + ")"} ${fun.P && "P(" + fun.P + ")"} ${fun.INPUT && "INPUT(" + fun.INPUT + ")"}`;
+}
+export function funObjectToString(obj) {
+    return `${obj.t ? obj.t : ""};${obj.p ? obj.p : ""};${obj.k ? obj.k : ""}`;
+}

package/lib/utils/path.js

@@ -10,7 +10,7 @@ export function getProjectRoot() {
         const parentDir = path.dirname(dir);
         if (dir === parentDir) {
             // Reached the root directory without finding package.json
-            return null;
+            return "";
         }
         dir = parentDir;
     }

package/lib/utils/regex.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parse key(value) expression NB. Nested brackets must be even
+ *
+ * @param expression
+ * @return
+ */
+export declare function parseKeyValueBetweenBrackets(expression: string): {
+    [key: string]: string;
+};

package/lib/utils/regex.js

@@ -0,0 +1,53 @@
+/**
+ * Parse key(value) expression NB. Nested brackets must be even
+ *
+ * @param expression
+ * @return
+ */
+export function parseKeyValueBetweenBrackets(expression) {
+    const map = {};
+    let key = "";
+    let value = "";
+    let bracketsCount = 0;
+    let isKey = true;
+    for (const c of expression) {
+        if (isKey && c !== "(" && c !== ")") {
+            // Check and accumulate key
+            key += c;
+        }
+        else {
+            if (c === "(") {
+                if (bracketsCount === 0) {
+                    // Start value expression
+                    isKey = false;
+                }
+                else {
+                    // Continue accumulating value expression
+                    value += c;
+                }
+                bracketsCount++;
+            }
+            else {
+                if (c === ")") {
+                    if (bracketsCount === 1) {
+                        // End value expression
+                        map[key.trim()] = value;
+                        isKey = true;
+                        key = "";
+                        value = "";
+                    }
+                    else {
+                        // Continue accumulating value expression
+                        value += c;
+                    }
+                    bracketsCount--;
+                }
+                else {
+                    // Continue accumulating value expression
+                    value += c;
+                }
+            }
+        }
+    }
+    return map;
+}