nesoi 3.0.0

package/lib/compiler/typescript/transformers/app_inject.transformer.js

@@ -0,0 +1,89 @@
+"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.makeAppInjectTransformer = makeAppInjectTransformer;
+const ts = __importStar(require("typescript"));
+const parser_1 = require("../parser");
+function makeAppInjectTransformer(modules) {
+    // @ts-expect-error This is according to documentation, but the type is broken for some reason
+    const transformer = (context) => {
+        const visit = (node) => {
+            // Find leaf node of builder which is a NewExpression
+            if (ts.isNewExpression(node)) {
+                if (parser_1.Parser.parseNode(node.expression).value !== 'MonolythApp') {
+                    return { monolyth: false, node };
+                }
+                return {
+                    monolyth: true,
+                    node: ts.factory.updateNewExpression(node, node.expression, node.typeArguments, [
+                        node.arguments[0]
+                    ])
+                };
+            }
+            // Check children for a monolyth NewExpression
+            let monolyth = false;
+            const cNode = ts.visitEachChild(node, (child) => {
+                const deep = visit(child);
+                if (deep.monolyth)
+                    monolyth = true;
+                return deep.node;
+            }, context);
+            // Transform .modules() into .prebuilt()
+            if (monolyth
+                && ts.isCallExpression(cNode)
+                && ts.isPropertyAccessExpression(cNode.expression)
+                && ts.isIdentifier(cNode.expression.name)
+                && cNode.expression.name.escapedText === 'modules') {
+                return {
+                    monolyth: true,
+                    node: ts.factory.updateCallExpression(cNode, ts.factory.updatePropertyAccessExpression(cNode.expression, cNode.expression.expression, ts.factory.createIdentifier('inject')), cNode.typeArguments, [
+                        ts.factory.createArrayLiteralExpression(modules.map(module => ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createIdentifier('require'), undefined, [
+                            ts.factory.createStringLiteral(`./modules/${module}`, true)
+                        ]), ts.factory.createIdentifier('default'))), true)
+                    ])
+                };
+            }
+            return {
+                monolyth,
+                node: cNode
+            };
+        };
+        return (node) => ts.visitNode(node, (child) => {
+            const { monolyth, node } = visit(child);
+            return node;
+        });
+    };
+    return transformer;
+}

package/lib/compiler/typescript/transformers/replace_import.transformer.d.ts

@@ -0,0 +1,4 @@
+import * as ts from 'typescript';
+export declare function makeReplaceImportTransformer(spacePath: string, buildPath: string, paths: Record<string, string | {
+    __remove: boolean;
+}>): ts.TransformerFactory<ts.SourceFile>;

package/lib/compiler/typescript/transformers/replace_import.transformer.js

@@ -0,0 +1,102 @@
+"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.makeReplaceImportTransformer = makeReplaceImportTransformer;
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+const log_1 = require("../../../engine/util/log");
+function makeReplaceImportTransformer(spacePath, buildPath, paths) {
+    // @ts-expect-error This is according to documentation, but the type is broken for some reason
+    const transformer = (context) => {
+        // For some reason the .getSourceFile() sometimes fail, returning undefined
+        let fileName;
+        const visit = (node) => {
+            if (node.kind === ts.SyntaxKind.SourceFile) {
+                fileName = node.fileName;
+            }
+            if (ts.isImportDeclaration(node)) {
+                fileName = fileName || node.getSourceFile().fileName;
+                const importPath = node.moduleSpecifier.text;
+                const isRelative = importPath.startsWith('./') || importPath.startsWith('../');
+                const isAbsolute = importPath.startsWith('/');
+                let targetPath;
+                // Relative import, search as the absolute path
+                if (isRelative) {
+                    targetPath = path.resolve(path.dirname(fileName), importPath + '.ts');
+                }
+                // Not a relative import, search as it is
+                else {
+                    targetPath = importPath;
+                }
+                let resolvedTargetPath;
+                for (const p in paths) {
+                    const pt = paths[p];
+                    if (targetPath.startsWith(p)) {
+                        if (typeof pt === 'string') {
+                            resolvedTargetPath = targetPath.replace(p, pt);
+                        }
+                        else if (pt.__remove) {
+                            resolvedTargetPath = { __remove: true };
+                        }
+                        break;
+                    }
+                }
+                if (!resolvedTargetPath) {
+                    if (!isRelative && !isAbsolute) {
+                        return node;
+                    }
+                    resolvedTargetPath = targetPath.replace(spacePath, buildPath);
+                }
+                if (typeof resolvedTargetPath !== 'string') {
+                    const importName = node.importClause?.name?.escapedText;
+                    log_1.Log.debug('compiler', 'trf.replace_import', `Removing import '${importName}' and replacing with a {}`);
+                    return ts.factory.createBlock([]);
+                }
+                resolvedTargetPath = resolvedTargetPath.replace(/\.ts$/, '');
+                const sourcePath = fileName;
+                const resolvedSourcePath = paths[sourcePath];
+                const sourceBuildPath = (resolvedSourcePath && typeof resolvedSourcePath === 'string')
+                    ? path.dirname(resolvedSourcePath)
+                    : path.dirname(sourcePath).replace(spacePath, buildPath);
+                const literal = './' + path.relative(sourceBuildPath, resolvedTargetPath);
+                log_1.Log.debug('compiler', 'trf.replace_import', `Transforming '${importPath}' into './${literal}'`);
+                return ts.factory.updateImportDeclaration(node, node.modifiers, node.importClause, ts.factory.createStringLiteral(literal, true), node.attributes);
+            }
+            return ts.visitEachChild(node, (child) => visit(child), context);
+        };
+        return (node) => ts.visitNode(node, visit);
+    };
+    return transformer;
+}

