nesoi 3.0.0

package/lib/compiler/apps/monolyth/stages/1_mkdir_stage.js

@@ -0,0 +1,80 @@
+"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.MkdirStage = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const space_1 = require("../../../../engine/space");
+const log_1 = require("../../../../engine/util/log");
+/**
+ * [Monolyth Compiler Stage #1]
+ * Create the directory structure
+ */
+class MkdirStage {
+    constructor(monolyth, app) {
+        this.monolyth = monolyth;
+        this.app = app;
+    }
+    async run() {
+        log_1.Log.info('compiler', 'monolyth', 'Creating build directory tree');
+        const dirs = this.monolyth.dirs;
+        dirs.build = space_1.Space.path(this.monolyth.compiler.space, 'build', this.app.name);
+        // Remove build folder
+        log_1.Log.debug('compiler', 'monolyth', `Removing folder ${dirs.build}`);
+        fs.rmSync(dirs.build, { recursive: true, force: true });
+        // Create build folder
+        log_1.Log.debug('compiler', 'monolyth', `Creating folder ${dirs.build}`);
+        fs.mkdirSync(dirs.build, { recursive: true });
+        // Create build/modules folder
+        dirs.build_modules = path.resolve(dirs.build, 'modules');
+        log_1.Log.debug('compiler', 'monolyth', `Creating folder ${dirs.build_modules}`);
+        if (!fs.existsSync(dirs.build_modules)) {
+            fs.mkdirSync(dirs.build_modules, { recursive: true });
+        }
+        // Create build/types folder
+        dirs.build_types = path.resolve(dirs.build, 'types');
+        log_1.Log.debug('compiler', 'monolyth', `Creating folder ${dirs.build_types}`);
+        if (!fs.existsSync(dirs.build_types)) {
+            fs.mkdirSync(dirs.build_types, { recursive: true });
+        }
+        // Create build/bin folder
+        dirs.build_bin = path.resolve(dirs.build, 'bin');
+        log_1.Log.debug('compiler', 'monolyth', `Creating folder ${dirs.build_bin}`);
+        if (!fs.existsSync(dirs.build_bin)) {
+            fs.mkdirSync(dirs.build_bin, { recursive: true });
+        }
+    }
+}
+exports.MkdirStage = MkdirStage;

package/lib/compiler/apps/monolyth/stages/2_build_typescript_stage.d.ts

@@ -0,0 +1,12 @@
+import { MonolythApp } from "../../../../engine/apps/monolyth/monolyth.app";
+import { MonolythCompiler } from '../monolyth_compiler';
+/**
+ * [Monolyth Compiler Stage #2]
+ * Build typescript files to build folder
+ */
+export declare class BuildTypescriptStage {
+    private monolyth;
+    private app;
+    constructor(monolyth: MonolythCompiler, app: MonolythApp<any, any>);
+    run(): Promise<void>;
+}

package/lib/compiler/apps/monolyth/stages/2_build_typescript_stage.js

