nesoi 3.0.0

package/lib/compiler/stages/3_extract_ts_stage.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractTSStage = void 0;
+const log_1 = require("../../engine/util/log");
+const extract_1 = require("../typescript/bridge/extract");
+const organize_1 = require("../typescript/bridge/organize");
+/**
+ * [Compiler Stage #3]
+ * Extract TypeScript sources (methods and imports) from builders
+ */
+class ExtractTSStage {
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    run() {
+        log_1.Log.info('compiler', 'stage.extract_ts', 'Extracting TypeScript code from builders...');
+        const { tree } = this.compiler;
+        const nodes = tree.allNodes();
+        const extract = {};
+        const organized = {
+            buckets: {},
+            messages: {},
+            jobs: {},
+            machines: {}
+        };
+        nodes.forEach(node => {
+            if (node.isInline) {
+                return;
+            }
+            const imports = extract_1.TSBridgeExtract.imports(this.compiler, node);
+            if (imports) {
+                extract[node.tag] = { imports, types: [], functions: [] };
+            }
+            const types = extract_1.TSBridgeExtract.types(this.compiler, node);
+            const functions = extract_1.TSBridgeExtract.functions(this.compiler, node);
+            if (!types && !functions) {
+                return;
+            }
+            const nodeOrganized = organize_1.TSBridgeOrganize.functions(types, functions);
+            Object.assign(organized.buckets, nodeOrganized.buckets);
+            Object.assign(organized.messages, nodeOrganized.messages);
+            Object.assign(organized.jobs, nodeOrganized.jobs);
+            Object.assign(organized.machines, nodeOrganized.machines);
+        });
+        nodes.forEach(node => {
+            const imports = node.isInline
+                ? extract[node.root.tag]?.imports
+                : extract[node.tag]?.imports;
+            let e;
+            if (node.builder.$b === 'bucket') {
+                e = organized.buckets[node.tag];
+            }
+            else if (node.builder.$b === 'message') {
+                e = organized.messages[node.tag];
+            }
+            else if (node.builder.$b === 'job') {
+                e = organized.jobs[node.tag];
+            }
+            else if (node.builder.$b === 'machine') {
+                e = organized.machines[node.tag];
+            }
+            node.bridge = {
+                imports,
+                extract: e,
+                appDependencies: [] // TODO
+            };
+        });
+        log_1.Log.trace('compiler', 'stage.extract_ts', 'Finished extracting TS code', organized);
+    }
+}
+exports.ExtractTSStage = ExtractTSStage;

package/lib/compiler/stages/4_build_schemas_stage.d.ts

@@ -0,0 +1,10 @@
+import { Compiler } from '../compiler';
+/**
+ * [Compiler Stage #4]
+ * Build the node schemas, following the graph resolved on previous steps.
+ */
+export declare class BuildSchemasStage {
+    compiler: Compiler;
+    constructor(compiler: Compiler);
+    run(): Promise<void>;
+}

package/lib/compiler/stages/4_build_schemas_stage.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildSchemasStage = void 0;
+const log_1 = require("../../engine/util/log");
+/**
+ * [Compiler Stage #4]
+ * Build the node schemas, following the graph resolved on previous steps.
+ */
+class BuildSchemasStage {
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    async run() {
+        log_1.Log.info('compiler', 'stage.build_schemas', 'Building schemas...');
+        await this.compiler.tree.traverse('Building schemas ', async (node) => {
+            // Inline nodes are built by their root builder
+            if (node.isInline) {
+                return;
+            }
+            const module = this.compiler.modules[node.module].module;
+            await module.buildNode(node, this.compiler.tree);
+        });
+    }
+}
+exports.BuildSchemasStage = BuildSchemasStage;

package/lib/compiler/stages/5_inject_ts_stage.d.ts

@@ -0,0 +1,10 @@
+import { Compiler } from '../compiler';
+/**
+ * [Compiler Stage #5]
+ * Transfer TypeScript sources (methods and imports) to schemas
+ */
+export declare class InjectTSStage {
+    compiler: Compiler;
+    constructor(compiler: Compiler);
+    run(): void;
+}

package/lib/compiler/stages/5_inject_ts_stage.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectTSStage = void 0;
+const log_1 = require("../../engine/util/log");
+const inject_1 = require("../typescript/bridge/inject");
+/**
+ * [Compiler Stage #5]
+ * Transfer TypeScript sources (methods and imports) to schemas
+ */
+class InjectTSStage {
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    run() {
+        log_1.Log.info('compiler', 'stage.inject_ts', 'Injecting TypeScript code to schemas...');
+        const { tree } = this.compiler;
+        const nodes = tree.allNodes();
+        inject_1.TSBridgeInject.inject(this.compiler, nodes);
+        log_1.Log.trace('compiler', 'stage.inject_ts', 'Finished injecting TS code');
+    }
+}
+exports.InjectTSStage = InjectTSStage;

