nesoi 3.0.12 → 3.0.14

package/lib/engine/data/trash.d.ts

@@ -1,14 +1,17 @@
-import { NesoiDatetime } from './datetime';
+import { NesoiObj } from './obj';
+import { AnyTrxNode } from '../transaction/trx_node';
+import { $Bucket } from "../../elements/entities/bucket/bucket.schema";
+import { AnyModule } from '../module';
 export type TrashObj = {
     id: number;
+    module: string;
     bucket: string;
-    original_id: number | string;
-    data: Record<string, any>;
-    adapter: {
-        name: string;
-        [x: string]: any;
-    };
-    trx: Record<string, any>;
-    deleted_by?: number | string;
-    deleted_at: NesoiDatetime;
+    object_id: string;
+    object: Record<string, any>;
+    delete_trx_id: string;
 };
+export declare const $TrashBucket: $Bucket;
+export declare class Trash {
+    static add<Obj extends NesoiObj>(trx: AnyTrxNode, module: AnyModule, bucket: string, object: Obj): Promise<void>;
+    static addMany<Obj extends NesoiObj>(trx: AnyTrxNode, module: AnyModule, bucket: string, objects: Obj[]): Promise<void>;
+}

package/lib/engine/data/trash.js

@@ -1,2 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trash = exports.$TrashBucket = void 0;
+const bucket_schema_1 = require("../../elements/entities/bucket/bucket.schema");
+const bucket_model_schema_1 = require("../../elements/entities/bucket/model/bucket_model.schema");
+const bucket_graph_schema_1 = require("../../elements/entities/bucket/graph/bucket_graph.schema");
+exports.$TrashBucket = new bucket_schema_1.$Bucket('__trash__', 'trash', 'Trash', new bucket_model_schema_1.$BucketModel({
+    id: new bucket_model_schema_1.$BucketModelField('id', 'id', 'int', 'id', false, true),
+    module: new bucket_model_schema_1.$BucketModelField('module', 'module', 'string', 'Module Name', false, true),
+    bucket: new bucket_model_schema_1.$BucketModelField('bucket', 'bucket', 'string', 'Bucket Name', false, true),
+    object_id: new bucket_model_schema_1.$BucketModelField('object_id', 'object_id', 'int', 'Object ID', false, true),
+    object: new bucket_model_schema_1.$BucketModelField('object', 'object', 'dict', 'Object', false, true, undefined, undefined, {
+        __dict: new bucket_model_schema_1.$BucketModelField('', '', 'unknown', '', false, true, undefined, undefined)
+    }),
+    delete_trx_id: new bucket_model_schema_1.$BucketModelField('delete_trx_id', 'delete_trx_id', 'int', 'ID of Delete Transaction', false, true),
+}), new bucket_graph_schema_1.$BucketGraph(), {});
+class Trash {
+    static async add(trx, module, bucket, object) {
+        if (!module.trash)
+            return;
+        await module.trash.create(trx, {
+            module: module.name,
+            bucket,
+            object_id: object.id,
+            object,
+            delete_trx_id: trx.globalId
+        });
+    }
+    static async addMany(trx, module, bucket, objects) {
+        for (const object of objects) {
+            await this.add(trx, module, bucket, object);
+        }
+    }
+}
+exports.Trash = Trash;

package/lib/engine/dependency.d.ts

