@eventra_dev/eventra-cli 0.2.3 → 0.3.1

package/dist/analysis/resolver/exportResolver.js

@@ -0,0 +1,75 @@
+"use strict";
+// src/analysis/resolver/exportResolver.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExportedSymbol = resolveExportedSymbol;
+const typescript_1 = __importDefault(require("typescript"));
+function isConcreteDeclaration(node) {
+    return (typescript_1.default.isFunctionDeclaration(node)
+        || typescript_1.default.isVariableDeclaration(node)
+        || typescript_1.default.isClassDeclaration(node)
+        || typescript_1.default.isEnumDeclaration(node)
+        || typescript_1.default.isInterfaceDeclaration(node)
+        || typescript_1.default.isTypeAliasDeclaration(node)
+        || typescript_1.default.isMethodDeclaration(node)
+        || typescript_1.default.isPropertyDeclaration(node));
+}
+function resolveExportedSymbol(symbol, checker, cache, visited) {
+    const seen = visited
+        ?? new Set();
+    const cached = cache.get(symbol);
+    if (cached !== undefined) {
+        return cached;
+    }
+    //
+    // cycle guard
+    //
+    if (seen.has(symbol)) {
+        cache.set(symbol, null);
+        return null;
+    }
+    seen.add(symbol);
+    //
+    // alias unwrap
+    //
+    if (symbol.flags
+        & typescript_1.default.SymbolFlags.Alias) {
+        const aliased = checker.getAliasedSymbol(symbol);
+        const resolved = resolveExportedSymbol(aliased, checker, cache, seen);
+        cache.set(symbol, resolved);
+        return resolved;
+    }
+    //
+    // export unwrap
+    //
+    const exportSymbol = checker.getExportSymbolOfSymbol(symbol);
+    if (exportSymbol
+        && exportSymbol !== symbol) {
+        const resolved = resolveExportedSymbol(exportSymbol, checker, cache, seen);
+        cache.set(symbol, resolved);
+        return resolved;
+    }
+    //
+    // declaration existence
+    //
+    const declarations = symbol.getDeclarations()
+        ?? [];
+    for (const declaration of declarations) {
+        if (isConcreteDeclaration(declaration)) {
+            cache.set(symbol, symbol);
+            return symbol;
+        }
+    }
+    //
+    // final validation
+    //
+    const valid = declarations.some(isConcreteDeclaration);
+    if (valid) {
+        cache.set(symbol, symbol);
+        return symbol;
+    }
+    cache.set(symbol, null);
+    return null;
+}

package/dist/analysis/resolver/resolver.js

