nesoi 3.2.9 → 3.3.0

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

@@ -18,7 +18,7 @@ export declare class NesoiCrypto {
     };
     /**
      *
-     * @param {Buffer} password - The password to be used for generating key
+     * @param {string} password - The password to be used for generating key
      *
      */
     static getKeyFromPassword(password: string, salt: string): string;
@@ -30,12 +30,13 @@ export declare class NesoiCrypto {
     static encrypt(value: any, key: string): Promise<string>;
     /**
      *
-     * @param {Buffer} ciphertext - Cipher text
-     * @param {Buffer} key - The key to be used for decryption
+     * @param {string} ciphertext - Cipher text
+     * @param {string} key - The key to be used for decryption
      *
      * The caller of this function has the responsibility to clear
      * the Buffer after the decryption to prevent the message text
      * and the key from lingering in the memory
      */
     static decrypt(ciphertext: string, key: string): Promise<any>;
+    static createHmac(text: string, sigKey: string): string;
 }

package/lib/engine/util/crypto.js

@@ -1,5 +1,4 @@
 "use strict";
-// TODO: Jest breaks with crypto types.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 //@ts-nocheck
 var __importDefault = (this && this.__importDefault) || function (mod) {
@@ -7,11 +6,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NesoiCrypto = void 0;
+/* @nesoi:browser ignore-start */
 const crypto_1 = __importDefault(require("crypto"));
+/* @nesoi:browser ignore-end */
+/* @nesoi:browser add
+const crypto = (window.crypto || window.msCrypto);
+*/
+const random_1 = require("./random");
 class NesoiCrypto {
     /**
      *
-     * @param {Buffer} password - The password to be used for generating key
+     * @param {string} password - The password to be used for generating key
      *
      */
     static getKeyFromPassword(password, salt) {
@@ -26,7 +31,7 @@ class NesoiCrypto {
      * @param {string} key - The key to be used for encryption
      */
     static async encrypt(value, key) {
-        const iv = crypto_1.default.randomBytes(this.C.iv_bytes);
+        const iv = random_1.Random.bytes(this.C.iv_bytes);
         const aes_key = await crypto_1.default.subtle.importKey('raw', Buffer.from(key), 'AES-GCM', true, ['encrypt', 'decrypt']);
         const encrypted = await crypto_1.default.subtle.encrypt({
             name: 'AES-GCM',
@@ -37,8 +42,8 @@ class NesoiCrypto {
     }
     /**
      *
-     * @param {Buffer} ciphertext - Cipher text
-     * @param {Buffer} key - The key to be used for decryption
+     * @param {string} ciphertext - Cipher text
+     * @param {string} key - The key to be used for decryption
      *
      * The caller of this function has the responsibility to clear
      * the Buffer after the decryption to prevent the message text
@@ -57,6 +62,11 @@ class NesoiCrypto {
         const decoded = Buffer.from(decrypted).toString('utf8');
         return JSON.parse(decoded);
     }
+    static createHmac(text, sigKey) {
+        return crypto_1.default.createHmac('sha1', sigKey)
+            .update(text)
+            .digest('hex');
+    }
 }
 exports.NesoiCrypto = NesoiCrypto;
 NesoiCrypto.C = {

package/lib/engine/util/hash.js

@@ -5,7 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hash = void 0;
 const fs_1 = __importDefault(require("fs"));
+/* @nesoi:browser ignore-start */
 const crypto_1 = __importDefault(require("crypto"));
+/* @nesoi:browser ignore-end */
+/* @nesoi:browser add
+const crypto = (window.crypto || window.msCrypto);
+*/
 class Hash {
     static file(filepath, algorithm = 'sha256') {
         return new Promise(resolve => {

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

@@ -1,17 +1,15 @@
-import { $BlockType } from "../../elements/blocks/block.schema";
 declare const LogLevel: readonly ["off", "error", "warn", "info", "debug", "trace"];
 export type LogLevel = typeof LogLevel[number];
-export type LogScope = $BlockType | 'compiler' | 'trx' | 'daemon' | 'app' | 'module' | 'layer' | 'message' | 'bucket' | 'job' | 'resource' | 'controller' | 'queue' | 'topic' | 'constants' | 'externals' | 'nql' | 'inc.server' | 'inc.client';
-export declare function scopeTag(scope: LogScope, scope_id: string): string;
+export declare function scopeTag(scope: string, scope_id: string): string;
 export declare function anyScopeTag(scopeWithId: string): string;
 export declare class Log {
     static level: LogLevel;
     private static l;
-    static error(scope: LogScope, scope_id: string, message: string, obj?: Record<string, any>): void;
-    static warn(scope: LogScope, scope_id: string, message: string, obj?: Record<string, any>): void;
-    static info(scope: LogScope, scope_id: string, message: string, obj?: Record<string, any>): void;
-    static debug(scope: LogScope, scope_id: string, message: string, obj?: Record<string, any>): void;
-    static trace(scope: LogScope, scope_id: string, message: string, obj?: Record<string, any>): void;
+    static error(scope: string, scope_id: string, message: string, obj?: Record<string, any>): void;
+    static warn(scope: string, scope_id: string, message: string, obj?: Record<string, any>): void;
+    static info(scope: string, scope_id: string, message: string, obj?: Record<string, any>): void;
+    static debug(scope: string, scope_id: string, message: string, obj?: Record<string, any>): void;
+    static trace(scope: string, scope_id: string, message: string, obj?: Record<string, any>): void;
     private static push;
 }
 export {};

package/lib/engine/util/log.js

@@ -16,7 +16,7 @@ function scopeTag(scope, scope_id) {
         layer: 'lightgreen',
         virtual: 'lightgreen',
         constants: 'lightblue',
-        externals: 'lightblue',
+        externals: 'lightpurple',
         message: 'lightblue',
         bucket: 'lightblue',
         job: 'lightblue',

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

@@ -0,0 +1,37 @@
+import { ElementType } from "../../schema";
+import { Tag, TagType } from '../dependency';
+export type ParsedType = string | ({
+    [x: string]: ParsedType;
+} & {
+    __array?: boolean;
+    __optional?: boolean;
+});
+export declare class NameHelpers {
+    static nameLowToHigh(low: string): string;
+    static nameHighToLow(high: string): string;
+    static unabbrevName(name: string, context: string): string;
+    static parseRefName(refName: string): {
+        module: string;
+        name: string;
+    } | {
+        name: string;
+        module?: undefined;
+    };
+    static names(schema: {
+        $t: ElementType | TagType;
+        name: string;
+    }): {
+        low: string;
+        high: string;
+        type: string;
+    };
+    /**
+     * Return the type name (UpperCamel) of the element
+     * referenced by a dependency.
+     *
+     * @param dep A `$Dependency` instance
+     * @param fromModule Name of dependant module
+     * @returns The type name of the dependency
+     */
+    static tagType(tag: Tag, fromModule: string): string;
+}

package/lib/{compiler/helpers → engine/util}/name_helpers.js

@@ -19,11 +19,20 @@ class NameHelpers {
         }
         return name;
     }
+    static parseRefName(refName) {
+        if (refName.includes('::')) {
+            const [module, name] = refName.split('::');
+            return { module, name };
+        }
+        return { name: refName };
+    }
     static names(schema) {
         const lowName = schema.name;
         const highName = this.nameLowToHigh(lowName);
         const suffix = {
             'constants': 'Constants',
+            'constants.enum': 'ConstantsEnum',
+            'constants.value': 'ConstantsValue',
             'externals': 'Externals',
             'bucket': 'Bucket',
             'message': 'Message',
@@ -41,5 +50,29 @@ class NameHelpers {
             type: typeName
         };
     }
+    /**
+     * Return the type name (UpperCamel) of the element
+     * referenced by a dependency.
+     *
+     * @param dep A `$Dependency` instance
+     * @param fromModule Name of dependant module
+     * @returns The type name of the dependency
+     */
+    static tagType(tag, fromModule) {
+        if (tag.module !== fromModule) {
+            const moduleHigh = NameHelpers.nameLowToHigh(tag.module);
+            // WARN: this might break non-regular plural block types in the future
+            const el_t = tag.type + 's';
+            return `${moduleHigh}Module['${el_t}']['${tag.name}']`;
+        }
+        else {
+            if (tag.type === 'constants.enum' || tag.type === 'constants.value') {
+                throw new Error('Constants/Enums have no direct Type');
+            }
+            return NameHelpers
+                .names({ $t: tag.type, name: tag.name })
+                .type;
+        }
+    }
 }
 exports.NameHelpers = NameHelpers;

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

@@ -1,11 +1,12 @@
 import { NesoiDate } from '../data/date';
-import { $MessageTemplateField, $MessageTemplateFields } from '../../elements/entities/message/template/message_template.schema';
+import { $MessageTemplateField, $MessageTemplateFieldMeta, $MessageTemplateFields } from '../../elements/entities/message/template/message_template.schema';
 import { $Module, BucketName, ViewName } from "../../schema";
 import { AnyTrxNode } from '../transaction/trx_node';
 import { NesoiDecimal } from '../data/decimal';
 import { NesoiDatetime } from '../data/datetime';
 import { NesoiFile } from '../data/file';
 import { NesoiDuration } from '../data/duration';
+import { Tag } from '../dependency';
 export declare function parseBoolean(field: {
     pathRaw: string;
     alias: string;
@@ -30,7 +31,7 @@ export declare function parseEnum(raw: Record<string, any>, field: {
     pathRaw: string;
     name: string;
     alias: string;
-}, path: string[], value: any, options: string | readonly string[] | Record<string, any>, trx: AnyTrxNode): any;
+}, path: string[], value: any, meta: NonNullable<$MessageTemplateFieldMeta['enum']>, trx: AnyTrxNode): string;
 export declare function parseFile(field: {
     pathRaw: string;
     name: string;
@@ -46,7 +47,7 @@ export declare function parseFloat_(field: {
 export declare function parseId<M extends $Module, Name extends BucketName<M>, View extends ViewName<M['buckets'][Name]> | undefined>(field: {
     pathRaw: string;
     alias: string;
-}, path: string[], value: any, trx: AnyTrxNode, bucket: Name, type?: 'int' | 'string', view?: View): Promise<{
+}, path: string[], value: any, trx: AnyTrxNode, bucket: Tag, type?: 'int' | 'string', view?: View): Promise<{
     id: string | number;
     obj: any;
 }>;

package/lib/engine/util/parse.js

@@ -60,25 +60,18 @@ function parseDecimal(field, path, value) {
     }
     throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'decimal' });
 }
-function parseEnum(raw, field, path, value, options, trx) {
+function parseEnum(raw, field, path, value, meta, trx) {
     if (typeof value === 'string') {
-        if (typeof options === 'string') {
-            let enumName = options;
-            const enumPath = enumName.match(/(.*)\.\{(.*)\}$/);
+        if (meta.enumpath) {
             let _enum;
-            if (enumPath) {
-                const v = tree_1.Tree.get(raw, enumPath[2]);
-                enumName = enumPath[1] + '.' + v;
-                try {
-                    _enum = trx.enum(enumName);
-                }
-                catch {
-                    throw error_1.NesoiError.Message.InvalidEnumScope({ alias: field.alias, path: path.join('.'), value: v, fieldpath: enumPath[2] });
-                }
-            }
-            else {
+            const v = tree_1.Tree.get(raw, meta.enumpath[1]);
+            const enumName = meta.enumpath[0] + '.' + v;
+            try {
                 _enum = trx.enum(enumName);
             }
+            catch {
+                throw error_1.NesoiError.Message.InvalidEnumScope({ alias: field.alias, path: path.join('.'), value: v, fieldpath: meta.enumpath[1] });
+            }
             const keys = _enum.keys();
             if (keys.includes(value)) {
                 return value;
@@ -87,20 +80,12 @@ function parseEnum(raw, field, path, value, options, trx) {
                 throw error_1.NesoiError.Message.InvalidFieldEnumValue({ alias: field.alias, path: path.join('.'), value, type: 'enum', options: keys });
             }
         }
-        else if (Array.isArray(options)) {
-            if (options.includes(value)) {
+        else {
+            if (value in meta.options) {
                 return value;
             }
             else {
-                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ alias: field.alias, path: path.join('.'), value, type: 'enum', options });
-            }
-        }
-        else if (typeof options === 'object') {
-            if (value in options) {
-                return options[value];
-            }
-            else {
-                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ alias: field.alias, path: path.join('.'), value, type: 'enum', options: Object.keys(options) });
+                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ alias: field.alias, path: path.join('.'), value, type: 'enum', options: Object.keys(meta.options) });
             }
         }
     }
@@ -147,8 +132,8 @@ async function parseId(field, path, value, trx, bucket, type, view) {
     return {
         id: val,
         obj: view
-            ? await trx.bucket(bucket).viewOneOrFail(val, view)
-            : await trx.bucket(bucket).readOneOrFail(val)
+            ? await trx.bucket(bucket.short).viewOneOrFail(val, view)
+            : await trx.bucket(bucket.short).readOneOrFail(val)
     };
 }
 function parseInt_(field, path, value) {

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

@@ -1,3 +1,4 @@
 export declare class Path {
     static expandWildcard(str: string): string[];
+    static allFiles(dir: string, filelist?: string[]): string[];
 }

package/lib/engine/util/path.js

@@ -88,5 +88,19 @@ class Path {
         }
         return paths;
     }
+    static allFiles(dir, filelist = []) {
+        const files = fs.readdirSync(dir);
+        filelist ?? (filelist = []);
+        files.forEach(file => {
+            const p = path.join(dir, file);
+            if (fs.statSync(p).isDirectory()) {
+                filelist = this.allFiles(p, filelist);
+            }
+            else {
+                filelist.push(p);
+            }
+        });
+        return filelist;
+    }
 }
 exports.Path = Path;

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

@@ -0,0 +1,4 @@
+export declare class Random {
+    static uuid(): `${string}-${string}-${string}-${string}-${string}`;
+    static bytes(n: number): Buffer;
+}

package/lib/engine/util/random.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Random = void 0;
+/* @nesoi:browser ignore-start */
+const crypto_1 = __importDefault(require("crypto"));
+/* @nesoi:browser ignore-end */
+/* @nesoi:browser add
+const crypto = (window.crypto || window.msCrypto);
+*/
+class Random {
+    static uuid() {
+        return crypto_1.default.randomUUID();
+    }
+    static bytes(n) {
+        /* @nesoi:browser ignore-start */
+        return crypto_1.default.randomBytes(n);
+        /* @nesoi:browser ignore-end */
+        /* @nesoi:browser add
+        const QUOTA = 65536;
+        const a = new Uint8Array(n);
+        for (let i = 0; i < n; i += QUOTA) {
+            crypto.getRandomValues(a.subarray(i, i + Math.min(n - i, QUOTA)));
+        }
+        return a;
+        */
+    }
+}
+exports.Random = Random;

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

@@ -8,3 +8,11 @@ export type MergeUnion<T> = {
 export type UnionToIntersection<T> = {
     [K in T as K & string]: K;
 }[any];
+export type TypeAsObj = string | ({
+    [x: string]: TypeAsObj;
+} & {
+    __array?: boolean;
+    __optional?: boolean;
+    __or?: TypeAsObj;
+});
+export type ObjTypeAsObj = TypeAsObj & Record<string, any>;

package/lib/schema.d.ts

@@ -9,7 +9,7 @@ import { $Resource } from './elements/blocks/resource/resource.schema';
 import { $Queue } from './elements/blocks/queue/queue.schema';
 import { $Externals } from './elements/edge/externals/externals.schema';
 import { $Topic } from './elements/blocks/topic/topic.schema';
-export type BuilderType = 'constants' | 'externals' | 'message' | 'bucket' | 'job' | 'resource' | 'machine' | 'controller' | 'queue' | 'topic';
+export type ElementType = 'constants' | 'externals' | 'message' | 'bucket' | 'job' | 'resource' | 'machine' | 'controller' | 'queue' | 'topic';
 export type $Space = {
     authnUsers: {
         [x: string]: User;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "nesoi",
-    "version": "3.2.9",
+    "version": "3.3.0",
     "description": "Declarative framework for data-driven applications",
     "repository": {
         "type": "git",
@@ -17,5 +17,8 @@
     "homepage": "https://github.com/nesoi-org/nesoi#readme",
     "peerDependencies": {
         "@types/node": ">=20"
+    },
+    "dependencies": {
+        "@types/web": "^0.0.262"
     }
 }

package/tools/joaquin/bucket.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.givenBucket = givenBucket;
 exports.expectBucket = expectBucket;
 const bucket_builder_1 = require("../../src/elements/entities/bucket/bucket.builder");
-const inline_app_1 = require("../../src/engine/apps/inline.app");
+const inline_app_1 = require("../../src/engine/app/inline.app");
 const elements_1 = require("../../src/elements");
 function givenBucket(name, def) {
     const builder = new bucket_builder_1.BucketBuilder('test', name);

package/tools/joaquin/job.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectJob = expectJob;
 const job_builder_1 = require("../../src/elements/blocks/job/job.builder");
-const inline_app_1 = require("../../src/engine/apps/inline.app");
+const inline_app_1 = require("../../src/engine/app/inline.app");
 function expectJob(def) {
     const builder = new job_builder_1.JobBuilder('test', 'test');
     def(builder);

package/tools/joaquin/message.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectMessage = expectMessage;
 const message_builder_1 = require("../../src/elements/entities/message/message.builder");
-const inline_app_1 = require("../../src/engine/apps/inline.app");
+const inline_app_1 = require("../../src/engine/app/inline.app");
 function expectMessage(def, inject = []) {
     const builder = new message_builder_1.MessageBuilder('test', 'test');
     builder.template(def);

package/tools/joaquin/mock.js

@@ -86,7 +86,8 @@ class BucketMockObj {
             return dict;
         }
         else if (field.type === 'enum') {
-            return field.meta.enum.options[Math.floor(Math.random() * field.meta.enum.options.length)];
+            const options = Object.values(field.meta.enum.options);
+            return options[Math.floor(Math.random() * options.length)];
         }
         else if (field.type === 'file') {
             // TODO