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

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/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;
+}

package/lib/utils/smeupDataStructureWriter.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import stream from "stream";
+import { SmeupMessage } from "../types/data-structures/smeupDataStructure.js";
+import { SmeupColumn, SmeupRow } from "../types/data-structures/smeupTable.js";
+import { SmeupTreeNode } from "../types/data-structures/smeupTree.js";
+import { Fun } from "../types/general.js";
+export declare class SmeupDataStructureWriter {
+    private out;
+    private initalTimestamp;
+    private messages;
+    private columns;
+    private firstElement;
+    private lastElementWritten;
+    private isInitializationWritten;
+    private isFinalizationWritten;
+    private isColumnWritten;
+    private isRowWritten;
+    private isNodeWritten;
+    constructor(out: stream.Writable);
+    writeDataStructureInitialization(fun: Fun): void;
+    writeDataStructureFinalization(fun: Fun): void;
+    writeTreeNode(node: SmeupTreeNode): void;
+    writeColumns(columns: SmeupColumn[]): void;
+    writeColumn(col: SmeupColumn): void;
+    writeRow(row: SmeupRow): void;
+    writeMessage(message: SmeupMessage): void;
+    getColumns(): SmeupColumn[];
+    getMessages(): SmeupMessage[];
+}

package/lib/utils/smeupDataStructureWriter.js

@@ -0,0 +1,158 @@
+import { SmeupDataStructureType, getSmeupDataStructureType, } from "../types/data-structures/smeupDataStructure.js";
+var DATA_TYPE;
+(function (DATA_TYPE) {
+    DATA_TYPE["COLUMN"] = "COLUMN";
+    DATA_TYPE["ROW"] = "ROW";
+    DATA_TYPE["NODE"] = "NODE";
+})(DATA_TYPE || (DATA_TYPE = {}));
+export class SmeupDataStructureWriter {
+    out;
+    initalTimestamp;
+    messages = [];
+    columns = [];
+    firstElement = true;
+    lastElementWritten;
+    isInitializationWritten = false;
+    isFinalizationWritten = false;
+    isColumnWritten = false;
+    isRowWritten = false;
+    isNodeWritten = false;
+    constructor(out) {
+        this.initalTimestamp = new Date();
+        this.out = out;
+    }
+    writeDataStructureInitialization(fun) {
+        if (!this.isInitializationWritten) {
+            this.initalTimestamp = new Date();
+            const type = getSmeupDataStructureType(fun);
+            this.out.write(utf8Encode("{"));
+            this.out.write(utf8Encode(`"type": "${type}"`));
+            this.isInitializationWritten = true;
+        }
+    }
+    writeDataStructureFinalization(fun) {
+        if (!this.isFinalizationWritten) {
+            const type = getSmeupDataStructureType(fun);
+            switch (type) {
+                case SmeupDataStructureType.SmeupTree:
+                    if (this.lastElementWritten != null) {
+                        // close rows, columns or messages
+                        this.out.write(utf8Encode("]"));
+                    }
+                    if (!this.isNodeWritten) {
+                        this.out.write(utf8Encode(`,"children":[]`));
+                    }
+                    break;
+                case SmeupDataStructureType.SmeupTable:
+                    // close rows or messages
+                    if (this.lastElementWritten != null) {
+                        // close rows, columns
+                        this.out.write(utf8Encode("]"));
+                    }
+                    if (!this.isColumnWritten) {
+                        this.out.write(utf8Encode(`,"columns":[]`));
+                    }
+                    if (!this.isRowWritten) {
+                        this.out.write(utf8Encode(`,"rows":[]`));
+                    }
+                    break;
+            }
+            // messages
+            this.out.write(utf8Encode(`,"messages":${JSON.stringify(this.getMessages())}`));
+            // debug info
+            const finalTimestamp = new Date();
+            const debugInfo = {
+                initialTimestamp: this.initalTimestamp.toISOString(),
+                finalTimestamp: finalTimestamp.toISOString(),
+                executionTime_ms: finalTimestamp.getTime() - this.initalTimestamp.getTime(),
+            };
+            this.out.write(utf8Encode(`,"debugInfo":${JSON.stringify(debugInfo)}`));
+            this.out.write(utf8Encode("}"));
+            this.out.end();
+            this.isFinalizationWritten = true;
+        }
+    }
+    writeTreeNode(node) {
+        if (this.lastElementWritten != null) {
+            if (this.lastElementWritten != DATA_TYPE.NODE) {
+                // close columns/messages/actions... array
+                this.out.write(utf8Encode("]"));
+                // children init
+                this.out.write(utf8Encode(`,"children": [`));
+                this.firstElement = true;
+            }
+        }
+        else {
+            // children init
+            this.out.write(utf8Encode(`,"children": [`));
+            this.firstElement = true;
+        }
+        // handle comma
+        if (!this.firstElement) {
+            this.out.write(utf8Encode(","));
+        }
+        this.out.write(utf8Encode(JSON.stringify(node)));
+        this.firstElement = false;
+        this.lastElementWritten = DATA_TYPE.NODE;
+        this.isNodeWritten = true;
+    }
+    writeColumns(columns) {
+        columns.forEach((col) => {
+            this.writeColumn(col);
+        });
+    }
+    writeColumn(col) {
+        if (this.lastElementWritten == null) {
+            // column init
+            this.out.write(utf8Encode(',"columns": ['));
+            this.firstElement = true;
+        }
+        // handle comma
+        if (!this.firstElement) {
+            this.out.write(utf8Encode(","));
+        }
+        this.out.write(utf8Encode(JSON.stringify(col)));
+        this.firstElement = false;
+        this.lastElementWritten = DATA_TYPE.COLUMN;
+        this.isColumnWritten = true;
+        // add to arraylist
+        this.columns.push(col);
+    }
+    writeRow(row) {
+        if (this.lastElementWritten != null) {
+            if (this.lastElementWritten != DATA_TYPE.ROW) {
+                // close columns/messages/actions... array
+                this.out.write(utf8Encode("]"));
+                // rows init
+                this.out.write(utf8Encode(`,"rows": [`));
+                this.firstElement = true;
+            }
+        }
+        else {
+            // rows init
+            this.out.write(utf8Encode(`,"rows": [`));
+            this.firstElement = true;
+        }
+        // handle comma
+        if (!this.firstElement) {
+            this.out.write(utf8Encode(","));
+        }
+        // write row
+        this.out.write(utf8Encode(JSON.stringify(row)));
+        this.firstElement = false;
+        this.lastElementWritten = DATA_TYPE.ROW;
+        this.isRowWritten = true;
+    }
+    writeMessage(message) {
+        this.messages.push(message);
+    }
+    getColumns() {
+        return this.columns;
+    }
+    getMessages() {
+        return this.messages;
+    }
+}
+function utf8Encode(s) {
+    return Buffer.from(s, "utf-8");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sme.up/kokos-sdk-node",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Kokos SDK Node.js",
   "author": "Smeup LAB <info@smeup.com> (https://www.smeup.com/)",
   "type": "module",
@@ -18,15 +18,12 @@
     "package.json",
     "tsconfig.json"
   ],
