nesoi 3.0.13 → 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/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);
                 }
             });
         }

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

@@ -1,6 +1,6 @@
 import { NesoiObj } from './obj';
 import { AnyTrxNode } from '../transaction/trx_node';
-import { $Bucket } from "../../elements";
+import { $Bucket } from "../../elements/entities/bucket/bucket.schema";
 import { AnyModule } from '../module';
 export type TrashObj = {
     id: number;

package/lib/engine/data/trash.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trash = exports.$TrashBucket = void 0;
-const elements_1 = require("../../elements");
+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 elements_1.$Bucket('__trash__', 'trash', 'Trash', new bucket_model_schema_1.$BucketModel({
+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),

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

@@ -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]>; };
@@ -101,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

@@ -79,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),

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/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 {};