nesoi 3.1.8 → 3.2.1

package/lib/compiler/apps/distributed/stages/4_dump_modules_stage.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DumpModulesStage = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const log_1 = require("../../../../engine/util/log");
+const app_1 = require("../../../../engine/apps/app");
+/**
+ * [distributed Compiler Stage #4]
+ * Dump modules to build/modules folder.
+ *
+ * @category distributed Compiler
+ * @subcategory Stages
+ */
+class DumpModulesStage {
+    constructor(distributed, app) {
+        this.distributed = distributed;
+        this.app = app;
+    }
+    async run() {
+        const { compiler, dirs: _dirs } = this.distributed;
+        for (const name in this.app.nodes) {
+            log_1.Log.info('compiler', 'distributed', `[${name}] Dumping modules to build/modules folder...`);
+            const node = this.app.nodes[name];
+            const info = app_1.App.getInfo(node);
+            const dirs = _dirs.nodes[name];
+            for (const name of info.spaceModules) {
+                const module = compiler.modules[name];
+                this.dumpModule(module, dirs.build_modules);
+            }
+        }
+    }
+    dumpModule(module, dir) {
+        log_1.Log.debug('compiler', 'distributed', `Dumping module ${module.lowName}`);
+        let str = `const { Module } = require('${module.compiler.config?.nesoiPath || 'nesoi'}/lib/engine/module');\n`;
+        str += `exports.default = new Module('${module.lowName}')\n`;
+        str += '  .inject({';
+        const externals = module.module.schema.externals;
+        if (externals) {
+            str += '\n    externals: {';
+            if (Object.keys(externals.buckets).length) {
+                str += '\n      buckets: {';
+                for (const b in externals.buckets) {
+                    const dep = externals.buckets[b];
+                    str += `\n        '${b}': ${JSON.stringify(dep, undefined, 2).replace(/\n/g, '\n        ')},`;
+                }
+                str += '\n      },';
+            }
+            if (Object.keys(externals.messages).length) {
+                str += '\n      messages: {';
+                for (const b in externals.messages) {
+                    const dep = externals.messages[b];
+                    str += `\n        '${b}': ${JSON.stringify(dep, undefined, 2).replace(/\n/g, '\n        ')},`;
+                }
+                str += '\n      },';
+            }
+            if (Object.keys(externals.jobs).length) {
+                str += '\n      jobs: {\n';
+                for (const b in externals.jobs) {
+                    const dep = externals.jobs[b];
+                    str += `\n        '${b}': ${JSON.stringify(dep, undefined, 2).replace(/\n/g, '\n        ')},`;
+                }
+                str += '\n      },';
+            }
+            if (Object.keys(externals.machines).length) {
+                str += '\n      machines: {\n';
+                for (const b in externals.machines) {
+                    const dep = externals.machines[b];
+                    str += `\n        '${b}': ${JSON.stringify(dep, undefined, 2).replace(/\n/g, '\n        ')},`;
+                }
+                str += '\n      },';
+            }
+            str += '\n    },';
+        }
+        const constants = module.module.schema.constants;
+        if (constants && (Object.values(constants.values).length || Object.values(constants.enums).length)) {
+            str += `\n    constants: require('./${module.lowName}/constants__${module.lowName}').default,`;
+        }
+        const buckets = Object.values(module.module.schema.buckets || {});
+        if (buckets.length) {
+            str += '\n    buckets: [\n';
+            buckets.forEach(bucket => {
+                str += `      require('./${module.lowName}/bucket__${bucket.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const messages = Object.values(module.module.schema.messages || {});
+        if (messages.length) {
+            str += '\n    messages: [\n';
+            messages.forEach(message => {
+                str += `      require('./${module.lowName}/message__${message.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const jobs = Object.values(module.module.schema.jobs || {});
+        if (jobs.length) {
+            str += '\n    jobs: [\n';
+            jobs.forEach(job => {
+                str += `      require('./${module.lowName}/job__${job.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const resources = Object.values(module.module.schema.resources || {});
+        if (resources.length) {
+            str += '\n    resources: [\n';
+            resources.forEach(resource => {
+                str += `      require('./${module.lowName}/resource__${resource.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const machines = Object.values(module.module.schema.machines || {});
+        if (machines.length) {
+            str += '\n    machines: [\n';
+            machines.forEach(machine => {
+                str += `      require('./${module.lowName}/machine__${machine.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const controllers = Object.values(module.module.schema.controllers || {});
+        if (controllers.length) {
+            str += '\n    controllers: [\n';
+            controllers.forEach(controller => {
+                str += `      require('./${module.lowName}/controller__${controller.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const queues = Object.values(module.module.schema.queues || {});
+        if (queues.length) {
+            str += '\n    queues: [\n';
+            queues.forEach(queue => {
+                str += `      require('./${module.lowName}/queue__${queue.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const topics = Object.values(module.module.schema.topics || {});
+        if (topics.length) {
+            str += '\n    topics: [\n';
+            topics.forEach(topic => {
+                str += `      require('./${module.lowName}/topic__${topic.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        str += '})';
+        const moduleFilename = `${module.lowName}.js`;
+        const modulePath = path.resolve(dir, moduleFilename);
+        fs.writeFileSync(modulePath, str);
+    }
+}
+exports.DumpModulesStage = DumpModulesStage;

package/lib/compiler/apps/distributed/stages/5_copy_static_stage.js

@@ -0,0 +1,31 @@
+"use strict";
+// import * as fs from 'fs';
+// import * as path from 'path';
+// import { Log } from '~/engine/util/log';
+// import { MonolythApp } from '~/engine/apps/monolyth/monolyth.app';
+// import { MonolythCompiler } from '../monolyth_compiler';
+// import { Space } from '~/engine/space';
+// /**
+//  * [Monolyth Compiler Stage #5]
+//  * Copy the paths passed to `staticPaths` on the compiler
+//  * config to the build folder.
+//  * 
+//  * @category Monolyth Compiler
+//  * @subcategory Stages
+//  */
+// export class CopyStaticStage {
+//     public constructor(
+//         private monolyth: MonolythCompiler,
+//         private app: MonolythApp<any, any>
+//     ) {}
+//     public async run() {
+//         Log.info('compiler', 'monolyth', 'Copying static paths to build folder...')
+//         for (const staticPath of this.monolyth.config.staticPaths || []) {
+//             const from = Space.path(this.monolyth.compiler.space, staticPath);
+//             const to = path.join(this.monolyth.dirs.build, staticPath);
+//             fs.cpSync(from, to, {
+//                 recursive: true
+//             })
+//         }
+//     }
+// }

package/lib/compiler/apps/distributed/stages/6_dump_cli_stage.js

@@ -0,0 +1,34 @@
+"use strict";
+// import * as fs from 'fs';
+// import * as path from 'path';
+// import { Log } from '~/engine/util/log';
+// import { MonolythApp } from '~/engine/apps/monolyth/monolyth.app';
+// import { MonolythCompiler } from '../monolyth_compiler';
+// /**
+//  * [Monolyth Compiler Stage #6]
+//  * Dump the cli.js file to build/bin folder.
+//  * 
+//  * @category Monolyth Compiler
+//  * @subcategory Stages
+//  */
+// export class DumpCLIStage {
+//     public constructor(
+//         private monolyth: MonolythCompiler,
+//         private app: MonolythApp<any, any>
+//     ) {}
+//     public async run() {
+//         Log.info('compiler', 'monolyth', 'Dumping cli.js file to build/bin folder...')
+//         const { dirs } = this.monolyth;
+//         let str = '';
+//         str += 'require("nesoi/tools/dotenv");\n';
+//         str += 'const app = require(\'../app\').default\n';
+//         str += 'const { Log } = require(\'nesoi/lib/engine/util/log\');\n';
+//         str += 'Log.level = \'debug\';\n'
+//         str += '\n';
+//         str += '(async () => {\n';
+//         str += '  (await app.daemon()).cli();\n';
+//         str += '})()'
+//         const filePath = path.resolve(dirs.build_bin, 'cli.js')
+//         fs.writeFileSync(filePath, str);
+//     }
+// }

package/lib/compiler/apps/distributed/stages/7_dump_package_json_stage.js

@@ -0,0 +1,45 @@
+"use strict";
+// import * as fs from 'fs';
+// import * as path from 'path';
+// import { Log } from '~/engine/util/log';
+// import { MonolythCompiler } from '../monolyth_compiler';
+// import { Space } from '~/engine/space';
+// import { MonolythApp } from '~/engine/apps/monolyth/monolyth.app';
+// /**
+//  * [Monolyth Compiler Stage #7]
+//  * Dump the package.json file to build folder.
+//  * 
+//  * @category Monolyth Compiler
+//  * @subcategory Stages
+//  */
+// export class DumpPackageJsonStage {
+//     public constructor(
+//         private monolyth: MonolythCompiler,
+//         private app: MonolythApp<any, any>
+//     ) {}
+//     public async run() {
+//         Log.info('compiler', 'monolyth', 'Dumping package.json to build folder...')
+//         const { config, compiler, dirs } = this.monolyth;
+//         const packageJsonPath = config.nesoiPath
+//             ? path.join(config.nesoiPath, 'package.json')
+//             : path.join('..', '..', '..', '..', '..', 'package.json');
+//         const nesoiPackageJson = await import(packageJsonPath);
+//         const spacePackageJson = await import(Space.path(compiler.space,'package.json'));
+//         const filePath = path.resolve(dirs.build, 'package.json');
+//         const scripts: Record<string, string> = {
+//             cli: 'node bin/cli.js'
+//         };
+//         Object.entries(config.scripts || {}).forEach(([name, path]) => {
+//             const jspath = path.replace(/\.ts/,'.js');
+//             scripts[name] = `node ${jspath}`;
+//         });
+//         const dependencies = {
+//             ...spacePackageJson.dependencies,
+//             nesoi: config.nesoiPath
+//                 ? `file:${config.nesoiPath}`
+//                 : nesoiPackageJson.version
+//         }
+//         const packageJson = MonolythApp.package(this.app, scripts, dependencies);
+//         fs.writeFileSync(filePath, JSON.stringify(packageJson, undefined, 2))
+//     }
+// }

package/lib/compiler/elements/element.js

@@ -93,9 +93,9 @@ class Element {
             return msgName.type;
         });
         const objs = schema.output?.obj?.map(bucket => {
-            const schema = compiler.tree.getSchema(bucket);
+            const schema = compiler.tree.getSchema(bucket.dep);
             const bucketName = name_helpers_1.NameHelpers.names(schema);
-            return bucketName.high;
+            return bucketName.high + (bucket.many ? '[]' : '');
         });
         const type = [
             raw,

package/lib/compiler/index.d.ts

@@ -1,2 +1,3 @@
 export { Compiler } from './compiler';
 export { MonolythCompiler } from './apps/monolyth/monolyth_compiler';
+export { DistributedCompiler } from './apps/distributed/distributed_compiler';

package/lib/compiler/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonolythCompiler = exports.Compiler = void 0;
+exports.DistributedCompiler = exports.MonolythCompiler = exports.Compiler = void 0;
 var compiler_1 = require("./compiler");
 Object.defineProperty(exports, "Compiler", { enumerable: true, get: function () { return compiler_1.Compiler; } });
 var monolyth_compiler_1 = require("./apps/monolyth/monolyth_compiler");
 Object.defineProperty(exports, "MonolythCompiler", { enumerable: true, get: function () { return monolyth_compiler_1.MonolythCompiler; } });
+var distributed_compiler_1 = require("./apps/distributed/distributed_compiler");
+Object.defineProperty(exports, "DistributedCompiler", { enumerable: true, get: function () { return distributed_compiler_1.DistributedCompiler; } });

package/lib/elements/blocks/block.builder.d.ts

@@ -30,4 +30,5 @@ export declare abstract class BlockBuilder<Space extends $Space, Module extends
     protected outputRaw(): unknown;
     protected outputMsg(...msgs: string[]): unknown;
     protected outputObj(...objs: string[]): unknown;
+    protected outputObjs(...objs: string[]): unknown;
 }

package/lib/elements/blocks/block.builder.js

@@ -79,7 +79,22 @@ class BlockBuilder {
         this._output ?? (this._output = {});
         (_a = this._output).obj ?? (_a.obj = []);
         objs.forEach(obj => {
-            this._output?.obj?.push(new dependency_1.$Dependency(this.module, 'bucket', obj, true));
+            this._output?.obj?.push({
+                dep: new dependency_1.$Dependency(this.module, 'bucket', obj, true),
+                many: false
+            });
+        });
+        return this;
+    }
+    outputObjs(...objs) {
+        var _a;
+        this._output ?? (this._output = {});
+        (_a = this._output).obj ?? (_a.obj = []);
+        objs.forEach(obj => {
+            this._output?.obj?.push({
+                dep: new dependency_1.$Dependency(this.module, 'bucket', obj, true),
+                many: true
+            });
         });
         return this;
     }

package/lib/elements/blocks/block.schema.d.ts

@@ -6,7 +6,10 @@ export type $BlockType = 'job' | 'resource' | 'machine' | 'queue' | 'topic';
 export type $BlockOutput = {
     raw?: TypeAsObj;
     msg?: $Dependency[];
-    obj?: $Dependency[];
+    obj?: {
+        dep: $Dependency;
+        many: boolean;
+    }[];
 };
 /**
  * @category Schemas

package/lib/elements/blocks/job/job.builder.d.ts

@@ -51,6 +51,7 @@ export declare class JobBuilder<Space extends $Space, Module extends $Module, Jo
         obj: <BucketName extends keyof Module["buckets"], Bucket extends NoInfer<Module["buckets"][BucketName]>>(...objs: BucketName[]) => JobBuilder<Space, Module, Overlay<Job, {
             "#output": unknown extends Job["#output"] ? Bucket["#data"] : (Job["#output"] | Bucket["#data"]);
         }>, Ctx>;
+        objs: (...objs: string[]) => unknown;
     };
     protected outputRaw<T>(): JobBuilder<Space, Module, Overlay<Job, {
         "#output": unknown extends Job["#output"] ? T : (Job["#output"] | T);

package/lib/elements/blocks/job/job.builder.js

@@ -41,7 +41,8 @@ class JobBuilder extends block_builder_1.BlockBuilder {
         return {
             raw: this.outputRaw.bind(this),
             msg: this.outputMsg.bind(this),
-            obj: this.outputObj.bind(this)
+            obj: this.outputObj.bind(this),
+            objs: this.outputObjs.bind(this)
         };
     }
     outputRaw() {

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

@@ -455,7 +455,7 @@ class Bucket {
         var _a, _b;
         log_1.Log.debug('bucket', this.schema.name, `Put id=${obj['id']}`, obj);
         // Separate composition
-        const composition = obj['#composition'] || {};
+        let composition = obj['#composition'];
         delete obj['#composition'];
         // Add meta (created_by/created_at/updated_by/updated_at)
         this.addMeta(trx, obj, 'create');
@@ -470,6 +470,12 @@ class Bucket {
         // Put
         const _obj = await this.adapter.put(trx, obj);
         // Composition
+        if (composition) {
+            this.replaceFutureId(composition, _obj.id);
+        }
+        else {
+            composition = {};
+        }
         for (const link of Object.values(this.schema.graph.links)) {
             if (link.rel !== 'composition')
                 continue;

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

@@ -13,41 +13,38 @@ 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;
+export type AppModuleConfig<S extends $Space, M extends ModuleName<S>, Services extends Record<string, IService>> = {
+    buckets?: AppBucketConfig<S, M, Services>;
+    trash?: AppTrashConfig<Services>;
+    controllers?: AppControllerConfig<S, M, Services>;
+    trx?: TrxEngineConfig<S, S['modules'][M], any, Services>;
+};
+export type AppConfig<S extends $Space, Modules extends ModuleName<S>, Services extends Record<string, IService>> = {
     authn?: AppAuthnConfig<S>;
-    buckets?: AppBucketConfig<S, Modules, any>;
-    controllers?: AppControllerConfig<S, Modules, any>;
+    modules?: Partial<{
+        [M in (Modules & keyof S['modules'])]: AppModuleConfig<S, M, Services>;
+    }>;
+    i18n?: AppI18nConfig;
     cli?: CLIConfig<any>;
     compiler?: CompilerConfig;
-    trxEngine?: AppTrxEngineConfig<S, Modules, any>;
-    trash?: AppTrashConfig<S, Modules, any>;
 };
-export type AnyAppConfig = AppConfig<any, any>;
+export type AnyAppConfig = AppConfig<any, any, any>;
 export type AppI18nConfig = {
     [x: string]: ($: Record<string, any>) => string;
 };
 export type AppAuthnConfig<S extends $Space> = {
     [K in keyof S['authnUsers']]: () => AuthnProvider<S['authnUsers'][K]>;
 };
-export type AppBucketConfig<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]['buckets']]: BucketConfig<S['modules'][M], S['modules'][M]['buckets'][K], Services>;
-    }>;
-}>;
-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 AppBucketConfig<S extends $Space, M extends keyof S['modules'], Services extends Record<string, IService>> = Partial<{
+    [K in keyof S['modules'][M]['buckets']]: BucketConfig<S['modules'][M], S['modules'][M]['buckets'][K], Services>;
 }>;
-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>;
-    }>;
-}>;
-export type AppTrxEngineConfig<S extends $Space, Modules extends ModuleName<S>, Services extends Record<string, IService>> = Partial<{
-    [M in (Modules & keyof S['modules'])]: TrxEngineConfig<S, S['modules'][M], any, Services>;
+export type AppTrashConfig<Services extends Record<string, IService>> = {
+    adapter?: (schema: typeof $TrashBucket, services: Services) => BucketAdapter<typeof $TrashBucket['#data']>;
+};
+export type AppControllerConfig<S extends $Space, M extends keyof S['modules'], Services extends Record<string, IService>> = Partial<{
+    [K in keyof S['modules'][M]['controllers']]: ControllerConfig<S['modules'][M], S['modules'][M]['controllers'][K], Services>;
 }>;
+export type AppTrxEngineConfig<S extends $Space, M extends keyof S['modules'], Services extends Record<string, IService>> = TrxEngineConfig<S, S['modules'][M], any, Services>;
 export type AppAuditConfig = {
     adapter: ($: Overlay<$Bucket, {
         '#data': NesoiObj;
@@ -60,17 +57,14 @@ export type AppAuditConfig = {
 /**
  * @category App
  */
-export declare class AppConfigFactory<S extends $Space, Modules extends string = ModuleName<S> & string, Services extends Record<string, any> = Record<string, any>, _App = App<S, Modules, Services>> {
+export declare class AppConfigBuilder<S extends $Space, Modules extends string = ModuleName<S> & string, Services extends Record<string, any> = Record<string, any>, _App = App<S, Modules, Services>> {
     private app;
     private config;
     constructor(app: _App);
-    i18n(config: AppI18nConfig): _App;
     authn(config: AppAuthnConfig<S>): _App;
-    buckets(config: AppBucketConfig<S, Modules, Services>): _App;
-    trash(config: AppTrashConfig<S, Modules, Services>): _App;
-    controllers(config: AppControllerConfig<S, Modules, Services>): _App;
+    module<M extends Modules>(name: M, config: AppModuleConfig<S, M, Services>): _App;
     audit(config: AppI18nConfig): _App;
-    compiler(config: CompilerConfig): _App;
+    i18n(config: AppI18nConfig): _App;
     cli(config: CLIConfig<Services>): _App;
-    trx(config: AppTrxEngineConfig<S, Modules, Services>): _App;
+    compiler(config: CompilerConfig): _App;
 }

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

@@ -1,52 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppConfigFactory = void 0;
+exports.AppConfigBuilder = void 0;
 /**
  * Factory
  */
 /**
  * @category App
  */
-class AppConfigFactory {
+class AppConfigBuilder {
     constructor(app) {
         this.app = app;
         this.config = app._config;
     }
-    i18n(config) {
-        this.config.i18n = config;
-        return this.app;
-    }
     authn(config) {
         this.config.authn = config;
         return this.app;
     }
-    buckets(config) {
-        this.config.buckets = config;
-        return this.app;
-    }
-    trash(config) {
-        this.config.trash = config;
-        return this.app;
-    }
-    controllers(config) {
-        this.config.controllers = config;
+    module(name, config) {
+        var _a;
+        (_a = this.config).modules ?? (_a.modules = {});
+        this.config.modules[name] = config;
         return this.app;
     }
     audit(config) {
         this.config.i18n = config;
         return this.app;
     }
-    compiler(config) {
-        this.config.compiler = config;
+    i18n(config) {
+        this.config.i18n = config;
         return this.app;
     }
     cli(config) {
         this.config.cli = config;
         return this.app;
     }
-    trx(config) {
-        this.config.trxEngine = config;
+    compiler(config) {
+        this.config.compiler = config;
         return this.app;
     }
 }
-exports.AppConfigFactory = AppConfigFactory;
+exports.AppConfigBuilder = AppConfigBuilder;

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

@@ -2,8 +2,9 @@ import { $Space, ModuleName } from "../../schema";
 import { AnyBuilder, AnyModule } from '../module';
 import { Space } from '../space';
 import { Daemon } from '../daemon';
-import { AnyAppConfig, AppConfigFactory } from './app.config';
+import { AnyAppConfig, AppConfigBuilder } from './app.config';
 import { IService } from './service';
+import { DistributedAppConfigBuilder } from './distributed/distributed.app.config';
 /**
  * @category App
  */
@@ -37,14 +38,14 @@ export declare abstract class App<S extends $Space, Modules extends string = Mod
      * ⚠ This has no effect on apps without a `Space`, such as `InlineApp`.
      * @param modules A list of names of modules from the current `Space`.
      */
-    modules<M extends ModuleName<S>>(modules: M[]): App<S, M & Modules, Services>;
+    protected modules<M extends ModuleName<S>>(modules: M[]): App<S, M & Modules, Services>;
     /**
      * Injects pre-built modules into this App.
      * These will be included on the Daemon once it starts.
      *
      * @param modules A list of pre-built modules.
      */
-    inject(modules: AnyModule[]): this;
+    protected inject(modules: AnyModule[]): this;
     /**
      * Declares a `Service`.
      *
@@ -52,8 +53,8 @@ export declare abstract class App<S extends $Space, Modules extends string = Mod
      * config to share globals between adapters and other methods.
      * @param $ object with an `up` and `down` method to create/destroy the service
      */
-    service<T extends IService>($: T): App<S, Modules, Services & { [K in T["name"]]: T; }>;
-    get config(): AppConfigFactory<S, Modules, Services>;
+    protected service<T extends IService>($: T): App<S, Modules, Services & { [K in T["name"]]: T; }>;
+    protected get config(): AppConfigBuilder<S, Modules, Services> | DistributedAppConfigBuilder<S, any, Modules, Services>;
     protected makeModules(): Record<string, AnyModule>;
     static getServices(app: AnyApp): Record<string, IService>;
     static getInfo(app: AnyApp): {

package/lib/engine/apps/app.js

@@ -68,7 +68,7 @@ class App {
     }
     //
     get config() {
-        return new app_config_1.AppConfigFactory(this);
+        return new app_config_1.AppConfigBuilder(this);
     }
     // 
     makeModules() {