nesoi 3.0.0 → 3.0.3

package/lib/engine/util/path.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Path = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+class Path {
+    static expandWildcard(str) {
+        const abs = path.isAbsolute(str);
+        const nodes = str.split(path.sep);
+        if (nodes.length === 1) {
+            return [
+                path.resolve(str)
+            ];
+        }
+        const step = {
+            root: abs ? nodes[0] + path.sep : nodes[0],
+            next: nodes.slice(1)
+        };
+        const paths = [];
+        let steps = [step];
+        while (steps.length) {
+            const nextSteps = [];
+            for (const step of steps) {
+                if (step.next.length === 0 || step.next[0].length === 0) {
+                    paths.push(step.root);
+                    continue;
+                }
+                const nextNext = step.next.slice(1);
+                if (step.next[0] === '*') {
+                    if (fs.lstatSync(step.root).isDirectory()) {
+                        fs.readdirSync(step.root, { withFileTypes: true })
+                            .forEach(node => {
+                            const nextRoot = path.resolve(step.root, node.name);
+                            nextSteps.push({
+                                root: nextRoot,
+                                next: nextNext
+                            });
+                        });
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                else {
+                    const nextRoot = path.resolve(step.root, step.next[0]);
+                    if (fs.existsSync(nextRoot)) {
+                        nextSteps.push({
+                            root: nextRoot,
+                            next: nextNext
+                        });
+                    }
+                }
+            }
+            steps = nextSteps;
+        }
+        return paths;
+    }
+}
+exports.Path = Path;

package/lib/engine/util/rules.d.ts

@@ -0,0 +1,4 @@
+export declare const requiredIf: (key: string, val: any, error: string) => ($: {
+    value?: any;
+    raw: Record<string, any>;
+}) => string | true;

package/lib/engine/util/rules.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requiredIf = void 0;
+const requiredIf = (key, val, error) => {
+    return ($) => {
+        if ($.value)
+            return true;
+        return $.raw[key] !== val
+            || error;
+    };
+};
+exports.requiredIf = requiredIf;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "nesoi",
-    "version": "3.0.0",
+    "version": "3.0.3",
     "description": "Declarative framework for data-driven applications",
     "repository": {
         "type": "git",

package/tools/compile.js

@@ -40,8 +40,8 @@ const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const node_util_1 = require("node:util");
 const compiler_1 = require("../lib/compiler/compiler");
-const log_1 = require("../src/engine/util/log");
-const console_1 = __importDefault(require("../src/engine/util/console"));
+const log_1 = require("../lib/engine/util/log");
+const console_1 = __importDefault(require("../lib/engine/util/console"));
 log_1.Log.level = 'info';
 /**
  * [ compile ]

package/tools/dotenv.d.ts

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

package/tools/dotenv.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = require("../lib/engine/util/dotenv");
+dotenv_1.DotEnv.load();

package/tools/joaquin/job.d.ts

@@ -3,19 +3,19 @@ import { AnyMessage } from "../../src/elements/entities/message/message";
 import { NesoiError } from "../../src/engine/data/error";
 export declare function expectJob(def: ($: AnyJobBuilder) => any): {
     onRaw(_raw: {
-        $: string;
+        $?: string;
         [x: string]: any;
     }): {
         toResolve(value: ($: {
             raw?: {
-                $: string;
+                $?: string;
                 [x: string]: any;
             };
             msg?: AnyMessage;
         }) => any): Promise<void>;
         toReject(error: ($: {
             raw?: {
-                $: string;
+                $?: string;
                 [x: string]: any;
             };
             msg?: AnyMessage;
@@ -24,14 +24,14 @@ export declare function expectJob(def: ($: AnyJobBuilder) => any): {
     onMessage(_msg: AnyMessage): {
         toResolve(value: ($: {
             raw?: {
-                $: string;
+                $?: string;
                 [x: string]: any;
             };
             msg?: AnyMessage;
         }) => any): Promise<void>;
         toReject(error: ($: {
             raw?: {
-                $: string;
+                $?: string;
                 [x: string]: any;
             };
             msg?: AnyMessage;

package/tools/joaquin/mock.d.ts

@@ -1,5 +1,8 @@
-import { $Bucket, $Module, $Space } from "../../src/elements";
+import { $Bucket, $Message, $Module, $Space } from "../../src/elements";
 import { Daemon } from "../../src/engine/daemon";
+import { NesoiDate } from "../../src/engine/data/date";
+import { NesoiDatetime } from "../../src/engine/data/datetime";
+import { NesoiDecimal } from "../../src/engine/data/decimal";
 import { DeepPartial } from "../../src/engine/util/deep";
 export declare class BucketMockObj<$ extends $Bucket, T> {
     private module;
@@ -14,7 +17,6 @@ export declare class BucketMockObj<$ extends $Bucket, T> {
     private makeObj;
     private makeList;
     private makeField;
-    private makeString;
 }
 declare class BucketMock<M extends $Module, $ extends $Bucket> {
     private module;
@@ -22,7 +24,26 @@ declare class BucketMock<M extends $Module, $ extends $Bucket> {
     constructor(module: M['name'], bucket: keyof M['buckets']);
     obj<O extends DeepPartial<$['#data']> | undefined>(overrides?: O): BucketMockObj<$, undefined extends O ? $["#data"] : Omit<$["#data"], keyof O> & O>;
 }
+declare class MessageMock<M extends $Module, $ extends $Message> {
+    private module;
+    private messageName;
+    private message?;
+    constructor(module: M['name'], messageName: keyof M['messages']);
+    raw<O extends DeepPartial<$['#raw']> | undefined>(daemon: Daemon<any, any>, overrides?: O): any;
+    private bindMessage;
+    private makeObj;
+    private makeList;
+    private makeField;
+}
 export declare class Mock<Space extends $Space = $Space> {
     bucket<ModuleName extends keyof Space['modules'], BucketName extends keyof Space['modules'][ModuleName]['buckets'], Module extends Space['modules'][ModuleName], Bucket extends Space['modules'][ModuleName]['buckets'][BucketName]>(module: ModuleName, bucket: BucketName): BucketMock<Module, Bucket>;
+    message<ModuleName extends keyof Space['modules'], MessageName extends keyof Space['modules'][ModuleName]['messages'], Module extends Space['modules'][ModuleName], Message extends Space['modules'][ModuleName]['messages'][MessageName]>(module: ModuleName, message: MessageName): MessageMock<Module, Message>;
+    static boolean(): boolean;
+    static date(): NesoiDate;
+    static datetime(): NesoiDatetime;
+    static decimal(): NesoiDecimal;
+    static float(): number;
+    static int(): number;
+    static string(): string;
 }
 export {};

package/tools/joaquin/mock.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mock = exports.BucketMockObj = void 0;
-const daemon_1 = require("../../src/engine/daemon");
-const date_1 = require("../../src/engine/data/date");
-const datetime_1 = require("../../src/engine/data/datetime");
-const decimal_1 = require("../../src/engine/data/decimal");
+const daemon_1 = require("../../lib/engine/daemon");
+const date_1 = require("../../lib/engine/data/date");
+const datetime_1 = require("../../lib/engine/data/datetime");
+const decimal_1 = require("../../lib/engine/data/decimal");
 class BucketMockObj {
     constructor(module, bucketName, overrides) {
         this.module = module;
@@ -53,7 +53,7 @@ class BucketMockObj {
     makeList(field, overrides) {
         const list = [];
         for (let i = 0; i < 3; i++) {
-            list.append(this.makeField(field, overrides));
+            list.push(this.makeField(field, overrides));
         }
         return list;
     }
@@ -62,53 +62,45 @@ class BucketMockObj {
             return [true, false][Math.floor(Math.random() * 2)];
         }
         else if (field.type === 'date') {
-            return date_1.NesoiDate.now();
+            return Mock.date();
         }
         else if (field.type === 'datetime') {
-            return datetime_1.NesoiDatetime.now();
+            return Mock.datetime();
         }
         else if (field.type === 'decimal') {
-            return new decimal_1.Decimal(`${Math.floor(Math.random() * 999)}.${Math.floor(Math.random() * 999)}`);
+            return Mock.decimal();
         }
         else if (field.type === 'dict') {
             const dict = {};
             for (let i = 0; i < 3; i++) {
-                dict[this.makeString()] = this.makeField(field.children.__dict);
+                dict[Mock.string()] = this.makeField(field.children.__dict);
             }
             return dict;
         }
         else if (field.type === 'enum') {
-            return field._enum.options[Math.floor(Math.random() * field._enum.options.length)];
+            return field.meta.enum.options[Math.floor(Math.random() * field.meta.enum.options.length)];
         }
         else if (field.type === 'file') {
             // TODO
             return undefined;
         }
         else if (field.type === 'float') {
-            return Math.random();
+            return Mock.float();
         }
         else if (field.type === 'int') {
-            return Math.floor(Math.random() * 999);
+            return Mock.int();
         }
         else if (field.type === 'obj') {
             return this.makeObj(field.children, overrides);
         }
         else if (field.type === 'string') {
-            return this.makeString();
+            return Mock.string();
         }
         else if (field.type === 'unknown') {
             // TODO
             return undefined;
         }
     }
-    makeString() {
-        const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
-        let str = 'TEST_';
-        for (let i = 0; i < 8; i++) {
-            str += charset[Math.floor(Math.random() * charset.length)];
-        }
-        return str;
-    }
 }
 exports.BucketMockObj = BucketMockObj;
 class BucketMock {
@@ -120,9 +112,123 @@ class BucketMock {
         return new BucketMockObj(this.module, this.bucket, overrides);
     }
 }
+class MessageMock {
+    constructor(module, messageName) {
+        this.module = module;
+        this.messageName = messageName;
+    }
+    raw(daemon, overrides) {
+        if (!this.message)
+            this.bindMessage(daemon);
+        return this.makeObj(this.message?.schema.template.fields || {}, overrides);
+    }
+    bindMessage(daemon) {
+        this.message = daemon_1.Daemon.getModule(daemon, this.module)
+            .messages[this.messageName];
+    }
+    makeObj(fields, overrides) {
+        const obj = {};
+        for (const f in fields) {
+            if (overrides && f in overrides) {
+                obj[f] = overrides[f];
+            }
+            else {
+                const field = fields[f];
+                if (field.array) {
+                    obj[f] = this.makeList(field, overrides?.[f]);
+                }
+                else {
+                    obj[f] = this.makeField(field, overrides?.[f]);
+                }
+            }
+        }
+        return obj;
+    }
+    makeList(field, overrides) {
+        const list = [];
+        for (let i = 0; i < 3; i++) {
+            list.push(this.makeField(field, overrides));
+        }
+        return list;
+    }
+    makeField(field, overrides) {
+        if (field.type === 'boolean') {
+            return [true, false][Math.floor(Math.random() * 2)];
+        }
+        else if (field.type === 'date') {
+            return Mock.date();
+        }
+        else if (field.type === 'datetime') {
+            return Mock.datetime();
+        }
+        else if (field.type === 'decimal') {
+            return Mock.decimal();
+        }
+        else if (field.type === 'dict') {
+            const dict = {};
+            for (let i = 0; i < 3; i++) {
+                dict[Mock.string()] = this.makeField(field.children.__dict);
+            }
+            return dict;
+        }
+        else if (field.type === 'enum') {
+            // TODO
+            return 'TODO';
+        }
+        else if (field.type === 'file') {
+            // TODO
+            return undefined;
+        }
+        else if (field.type === 'float') {
+            return Mock.float();
+        }
+        else if (field.type === 'int') {
+            return Mock.int();
+        }
+        else if (field.type === 'obj') {
+            return this.makeObj(field.children, overrides);
+        }
+        else if (field.type === 'string') {
+            return Mock.string();
+        }
+        else if (field.type === 'unknown') {
+            // TODO
+            return undefined;
+        }
+    }
+}
 class Mock {
     bucket(module, bucket) {
         return new BucketMock(module, bucket);
     }
+    message(module, message) {
+        return new MessageMock(module, message);
+    }
+    static boolean() {
+        return [true, false][Math.floor(Math.random() * 2)];
+    }
+    static date() {
+        return date_1.NesoiDate.now();
+    }
+    static datetime() {
+        return datetime_1.NesoiDatetime.now();
+    }
+    static decimal() {
+        return new decimal_1.NesoiDecimal(`${Math.floor(Math.random() * 999)}.${Math.floor(Math.random() * 999)}`);
+    }
+    static float() {
+        return Math.random();
+    }
+    static int() {
+        return Math.floor(Math.random() * 999);
+    }
+    static string() {
+        const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+        let str = 'TEST_';
+        for (let i = 0; i < 8; i++) {
+            str += charset[Math.floor(Math.random() * charset.length)];
+        }
+        return str;
+    }
 }
 exports.Mock = Mock;