package/lib/compiler/stages/6_build_elements_stage.d.ts

@@ -0,0 +1,11 @@
+import { Compiler } from '../compiler';
+/**
+ * [Compiler Stage #6]
+ * Build the node elements (the schemas which are saved to the .nesoi folder),
+ * following the graph resolved on previous steps.
+ */
+export declare class BuildElementsStage {
+    compiler: Compiler;
+    constructor(compiler: Compiler);
+    run(): Promise<void>;
+}

package/lib/compiler/stages/6_build_elements_stage.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildElementsStage = void 0;
+const log_1 = require("../../engine/util/log");
+/**
+ * [Compiler Stage #6]
+ * Build the node elements (the schemas which are saved to the .nesoi folder),
+ * following the graph resolved on previous steps.
+ */
+class BuildElementsStage {
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    async run() {
+        log_1.Log.info('compiler', 'stage.build_elements', 'Building Elements...');
+        await this.compiler.tree.traverse('Building elements ', async (node) => {
+            const module = this.compiler.modules[node.module];
+            await module.buildElementNode(node);
+        });
+    }
+}
+exports.BuildElementsStage = BuildElementsStage;

package/lib/compiler/stages/7_dump_stage.d.ts

@@ -0,0 +1,14 @@
+import { Compiler } from '../compiler';
+/**
+ * [Compiler Stage #7]
+ * Dump the element schemas and types to the .nesoi folder.
+ */
+export declare class DumpStage {
+    compiler: Compiler;
+    constructor(compiler: Compiler);
+    run(): void;
+    private dumpSpace;
+    private dumpModule;
+    private dumpModuleSchemas;
+    private dumpModuleType;
+}

package/lib/compiler/stages/7_dump_stage.js