@@ -0,0 +1,128 @@
+"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.BuildTypescriptStage = void 0;
+const ts = __importStar(require("typescript"));
+const path = __importStar(require("path"));
+const space_1 = require("../../../../engine/space");
+const log_1 = require("../../../../engine/util/log");
+const typescript_compiler_1 = require("../../../typescript/typescript_compiler");
+const app_1 = require("../../../../engine/apps/app");
+/**
+ * [Monolyth Compiler Stage #2]
+ * Build typescript files to build folder
+ */
+class BuildTypescriptStage {
+    constructor(monolyth, app) {
+        this.monolyth = monolyth;
+        this.app = app;
+    }
+    async run() {
+        log_1.Log.info('compiler', 'monolyth', 'Building TypeScript files...');
+        const { config, compiler, dirs, appPath } = this.monolyth;
+        const libPaths = (config.libPaths || []).map(path => {
+            return space_1.Space.path(compiler.space, path);
+        });
+        const binFiles = Object.values(config.scripts || {}).map(path => {
+            return space_1.Space.path(compiler.space, path);
+        });
+        const info = app_1.App.getInfo(this.app);
+        const modulePaths = info.spaceModules.map(mod => {
+            return space_1.Space.path(compiler.space, '.nesoi', mod);
+        });
+        const space = compiler.space;
+        const spacePath = space_1.Space.path(space);
+        const libFiles = typescript_compiler_1.TypeScriptCompiler.allFiles(libPaths);
+        const appFile = space_1.Space.path(space, appPath);
+        const nesoiFile = space_1.Space.path(space, 'nesoi.ts');
+        const moduleFiles = typescript_compiler_1.TypeScriptCompiler.allFiles(modulePaths);
+        const replacePaths = {
+            [nesoiFile]: { __remove: true },
+            '$': { __remove: true },
+            [appFile]: path.resolve(dirs.build, 'app.js'),
+            '.nesoi': path.resolve(dirs.build, 'types'),
+        };
+        const tsPaths = {
+            '$': [nesoiFile]
+        };
+        if (config.nesoiPath) {
+            tsPaths['nesoi/*'] = [`${config.nesoiPath}/*`];
+        }
+        this.monolyth.config.libPaths?.forEach(lib => {
+            replacePaths[lib] = path.resolve(dirs.build, lib);
+            tsPaths['.nesoi/*'] = [space_1.Space.path(compiler.space, '.nesoi') + '/*'];
+            tsPaths[lib + '/*'] = [space_1.Space.path(compiler.space, lib) + '/*'];
+        });
+        const dotNesoiPath = space_1.Space.path(compiler.space, '.nesoi');
+        moduleFiles.forEach(moduleFile => {
+            const module = moduleFile.replace(dotNesoiPath, '').split(path.sep)[1];
+            if (!module?.length) {
+                throw new Error(`Unable to find module name from path ${moduleFile}`);
+            }
+            const filename = path.basename(moduleFile).replace(/\.ts$/, '.js');
+            replacePaths[moduleFile] = path.resolve(dirs.build, 'modules', module, filename);
+        });
+        binFiles.forEach(binFile => {
+            const filename = path.basename(binFile).replace(/\.ts$/, '.js');
+            replacePaths[binFile] = path.resolve(dirs.build, 'bin', filename);
+        });
+        const emitCode = typescript_compiler_1.TypeScriptCompiler.compileApp(info.spaceModules, [
+            appFile,
+            ...libFiles,
+            ...binFiles,
+            ...moduleFiles
+        ], {
+            target: ts.ScriptTarget.ES2020,
+            module: ts.ModuleKind.CommonJS,
+            moduleResolution: ts.ModuleResolutionKind.Node10,
+            noEmitOnError: true,
+            declaration: true,
+            strict: true,
+            esModuleInterop: true,
+            paths: {
+                ...tsPaths
+            },
+            rootDir: space_1.Space.path(space),
+            outDir: dirs.build,
+            // Built methods don't carry all the typings, so we disable this check
+            // However, this has been checked before Compiler built them
+            noImplicitAny: false,
+        }, spacePath, dirs.build, replacePaths);
+        if (emitCode !== 0) {
+            throw new Error('One or more TypeScript files contains errors.');
+        }
+    }
+}
+exports.BuildTypescriptStage = BuildTypescriptStage;

package/lib/compiler/apps/monolyth/stages/3_copy_types_stage.d.ts

@@ -0,0 +1,12 @@
+import { MonolythApp } from "../../../../engine/apps/monolyth/monolyth.app";
+import { MonolythCompiler } from '../monolyth_compiler';
+/**
+ * [Monolyth Compiler Stage #3]
+ * Copy type declarations to build/types folder
+ */
+export declare class CopyTypesStage {
+    private monolyth;
+    private app;
+    constructor(monolyth: MonolythCompiler, app: MonolythApp<any, any>);
+    run(): Promise<void>;
+}

package/lib/compiler/apps/monolyth/stages/3_copy_types_stage.js

