nesoi 3.0.0

package/lib/compiler/typescript/typescript_compiler.js

@@ -0,0 +1,602 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptCompiler = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+const log_1 = require("../../engine/util/log");
+const space_1 = require("../../engine/space");
+const replace_import_transformer_1 = require("./transformers/replace_import.transformer");
+const app_inject_transformer_1 = require("./transformers/app_inject.transformer");
+const string_1 = require("../../engine/util/string");
+const parser_1 = require("./parser");
+class TypeScriptCompiler {
+    constructor(space, nesoiPath = 'node_modules/nesoi') {
+        this.space = space;
+        this.nesoiPath = nesoiPath;
+        this.files = TypeScriptCompiler.allFiles([
+            space_1.Space.path(space, 'modules')
+        ]);
+        this.files.push(space_1.Space.path(space, 'nesoi.ts'));
+        this.createProgram();
+    }
+    createProgram() {
+        this.program = ts.createProgram({
+            rootNames: this.files,
+            options: {
+                target: ts.ScriptTarget.ES2020,
+                module: ts.ModuleKind.CommonJS,
+                moduleResolution: ts.ModuleResolutionKind.Node10,
+                noEmitOnError: true,
+                declaration: false,
+                strict: true,
+                esModuleInterop: true,
+                paths: {
+                    ...(this.nesoiPath ? { 'nesoi/*': [`${this.nesoiPath}/*`] } : {}),
+                    '$': ['nesoi.ts']
+                },
+                rootDir: space_1.Space.path(this.space),
+                baseUrl: '.'
+            },
+        });
+        this.checker = this.program.getTypeChecker();
+    }
+    check(filepath) {
+        log_1.Log.debug('compiler', 'ts', `Diagnosing file ${(0, string_1.colored)(filepath, 'blue')}`);
+        const source = this.getSource(filepath);
+        const diagnostics = ts.getPreEmitDiagnostics(this.program, source);
+        TypeScriptCompiler.logDiagnostics(diagnostics);
+        if (diagnostics.length) {
+            throw new Error('TypeScript errors found.');
+        }
+    }
+    /**
+     * Extract all import nodes
+     */
+    extractImports(filepath, $) {
+        log_1.Log.trace('compiler', 'ts', `Extracting imports for file ${(0, string_1.colored)(filepath, 'blue')}`);
+        const source = this.getSource(filepath);
+        const imports = this.findAll(source, node => {
+            if (!ts.isImportDeclaration(node)) {
+                return;
+            }
+            const spec = parser_1.Parser.parseNode(node.moduleSpecifier).value;
+            // Not a relative import, use as it is
+            if (!spec.startsWith('./') && !spec.startsWith('../')) {
+                return node;
+            }
+            const from = path.resolve(filepath, '..', spec);
+            if ($?.ignore?.includes(from)) {
+                return;
+            }
+            return ts.factory.createImportDeclaration(node.modifiers, node.importClause, ts.factory.createStringLiteral(from, true));
+        });
+        const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+        const importStrs = imports.map(node => printer.printNode(ts.EmitHint.Unspecified, node, source));
+        return importStrs;
+    }
+    query(filepath, $) {
+        log_1.Log.trace('compiler', 'ts', `Querying '${$.query}' for file ${(0, string_1.colored)(filepath, 'blue')}`);
+        const source = this.getSource(filepath);
+        const builders = this.findAllNesoiBuilders(source);
+        const path = $.query.split('.');
+        if (path.length < 2) {
+            throw new Error('Query must start with builder_type.(*|builder_name)');
+        }
+        const buildersOfType = builders[path[0]];
+        if (!buildersOfType) {
+            throw new Error(`Invalid builder type ${path[0]}`);
+        }
+        const nodes = Object.entries(buildersOfType).filter(([name, node]) => path[1] === '*' || path[1] === name).map(([name, node]) => {
+            const [mod, el] = name.split('::');
+            return {
+                path: `${mod}::${path[0]}:${el}`,
+                node
+            };
+        });
+        const results = this.runQuery(nodes, {
+            ...$,
+            query: path.slice(2).join('.')
+        });
+        log_1.Log.trace('compiler', 'ts', 'Query results:', results.map(res => ({
+            path: res.path,
+            kind: ts.SyntaxKind[res.node.kind]
+        })));
+        return results;
+    }
+    runQuery(nodes, $) {
+        let results = [...nodes];
+        const path = $.query.split('.');
+        const loop = {
+            query: undefined
+        };
+        path.forEach(p => {
+            // Loop behavior
+            let loopStart = false;
+            let loopEnd = false;
+            if (p.startsWith('{')) {
+                p = p.slice(1);
+                loop.query = p;
+                loopStart = true;
+            }
+            if (p.endsWith('}')) {
+                if (loop.query === undefined) {
+                    throw new Error('In order to close a loop query, you must open one first');
+                }
+                p = p.slice(0, -1);
+                loopEnd = true;
+            }
+            if (!loopStart && loop.query !== undefined) {
+                loop.query += '.' + p;
+            }
+            // Filter step
+            results = results.map(result => {
+                const ptr = result.node;
+                // TS API object
+                if (ts.isCallExpression(ptr)) {
+                    const argIdx = parseInt(p);
+                    if (!isNaN(argIdx)) {
+                        if (argIdx >= ptr.arguments.length) {
+                            return [];
+                        }
+                        return {
+                            path: result.path + '▹' + argIdx.toString(),
+                            node: ptr.arguments[argIdx]
+                        };
+                    }
+                    return this.findInCallChain(ptr, node => {
+                        const name = this.getCallName(node);
+                        return p === '*' || name === p;
+                    }).map(node => {
+                        const suffix = (ts.isCallExpression(node) && ts.isStringLiteral(node.arguments[0]))
+                            ? '▹' + node.arguments[0].text
+                            : '';
+                        return {
+                            path: result.path + '▹' + p + suffix,
+                            node,
+                        };
+                    });
+                }
+                if (ts.isPropertyAccessExpression(ptr)) {
+                    return this.findInCallChain(ptr, parent => {
+                        const name = this.getCallName(parent);
+                        return name === p;
+                    }).map(node => ({
+                        path: result.path + '▹' + p,
+                        node,
+                    }));
+                }
+                if (ts.isFunctionExpression(ptr) || ts.isArrowFunction(ptr)) {
+                    if (p === 'return') {
+                        const node = this.getReturnNode(ptr);
+                        if (!node) {
+                            return [];
+                        }
+                        return {
+                            path: result.path + '▹return',
+                            node
+                        };
+                    }
+                    throw new Error('You can only query functions with .return');
+                }
+                if (ts.isObjectLiteralExpression(ptr)) {
+                    const parseObj = (node, path, nested = false) => {
+                        return node.properties.map(prop => {
+                            if (!ts.isPropertyAssignment(prop)) {
+                                throw new Error('A nesoi builder object property must be an assignment');
+                            }
+                            let name;
+                            if (ts.isIdentifier(prop.name)) {
+                                name = prop.name.escapedText;
+                            }
+                            else if (ts.isStringLiteral(prop.name)) {
+                                name = prop.name.text;
+                            }
+                            else {
+                                throw new Error('A nesoi builder object property assignment name must be an identifier or string literal');
+                            }
+                            if (p === '**') {
+                                if (ts.isObjectLiteralExpression(prop.initializer)) {
+                                    const nestedPath = path + '▹' + name;
+                                    return parseObj(prop.initializer, nestedPath, true);
+                                }
+                            }
+                            if (p === '*' || p === '**' || name === p) {
+                                return {
+                                    path: path + (nested ? '.' : '▹') + name,
+                                    node: prop.initializer
+                                };
+                            }
+                        })
+                            .flat(1)
+                            .filter(p => !!p);
+                    };
+                    return parseObj(ptr, result.path);
+                }
+                return [];
+            }).flat(1);
+            // Loop behavior
+            if (loopEnd) {
+                let loopResults = results;
+                while (loopResults.length) {
+                    loopResults = this.runQuery(loopResults, { query: loop.query, expectedKinds: [] });
+                    results.push(...loopResults);
+                }
+                loop.query = undefined;
+            }
+        });
+        if ($.expectedKinds.length) {
+            results.forEach(ptr => {
+                if (!$.expectedKinds.includes(ptr.node.kind)) {
+                    throw new Error(`Unexpected kind ${ts.SyntaxKind[ptr.node.kind]} on query result`);
+                }
+            });
+        }
+        return results;
+    }
+    getReturnNode(node) {
+        if (!ts.isFunctionExpression(node) && !ts.isArrowFunction(node)) {
+            return;
+        }
+        if (ts.isBlock(node.body)) {
+            // Warning: this only returns the first "return"
+            // to appear on the AST
+            const ret = node.body.statements.find(st => ts.isReturnStatement(st));
+            return ret?.expression;
+        }
+        if (ts.isParenthesizedExpression(node.body)) {
+            return node.body.expression;
+        }
+        if (ts.isCallExpression(node.body)) {
+            return node.body;
+        }
+        if (ts.isIdentifier(node.body)) {
+            return undefined;
+        }
+        throw new Error(`Unknown kind ${ts.SyntaxKind[node.body.kind]} for function body`);
+    }
+    getReturnType(node) {
+        const type = this.checker.getTypeAtLocation(node);
+        const signatures = this.checker.getSignaturesOfType(type, ts.SignatureKind.Call);
+        let fnReturnType = this.checker.getReturnTypeOfSignature(signatures[0]);
+        if (fnReturnType.symbol?.escapedName === 'Promise') {
+            fnReturnType = this.checker.getTypeArguments(fnReturnType)[0];
+        }
+        return this.checker.typeToString(fnReturnType, undefined, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.NoTypeReduction | ts.TypeFormatFlags.UseFullyQualifiedType // TODO: this causes freaky imports
+        );
+    }
+    getFnText(node) {
+        // This method is only used to generated intermediate schemas
+        // (the ones on the .nesoi folder). The function should have been
+        // evaluated before generating this schema, so the typing is useless here
+        return `(${node.getFullText()}) as (...args: any[]) => any`;
+    }
+    getFnType(node) {
+        const type = this.checker.getTypeAtLocation(node);
+        return this.checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.NoTypeReduction);
+    }
+    getCallName(node) {
+        // Function Call
+        if (ts.isCallExpression(node)) {
+            if (!ts.isPropertyAccessExpression(node.expression)) {
+                return undefined;
+            }
+            if (!ts.isIdentifier(node.expression.name)) {
+                return undefined;
+            }
+            return node.expression.name.escapedText;
+        }
+        // Getter Call
+        else if (ts.isPropertyAccessExpression(node)) {
+            if (!ts.isCallExpression(node.expression)) {
+                return undefined;
+            }
+            return node.name.escapedText;
+        }
+        return undefined;
+    }
+    isCall(node, from, method) {
+        if (ts.isCallExpression(node)
+            && ts.isPropertyAccessExpression(node.expression)
+            && ts.isIdentifier(node.expression.name)
+            && (!method || node.expression.name.escapedText === method)) {
+            const $ = node.expression.expression;
+            const symbol = this.checker.getTypeAtLocation($).getSymbol();
+            return symbol == from;
+        }
+        return false;
+    }
+    getSource(filename) {
+        const source = this.program.getSourceFile(filename);
+        if (!source) {
+            throw new Error(`Unable to find SourceFile for file '${filename}'`);
+        }
+        return source;
+    }
+    getNesoiSymbol(name, path) {
+        const factorySource = this.getSource(`${this.nesoiPath}/${path}`);
+        const factorySourceSymbol = this.checker.getSymbolAtLocation(factorySource);
+        if (!factorySourceSymbol) {
+            throw new Error(`Unable to find Nesoi symbol named '${name}' at '${path}'`);
+        }
+        const factorySourceExports = this.checker.getExportsOfModule(factorySourceSymbol);
+        for (const expt of factorySourceExports) {
+            if (expt.escapedName === name) {
+                return expt;
+            }
+        }
+        throw new Error(`Unable to find Nesoi symbol named '${name}' at '${path}'`);
+    }
+    getPropPath(node) {
+        const path = [
+            parser_1.Parser.parseNode(node.name).value
+        ];
+        let ptr = node;
+        while (ptr.parent?.parent) {
+            ptr = ptr.parent?.parent;
+            if (!ts.isPropertyAssignment(ptr)) {
+                break;
+            }
+            path.unshift(parser_1.Parser.parseNode(ptr.name).value);
+        }
+        return path.join('.');
+    }
+    findAllNesoiBuilders(node) {
+        const Nesoi = this.getNesoiSymbol('Space', 'lib/engine/space.d.ts');
+        const allBuilders = this.findAll(node, node => this.isCall(node, Nesoi) ? node : undefined);
+        const builders = {};
+        allBuilders.forEach(b => {
+            if (!ts.isCallExpression(b)) {
+                throw new Error('A Space property is not being called as a function');
+            }
+            if (!ts.isPropertyAccessExpression(b.expression)) {
+                throw new Error('A Space property is not being properly called');
+            }
+            const builderType = parser_1.Parser.parseNode(b.expression.name).value;
+            if (!builderType) {
+                throw new Error('Unable to identify builder type');
+            }
+            if (![
+                'externals',
+                'constants',
+                'bucket',
+                'message',
+                'job',
+                'resource',
+                'machine',
+                'controller',
+                'queue',
+            ].includes(builderType)) {
+                throw new Error(`Unknown builder type ${builderType}`);
+            }
+            builders[builderType] ?? (builders[builderType] = {});
+            if (b.arguments.length != 1) {
+                throw new Error('A builder initial call requires a single string argument');
+            }
+            if (!ts.isStringLiteral(b.arguments[0])) {
+                throw new Error('A builder name must be a string (to be known at compile time)');
+            }
+            const name = parser_1.Parser.parseNode(b.arguments[0]).value;
+            builders[builderType][name] = b;
+        });
+        return builders;
+    }
+    findAll(node, predicate) {
+        const found = [];
+        const visit = (node) => {
+            const result = predicate(node);
+            if (result) {
+                found.push(result);
+            }
+            return node.forEachChild((child) => visit(child));
+        };
+        node.forEachChild((child) => visit(child));
+        return found;
+    }
+    findParent(from, predicate) {
+        let node = from;
+        while (node.parent) {
+            node = node.parent;
+            if (predicate(node)) {
+                return node;
+            }
+        }
+    }
+    findInCallChain(node, predicate) {
+        const results = [];
+        const from = this.findCallsUntilRoot(node);
+        const to = this.findCallsUntilLast(node);
+        from.reverse();
+        const calls = [
+            ...from,
+            ...(ts.isCallExpression(node) ? [node] : []),
+            ...to
+        ];
+        for (const call of calls) {
+            if (predicate(call)) {
+                results.push(call);
+            }
+        }
+        return results;
+    }
+    findCallsUntilRoot(from) {
+        const calls = [];
+        let node = from;
+        while (node) {
+            if (!ts.isCallExpression(node) && !ts.isPropertyAccessExpression(node)) {
+                return calls;
+            }
+            if (!node.expression || !ts.isPropertyAccessExpression(node.expression)) {
+                return calls;
+            }
+            if (!node.expression.expression) {
+                return calls;
+            }
+            if (ts.isCallExpression(node.expression.expression)) {
+                calls.push(node.expression.expression);
+                node = node.expression.expression;
+            }
+            else if (ts.isPropertyAccessExpression(node.expression.expression)) {
+                calls.push(node.expression);
+                node = node.expression;
+            }
+            else {
+                return calls;
+            }
+        }
+        return calls;
+    }
+    findCallsUntilLast(from) {
+        const calls = [];
+        let node = from;
+        while (node) {
+            if (!node.parent || !ts.isPropertyAccessExpression(node.parent)) {
+                return calls;
+            }
+            if (!node.parent.parent) {
+                return calls;
+            }
+            if (ts.isPropertyAccessExpression(node.parent.parent)) {
+                calls.push(node.parent);
+                node = node.parent;
+            }
+            else if (ts.isCallExpression(node.parent.parent)) {
+                calls.push(node.parent.parent);
+                node = node.parent.parent;
+            }
+            else {
+                return calls;
+            }
+        }
+        return calls;
+    }
+    static logDiagnostics(diagnostics) {
+        if (!diagnostics.length) {
+            return;
+        }
+        log_1.Log.error('compiler', 'ts', 'TypeScript errors found:');
+        diagnostics.forEach(diagnostic => {
+            if (diagnostic.file) {
+                const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+                const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+                console.log(`${(0, string_1.colored)(diagnostic.file.fileName, 'blue')}:${(0, string_1.colored)(line + 1 + '', 'purple')},${(0, string_1.colored)(character + 1 + '', 'purple')}: ${(0, string_1.colored)(message, 'red')}`);
+            }
+            else {
+                console.log((0, string_1.colored)(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'), 'red'));
+            }
+        });
+    }
+    static allFiles(dirPaths) {
+        const arrayOfFiles = [];
+        for (const dirPath of dirPaths) {
+            const files = fs.readdirSync(dirPath);
+            files.forEach(function (file) {
+                const filepath = path.join(dirPath, file);
+                if (fs.lstatSync(filepath).isDirectory()) {
+                    arrayOfFiles.push(...TypeScriptCompiler.allFiles([filepath]));
+                }
+                else if (file.endsWith('.ts')) {
+                    arrayOfFiles.push(path.join(dirPath, file));
+                }
+            });
+        }
+        return arrayOfFiles;
+    }
+    /**
+     *
+     */
+    static compileFile(fileName, options = {
+        target: ts.ScriptTarget.ES2020,
+        module: ts.ModuleKind.CommonJS,
+        moduleResolution: ts.ModuleResolutionKind.Node10
+    }) {
+        log_1.Log.debug('compiler', 'ts', `Building file ${fileName}`);
+        const program = ts.createProgram([fileName], options);
+        const source = program.getSourceFile(fileName);
+        const diagnostics = ts.getPreEmitDiagnostics(program, source);
+        this.logDiagnostics(diagnostics);
+        if (diagnostics.length) {
+            throw new Error('TypeScript errors found.');
+        }
+        const result = ts.transpileModule(source.getFullText(), { compilerOptions: options });
+        return result.outputText;
+    }
+    /**
+     * !The first file is currently expected to be the app file
+     */
+    static compileApp(modules, fileNames, options, spacePath, buildPath, paths = {}) {
+        // const host = ts.createCompilerHost(options);
+        const program = ts.createProgram(fileNames, options);
+        let exitCode = 0;
+        for (const fileName of fileNames) {
+            log_1.Log.debug('compiler', 'ts', `Building file ${fileName}`);
+            const source = program.getSourceFile(fileName);
+            const emitResult = program.emit(source, (_, text) => {
+                let path = _;
+                const resolvedPath = paths[fileName];
+                if (resolvedPath && typeof resolvedPath === 'string') {
+                    path = resolvedPath;
+                    if (_.endsWith('.d.ts')) {
+                        path = path.replace(/\.js$/, '.d.ts');
+                    }
+                }
+                ts.sys.writeFile(path, text);
+            }, undefined, undefined, {
+                before: [
+                    (0, replace_import_transformer_1.makeReplaceImportTransformer)(spacePath, buildPath, paths),
+                    ...(fileName === fileNames[0] ? [(0, app_inject_transformer_1.makeAppInjectTransformer)(modules)] : [])
+                ],
+                afterDeclarations: [(0, replace_import_transformer_1.makeReplaceImportTransformer)(spacePath, buildPath, paths)]
+            });
+            emitResult.diagnostics.forEach(diagnostic => {
+                if (diagnostic.file) {
+                    const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+                    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+                    log_1.Log.error('compiler', 'ts', `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+                }
+                else {
+                    log_1.Log.error('compiler', 'ts', ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'));
+                }
+            });
+            const stepExitCode = emitResult.emitSkipped ? 1 : 0;
+            log_1.Log.trace('compiler', 'ts', `Compiler resulted code '${exitCode}'.`);
+            if (stepExitCode)
+                exitCode = stepExitCode;
+        }
+        return exitCode;
+    }
+}
+exports.TypeScriptCompiler = TypeScriptCompiler;

package/lib/elements/blocks/block.builder.d.ts

@@ -0,0 +1,29 @@
+import { $Module, $Space } from "../../schema";
+import { $BlockOutput, $BlockType } from './block.schema';
+import { MultiMessageTemplateDef } from "../entities/message/template/message_template.builder";
+import { $Dependency, BuilderNode } from "../../engine/dependency";
+export declare abstract class BlockBuilder<Space extends $Space, Module extends $Module, Type extends $BlockType> {
+    protected module: string;
+    protected type: Type;
+    protected name: string;
+    protected _alias?: string;
+    protected _authn: string[];
+    protected _inlineNodes: BuilderNode[];
+    protected _inputMsgs: $Dependency[];
+    protected _output?: $BlockOutput;
+    constructor(module: string, type: Type, name: string);
+    /** Block "human" name */
+    as(alias: string): this;
+    /**
+     * Inline messages. These messages are exposed to the module,
+     * with a name prefixed by the block name.
+     * @param def Example: `$ => { msg1: { prop1: $.int, prop2: $.string }, msg2: { prop3: $.boolean } }`
+     * @returns
+     */
+    protected messages<Def extends MultiMessageTemplateDef<Space, Module>>(def: Def): unknown;
+    authn(...providers: string[]): unknown;
+    protected _input(...names: string[]): unknown;
+    protected outputRaw(): unknown;
+    protected outputMsg(...msgs: string[]): unknown;
+    protected outputObj(...objs: string[]): unknown;
+}