nesoi 3.0.6 → 3.0.9

package/lib/adapters/postgres/src/migrator/runner/runner.js

@@ -0,0 +1,249 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationRunner = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const string_1 = require("../../../../../engine/util/string");
+const log_1 = require("../../../../../engine/util/log");
+const datetime_1 = require("../../../../../engine/data/datetime");
+const daemon_1 = require("../../../../../engine/daemon");
+const trx_1 = require("../../../../../engine/transaction/trx");
+const status_1 = require("./status");
+const __1 = require("..");
+const ui_1 = __importDefault(require("../../../../../engine/cli/ui"));
+class MigrationRunner {
+    // Scan (to generate status)
+    static async scanFiles(daemon, migrations_dir) {
+        const modules = daemon_1.Daemon.getModules(daemon);
+        // Read migration files of each module
+        const files = [];
+        for (const module of modules) {
+            const modulepath = path.join('modules', module.name, migrations_dir);
+            if (!fs.existsSync(modulepath))
+                continue;
+            fs.readdirSync(modulepath, { withFileTypes: true })
+                .forEach(node => {
+                const nodePath = path.resolve(modulepath, node.name);
+                if (nodePath.endsWith('.d.ts')) {
+                    return;
+                }
+                files.push({
+                    module: module.name,
+                    name: node.name,
+                    path: nodePath
+                });
+            });
+        }
+        // Extract migration routine of each file
+        const migrationFiles = [];
+        for (const file of files) {
+            const { default: routine } = await Promise.resolve(`${file.path}`).then(s => __importStar(require(s)));
+            if (routine instanceof __1.MigrationRoutine) {
+                const name = file.name.replace(/'.[t|j]s'/, '');
+                migrationFiles.push({
+                    ...file,
+                    name,
+                    routine
+                });
+            }
+            else {
+                log_1.Log.warn('migrator', 'scan', `File at ${file.path} doesn't appear to be a migration. Skipping it.`);
+            }
+        }
+        return migrationFiles;
+    }
+    static async scanRows(sql) {
+        const db = await sql `
+            SELECT * FROM ${sql(_a.MIGRATION_TABLE_NAME)}
+            ORDER BY id
+        `;
+        return db;
+    }
+    static async status(daemon, sql, migrations_dir) {
+        const migrationFiles = await _a.scanFiles(daemon, migrations_dir);
+        const migrationRows = await _a.scanRows(sql);
+        return new status_1.MigrationRunnerStatus(migrationFiles, migrationRows);
+    }
+    // Public Up / Down
+    static async up(daemon, sql, mode = 'one', dirpath = 'migrations') {
+        let status = await _a.status(daemon, sql, dirpath);
+        console.log(status.describe());
+        const pending = status.items.filter(item => item.state === 'pending');
+        if (!pending.length) {
+            log_1.Log.info('migrator', 'up', 'No migrations to run.');
+            return;
+        }
+        const n = (mode === 'one' ? 1 : pending.length).toString();
+        const confirm = await ui_1.default.yesOrNo(`Run ${(0, string_1.colored)(n, 'green')} migration(s) ${(0, string_1.colored)('▲ UP', 'lightgreen')}?`);
+        if (!confirm) {
+            return;
+        }
+        await sql.begin(async (sql) => {
+            if (mode === 'one') {
+                const migration = pending[0];
+                await this.migrateUp(daemon, sql, migration, status.batch + 1);
+            }
+            else {
+                for (const migration of pending) {
+                    await this.migrateUp(daemon, sql, migration, status.batch + 1);
+                }
+            }
+        });
+        status = await _a.status(daemon, sql, dirpath);
+        console.log(status.describe());
+    }
+    static async down(daemon, sql, mode = 'one', dirpath = 'migrations') {
+        let status = await _a.status(daemon, sql, dirpath);
+        console.log(status.describe());
+        const lastBatch = status.items.filter(item => item.batch === status.batch);
+        if (!lastBatch.length) {
+            log_1.Log.info('migrator', 'down', 'No migrations to rollback.');
+            return;
+        }
+        const n = mode === 'one' ? 'one' : 'last batch of';
+        const confirm = await ui_1.default.yesOrNo(`Rollback ${(0, string_1.colored)(n, 'green')} migration(s) ${(0, string_1.colored)('▼ DOWN', 'red')}?`);
+        if (!confirm) {
+            return;
+        }
+        await sql.begin(async (sql) => {
+            if (mode === 'one') {
+                const migration = lastBatch.at(-1);
+                await this.migrateDown(daemon, sql, migration);
+            }
+            else {
+                for (const migration of lastBatch) {
+                    await this.migrateDown(daemon, sql, migration);
+                }
+            }
+        });
+        status = await _a.status(daemon, sql, dirpath);
+        console.log(status.describe());
+    }
+    // Implementation Up/Down
+    static async migrateUp(daemon, sql, migration, batch) {
+        log_1.Log.info('migrator', 'up', `Running migration ${(0, string_1.colored)('▲ UP', 'lightgreen')} ${(0, string_1.colored)(migration.name, 'lightblue')}`);
+        const status = await daemon.trx(migration.module)
+            .run(async (trx) => {
+            trx_1.Trx.set(trx, 'sql', sql);
+            await migration.routine.up({
+                sql,
+                trx
+            });
+        });
+        if (status.state !== 'ok') {
+            throw new Error('Migration failed. Rolling back all batch changes.');
+        }
+        const row = {
+            module: migration.module,
+            name: migration.name,
+            description: migration.routine.description,
+            batch,
+            timestamp: datetime_1.NesoiDatetime.now(),
+            hash: migration.hash || null
+        };
+        if (migration.description) {
+            row.description = migration.description;
+        }
+        await sql `
+            INSERT INTO ${sql(_a.MIGRATION_TABLE_NAME)}
+            ${sql(row)}
+        `;
+    }
+    static async migrateDown(daemon, sql, migration) {
+        const name = (0, string_1.colored)(migration.name, 'lightblue');
+        log_1.Log.info('migrator', 'up', `Running migration ${(0, string_1.colored)('▼ DOWN', 'yellow')} ${name}`);
+        if (migration.state === 'lost') {
+            const del = await ui_1.default.yesOrNo(`The migration ${name} is ${(0, string_1.colored)('lost', 'red')}, skip and delete it? ${(0, string_1.colored)('Warning: this might cause inconsistencies', 'red')}.`);
+            if (!del) {
+                throw new Error(`Migration ${migration.name} was lost, unable to migrate down.`);
+            }
+        }
+        else {
+            const status = await daemon.trx(migration.module)
+                .run(async (trx) => {
+                trx_1.Trx.set(trx, 'sql', sql);
+                await migration.routine.down({
+                    sql,
+                    trx
+                });
+            });
+            if (status.state !== 'ok') {
+                throw new Error('Migration failed. Rolling back all batch changes.');
+            }
+        }
+        await sql `
+            DELETE FROM ${sql(_a.MIGRATION_TABLE_NAME)}
+            WHERE id = ${migration.id}
+        `;
+    }
+}
+exports.MigrationRunner = MigrationRunner;
+_a = MigrationRunner;
+MigrationRunner.MIGRATION_TABLE_NAME = '__nesoi_migrations';
+MigrationRunner.fromSchema = {
+    up: async (daemon, sql, migration, dirpath = 'migrations') => {
+        let status = await _a.status(daemon, sql, dirpath);
+        console.log(status.describe());
+        const routine = new __1.MigrationRoutine({
+            description: migration.description,
+            up: async ($) => {
+                for (const sql of migration.sqlUp()) {
+                    await $.sql.unsafe(sql);
+                }
+            },
+            down: async ($) => {
+                for (const sql of migration.sqlDown()) {
+                    await $.sql.unsafe(sql);
+                }
+            }
+        });
+        const mig = {
+            ...migration,
+            state: 'pending',
+            hash: routine.hash,
+            routine
+        };
+        await sql.begin(async (sql) => {
+            await _a.migrateUp(daemon, sql, mig, status.batch + 1);
+        });
+        status = await _a.status(daemon, sql, dirpath);
+        console.log(status.describe());
+    }
+};