@@ -96,6 +96,9 @@ export declare class BuilderNode {
     filepath: string | string[];
     dependencies: $Dependency[];
     builder: AnyBuilder;
+    progressive?: {
+        schema: AnyElementSchema;
+    };
     constructor($: {
         module: string;
         type: BuilderType;
@@ -104,6 +107,9 @@ export declare class BuilderNode {
         filepath: string | string[];
         dependencies: $Dependency[];
         builder: AnyBuilder;
+        progressive?: {
+            schema: AnyElementSchema;
+        };
     });
 }
 /**

package/lib/engine/dependency.js

@@ -156,6 +156,7 @@ class BuilderNode {
         this.filepath = $.filepath;
         this.dependencies = $.dependencies;
         this.builder = $.builder;
+        this.progressive = $.progressive;
     }
 }
 exports.BuilderNode = BuilderNode;

package/lib/engine/module.d.ts

@@ -11,7 +11,7 @@ import { $Message } from "../elements/entities/message/message.schema";
 import { Resource } from "../elements/blocks/resource/resource";
 import { Queue } from "../elements/blocks/queue/queue";
 import { Controller } from "../elements/edge/controller/controller";
-import { Bucket } from "../elements/entities/bucket/bucket";
+import { AnyBucket, Bucket } from "../elements/entities/bucket/bucket";
 import { $Constants } from "../elements/entities/constants/constants.schema";
 import { ConstantsBuilder } from "../elements/entities/constants/constants.builder";
 import { AnyControllerBuilder } from "../elements/edge/controller/controller.builder";
@@ -63,6 +63,7 @@ export type VirtualModuleDef = {
  */
 export declare class Module<S extends $Space, $ extends $Module> {
     name: string;
+    subdir: string[];
     schema: $;
     buckets: { [B in keyof $["buckets"]]: Bucket<$, $["buckets"][B]>; };
     messages: { [B in keyof $["messages"]]: MessageParser<$["messages"][B]>; };
@@ -71,6 +72,7 @@ export declare class Module<S extends $Space, $ extends $Module> {
     machines: { [B in keyof $["machines"]]: Machine<S, $, $["machines"][B]>; };
     queues: { [B in keyof $["queues"]]: Queue<$, $["queues"][B]>; };
     controllers: { [B in keyof $["controllers"]]: Controller<S, $, $["controllers"][B]>; };
+    trash?: AnyBucket;
     /**
      * Daemon which is running the current module.
      * This is `undefined` when the _Module_ is created for compiling.
@@ -100,7 +102,7 @@ export declare class Module<S extends $Space, $ extends $Module> {
         dirpath: string;
     } | {
         builders: AnyBuilder[];
-    });
+    }, subdir?: string[]);
     /**
      * Log the module elements
      */

package/lib/engine/module.js

@@ -59,6 +59,7 @@ const app_1 = require("./apps/app");
 const queue_builder_1 = require("../elements/blocks/queue/queue.builder");
 const nql_engine_1 = require("../elements/entities/bucket/query/nql_engine");
 const daemon_1 = require("./daemon");
+const trash_1 = require("./data/trash");
 /**
  * A `Module` is an isolated named collection of _Elements_.
  *
@@ -78,8 +79,9 @@ class Module {
      * @param name A module name
      * @param boot The boot source for this module
      */
-    constructor(name, boot) {
+    constructor(name, boot, subdir = []) {
         this.name = name;
+        this.subdir = subdir;
         this.schema = {
             constants: new constants_schema_1.$Constants(this.name),
             externals: new externals_schema_1.$Externals(this.name),
@@ -334,7 +336,7 @@ class Module {
         const config = info.config;
         Object.entries(this.schema.buckets).forEach(([name, schema]) => {
             const bucketConfig = config.buckets?.[this.name]?.[name];
-            this.buckets[name] = new bucket_1.Bucket(schema, bucketConfig, services);
+            this.buckets[name] = new bucket_1.Bucket(this, schema, bucketConfig, services);
         });
         Object.entries(this.schema.messages).forEach(([name, schema]) => {
             this.messages[name] = new message_parser_1.MessageParser(schema);
@@ -356,6 +358,9 @@ class Module {
             this.queues[name] = new queue_1.Queue(this, schema);
         });
         this.nql = new nql_engine_1.NQL_Engine(this);
+        if (config.trash?.[this.name]) {
+            this.trash = new bucket_1.Bucket(this, trash_1.$TrashBucket, config.trash[this.name], services);
+        }
     }
     // Destroy
     /**
@@ -417,7 +422,7 @@ class Module {
             virtualModule.inject(def.schemas);
         }
         // Build schemas
-        await virtualModule.start({ config: {} }, {});
+        await virtualModule.start({ _config: {} }, {});
         // Inject externals
         if (def.externals) {
             const modules = {};

package/lib/engine/space.d.ts

@@ -203,6 +203,6 @@ export declare class Space<$ extends $Space> {
      * @param space A `Space` instance
      * @param buildFn A callback to run for each module directory
      */
-    static scan(space: Space<any>, buildFn: (name: string, path: string) => void): void;
+    static scan(space: Space<any>, buildFn: (name: string, path: string, subdir: string[]) => void): void;
 }
 export type AnySpace = Space<$Space>;

package/lib/engine/space.js

@@ -296,11 +296,20 @@ class Space {
         if (!fs.existsSync(modulesPath)) {
             throw error_1.CompilerError.NoModulesFolder();
         }
-        const dirs = fs.readdirSync(modulesPath, { withFileTypes: true })
-            .filter(node => node.isDirectory());
-        for (const dir of dirs) {
-            buildFn(dir.name, path.join(modulesPath, dir.name));
-        }
+        const perform = (dirpath, subdir) => {
+            const dirs = fs.readdirSync(dirpath, { withFileTypes: true })
+                .filter(node => node.isDirectory());
+            for (const dir of dirs) {
+                const modulePath = path.join(dirpath, dir.name);
+                if (fs.existsSync(path.join(modulePath, '.modules'))) {
+                    perform(modulePath, [...subdir, dir.name]);
+                }
+                else {
+                    buildFn(dir.name, modulePath, subdir);
+                }
+            }
+        };
+        perform(modulesPath, []);
     }
 }
 exports.Space = Space;

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

@@ -54,7 +54,11 @@ export declare class BucketTrxNode<M extends $Module, $ extends $Bucket> {
     /**
      * Returns a list containing the results of the query.
      */
-    query<V extends ViewName<$> = 'default'>(query: NQL_Query<M, $>, view?: V): BucketQueryTrxNode<M, $, V>;
+    query(query: NQL_Query<M, $>): BucketQueryTrxNode<M, $>;
+    /**
+     * Returns a list containing the results of the query built with a view.
+     */
+    viewQuery<V extends ViewName<$> = 'default'>(query: NQL_Query<M, $>, view?: V): BucketQueryTrxNode<M, $, V>;
     /**
      * Returns one or more objects referenced by the graph link,
      * or `undefined` if the graph link doesn't resolve.

package/lib/engine/transaction/nodes/bucket.trx_node.js

@@ -109,9 +109,16 @@ class BucketTrxNode {
     /**
      * Returns a list containing the results of the query.
      */
-    query(query, view = 'default') {
+    query(query) {
         const trx = trx_node_1.TrxNode.makeChildNode(this.parentTrx, this.bucket.schema.module, 'bucket', this.bucket.schema.name);
-        return new bucket_query_trx_node_1.BucketQueryTrxNode(trx, this.bucket, query, view, this.enableTenancy);
+        return new bucket_query_trx_node_1.BucketQueryTrxNode(trx, this.bucket, query, this.enableTenancy);
+    }
+    /**
+     * Returns a list containing the results of the query built with a view.
+     */
+    viewQuery(query, view = 'default') {
+        const trx = trx_node_1.TrxNode.makeChildNode(this.parentTrx, this.bucket.schema.module, 'bucket', this.bucket.schema.name);
+        return new bucket_query_trx_node_1.BucketQueryTrxNode(trx, this.bucket, query, this.enableTenancy, view);
     }
     /*
         Graph

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

@@ -8,13 +8,13 @@ import { NQL_Result } from "../../../elements/entities/bucket/query/nql_engine";
  * @category Engine
  * @subcategory Transaction
  */
-export declare class BucketQueryTrxNode<M extends $Module, B extends $Bucket, V extends ViewName<B>, Obj = ViewObj<B, V>> {
+export declare class BucketQueryTrxNode<M extends $Module, B extends $Bucket, V extends ViewName<B> | undefined = undefined, Obj = V extends string ? ViewObj<B, V> : B['#data']> {
     private trx;
     private bucket;
     private query;
-    private view;
     private enableTenancy;
-    constructor(trx: TrxNode<any, M, any>, bucket: Bucket<M, B>, query: NQL_AnyQuery, view: V, enableTenancy: boolean);
+    private view?;
+    constructor(trx: TrxNode<any, M, any>, bucket: Bucket<M, B>, query: NQL_AnyQuery, enableTenancy: boolean, view?: V | undefined);
     merge($: NQL_Query<M, B>): void;
     first(): Promise<Obj | undefined>;
     firstOrFail(): Promise<Obj>;

package/lib/engine/transaction/nodes/bucket_query.trx_node.js

@@ -8,12 +8,12 @@ const error_1 = require("../../data/error");
  * @subcategory Transaction
  */
 class BucketQueryTrxNode {
-    constructor(trx, bucket, query, view, enableTenancy) {
+    constructor(trx, bucket, query, enableTenancy, view) {
         this.trx = trx;
         this.bucket = bucket;
         this.query = query;
-        this.view = view;
         this.enableTenancy = enableTenancy;
+        this.view = view;
     }
     merge($) {
         const and = $['#and'];

package/lib/engine/transaction/trx_engine.d.ts

@@ -5,7 +5,7 @@ import { TrxNode, TrxNodeStatus } from './trx_node';
 import { AnyAuthnProviders, AuthnRequest } from '../auth/authn';
 import { TrxEngineConfig } from './trx_engine.config';
 import { IService } from '../apps/service';
-export type TrxEngineOrigin = `app:${string}`;
+export type TrxEngineOrigin = `app:${string}` | `plugin:${string}`;
 /**
  * @category Engine
  * @subcategory Transaction

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

@@ -59,7 +59,7 @@ export declare class TrxNode<Space extends $Space, M extends $Module, Authn exte
     machine<Name extends keyof M['machines'], Machine extends M['machines'][Name]>(name: Name): MachineTrxNode<M, Machine>;
     queue<Name extends keyof M['queues'], Queue extends M['queues'][Name]>(name: Name): QueueTrxNode<M, Queue>;
     authenticate(authnRequest: AuthnRequest<keyof Authn>): Promise<TrxNode<$Space, $Module, Authn>>;
-    token<U extends keyof Authn & keyof M['#authn']>(provider: U): M['#authn'][U];
+    token<U extends keyof Authn & keyof M['#authn']>(provider: U): string;
     user<U extends keyof Authn & keyof M['#authn']>(provider: U): M['#authn'][U];
     virtual<T>(def: VirtualModuleDef, fn: ($: AnyTrxNode) => T | Promise<T>): Promise<T>;
     status(): TrxNodeStatus;

package/lib/engine/transaction/trx_node.js

@@ -55,7 +55,9 @@ class TrxNode {
             error.message = i18n_1.i18n.error(error, node.trx.root.module.daemon);
         }
         else {
-            error = new error_1.NesoiError.BaseError('UnknownError', error.message);
+            const _e = error;
+            error = new error_1.NesoiError.BaseError('UnknownError', _e.message);
+            error.stack = _e;
         }
         node.error = error;
         node.time.end = datetime_1.NesoiDatetime.now();

package/lib/engine/tree.d.ts

@@ -2,6 +2,7 @@ import { BuilderType } from "../schema";
 import { ResolvedBuilderNode } from './dependency';
 import { AnyModule } from './module';
 import { TreeshakeConfig } from "../compiler/treeshake";
+import { ProgressiveBuildCache } from "../compiler/progressive";
 type TraverseCallback = (node: ResolvedBuilderNode) => Promise<void>;
 /**
  * A tree of module elements which allows building in the correct order.
@@ -23,7 +24,7 @@ export declare class ModuleTree {
      * - Resolves each found dependency forming a tree
      * - Groups tree into layers which can be built in isolation
      */
-    resolve(): Promise<void>;
+    resolve(cache?: ProgressiveBuildCache): Promise<void>;
     /**
      * Read the module elements from files and identify
      * all related nodes.
@@ -82,5 +83,11 @@ export declare class ModuleTree {
      * @returns A list of resolved builder nodes
      */
     allNodes(): ResolvedBuilderNode[];
+    /**
+     * Return a list of all nodes of all modules on the tree.
+     *
+     * @returns A list of resolved builder nodes
+     */
+    allNodesByModule(): Record<string, ResolvedBuilderNode[]>;
 }
 export {};

package/lib/engine/tree.js

@@ -6,6 +6,7 @@ const error_1 = require("../compiler/error");
 const log_1 = require("./util/log");
 const string_1 = require("./util/string");
 const treeshake_1 = require("../compiler/treeshake");
+const progressive_1 = require("../compiler/progressive");
 /**
  * A tree of module elements which allows building in the correct order.
  *
@@ -27,8 +28,9 @@ class ModuleTree {
      * - Resolves each found dependency forming a tree
      * - Groups tree into layers which can be built in isolation
      */
-    async resolve() {
-        const nodesByModule = await this.treeshake();
+    async resolve(cache) {
+        cache ?? (cache = progressive_1.ProgressiveBuild.empty());
+        const nodesByModule = await this.treeshake(cache);
         const resolvedNodes = await this.resolveDependencies(nodesByModule);
         this.layers = this.resolveLayers(resolvedNodes);
     }
@@ -38,12 +40,12 @@ class ModuleTree {
      *
      * @returns A dictionary of nodes by module name
      */
-    async treeshake() {
+    async treeshake(cache) {
         log_1.Log.debug('compiler', 'tree', 'Treeshaking');
         const nodesByModule = {};
         for (const m in this.modules) {
             const module = this.modules[m];
-            const nodes = await treeshake_1.Treeshake.module(module, this.config);
+            const nodes = await treeshake_1.Treeshake.module(module, cache, this.config);
             nodesByModule[module.name] = nodes;
         }
         return nodesByModule;
@@ -89,27 +91,29 @@ class ModuleTree {
                     return { node: resolved[dep.tag], soft: dep.soft };
                 });
                 const inlines = {};
-                if ('_inlineNodes' in node.builder) {
-                    const inlineNodes = node.builder._inlineNodes;
-                    inlineNodes.forEach((inline) => {
-                        log_1.Log.trace('compiler', 'tree', `   └ ${(0, string_1.colored)('OK', 'green')} ${(0, string_1.colored)(inline.module + '::' + inline.type + ':' + inline.name, 'lightcyan')}`);
-                        // If inline node was not resolved yet, create a shared reference
-                        // on which the `dependencies` and `inlines` will be populated on future iterations.
-                        if (!(inline.tag in resolved)) {
-                            resolved[inline.tag] = {
-                                ...inline,
-                                dependencies: [],
-                                inlines: {}
-                            };
-                        }
-                        const type = inline.type;
-                        if (!(type in inlines)) {
-                            inlines[type] = {
-                                [inline.name]: resolved[inline.tag]
-                            };
-                        }
-                        inlines[type][inline.name] = resolved[inline.tag];
-                    });
+                if (!node.progressive) {
+                    if ('_inlineNodes' in node.builder) {
+                        const inlineNodes = node.builder._inlineNodes;
+                        inlineNodes.forEach((inline) => {
+                            log_1.Log.trace('compiler', 'tree', `   └ ${(0, string_1.colored)('OK', 'green')} ${(0, string_1.colored)(inline.module + '::' + inline.type + ':' + inline.name, 'lightcyan')}`);
+                            // If inline node was not resolved yet, create a shared reference
+                            // on which the `dependencies` and `inlines` will be populated on future iterations.
+                            if (!(inline.tag in resolved)) {
+                                resolved[inline.tag] = {
+                                    ...inline,
+                                    dependencies: [],
+                                    inlines: {}
+                                };
+                            }
+                            const type = inline.type;
+                            if (!(type in inlines)) {
+                                inlines[type] = {
+                                    [inline.name]: resolved[inline.tag]
+                                };
+                            }
+                            inlines[type][inline.name] = resolved[inline.tag];
+                        });
+                    }
                 }
                 // If node was already created when resolving a dependendant,
                 // just fill the dependencies and inlines.
@@ -274,5 +278,21 @@ class ModuleTree {
         }
         return nodes;
     }
+    /**
+     * Return a list of all nodes of all modules on the tree.
+     *
+     * @returns A list of resolved builder nodes
+     */
+    allNodesByModule() {
+        var _a;
+        const modules = {};
+        for (const layer of this.layers) {
+            for (const node of layer) {
+                modules[_a = node.module] ?? (modules[_a] = []);
+                modules[node.module].push(node);
+            }
+        }
+        return modules;
+    }
 }
 exports.ModuleTree = ModuleTree;

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

@@ -1,3 +1,4 @@
 export declare class Hash {
-    static file(filepath: string, algorithm: 'sha256' | 'sha1' | 'md5'): Promise<string>;
+    static file(filepath: string, algorithm?: 'sha256' | 'sha1' | 'md5'): Promise<string>;
+    static merge(tree: Record<string, string>, algorithm?: 'sha256' | 'sha1' | 'md5'): string;
 }

package/lib/engine/util/hash.js

@@ -7,7 +7,7 @@ exports.Hash = void 0;
 const fs_1 = __importDefault(require("fs"));
 const crypto_1 = __importDefault(require("crypto"));
 class Hash {
-    static file(filepath, algorithm) {
+    static file(filepath, algorithm = 'sha256') {
         return new Promise(resolve => {
             const fd = fs_1.default.createReadStream(filepath);
             const hash = crypto_1.default.createHash(algorithm);
@@ -19,5 +19,14 @@ class Hash {
             fd.pipe(hash);
         });
     }
+    static merge(tree, algorithm = 'sha256') {
+        const str = Object.entries(tree)
+            .map((key, value) => `${key}:${value}`)
+            .sort()
+            .join('\n');
+        return crypto_1.default.createHash(algorithm)
+            .update(str)
+            .digest('hex');
+    }
 }
 exports.Hash = Hash;

package/package.json

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