@sme.up/kokos-sdk-node 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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";

package/lib/index.js

@@ -0,0 +1,9 @@
+/**
+ * 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";

package/lib/services/JS_00_01.d.ts

@@ -0,0 +1,3 @@
+import { KokosService } from "../types/general.js";
+declare const JS_00_01: KokosService;
+export default JS_00_01;

package/lib/services/JS_00_01.js

@@ -0,0 +1,67 @@
+import { SmeupDataStructureType } from "../types/data-structures/smeupDataStructure.js";
+const JS_00_01 = {
+    methods: {
+        "GET.TRE": getTree,
+        "GET.EXB": getTable,
+    },
+};
+async function getTree(fun, context) {
+    const tree = {
+        type: SmeupDataStructureType.SmeupTree,
+        children: [
+            {
+                children: [],
+                content: {
+                    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",
+                        },
+                    },
+                },
+            },
+        ],
+    };
+    return table;
+}
+export default JS_00_01;

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

@@ -0,0 +1,32 @@
+/**
+ * Smeup data structure
+ */
+export interface SmeupDataStructure {
+    type: SmeupDataStructureType;
+}
+/**
+ * SmeupDataStructure types
+ */
+export declare enum SmeupDataStructureType {
+    /** Smeup table (EXB) */
+    SmeupTable = "SmeupTable",
+    /** Smeup tree node (TRE) */
+    SmeupTree = "SmeupTreeNode"
+}
+/**
+ * SmeupMessage type
+ */
+export interface SmeupMessage {
+    gravity: SmeupMessageGravity;
+    message: string;
+    mode: string;
+}
+/**
+ * SmeupMessage Gravity
+ */
+export declare const SMEUP_MESSAGE_GRAVITY: {
+    readonly INFO: "INFO";
+    readonly ERROR: "ERROR";
+    readonly WARNING: "WARNING";
+};
+export type SmeupMessageGravity = typeof SMEUP_MESSAGE_GRAVITY[keyof typeof SMEUP_MESSAGE_GRAVITY];

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

@@ -0,0 +1,19 @@
+/**
+ * SmeupDataStructure types
+ */
+export var SmeupDataStructureType;
+(function (SmeupDataStructureType) {
+    /** Smeup table (EXB) */
+    SmeupDataStructureType["SmeupTable"] = "SmeupTable";
+    /** Smeup tree node (TRE) */
+    SmeupDataStructureType["SmeupTree"] = "SmeupTreeNode";
+})(SmeupDataStructureType || (SmeupDataStructureType = {}));
+;
+/**
+ * SmeupMessage Gravity
+ */
+export const SMEUP_MESSAGE_GRAVITY = {
+    INFO: "INFO",
+    ERROR: "ERROR",
+    WARNING: "WARNING",
+};

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