@@ -0,0 +1,133 @@
+"use strict";
+// src/analysis/resolver/resolver.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNodeValue = resolveNodeValue;
+const typescript_1 = __importDefault(require("typescript"));
+const exportResolver_1 = require("./exportResolver");
+const returnPropagationAnalyzer_1 = require("../scanner/analyzer/returnPropagationAnalyzer");
+const callResolver_1 = require("./callResolver");
+const resolvedCallCache_1 = require("../cache/resolvedCallCache");
+function unique(values) {
+    return [
+        ...new Set(values),
+    ];
+}
+function empty() {
+    return {
+        values: [],
+        dynamic: true,
+    };
+}
+function concat(left, right) {
+    const result = [];
+    for (const l of left) {
+        for (const r of right) {
+            result.push(l + r);
+        }
+    }
+    return unique(result);
+}
+function resolveIdentifier(node, checker, context, visited, evaluationCache, exportCache) {
+    const boundSymbol = checker.getSymbolAtLocation(node);
+    if (boundSymbol
+        && context.parameterBindings.has(boundSymbol)) {
+        const bound = context.parameterBindings.get(boundSymbol);
+        if (bound) {
+            return resolveNodeValue(bound, checker, context, visited, evaluationCache, undefined, exportCache);
+        }
+    }
+    let symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) {
+        return empty();
+    }
+    symbol =
+        (0, exportResolver_1.resolveExportedSymbol)(symbol, checker, exportCache)
+            ?? symbol;
+    const cached = evaluationCache.get(symbol);
+    if (cached) {
+        return cached;
+    }
+    const resolving = empty();
+    evaluationCache.set(symbol, resolving);
+    const declarations = symbol.getDeclarations()
+        ?? [];
+    for (const declaration of declarations) {
+        if (typescript_1.default.isVariableDeclaration(declaration)
+            && declaration.initializer) {
+            const resolved = resolveNodeValue(declaration.initializer, checker, context, visited, evaluationCache, undefined, exportCache);
+            evaluationCache.set(symbol, resolved);
+            return resolved;
+        }
+    }
+    return resolving;
+}
+function resolveCallExpression(node, checker, context, visited, evaluationCache, resolvedCallCache, exportCache) {
+    const resolved = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker, resolvedCallCache
+        ?? new resolvedCallCache_1.ResolvedCallCache(), exportCache);
+    if (!resolved) {
+        return empty();
+    }
+    const semantic = (0, returnPropagationAnalyzer_1.analyzeReturnPropagation)(resolved);
+    if (!semantic) {
+        return empty();
+    }
+    const values = [];
+    for (const propagation of semantic.propagations) {
+        const argument = node.arguments[propagation.parameterIndex];
+        if (!argument) {
+            continue;
+        }
+        const nextContext = {
+            parameterBindings: new Map(context.parameterBindings),
+        };
+        const parameterSymbol = checker.getSymbolAtLocation(propagation.parameter.name);
+        if (parameterSymbol) {
+            nextContext.parameterBindings.set(parameterSymbol, argument);
+        }
+        const resolvedValue = resolveNodeValue(propagation.returnExpression, checker, nextContext, new Set(visited), evaluationCache, resolvedCallCache, exportCache);
+        values.push(...resolvedValue.values);
+    }
+    return {
+        values: unique(values),
+        dynamic: true,
+    };
+}
+function resolveNodeValue(node, checker, context, visited, evaluationCache, resolvedCallCache, exportCache) {
+    if (visited.has(node)) {
+        return empty();
+    }
+    visited.add(node);
+    try {
+        if (typescript_1.default.isStringLiteral(node)) {
+            return {
+                values: [
+                    node.text,
+                ],
+                dynamic: false,
+            };
+        }
+        if (typescript_1.default.isIdentifier(node)) {
+            return resolveIdentifier(node, checker, context, visited, evaluationCache, exportCache);
+        }
+        if (typescript_1.default.isBinaryExpression(node)
+            && node.operatorToken.kind
+                === typescript_1.default.SyntaxKind.PlusToken) {
+            const left = resolveNodeValue(node.left, checker, context, visited, evaluationCache, resolvedCallCache, exportCache);
+            const right = resolveNodeValue(node.right, checker, context, visited, evaluationCache, resolvedCallCache, exportCache);
+            return {
+                values: concat(left.values, right.values),
+                dynamic: true,
+            };
+        }
+        if (typescript_1.default.isCallExpression(node)) {
+            return resolveCallExpression(node, checker, context, visited, evaluationCache, resolvedCallCache, exportCache);
+        }
+        return empty();
+    }
+    finally {
+        visited.delete(node);
+    }
+}

package/dist/analysis/scanner/analyzer/propagationAnalyzer.js