-  "bin": {
-    "kokos": "./bin/kokos.js"
-  },
   "scripts": {
     "clean": "rimraf lib",
     "test": "NODE_ENV=test jest",
     "build": "npm run clean && tsc",
-    "start:restapi": "NODE_ENV=production node ./lib/entrypoint/restapi/index.js",
-    "dev:restapi": "NODE_ENV=development nodemon --watch './**/*.ts' --exec node --experimental-specifier-resolution=node --loader ts-node/esm ./src/entrypoint/restapi/index.ts"
+    "start": "NODE_ENV=production node ./lib/entrypoint/restapi/index.js",
+    "dev": "NODE_ENV=development nodemon --watch './**/*.ts' --exec node --experimental-specifier-resolution=node --loader ts-node/esm ./src/entrypoint/restapi/index.ts"
   },
   "repository": {
     "type": "git",
@@ -42,7 +39,8 @@
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.0",
     "express": "^4.18.2",
-    "nodemon": "^2.0.22",
+    "js-yaml": "^4.1.0",
+    "nodemon": "^3.0.1",
     "rimraf": "^4.4.1",
     "ts-node": "^10.9.1",
     "typescript": "^4.9.4"
@@ -50,6 +48,7 @@
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/jest": "^29.5.0",
+    "@types/js-yaml": "^4.0.9",
     "axios": "^1.3.4",
     "jest": "^29.5.0",
     "ts-jest": "^29.0.5"

package/tsconfig.json

@@ -7,6 +7,7 @@
 		"rootDir": "./src",
 		"moduleResolution": "node",
 		"alwaysStrict": true,
+		"strict": true,
 		"noImplicitAny": true,
 		"experimentalDecorators": true,
 		"emitDecoratorMetadata": true,

package/bin/kokos.js

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-
-// get argument
-const action = process.argv[2];
-
-switch (action) {
-  // generic actions
-  case "init":
-    import("../scripts/init.js");
-    break;
-  case "build":
-    import("../scripts/build.js");
-    break;
-  // rest api actions
-  case "dev:restapi":
-    import("../scripts/restapi/dev.js");
-    break;
-  case "start:restapi":
-    import("../scripts/restapi/start.js");
-    break;
-  case "build-image:restapi":
-    import("../scripts/restapi/build-image-restapi.js");
-    break;
-  default:
-    console.error("Operation not permitted");
-}

package/docker/restapi/Dockerfile

@@ -1,14 +0,0 @@
-FROM node:18-slim AS builder
-WORKDIR /app
-COPY package*.json ./
-RUN npm install
-COPY . .
-RUN npm run build
-
-FROM node:18-slim AS server
-WORKDIR /app
-COPY package* ./
-RUN npm install
-COPY --from=builder ./app/lib ./lib
-EXPOSE 3000
-CMD ["npm", "run", "start:restapi"]