@@ -0,0 +1,208 @@
+"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.DumpStage = void 0;
+const fs = __importStar(require("fs"));
+const log_1 = require("../../engine/util/log");
+const name_helpers_1 = require("../helpers/name_helpers");
+const path_1 = __importDefault(require("path"));
+const dependency_1 = require("../../engine/dependency");
+const bucket_element_1 = require("../elements/bucket.element");
+const dump_helpers_1 = require("../helpers/dump_helpers");
+const space_1 = require("../../engine/space");
+/**
+ * [Compiler Stage #7]
+ * Dump the element schemas and types to the .nesoi folder.
+ */
+class DumpStage {
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    run() {
+        log_1.Log.info('compiler', 'stage.dump', 'Dumping Schemas and Types...');
+        const spaceType = this.dumpSpace();
+        Object.values(this.compiler.modules).forEach(module => {
+            this.dumpModule(module, spaceType);
+        });
+    }
+    /* Space */
+    dumpSpace() {
+        const type = {
+            authnUsers: {},
+            modules: {}
+        };
+        // Authentication users
+        const _authn = this.compiler.space._authn;
+        Object.entries(_authn).forEach(([name, model]) => {
+            type.authnUsers[name] = bucket_element_1.BucketElement.buildModelTypeFromSchema(model);
+        });
+        // Module types
+        let dump = '';
+        dump += `import { $Space } from '${this.compiler.config?.nesoiPath ?? 'nesoi'}/lib/schema';\n`;
+        Object.values(this.compiler.modules).forEach(module => {
+            type.modules[module.lowName] = module.typeName;
+            dump += `import ${module.typeName} from './${module.lowName}.module';\n`;
+        });
+        const name = this.compiler.space._name;
+        dump += `\nexport default interface ${name} extends $Space `;
+        dump += dump_helpers_1.DumpHelpers.dumpType(type);
+        // Create dir and write to file
+        const dumpDir = space_1.Space.path(this.compiler.space, './.nesoi');
+        if (!fs.existsSync(dumpDir)) {
+            fs.mkdirSync(dumpDir, { recursive: true });
+        }
+        const spaceFilepath = path_1.default.resolve(dumpDir, name_helpers_1.NameHelpers.nameHighToLow(name) + '.ts');
+        fs.writeFileSync(spaceFilepath, dump);
+        return type;
+    }
+    /* Module */
+    dumpModule(module, spaceType) {
+        const dumpDir = space_1.Space.path(this.compiler.space, `./.nesoi/${module.lowName}`);
+        if (!fs.existsSync(dumpDir)) {
+            fs.mkdirSync(dumpDir, { recursive: true });
+        }
+        this.dumpModuleType(module, spaceType, dumpDir);
+        this.dumpModuleSchemas(module, dumpDir);
+    }
+    dumpModuleSchemas(module, dumpDir) {
+        const nesoiPath = this.compiler.config?.nesoiPath ?? 'nesoi';
+        module.elements.forEach((element) => {
+            const filename = path_1.default.basename(element.filepath());
+            const elPath = path_1.default.resolve(dumpDir, filename);
+            fs.writeFileSync(elPath, element.dumpFileSchema(nesoiPath));
+        });
+    }
+    dumpModuleType(module, spaceType, dumpDir) {
+        const nesoiPath = this.compiler.config?.nesoiPath ?? 'nesoi';
+        const moduleFile = [];
+        moduleFile.push(`import { $Module, $Constants, $Bucket, $Message, $Job, $Resource, $Machine, $Controller, $Queue } from '${nesoiPath}/lib/elements';`);
+        moduleFile.push(`import { NesoiDate } from '${nesoiPath}/lib/engine/data/date';`);
+        moduleFile.push(`import { NesoiDatetime } from '${nesoiPath}/lib/engine/data/datetime';`);
+        // Build module type (with all blocks)
+        const type = {
+            name: `'${module.lowName}'`,
+            externals: 'any',
+            constants: 'any',
+            buckets: {},
+            messages: {},
+            jobs: {},
+            resources: {},
+            machines: {},
+            queues: {},
+            controllers: {},
+        };
+        const externals = module.elements.find(el => el.$t === 'externals');
+        // Inject external node types on module
+        if (externals) {
+            if (!type.buckets) {
+                type.buckets = {};
+            }
+            Object.entries(externals.schema.buckets).forEach(([tag, ref]) => {
+                type.buckets[tag] = dependency_1.$Dependency.typeName(ref, module.lowName);
+            });
+            if (!type.jobs) {
+                type.jobs = {};
+            }
+            Object.entries(externals.schema.jobs).forEach(([tag, ref]) => {
+                type.jobs[tag] = dependency_1.$Dependency.typeName(ref, module.lowName);
+            });
+            if (!type.machines) {
+                type.machines = {};
+            }
+            Object.entries(externals.schema.machines).forEach(([tag, ref]) => {
+                type.machines[tag] = dependency_1.$Dependency.typeName(ref, module.lowName);
+            });
+        }
+        if (module.elements.some(el => el.$t === 'constants')) {
+            type.constants = module.highName + 'Constants';
+        }
+        module.elements.forEach(element => {
+            if (element.$t === 'externals' || element.$t === 'constants') {
+                return;
+            }
+            // WARN: this might breat non-regular plural block names in the future
+            const el_t = element.$t + 's';
+            if (!(el_t in type)) {
+                type[el_t] = {};
+            }
+            type[el_t][element.lowName] = element.typeName;
+        });
+        type['#input'] = dump_helpers_1.DumpHelpers.dumpType(module.elements
+            .filter(el => el.$t === 'message')
+            .map(el => el.typeName));
+        type['#authn'] = 'AuthnUsers';
+        // Dump external elements (imports)
+        module.elements
+            .filter(el => el.$t === 'externals')
+            .forEach((element) => {
+            moduleFile.push(element.dumpTypeSchema());
+        });
+        // Dump module type
+        moduleFile.push('');
+        moduleFile.push('/**');
+        moduleFile.push(` *  ${module.typeName}`);
+        moduleFile.push(' */');
+        moduleFile.push('');
+        let moduleDump = `export default interface ${module.typeName} extends $Module `;
+        moduleDump += dump_helpers_1.DumpHelpers.dumpType({
+            // Constants should be unknown by default, since enum types
+            // are validated across modules. The default type causes
+            // the enum alias to be keyof ... & Record<string, ...>, which
+            // invalidated the type assertion
+            constants: 'Omit<$Constants, \'values\'|\'enums\'> & { values: {}, enums: {} }',
+            ...type
+        });
+        moduleFile.push(moduleDump);
+        moduleFile.push('');
+        moduleFile.push('/* */');
+        moduleFile.push('');
+        // Dump authentication users
+        moduleFile.push(`type AuthnUsers = ${dump_helpers_1.DumpHelpers.dumpType(spaceType.authnUsers)}`);
+        // Dump other elements
+        module.elements
+            .filter(el => el.$t !== 'externals')
+            .forEach((element) => {
+            moduleFile.push(element.dumpTypeSchema());
+        });
+        // Write to file
+        const moduleFilename = `../${module.lowName}.module`;
+        const moduleFilepath = path_1.default.resolve(dumpDir, moduleFilename + '.ts');
+        fs.writeFileSync(moduleFilepath, moduleFile.join('\n'));
+    }
+}
+exports.DumpStage = DumpStage;

