nesoi 3.0.12 → 3.0.14

package/lib/compiler/stages/4_build_schemas_stage.js

@@ -15,14 +15,23 @@ class BuildSchemasStage {
     }
     async run() {
         log_1.Log.info('compiler', 'stage.build_schemas', 'Building schemas...');
+        const t0 = new Date().getTime();
         await this.compiler.tree.traverse('Building schemas ', async (node) => {
+            const module = this.compiler.modules[node.module].module;
+            if (node.progressive) {
+                await module.inject({
+                    [node.progressive.schema.$t + 's']: [node.progressive.schema]
+                });
+                return;
+            }
             // Inline nodes are built by their root builder
             if (node.isInline) {
                 return;
             }
-            const module = this.compiler.modules[node.module].module;
             await module.buildNode(node, this.compiler.tree);
         });
+        const t = new Date().getTime();
+        log_1.Log.debug('compiler', 'stage.build_schemas', `[t: ${(t - t0) / 1000} ms]`);
     }
 }
 exports.BuildSchemasStage = BuildSchemasStage;

package/lib/compiler/stages/5_inject_ts_stage.js

@@ -16,9 +16,12 @@ class InjectTSStage {
     }
     run() {
         log_1.Log.info('compiler', 'stage.inject_ts', 'Injecting TypeScript code to schemas...');
+        const t0 = new Date().getTime();
         const { tree } = this.compiler;
         const nodes = tree.allNodes();
         inject_1.TSBridgeInject.inject(this.compiler, nodes);
+        const t = new Date().getTime();
+        log_1.Log.debug('compiler', 'stage.inject_ts', `[t: ${(t - t0) / 1000} ms]`);
         log_1.Log.trace('compiler', 'stage.inject_ts', 'Finished injecting TS code');
     }
 }

package/lib/compiler/stages/6_build_elements_stage.js

@@ -16,10 +16,13 @@ class BuildElementsStage {
     }
     async run() {
         log_1.Log.info('compiler', 'stage.build_elements', 'Building Elements...');
+        const t0 = new Date().getTime();
         await this.compiler.tree.traverse('Building elements ', async (node) => {
             const module = this.compiler.modules[node.module];
             await module.buildElementNode(node);
         });
+        const t = new Date().getTime();
+        log_1.Log.debug('compiler', 'stage.build_elements', `[t: ${(t - t0) / 1000} ms]`);
     }
 }
 exports.BuildElementsStage = BuildElementsStage;

package/lib/compiler/stages/7_dump_stage.d.ts

@@ -8,10 +8,13 @@ import { Compiler } from '../compiler';
  */
 export declare class DumpStage {
     compiler: Compiler;
+    private cache;
+    private hash;
     constructor(compiler: Compiler);
-    run(): void;
+    run(): Promise<void>;
     private dumpSpace;
     private dumpModule;
     private dumpModuleSchemas;
     private dumpModuleType;
+    private makeModuleType;
 }

package/lib/compiler/stages/7_dump_stage.js

@@ -45,6 +45,7 @@ const dependency_1 = require("../../engine/dependency");
 const bucket_element_1 = require("../elements/bucket.element");
 const dump_helpers_1 = require("../helpers/dump_helpers");
 const space_1 = require("../../engine/space");
