nesoi 3.0.0

package/lib/compiler/elements/element.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Element = void 0;
+const name_helpers_1 = require("../helpers/name_helpers");
+const dump_helpers_1 = require("../helpers/dump_helpers");
+class Element {
+    constructor(compiler, module, $t, files, schema, dependencies, inlineRoot, bridge) {
+        this.compiler = compiler;
+        this.module = module;
+        this.$t = $t;
+        this.files = files;
+        this.schema = schema;
+        this.dependencies = dependencies;
+        this.inlineRoot = inlineRoot;
+        this.bridge = bridge;
+        const names = name_helpers_1.NameHelpers.names(schema);
+        this.lowName = names.low;
+        this.highName = names.high;
+        this.typeName = names.type;
+    }
+    prepare() {
+        return;
+    }
+    filepath() {
+        return `${this.$t}__${this.lowName}.ts`;
+    }
+    bridgeImports() {
+        let imports = '';
+        for (const imp of this.bridge?.imports || []) {
+            imports += imp + '\n';
+        }
+        return imports;
+    }
+    customImports(nesoiPath) {
+        return '';
+    }
+    dumpFileSchema(nesoiPath) {
+        this.prepare();
+        return `import { ${this.typeName} } from '../${this.module}.module'\n`
+            + this.bridgeImports()
+            + this.customImports(nesoiPath)
+            + '\n'
+            + `const ${this.typeName}: ${this.typeName} = ${dump_helpers_1.DumpHelpers.dumpSchema(this.schema)}\n`
+            + `export default ${this.typeName}`;
+    }
+    dumpTypeSchema() {
+        this.type = this.buildType();
+        const typeschema = {
+            'constants': '$Constants',
+            'externals': '$Externals',
+            'message': '$Message',
+            'bucket': '$Bucket',
+            'job': '$Job',
+            'resource': '$Resource',
+            'machine': '$Machine',
+            'controller': '$Controller',
+            'queue': '$Queue',
+        }[this.$t];
+        return `export interface ${this.typeName} extends ${typeschema} ${dump_helpers_1.DumpHelpers.dumpType(this.type)};\n`;
+    }
+    static makeAuthnType(authn) {
+        if (authn.length === 0) {
+            return '{}';
+        }
+        const type = {};
+        authn.forEach(provider => {
+            type[provider] = `AuthnUsers['${provider}']`;
+        });
+        return type;
+    }
+    static makeIOType(compiler, schema) {
+        const input = schema.input.map(msg => {
+            const schema = compiler.tree.getSchema(msg);
+            const msgName = name_helpers_1.NameHelpers.names(schema);
+            return msgName.type;
+        });
+        const output = schema['#output'] || this.makeOutputType(compiler, schema);
+        return {
+            input: input.length ? input.join(' | ') : 'never',
+            output
+        };
+    }
+    static makeOutputType(compiler, schema) {
+        const raw = schema.output?.raw ? dump_helpers_1.DumpHelpers.dumpType(schema.output.raw) : undefined;
+        const msgs = schema.output?.msg?.map(msg => {
+            const schema = compiler.tree.getSchema(msg);
+            const msgName = name_helpers_1.NameHelpers.names(schema);
+            return msgName.type;
+        });
+        const objs = schema.output?.obj?.map(bucket => {
+            const schema = compiler.tree.getSchema(bucket);
+            const bucketName = name_helpers_1.NameHelpers.names(schema);
+            return bucketName.high;
+        });
+        const type = [
+            raw,
+            ...msgs || [],
+            ...objs || []
+        ].join(' | ');
+        return type || 'unknown';
+    }
+}
+exports.Element = Element;
+Element.Any = Symbol('undefined as any');
+Element.Never = Symbol('undefined as never');

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