@@ -0,0 +1,75 @@
+"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.CopyTypesStage = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const space_1 = require("../../../../engine/space");
+const log_1 = require("../../../../engine/util/log");
+const name_helpers_1 = require("../../../helpers/name_helpers");
+const app_1 = require("../../../../engine/apps/app");
+/**
+ * [Monolyth Compiler Stage #3]
+ * Copy type declarations to build/types folder
+ */
+class CopyTypesStage {
+    constructor(monolyth, app) {
+        this.monolyth = monolyth;
+        this.app = app;
+    }
+    async run() {
+        log_1.Log.info('compiler', 'monolyth', 'Copying module and space types from .nesoi to build/types folder...');
+        const { compiler, dirs } = this.monolyth;
+        const info = app_1.App.getInfo(this.app);
+        // Copy module types to types folder
+        for (const key of info.spaceModules) {
+            const module = compiler.modules[key];
+            const from = space_1.Space.path(compiler.space, '.nesoi', module.lowName + '.module.ts');
+            const to = path.resolve(dirs.build_types, module.lowName + '.module.ts');
+            log_1.Log.debug('compiler', 'monolyth', `Copying module types from ${from} to ${to}`);
+            fs.cpSync(from, to, { recursive: true });
+        }
+        // Copy space type to types folder
+        {
+            const space = compiler.space._name;
+            const spaceLow = name_helpers_1.NameHelpers.nameHighToLow(space);
+            const from = space_1.Space.path(compiler.space, '.nesoi', spaceLow + '.ts');
+            const to = path.resolve(dirs.build_types, spaceLow + '.ts');
+            log_1.Log.debug('compiler', 'monolyth', `Copying space types from ${from} to ${to}`);
+            fs.cpSync(from, to, { recursive: true });
+        }
+    }
+}
+exports.CopyTypesStage = CopyTypesStage;

package/lib/compiler/apps/monolyth/stages/4_dump_modules_stage.d.ts

@@ -0,0 +1,13 @@
+import { MonolythApp } from "../../../../engine/apps/monolyth/monolyth.app";
+import { MonolythCompiler } from '../monolyth_compiler';
+/**
+ * [Monolyth Compiler Stage #4]
+ * Dump modules to build/modules folder.
+ */
+export declare class DumpModulesStage {
+    private monolyth;
+    private app;
+    constructor(monolyth: MonolythCompiler, app: MonolythApp<any, any>);
+    run(): Promise<void>;
+    private dumpModule;
+}

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