package/lib/adapters/postgres/src/migrator/runner/status.d.ts

@@ -0,0 +1,17 @@
+import { MigrationFile, MigrationRoutine, MigrationRow } from '..';
+export declare class MigrationRunnerStatus {
+    items: {
+        state: 'done' | 'pending' | 'lost' | 'modified';
+        id?: number;
+        module: string;
+        name: string;
+        description?: string;
+        batch?: number;
+        timestamp?: string;
+        hash?: string;
+        routine?: MigrationRoutine;
+    }[];
+    batch: number;
+    constructor(migrationFiles: MigrationFile[], migrationRows: MigrationRow[]);
+    describe(): string;
+}

package/lib/adapters/postgres/src/migrator/runner/status.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationRunnerStatus = void 0;
+const string_1 = require("../../../../../engine/util/string");
+class MigrationRunnerStatus {
+    constructor(migrationFiles, migrationRows) {
+        this.items = migrationRows.map(migration => ({
+            ...migration,
+            state: 'lost'
+        }));
+        migrationFiles.forEach(migration => {
+            const hash = migration.routine.hash;
+            const old = this.items.find(item => item.name === migration.name);
+            if (old) {
+                if (!old.hash || old.hash === hash) {
+                    old.state = 'done';
+                }
+                else {
+                    old.state = 'modified';
+                }
+                old.routine = migration.routine;
+            }
+            else {
+                this.items.push({
+                    id: undefined,
+                    module: migration.module,
+                    name: migration.name,
+                    description: migration.routine.description,
+                    batch: undefined,
+                    hash,
+                    state: 'pending',
+                    routine: migration.routine
+                });
+            }
+        });
+        const lastBatch = Math.max(...this.items.map(item => item.batch || 0), 0);
+        this.batch = lastBatch;
+    }
+    describe() {
+        let str = '';
+        str += `◆ ${(0, string_1.colored)('Migration Status', 'lightblue')}\n`;
+        this.items.forEach(item => {
+            const state = {
+                'done': () => (0, string_1.colored)('done', 'green'),
+                'pending': () => (0, string_1.colored)('pending', 'yellow'),
+                'lost': () => (0, string_1.colored)('lost', 'red'),
+                'modified': () => (0, string_1.colored)('modified', 'brown'),
+            }[item.state]();
+            const module = (0, string_1.colored)(item.module, 'lightcyan');
+            str += `└ ${item.id || '*'}\t${state}\t${module} ${item.name} @ ${item.batch || '...'}\n`;
+        });
+        return str;
+    }
+}
+exports.MigrationRunnerStatus = MigrationRunnerStatus;

