@eventra_dev/eventra-cli 0.3.1 → 0.3.3

package/dist/analysis/resolver/resolver.js

@@ -1,5 +1,4 @@
 "use strict";
-// src/analysis/resolver/resolver.ts
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,47 +29,111 @@ function concat(left, right) {
     }
     return unique(result);
 }
-function resolveIdentifier(node, checker, context, visited, evaluationCache, exportCache) {
+function getPropertyName(node) {
+    if (typescript_1.default.isElementAccessExpression(node)) {
+        if (!node.argumentExpression || !typescript_1.default.isStringLiteral(node.argumentExpression)) {
+            return null;
+        }
+        return node.argumentExpression.text;
+    }
+    return node.name.text;
+}
+function resolvePropertyAccess(node, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache) {
+    const propertyName = getPropertyName(node);
+    if (!propertyName) {
+        return empty();
+    }
+    // payload.event
+    // payload["event"]
+    const targetExpression = typescript_1.default.isElementAccessExpression(node) ? node.expression : node.expression;
+    if (typescript_1.default.isIdentifier(targetExpression)) {
+        const symbol = checker.getSymbolAtLocation(targetExpression);
+        // parameter binding
+        if (symbol && context.parameterBindings.has(symbol)) {
+            const bound = context.parameterBindings.get(symbol);
+            if (bound && typescript_1.default.isObjectLiteralExpression(bound)) {
+                for (const property of bound.properties) {
+                    if (!typescript_1.default.isPropertyAssignment(property) && !typescript_1.default.isShorthandPropertyAssignment(property)) {
+                        continue;
+                    }
+                    const objectPropertyName = typescript_1.default.isIdentifier(property.name) ? property.name.text : property.name.getText();
+                    if (objectPropertyName !== propertyName) {
+                        continue;
+                    }
+                    const initializer = typescript_1.default.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
+                    return resolveNodeValue(initializer, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
+                }
+            }
+        }
+        // const EVENTS = {
+        //   LOGIN: "login"
+        // }
+        if (symbol) {
+            const declarations = symbol.getDeclarations() ?? [];
+            for (const declaration of declarations) {
+                if (!typescript_1.default.isVariableDeclaration(declaration) || !declaration.initializer || !typescript_1.default.isObjectLiteralExpression(declaration.initializer)) {
+                    continue;
+                }
+                for (const property of declaration.initializer.properties) {
+                    if (!typescript_1.default.isPropertyAssignment(property) && !typescript_1.default.isShorthandPropertyAssignment(property)) {
+                        continue;
+                    }
+                    const objectPropertyName = typescript_1.default.isIdentifier(property.name) ? property.name.text : property.name.getText();
+                    if (objectPropertyName !== propertyName) {
+                        continue;
+                    }
+                    const initializer = typescript_1.default.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
+                    return resolveNodeValue(initializer, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
+                }
+            }
+        }
+    }
+    return empty();
+}
+function resolveIdentifier(node, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache) {
     const boundSymbol = checker.getSymbolAtLocation(node);
-    if (boundSymbol
-        && context.parameterBindings.has(boundSymbol)) {
+    if (boundSymbol && context.parameterBindings.has(boundSymbol)) {
         const bound = context.parameterBindings.get(boundSymbol);
         if (bound) {
-            return resolveNodeValue(bound, checker, context, visited, evaluationCache, undefined, exportCache);
+            return resolveNodeValue(bound, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
         }
     }
     let symbol = checker.getSymbolAtLocation(node);
     if (!symbol) {
         return empty();
     }
-    symbol =
-        (0, exportResolver_1.resolveExportedSymbol)(symbol, checker, exportCache)
-            ?? symbol;
+    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()
-        ?? [];
+    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);
+        if (typescript_1.default.isVariableDeclaration(declaration) && declaration.initializer) {
+            const resolved = resolveNodeValue(declaration.initializer, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
+            evaluationCache.set(symbol, resolved);
+            return resolved;
+        }
+        if (typescript_1.default.isEnumMember(declaration) && declaration.initializer) {
+            const resolved = resolveNodeValue(declaration.initializer, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, 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);
+function resolveCallExpression(node, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, 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);
+    let semantic = returnPropagationCache.get(resolved);
+    if (semantic === undefined) {
+        semantic = (0, returnPropagationAnalyzer_1.analyzeReturnPropagation)(resolved);
+        returnPropagationCache.set(resolved, semantic);
+    }
     if (!semantic) {
         return empty();
     }
@@ -87,7 +150,7 @@ function resolveCallExpression(node, checker, context, visited, evaluationCache,
         if (parameterSymbol) {
             nextContext.parameterBindings.set(parameterSymbol, argument);
         }
-        const resolvedValue = resolveNodeValue(propagation.returnExpression, checker, nextContext, new Set(visited), evaluationCache, resolvedCallCache, exportCache);
+        const resolvedValue = resolveNodeValue(propagation.returnExpression, checker, nextContext, new Set(visited), evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
         values.push(...resolvedValue.values);
     }
     return {
@@ -95,7 +158,7 @@ function resolveCallExpression(node, checker, context, visited, evaluationCache,
         dynamic: true,
     };
 }
-function resolveNodeValue(node, checker, context, visited, evaluationCache, resolvedCallCache, exportCache) {
+function resolveNodeValue(node, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache) {
     if (visited.has(node)) {
         return empty();
     }
@@ -103,27 +166,83 @@ function resolveNodeValue(node, checker, context, visited, evaluationCache, reso
     try {
         if (typescript_1.default.isStringLiteral(node)) {
             return {
-                values: [
-                    node.text,
-                ],
+                values: [node.text],
                 dynamic: false,
             };
         }
+        if (typescript_1.default.isNoSubstitutionTemplateLiteral(node)) {
+            return {
+                values: [node.text],
+                dynamic: false,
+            };
+        }
+        if (typescript_1.default.isTemplateExpression(node)) {
+            let values = [node.head.text];
+            for (const span of node.templateSpans) {
+                const resolved = resolveNodeValue(span.expression, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
+                values = concat(values, resolved.values.map(value => value + span.literal.text));
+            }
+            return {
+                values: unique(values),
+                dynamic: true,
+            };
+        }
+        if (typescript_1.default.isConditionalExpression(node)) {
+            const whenTrue = resolveNodeValue(node.whenTrue, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
+            const whenFalse = resolveNodeValue(node.whenFalse, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
+            return {
+                values: unique([...whenTrue.values, ...whenFalse.values]),
+                dynamic: true,
+            };
+        }
+        if (typescript_1.default.isArrayLiteralExpression(node)) {
+            const values = [];
+            for (const element of node.elements) {
+                const resolved = resolveNodeValue(element, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
+                values.push(...resolved.values);
+            }
+            return {
+                values: unique(values),
+                dynamic: true,
+            };
+        }
+        if (typescript_1.default.isObjectLiteralExpression(node)) {
+            const values = [];
+            for (const property of node.properties) {
+                if (!typescript_1.default.isPropertyAssignment(property) && !typescript_1.default.isShorthandPropertyAssignment(property)) {
+                    continue;
+                }
+                const initializer = typescript_1.default.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
+                const resolved = resolveNodeValue(initializer, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
+                values.push(...resolved.values);
+            }
+            return {
+                values: unique(values),
+                dynamic: true,
+            };
+        }
+        if (typescript_1.default.isParenthesizedExpression(node)) {
+            return resolveNodeValue(node.expression, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
+        }
+        if (typescript_1.default.isAsExpression(node) || typescript_1.default.isTypeAssertionExpression(node)) {
+            return resolveNodeValue(node.expression, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
+        }
+        if (typescript_1.default.isPropertyAccessExpression(node) || typescript_1.default.isPropertyAccessChain(node) || typescript_1.default.isElementAccessExpression(node)) {
+            return resolvePropertyAccess(node, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
+        }
         if (typescript_1.default.isIdentifier(node)) {
-            return resolveIdentifier(node, checker, context, visited, evaluationCache, exportCache);
+            return resolveIdentifier(node, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, 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);
+        if (typescript_1.default.isBinaryExpression(node) && node.operatorToken.kind === typescript_1.default.SyntaxKind.PlusToken) {
+            const left = resolveNodeValue(node.left, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
+            const right = resolveNodeValue(node.right, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, 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 resolveCallExpression(node, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
         }
         return empty();
     }

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

@@ -1,5 +1,4 @@
 "use strict";
-// src/analysis/scanner/propagationAnalyzer.ts
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -10,10 +9,9 @@ const symbolUtils_1 = require("../../symbols/symbolUtils");
 function extractPropertyPath(expression) {
     const result = [];
     let current = expression;
-    while (typescript_1.default.isPropertyAccessExpression(current)) {
+    while (typescript_1.default.isPropertyAccessExpression(current) || typescript_1.default.isPropertyAccessChain(current)) {
         result.unshift(current.name.text);
-        current =
-            current.expression;
+        current = current.expression;
     }
     if (!typescript_1.default.isIdentifier(current)) {
         return null;
@@ -22,12 +20,7 @@ function extractPropertyPath(expression) {
 }
 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;
+        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;
         }
@@ -35,23 +28,18 @@ function resolveObjectBinding(parameter, pattern, identifier, parentPath) {
             ...parentPath,
             propertyName,
         ];
-        //
         // alias:
         // { event: name }
-        //
         if (typescript_1.default.isIdentifier(element.name)) {
-            if (element.name.text
-                === identifier.text) {
+            if (element.name.text === identifier.text) {
                 return {
                     parameter,
                     propertyPath: nextPath,
                 };
             }
         }
-        //
         // nested:
-        // { meta: { event } }
-        //
+        // { meta: { event }
         if (typescript_1.default.isObjectBindingPattern(element.name)) {
             const nested = resolveObjectBinding(parameter, element.name, identifier, nextPath);
             if (nested) {
@@ -63,14 +51,10 @@ function resolveObjectBinding(parameter, pattern, identifier, parentPath) {
 }
 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) {
+            if (parameter.name.text === identifier.text) {
                 return {
                     parameter,
                     propertyPath: [],
@@ -78,11 +62,8 @@ function resolveParameter(fn, identifier) {
             }
             continue;
         }
-        //
         // destructuring
-        //
         // function x({ event })
-        //
         if (typescript_1.default.isObjectBindingPattern(parameter.name)) {
             const resolved = resolveObjectBinding(parameter, parameter.name, identifier, []);
             if (resolved) {
@@ -92,7 +73,7 @@ function resolveParameter(fn, identifier) {
     }
     return null;
 }
-function collectPropagations(fn, checker, sinks) {
+function collectPropagations(fn, sinks) {
     const result = [];
     for (const sink of sinks) {
         for (const tracked of sink.trackedArguments) {
@@ -100,32 +81,24 @@ function collectPropagations(fn, checker, sinks) {
             if (!argument) {
                 continue;
             }
-            //
             // direct parameter
-            //
             // track(name)
             // track(props.event)
-            //
-            if (typescript_1.default.isIdentifier(argument)
-                || typescript_1.default.isPropertyAccessExpression(argument)) {
+            // track(props?.event)
+            if (typescript_1.default.isIdentifier(argument) || typescript_1.default.isPropertyAccessExpression(argument) || typescript_1.default.isPropertyAccessChain(argument)) {
                 let identifier = null;
                 let propertyPath = [];
                 if (typescript_1.default.isIdentifier(argument)) {
-                    identifier =
-                        argument;
+                    identifier = argument;
                 }
                 else {
-                    propertyPath =
-                        extractPropertyPath(argument)
-                            ?? [];
+                    propertyPath = extractPropertyPath(argument) ?? [];
                     let root = argument;
-                    while (typescript_1.default.isPropertyAccessExpression(root)) {
-                        root =
-                            root.expression;
+                    while (typescript_1.default.isPropertyAccessExpression(root) || typescript_1.default.isPropertyAccessChain(root)) {
+                        root = root.expression;
                     }
                     if (typescript_1.default.isIdentifier(root)) {
-                        identifier =
-                            root;
+                        identifier = root;
                     }
                 }
                 if (!identifier) {
@@ -146,17 +119,15 @@ function collectPropagations(fn, checker, sinks) {
                 });
                 continue;
             }
-            //
             // object literal
-            //
             // track({ event: name })
-            //
+            // track({ event })
             if (typescript_1.default.isObjectLiteralExpression(argument)) {
                 for (const property of argument.properties) {
-                    if (!typescript_1.default.isPropertyAssignment(property)) {
+                    if (!typescript_1.default.isPropertyAssignment(property) && !typescript_1.default.isShorthandPropertyAssignment(property)) {
                         continue;
                     }
-                    const initializer = property.initializer;
+                    const initializer = typescript_1.default.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
                     if (!typescript_1.default.isIdentifier(initializer)) {
                         continue;
                     }
@@ -176,12 +147,12 @@ function collectPropagations(fn, checker, sinks) {
     }
     return result;
 }
-function analyzeWrapperPropagation(fn, checker, sinks, wrapperRegistry, resolvedCallCache, exportCache) {
+function analyzeWrapperPropagation(fn, checker, sinks) {
     const symbol = (0, symbolUtils_1.getFunctionSymbol)(fn, checker);
     if (!symbol) {
         return null;
     }
-    const propagations = collectPropagations(fn, checker, sinks);
+    const propagations = collectPropagations(fn, sinks);
     if (propagations.length === 0) {
         return null;
     }

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

@@ -1,5 +1,4 @@
 "use strict";
-// src/analysis/scanner/returnPropagationAnalyzer.ts
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -11,8 +10,7 @@ function resolveParameter(fn, identifier) {
         if (!typescript_1.default.isIdentifier(parameter.name)) {
             continue;
         }
-        if (parameter.name.text
-            === identifier.text) {
+        if (parameter.name.text === identifier.text) {
             return parameter;
         }
     }
@@ -21,20 +19,15 @@ function resolveParameter(fn, identifier) {
 function analyzeReturnPropagation(fn) {
     const propagations = [];
     function visit(node) {
-        //
         // return value
-        //
-        if (typescript_1.default.isReturnStatement(node)
-            && node.expression) {
+        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) {
@@ -47,10 +40,8 @@ function analyzeReturnPropagation(fn) {
             });
             return;
         }
-        //
         // object return
         // return { event }
-        //
         if (typescript_1.default.isObjectLiteralExpression(expression)) {
             for (const property of expression.properties) {
                 if (!typescript_1.default.isPropertyAssignment(property)) {
@@ -72,9 +63,7 @@ function analyzeReturnPropagation(fn) {
             }
             return;
         }
-        //
         // template returns
-        //
         if (typescript_1.default.isTemplateExpression(expression)) {
             for (const span of expression.templateSpans) {
                 if (!typescript_1.default.isIdentifier(span.expression)) {

package/dist/analysis/scanner/scanner.js

@@ -7,67 +7,44 @@ 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) {
+function scanSource(source, checker, 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)) {
+        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)) {
+        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 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 (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)) {
+                        if (property && typescript_1.default.isPropertyAssignment(property)) {
                             return property.initializer;
                         }
                     }
-                    //
                     // track(name)
-                    //
                     return argument;
-                })
-                    .filter((value) => {
+                }).filter((value) => {
                     return Boolean(value);
                 });
                 trackCalls.push({
@@ -80,9 +57,7 @@ function scanSource(source, checker, _config, resolvedCallCache, resolvedExportC
         typescript_1.default.forEachChild(node, visit);
     }
     visit(source);
-    //
-    // generic semantic analysis
-    //
+    // semantic wrapper analysis
     for (const fn of functions) {
         if (!fn.body) {
             continue;
@@ -93,19 +68,16 @@ function scanSource(source, checker, _config, resolvedCallCache, resolvedExportC
                 if (current === fn) {
                     return true;
                 }
-                current =
-                    current.parent;
+                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);
+        const wrapper = (0, propagationAnalyzer_1.analyzeWrapperPropagation)(fn, checker, localSinks);
+        if (!wrapper) {
+            continue;
         }
+        wrappers.push(wrapper);
+        wrapperRegistry.set(wrapper);
     }
     return {
         fileName: source.fileName,