@@ -0,0 +1,21 @@
+/**
+ * Smeup object
+ */
+export interface SmeupObject {
+    /** type (T) */
+    tipo: string;
+    /** parameter (P) */
+    parametro: string;
+    /** code (K) */
+    codice: string;
+    /** text (D) */
+    testo?: string;
+    /** exec (E) */
+    exec?: string;
+    /** Field */
+    fld?: string;
+    /** Leaf */
+    leaf?: string;
+    /** i (I) */
+    i?: string;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,66 @@
+import { SmeupDataStructure, SmeupDataStructureType } from "./smeupDataStructure.js";
+import { SmeupObject } from "./smeupObject.js";
+/**
+ * SmeupTable (EXB)
+ */
+export interface SmeupTable extends SmeupDataStructure {
+    type: SmeupDataStructureType.SmeupTable;
+    columns: SmeupColumn[];
+    rows: SmeupRow[];
+}
+/**
+ * Column Data Type
+ */
+export interface SmeupColumn {
+    /** Name (code) */
+    code: string;
+    /** Group */
+    grp?: string;
+    /** Field length */
+    lun?: string;
+    canonicalForm?: string;
+    /** render component */
+    cmp?: string;
+    /**
+     * I: Input
+     * O: Output
+     * B: Input (???)
+     * H: Hide
+     * E: Autocomplete
+     * G: ???
+     *
+     */
+    io?: "I" | "O" | "B" | "H" | "G" | "E" | "";
+    tooltip?: boolean;
+    /** Visibile text */
+    text?: string;
+    sortMode?: string;
+    /**
+     * ASSE
+     * SERIE
+     */
+    fill?: "ASSE" | "SERIE";
+    /** Smeup object */
+    ogg?: string;
+    /** simple client validation */
+    validation?: string;
+    pfk?: string;
+    tfk?: string;
+    sfk?: string;
+}
+/**
+ * Row Data Type
+ */
+export interface SmeupRow {
+    fields: {
+        [index: string]: SmeupCell;
+    };
+}
+/** Cell */
+export interface SmeupCell {
+    /** name, refer to column name */
+    name: string;
+    /** smeup object */
+    smeupObject: SmeupObject;
+    tooltip?: boolean;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,21 @@
+import { SmeupDataStructure, SmeupDataStructureType } from "./smeupDataStructure.js";
+import { SmeupObject } from "./smeupObject.js";
+import { SmeupColumn, SmeupRow } from "./smeupTable.js";
+/**
+ * SmeupTree (TRE)
+ */
+export interface SmeupTree extends SmeupDataStructure {
+    type: SmeupDataStructureType.SmeupTree;
+    children: SmeupTreeNode[];
+    columns?: SmeupColumn[];
+    row?: SmeupRow;
+}
+/**
+ * Smeup Tree Node (child node)
+ */
+export interface SmeupTreeNode {
+    children: SmeupTreeNode[];
+    content: SmeupObject;
+    columns?: SmeupColumn[];
+    row?: SmeupRow;
+}

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

@@ -0,0 +1 @@
+export {};

package/lib/types/exceptions/application.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generic application exception
+ */
+export declare class ApplicationException extends Error {
+    status: number;
+    message: string;
+    constructor(status: number, message: string);
+}

package/lib/types/exceptions/application.js

@@ -0,0 +1,12 @@
+/**
+ * Generic application exception
+ */
+export class ApplicationException extends Error {
+    status;
+    message;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.message = message;
+    }
+}

package/lib/types/exceptions/execution.d.ts

@@ -0,0 +1,7 @@
+import { ApplicationException } from "./application.js";
+/**
+ * Execution Exception
+ */
+export declare class ExecutionException extends ApplicationException {
+    constructor(message: string, error?: Error);
+}

package/lib/types/exceptions/execution.js

@@ -0,0 +1,10 @@
+import { ApplicationException } from "./application.js";
+/**
+ * Execution Exception
+ */
+export class ExecutionException extends ApplicationException {
+    constructor(message, error) {
+        const errorMessage = error ? " - " + error.message : "";
+        super(500, message + errorMessage);
+    }
+}

package/lib/types/exceptions/validation.d.ts

@@ -0,0 +1,7 @@
+import { ApplicationException } from "./application.js";
+/**
+ * Validation Exception
+ */
+export declare class ValidationException extends ApplicationException {
+    constructor(message: string);
+}

package/lib/types/exceptions/validation.js

@@ -0,0 +1,9 @@
+import { ApplicationException } from "./application.js";
+/**
+ * Validation Exception
+ */
+export class ValidationException extends ApplicationException {
+    constructor(message) {
+        super(400, message);
+    }
+}

package/lib/types/general.d.ts

@@ -0,0 +1,65 @@
+import { SmeupDataStructure } from "./data-structures/smeupDataStructure.js";
+/**
+ * Fun Object
+ */
+export declare class FunObject {
+    t: string;
+    p: string;
+    k: string;
+}
+/**
+ * Fun
+ */
+export declare class Fun {
+    component: string;
+    service: string;
+    function: string;
+    obj1?: FunObject;
+    obj2?: FunObject;
+    obj3?: FunObject;
+    obj4?: FunObject;
+    obj5?: FunObject;
+    obj6?: FunObject;
+    P?: string;
+    INPUT?: string;
+}
+/**
+ * User Type
+ */
+export declare class User {
+    sessionId: string;
+    username: string;
+    environment: string;
+    device: string;
+}
+/**
+ * Execution Context
+ */
+export declare class ExecutionContext {
+    user: User;
+}
+/**
+ * Execute Fun payalod DTO
+ */
+export declare class ExecuteFunPayload {
+    fun: Fun;
+    context: ExecutionContext;
+}
+/**
+ * Type of Kokos Service ES Module
+ */
+export interface KokosServiceModule {
+    default: KokosService;
+}
+/**
+ * Kokos Service Interface
+ */
+export interface KokosService {
+    methods: KokosServiceMethods;
+}
+/**
+ * Kokos Service Method
+ */
+export interface KokosServiceMethods {
+    [key: string]: (fun: Fun, context: ExecutionContext) => Promise<SmeupDataStructure>;
+}

package/lib/types/general.js

@@ -0,0 +1,158 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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";
+/**
+ * Fun Object
+ */
+export class FunObject {
+    t;
+    p;
+    k;
+}
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], FunObject.prototype, "t", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], FunObject.prototype, "p", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], FunObject.prototype, "k", void 0);
+/**
+ * Fun
+ */
+export class Fun {
+    component;
+    service;
+    function;
+    obj1;
+    obj2;
+    obj3;
+    obj4;
+    obj5;
+    obj6;
+    P;
+    INPUT;
+}
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], Fun.prototype, "component", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], Fun.prototype, "service", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], Fun.prototype, "function", void 0);
+__decorate([
+    IsObject(),
+    IsOptional(),
+    ValidateNested(),
+    __metadata("design:type", FunObject)
+], Fun.prototype, "obj1", void 0);
+__decorate([
+    IsObject(),
+    IsOptional(),
+    ValidateNested(),
+    __metadata("design:type", FunObject)
+], Fun.prototype, "obj2", void 0);
+__decorate([
+    IsObject(),
+    IsOptional(),
+    ValidateNested(),
+    __metadata("design:type", FunObject)
+], Fun.prototype, "obj3", void 0);
+__decorate([
+    IsObject(),
+    IsOptional(),
+    ValidateNested(),
+    __metadata("design:type", FunObject)
+], Fun.prototype, "obj4", void 0);
+__decorate([
+    IsObject(),
+    IsOptional(),
+    ValidateNested(),
+    __metadata("design:type", FunObject)
+], Fun.prototype, "obj5", void 0);
+__decorate([
+    IsObject(),
+    IsOptional(),
+    ValidateNested(),
+    __metadata("design:type", FunObject)
+], Fun.prototype, "obj6", void 0);
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], Fun.prototype, "P", void 0);
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], Fun.prototype, "INPUT", void 0);
+/**
+ * User Type
+ */
+export class User {
+    sessionId;
+    username;
+    environment;
+    device;
+}
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], User.prototype, "sessionId", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], User.prototype, "username", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], User.prototype, "environment", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], User.prototype, "device", void 0);
+/**
+ * Execution Context
+ */
+export class ExecutionContext {
+    user;
+}
+__decorate([
+    IsObject(),
+    IsOptional(),
+    ValidateNested(),
+    __metadata("design:type", User)
+], ExecutionContext.prototype, "user", void 0);
+/**
+ * Execute Fun payalod DTO
+ */
+export class ExecuteFunPayload {
+    fun;
+    context;
+}
+__decorate([
+    IsObject(),
+    ValidateNested(),
+    __metadata("design:type", Fun)
+], ExecuteFunPayload.prototype, "fun", void 0);
+__decorate([
+    IsObject(),
+    ValidateNested(),
+    __metadata("design:type", ExecutionContext)
+], ExecuteFunPayload.prototype, "context", void 0);