package/lib/compiler/typescript/typescript_compiler.d.ts

@@ -0,0 +1,63 @@
+import * as ts from 'typescript';
+import { AnySpace } from "../../engine/space";
+import { BuilderType } from "../../schema";
+export type tsQueryResult<T = ts.Node> = {
+    path: string;
+    node: T;
+};
+export type tsFnQueryResult = tsQueryResult<ts.FunctionExpression | ts.ArrowFunction>;
+export type tsBuilderFunction = {
+    type: string;
+    node: string;
+    owner?: string;
+    path?: string;
+    fn: ts.ArrowFunction | ts.FunctionExpression;
+};
+export declare class TypeScriptCompiler {
+    space: AnySpace;
+    nesoiPath: string;
+    private files;
+    program: ts.Program;
+    checker: ts.TypeChecker;
+    constructor(space: AnySpace, nesoiPath?: string);
+    createProgram(): void;
+    check(filepath: string): void;
+    /**
+     * Extract all import nodes
+     */
+    extractImports(filepath: string, $?: {
+        ignore?: string[];
+    }): string[];
+    query(filepath: string, $: {
+        query: string;
+        expectedKinds: ts.SyntaxKind[];
+    }): tsQueryResult<ts.Node>[];
+    private runQuery;
+    getReturnNode(node: ts.FunctionExpression | ts.ArrowFunction): ts.Expression | undefined;
+    getReturnType(node: ts.FunctionExpression | ts.ArrowFunction): string;
+    getFnText(node: ts.FunctionExpression | ts.ArrowFunction): string;
+    getFnType(node: ts.FunctionExpression | ts.ArrowFunction): string;
+    getCallName(node: ts.Node): ts.__String | undefined;
+    isCall(node: ts.Node, from: ts.Symbol, method?: string): boolean;
+    private getSource;
+    getNesoiSymbol(name: string, path: string): ts.Symbol;
+    getPropPath(node: ts.PropertyAssignment): string;
+    findAllNesoiBuilders(node: ts.Node): Partial<Record<BuilderType, Record<string, ts.Node>>>;
+    findAll(node: ts.Node, predicate: (node: ts.Node) => ts.Node | undefined): ts.Node[];
+    private findParent;
+    private findInCallChain;
+    private findCallsUntilRoot;
+    private findCallsUntilLast;
+    private static logDiagnostics;
+    static allFiles(dirPaths: string[]): string[];
+    /**
+     *
+     */
+    static compileFile(fileName: string, options?: ts.CompilerOptions): string;
+    /**
+     * !The first file is currently expected to be the app file
+     */
+    static compileApp(modules: string[], fileNames: string[], options: ts.CompilerOptions, spacePath: string, buildPath: string, paths?: Record<string, string | {
+        __remove: boolean;
+    }>): number;
+}