@@ -0,0 +1,19 @@
+import { $Externals } from "../../elements/blocks/externals/externals.schema";
+import { Element } from './element';
+import { Compiler } from '../compiler';
+import { ResolvedBuilderNode } from "../../engine/dependency";
+export declare class ExternalsElement extends Element<$Externals> {
+    protected compiler: Compiler;
+    protected module: string;
+    $t: string;
+    files: string[];
+    schema: $Externals;
+    dependencies: ResolvedBuilderNode[];
+    inlineRoot?: ResolvedBuilderNode | undefined;
+    bridge?: ResolvedBuilderNode['bridge'];
+    private elements;
+    constructor(compiler: Compiler, module: string, $t: string, files: string[], schema: $Externals, dependencies: ResolvedBuilderNode[], inlineRoot?: ResolvedBuilderNode | undefined, bridge?: ResolvedBuilderNode['bridge']);
+    protected buildType(): {};
+    dumpFileSchema(): string;
+    dumpTypeSchema(): string;
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalsElement = void 0;
+const element_1 = require("./element");
+const name_helpers_1 = require("../helpers/name_helpers");
+const dump_helpers_1 = require("../helpers/dump_helpers");
+class ExternalsElement extends element_1.Element {
+    constructor(compiler, module, $t, files, schema, dependencies, inlineRoot, bridge) {
+        super(compiler, module, $t, files, schema, dependencies, inlineRoot, bridge);
+        this.compiler = compiler;
+        this.module = module;
+        this.$t = $t;
+        this.files = files;
+        this.schema = schema;
+        this.dependencies = dependencies;
+        this.inlineRoot = inlineRoot;
+        this.bridge = bridge;
+        this.elements = {
+            bucket: {},
+            job: {}
+        };
+        // Object.entries(schema.buckets).forEach(([key, ref]) => {
+        //     const element = compiler.modules[ref.module].elements
+        //         .find(el => el.lowName === ref.name && el.$t === 'bucket')
+        //     if (!element) {
+        //         throw new Error(`External bucket ${ref.name} not found`)
+        //     }
+        //     this.elements.bucket[key] = element as BucketElement;
+        // })
+        // Object.entries(schema.jobs).forEach(([key, ref]) => {
+        //     const element = compiler.modules[ref.module].elements
+        //         .find(el => el.lowName === ref.name && el.$t === 'job')
+        //     if (!element) {
+        //         throw new Error(`External job ${ref.name} not found`)
+        //     }
+        //     this.elements.job[key] = element as JobElement;
+        // })
+        // this.type = this.buildType();
+    }
+    buildType() {
+        return {};
+        // if (!this.elements) {
+        //     return {};
+        // }
+        // const type = {
+        //     models: {},
+        //     buckets: {},
+        //     jobs: {}
+        // } as ObjTypeAsObj;
+        // Object.entries(this.elements.bucket).map(([tag, el]) => {
+        //     type.models[tag] = (el.type as ObjTypeAsObj).model;
+        //     type.buckets[tag] = (el.type as ObjTypeAsObj).bucket;
+        // })        
+        // return type;
+    }
+    dumpFileSchema() {
+        return `const ${this.typeName} = ${dump_helpers_1.DumpHelpers.dumpSchema(this.schema)}\n`
+            + `export default ${this.typeName}`;
+    }
+    dumpTypeSchema() {
+        this.type = this.buildType();
+        this.prepare();
+        const externalModules = new Set();
+        Object.values(this.schema.buckets).forEach(ref => {
+            externalModules.add(ref.module);
+        });
+        Object.values(this.schema.jobs).forEach(ref => {
+            externalModules.add(ref.module);
+        });
+        // Add imports for external elements
+        this.compiler.modules[this.module].elements.forEach(el => {
+            el.dependencies.forEach(dep => {
+                if (dep.module !== this.module) {
+                    externalModules.add(dep.module);
+                }
+            });
+        });
+        return Array.from(externalModules)
+            .map(module => `import ${name_helpers_1.NameHelpers.nameLowToHigh(module)}Module from './${module}.module'`)
+            .join('\n');
+    }
+}
+exports.ExternalsElement = ExternalsElement;

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

@@ -0,0 +1,7 @@
+import { Element } from './element';
+import { $Job } from "../../elements/blocks/job/job.schema";
+export declare class JobElement extends Element<$Job> {
+    protected prepare(): void;
+    protected customImports(nesoiPath: string): string;
+    protected buildType(): import("./element").TypeAsObj;
+}

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobElement = void 0;
+const element_1 = require("./element");
+const dump_helpers_1 = require("../helpers/dump_helpers");
+const resource_job_1 = require("../../elements/blocks/job/internal/resource_job");
+class JobElement extends element_1.Element {
+    prepare() {
+        this.schema['#authn'] = element_1.Element.Any;
+        this.schema['#input'] = this.schema.input.length ? element_1.Element.Any : element_1.Element.Never;
+        this.schema['#output'] = element_1.Element.Any;
+        this.schema['#extra'] = element_1.Element.Any;
+        // ResourceJob
+        if (this.schema.scope && 'resource' in this.schema.scope) {
+            this.schema.method = {
+                __fn: 'ResourceJob.method as (...args: any[]) => any',
+                __fn_type: 'any' // TODO: evaluate
+            };
+            if (this.schema.scope.prepareMethod == resource_job_1.ResourceJob.prepareMsgData) {
+                this.schema.scope.prepareMethod = {
+                    __fn: '($ => $.msg.getData()) as (...args: any[]) => any',
+                    __fn_type: 'any' // TODO: evaluate
+                };
+            }
+            else if (this.schema.scope.prepareMethod == resource_job_1.ResourceJob.prepareTrue) {
+                this.schema.scope.prepareMethod = {
+                    __fn: '($ => true) as (...args: any[]) => any',
+                    __fn_type: 'boolean' // TODO: evaluate
+                };
+            }
+            this.schema.scope.execMethod = {
+                __fn: `Resource.${this.schema.scope.method} as (...args: any[]) => any`,
+                __fn_type: 'any' // TODO: evaluate
+            };
+        }
+    }
+    customImports(nesoiPath) {
+        let imports = '';
+        if (this.schema.scope && 'resource' in this.schema.scope) {
+            imports += `import { Resource } from '${nesoiPath}/lib/elements/blocks/resource/resource';\n`;
+            imports += `import { ResourceJob } from '${nesoiPath}/lib/elements/blocks/job/internal/resource_job';\n`;
+        }
+        return imports;
+    }
+    buildType() {
+        const { input, output } = element_1.Element.makeIOType(this.compiler, this.schema);
+        const type = dump_helpers_1.DumpHelpers.dumpValueToType(this.schema, {
+            extrasAndAsserts: () => 'any',
+            method: () => 'any',
+            output: () => 'any'
+        });
+        Object.assign(type, {
+            'input': 'any',
+            '#authn': element_1.Element.makeAuthnType(this.schema.authn),
+            '#input': input,
+            '#output': output,
+            '#extra': 'any // TODO: Typescript API'
+        });
+        return type;
+    }
+}
+exports.JobElement = JobElement;

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

@@ -0,0 +1,10 @@
+import { Element } from './element';
+import { $Machine } from "../../elements/blocks/machine/machine.schema";
+export declare class MachineElement extends Element<$Machine> {
+    protected prepare(): void;
+    private prepareStates;
+    private prepareTransitions;
+    protected buildType(): import("./element").TypeAsObj;
+    private buildStatesType;
+    private buildTransitionsType;
+}

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MachineElement = void 0;
+const element_1 = require("./element");
+const dependency_1 = require("../../engine/dependency");
+const dump_helpers_1 = require("../helpers/dump_helpers");
+class MachineElement extends element_1.Element {
+    prepare() {
+        this.schema['#authn'] = element_1.Element.Any;
+        this.schema['#input'] = this.schema.input.length ? element_1.Element.Any : element_1.Element.Never;
+        this.schema['#output'] = element_1.Element.Never;
+        this.schema['#data'] = element_1.Element.Any;
+        this.prepareStates(this.schema.states);
+        this.prepareTransitions(this.schema.transitions.from);
+        this.prepareTransitions(this.schema.transitions.to);
+    }
+    prepareStates(fields) {
+        Object.values(fields).forEach(field => {
+            field['#authn'] = element_1.Element.Any;
+            field['#input'] = field.input.length ? element_1.Element.Any : element_1.Element.Never;
+            field['#input.enter'] = field.inputEnter.length ? element_1.Element.Any : element_1.Element.Never;
+            field['#input.leave'] = field.inputLeave.length ? element_1.Element.Any : element_1.Element.Never;
+            field['#output'] = element_1.Element.Never;
+        });
+    }
+    prepareTransitions(ofStates) {
+        Object.values(ofStates).forEach(ofMsgs => {
+            Object.values(ofMsgs).forEach(transitions => {
+                Object.values(transitions).forEach(transition => {
+                    transition['#authn'] = element_1.Element.Any;
+                    transition['#input'] = transition.input.length ? element_1.Element.Any : element_1.Element.Never;
+                    transition['#output'] = element_1.Element.Never;
+                });
+            });
+        });
+    }
+    buildType() {
+        const type = dump_helpers_1.DumpHelpers.dumpValueToType(this.schema, {
+            states: v => this.buildStatesType(v),
+            transitions: {
+                from: v => this.buildTransitionsType(v),
+                to: v => this.buildTransitionsType(v)
+            }
+        });
+        const data = this.schema.buckets.map(bucket => {
+            const schema = this.compiler.tree.getSchema(bucket);
+            return dependency_1.$Dependency.typeName(bucket, this.module) + '[\'#data\']';
+        });
+        Object.assign(type, {
+            '#authn': element_1.Element.makeAuthnType(this.schema.authn),
+            '#input': element_1.Element.makeIOType(this.compiler, this.schema).input,
+            '#output': 'never',
+            '#data': data,
+        });
+        return type;
+    }
+    buildStatesType(states) {
+        const type = {};
+        Object.entries(states).forEach(([key, state]) => {
+            type[key] = dump_helpers_1.DumpHelpers.dumpValueToType(state);
+            Object.assign(type[key], {
+                jobs: {
+                    beforeEnter: type[key].jobs.beforeEnter ?? 'undefined',
+                    afterEnter: type[key].jobs.afterEnter ?? 'undefined',
+                    beforeLeave: type[key].jobs.beforeLeave ?? 'undefined',
+                    afterLeave: type[key].jobs.afterLeave ?? 'undefined'
+                },
+                '#authn': element_1.Element.makeAuthnType(state.authn),
+                '#input': element_1.Element.makeIOType(this.compiler, state).input,
+                '#input.enter': element_1.Element.makeIOType(this.compiler, { input: state.inputEnter, output: 'never' }).input,
+                '#input.leave': element_1.Element.makeIOType(this.compiler, { input: state.inputLeave, output: 'never' }).input,
+                '#output': 'never',
+            });
+        });
+        return type;
+    }
+    buildTransitionsType(transitions) {
+        const type = {};
+        Object.entries(transitions).forEach(([state, stateTransitions]) => {
+            type[state] = {};
+            Object.entries(stateTransitions).forEach(([msg, msgTransitions]) => {
+                type[state][msg] = [];
+                Object.values(msgTransitions).forEach(transition => {
+                    const t = dump_helpers_1.DumpHelpers.dumpValueToType(transition, undefined, 4);
+                    Object.assign(t, {
+                        '#authn': element_1.Element.makeAuthnType(transition.authn),
+                        '#input': element_1.Element.makeIOType(this.compiler, transition).input,
+                        '#output': 'never',
+                    });
+                    type[state][msg].push(t);
+                });
+                type[state][msg] = '[' + type[state][msg].map((v) => dump_helpers_1.DumpHelpers.dumpType(v, 4)).join(', ') + ']';
+            });
+        });
+        return type;
+    }
+}
+exports.MachineElement = MachineElement;

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

@@ -0,0 +1,9 @@
+import { $Message } from "../../elements/entities/message/message.schema";
+import { Element } from './element';
+export declare class MessageElement extends Element<$Message> {
+    protected prepare(): void;
+    private prepareFields;
+    protected customImports(nesoiPath: string): string;
+    protected buildType(): import("./element").TypeAsObj;
+    private buildIO;
+}

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

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageElement = void 0;
+const element_1 = require("./element");
+const name_helpers_1 = require("../helpers/name_helpers");
+const dependency_1 = require("../../engine/dependency");
+const dump_helpers_1 = require("../helpers/dump_helpers");
+class MessageElement extends element_1.Element {
+    prepare() {
+        this.schema['#raw'] = element_1.Element.Any;
+        this.schema['#parsed'] = element_1.Element.Any;
+        this.prepareFields(this.schema.template.fields);
+    }
+    prepareFields(fields) {
+        Object.values(fields).forEach(field => {
+            field['#raw'] = element_1.Element.Any;
+            field['#parsed'] = element_1.Element.Any;
+            if (field.children) {
+                this.prepareFields(field.children);
+            }
+        });
+    }
+    customImports(nesoiPath) {
+        // TODO: only include this import if there are computed fields
+        return `import { $MessageTemplateRule } from '${nesoiPath}/lib/elements/entities/message/template/message_template.schema'`;
+    }
+    buildType() {
+        const { input, output } = this.buildIO();
+        const type = dump_helpers_1.DumpHelpers.dumpValueToType(this.schema, {
+            template: v => 'any'
+        });
+        Object.assign(type, {
+            '#raw': {
+                $: dump_helpers_1.DumpHelpers.dumpValueToType(this.lowName),
+                ...input
+            },
+            '#parsed': {
+                $: dump_helpers_1.DumpHelpers.dumpValueToType(this.lowName),
+                ...output
+            }
+        });
+        return type;
+    }
+    buildIO(fields = this.schema.template.fields) {
+        const input = {};
+        const output = {};
+        Object.entries(fields).forEach(([key, field]) => {
+            if (field.type === 'boolean') {
+                input[key] = 'boolean';
+                output[key] = 'boolean';
+            }
+            else if (field.type === 'date') {
+                input[key] = 'string';
+                output[key] = 'NesoiDate';
+            }
+            else if (field.type === 'datetime') {
+                input[key] = 'string';
+                output[key] = 'NesoiDatetime';
+            }
+            else if (field.type === 'enum') {
+                const options = field.meta.enum.options;
+                if (typeof options === 'string') {
+                    const constants = this.compiler.tree.getSchema(field.meta.enum.dep);
+                    const constName = name_helpers_1.NameHelpers.names(constants);
+                    const tag = dependency_1.$Tag.parseOrFail(options);
+                    const moduleName = constName.high + 'Module';
+                    let enumkeys;
+                    if (tag.module || constants.module !== this.module) {
+                        const key = tag.name || options;
+                        const enumpath = key.match(/(.*)\.\{(.*)\}$/);
+                        enumkeys = enumpath
+                            ? `keyof ${moduleName}['constants']['enums']['${enumpath[1]}']['options']`
+                            : `keyof ${moduleName}['constants']['enums']['${key}']['options']`;
+                    }
+                    else {
+                        const enumpath = options.match(/(.*)\.\{(.*)\}$/);
+                        enumkeys = enumpath
+                            ? `keyof ${constName.type}['enums']['${enumpath[1]}']['options']`
+                            : `keyof ${constName.type}['enums']['${options}']['options']`;
+                    }
+                    input[key] = enumkeys;
+                    output[key] = enumkeys;
+                }
+                else if (Array.isArray(options)) {
+                    input[key] = options.map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v));
+                    output[key] = options.map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v));
+                }
+                else if (typeof options === 'object') {
+                    input[key] = Object.keys(options || []).map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v));
+                    output[key] = Object.values(options || []).map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v));
+                }
+            }
+            else if (field.type === 'file') {
+                input[key] = 'File';
+                output[key] = 'File';
+            }
+            else if (field.type === 'float') {
+                input[key] = 'number';
+                output[key] = 'number';
+            }
+            else if (field.type === 'id') {
+                const ref = field.meta.id.bucket;
+                const modelName = dependency_1.$Dependency.typeName(ref, this.module);
+                input[key + '_id'] = `${modelName}['#data']['id']`;
+                output[key] = `${modelName}['#data']`;
+            }
+            else if (field.type === 'int') {
+                input[key] = 'number';
+                output[key] = 'number';
+            }
+            else if (field.type === 'string') {
+                input[key] = 'string';
+                output[key] = 'string';
+            }
+            else if (field.type === 'string_or_number') {
+                input[key] = '(string | number)';
+                output[key] = '(string | number)';
+            }
+            else if (field.type === 'obj') {
+                const child = this.buildIO(field.children);
+                input[key] = child.input;
+                output[key] = child.output;
+            }
+            else if (field.type === 'dict') {
+                const child = this.buildIO(field.children);
+                input[key] = {
+                    '[x: string]': child.input.__dict
+                };
+                output[key] = {
+                    '[x: string]': child.output.__dict
+                };
+            }
+            else if (field.type === 'msg') {
+                input[key] = 'any';
+                output[key] = 'any';
+            }
+            else {
+                input[key] = 'unknown';
+                output[key] = 'unknown';
+            }
+            if (!field.required) {
+                if (typeof input[key] === 'object') {
+                    input[key].__optional = true;
+                }
+                else {
+                    input[key] += ' | undefined';
+                }
+                if (field.defaultValue === undefined) {
+                    if (typeof output[key] === 'object') {
+                        output[key].__optional = true;
+                    }
+                    else {
+                        output[key] += ' | undefined';
+                    }
+                }
+            }
+            if (field.array) {
+                if (typeof input[key] === 'object') {
+                    input[key].__array = true;
+                }
+                else {
+                    input[key] += '[]';
+                }
+                if (typeof output[key] === 'object') {
+                    output[key].__array = true;
+                }
+                else {
+                    output[key] += '[]';
+                }
+            }
+        });
+        return { input, output };
+    }
+}
+exports.MessageElement = MessageElement;

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueElement = void 0;
+const element_1 = require("./element");
+const dump_helpers_1 = require("../helpers/dump_helpers");
+class QueueElement extends element_1.Element {
+    prepare() {
+        this.schema['#authn'] = element_1.Element.Any;
+        this.schema['#input'] = element_1.Element.Any;
+        this.schema['#output'] = element_1.Element.Any;
+    }
+    buildType() {
+        const { input, output } = element_1.Element.makeIOType(this.compiler, this.schema);
+        const type = dump_helpers_1.DumpHelpers.dumpValueToType(this.schema);
+        delete type['output'];
+        return {
+            '#authn': element_1.Element.makeAuthnType(this.schema.authn),
+            '#input': input,
+            '#output': output,
+            ...type,
+        };
+    }
+}
+exports.QueueElement = QueueElement;

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

@@ -0,0 +1,7 @@
+import { Element } from './element';
+import { $Resource } from "../../elements/blocks/resource/resource.schema";
+export declare class ResourceElement extends Element<$Resource> {
+    protected prepare(): void;
+    protected buildType(): import("./element").TypeAsObj;
+    protected buildCreate(): void;
+}