nesoi 3.0.0

package/lib/compiler/compiler.js

@@ -0,0 +1,83 @@
+"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.Compiler = void 0;
+const fs = __importStar(require("fs"));
+const tree_1 = require("../engine/tree");
+const space_1 = require("../engine/space");
+const typescript_compiler_1 = require("./typescript/typescript_compiler");
+const _1_scan_stage_1 = require("./stages/1_scan_stage");
+const _2_treeshake_stage_1 = require("./stages/2_treeshake_stage");
+const _3_extract_ts_stage_1 = require("./stages/3_extract_ts_stage");
+const _4_build_schemas_stage_1 = require("./stages/4_build_schemas_stage");
+const _5_inject_ts_stage_1 = require("./stages/5_inject_ts_stage");
+const _6_build_elements_stage_1 = require("./stages/6_build_elements_stage");
+const _7_dump_stage_1 = require("./stages/7_dump_stage");
+const console_1 = __importDefault(require("../engine/util/console"));
+const log_1 = require("../engine/util/log");
+const _8_diagnose_stage_1 = require("./stages/8_diagnose_stage");
+class Compiler {
+    constructor(space, config) {
+        this.space = space;
+        this.config = config;
+        this.modules = {};
+        this.tree = new tree_1.ModuleTree({}, this.config);
+        this.tsCompiler = new typescript_compiler_1.TypeScriptCompiler(space, config?.nesoiPath);
+    }
+    async run() {
+        console_1.default.header('Elements Compiler');
+        // Cleanup .nesoi folder
+        fs.rmSync(space_1.Space.path(this.space, '.nesoi'), { recursive: true, force: true });
+        try {
+            await new _1_scan_stage_1.ScanStage(this).run();
+            await new _2_treeshake_stage_1.TreeshakeStage(this).run();
+            await new _3_extract_ts_stage_1.ExtractTSStage(this).run();
+            await new _4_build_schemas_stage_1.BuildSchemasStage(this).run();
+            await new _5_inject_ts_stage_1.InjectTSStage(this).run();
+            await new _6_build_elements_stage_1.BuildElementsStage(this).run();
+            await new _7_dump_stage_1.DumpStage(this).run();
+            await new _8_diagnose_stage_1.DiagnoseStage(this).run();
+        }
+        catch (e) {
+            log_1.Log.error('compiler', 'nesoi', e.toString(), { stack: e.stack });
+            process.exit();
+        }
+        return this;
+    }
+}
+exports.Compiler = Compiler;

package/lib/compiler/elements/bucket.element.d.ts

@@ -0,0 +1,23 @@
+import { $BucketModel, $BucketModelFields } from "../../elements/entities/bucket/model/bucket_model.schema";
+import { Element, ObjTypeAsObj, TypeAsObj } from './element';
+import { $Bucket } from "../../elements/entities/bucket/bucket.schema";
+export declare class BucketElement extends Element<$Bucket> {
+    protected prepare(): void;
+    private prepareGraph;
+    private prepareViews;
+    private prepareViewFields;
+    protected customImports(nesoiPath: string): string;
+    protected buildType(): {
+        model: ObjTypeAsObj;
+        bucket: TypeAsObj;
+    };
+    private buildModelFieldType;
+    private buildCompositionType;
+    buildModelType(fields?: $BucketModelFields): ObjTypeAsObj;
+    buildModelFieldNamesType(model: ObjTypeAsObj, fields?: $BucketModelFields, path?: string): Record<string, TypeAsObj>;
+    private buildGraphType;
+    private buildViewsType;
+    private buildViewType;
+    dumpTypeSchema(): string;
+    static buildModelTypeFromSchema(model: $BucketModel): any;
+}

