nesoi 3.0.0

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

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresCLI = 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;
+const cli_adapter_1 = require("../../../engine/cli/cli_adapter");
+const database_1 = require("./migrator/database");
+const ui_1 = __importDefault(require("../../../engine/cli/ui"));
+const migrator_1 = require("./migrator");
+const runner_1 = require("./migrator/runner");
+class cmd_check extends cli_adapter_1.CLICommand {
+    constructor(provider) {
+        super('check', 'check', 'Check if the connection to PostgreSQL is working properly');
+        this.provider = provider;
+    }
+    async run() {
+        const res = await database_1.Database.checkConnection(this.provider.sql);
+        if (res == true)
+            ui_1.default.result('ok', 'Connection to PostgreSQL working.');
+        else
+            ui_1.default.result('error', 'Connection to PostgreSQL not working.', res);
+    }
+}
+exports.cmd_check = cmd_check;
+class cmd_tables extends cli_adapter_1.CLICommand {
+    constructor(provider) {
+        super('tables', 'tables', 'List the tables present on the database');
+        this.provider = provider;
+    }
+    async run() {
+        const res = await database_1.Database.listTables(this.provider.sql);
+        ui_1.default.list(res);
+    }
+}
+exports.cmd_tables = cmd_tables;
+class cmd_create_db extends cli_adapter_1.CLICommand {
+    constructor(provider) {
+        super('create db', 'create db( NAME)', 'Create the database used by the application', /(\w*)/, ['name']);
+        this.provider = provider;
+    }
+    async run(_, $) {
+        let name = $.name;
+        const config = this.provider.config?.connection;
+        if (!name) {
+            if (!config?.db) {
+                ui_1.default.result('error', 'Database name not configured on PostgresConfig used', config);
+                return;
+            }
+            name = config.db;
+        }
+        try {
+            await database_1.Database.createDatabase(name, config);
+            ui_1.default.result('ok', `Database ${name} created`);
+        }
+        catch (e) {
+            ui_1.default.result('error', `Failed to create database ${name}`, e);
+        }
+    }
+}
+exports.cmd_create_db = cmd_create_db;
+class cmd_status extends cli_adapter_1.CLICommand {
+    constructor(provider) {
+        super('status', 'status', 'Show the status of migrations on the current database');
+        this.provider = provider;
+    }
+    async run(daemon) {
+        const migrator = await migrator_1.Migrator.prepare(daemon, this.provider.sql);
+        console.log(migrator.status.describe());
+    }
+}
+exports.cmd_status = cmd_status;
+class cmd_make_migrations extends cli_adapter_1.CLICommand {
+    constructor(provider) {
+        super('make migrations', 'make migrations( TAG)', 'Generate migrations for the bucket(s) using PostgresBucketAdapter', /(\w*)/, ['tag']);
+        this.provider = provider;
+    }
+    async run(daemon, $) {
+        // TODO: restrict by tag
+        const migrator = await migrator_1.Migrator.prepare(daemon, this.provider.sql);
+        const migrations = await migrator.generate();
+        for (const migration of migrations) {
+            console.log(migration.describe());
+            migration.save();
+        }
+    }
+}
+exports.cmd_make_migrations = cmd_make_migrations;
+class cmd_migrate_up extends cli_adapter_1.CLICommand {
+    constructor(provider) {
+        super('migrate up', 'migrate up', 'Run ALL the pending migrations up (batch)');
+        this.provider = provider;
+    }
+    async run(daemon) {
+        await runner_1.MigrationRunner.up(daemon, this.provider.sql, 'batch');
+    }
+}
+exports.cmd_migrate_up = cmd_migrate_up;
+class cmd_migrate_one_up extends cli_adapter_1.CLICommand {
+    constructor(provider) {
+        super('migrate one up', 'migrate one up', 'Run ONE pending migration up');
+        this.provider = provider;
+    }
+    async run(daemon) {
+        await runner_1.MigrationRunner.up(daemon, this.provider.sql, 'one');
+    }
+}
+exports.cmd_migrate_one_up = cmd_migrate_one_up;
+class PostgresCLI extends cli_adapter_1.CLIAdapter {
+    constructor(provider) {
+        super();
+        this.provider = provider;
+        this.commands = {
+            'check': new cmd_check(provider),
+            'tables': new cmd_tables(provider),
+            'create db': new cmd_create_db(provider),
+            'status': new cmd_status(provider),
+            'make migrations': new cmd_make_migrations(provider),
+            'migrate up': new cmd_migrate_up(provider),
+            'migrate one up': new cmd_migrate_one_up(provider),
+        };
+    }
+}
+exports.PostgresCLI = PostgresCLI;

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