package/lib/adapters/postgres/src/postgres.cli.d.ts

@@ -1,6 +1,7 @@
 import { CLIAdapter, CLICommand } from "../../../engine/cli/cli_adapter";
 import { PostgresProvider } from './postgres.provider';
 import { AnyDaemon } from "../../../engine/daemon";
+import { CLI } from "../../../engine/cli/cli";
 export declare class cmd_check extends CLICommand {
     provider: PostgresProvider;
     constructor(provider: PostgresProvider);
@@ -23,6 +24,14 @@ export declare class cmd_status extends CLICommand {
     constructor(provider: PostgresProvider);
     run(daemon: AnyDaemon): Promise<void>;
 }
+export declare class cmd_make_empty_migration extends CLICommand {
+    cli: CLI;
+    provider: PostgresProvider;
+    constructor(cli: CLI, provider: PostgresProvider);
+    run(daemon: AnyDaemon, $: {
+        name?: string;
+    }): Promise<void>;
+}
 export declare class cmd_make_migrations extends CLICommand {
     provider: PostgresProvider;
     constructor(provider: PostgresProvider);
@@ -61,6 +70,7 @@ export declare class cmd_import_csv extends CLICommand {
     run(daemon: AnyDaemon, input: Record<string, any>): Promise<void>;
 }
 export declare class PostgresCLI extends CLIAdapter {
+    cli: CLI;
     provider: PostgresProvider;
-    constructor(provider: PostgresProvider);
+    constructor(cli: CLI, provider: PostgresProvider);
 }

package/lib/adapters/postgres/src/postgres.cli.js

@@ -3,15 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresCLI = exports.cmd_import_csv = exports.cmd_query = exports.cmd_migrate_one_down = exports.cmd_migrate_down = exports.cmd_migrate_one_up = exports.cmd_migrate_up = exports.cmd_make_migrations = exports.cmd_status = exports.cmd_create_db = exports.cmd_tables = exports.cmd_check = void 0;
+exports.PostgresCLI = exports.cmd_import_csv = exports.cmd_query = exports.cmd_migrate_one_down = exports.cmd_migrate_down = exports.cmd_migrate_one_up = exports.cmd_migrate_up = exports.cmd_make_migrations = exports.cmd_make_empty_migration = exports.cmd_status = exports.cmd_create_db = exports.cmd_tables = exports.cmd_check = void 0;
 const cli_adapter_1 = require("../../../engine/cli/cli_adapter");
 const database_1 = require("./migrator/database");
+const provider_1 = require("./migrator/generator/provider");
 const ui_1 = __importDefault(require("../../../engine/cli/ui"));
-const migrator_1 = require("./migrator");
 const daemon_1 = require("../../../engine/daemon");
-const runner_1 = require("./migrator/runner");
 const postgres_bucket_adapter_1 = require("./postgres.bucket_adapter");
 const csv_1 = require("./migrator/csv");
+const runner_1 = require("./migrator/runner/runner");
+const migration_1 = require("./migrator/generator/migration");
 class cmd_check extends cli_adapter_1.CLICommand {
     constructor(provider) {
         super('any', 'check', 'check', 'Check if the connection to PostgreSQL is working properly');
@@ -23,7 +24,7 @@ class cmd_check extends cli_adapter_1.CLICommand {
             ui_1.default.result('ok', 'Connection to PostgreSQL working.');
         else
             ui_1.default.result('error', 'Connection to PostgreSQL not working.', res);
-        await migrator_1.Migrator.prepare(daemon, this.provider.sql);
+        await provider_1.MigrationProvider.create(daemon, this.provider.sql);
     }
 }
 exports.cmd_check = cmd_check;
@@ -60,7 +61,7 @@ class cmd_create_db extends cli_adapter_1.CLICommand {
         catch (e) {
             ui_1.default.result('error', `Failed to create database ${name}`, e);
         }
-        await migrator_1.Migrator.prepare(daemon, this.provider.sql);
+        await provider_1.MigrationProvider.create(daemon, this.provider.sql);
     }
 }
 exports.cmd_create_db = cmd_create_db;
@@ -70,24 +71,40 @@ class cmd_status extends cli_adapter_1.CLICommand {
         this.provider = provider;
     }
     async run(daemon) {
-        const migrator = await migrator_1.Migrator.prepare(daemon, this.provider.sql);
+        const migrator = await provider_1.MigrationProvider.create(daemon, this.provider.sql);
         console.log(migrator.status.describe());
     }
 }
 exports.cmd_status = cmd_status;
+class cmd_make_empty_migration extends cli_adapter_1.CLICommand {
+    constructor(cli, provider) {
+        super('any', 'make empty migration', 'make empty migration( NAME)', 'Generate an empty migration to be filled by the user', /(\w*)/, ['name']);
+        this.cli = cli;
+        this.provider = provider;
+    }
+    async run(daemon, $) {
+        const module = await ui_1.default.select('Pick a module to create the migration into:', daemon_1.Daemon.getModules(daemon).map(m => m.name));
+        const name = $.name || await ui_1.default.question('Migration name');
+        const migration = migration_1.$Migration.empty(module.value, name);
+        const filepath = migration.save();
+        this.cli.openEditor(filepath);
+    }
+}
+exports.cmd_make_empty_migration = cmd_make_empty_migration;
 class cmd_make_migrations extends cli_adapter_1.CLICommand {
     constructor(provider) {
         super('any', 'make migrations', 'make migrations( TAG)', 'Generate migrations for the bucket(s) using PostgresBucketAdapter', /(\w*)/, ['tag']);
         this.provider = provider;
     }
     async run(daemon, $) {
+        console.clear();
         // TODO: restrict by tag
-        const migrator = await migrator_1.Migrator.prepare(daemon, this.provider.sql);
+        const migrator = await provider_1.MigrationProvider.create(daemon, this.provider.sql);
         const migrations = await migrator.generate();
         for (const migration of migrations) {
-            console.log(migration.describe());
             migration.save();
         }
+        await runner_1.MigrationRunner.up(daemon, this.provider.sql, 'batch');
     }
 }
 exports.cmd_make_migrations = cmd_make_migrations;
@@ -97,6 +114,7 @@ class cmd_migrate_up extends cli_adapter_1.CLICommand {
         this.provider = provider;
     }
     async run(daemon) {
+        console.clear();
         await runner_1.MigrationRunner.up(daemon, this.provider.sql, 'batch');
     }
 }