+const progressive_1 = require("../progressive");
 /**
  * [Compiler Stage #7]
  * Dump the element schemas and types to the .nesoi folder.
@@ -56,12 +57,27 @@ class DumpStage {
     constructor(compiler) {
         this.compiler = compiler;
     }
-    run() {
+    async run() {
         log_1.Log.info('compiler', 'stage.dump', 'Dumping Schemas and Types...');
-        const spaceType = this.dumpSpace();
+        const t0 = new Date().getTime();
+        this.cache = await progressive_1.ProgressiveBuild.cache(this.compiler);
+        this.hash = await progressive_1.ProgressiveBuild.hash(this.compiler);
+        let spaceType;
+        if (this.hash.$ !== this.cache.hash.$) {
+            spaceType = this.dumpSpace();
+            this.cache.types.space = spaceType;
+        }
+        else {
+            spaceType = this.cache.types.space;
+        }
         Object.values(this.compiler.modules).forEach(module => {
-            this.dumpModule(module, spaceType);
+            if (this.hash.modules[module.lowName]?.$ !== this.cache.hash.modules[module.lowName]?.$) {
+                this.dumpModule(module, spaceType);
+            }
         });
+        await progressive_1.ProgressiveBuild.save(this.compiler.space, this.cache, this.hash);
+        const t = new Date().getTime();
+        log_1.Log.debug('compiler', 'stage.dump', `[t: ${(t - t0) / 1000} ms]`);
     }
     /* Space */
     dumpSpace() {
@@ -74,7 +90,7 @@ class DumpStage {
         Object.entries(_authn).forEach(([name, model]) => {
             type.authnUsers[name] = bucket_element_1.BucketElement.buildModelTypeFromSchema(model);
         });
-        // Module types
+        // Module imports
         let dump = '';
         dump += `import { $Space } from '${this.compiler.config?.nesoiPath ?? 'nesoi'}/lib/schema';\n`;
         Object.values(this.compiler.modules).forEach(module => {
@@ -105,12 +121,18 @@ class DumpStage {
     dumpModuleSchemas(module, dumpDir) {
         const nesoiPath = this.compiler.config?.nesoiPath ?? 'nesoi';
         module.elements.forEach((element) => {
-            const filename = path_1.default.basename(element.filepath());
-            const elPath = path_1.default.resolve(dumpDir, filename);
-            fs.writeFileSync(elPath, element.dumpFileSchema(nesoiPath));
+            if (element.schema.$t === 'constants'
+                || element.schema.$t === 'externals'
+                || (this.hash.modules[element.schema.module].nodes[element.tag]
+                    !== this.cache.hash.modules[element.schema.module]?.nodes[element.tag])) {
+                const filename = path_1.default.basename(element.filepath());
+                const elPath = path_1.default.resolve(dumpDir, filename);
+                fs.writeFileSync(elPath, element.dumpFileSchema(nesoiPath));
+            }
         });
     }
     dumpModuleType(module, spaceType, dumpDir) {
+        var _a, _b;
         const nesoiPath = this.compiler.config?.nesoiPath ?? 'nesoi';
         const moduleFile = [];
         moduleFile.push(`import { $Module, $Constants, $Bucket, $Message, $Job, $Resource, $Machine, $Controller, $Queue } from '${nesoiPath}/lib/elements';`);
@@ -118,6 +140,71 @@ class DumpStage {
         moduleFile.push(`import { NesoiDatetime } from '${nesoiPath}/lib/engine/data/datetime';`);
         moduleFile.push(`import { NesoiDecimal } from '${nesoiPath}/lib/engine/data/decimal';`);
         moduleFile.push(`import { NesoiFile } from '${nesoiPath}/lib/engine/data/file';`);
+        // Get external modules
+        const moduleDependencies = new Set();
+        // Pre-populate from cache
+        if (this.cache) {
+            this.cache.modules[module.lowName]?.dependencies.modules.forEach(module => {
+                if (module in this.compiler.modules) {
+                    moduleDependencies.add(module);
+                }
+            });
+        }
+        // Extract from updated elements
+        const externalElement = module.elements
+            .find(el => el.$t === 'externals');
+        if (externalElement) {
+            for (const module of externalElement.getModuleDependencies()) {
+                moduleDependencies.add(module);
+            }
+        }
+        // Dump external imports
+        moduleFile.push(...Array.from(moduleDependencies)
+            .map(module => `import ${name_helpers_1.NameHelpers.nameLowToHigh(module)}Module from './${module}.module'`));
+        (_a = this.cache.modules)[_b = module.lowName] ?? (_a[_b] = {
+            dependencies: {
+                modules: []
+            }
+        });
+        this.cache.modules[module.lowName].dependencies.modules = Array.from(moduleDependencies);
+        // Build module type (with all elements)
+        const type = this.makeModuleType(module);
+        this.cache.types.modules[module.lowName] = type;
+        // Dump module type
+        moduleFile.push('');
+        moduleFile.push('/**');
+        moduleFile.push(` *  ${module.typeName}`);
+        moduleFile.push(' */');
+        moduleFile.push('');
+        let moduleDump = `export default interface ${module.typeName} extends $Module `;
+        moduleDump += dump_helpers_1.DumpHelpers.dumpType({
+            // Constants should be unknown by default, since enum types
+            // are validated across modules. The default type causes
+            // the enum alias to be keyof ... & Record<string, ...>, which
+            // invalidated the type assertion
+            constants: 'Omit<$Constants, \'values\'|\'enums\'> & { values: {}, enums: {} }',
+            ...type
+        });
+        moduleFile.push(moduleDump);
+        moduleFile.push('');
+        moduleFile.push('/* */');
+        moduleFile.push('');
+        // Dump authentication users
+        moduleFile.push(`type AuthnUsers = ${dump_helpers_1.DumpHelpers.dumpType(spaceType.authnUsers)}`);
+        // Dump other elements
+        module.elements
+            .filter(el => el.$t !== 'externals')
+            .forEach((element) => {
+            const type = element.dumpTypeSchema(this.cache);
+            this.cache.types.elements[element.tag] = type;
+            moduleFile.push(this.cache.types.elements[element.tag]);
+        });
+        // Write to file
+        const moduleFilename = `../${module.lowName}.module`;
+        const moduleFilepath = path_1.default.resolve(dumpDir, moduleFilename + '.ts');
+        fs.writeFileSync(moduleFilepath, moduleFile.join('\n'));
+    }
+    makeModuleType(module) {
         // Build module type (with all blocks)
         const type = {
             name: `'${module.lowName}'`,
@@ -131,6 +218,19 @@ class DumpStage {
             queues: {},
             controllers: {},
         };
+        // Merge types that currently exist and are found on cache
+        const typeCache = this.cache.types.modules[module.lowName];
+        if (typeCache) {
+            type.externals = typeCache.externals || 'any';
+            type.constants = typeCache.constants || 'any';
+            for (const eltype of ['buckets', 'messages', 'jobs', 'resources', 'machines', 'queues', 'controllers']) {
+                for (const name in typeCache[eltype] || {}) {
+                    if (name in module.module.schema[eltype]) {
+                        type[eltype][name] = typeCache[eltype][name];
+                    }
+                }
+            }
+        }
         const externals = module.elements.find(el => el.$t === 'externals');
         // Inject external node types on module
         if (externals) {
@@ -171,43 +271,7 @@ class DumpStage {
             .filter(el => el.$t === 'message')
             .map(el => el.typeName));
         type['#authn'] = 'AuthnUsers';
-        // Dump external elements (imports)
-        module.elements
-            .filter(el => el.$t === 'externals')
-            .forEach((element) => {
-            moduleFile.push(element.dumpTypeSchema());
-        });
-        // Dump module type
-        moduleFile.push('');
-        moduleFile.push('/**');
-        moduleFile.push(` *  ${module.typeName}`);
-        moduleFile.push(' */');
-        moduleFile.push('');
-        let moduleDump = `export default interface ${module.typeName} extends $Module `;
-        moduleDump += dump_helpers_1.DumpHelpers.dumpType({
-            // Constants should be unknown by default, since enum types
-            // are validated across modules. The default type causes
-            // the enum alias to be keyof ... & Record<string, ...>, which
-            // invalidated the type assertion
-            constants: 'Omit<$Constants, \'values\'|\'enums\'> & { values: {}, enums: {} }',
-            ...type
-        });
-        moduleFile.push(moduleDump);
-        moduleFile.push('');
-        moduleFile.push('/* */');
-        moduleFile.push('');
-        // Dump authentication users
-        moduleFile.push(`type AuthnUsers = ${dump_helpers_1.DumpHelpers.dumpType(spaceType.authnUsers)}`);
-        // Dump other elements
-        module.elements
-            .filter(el => el.$t !== 'externals')
-            .forEach((element) => {
-            moduleFile.push(element.dumpTypeSchema());
-        });
-        // Write to file
-        const moduleFilename = `../${module.lowName}.module`;
-        const moduleFilepath = path_1.default.resolve(dumpDir, moduleFilename + '.ts');
-        fs.writeFileSync(moduleFilepath, moduleFile.join('\n'));
+        return type;
     }
 }
 exports.DumpStage = DumpStage;

package/lib/compiler/stages/8_diagnose_stage.js

@@ -21,6 +21,7 @@ class DiagnoseStage {
     }
     async run() {
         log_1.Log.info('compiler', 'stage.diagnose', 'Diagnosing space files with TypeScript...');
+        const t0 = new Date().getTime();
         const { tsCompiler, tree } = this.compiler;
         // Recreate TS program, to load new version of types
         tsCompiler.createProgram();
@@ -41,6 +42,8 @@ class DiagnoseStage {
         filepaths.forEach(filepath => {
             tsCompiler.check(filepath);
         });
+        const t = new Date().getTime();
+        log_1.Log.debug('compiler', 'stage.diagnose', `[t: ${(t - t0) / 1000} ms]`);
     }
 }
 exports.DiagnoseStage = DiagnoseStage;

package/lib/compiler/treeshake.d.ts

@@ -2,6 +2,7 @@ import { $Dependency, BuilderNode } from "../engine/dependency";
 import { BucketGraphBuilder } from "../elements/entities/bucket/graph/bucket_graph.builder";
 import { AnyModule } from "../engine/module";
 import { $BucketModelFields } from "../elements/entities/bucket/model/bucket_model.schema";
+import { ProgressiveBuildCache } from './progressive';
 export type TreeshakeConfig = {
     exclude?: string[];
 };
@@ -28,14 +29,16 @@ export declare class Treeshake {
         inlines: BuilderNode[];
     };
     static controller(node: BuilderNode): void;
-    static queue(node: BuilderNode): void;
+    static queue(node: BuilderNode): {
+        inlines: BuilderNode[];
+    };
     /**
      * Scans the module directory, imports the builders and lists
      * all nodes found.
      *
      * @returns A list of all `BuilderNodes` found on the module folder
      */
-    static module(module: AnyModule, config?: TreeshakeConfig): Promise<BuilderNode[]>;
+    static module(module: AnyModule, cache: ProgressiveBuildCache, config?: TreeshakeConfig): Promise<BuilderNode[]>;
     /**
      * Shakes a file to find all the builders declared on that file, and returns
      * them as BuilderNodes:

package/lib/compiler/treeshake.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Treeshake = void 0;
 const dependency_1 = require("../engine/dependency");
@@ -8,6 +11,8 @@ const log_1 = require("../engine/util/log");
 const string_1 = require("../engine/util/string");
 const error_1 = require("../engine/data/error");
 const constants_builder_1 = require("../elements/entities/constants/constants.builder");
+const progressive_1 = require("./progressive");
+const path_1 = __importDefault(require("path"));
 class Treeshake {
     /* Externals */
     static externals(node, depth = 1) {
@@ -191,8 +196,15 @@ class Treeshake {
         node.dependencies = [];
     }
     static queue(node) {
-        const b = node.builder;
-        node.dependencies = [];
+        const builder = node.builder;
+        log_1.Log.trace('compiler', 'treeshake', `└ Treeshaking node ${(0, log_1.scopeTag)(builder.$b, node.name)}`);
+        const inlineTreeshake = Treeshake.blockInlineNodes(node);
+        node.dependencies = [
+            ...Treeshake.blockIO(node),
+            ...inlineTreeshake.dependencies
+        ];
+        node.dependencies = this.cleanNodeDependencies(node);
+        return { inlines: inlineTreeshake.inlines };
     }
     /* Module */
     /**
@@ -201,7 +213,7 @@ class Treeshake {
      *
      * @returns A list of all `BuilderNodes` found on the module folder
      */
-    static async module(module, config) {
+    static async module(module, cache, config) {
         log_1.Log.debug('compiler', 'treeshake', `Treeshaking ${(0, log_1.scopeTag)('module', module.name)}`);
         const nodes = [];
         const merge = (node) => {
@@ -230,7 +242,7 @@ class Treeshake {
         if (module.boot && 'dirpath' in module.boot) {
             const files = module.scanFiles(module.boot.dirpath, config?.exclude);
             for (const file of files) {
-                const fileNodes = await Treeshake.file(module.name, file);
+                const fileNodes = await Treeshake.file(module.name, file, cache);
                 fileNodes.forEach(merge);
             }
         }
@@ -254,7 +266,13 @@ class Treeshake {
      * - Inline builders
      * - Nested inline builders
      */
-    static async file(module, filepath) {
+    static async file(module, filepath, cache) {
+        if (cache && filepath in cache.files) {
+            const nodes = await progressive_1.ProgressiveBuild.treeshake(cache, filepath);
+            if (nodes) {
+                return nodes;
+            }
+        }
         log_1.Log.debug('compiler', 'treeshake', ` └ Treeshaking file ${(0, string_1.colored)(filepath, 'blue')}`);
         // Require is used here to avoid cache - which allows watch mode
         delete require.cache[filepath];
@@ -272,6 +290,10 @@ class Treeshake {
             nodes.push(...Treeshake.builder(module, builder, filepath));
         }
         log_1.Log.debug('compiler', 'treeshake', ` - Nodes: ${(0, string_1.colored)(nodes.map(node => node.tag).join(', '), 'purple')}`);
+        cache.files[filepath] = {
+            type: nodes.map(node => node.type),
+            elements: nodes.map(node => path_1.default.join(cache.nesoidir, module, `${node.type}__${node.name}.ts`)).flat(1)
+        };
         return nodes;
     }
     /**
@@ -341,7 +363,14 @@ class Treeshake {
             Treeshake.controller(node);
         }
         else if (builder.$b === 'queue') {
-            Treeshake.queue(node);
+            const { inlines } = Treeshake.queue(node);
+            inlines.forEach(inline => {
+                nodes.push({
+                    ...inline,
+                    module,
+                    filepath
+                });
+            });
         }
         else {
             throw error_1.NesoiError.Module.UnknownBuilderType({}, filepath, '', builder.$b);
@@ -382,9 +411,13 @@ class Treeshake {
         }))
             .sort((a, b) => a.tag.localeCompare(b.tag))
             .forEach(({ node, tag }) => {
-            log_1.Log.trace('compiler', 'treeshake', `${'  '.repeat(depth)} └ ${tag} ` + (0, string_1.colored)(`@ ${node.filepath}`, 'purple'));
+            log_1.Log.debug('compiler', 'treeshake', `${'  '.repeat(depth)} └ ${tag} ` + (0, string_1.colored)(`@ ${node.filepath}`, 'purple'));
+            if (node.progressive) {
+                log_1.Log.debug('compiler', 'treeshake', `${'  '.repeat(depth + 1)}` + (0, string_1.colored)('[cache]', 'green'));
+                return;
+            }
             if (node.dependencies.length) {
-                log_1.Log.trace('compiler', 'treeshake', (0, string_1.colored)(`${'  '.repeat(depth)}   (depends on: ${node.dependencies.map(dep => dep.tag).join(', ')})`, 'purple'));
+                log_1.Log.debug('compiler', 'treeshake', (0, string_1.colored)(`${'  '.repeat(depth)}   (depends on: ${node.dependencies.map(dep => dep.tag).join(', ')})`, 'purple'));
             }
             if ('_inlineNodes' in node.builder) {
                 const inlineNodes = node.builder['_inlineNodes'];

package/lib/compiler/typescript/bridge/inject.js

@@ -7,6 +7,8 @@ class TSBridgeInject {
     static inject(compiler, nodes) {
         const { tsCompiler } = compiler;
         nodes.forEach(node => {
+            if (node.progressive)
+                return;
             log_1.Log.debug('compiler', 'bridge.inject', `Injecting TS code on ${node.tag}`);
             const schema = node.schema;
             if (schema.$t === 'bucket') {

package/lib/compiler/typescript/transformers/app_inject.transformer.js

@@ -60,7 +60,7 @@ function makeAppInjectTransformer(modules) {
                     monolyth = true;
                 return deep.node;
             }, context);
-            // Transform .modules() into .prebuilt()
+            // Transform .modules() into .inject()
             if (monolyth
                 && ts.isCallExpression(cNode)
                 && ts.isPropertyAccessExpression(cNode.expression)

package/lib/elements/blocks/resource/resource.js

@@ -91,7 +91,7 @@ class Resource extends block_1.Block {
     static query($) {
         const scope = $.job.scope;
         return $.trx.bucket(scope.bucket)
-            .query($.msg.query).page({
+            .viewQuery($.msg.query).page({
             page: $.msg.page,
             perPage: $.msg.perPage,
             count: true

package/lib/elements/entities/bucket/bucket.d.ts

@@ -11,6 +11,7 @@ import { NQL_Result } from './query/nql_engine';
 import { $BucketModelFields } from './model/bucket_model.schema';
 import { DriveAdapter } from '../drive/drive_adapter';
 import { IService } from "../../../engine/apps/service";
+import { AnyModule } from "../../../engine/module";
 /**
  * **This should only be used inside a `#composition` of a bucket `create`** to refer to the parent id, which doesn't exist yet.
  *
@@ -26,6 +27,7 @@ export declare const $id: string | number;
  * @subcategory Entity
  * */
 export declare class Bucket<M extends $Module, $ extends $Bucket> {
+    module: AnyModule;
     schema: $;
     private config?;
     services: Record<string, IService>;
@@ -34,7 +36,7 @@ export declare class Bucket<M extends $Module, $ extends $Bucket> {
     graph: BucketGraph<M, $>;
     private views;
     drive?: DriveAdapter;
-    constructor(schema: $, config?: BucketConfig<any, any, any> | undefined, services?: Record<string, IService>);
+    constructor(module: AnyModule, schema: $, config?: BucketConfig<any, any, any> | undefined, services?: Record<string, IService>);
     getQueryMeta(): {
         bucket: $;
         scope: string;

package/lib/elements/entities/bucket/bucket.js

@@ -12,6 +12,7 @@ const datetime_1 = require("../../../engine/data/datetime");
 const tree_1 = require("../../../engine/data/tree");
 const crypto_1 = require("../../../engine/util/crypto");
 const bucket_model_schema_1 = require("./model/bucket_model.schema");
+const trash_1 = require("../../../engine/data/trash");
 /**
  * **This should only be used inside a `#composition` of a bucket `create`** to refer to the parent id, which doesn't exist yet.
  *
@@ -27,7 +28,8 @@ exports.$id = Symbol('FUTURE ID OF CREATE');
  * @subcategory Entity
  * */
 class Bucket {
-    constructor(schema, config, services = {}) {
+    constructor(module, schema, config, services = {}) {
+        this.module = module;
         this.schema = schema;
         this.config = config;
         this.services = services;
@@ -506,18 +508,19 @@ class Bucket {
             throw error_1.NesoiError.Bucket.InvalidId({ bucket: this.schema.alias, id });
         }
         // Read object, if safe, to check if it exists
-        if (!options?.unsafe) {
+        let result;
+        if (this.module.trash || !options?.unsafe) {
             // Tenancy
             const tenancy = (options?.no_tenancy)
                 ? undefined
                 : this.getTenancyQuery(trx);
             // Check if object exists
-            const result = await this.adapter.query(trx, {
+            result = await this.adapter.query(trx, {
                 id, '#and': tenancy
             }, { perPage: 1 }, undefined, {
                 metadataOnly: true
             });
-            if (!result.data.length) {
+            if (!result.data.length && !options?.unsafe) {
                 throw error_1.NesoiError.Bucket.ObjNotFound({ bucket: this.schema.alias, id });
             }
         }
@@ -542,6 +545,10 @@ class Bucket {
             }
         }
         // Delete the object itself
+        if (this.module.trash) {
+            const obj = result.data[0];
+            await trash_1.Trash.add(trx, this.module, this.schema.name, obj);
+        }
         await this.adapter.delete(trx, id);
         // Composition (with self key)
         for (const link of Object.values(this.schema.graph.links)) {
@@ -574,13 +581,14 @@ class Bucket {
     async deleteMany(trx, ids, options) {
         log_1.Log.debug('bucket', this.schema.name, `Delete Many ids=${ids}`);
         // Filter ids, if safe, to check if it exists
-        if (!options?.unsafe) {
+        let result;
+        if (this.module.trash || !options?.unsafe) {
             // Tenancy
             const tenancy = (options?.no_tenancy)
                 ? undefined
                 : this.getTenancyQuery(trx);
             // Filter ids
-            const result = await this.adapter.query(trx, {
+            result = await this.adapter.query(trx, {
                 'id in': ids,
                 '#and': tenancy
             }, undefined, undefined, {
@@ -606,6 +614,10 @@ class Bucket {
                 }
             }
         }
+        if (this.module.trash) {
+            const objs = result.data;
+            await trash_1.Trash.addMany(trx, this.module, this.schema.name, objs);
+        }
         await this.adapter.deleteMany(trx, ids);
         // Composition (with self key)
         for (const link of Object.values(this.schema.graph.links)) {

package/lib/engine/apps/app.config.d.ts

@@ -8,10 +8,11 @@ import { App } from './app';
 import { IService } from './service';
 import { CLIConfig } from '../cli/cli';
 import { BucketAdapter } from "../../elements/entities/bucket/adapters/bucket_adapter";
-import { TrashObj } from '../data/trash';
+import { $TrashBucket } from '../data/trash';
 import { $Bucket } from "../../elements";
 import { Overlay } from '../util/type';
 import { TrxStatus } from '../transaction/trx';
+import { NesoiObj } from '../data/obj';
 export type AppConfig<S extends $Space, Modules extends ModuleName<S>> = {
     i18n?: AppI18nConfig;
     authn?: AppAuthnConfig<S>;
@@ -20,6 +21,7 @@ export type AppConfig<S extends $Space, Modules extends ModuleName<S>> = {
     cli?: CLIConfig<any>;
     compiler?: CompilerConfig;
     trxEngine?: AppTrxEngineConfig<S, Modules, any>;
+    trash?: AppTrashConfig<S, Modules, any>;
 };
 export type AnyAppConfig = AppConfig<any, any>;
 export type AppI18nConfig = {
@@ -33,11 +35,11 @@ export type AppBucketConfig<S extends $Space, Modules extends ModuleName<S>, Ser
         [K in keyof S['modules'][M]['buckets']]: BucketConfig<S['modules'][M], S['modules'][M]['buckets'][K], Services>;
     }>;
 }>;
-export type AppTrashConfig = {
-    adapter: ($: Overlay<$Bucket, {
-        '#data': TrashObj;
-    }>) => BucketAdapter<TrashObj>;
-};
+export type AppTrashConfig<S extends $Space, Modules extends ModuleName<S>, Services extends Record<string, IService>> = Partial<{
+    [M in (Modules & keyof S['modules'])]: {
+        adapter?: (schema: typeof $TrashBucket, services: Services) => BucketAdapter<typeof $TrashBucket['#data']>;
+    };
+}>;
 export type AppControllerConfig<S extends $Space, Modules extends ModuleName<S>, Services extends Record<string, IService>> = Partial<{
     [M in (Modules & keyof S['modules'])]: Partial<{
         [K in keyof S['modules'][M]['controllers']]: ControllerConfig<S['modules'][M], S['modules'][M]['controllers'][K], Services>;
@@ -48,8 +50,8 @@ export type AppTrxEngineConfig<S extends $Space, Modules extends ModuleName<S>,
 }>;
 export type AppAuditConfig = {
     adapter: ($: Overlay<$Bucket, {
-        '#data': TrashObj;
-    }>) => BucketAdapter<TrashObj>;
+        '#data': NesoiObj;
+    }>) => BucketAdapter<NesoiObj>;
     transform?: (trx: TrxStatus<any>) => Record<string, any>;
 };
 /**
@@ -65,7 +67,7 @@ export declare class AppConfigFactory<S extends $Space, Modules extends string =
     i18n(config: AppI18nConfig): _App;
     authn(config: AppAuthnConfig<S>): _App;
     buckets(config: AppBucketConfig<S, Modules, Services>): _App;
-    trash(config: AppTrashConfig): _App;
+    trash(config: AppTrashConfig<S, Modules, Services>): _App;
     controllers(config: AppControllerConfig<S, Modules, Services>): _App;
     audit(config: AppI18nConfig): _App;
     compiler(config: CompilerConfig): _App;

package/lib/engine/apps/app.config.js

@@ -25,8 +25,7 @@ class AppConfigFactory {
         return this.app;
     }
     trash(config) {
-        // TODO
-        // this.config.buckets = config as never;
+        this.config.trash = config;
         return this.app;
     }
     controllers(config) {

package/lib/engine/apps/app.js

@@ -74,9 +74,9 @@ class App {
     makeModules() {
         const modules = {};
         if (this.space) {
-            space_1.Space.scan(this.space, (name, path) => {
+            space_1.Space.scan(this.space, (name, path, subdir) => {
                 if (this._spaceModuleNames.includes(name)) {
-                    modules[name] = new module_1.Module(name, { dirpath: path });
+                    modules[name] = new module_1.Module(name, { dirpath: path }, subdir);
                 }
             });
         }