@@ -0,0 +1,12 @@
+import { AnyTrxNode } from "../../../engine/transaction/trx_node";
+import { NQLRunner } from "../../../elements/entities/bucket/query/nql_engine";
+import { NQL_Part } from "../../../elements/entities/bucket/query/nql.schema";
+import postgres from 'postgres';
+type Obj = Record<string, any>;
+export declare class PostgresNQLRunner extends NQLRunner {
+    protected sql?: postgres.Sql<any>;
+    constructor();
+    private guard;
+    run(trx: AnyTrxNode, part: NQL_Part, params: Obj): Promise<any>;
+}
+export {};

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresNQLRunner = void 0;
+const nql_engine_1 = require("../../../elements/entities/bucket/query/nql_engine");
+const trx_1 = require("../../../engine/transaction/trx");
+const postgres_bucket_adapter_1 = require("./postgres.bucket_adapter");
+const log_1 = require("../../../engine/util/log");
+class PostgresNQLRunner extends nql_engine_1.NQLRunner {
+    constructor() {
+        super();
+    }
+    guard(sql) {
+        return (template, ...params) => {
+            return sql.call(sql, template, ...params).catch(e => {
+                log_1.Log.error('bucket', 'postgres', e.toString(), e);
+                throw new Error('Database error.');
+            });
+        };
+    }
+    async run(trx, part, params) {
+        const sql = trx_1.Trx.get(trx, 'sql');
+        const tableName = postgres_bucket_adapter_1.PostgresBucketAdapter.getTableName(trx, part.union.meta);
+        // console.log(NQL_RuleTree.describe(part.union));
+        const _sql = (part) => {
+            return this.guard(sql) `SELECT * FROM ${sql(tableName)} WHERE ${sql.unsafe(_union(part.union))}`;
+        };
+        const _union = (union) => {
+            return `(${union.inters.map(i => _inter(i)).join(' OR ')})`;
+        };
+        const _inter = (inter) => {
+            return `(${inter.rules.map(r => (('value' in r) ? _rule(r) : _union(r))).join(' AND ')})`;
+        };
+        const _rule = (rule) => {
+            // Replace '.' of fieldpath with '->' (JSONB compatible)
+            // TODO: process '.*'
+            const column = rule.fieldpath.replace(/\./g, '->');
+            const op = {
+                '==': '=',
+                '<': '<',
+                '>': '>',
+                '<=': '<=',
+                '>=': '>=',
+                'in': 'in',
+                'contains': 'like',
+                'contains_any': 'like',
+                'present': ''
+            }[rule.op];
+            let value;
+            if ('static' in rule.value)
+                value = rule.value.static;
+            else if ('param' in rule.value)
+                value = params[rule.value.param]; // TODO: deal with param[]
+            else {
+                // TODO: subquery
+                throw new Error('Sub-queries not implemented yet.');
+            }
+            return `${column} ${op} ${value}`;
+        };
+        // Debug
+        // const str = await _sql(part).describe().catch(e => {
+        //     Log.error('postgres' as any, 'nql', e.query, e);
+        // })
+        // console.log((str as any).string);
+        // End of Debug
+        const out = await _sql(part);
+        return Object.values(out);
+    }
+}
+exports.PostgresNQLRunner = PostgresNQLRunner;