@@ -107,6 +125,7 @@ class cmd_migrate_one_up extends cli_adapter_1.CLICommand {
         this.provider = provider;
     }
     async run(daemon) {
+        console.clear();
         await runner_1.MigrationRunner.up(daemon, this.provider.sql, 'one');
     }
 }
@@ -117,6 +136,7 @@ class cmd_migrate_down extends cli_adapter_1.CLICommand {
         this.provider = provider;
     }
     async run(daemon) {
+        console.clear();
         await runner_1.MigrationRunner.down(daemon, this.provider.sql, 'batch');
     }
 }
@@ -127,6 +147,7 @@ class cmd_migrate_one_down extends cli_adapter_1.CLICommand {
         this.provider = provider;
     }
     async run(daemon) {
+        console.clear();
         await runner_1.MigrationRunner.down(daemon, this.provider.sql, 'one');
     }
 }
@@ -158,13 +179,14 @@ class cmd_import_csv extends cli_adapter_1.CLICommand {
         })))
             .flat(1);
         const bucket = await ui_1.default.select('Bucket', buckets, b => b.name);
-        await csv_1.CSV.import(this.provider.sql, bucket.tableName, input.path);
+        await csv_1.CSV.import(this.provider.sql, bucket.value.tableName, input.path);
     }
 }
 exports.cmd_import_csv = cmd_import_csv;
 class PostgresCLI extends cli_adapter_1.CLIAdapter {
-    constructor(provider) {
-        super();
+    constructor(cli, provider) {
+        super(cli);
+        this.cli = cli;
         this.provider = provider;
         this.commands = {
             'check': new cmd_check(provider),
@@ -172,6 +194,7 @@ class PostgresCLI extends cli_adapter_1.CLIAdapter {
             'create db': new cmd_create_db(provider),
             'status': new cmd_status(provider),
             'make migrations': new cmd_make_migrations(provider),
+            'make empty migration': new cmd_make_empty_migration(cli, provider),
             'migrate up': new cmd_migrate_up(provider),
             'migrate one up': new cmd_migrate_one_up(provider),
             'migrate down': new cmd_migrate_down(provider),

package/lib/adapters/postgres/test/postgres.bucket_adapter.test.js

@@ -6,9 +6,9 @@ const log_1 = require("../../../engine/util/log");
 const inline_app_1 = require("../../../engine/apps/inline.app");
 const postgres_provider_1 = require("../src/postgres.provider");
 const postgres_bucket_adapter_1 = require("../src/postgres.bucket_adapter");
-const migrator_1 = require("../src/migrator");
-const runner_1 = require("../src/migrator/runner");
 const datetime_1 = require("../../../engine/data/datetime");
+const provider_1 = require("../src/migrator/generator/provider");
+const runner_1 = require("../src/migrator/runner/runner");
 log_1.Log.level = 'warn';
 // TODO: read this from env
 const PostgresConfig = {
@@ -72,11 +72,11 @@ async function setup() {
     // TODO: encapsulate this
     // await Database.createDatabase('NESOI_TEST', PostgresConfig.connection, { if_exists: 'delete' });
     const pg = postgres_provider_1.PostgresProvider.make('pg', PostgresConfig).up();
-    const migrator = await migrator_1.Migrator.prepare(daemon, pg.sql);
+    const migrator = await provider_1.MigrationProvider.create(daemon, pg.sql);
     const migration = await migrator.generateForBucket('MODULE', 'BUCKET', 'nesoi_test_table');
     if (migration) {
         migration.name = 'postgres.bucket_adapter.test';
-        await runner_1.MigrationRunner.injectUp(daemon, pg.sql, migration);
+        await runner_1.MigrationRunner.fromSchema.up(daemon, pg.sql, migration);
     }
     // migration?.save();
     // await MigrationRunner.up(daemon, 'one', PostgresConfig);

package/lib/compiler/apps/monolyth/stages/1_mkdir_stage.d.ts

@@ -3,6 +3,9 @@ import { MonolythCompiler } from '../monolyth_compiler';
 /**
  * [Monolyth Compiler Stage #1]
  * Create the directory structure
+ *
+ * @category Monolyth Compiler
+ * @subcategory Stages
  */
 export declare class MkdirStage {
     private monolyth;

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

@@ -41,6 +41,9 @@ const log_1 = require("../../../../engine/util/log");
 /**
  * [Monolyth Compiler Stage #1]
  * Create the directory structure
+ *
+ * @category Monolyth Compiler
+ * @subcategory Stages
  */
 class MkdirStage {
     constructor(monolyth, app) {

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

@@ -3,6 +3,9 @@ import { MonolythCompiler } from '../monolyth_compiler';
 /**
  * [Monolyth Compiler Stage #2]
  * Build typescript files to build folder
+ *
+ * @category Monolyth Compiler
+ * @subcategory Stages
  */
 export declare class BuildTypescriptStage {
     private monolyth;

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

@@ -43,6 +43,9 @@ const app_1 = require("../../../../engine/apps/app");
 /**
  * [Monolyth Compiler Stage #2]
  * Build typescript files to build folder
+ *
+ * @category Monolyth Compiler
+ * @subcategory Stages
  */
 class BuildTypescriptStage {
     constructor(monolyth, app) {

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

@@ -3,6 +3,9 @@ import { MonolythCompiler } from '../monolyth_compiler';
 /**
  * [Monolyth Compiler Stage #3]
  * Copy type declarations to build/types folder
+ *
+ * @category Monolyth Compiler
+ * @subcategory Stages
  */
 export declare class CopyTypesStage {
     private monolyth;

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

@@ -43,6 +43,9 @@ const app_1 = require("../../../../engine/apps/app");
 /**
  * [Monolyth Compiler Stage #3]
  * Copy type declarations to build/types folder
+ *
+ * @category Monolyth Compiler
+ * @subcategory Stages
  */
 class CopyTypesStage {
     constructor(monolyth, app) {

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

@@ -3,6 +3,9 @@ import { MonolythCompiler } from '../monolyth_compiler';
 /**
  * [Monolyth Compiler Stage #4]
  * Dump modules to build/modules folder.
+ *
+ * @category Monolyth Compiler
+ * @subcategory Stages
  */
 export declare class DumpModulesStage {
     private monolyth;

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

@@ -41,6 +41,9 @@ const app_1 = require("../../../../engine/apps/app");
 /**
  * [Monolyth Compiler Stage #4]
  * Dump modules to build/modules folder.
+ *
+ * @category Monolyth Compiler
+ * @subcategory Stages
  */
 class DumpModulesStage {
     constructor(monolyth, app) {
@@ -61,6 +64,35 @@ class DumpModulesStage {
         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.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,`;

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

@@ -3,6 +3,9 @@ import { MonolythCompiler } from '../monolyth_compiler';
 /**
  * [Monolyth Compiler Stage #5]
  * Dump the cli.js file to build/bin folder.
+ *
+ * @category Monolyth Compiler
+ * @subcategory Stages
  */
 export declare class DumpCLIStage {
     private monolyth;

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

@@ -40,6 +40,9 @@ const log_1 = require("../../../../engine/util/log");
 /**
  * [Monolyth Compiler Stage #5]
  * Dump the cli.js file to build/bin folder.
+ *
+ * @category Monolyth Compiler
+ * @subcategory Stages
  */
 class DumpCLIStage {
     constructor(monolyth, app) {