@@ -0,0 +1,193 @@
+"use strict";
+// src/analysis/scanner/propagationAnalyzer.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeWrapperPropagation = analyzeWrapperPropagation;
+const typescript_1 = __importDefault(require("typescript"));
+const symbolUtils_1 = require("../../symbols/symbolUtils");
+function extractPropertyPath(expression) {
+    const result = [];
+    let current = expression;
+    while (typescript_1.default.isPropertyAccessExpression(current)) {
+        result.unshift(current.name.text);
+        current =
+            current.expression;
+    }
+    if (!typescript_1.default.isIdentifier(current)) {
+        return null;
+    }
+    return result;
+}
+function resolveObjectBinding(parameter, pattern, identifier, parentPath) {
+    for (const element of pattern.elements) {
+        const propertyName = element.propertyName
+            && typescript_1.default.isIdentifier(element.propertyName)
+            ? element.propertyName.text
+            : typescript_1.default.isIdentifier(element.name)
+                ? element.name.text
+                : null;
+        if (!propertyName) {
+            continue;
+        }
+        const nextPath = [
+            ...parentPath,
+            propertyName,
+        ];
+        //
+        // alias:
+        // { event: name }
+        //
+        if (typescript_1.default.isIdentifier(element.name)) {
+            if (element.name.text
+                === identifier.text) {
+                return {
+                    parameter,
+                    propertyPath: nextPath,
+                };
+            }
+        }
+        //
+        // nested:
+        // { meta: { event } }
+        //
+        if (typescript_1.default.isObjectBindingPattern(element.name)) {
+            const nested = resolveObjectBinding(parameter, element.name, identifier, nextPath);
+            if (nested) {
+                return nested;
+            }
+        }
+    }
+    return null;
+}
+function resolveParameter(fn, identifier) {
+    for (const parameter of fn.parameters) {
+        //
+        // simple param
+        //
+        // function x(name)
+        //
+        if (typescript_1.default.isIdentifier(parameter.name)) {
+            if (parameter.name.text
+                === identifier.text) {
+                return {
+                    parameter,
+                    propertyPath: [],
+                };
+            }
+            continue;
+        }
+        //
+        // destructuring
+        //
+        // function x({ event })
+        //
+        if (typescript_1.default.isObjectBindingPattern(parameter.name)) {
+            const resolved = resolveObjectBinding(parameter, parameter.name, identifier, []);
+            if (resolved) {
+                return resolved;
+            }
+        }
+    }
+    return null;
+}
+function collectPropagations(fn, checker, sinks) {
+    const result = [];
+    for (const sink of sinks) {
+        for (const tracked of sink.trackedArguments) {
+            const argument = sink.call.arguments[tracked.index];
+            if (!argument) {
+                continue;
+            }
+            //
+            // direct parameter
+            //
+            // track(name)
+            // track(props.event)
+            //
+            if (typescript_1.default.isIdentifier(argument)
+                || typescript_1.default.isPropertyAccessExpression(argument)) {
+                let identifier = null;
+                let propertyPath = [];
+                if (typescript_1.default.isIdentifier(argument)) {
+                    identifier =
+                        argument;
+                }
+                else {
+                    propertyPath =
+                        extractPropertyPath(argument)
+                            ?? [];
+                    let root = argument;
+                    while (typescript_1.default.isPropertyAccessExpression(root)) {
+                        root =
+                            root.expression;
+                    }
+                    if (typescript_1.default.isIdentifier(root)) {
+                        identifier =
+                            root;
+                    }
+                }
+                if (!identifier) {
+                    continue;
+                }
+                const parameter = resolveParameter(fn, identifier);
+                if (!parameter) {
+                    continue;
+                }
+                result.push({
+                    sourceParameter: parameter.parameter,
+                    sourceParameterIndex: fn.parameters.indexOf(parameter.parameter),
+                    propertyPath: [
+                        ...parameter.propertyPath,
+                        ...propertyPath,
+                    ],
+                    targetNode: argument,
+                });
+                continue;
+            }
+            //
+            // object literal
+            //
+            // track({ event: name })
+            //
+            if (typescript_1.default.isObjectLiteralExpression(argument)) {
+                for (const property of argument.properties) {
+                    if (!typescript_1.default.isPropertyAssignment(property)) {
+                        continue;
+                    }
+                    const initializer = property.initializer;
+                    if (!typescript_1.default.isIdentifier(initializer)) {
+                        continue;
+                    }
+                    const parameter = resolveParameter(fn, initializer);
+                    if (!parameter) {
+                        continue;
+                    }
+                    result.push({
+                        sourceParameter: parameter.parameter,
+                        sourceParameterIndex: fn.parameters.indexOf(parameter.parameter),
+                        propertyPath: parameter.propertyPath,
+                        targetNode: initializer,
+                    });
+                }
+            }
+        }
+    }
+    return result;
+}
+function analyzeWrapperPropagation(fn, checker, sinks, wrapperRegistry, resolvedCallCache, exportCache) {
+    const symbol = (0, symbolUtils_1.getFunctionSymbol)(fn, checker);
+    if (!symbol) {
+        return null;
+    }
+    const propagations = collectPropagations(fn, checker, sinks);
+    if (propagations.length === 0) {
+        return null;
+    }
+    return {
+        symbol,
+        declaration: fn,
+        propagations,
+    };
+}

package/dist/analysis/scanner/analyzer/returnPropagationAnalyzer.js

