nesoi 3.0.0 → 3.0.3

package/lib/engine/data/tree.js

@@ -7,45 +7,61 @@ exports.Tree = void 0;
 const error_1 = require("./error");
 class Tree {
     /**
-     * When the fieldpath contains a `.*.`, which refers to a item in a list:
-     * - If the `index` parameter is null, returns nested lists
-     * - If the `index` parameter is a list of indices, returns the target object
+     * Read one or more values from the object, from a _fieldpath_.
      *
+     * The `index` argument is only relevant if the fieldpath contains a spread (`.#`):
+     * - `*`: Return all values of the matched array or dict
+     * - `0`: Return the first value of an array or dict (dict ordering is unstable)
+     * - `(number|string)[]`: Sequence of values to replace the `#`s on the fieldpath
      */
-    static get(obj, fieldpath, index = []) {
+    static get(obj, fieldpath, index = '*') {
         index = (!Array.isArray(index)) ? index : [...index];
         const paths = fieldpath.split('.');
-        const pathIndexCount = paths.filter(p => p === '*').length;
+        const pathIndexCount = paths.filter(p => p === '#').length;
         if (Array.isArray(index) && pathIndexCount > index.length) {
             throw error_1.NesoiError.Bucket.Fieldpath.InvalidIndexLength({ fieldpath, index });
         }
         let ref = obj;
         for (let i = 0; i < paths.length; i++) {
             const path = paths[i];
-            if (path === '*') {
+            if (path === '#') {
                 // 0 index, read the first item from the list
                 if (index === 0) {
-                    // This is a ObjTypeAsObj, stay on the node
-                    if ('__array' in ref) {
+                    // This is a TypeAsObj, stay on the node
+                    if (typeof ref === 'object' && '__array' in ref) {
                         // 
                     }
                     else {
-                        if (!Array.isArray(ref)) {
+                        if (typeof ref !== 'object') {
                             return undefined;
                         }
-                        ref = ref[0];
+                        if (Array.isArray(ref)) {
+                            ref = ref[0];
+                        }
+                        else {
+                            ref = ref[Object.keys(ref)[0]];
+                        }
                     }
                 }
                 // Null index, return a list of all items
-                else if (index === null) {
-                    if (!Array.isArray(ref)) {
+                else if (index === '*') {
+                    if (typeof ref !== 'object') {
                         return undefined;
                     }
+                    if (!Array.isArray(ref)) {
+                        ref = Object.values(ref);
+                    }
                     const childPath = paths.slice(i + 1);
                     if (childPath.length === 0) {
                         return ref;
                     }
-                    return ref.map(v => this.get(v, childPath.join('.'), null));
+                    const out = [];
+                    ref.forEach((v) => {
+                        const deep = this.get(v, childPath.join('.'), '*');
+                        if (deep !== undefined)
+                            out.push(deep);
+                    });
+                    return out.flat(1);
                 }
                 // List of indices, advance on it
                 else {
@@ -57,55 +73,91 @@ class Tree {
                 }
             }
             else {
-                ref = ref[path];
+                ref = ref?.[path];
             }
             if (ref === undefined) {
-                return undefined;
+                return ref;
             }
         }
+        // When reading from a TypeAsObj,
+        // advance on unions
+        if (!ref && '__or' in obj) {
+            return this.get(obj.__or, fieldpath, index);
+        }
         return ref;
     }
-    static find(obj, fn, link, _prefix) {
-        const root = link ? obj[link] : obj;
-        for (const key in root) {
-            const prop = root[key];
-            const path = (_prefix ? _prefix + '.' : '') + key;
-            if (fn(path, prop)) {
-                return {
-                    path,
-                    key,
-                    value: prop
-                };
+    static set(obj, fieldpath, replacer, __index = []) {
+        const paths = fieldpath.split('.');
+        class Ptr {
+            constructor(obj) {
+                this.obj = obj;
             }
-            if (typeof prop === 'object'
-                && !Array.isArray(prop)
-                && !prop['__type']) {
-                const inner = this.find(prop, fn, link, path);
-                if (inner) {
-                    return inner;
+            walk(key) {
+                if (this.key) {
+                    this.obj = this.obj[this.key];
                 }
+                this.key = key;
+            }
+            get() {
+                if (!this.key)
+                    return this.obj;
+                return this.obj?.[this.key];
+            }
+            replace(replacer, i) {
+                this.obj ?? (this.obj = {});
+                this.obj[this.key] = replacer(this.obj?.[this.key], i);
             }
         }
-    }
-    static findAll(obj, fn, _prefix) {
-        const nodes = [];
-        for (const key in obj) {
-            const prop = obj[key];
-            const path = (_prefix ? _prefix + '.' : '') + key;
-            if (typeof prop === 'object'
-                && !Array.isArray(prop)
-                && !prop['__type']) {
-                nodes.push(...this.findAll(prop, fn, key));
+        const ref = new Ptr(obj);
+        for (let i = 0; i < paths.length; i++) {
+            const path = paths[i];
+            if (path === '#') {
+                const arr = ref.get();
+                if (typeof arr !== 'object') {
+                    return;
+                }
+                const childPath = paths.slice(i + 1);
+                if (childPath.length === 0) {
+                    if (Array.isArray(arr)) {
+                        for (let i = 0; i < arr.length; i++) {
+                            arr[i] = replacer(arr[i], [...__index, i]);
+                        }
+                    }
+                    else {
+                        for (const key in arr) {
+                            arr[key] = replacer(arr[key], [...__index, key]);
+                        }
+                    }
+                    return;
+                }
+                if (Array.isArray(arr)) {
+                    for (let i = 0; i < arr.length; i++) {
+                        if (typeof arr[i] === 'object') {
+                            this.set(arr[i], childPath.join('.'), replacer, [...__index, i]);
+                        }
+                    }
+                }
+                else {
+                    for (const key in arr) {
+                        if (typeof arr[key] === 'object') {
+                            this.set(arr[key], childPath.join('.'), replacer, [...__index, key]);
+                        }
+                    }
+                }
+                return;
             }
-            if (fn(path, prop)) {
-                nodes.push({
-                    path,
-                    key,
-                    value: prop
-                });
+            else {
+                ref.walk(path);
+            }
+            if (ref.get() === undefined) {
+                ref.replace(replacer, __index);
+                return;
             }
         }
-        return nodes;
+        if ('__or' in obj) {
+            this.set(obj.__or, fieldpath, replacer, __index);
+        }
+        ref.replace(replacer, __index);
     }
 }
 exports.Tree = Tree;

package/lib/engine/module.d.ts

@@ -41,6 +41,7 @@ export type VirtualModuleDef = {
         machines?: $Machine[];
     };
     externals?: {
+        messages?: $Dependency[];
         buckets?: $Dependency[];
         jobs?: $Dependency[];
     };
@@ -92,6 +93,6 @@ export declare class Module<S extends $Space, $ extends $Module> {
     start(app: AnyApp, providers: Record<string, any>): void;
     destroy(): void;
     private destroyBlock;
-    static virtual(module: AnyModule, def: VirtualModuleDef): Promise<Module<$Space, $Module>>;
+    static virtual(daemon: AnyDaemon, def: VirtualModuleDef): Promise<Module<$Space, $Module>>;
 }
 export type AnyModule = Module<any, any>;

package/lib/engine/module.js

@@ -314,10 +314,7 @@ class Module {
         delete this[t][name];
     }
     // Virtual
-    static async virtual(module, def) {
-        if (!module.daemon) {
-            throw new Error(`Internal Error: unable to reach nesoi daemon when building virtual module '${def.name}'`);
-        }
+    static async virtual(daemon, def) {
         const virtualModule = new Module(def.name, { builders: [] });
         // Inject schemas
         if (def.schemas) {
@@ -327,7 +324,7 @@ class Module {
         await virtualModule.start({ config: {} }, {});
         // Inject externals
         if (def.externals) {
-            virtualModule.injectDependencies(module.daemon, def.externals);
+            virtualModule.injectDependencies(daemon, def.externals);
         }
         return virtualModule;
     }

package/lib/engine/space.d.ts

@@ -49,6 +49,7 @@ export declare class Space<$ extends $Space> {
      *
      */
     static path(space: Space<any>, ...relPath: string[]): string;
+    static relPath(space: Space<any>, absPath: string): string;
     static scan(space: Space<any>, buildFn: (name: string, path: string) => void): void;
 }
 export type AnySpace = Space<$Space>;

package/lib/engine/space.js

@@ -120,6 +120,12 @@ class Space {
         }
         return path.resolve(space.dirname, ...relPath);
     }
+    static relPath(space, absPath) {
+        if (!space.dirname) {
+            throw new Error('Cant use .path() on virtual space');
+        }
+        return path.relative(space.dirname, absPath);
+    }
     static scan(space, buildFn) {
         if (!fs.existsSync(space.dirname)) {
             throw error_1.CompilerError.DirectoryDoesntExists(space.dirname);

package/lib/engine/transaction/nodes/bucket.trx_node.d.ts

@@ -1,53 +1,185 @@
 import { $Module, ViewName, ViewObj } from "../../../schema";
-import { TrxNode } from '../trx_node';
+import { AnyTrxNode, TrxNode } from '../trx_node';
 import { BucketQueryTrxNode } from './bucket_query.trx_node';
 import { $Bucket } from "../../../elements/entities/bucket/bucket.schema";
 import { Bucket } from "../../../elements/entities/bucket/bucket";
-import { CreateObj, PatchObj, PutObj, ReplaceObj } from "../../../elements/entities/bucket/bucket.types";
-import { NQL_Query, NQL_Order, NQL_Pagination } from "../../../elements/entities/bucket/query/nql.schema";
+import { CreateObj, PatchObj, PutObj } from "../../../elements/entities/bucket/bucket.types";
+import { NQL_Query } from "../../../elements/entities/bucket/query/nql.schema";
 export declare class BucketTrxNode<M extends $Module, $ extends $Bucket> {
     private parentTrx;
     private bucket;
+    private enableTenancy;
     constructor(parentTrx: TrxNode<any, M, any>, bucket: Bucket<M, $>);
+    get no_tenancy(): this;
+    wrap(action: string, input: Record<string, any>, fn: (trx: AnyTrxNode) => Promise<any>, fmtTrxOut?: (out: any) => any): Promise<any>;
+    /**
+     * Returns one object by `id`, without pre-formatting,
+     * or `undefined` if the object was not found.
+     */
     readOne(id: $['#data']['id']): Promise<$['#data'] | undefined>;
+    /**
+     * Returns one object by `id` formated with the specified view,
+     * or `undefined` if the object was not found.
+     * - The formating process can impact performance. If you just need
+     * the raw obj, it's recommended to use `readOne` instead.
+     */
     viewOne<V extends ViewName<$>>(id: $['#data']['id'], view?: V): Promise<ViewObj<$, V> | undefined>;
+    /**
+     * Returns one object by `id`, without pre-formatting,
+     * or **throws an exception** if the object was not found.
+     */
     readOneOrFail(id: $['#data']['id']): Promise<$['#data']>;
+    /**
+     * Returns one object by `id`, without pre-formatting,
+     * or **throws an exception** if the object was not found.
+     * - The formating process can impact performance. If you just need
+     * the raw obj, it's recommended to use `readOneOrFail` instead.
+     */
     viewOneOrFail<V extends ViewName<$>>(id: $['#data']['id'], view?: V): Promise<ViewObj<$, V>>;
-    readAll(pagination?: NQL_Pagination, order?: NQL_Order<$['#fieldpath']>): Promise<$['#data'][]>;
-    viewAll<V extends ViewName<$>>(view?: V, pagination?: NQL_Pagination, order?: NQL_Order<$['#fieldpath']>): Promise<ViewObj<$, V>[]>;
+    /**
+     * Returns a list of all objects, without pre-formatting.
+     */
+    readAll(): Promise<$['#data'][]>;
+    /**
+     * Returns a list of all objects formated with the specified view.
+     * - The formating process can impact performance. If you just need
+     * the raw obj, it's recommended to use `readAll` instead.
+     */
+    viewAll<V extends ViewName<$>>(view?: V): Promise<ViewObj<$, V>[]>;
+    /**
+     * Returns a list containing the results of the query.
+     */
     query<V extends ViewName<$> = 'default'>(query: NQL_Query<M, $>, view?: V): BucketQueryTrxNode<M, $, V>;
-    readLink<LinkName extends keyof $['graph']['links'], Link extends $['graph']['links'][LinkName], LinkBucket extends Link['#bucket'], V extends ViewName<LinkBucket>, Obj extends ViewObj<LinkBucket, V>>(id: $['#data']['id'], link: LinkName, view?: V): Promise<Link['#many'] extends true ? Obj[] : (Obj | undefined)>;
-    readLinkOrFail<LinkName extends keyof $['graph']['links'], Link extends $['graph']['links'][LinkName], LinkBucket extends Link['#bucket'], V extends ViewName<LinkBucket>, Obj extends ViewObj<LinkBucket, V>>(id: $['#data']['id'], link: LinkName, view?: V): Promise<Link['#many'] extends true ? Obj[] : Obj>;
+    /**
+     * Returns one or more objects referenced by the graph link,
+     * or `undefined` if the graph link doesn't resolve.
+     */
+    readLink<LinkName extends keyof $['graph']['links'], Link extends $['graph']['links'][LinkName], Obj extends Link['#bucket']['#data']>(id: $['#data']['id'], link: LinkName): Promise<Link['#many'] extends true ? Obj[] : (Obj | undefined)>;
+    /**
+     * Returns one or more objects referenced by the graph link built with a view,
+     * or `undefined` if the graph link doesn't resolve.
+     */
+    viewLink<LinkName extends keyof $['graph']['links'], Link extends $['graph']['links'][LinkName], LinkBucket extends Link['#bucket'], V extends ViewName<LinkBucket>, Obj extends ViewObj<LinkBucket, V>>(id: $['#data']['id'], link: LinkName, view?: V): Promise<Link['#many'] extends true ? Obj[] : (Obj | undefined)>;
+    /**
+     * Returns one or more objects referenced by the graph link,
+     * or **throws an exception** if the graph link doesn't resolve.
+     */
+    readLinkOrFail<LinkName extends keyof $['graph']['links'], Link extends $['graph']['links'][LinkName], Obj extends Link['#bucket']['#data']>(id: $['#data']['id'], link: LinkName): Promise<Link['#many'] extends true ? Obj[] : Obj>;
+    /**
+     * Returns one or more objects referenced by the graph link built with a view,
+     * or **throws an exception** if the graph link doesn't resolve.
+     */
+    viewLinkOrFail<LinkName extends keyof $['graph']['links'], Link extends $['graph']['links'][LinkName], LinkBucket extends Link['#bucket'], V extends ViewName<LinkBucket>, Obj extends ViewObj<LinkBucket, V>>(id: $['#data']['id'], link: LinkName, view?: V): Promise<Link['#many'] extends true ? Obj[] : Obj>;
+    /**
+     * Returns `true` if the graph link resolves to at least 1 object.
+     */
     hasLink<LinkName extends keyof $['graph']['links']>(id: $['#data']['id'], link: LinkName): Promise<boolean | undefined>;
     /**
-     * Updates an object by passing it directly to the bucket adapter,
-     * without checking if it exists. This creates an object if a new
-     * id is passed.
+     * Creates an object by passing it to the bucket adapter.
+     * Also creates the compositions of this bucket, from the
+     * `#composition` field passed in the message.
+     *
+     * - If `#composition` is wrong, this will throw an exception
+     */
+    create(obj: CreateObj<$>): Promise<$['#data']>;
+    /**
+     * Reads one object by `id` and `patch` (modify) it based on the one passed as an argument.
+     * Also patches the compositions of this bucket, from the
+     * `#composition` field passed in the message.
+     *
+     * - If the object is not found, this will throw an exception
+     * - If `#composition` is wrong, this will throw an exception
+     * - The read query before updating might impact performance and be unnecessary
+     * when you're updating from code that's sure the object exists. In that case,
+     * you can use `unsafe.patch`, which doesn't read prior to writing.
+     */
+    patch(obj: PatchObj<$>): Promise<$['#data']>;
+    /**
+     * Reads one object by `id` and `replace` it with the one passed as an argument.
+     * Also patches the compositions of this bucket, from the
+     * `#composition` field passed in the message.
+     *
+     * - If the object is not found, this will throw an exception
+     * - If `#composition` is wrong, this will throw an exception
+     * - The read query before updating might impact performance and be unnecessary
+     * when you're updating from code that's sure the object exists. In that case,
+     * you can use `unsafe.replace`, which doesn't read prior to writing.
+     */
+    replace(obj: PatchObj<$>): Promise<$['#data']>;
+    /**
+     * Creates or replaces (by `id`) the object passed as an argument.
+     * Does the same for compositions of this bucket, from the
+     * `#composition` field passed in the message.
+     *
+     * - If `#composition` is wrong, this will throw an exception.
+     * - This will **REPLACE** objects and it's compositions if they already exist,
+     *  so there might be unexpected data loss, use it carefully.
+     *
+     * **WARNING** Tenancy currently not implemented for put.
      */
     put(obj: PutObj<$>): Promise<$['#data']>;
     /**
-     * Creates an object by passing it to the bucket adapter,
-     * without an ID (it's removed if passed).
-     * This is a safer version of `put`, which ensures no update will happen.
+     * Attempts to read an object by `id`, if found, deletes it.
+     *
+     * - If you want to skip the read query, use the `unsafe.delete` method,
+     * so the behavior depends on the bucket used.
      */
-    create(obj: CreateObj<$>): Promise<$['#data']>;
+    delete(id: $['#data']['id']): Promise<void>;
     /**
-     * Reads the id from the bucket adapter to ensure the object exists
-     * before updating.
-     * This is a safer version of `put`, suited for updating data.
+     * Attempts to read an object by `id`, if found, deletes it.
+     *
+     * - If you want to skip the read query, use the `unsafe.delete` method,
+     * so the behavior depends on the bucket used.
      */
-    replace(obj: ReplaceObj<$>): Promise<$['#data']>;
+    deleteMany(ids: $['#data']['id'][]): Promise<void>;
+    buildOne<V extends ViewName<$>, Obj extends ViewObj<$, V>>(obj: $['#data'], view: V): Promise<Obj>;
+    buildMany<V extends ViewName<$>, Obj extends ViewObj<$, V>>(objs: $['#data'][], view: V): Promise<Obj[]>;
+    /**
+     * Unsafe versions of methods, which improve performance
+     * by avoiding some validations and queries.
+     *
+     * **Use it carefully.**
+     */
+    get unsafe(): BucketUnsafeTrxNode<M, $>;
+}
+export declare class BucketUnsafeTrxNode<M extends $Module, $ extends $Bucket> {
+    private bucketTrx;
+    private bucket;
+    private enableTenancy;
+    constructor(bucketTrx: BucketTrxNode<M, $>, bucket: Bucket<M, $>, enableTenancy: boolean);
+    get no_tenancy(): this;
     /**
-     * Reads the id from the bucket adapter to ensure the object exists
-     * before updating. Applies changes to the object instead of replacing it.
+     * Directly `patch` (modify) an object based on the one passed as an argument.
+     * Also patches the compositions of this bucket, from the
+     * `#composition` field passed in the message.
+     *
+     * > This unsafe version does not check if the object exists prior to patching.
+     *
+     * - If the object is not found, this will throw an exception
+     * - If `#composition` is wrong, this will throw an exception
      */
     patch(obj: PatchObj<$>): Promise<$['#data']>;
+    /**
+     * Directly `replace` on object with the one passed as an argument.
+     * Also replaces the compositions of this bucket, from the
+     * `#composition` field passed in the message.
+     *
+     * > This unsafe version does not check if the object exists prior to replacing.
+     *
+     * - If the object is not found, this will throw an exception
+     * - If `#composition` is wrong, this will throw an exception
+     */
+    replace(obj: PatchObj<$>): Promise<$['#data']>;
+    /**
+     * Deletes an object
+     *
+     * > This unsafe version does not check if the object exists prior to deleting.
+     */
     delete(id: $['#data']['id']): Promise<void>;
     /**
-     * **WARNING**: This does not currently implement composition
+     * Attempts to read an object by `id`, if found, deletes it.
+     *
+     * > This unsafe version does not check if the objects exist prior to deleting.
      */
     deleteMany(ids: $['#data']['id'][]): Promise<void>;
-    deleteOrFail(id: $['#data']['id']): Promise<void>;
-    buildOne<V extends ViewName<$>, Obj extends ViewObj<$, V>>(obj: $['#data'], view: V): Promise<Obj>;
-    buildAll<V extends ViewName<$>, Obj extends ViewObj<$, V>>(objs: $['#data'][], view: V): Promise<Obj[]>;
 }