package/lib/utils/path.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Get the project root
+ * @returns
+ */
+export declare function getProjectRoot(): string;

package/lib/utils/path.js

@@ -0,0 +1,28 @@
+import path from "path";
+import fs from "fs";
+/**
+ * Get the project root
+ * @returns
+ */
+export function getProjectRoot() {
+    let dir = process.cwd();
+    while (!containsFileOrFolder(dir, "package.json")) {
+        const parentDir = path.dirname(dir);
+        if (dir === parentDir) {
+            // Reached the root directory without finding package.json
+            return null;
+        }
+        dir = parentDir;
+    }
+    return dir;
+}
+function containsFileOrFolder(dir, name) {
+    const filePath = path.join(dir, name);
+    try {
+        const stats = fs.statSync(filePath);
+        return stats.isFile() || stats.isDirectory();
+    }
+    catch (error) {
+        return false;
+    }
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+	"name": "@sme.up/kokos-sdk-node",
+	"version": "0.0.1",
+	"description": "Node.js Kokos SDK",
+	"author": "Smeup LAB <info@smeup.com> (https://www.smeup.com/)",
+	"type": "module",
+	"exports": "./lib/index.js",
+	"module": "./lib/index.js",
+	"typings": "./lib/index.d.ts",
+	"files": [
+		"lib/",
+		"scripts/",
+		"bin/",
+		"docker/",
+		"init/",
+		"swagger/",
+		"docs/",
+		"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"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/smeup/kokos.git"
+	},
+	"license": "ISC",
+	"bugs": {
+		"url": "https://github.com/smeup/kokos/issues"
+	},
+	"homepage": "https://github.com/smeup/kokos#readme",
+	"dependencies": {
+		"@types/node": "^18.15.11",
+		"class-transformer": "^0.5.1",
+		"class-validator": "^0.14.0",
+		"express": "^4.18.2",
+		"nodemon": "^2.0.22",
+		"rimraf": "^4.4.1",
+		"ts-node": "^10.9.1",
+		"typescript": "^4.9.4"
+	},
+	"devDependencies": {
+		"@types/express": "^4.17.17",
+		"@types/jest": "^29.5.0",
+		"axios": "^1.3.4",
+		"jest": "^29.5.0",
+		"ts-jest": "^29.0.5"
+	},
+	"jest": {
+		"preset": "ts-jest/presets/default-esm",
+		"moduleNameMapper": {
+			"^(\\.{1,2}/.*)\\.js$": "$1"
+		}
+	}
+}

package/scripts/build.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { exec } from "child_process";
+
+/**
+ * BUILD
+ */
+
+// start production mode
+console.log("Start building");
+
+// build project with typescript compiler
+const build = exec("rimraf lib && tsc");
+
+// redirect build stdout to standard output
+build.stdout.pipe(process.stdout);
+// redirect build stderr to standard output
+build.stderr.pipe(process.stderr);
+
+if (build.pid) {
+  console.log(`Building...\nPress CTRL+C to exit\nPID: ${build.pid}`);
+}
+
+build.on("exit", function () {
+  console.log("Build successfull");
+});