@@ -0,0 +1,105 @@
+"use strict";
+// src/analysis/scanner/returnPropagationAnalyzer.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeReturnPropagation = analyzeReturnPropagation;
+const typescript_1 = __importDefault(require("typescript"));
+function resolveParameter(fn, identifier) {
+    for (const parameter of fn.parameters) {
+        if (!typescript_1.default.isIdentifier(parameter.name)) {
+            continue;
+        }
+        if (parameter.name.text
+            === identifier.text) {
+            return parameter;
+        }
+    }
+    return null;
+}
+function analyzeReturnPropagation(fn) {
+    const propagations = [];
+    function visit(node) {
+        //
+        // return value
+        //
+        if (typescript_1.default.isReturnStatement(node)
+            && node.expression) {
+            collectExpression(node.expression);
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    function collectExpression(expression) {
+        //
+        // direct return
+        // return event
+        //
+        if (typescript_1.default.isIdentifier(expression)) {
+            const parameter = resolveParameter(fn, expression);
+            if (!parameter) {
+                return;
+            }
+            propagations.push({
+                parameter,
+                parameterIndex: fn.parameters.indexOf(parameter),
+                returnExpression: expression,
+            });
+            return;
+        }
+        //
+        // object return
+        // return { event }
+        //
+        if (typescript_1.default.isObjectLiteralExpression(expression)) {
+            for (const property of expression.properties) {
+                if (!typescript_1.default.isPropertyAssignment(property)) {
+                    continue;
+                }
+                const initializer = property.initializer;
+                if (!typescript_1.default.isIdentifier(initializer)) {
+                    continue;
+                }
+                const parameter = resolveParameter(fn, initializer);
+                if (!parameter) {
+                    continue;
+                }
+                propagations.push({
+                    parameter,
+                    parameterIndex: fn.parameters.indexOf(parameter),
+                    returnExpression: initializer,
+                });
+            }
+            return;
+        }
+        //
+        // template returns
+        //
+        if (typescript_1.default.isTemplateExpression(expression)) {
+            for (const span of expression.templateSpans) {
+                if (!typescript_1.default.isIdentifier(span.expression)) {
+                    continue;
+                }
+                const parameter = resolveParameter(fn, span.expression);
+                if (!parameter) {
+                    continue;
+                }
+                propagations.push({
+                    parameter,
+                    parameterIndex: fn.parameters.indexOf(parameter),
+                    returnExpression: expression,
+                });
+            }
+        }
+    }
+    if (fn.body) {
+        visit(fn.body);
+    }
+    if (propagations.length === 0) {
+        return null;
+    }
+    return {
+        declaration: fn,
+        propagations,
+    };
+}

package/dist/analysis/scanner/scanner.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanSource = scanSource;
+const typescript_1 = __importDefault(require("typescript"));
+const sinkDetector_1 = require("./sinkDetector");
+const propagationAnalyzer_1 = require("./analyzer/propagationAnalyzer");
+function scanSource(source, checker, _config, resolvedCallCache, resolvedExportCache, wrapperRegistry) {
+    const sinks = [];
+    const wrappers = [];
+    const trackCalls = [];
+    const functions = [];
+    function visit(node) {
+        //
+        // imports/exports are irrelevant
+        //
+        if (typescript_1.default.isImportDeclaration(node)
+            || typescript_1.default.isExportDeclaration(node)) {
+            return;
+        }
+        //
+        // function collection
+        //
+        if (typescript_1.default.isFunctionDeclaration(node)
+            || typescript_1.default.isArrowFunction(node)
+            || typescript_1.default.isFunctionExpression(node)
+            || typescript_1.default.isMethodDeclaration(node)) {
+            functions.push(node);
+        }
+        //
+        // sink detection
+        //
+        if (typescript_1.default.isCallExpression(node)) {
+            const sink = (0, sinkDetector_1.detectTrackSink)(node);
+            if (sink) {
+                sinks.push(sink);
+                const trackedArguments = sink.trackedArguments
+                    .map(tracked => {
+                    const argument = node.arguments[tracked.index];
+                    if (!argument) {
+                        return undefined;
+                    }
+                    //
+                    // track({
+                    //   event: name
+                    // })
+                    //
+                    if (tracked.propertyPath
+                        .length > 0
+                        && typescript_1.default.isObjectLiteralExpression(argument)) {
+                        const property = argument.properties
+                            .find(prop => {
+                            return (typescript_1.default.isPropertyAssignment(prop)
+                                && prop.name.getText()
+                                    === tracked
+                                        .propertyPath[0]);
+                        });
+                        if (property
+                            && typescript_1.default.isPropertyAssignment(property)) {
+                            return property.initializer;
+                        }
+                    }
+                    //
+                    // track(name)
+                    //
+                    return argument;
+                })
+                    .filter((value) => {
+                    return Boolean(value);
+                });
+                trackCalls.push({
+                    node,
+                    sourceFile: source,
+                    trackedArguments,
+                });
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    visit(source);
+    //
+    // generic semantic analysis
+    //
+    for (const fn of functions) {
+        if (!fn.body) {
+            continue;
+        }
+        const localSinks = sinks.filter(sink => {
+            let current = sink.call;
+            while (current) {
+                if (current === fn) {
+                    return true;
+                }
+                current =
+                    current.parent;
+            }
+            return false;
+        });
+        //
+        // wrapper propagation
+        //
+        const wrapper = (0, propagationAnalyzer_1.analyzeWrapperPropagation)(fn, checker, localSinks, wrapperRegistry, resolvedCallCache, resolvedExportCache);
+        if (wrapper) {
+            wrappers.push(wrapper);
+            wrapperRegistry.set(wrapper, checker, resolvedExportCache);
+        }
+    }
+    return {
+        fileName: source.fileName,
+        sourceFile: source,
+        sinks,
+        trackCalls,
+        wrappers,
+    };
+}