package/lib/adapters/postgres/test/postgres.bucket_adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mock_1 = require("../../../../tools/joaquin/mock");
+const bucket_builder_1 = require("../../../elements/entities/bucket/bucket.builder");
+const log_1 = require("../../../engine/util/log");
+const inline_app_1 = require("../../../engine/apps/inline.app");
+const postgres_bucket_adapter_1 = require("../src/postgres.bucket_adapter");
+const migrator_1 = require("../src/migrator");
+const runner_1 = require("../src/migrator/runner");
+const database_1 = require("../src/migrator/database");
+log_1.Log.level = 'warn';
+// TODO: read this from env
+const PostgresConfig = {
+    updatedAtField: 'updated_at',
+    connection: {
+        host: 'localhost',
+        port: 5432,
+        user: 'postgres',
+        pass: 'postgres',
+        db: 'NESOI_TEST',
+    }
+};
+let daemon;
+async function setup() {
+    if (daemon) {
+        return daemon;
+    }
+    // Build bucket used for test
+    const bucket = new bucket_builder_1.BucketBuilder('MODULE', 'BUCKET')
+        .model($ => ({
+        id: $.int,
+        p_boolean: $.boolean,
+        p_date: $.date,
+        p_datetime: $.datetime,
+        p_decimal: $.decimal(),
+        p_enum: $.enum(['a', 'b', 'c']),
+        p_int: $.int,
+        p_float: $.float,
+        p_string: $.string,
+        p_obj: $.obj({
+            a: $.int,
+            b: $.string
+        }),
+        p_dict: $.dict($.boolean)
+    }));
+    // Build test app
+    const app = new inline_app_1.InlineApp('RUNTIME', [
+        bucket
+    ])
+        .provider(postgres_bucket_adapter_1.PostgresProvider.make('pg', PostgresConfig))
+        .config.buckets({
+        'MODULE': {
+            'BUCKET': {
+                adapter: ($, { pg }) => new postgres_bucket_adapter_1.PostgresBucketAdapter($, pg, 'nesoi_test_table')
+            }
+        }
+    })
+        .config.trx({
+        'MODULE': {
+            trx: {
+                wrap: postgres_bucket_adapter_1.PostgresProvider.wrap('pg')
+            }
+        }
+    });
+    // Run test daemon
+    daemon = await app.daemon();
+    // Prepare database using daemon
+    // TODO: encapsulate this
+    // await Migrator.createDatabase('NESOI_TEST', PostgresConfig, { if_exists: 'delete' });
+    const sql = database_1.Database.connect(PostgresConfig.connection);
+    const migrator = await migrator_1.Migrator.prepare(daemon, sql);
+    const migration = await migrator.generateForBucket('MODULE', 'BUCKET', 'nesoi_test_table');
+    if (migration) {
+        migration.name = 'postgres.bucket_adapter.test';
+        await runner_1.MigrationRunner.oneUp(daemon, sql, migration);
+    }
+    // migration?.save();
+    // await MigrationRunner.up(daemon, 'one', PostgresConfig);
+    return daemon;
+}
+const mock = new mock_1.Mock();
+beforeAll(async () => {
+    await setup();
+}, 30000);
+describe('Postgres Bucket Adapter', () => {
+    // it ('!', () => {
+    //     expect(1+1).toEqual(2);
+    // })
+    describe('CRUD', () => {
+        it('create should return unmodified object', async () => {
+            await daemon.trx('MODULE').run(async (trx) => {
+                // given
+                const BUCKET = trx.bucket('BUCKET');
+                const input = mock.bucket('MODULE', 'BUCKET')
+                    .obj({ id: undefined }).raw(daemon);
+                // when
+                const { id, ...obj } = await BUCKET.create(input);
+                // then
+                expect(id).toBeTruthy();
+                expect(obj).toEqual(input);
+            });
+        });
+        it('read should return unmodified object after create', async () => {
+            await daemon.trx('MODULE').run(async (trx) => {
+                // given
+                const BUCKET = trx.bucket('BUCKET');
+                const input = mock.bucket('MODULE', 'BUCKET')
+                    .obj({ id: undefined }).raw(daemon);
+                // when
+                const created = await BUCKET.create(input);
+                const { id, ...obj } = await BUCKET.readOneOrFail(created.id);
+                // then
+                expect(id).toBeTruthy();
+                expect(obj).toEqual(input);
+            });
+        });
+        it('update should modify object after insert', async () => {
+            await daemon.trx('MODULE').run(async (trx) => {
+                // given
+                const BUCKET = trx.bucket('BUCKET');
+                const input1 = mock.bucket('MODULE', 'BUCKET')
+                    .obj({ id: undefined }).raw(daemon);
+                const input2 = mock.bucket('MODULE', 'BUCKET')
+                    .obj({ id: undefined }).raw(daemon);
+                // when
+                const { id: id_create, ...created } = await BUCKET.create(input1);
+                const { id: id_update, ...updated } = await BUCKET.put({
+                    ...input2,
+                    id: id_create
+                });
+                // then
+                expect(id_create).toBeTruthy();
+                expect(id_update).toEqual(id_create);
+                expect(created).toEqual(input1);
+                expect(updated).toEqual(input2);
+            });
+        });
+        it('delete should remove object from database', async () => {
+            await daemon.trx('MODULE').run(async (trx) => {
+                // given
+                const BUCKET = trx.bucket('BUCKET');
+                const input = mock.bucket('MODULE', 'BUCKET')
+                    .obj({ id: undefined }).raw(daemon);
+                // when
+                const created = await BUCKET.create(input);
+                const read = await BUCKET.readOneOrFail(created.id);
+                await BUCKET.deleteOrFail(read.id);
+                const read2 = await BUCKET.readOne(read.id);
+                // then
+                expect(read2).toBeUndefined();
+            });
+        });
+    });
+    describe('Query', () => {
+        it('query first by existing id should return object', async () => {
+            let queried;
+            await daemon.trx('MODULE').run(async (trx) => {
+                // given
+                const BUCKET = trx.bucket('BUCKET');
+                const input = mock.bucket('MODULE', 'BUCKET')
+                    .obj({ id: undefined }).raw(daemon);
+                // when
+                const created = await BUCKET.create(input);
+                queried = await BUCKET.query({
+                    'id': created.id
+                }).all();
+                // then
+                expect(queried.length).toEqual(1);
+                expect(queried[0].id).toEqual(created.id);
+            });
+        });
+    });
+});

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