@@ -0,0 +1,130 @@
+"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");
+/**
+ * [Monolyth Compiler Stage #4]
+ * Dump modules to build/modules folder.
+ */
+class DumpModulesStage {
+    constructor(monolyth, app) {
+        this.monolyth = monolyth;
+        this.app = app;
+    }
+    async run() {
+        log_1.Log.info('compiler', 'monolyth', 'Dumping modules to build/modules folder...');
+        const { compiler, dirs } = this.monolyth;
+        const info = app_1.App.getInfo(this.app);
+        for (const key of info.spaceModules) {
+            const module = compiler.modules[key];
+            this.dumpModule(module, dirs.build_modules);
+        }
+    }
+    dumpModule(module, dir) {
+        log_1.Log.debug('compiler', 'monolyth', `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 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 += '    ],';
+        }
+        str += '})';
+        const moduleFilename = `${module.lowName}.js`;
+        const modulePath = path.resolve(dir, moduleFilename);
+        fs.writeFileSync(modulePath, str);
+    }
+}
+exports.DumpModulesStage = DumpModulesStage;

package/lib/compiler/apps/monolyth/stages/5_dump_cli_stage.d.ts

@@ -0,0 +1,12 @@
+import { MonolythApp } from "../../../../engine/apps/monolyth/monolyth.app";
+import { MonolythCompiler } from '../monolyth_compiler';
+/**
+ * [Monolyth Compiler Stage #5]
+ * Dump the cli.js file to build/bin folder.
+ */
+export declare class DumpCLIStage {
+    private monolyth;
+    private app;
+    constructor(monolyth: MonolythCompiler, app: MonolythApp<any, any>);
+    run(): Promise<void>;
+}

package/lib/compiler/apps/monolyth/stages/5_dump_cli_stage.js

@@ -0,0 +1,65 @@
+"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.DumpCLIStage = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const log_1 = require("../../../../engine/util/log");
+/**
+ * [Monolyth Compiler Stage #5]
+ * Dump the cli.js file to build/bin folder.
+ */
+class DumpCLIStage {
+    constructor(monolyth, app) {
+        this.monolyth = monolyth;
+        this.app = app;
+    }
+    async run() {
+        log_1.Log.info('compiler', 'monolyth', 'Dumping cli.js file to build/bin folder...');
+        const { dirs } = this.monolyth;
+        let str = '';
+        str += 'require("dotenv/config");\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);
+    }
+}
+exports.DumpCLIStage = DumpCLIStage;

package/lib/compiler/apps/monolyth/stages/6_dump_package_json_stage.d.ts

@@ -0,0 +1,12 @@
+import { MonolythCompiler } from '../monolyth_compiler';
+import { MonolythApp } from "../../../../engine/apps/monolyth/monolyth.app";
+/**
+ * [Monolyth Compiler Stage #6]
+ * Dump the package.json file to build folder.
+ */
+export declare class DumpPackageJsonStage {
+    private monolyth;
+    private app;
+    constructor(monolyth: MonolythCompiler, app: MonolythApp<any, any>);
+    run(): Promise<void>;
+}

package/lib/compiler/apps/monolyth/stages/6_dump_package_json_stage.js

@@ -0,0 +1,74 @@
+"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.DumpPackageJsonStage = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const log_1 = require("../../../../engine/util/log");
+const space_1 = require("../../../../engine/space");
+const monolyth_app_1 = require("../../../../engine/apps/monolyth/monolyth.app");
+/**
+ * [Monolyth Compiler Stage #6]
+ * Dump the package.json file to build folder.
+ */
+class DumpPackageJsonStage {
+    constructor(monolyth, app) {
+        this.monolyth = monolyth;
+        this.app = app;
+    }
+    async run() {
+        log_1.Log.info('compiler', 'monolyth', 'Dumping package.json to build folder...');
+        const { config, compiler, dirs } = this.monolyth;
+        const nesoiPackageJson = await Promise.resolve(`${`${config.nesoiPath || 'node_modules/nesoi'}/package.json`}`).then(s => __importStar(require(s)));
+        const spacePackageJson = await Promise.resolve(`${space_1.Space.path(compiler.space, 'package.json')}`).then(s => __importStar(require(s)));
+        const filePath = path.resolve(dirs.build, 'package.json');
+        const scripts = {
+            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 = monolyth_app_1.MonolythApp.package(this.app, scripts, dependencies);
+        fs.writeFileSync(filePath, JSON.stringify(packageJson, undefined, 2));
+    }
+}
+exports.DumpPackageJsonStage = DumpPackageJsonStage;

package/lib/compiler/compiler.d.ts

@@ -0,0 +1,19 @@
+import { CompilerModule } from './module';
+import { ModuleTree } from "../engine/tree";
+import { Space } from "../engine/space";
+import { $Space } from "../schema";
+import { TypeScriptCompiler } from './typescript/typescript_compiler';
+export type CompilerConfig = {
+    nesoiPath?: string;
+    exclude?: string[];
+};
+export declare class Compiler {
+    space: Space<$Space>;
+    config?: CompilerConfig | undefined;
+    modules: Record<string, CompilerModule>;
+    tree: ModuleTree;
+    tsCompiler: TypeScriptCompiler;
+    logFn?: (msg: string) => void;
+    constructor(space: Space<$Space>, config?: CompilerConfig | undefined);
+    run(): Promise<this>;
+}