@eventra_dev/eventra-cli 1.0.6 → 2.0.1

package/README.md

@@ -80,6 +80,20 @@ function trackFeature(name: string) {
 trackFeature("purchase");
 ```
 
+The event name can also come from a property on the wrapper's parameter — plain access, optional chaining, element access, or destructuring (including aliased and nested):
+
+```ts
+function trackWrapper(payload: { event: string }) {
+  sdk.track(payload.event);        // also: payload?.event, payload["event"]
+}
+trackWrapper({ event: "checkout" });
+
+function trackDestructured({ event: name }: { event: string }) {
+  sdk.track(name);
+}
+trackDestructured({ event: "checkout" });
+```
+
 ### Variables, templates, conditionals
 
 ```ts

package/dist/analysis/extractor/propagationExtractor.js

@@ -62,26 +62,40 @@ function extractPropagationEvents(call, checker, wrapperRegistry, resolvedCallCa
     }
 }
 function extractPropagation(propagation, call, checker, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache, events, dynamicOccurrences) {
-    let argument = call.arguments[propagation.sourceParameterIndex];
+    const argument = call.arguments[propagation.sourceParameterIndex];
     if (!argument) {
         return;
     }
-    // wrapper({
-    //   nested: {
-    //     event: "x"
-    //   }
-    // })
-    if (propagation.propertyPath.length > 0) {
+    const context = (0, evaluationContext_1.createEvaluationContext)();
+    if (typescript_1.default.isIdentifier(propagation.sourceParameter.name)) {
+        // sourceParameter is a plain identifier (`function f(payload)`), so
+        // propagation.targetNode — `payload`, `payload.event`, or any expression
+        // a plugin builds from it (e.g. a template literal) — can resolve its own
+        // propertyPath by evaluating targetNode with `payload` substituted for
+        // the *raw*, un-narrowed call-site argument.
+        const parameterSymbol = checker.getSymbolAtLocation(propagation.sourceParameter.name);
+        if (parameterSymbol) {
+            context.parameterBindings.set(parameterSymbol, argument);
+        }
+    }
+    else {
+        // sourceParameter is a destructuring pattern (`function f({ event })`),
+        // which has no symbol of its own — `getSymbolAtLocation` on the pattern
+        // returns nothing. Narrow to the leaf value ourselves via propertyPath,
+        // then bind it to the destructured binding's own symbol (targetNode is
+        // that binding's reference, e.g. `event` in `sdk.track(event)`).
+        if (propagation.propertyPath.length === 0 || !typescript_1.default.isIdentifier(propagation.targetNode)) {
+            return;
+        }
         const resolvedPath = resolveObjectPath(argument, propagation.propertyPath);
         if (!resolvedPath) {
             return;
         }
-        argument = resolvedPath;
-    }
-    const context = (0, evaluationContext_1.createEvaluationContext)();
-    const parameterSymbol = checker.getSymbolAtLocation(propagation.sourceParameter.name);
-    if (parameterSymbol) {
-        context.parameterBindings.set(parameterSymbol, argument);
+        const bindingSymbol = checker.getSymbolAtLocation(propagation.targetNode);
+        if (!bindingSymbol) {
+            return;
+        }
+        context.parameterBindings.set(bindingSymbol, resolvedPath);
     }
     const resolved = (0, resolver_1.resolveNodeValue)(propagation.targetNode, checker, context, new Set(), evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
     for (const value of resolved.values) {

package/dist/analysis/resolver/resolver.js

@@ -9,6 +9,7 @@ const exportResolver_1 = require("./exportResolver");
 const returnPropagationAnalyzer_1 = require("../scanner/analyzer/returnPropagationAnalyzer");
 const callResolver_1 = require("./callResolver");
 const resolvedCallCache_1 = require("../cache/resolvedCallCache");
+const utils_1 = require("../shared/utils");
 function unique(values) {
     return [
         ...new Set(values),
@@ -29,42 +30,69 @@ function concat(left, right) {
     }
     return unique(result);
 }
-function getPropertyName(node) {
-    if (typescript_1.default.isElementAccessExpression(node)) {
-        if (!node.argumentExpression || !typescript_1.default.isStringLiteral(node.argumentExpression)) {
+// Walks a chain rooted at a parameter-bound identifier — e.g. `payload.nested`
+// inside `payload.nested.event` — down to the object literal it refers to, so
+// resolvePropertyAccess can pick the final property off a nested payload, not
+// just a one-level-deep one.
+function resolveBoundObjectNode(rawNode, checker, context) {
+    const node = (0, utils_1.unwrapExpression)(rawNode);
+    if (typescript_1.default.isIdentifier(node)) {
+        const symbol = checker.getSymbolAtLocation(node);
+        if (!symbol || !context.parameterBindings.has(symbol)) {
             return null;
         }
-        return node.argumentExpression.text;
+        return context.parameterBindings.get(symbol) ?? null;
     }
-    return node.name.text;
+    if (typescript_1.default.isPropertyAccessExpression(node) || typescript_1.default.isPropertyAccessChain(node) || typescript_1.default.isElementAccessExpression(node)) {
+        const propertyName = (0, utils_1.getPropertyName)(node);
+        if (!propertyName) {
+            return null;
+        }
+        const base = resolveBoundObjectNode(node.expression, checker, context);
+        if (!base || !typescript_1.default.isObjectLiteralExpression(base)) {
+            return null;
+        }
+        for (const property of base.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;
+            }
+            return typescript_1.default.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
+        }
+        return null;
+    }
+    return null;
 }
 function resolvePropertyAccess(node, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache) {
-    const propertyName = getPropertyName(node);
+    const propertyName = (0, utils_1.getPropertyName)(node);
     if (!propertyName) {
         return empty();
     }
     // payload.event
     // payload["event"]
+    // payload.nested.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 bound = resolveBoundObjectNode(targetExpression, checker, context);
+        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);
             }
         }
+    }
+    if (typescript_1.default.isIdentifier(targetExpression)) {
+        const symbol = checker.getSymbolAtLocation(targetExpression);
         // const EVENTS = {
         //   LOGIN: "login"
         // }
@@ -221,10 +249,11 @@ function resolveNodeValue(node, checker, context, visited, evaluationCache, reso
                 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)) {
+        if (typescript_1.default.isParenthesizedExpression(node) ||
+            typescript_1.default.isAsExpression(node) ||
+            typescript_1.default.isTypeAssertionExpression(node) ||
+            typescript_1.default.isNonNullExpression(node) ||
+            typescript_1.default.isSatisfiesExpression(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)) {

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

@@ -6,12 +6,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeWrapperPropagation = analyzeWrapperPropagation;
 const typescript_1 = __importDefault(require("typescript"));
 const symbolUtils_1 = require("../../symbols/symbolUtils");
+const utils_1 = require("../../shared/utils");
+function isPropertyAccessLike(node) {
+    return typescript_1.default.isPropertyAccessExpression(node) || typescript_1.default.isPropertyAccessChain(node) || typescript_1.default.isElementAccessExpression(node);
+}
 function extractPropertyPath(expression) {
     const result = [];
-    let current = expression;
-    while (typescript_1.default.isPropertyAccessExpression(current) || typescript_1.default.isPropertyAccessChain(current)) {
-        result.unshift(current.name.text);
-        current = current.expression;
+    let current = (0, utils_1.unwrapExpression)(expression);
+    while (isPropertyAccessLike(current)) {
+        const propertyName = (0, utils_1.getPropertyName)(current);
+        if (!propertyName) {
+            return null;
+        }
+        result.unshift(propertyName);
+        current = (0, utils_1.unwrapExpression)(current.expression);
     }
     if (!typescript_1.default.isIdentifier(current)) {
         return null;
@@ -77,15 +85,18 @@ function collectPropagations(fn, sinks) {
     const result = [];
     for (const sink of sinks) {
         for (const tracked of sink.trackedArguments) {
-            const argument = sink.call.arguments[tracked.index];
-            if (!argument) {
+            const rawArgument = sink.call.arguments[tracked.index];
+            if (!rawArgument) {
                 continue;
             }
+            const argument = (0, utils_1.unwrapExpression)(rawArgument);
             // direct parameter
             // track(name)
             // track(props.event)
             // track(props?.event)
-            if (typescript_1.default.isIdentifier(argument) || typescript_1.default.isPropertyAccessExpression(argument) || typescript_1.default.isPropertyAccessChain(argument)) {
+            // track(props?.event as string)
+            // track(props["event"])
+            if (typescript_1.default.isIdentifier(argument) || isPropertyAccessLike(argument)) {
                 let identifier = null;
                 let propertyPath = [];
                 if (typescript_1.default.isIdentifier(argument)) {
@@ -94,8 +105,8 @@ function collectPropagations(fn, sinks) {
                 else {
                     propertyPath = extractPropertyPath(argument) ?? [];
                     let root = argument;
-                    while (typescript_1.default.isPropertyAccessExpression(root) || typescript_1.default.isPropertyAccessChain(root)) {
-                        root = root.expression;
+                    while (isPropertyAccessLike(root)) {
+                        root = (0, utils_1.unwrapExpression)(root.expression);
                     }
                     if (typescript_1.default.isIdentifier(root)) {
                         identifier = root;

package/dist/analysis/sdk/isEventraTrackCall.js

@@ -18,20 +18,6 @@ function isTrackCallee(expr) {
     }
     return false;
 }
-function fileImportsEventraSdk(sourceFile) {
-    for (const stmt of sourceFile.statements) {
-        if (!typescript_1.default.isImportDeclaration(stmt) || !stmt.moduleSpecifier) {
-            continue;
-        }
-        if (!typescript_1.default.isStringLiteral(stmt.moduleSpecifier)) {
-            continue;
-        }
-        if ((0, eventraSdk_1.isEventraSdkModuleSpecifier)(stmt.moduleSpecifier.text)) {
-            return true;
-        }
-    }
-    return false;
-}
 function getImportDeclarationForSpecifier(decl) {
     let current = decl;
     while (current) {
@@ -155,10 +141,6 @@ function isEventraSdkTrackCall(call, checker) {
     if (!isTrackCallee(expr)) {
         return false;
     }
-    const sourceFile = call.getSourceFile();
-    if (!fileImportsEventraSdk(sourceFile)) {
-        return false;
-    }
     const receiver = typescript_1.default.isPropertyAccessExpression(expr) ||
         typescript_1.default.isPropertyAccessChain(expr) ||
         typescript_1.default.isElementAccessExpression(expr)

package/dist/analysis/shared/utils.js

@@ -4,9 +4,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapExpression = unwrapExpression;
+exports.getPropertyName = getPropertyName;
 exports.getCallName = getCallName;
 exports.getFunctionName = getFunctionName;
 const typescript_1 = __importDefault(require("typescript"));
+// track(payload?.event as string)
+// track((payload.event))
+// track(payload!.event)
+function unwrapExpression(expression) {
+    let current = expression;
+    while (typescript_1.default.isAsExpression(current) ||
+        typescript_1.default.isTypeAssertionExpression(current) ||
+        typescript_1.default.isNonNullExpression(current) ||
+        typescript_1.default.isParenthesizedExpression(current) ||
+        typescript_1.default.isSatisfiesExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+}
+// payload.event -> "event"
+// payload["event"] -> "event"
+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 getCallName(expression) {
     //
     // track()

package/dist/cli/send.js

@@ -62,6 +62,7 @@ async function send(opts = {}) {
     const config = await (0, config_1.loadConfig)();
     if (!config) {
         console.log(chalk_1.default.red("eventra.json not found. Run 'eventra init'"));
+        process.exitCode = 1;
         return;
     }
     const endpoint = config.endpoint || process.env.EVENTRA_ENDPOINT || undefined;
@@ -79,6 +80,7 @@ async function send(opts = {}) {
                 console.log(chalk_1.default.red(`Endpoint "${endpoint}" from eventra.json is not locally approved.`));
                 console.log(chalk_1.default.gray("If this is expected (e.g. a self-hosted ingest URL), approve it once with:"));
                 console.log(chalk_1.default.gray("  eventra send --trust-endpoint"));
+                process.exitCode = 1;
                 return;
             }
             await (0, config_1.trustEndpoint)(endpoint);
@@ -90,6 +92,7 @@ async function send(opts = {}) {
     if (!apiKey) {
         if (!process.stdin.isTTY) {
             console.log(chalk_1.default.red("API key required. Set the EVENTRA_API_KEY environment variable (recommended for CI) or run 'eventra init'."));
+            process.exitCode = 1;
             return;
         }
         const answers = await inquirer_1.default.prompt([
@@ -110,14 +113,17 @@ async function send(opts = {}) {
     // no events
     if (!config.events?.length) {
         console.log(chalk_1.default.yellow("No events found. Run 'eventra sync'"));
+        process.exitCode = 1;
         return;
     }
     if (!apiKey) {
         console.log(chalk_1.default.red("API key required"));
+        process.exitCode = 1;
         return;
     }
     if (!endpoint) {
         console.log(chalk_1.default.red("Endpoint not configured"));
+        process.exitCode = 1;
         return;
     }
     console.log("");
@@ -145,6 +151,7 @@ async function send(opts = {}) {
                 console.log(chalk_1.default.red(`Request failed (${outcome.status})`));
                 if (outcome.body)
                     console.log(chalk_1.default.gray(outcome.body));
+                process.exitCode = 1;
                 return;
             }
             lastFailure = { status: outcome.status, body: outcome.body };
@@ -173,6 +180,7 @@ async function send(opts = {}) {
         else if (lastFailure?.error instanceof Error) {
             console.log(chalk_1.default.gray(lastFailure.error.message));
         }
+        process.exitCode = 1;
         return;
     }
     console.log(chalk_1.default.green("Events registered successfully"));

package/dist/cli/watch.js

@@ -35,6 +35,14 @@ async function watch() {
     const normalize = (file) => {
         return path_1.default.resolve(file).replace(/\\/g, "/");
     };
+    // chokidar's `ignored` receives absolute, normalized paths — reject any path
+    // with an excluded directory name as one of its segments (matches how
+    // `fast-glob`'s own `ignore` option is applied during the initial scan).
+    const excludedDirs = new Set(config.sync.exclude);
+    const isExcludedPath = (file) => {
+        const segments = normalize(file).split("/");
+        return segments.some((segment) => excludedDirs.has(segment));
+    };
     const files = await (0, fast_glob_1.default)(include, {
         ignore: config.sync.exclude,
         absolute: true,
@@ -68,7 +76,15 @@ async function watch() {
     const initialEvents = engine.getAllEvents();
     const initialWrappers = engine.getAllFunctionWrappers();
     console.log(chalk_1.default.gray(`Initial: ${initialEvents.length} events, ${initialWrappers.length} wrappers\n`));
-    const watcher = chokidar_1.default.watch([...sourceFiles, ...watchedDeps], { ignoreInitial: true });
+    // Watch the project root (not just the files found by the initial scan) so
+    // that brand-new files matching `include` are noticed as they're created —
+    // a fixed file list only ever detects edits to files chokidar already knows
+    // about. Dependency files outside the root (added below via `watcher.add`)
+    // are unaffected by this and keep working the same way.
+    const watcher = chokidar_1.default.watch(process.cwd(), {
+        ignoreInitial: true,
+        ignored: isExcludedPath,
+    });
     const queue = new Map();
     let timer = null;
     const run = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "1.0.6",
+  "version": "2.0.1",
   "description": "Static analytics event extraction CLI powered by the TypeScript compiler API",
   "license": "MIT",
   "type": "commonjs",