package/lib/compiler/elements/bucket.element.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketElement = void 0;
+const element_1 = require("./element");
+const name_helpers_1 = require("../helpers/name_helpers");
+const dependency_1 = require("../../engine/dependency");
+const tree_1 = require("../../engine/data/tree");
+const dump_helpers_1 = require("../helpers/dump_helpers");
+class BucketElement extends element_1.Element {
+    // Prepare
+    prepare() {
+        this.schema['#data'] = element_1.Element.Any;
+        this.schema['#fieldpath'] = element_1.Element.Any;
+        this.schema['#composition'] = element_1.Element.Any;
+        this.schema['#defaults'] = element_1.Element.Any;
+        this.prepareGraph(this.schema.graph.links);
+        this.prepareViews(this.schema.views);
+    }
+    prepareGraph(links) {
+        Object.values(links).forEach(field => {
+            field['#bucket'] = element_1.Element.Any;
+            field['#many'] = element_1.Element.Any;
+        });
+    }
+    prepareViews(views) {
+        Object.values(views).forEach(view => {
+            view['#data'] = element_1.Element.Any;
+            this.prepareViewFields(view.fields);
+        });
+    }
+    prepareViewFields(fields) {
+        Object.values(fields).forEach(field => {
+            field['#data'] = element_1.Element.Any;
+            if (field.children) {
+                this.prepareViewFields(field.children);
+            }
+            else {
+                field.children = element_1.Element.Never;
+            }
+        });
+    }
+    // Imports 
+    customImports(nesoiPath) {
+        // TODO: only include this import if there are computed fields
+        return `import { $BucketViewFieldFn } from '${nesoiPath}/lib/elements/entities/bucket/view/bucket_view.schema';\n`;
+    }
+    // Build Type
+    buildType() {
+        const model = this.buildModelType();
+        const bucket = dump_helpers_1.DumpHelpers.dumpValueToType(this.schema, {
+            graph: () => this.buildGraphType(),
+            views: () => this.buildViewsType(model)
+        });
+        const fieldpaths = this.buildModelFieldNamesType(model);
+        const composition = this.buildCompositionType();
+        Object.assign(bucket, {
+            '#fieldpath': fieldpaths,
+            '#composition': composition,
+            '#defaults': bucket.defaults || '{}',
+            '#data': this.highName
+        });
+        return {
+            model,
+            bucket
+        };
+    }
+    buildModelFieldType(field) {
+        let type = 'unknown';
+        if (field.type === 'boolean') {
+            type = 'boolean';
+        }
+        else if (field.type === 'date') {
+            type = 'NesoiDate';
+        }
+        else if (field.type === 'datetime') {
+            type = 'NesoiDatetime';
+        }
+        else if (field.type === 'enum') {
+            const options = field._enum.options;
+            if (typeof options === 'string') {
+                const constants = this.compiler.tree.getSchema(field._enum.dep);
+                const constName = name_helpers_1.NameHelpers.names(constants);
+                const tag = dependency_1.$Tag.parseOrFail(options);
+                if (tag.module || constants.module !== this.module) {
+                    const moduleName = constName.high + 'Module';
+                    type = `keyof ${moduleName}['constants']['enums']['${tag.name || options}']['options']`;
+                }
+                else {
+                    type = `keyof ${constName.type}['enums']['${options}']['options']`;
+                }
+            }
+            else if (Array.isArray(options)) {
+                type = options.map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v));
+            }
+            else if (typeof options === 'object') {
+                type = Object.values(options || []).map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v));
+            }
+        }
+        else if (field.type === 'file') {
+            type = 'File';
+        }
+        else if (field.type === 'float') {
+            type = 'number';
+        }
+        else if (field.type === 'int') {
+            type = 'number';
+        }
+        else if (field.type === 'string') {
+            type = 'string';
+        }
+        else if (field.type === 'obj') {
+            type = this.buildModelType(field.children);
+        }
+        else if (field.type === 'unknown') {
+            type = 'unknown';
+        }
+        else if (field.type === 'dict') {
+            type = this.buildModelType({
+                '[x: string]': field.children.__dict
+            });
+        }
+        if (!field.required && !field.defaultValue) {
+            if (typeof type === 'object') {
+                type.__optional = true;
+            }
+            else {
+                type += ' | undefined';
+            }
+        }
+        if (field.array) {
+            if (typeof type === 'object') {
+                type.__array = true;
+            }
+            else {
+                type += '[]';
+            }
+        }
+        if (field.or) {
+            type = dump_helpers_1.DumpHelpers.dumpType(type, 4)
+                + ' | '
+                + dump_helpers_1.DumpHelpers.dumpType(this.buildModelFieldType(field.or), 4);
+        }
+        return type;
+    }
+    buildCompositionType() {
+        const composition = {};
+        Object.values(this.schema.graph.links).forEach(link => {
+            if (link.rel === 'composition') {
+                const bucket = dependency_1.$Dependency.typeName(link.bucket, this.module);
+                composition[link.name] = {
+                    bucket,
+                    many: link.many.toString(),
+                    optional: link.optional.toString()
+                };
+            }
+        });
+        return composition;
+    }
+    buildModelType(fields = this.schema.model.fields) {
+        const model = {};
+        Object.entries(fields).forEach(([key, field]) => {
+            model[key] = this.buildModelFieldType(field);
+        });
+        return model;
+    }
+    buildModelFieldNamesType(model, fields = this.schema.model.fields, path) {
+        const fieldPaths = {};
+        Object.entries(fields).forEach(([key, field]) => {
+            if (key === '__dict') {
+                return;
+            }
+            const keyPath = (path ? path + '.' : '') + key;
+            fieldPaths[keyPath] = model[key];
+            if (field.children) {
+                let nextFields = field.children;
+                let nextKey = keyPath;
+                if ('__dict' in field.children) {
+                    nextFields = field.children.__dict.children;
+                    nextKey += '.*';
+                }
+                if (field.array)
+                    nextKey += '.*';
+                if (nextFields) {
+                    Object.assign(fieldPaths, this.buildModelFieldNamesType(model[key], nextFields, nextKey));
+                }
+            }
+        });
+        return fieldPaths;
+    }
+    buildGraphType() {
+        const links = {};
+        Object.entries(this.schema.graph.links).forEach(([key, link]) => {
+            links[key] = dump_helpers_1.DumpHelpers.dumpValueToType(link);
+            const bucket = dependency_1.$Dependency.typeName(link.bucket, this.module);
+            Object.assign(links[key], {
+                '#bucket': bucket,
+                '#many': link.many.toString()
+            });
+        });
+        return {
+            $t: dump_helpers_1.DumpHelpers.dumpValueToType('bucket.graph'),
+            links
+        };
+    }
+    buildViewsType(model) {
+        const views = {};
+        Object.entries(this.schema.views).forEach(([key, view]) => {
+            views[key] = this.buildViewType(model, view.fields, key);
+        });
+        return views;
+    }
+    buildViewType(model, schema, name) {
+        if (!schema) {
+            return;
+        }
+        const fields = {};
+        const data = {};
+        Object.entries(schema).forEach(([key, field]) => {
+            if (field.scope === 'model' && 'model' in field.value) {
+                data[key] = tree_1.Tree.get(model, field.value.model.key, 0) || {};
+                let children;
+                if (field.type === 'obj') {
+                    children = field.children &&
+                        this.buildViewType(model, field.children, field.name);
+                    data[key] = Object.assign({}, data[key], children?.['#data']);
+                }
+                fields[key] = {
+                    '#data': data[key],
+                    children: children?.fields
+                };
+            }
+            else if (field.scope === 'graph' && 'graph' in field.value) {
+                const link = this.schema.graph.links[field.value.graph.link];
+                const bucket = dependency_1.$Dependency.typeName(link.bucket, this.module);
+                if (field.value.graph.view) {
+                    data[key] = `${bucket}['views']['${field.value.graph.view}']['#data']${link.many ? '[]' : ''}${link.optional ? ' | undefined' : ''}`;
+                }
+                else {
+                    data[key] = `${bucket}['#data']${link.many ? '[]' : ''}${link.optional ? ' | undefined' : ''}`;
+                }
+                fields[key] = {
+                    '#data': data[key],
+                    children: 'undefined'
+                };
+            }
+            else if (field.scope === 'computed') {
+                data[key] = field['#data'];
+                fields[key] = {
+                    '#data': data[key],
+                    children: 'undefined'
+                };
+            }
+            else if (field.scope === 'view' || field.scope === 'group') {
+                const children = this.buildViewType(model, field.children, field.name);
+                data[key] = children['#data'];
+                fields[key] = {
+                    '#data': data[key],
+                    children: children.fields
+                };
+            }
+            const { children, ...f } = field;
+            const type = dump_helpers_1.DumpHelpers.dumpValueToType(f, {
+                $t: () => dump_helpers_1.DumpHelpers.dumpValueToType('bucket.view.field'),
+                value: {
+                    model: v => ({
+                        key: dump_helpers_1.DumpHelpers.dumpValueToType(v.key),
+                        enumOptions: v.enumOptions ? dump_helpers_1.DumpHelpers.dumpValueToType(v.enumOptions) : 'undefined'
+                    }),
+                    graph: v => ({
+                        link: dump_helpers_1.DumpHelpers.dumpValueToType(v.link),
+                        view: v.view ? dump_helpers_1.DumpHelpers.dumpValueToType(v.view) : 'undefined'
+                    })
+                }
+            });
+            Object.assign(fields[key], type);
+        });
+        return {
+            $t: dump_helpers_1.DumpHelpers.dumpValueToType('bucket.view'),
+            '#data': data,
+            name: dump_helpers_1.DumpHelpers.dumpValueToType(name),
+            fields: 'any' // TODO: review if this might be needed
+        };
+    }
+    // Dump
+    dumpTypeSchema() {
+        this.type = this.buildType();
+        this.prepare();
+        const type = this.type;
+        const obj = `export type ${this.highName} = ${dump_helpers_1.DumpHelpers.dumpType(type.model)};\n`;
+        const bucket = `export interface ${this.typeName} extends $Bucket ${dump_helpers_1.DumpHelpers.dumpType(type.bucket)};\n`;
+        return obj + '\n' + bucket;
+    }
+    //
+    static buildModelTypeFromSchema(model) {
+        // This currently breaks with enum, which are module-level
+        // Since this method is used to build space-level models
+        const el = {
+            buildModel: BucketElement.prototype.buildModelType,
+            buildModelFieldType: BucketElement.prototype.buildModelFieldType
+        };
+        return el.buildModel.bind(el)(model.fields);
+    }
+}
+exports.BucketElement = BucketElement;