@@ -0,0 +1,136 @@
+"use strict";
+// import { Mock } from 'nesoi/tools/papagaio/mock';
+// import { BucketBuilder } from '~/elements/entities/bucket/bucket.builder';
+// import { Log } from '~/engine/util/log'
+// import { InlineApp } from '~/engine/apps/inline.app';
+// import { AnyDaemon } from '~/engine/apps/app';
+// import { PostgresBucketAdapter, PostgresBucketAdapterConfig } from '../src/postgres.bucket_adapter';
+// import { Migrator } from 'nesoi/tools/migrator';
+// import { MigrationRunner } from 'nesoi/tools/migrator/runner';
+// Log.level = 'info';
+// // TODO: read this from env
+// const PostgresConfig: PostgresBucketAdapterConfig = {
+//     updatedAtField: 'updated_at',
+//     postgres: {
+//         host: 'localhost',
+//         port: 5432,
+//         user: 'postgres',
+//         pass: 'postgres',
+//         db: 'NESOI_TEST',
+//     }
+// }
+// let daemon: AnyDaemon;
+// async function setup() {
+//     if (daemon) {
+//         return daemon;
+//     }
+//     // Build buckets used for test
+//     const tagBucket = new BucketBuilder('MODULE', 'tag')
+//         .model($ => ({
+//             id: $.string,
+//             scope: $.string
+//         }));
+//     const colorBucket = new BucketBuilder('MODULE', 'color')
+//         .model($ => ({
+//             id: $.int,
+//             r: $.float,
+//             g: $.float,
+//             b: $.float,
+//             tag: $.string,
+//             scope: $.string
+//         }));
+//     const shapeBucket = new BucketBuilder('MODULE', 'shape')
+//         .model($ => ({
+//             id: $.int,
+//             name: $.string,
+//             size: $.float,
+//             color_id: $.int,
+//             tag: $.string,
+//             scope: $.string
+//         }));
+//     // Build test app
+//     const app = new InlineApp('RUNTIME', [
+//         tagBucket,
+//         colorBucket,
+//         shapeBucket
+//     ])
+//         .config.buckets({
+//             'MODULE': {
+//                 'tag': {
+//                     adapter: $ => new PostgresBucketAdapter($, 'tags', PostgresConfig)
+//                 },
+//                 'color': {
+//                     adapter: $ => new PostgresBucketAdapter($, 'colors', PostgresConfig)
+//                 },
+//                 'shape': {
+//                     adapter: $ => new PostgresBucketAdapter($, 'shapes', PostgresConfig)
+//                 },
+//             }
+//         })
+//     // Run test daemon
+//     daemon = await app.daemon();
+//     // Prepare database using daemon
+//     // TODO: encapsulate this
+//     // await Migrator.createDatabase('NESOI_TEST', PostgresConfig, { if_exists: 'delete' });
+//     const migrator = await Migrator.prepare(daemon, PostgresConfig);
+//     {
+//         const migration = await migrator.bucket('MODULE', 'tag', 'tags')
+//         if (migration) {
+//             migration.name = '0_tag';
+//             await MigrationRunner.oneUp(daemon, migration, PostgresConfig);
+//         }
+//     }
+//     {
+//         const migration = await migrator.bucket('MODULE', 'color', 'colors')
+//         if (migration) {
+//             migration.name = '0_color';
+//             await MigrationRunner.oneUp(daemon, migration, PostgresConfig);
+//         }
+//     }
+//     {
+//         const migration = await migrator.bucket('MODULE', 'shape', 'shapes')
+//         if (migration) {
+//             migration.name = '0_shape';
+//             await MigrationRunner.oneUp(daemon, migration, PostgresConfig);
+//         }
+//     }
+//     // migration?.save();
+//     // await MigrationRunner.up(daemon, 'one', PostgresConfig);
+//     return daemon;
+// }
+// const mock = new Mock();
+// beforeAll(async () => {
+//     await setup();
+// }, 30000)
+// describe('Postgres Bucket Query', () => {
+//     describe('CRUD', () => {
+//         it('create should return unmodified object', async() => {
+//             await daemon.trx('MODULE').run(async trx => {
+//                 const Tag = trx.bucket('tag');
+//                 const TagMock = mock.bucket('MODULE', 'tag');
+//                 const Color = trx.bucket('color');
+//                 const ColorMock = mock.bucket('MODULE', 'color');
+//                 const Shape = trx.bucket('shape');
+//                 const ShapeMock = mock.bucket('MODULE', 'shape');
+//                 const tags: any[] = [];
+//                 for (let i=0; i<100; i++) {
+//                     const obj = TagMock.obj().raw(daemon) as any;
+//                     (obj as any).scope = 'scope';
+//                     tags.push(await Tag.put(obj))
+//                 }
+//                 for (let i=0; i<100; i++) {
+//                     const obj = ColorMock.obj().raw(daemon);
+//                     (obj as any).tag = tags[i].id;
+//                     (obj as any).scope = 'scope';
+//                     await Color.create(obj);
+//                 }
+//                 for (let i=0; i<100; i++) {
+//                     const obj = ShapeMock.obj().raw(daemon);
+//                     (obj as any).tag = tags[i].id;
+//                     (obj as any).scope = 'scope';
+//                     await Shape.create(obj);
+//                 }
+//             })
+//         })
+//     })
+// })