package/lib/compiler/stages/8_diagnose_stage.d.ts

@@ -0,0 +1,16 @@
+import { Compiler } from '../compiler';
+/**
+ * [Compiler Stage #8]
+ * Diagnose the space source with TypeScript
+ *
+ * This is the last stage since the source needs the .nesoi definitions to be up-to-date.
+ * So we build everything ignoring TypeScript errors, then check for those errors.
+ *
+ * This strategy has the downside of breaking the elements on a failed compile, which
+ * causes instability on the project types while the issue is not fixed
+ */
+export declare class DiagnoseStage {
+    compiler: Compiler;
+    constructor(compiler: Compiler);
+    run(): Promise<void>;
+}

package/lib/compiler/stages/8_diagnose_stage.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnoseStage = void 0;
+const log_1 = require("../../engine/util/log");
+/**
+ * [Compiler Stage #8]
+ * Diagnose the space source with TypeScript
+ *
+ * This is the last stage since the source needs the .nesoi definitions to be up-to-date.
+ * So we build everything ignoring TypeScript errors, then check for those errors.
+ *
+ * This strategy has the downside of breaking the elements on a failed compile, which
+ * causes instability on the project types while the issue is not fixed
+ */
+class DiagnoseStage {
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    async run() {
+        log_1.Log.info('compiler', 'stage.diagnose', 'Diagnosing space files with TypeScript...');
+        const { tsCompiler, tree } = this.compiler;
+        // Recreate TS program, to load new version of types
+        tsCompiler.createProgram();
+        const filepaths = [];
+        // Find all files
+        tree.allNodes().forEach(node => {
+            // Inline nodes belong to the same file as their parent
+            if (node.isInline) {
+                return;
+            }
+            if (Array.isArray(node.filepath)) {
+                filepaths.push(...node.filepath);
+            }
+            else {
+                filepaths.push(node.filepath);
+            }
+        });
+        filepaths.forEach(filepath => {
+            tsCompiler.check(filepath);
+        });
+    }
+}
+exports.DiagnoseStage = DiagnoseStage;

package/lib/compiler/treeshake.d.ts

@@ -0,0 +1,58 @@
+import { $Dependency, BuilderNode } from "../engine/dependency";
+import { BucketGraphBuilder } from "../elements/entities/bucket/graph/bucket_graph.builder";
+import { AnyModule } from "../engine/module";
+import { $BucketModelFields } from "../elements/entities/bucket/model/bucket_model.schema";
+export type TreeshakeConfig = {
+    exclude?: string[];
+};
+export declare class Treeshake {
+    static externals(node: BuilderNode, depth?: number): void;
+    static bucket(node: BuilderNode, depth?: number): void;
+    static bucketModelFields(node: BuilderNode, fields: $BucketModelFields): $Dependency[];
+    static bucketGraph(node: BuilderNode, builder: BucketGraphBuilder<any>): $Dependency[];
+    private static bucketGraphLink;
+    static message(node: BuilderNode, depth?: number): void;
+    private static messageFieldTree;
+    protected static blockIO(node: BuilderNode): $Dependency[];
+    protected static blockInlineNodes(node: BuilderNode, depth?: number): {
+        dependencies: $Dependency[];
+        inlines: BuilderNode[];
+    };
+    static job(node: BuilderNode, depth?: number): {
+        inlines: BuilderNode[];
+    };
+    static resource(node: BuilderNode, depth?: number): {
+        inlines: BuilderNode[];
+    };
+    static machine(node: BuilderNode, depth?: number): {
+        inlines: BuilderNode[];
+    };
+    static controller(node: BuilderNode): void;
+    static queue(node: BuilderNode): void;
+    /**
+     * Scans the module directory, imports the builders and lists
+     * all nodes found.
+     *
+     * @returns A list of all `BuilderNodes` found on the module folder
+     */
+    static module(module: AnyModule, config?: TreeshakeConfig): Promise<BuilderNode[]>;
+    /**
+     * Shakes a file to find all the builders declared on that file, and returns
+     * them as BuilderNodes:
+     * - Root-level (exported) builders
+     * - Inline builders
+     * - Nested inline builders
+     */
+    private static file;
+    /**
+     * Shakes a file to find all the builders declared on that file, and returns
+     * them as BuilderNodes:
+     * - Root-level (exported) builders
+     * - Inline builders
+     * - Nested inline builders
+     */
+    private static builder;
+    private static cleanNodeDependencies;
+    private static logNodeList;
+    private static logNodeTree;
+}