package/lib/compiler/elements/constants.element.d.ts

@@ -0,0 +1,9 @@
+import { Element } from './element';
+import { $Constants } from "../../elements/entities/constants/constants.schema";
+export declare class ConstantsElement extends Element<$Constants> {
+    protected prepare(): void;
+    protected buildType(): import("./element").TypeAsObj;
+    private buildEnums;
+    private buildEnumTree;
+    private buildEnumPaths;
+}

package/lib/compiler/elements/constants.element.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantsElement = void 0;
+const element_1 = require("./element");
+const dump_helpers_1 = require("../helpers/dump_helpers");
+class ConstantsElement extends element_1.Element {
+    prepare() {
+        // Enums
+        this.schema['#enumpath'] = element_1.Element.Any;
+        Object.values(this.schema.enums).forEach(enu => {
+            enu['#data'] = element_1.Element.Any;
+        });
+    }
+    buildType() {
+        const enums = this.buildEnums();
+        // Make a tree of subenums, to generate enumpaths
+        // These are paths that can be used to refer to an enum
+        // on a message, to allow for dynamically scoped enums
+        const enumTree = this.buildEnumTree(enums);
+        const enumPaths = this.buildEnumPaths(enumTree);
+        return dump_helpers_1.DumpHelpers.dumpValueToType(this.schema, {
+            '#enumpath': v => enumPaths,
+            enums: v => enums
+        });
+    }
+    buildEnums() {
+        const enums = {};
+        Object.entries(this.schema.enums).forEach(([key, val]) => {
+            const type = {};
+            const data = {};
+            Object.entries(val.options).forEach(([optKey, optVal]) => {
+                const value = dump_helpers_1.DumpHelpers.dumpValueToType(optVal.value);
+                type[optKey] = {
+                    key: dump_helpers_1.DumpHelpers.dumpValueToType(optKey),
+                    value
+                };
+                data[optKey] = value;
+            });
+            enums[key] = {
+                '#data': data,
+                name: dump_helpers_1.DumpHelpers.dumpValueToType(key),
+                options: type
+            };
+        });
+        return enums;
+    }
+    buildEnumTree(enums) {
+        const enumTree = {};
+        Object.keys(enums).forEach(name => {
+            const split = name.split('.');
+            let key = '';
+            let node = enumTree;
+            split.forEach((part, i) => {
+                key += key.length ? `.${part}` : part;
+                node[part] ?? (node[part] = {
+                    _enum: `${this.typeName}['enums']['${key}']`,
+                    _subs: []
+                });
+                if (i < split.length - 1) {
+                    if (!node[part]._subs.includes(split[i + 1])) {
+                        node[part]._subs.push(split[i + 1]);
+                    }
+                }
+                node = node[part];
+            });
+        });
+        return enumTree;
+    }
+    buildEnumPaths(enumTree, path = '') {
+        const paths = {};
+        Object.entries(enumTree).forEach(([key, val]) => {
+            const { _enum, _subs, ...next } = val;
+            paths[path + key] = {
+                _enum: _enum,
+                _subs: 'never'
+            };
+            if (_subs.length) {
+                paths[path + key + '.*'] = {
+                    _enum: _enum,
+                    _subs: _subs.map(v => `'${v}'`).join(' | ')
+                };
+            }
+            Object.assign(paths, this.buildEnumPaths(next, path + key + '.'));
+        });
+        return paths;
+    }
+}
+exports.ConstantsElement = ConstantsElement;

