@eventra_dev/eventra-cli 2.2.0 → 2.3.1

package/dist/plugin/builtins/configuredSinks.js

@@ -82,20 +82,6 @@ function moduleMatches(specifier, modules) {
     return modules.some((m) => specifier === m || specifier.startsWith(`${m}/`));
 }
 const MAX_ALIAS_HOPS = 6;
-/** Identifiers naming the types in a type annotation: `PostHog`, `PostHog | null`, `ph.PostHog`. */
-function typeReferenceRoots(type) {
-    if (typescript_1.default.isParenthesizedTypeNode(type))
-        return typeReferenceRoots(type.type);
-    if (typescript_1.default.isUnionTypeNode(type) || typescript_1.default.isIntersectionTypeNode(type))
-        return type.types.flatMap(typeReferenceRoots);
-    if (typescript_1.default.isTypeReferenceNode(type)) {
-        let name = type.typeName;
-        while (typescript_1.default.isQualifiedName(name))
-            name = name.left;
-        return [name];
-    }
-    return [];
-}
 /**
  * The symbol an identifier refers to, keeping an import as the import binding itself. TS resolves an
  * import all the way to its target in some positions once something makes the module resolvable
@@ -109,6 +95,55 @@ function symbolAt(id, checker) {
         return symbol;
     return checker.getSymbolsInScope(id, typescript_1.default.SymbolFlags.Alias).find((alias) => alias.name === id.text) ?? symbol;
 }
+/** `import("m")`: the specifier of the call decides, no installed package needed. */
+function dynamicImportFrom(expression, modules) {
+    const specifier = typescript_1.default.isCallExpression(expression) && expression.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword
+        ? expression.arguments[0]
+        : undefined;
+    return specifier !== undefined && typescript_1.default.isStringLiteralLike(specifier) && moduleMatches(specifier.text, modules);
+}
+const PROMISE_TYPES = new Set(["Promise", "PromiseLike"]);
+/**
+ * True when a type annotation names something from `modules`: `PostHog`, `PostHog | null`, `ph.PostHog`,
+ * `typeof import("posthog-js")`, `Promise<typeof import("posthog-js")>`, `typeof posthog`.
+ */
+function typeFromModules(type, checker, modules, hops) {
+    if (typescript_1.default.isParenthesizedTypeNode(type))
+        return typeFromModules(type.type, checker, modules, hops);
+    if (typescript_1.default.isUnionTypeNode(type) || typescript_1.default.isIntersectionTypeNode(type)) {
+        return type.types.some((member) => typeFromModules(member, checker, modules, hops));
+    }
+    if (typescript_1.default.isImportTypeNode(type)) {
+        return typescript_1.default.isLiteralTypeNode(type.argument) && typescript_1.default.isStringLiteral(type.argument.literal) && moduleMatches(type.argument.literal.text, modules);
+    }
+    const name = typescript_1.default.isTypeReferenceNode(type) ? type.typeName : typescript_1.default.isTypeQueryNode(type) ? type.exprName : undefined;
+    if (name === undefined)
+        return false;
+    let root = name;
+    while (typescript_1.default.isQualifiedName(root))
+        root = root.left;
+    return (symbolFromModules(symbolAt(root, checker), checker, modules, hops + 1) ||
+        // a promise of the module (`Promise<typeof import("posthog-js")>`), not any generic that mentions it
+        (typescript_1.default.isTypeReferenceNode(type) &&
+            typescript_1.default.isIdentifier(type.typeName) &&
+            PROMISE_TYPES.has(type.typeName.text) &&
+            (type.typeArguments ?? []).some((argument) => typeFromModules(argument, checker, modules, hops))));
+}
+/** `return expr` statements of a function body, not looking into functions nested in it. */
+function returnedExpressions(body) {
+    if (!typescript_1.default.isBlock(body))
+        return [body];
+    const found = [];
+    const visit = (node) => {
+        if (typescript_1.default.isFunctionLike(node))
+            return;
+        if (typescript_1.default.isReturnStatement(node) && node.expression)
+            found.push(node.expression);
+        typescript_1.default.forEachChild(node, visit);
+    };
+    typescript_1.default.forEachChild(body, visit);
+    return found;
+}
 /** The symbol `name` exported by the module a specifier points at, when TS can resolve that module. */
 function resolveExport(specifier, name, checker) {
     const moduleSymbol = checker.getSymbolAtLocation(specifier);
@@ -123,6 +158,8 @@ function expressionFromModules(expression, checker, modules, hops) {
     let expr = (0, utils_1.unwrapExpression)(expression);
     if (typescript_1.default.isAwaitExpression(expr))
         expr = (0, utils_1.unwrapExpression)(expr.expression);
+    if (dynamicImportFrom(expr, modules))
+        return true;
     if (typescript_1.default.isCallExpression(expr) || typescript_1.default.isNewExpression(expr))
         expr = (0, utils_1.unwrapExpression)(expr.expression);
     const fromName = (name) => typescript_1.default.isIdentifier(name) && symbolFromModules(symbolAt(name, checker), checker, modules, hops);
@@ -133,7 +170,10 @@ function expressionFromModules(expression, checker, modules, hops) {
     let root = expr;
     while (typescript_1.default.isPropertyAccessExpression(root))
         root = (0, utils_1.unwrapExpression)(root.expression);
-    return fromName(expr.name) || fromName(root);
+    // `(await import("posthog-js")).default`
+    if (typescript_1.default.isAwaitExpression(root))
+        root = (0, utils_1.unwrapExpression)(root.expression);
+    return fromName(expr.name) || fromName(root) || dynamicImportFrom(root, modules);
 }
 function declarationFromModules(decl, checker, modules, hops) {
     if (typescript_1.default.isImportSpecifier(decl) || typescript_1.default.isImportClause(decl) || typescript_1.default.isNamespaceImport(decl)) {
@@ -162,15 +202,42 @@ function declarationFromModules(decl, checker, modules, hops) {
     if (typescript_1.default.isExportAssignment(decl)) {
         return expressionFromModules(decl.expression, checker, modules, hops + 1);
     }
+    // function useAnalytics() { return usePostHog() } / const load = () => import("posthog-js"): a function
+    // gives back what it returns (or what its return annotation names)
+    const fn = typescript_1.default.isFunctionDeclaration(decl) || typescript_1.default.isMethodDeclaration(decl)
+        ? decl
+        : (typescript_1.default.isVariableDeclaration(decl) || typescript_1.default.isPropertyDeclaration(decl)) &&
+            decl.initializer &&
+            (typescript_1.default.isArrowFunction(decl.initializer) || typescript_1.default.isFunctionExpression(decl.initializer))
+            ? decl.initializer
+            : undefined;
+    if (fn) {
+        if (fn.type && typeFromModules(fn.type, checker, modules, hops))
+            return true;
+        if (fn.body && returnedExpressions(fn.body).some((returned) => expressionFromModules(returned, checker, modules, hops + 1))) {
+            return true;
+        }
+    }
     // const { posthog } = usePostHog(): the binding's own declaration is the enclosing variable.
     const owner = typescript_1.default.isBindingElement(decl) ? decl.parent.parent : decl;
+    // promise.then(({ default: posthog }) => ...) / promise.then((mod) => ...): the parameter holds what the promise resolves to
+    if (typescript_1.default.isParameter(owner)) {
+        const callback = owner.parent;
+        const call = callback.parent;
+        if ((typescript_1.default.isArrowFunction(callback) || typescript_1.default.isFunctionExpression(callback)) &&
+            typescript_1.default.isCallExpression(call) &&
+            call.arguments[0] === callback &&
+            typescript_1.default.isPropertyAccessExpression(call.expression) &&
+            call.expression.name.text === "then") {
+            return expressionFromModules(call.expression.expression, checker, modules, hops + 1);
+        }
+    }
     // Variables, properties, parameters, functions (return type) and type aliases all keep their
     // annotation in `type`; variables, properties and parameters keep a default/initial value in
     // `initializer`. Anything else (classes, interfaces, ...) simply has neither.
     const { type, initializer } = owner;
     // let client: PostHog | null / private client: PostHog / (client: PostHog) => ... / type Client = PostHog
-    if (type &&
-        typeReferenceRoots(type).some((id) => symbolFromModules(symbolAt(id, checker), checker, modules, hops + 1))) {
+    if (type && typeFromModules(type, checker, modules, hops)) {
         return true;
     }
     // const ph = usePostHog() / new PostHog(k) / client = new PostHog(k) / const useTrack = usePostHog

package/dist/plugin/builtins/consoleDynamicEventReporter.js

@@ -28,6 +28,9 @@ const consoleDynamicEventReporter = {
             if (occ.inTemplate) {
                 console.log(chalk_1.default.yellow(`~ template of ${file}: event="${occ.eventExpression ?? ""}"${values}`));
             }
+            else if (occ.inTemplateCode) {
+                console.log(chalk_1.default.yellow(`~ template of ${file}: ${occ.calleeText}(...)${values}`));
+            }
             else {
                 console.log(chalk_1.default.yellow(`~ ${file}:${occ.line} ${occ.calleeText}(...)${values}`));
             }

package/dist/plugin/registry.js

@@ -7,6 +7,20 @@ exports.PluginRegistry = void 0;
 const path_1 = __importDefault(require("path"));
 // the synthetic callee each framework plugin uses for a template `event=...`
 const TEMPLATE_CALLEE = /^__eventra_[a-z]+_template_event__$/;
+// A plugin starts the code it generates from a template with this comment line, so a call found
+// below it is not on a line the user wrote.
+const TEMPLATE_REGION_START = /^\s*\/\/ --- [a-z]+ template \(auto-generated\) ---$/;
+// optional: a module that carries more after the generated code (an Angular component class) ends it
+const TEMPLATE_REGION_END = /^\s*\/\/ --- end template ---$/;
+// 1-based lines of the generated template region in a virtual module, or undefined when it has none
+function templateRegionOf(content) {
+    const lines = content.split("\n");
+    const start = lines.findIndex((line) => TEMPLATE_REGION_START.test(line));
+    if (start === -1)
+        return undefined;
+    const end = lines.findIndex((line, index) => index > start && TEMPLATE_REGION_END.test(line));
+    return { from: start + 1, to: end === -1 ? Infinity : end + 1 };
+}
 // `__eventra_x_template_event__(expr)` (callText may be cut with an ellipsis)
 function templateExpression(occurrence) {
     const open = occurrence.callText.indexOf("(");
@@ -22,6 +36,7 @@ class PluginRegistry {
     dynamicEventReporters = [];
     includePatterns = [];
     sourceToVirtuals = new Map();
+    templateRegions = new Map();
     registerFilePreprocessor(preprocessor) {
         if (this.preprocessors.some((p) => p.name === preprocessor.name)) {
             throw new Error(`File preprocessor already registered: ${preprocessor.name}`);
@@ -85,10 +100,23 @@ class PluginRegistry {
             }
             const files = await preprocessor.process(input);
             if (files.length > 0) {
+                // virtual files this source produced before and no longer does: their regions are not valid for anything else
+                for (const stale of this.sourceToVirtuals.get(sourceKey) ?? [])
+                    this.templateRegions.delete(stale);
+                for (const file of files) {
+                    const key = this.normalizePath(file.fileName);
+                    const region = templateRegionOf(file.content);
+                    if (region === undefined)
+                        this.templateRegions.delete(key);
+                    else
+                        this.templateRegions.set(key, region);
+                }
                 this.sourceToVirtuals.set(sourceKey, files.map((file) => this.normalizePath(file.fileName)));
                 return files;
             }
         }
+        for (const stale of this.sourceToVirtuals.get(sourceKey) ?? [])
+            this.templateRegions.delete(stale);
         this.sourceToVirtuals.delete(sourceKey);
         return [{ fileName: input.fileName, content: input.content }];
     }
@@ -147,6 +175,11 @@ class PluginRegistry {
                     eventExpression: templateExpression(occurrence),
                 };
             }
+            // ordinary code the plugin copied out of the template: its line is in the generated text
+            const region = this.templateRegions.get(this.normalizePath(occurrence.fileName));
+            if (region !== undefined && occurrence.line >= region.from && occurrence.line <= region.to) {
+                return { ...occurrence, fileName: source, inTemplateCode: true };
+            }
             // an Angular template module embeds the component class: lines there
             // are generated, the real call is also reported from the class file
             return source.toLowerCase().endsWith(".html")

package/dist/respawn.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRespawnDeps = exports.SCANNING_COMMANDS = exports.RESPAWN_ENV = void 0;
+exports.wantedHeapMb = wantedHeapMb;
+exports.usableMemory = usableMemory;
+exports.respawnWithMoreHeap = respawnWithMoreHeap;
+const child_process_1 = require("child_process");
+const os_1 = __importDefault(require("os"));
+const v8_1 = __importDefault(require("v8"));
+/** Set on the child, so a process started with more memory never starts another one. */
+exports.RESPAWN_ENV = "EVENTRA_HEAP_RESPAWNED";
+/** The commands that read the whole project; the rest (`init`, `--version`, `--help`) stay in one process. */
+exports.SCANNING_COMMANDS = new Set(["sync", "check", "watch", "send"]);
+const MIB = 1024 * 1024;
+// a project of tens of thousands of files needs a few GB while its program is built; more than
+// this is never useful, and half the machine's memory is what can be taken without hurting it
+const MAX_HEAP_MB = 8192;
+const SHARE_OF_MEMORY = 0.5;
+/** Signals a parent passes on, so stopping it stops the child too instead of leaving it running. */
+const FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+/**
+ * The old-space limit (MB) worth starting with, or `undefined` to carry on as is: Node's default
+ * limit is a fraction of the memory and can be well below what a large monorepo needs.
+ */
+function wantedHeapMb(availableMemoryBytes, currentLimitBytes) {
+    const wanted = Math.min(MAX_HEAP_MB, Math.floor((availableMemoryBytes * SHARE_OF_MEMORY) / MIB));
+    // not worth a second process for a small difference
+    return wanted > (currentLimitBytes / MIB) * 1.25 ? wanted : undefined;
+}
+/**
+ * Memory this process can use: the smaller of the machine's and the container's limit (cgroups) when it has
+ * one. `constrained` is 0 when nothing limits the process, and undefined on a Node that does not report it.
+ */
+function usableMemory(total, constrained) {
+    return constrained !== undefined && constrained > 0 ? Math.min(total, constrained) : total;
+}
+function runChild(command, args, env) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(command, [...args], { stdio: "inherit", env });
+        const forwarders = FORWARDED_SIGNALS.map((signal) => {
+            const forward = () => child.kill(signal);
+            process.on(signal, forward);
+            return [signal, forward];
+        });
+        const done = (code) => {
+            for (const [signal, forward] of forwarders)
+                process.off(signal, forward);
+            resolve(code);
+        };
+        // a child that could not start at all (`error`) counts as a failed run, like one killed by a signal
+        child.on("error", () => done(1));
+        child.on("exit", (code) => done(code ?? 1));
+    });
+}
+const defaultRespawnDeps = () => ({
+    env: process.env,
+    execArgv: process.execArgv,
+    argv: process.argv,
+    execPath: process.execPath,
+    availableMemoryBytes: usableMemory(os_1.default.totalmem(), os_1.default.constrainedMemory?.()),
+    heapLimitBytes: v8_1.default.getHeapStatistics().heap_size_limit,
+    run: runChild,
+    exit: (code) => process.exit(code),
+});
+exports.defaultRespawnDeps = defaultRespawnDeps;
+/**
+ * Runs a scanning command again in a child with a larger heap when this process would start with too
+ * little, and exits with the child's status. Resolves `true` when it did, so the caller stops there. An
+ * explicit `--max-old-space-size` (in NODE_OPTIONS or the command line) is the user's choice and is left alone.
+ */
+async function respawnWithMoreHeap(deps = (0, exports.defaultRespawnDeps)()) {
+    if (deps.env[exports.RESPAWN_ENV])
+        return false;
+    // a second process costs startup time, so only a command that scans a project is worth it
+    if (!exports.SCANNING_COMMANDS.has(deps.argv[2] ?? ""))
+        return false;
+    const explicit = [deps.env.NODE_OPTIONS ?? "", ...deps.execArgv].some((part) => part.includes("max-old-space-size"));
+    if (explicit)
+        return false;
+    const heapMb = wantedHeapMb(deps.availableMemoryBytes, deps.heapLimitBytes);
+    if (heapMb === undefined)
+        return false;
+    const code = await deps.run(deps.execPath, [`--max-old-space-size=${heapMb}`, ...deps.execArgv, ...deps.argv.slice(1)], { ...deps.env, [exports.RESPAWN_ENV]: "1" });
+    deps.exit(code);
+    return true;
+}

package/package.json

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