package/lib/compiler/apps/monolyth/monolyth_compiler.d.ts

@@ -0,0 +1,21 @@
+import { Compiler } from "../../compiler";
+import { MonolythApp } from "../../../engine/apps/monolyth/monolyth.app";
+export type MonolythCompilerConfig = {
+    libPaths?: string[];
+    scripts?: Record<string, string>;
+    nesoiPath?: string;
+};
+export declare class MonolythCompiler {
+    compiler: Compiler;
+    appPath: string;
+    config: MonolythCompilerConfig;
+    dirs: {
+        build: string;
+        build_modules: string;
+        build_types: string;
+        build_bin: string;
+    };
+    constructor(compiler: Compiler, appPath: string, config?: MonolythCompilerConfig);
+    run(): Promise<void>;
+    static scanAll(dir: string): Promise<MonolythApp<any, any, Record<string, any>>[] | undefined>;
+}

package/lib/compiler/apps/monolyth/monolyth_compiler.js

@@ -0,0 +1,95 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonolythCompiler = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const space_1 = require("../../../engine/space");
+const console_1 = __importDefault(require("../../../engine/util/console"));
+const _1_mkdir_stage_1 = require("./stages/1_mkdir_stage");
+const _3_copy_types_stage_1 = require("./stages/3_copy_types_stage");
+const _4_dump_modules_stage_1 = require("./stages/4_dump_modules_stage");
+const _5_dump_cli_stage_1 = require("./stages/5_dump_cli_stage");
+const _6_dump_package_json_stage_1 = require("./stages/6_dump_package_json_stage");
+const _2_build_typescript_stage_1 = require("./stages/2_build_typescript_stage");
+const log_1 = require("../../../engine/util/log");
+const app_1 = require("../../../engine/apps/app");
+const monolyth_app_1 = require("../../../engine/apps/monolyth/monolyth.app");
+class MonolythCompiler {
+    constructor(compiler, appPath, config = {}) {
+        this.compiler = compiler;
+        this.appPath = appPath;
+        this.config = config;
+        this.dirs = {};
+    }
+    async run() {
+        console_1.default.header('Monolyth Compiler');
+        log_1.Log.info('compiler', 'monolyth', `Importing the monolyth definition from ${this.appPath}`);
+        const appFile = space_1.Space.path(this.compiler.space, this.appPath);
+        const app = (await Promise.resolve(`${appFile}`).then(s => __importStar(require(s)))).default;
+        this.config = Object.assign({}, app_1.App.getInfo(app).config?.compiler || {}, this.config);
+        try {
+            await new _1_mkdir_stage_1.MkdirStage(this, app).run();
+            await new _2_build_typescript_stage_1.BuildTypescriptStage(this, app).run();
+            await new _3_copy_types_stage_1.CopyTypesStage(this, app).run();
+            await new _4_dump_modules_stage_1.DumpModulesStage(this, app).run();
+            await new _5_dump_cli_stage_1.DumpCLIStage(this, app).run();
+            await new _6_dump_package_json_stage_1.DumpPackageJsonStage(this, app).run();
+        }
+        catch (e) {
+            log_1.Log.error('compiler', 'monolyth', e.toString(), { stack: e.stack });
+            process.exit();
+        }
+    }
+    static async scanAll(dir) {
+        const apps = [];
+        const nodes = fs.readdirSync(dir, { withFileTypes: true });
+        for (const node of nodes) {
+            const nodePath = path.resolve(dir, node.name);
+            if (!nodePath.endsWith('.ts')) {
+                return;
+            }
+            const exported = (await Promise.resolve(`${nodePath}`).then(s => __importStar(require(s))))?.default;
+            if (exported instanceof monolyth_app_1.MonolythApp) {
+                apps.push(exported);
+            }
+        }
+        return apps;
+    }
+}
+exports.MonolythCompiler = MonolythCompiler;

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

@@ -0,0 +1,12 @@
+import { MonolythApp } from "../../../../engine/apps/monolyth/monolyth.app";
+import { MonolythCompiler } from '../monolyth_compiler';
+/**
+ * [Monolyth Compiler Stage #1]
+ * Create the directory structure
+ */
+export declare class MkdirStage {
+    private monolyth;
+    private app;
+    constructor(monolyth: MonolythCompiler, app: MonolythApp<any, any>);
+    run(): Promise<void>;
+}