package/lib/compiler/elements/controller.element.d.ts

@@ -0,0 +1,6 @@
+import { Element } from './element';
+import { $Controller } from "../../elements/edge/controller/controller.schema";
+export declare class ControllerElement extends Element<$Controller> {
+    protected prepare(): void;
+    protected buildType(): any;
+}

package/lib/compiler/elements/controller.element.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllerElement = void 0;
+const dependency_1 = require("../../engine/dependency");
+const element_1 = require("./element");
+const dump_helpers_1 = require("../helpers/dump_helpers");
+class ControllerElement extends element_1.Element {
+    prepare() {
+        this.schema['#authn'] = element_1.Element.Any;
+        this.schema['#input'] = element_1.Element.Any;
+    }
+    buildType() {
+        const type = dump_helpers_1.DumpHelpers.dumpValueToType(this.schema);
+        const input = this.schema.input.map(dep => dependency_1.$Dependency.typeName(dep, this.module)).join(' | ');
+        return {
+            '#authn': element_1.Element.makeAuthnType(this.schema.authn),
+            '#input': input,
+            ...type
+        };
+    }
+}
+exports.ControllerElement = ControllerElement;

package/lib/compiler/elements/element.d.ts

@@ -0,0 +1,49 @@
+import { ResolvedBuilderNode } from "../../engine/dependency";
+import { AnyElementSchema } from "../../engine/module";
+import { $Machine, $MachineState, $MachineTransition } from "../../elements/blocks/machine/machine.schema";
+import { $Job } from "../../elements/blocks/job/job.schema";
+import { $Queue } from "../../elements/blocks/queue/queue.schema";
+import { Compiler } from '../compiler';
+import { $Block } from "../../elements/blocks/block.schema";
+export type TypeAsObj = string | ({
+    [x: string]: TypeAsObj;
+} & {
+    __array?: boolean;
+    __optional?: boolean;
+});
+export type ObjTypeAsObj = TypeAsObj & Record<string, any>;
+export declare abstract class Element<T extends AnyElementSchema> {
+    protected compiler: Compiler;
+    protected module: string;
+    $t: string;
+    files: string[];
+    schema: T;
+    dependencies: ResolvedBuilderNode[];
+    inlineRoot?: ResolvedBuilderNode | undefined;
+    bridge?: ResolvedBuilderNode['bridge'];
+    static Any: any;
+    static Never: any;
+    type: TypeAsObj;
+    lowName: string;
+    highName: string;
+    typeName: string;
+    constructor(compiler: Compiler, module: string, $t: string, files: string[], schema: T, dependencies: ResolvedBuilderNode[], inlineRoot?: ResolvedBuilderNode | undefined, bridge?: ResolvedBuilderNode['bridge']);
+    protected prepare(): void;
+    protected abstract buildType(): TypeAsObj;
+    filepath(): string;
+    private bridgeImports;
+    protected customImports(nesoiPath: string): string;
+    dumpFileSchema(nesoiPath: string): string;
+    dumpTypeSchema(): string;
+    static makeAuthnType(authn: string[]): ({
+        [x: string]: TypeAsObj;
+    } & {
+        __array?: boolean;
+        __optional?: boolean;
+    } & Record<string, any>) | "{}";
+    static makeIOType(compiler: Compiler, schema: $Job | $Machine | $MachineState | $MachineTransition | $Queue): {
+        input: string;
+        output: {};
+    };
+    static makeOutputType(compiler: Compiler, schema: $Block): string;
+}