@eventra_dev/eventra-cli 2.1.0 → 2.3.0

package/dist/compiler/compilerContext.js

@@ -8,13 +8,30 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const typescript_1 = __importDefault(require("typescript"));
 const documentRegistry_1 = require("./documentRegistry");
+const workspacePackages_1 = require("./workspacePackages");
 class CompilerContext {
     rootDir;
     registry = new documentRegistry_1.DocumentRegistry();
+    // Parsed files survive a program rebuild: a flush changes a handful of files,
+    // and parsing every other file (and the default lib .d.ts files) again was
+    // most of the rebuild cost. Reusing a SourceFile object across programs is
+    // what the TypeScript language service does too.
+    sourceFileCache = new Map();
     compilerOptions;
     host;
-    program = typescript_1.default.createProgram([], {});
+    // Built on first use (or by flushUpdates): the engine stages every file of a
+    // scan and flushes once, so an eager build in the constructor was thrown away.
+    programInstance;
     rootNames = new Set();
+    // compiler options of the nearest tsconfig.json above a folder (the root one for files outside any other)
+    optionsByDir = new Map();
+    // the options a project starts from before any tsconfig.json is applied
+    defaultOptions;
+    workspacePackages;
+    // one module resolution cache per set of options; only alive while a program is built or a batch runs
+    resolutionCaches = new Map();
+    // how many builds or batches are running that share the caches (a rebuild can start inside a batch)
+    cachingDepth = 0;
     constructor(rootDir) {
         this.rootDir = rootDir;
         const localTsconfig = path_1.default.join(rootDir, "tsconfig.json");
@@ -35,6 +52,7 @@ class CompilerContext {
             allowNonTsExtensions: true,
             incremental: false,
         };
+        this.defaultOptions = compilerOptions;
         if (configPath) {
             const config = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
             if (config.error) {
@@ -45,18 +63,138 @@ class CompilerContext {
                 ...compilerOptions,
                 ...parsed.options,
             };
+            // A solution-style tsconfig (`"files": []` plus `references`, the Vite and Vue template) keeps its
+            // `@/*` aliases in a referenced config, so without this every aliased import stays unresolved.
+            if (!parsed.options.paths) {
+                Object.assign(compilerOptions, this.pathOptionsFromReferences(parsed.projectReferences));
+            }
             for (const file of parsed.fileNames) {
                 this.rootNames.add(this.normalize(file));
             }
         }
         this.compilerOptions = compilerOptions;
+        this.workspacePackages = (0, workspacePackages_1.findWorkspacePackages)(rootDir);
         this.host = typescript_1.default.createCompilerHost(this.compilerOptions, true);
         this.patchCompilerHost();
-        this.rebuildProgram();
     }
     normalize(fileName) {
         return this.registry.normalize(fileName);
     }
+    /**
+     * Compiler options for resolving the imports of `fromFile`: those of the nearest tsconfig.json above
+     * it. A monorepo keeps one per app (`@/*` means a different folder in each) and often none at the root;
+     * a single root-level tsconfig.json answers for every file below it, as it always did.
+     */
+    optionsFor(fromFile) {
+        // an installed package may ship a tsconfig.json of its own: its settings are for building it, not for this project
+        if (fromFile.split(/[\\/]/).includes("node_modules"))
+            return this.compilerOptions;
+        const visited = [];
+        let options = this.compilerOptions;
+        for (let dir = path_1.default.dirname(fromFile);; dir = path_1.default.dirname(dir)) {
+            const cached = this.optionsByDir.get(dir);
+            const own = cached ?? this.readDirectoryOptions(dir);
+            if (own) {
+                options = own;
+                visited.push(dir);
+                break;
+            }
+            visited.push(dir);
+            // a file outside the project, or the top of the filesystem, keeps the root options
+            if (path_1.default.relative(this.rootDir, dir).startsWith("..") || path_1.default.dirname(dir) === dir || dir === this.rootDir)
+                break;
+        }
+        for (const dir of visited)
+            this.optionsByDir.set(dir, options);
+        return options;
+    }
+    /** The options a folder's own tsconfig.json sets, `undefined` when it has none (the root's are already loaded). */
+    readDirectoryOptions(dir) {
+        if (dir === this.rootDir)
+            return this.compilerOptions;
+        const configPath = path_1.default.join(dir, "tsconfig.json");
+        if (!fs_1.default.existsSync(configPath))
+            return undefined;
+        const config = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
+        if (config.error)
+            return undefined;
+        const parsed = typescript_1.default.parseJsonConfigFileContent(config.config, typescript_1.default.sys, dir);
+        return {
+            ...this.defaultOptions,
+            ...parsed.options,
+            ...(parsed.options.paths ? {} : this.aliasesWithout(parsed.options, parsed.projectReferences)),
+        };
+    }
+    /**
+     * Aliases for a config that sets no `paths` of its own: those of its project references, or else the root's.
+     * A tsconfig.json that only adjusts a few options (a `tests/` one, say) does not mean the root's `@/*` stopped
+     * being valid there, and the root's aliases applied to every file before configs were read per folder.
+     */
+    aliasesWithout(own, references) {
+        const fromReferences = this.pathOptionsFromReferences(references);
+        if (fromReferences.paths)
+            return fromReferences;
+        const { paths, baseUrl, pathsBasePath } = this.compilerOptions;
+        return { paths, baseUrl: own.baseUrl ?? baseUrl, pathsBasePath };
+    }
+    cacheFor(options) {
+        if (this.cachingDepth === 0)
+            return undefined;
+        let cache = this.resolutionCaches.get(options);
+        if (!cache) {
+            cache = typescript_1.default.createModuleResolutionCache(this.rootDir, (fileName) => this.normalize(fileName), options);
+            this.resolutionCaches.set(options, cache);
+        }
+        return cache;
+    }
+    /** Where a monorepo package's own folder is for an import of it (`@acme/lib`, `@acme/lib/hooks/x`), if it is one. */
+    workspaceTargets(moduleName) {
+        let best;
+        for (const [name, dir] of this.workspacePackages) {
+            if ((moduleName === name || moduleName.startsWith(`${name}/`)) && (!best || name.length > best.name.length)) {
+                best = { name, dir };
+            }
+        }
+        if (!best)
+            return [];
+        const sub = moduleName.slice(best.name.length + 1);
+        // the package's sources may sit in src/ while its package.json points at a build that is not there
+        return [path_1.default.join(best.dir, sub), path_1.default.join(best.dir, "src", sub)];
+    }
+    resolveImport(moduleName, containingFile, redirectedReference, mode) {
+        const options = this.optionsFor(containingFile);
+        const cache = this.cacheFor(options);
+        const resolved = typescript_1.default.resolveModuleName(moduleName, containingFile, options, this.host, cache, redirectedReference, mode);
+        if (resolved.resolvedModule)
+            return resolved;
+        // not installed, so no node_modules link: a package of this very monorepo is found by its folder
+        for (const target of this.workspaceTargets(moduleName)) {
+            const viaWorkspace = typescript_1.default.resolveModuleName(target, containingFile, options, this.host, cache, redirectedReference, mode);
+            if (viaWorkspace.resolvedModule)
+                return viaWorkspace;
+        }
+        return resolved;
+    }
+    /**
+     * Alias options (`paths`, `baseUrl`) of the first referenced tsconfig that defines `paths`. A
+     * reference that is unreadable or has no aliases is skipped; only aliases are taken, never the files.
+     */
+    pathOptionsFromReferences(references) {
+        for (const reference of references ?? []) {
+            const referenced = typescript_1.default.sys.directoryExists(reference.path)
+                ? path_1.default.join(reference.path, "tsconfig.json")
+                : reference.path;
+            const config = typescript_1.default.readConfigFile(referenced, typescript_1.default.sys.readFile);
+            if (config.error)
+                continue;
+            const { options } = typescript_1.default.parseJsonConfigFileContent(config.config, typescript_1.default.sys, path_1.default.dirname(referenced));
+            if (options.paths) {
+                const { paths, baseUrl, pathsBasePath } = options;
+                return { paths, baseUrl, pathsBasePath };
+            }
+        }
+        return {};
+    }
     resolveLanguageVersion(languageVersionOrOptions) {
         if (typeof languageVersionOrOptions === "object") {
             return languageVersionOrOptions.languageVersion;
@@ -75,7 +213,17 @@ class CompilerContext {
         if (!snapshot) {
             return undefined;
         }
-        const sourceFile = typescript_1.default.createSourceFile(normalized, snapshot.getText(0, snapshot.getLength()), languageVersion, true, this.getScriptKind(normalized));
+        const content = snapshot.getText(0, snapshot.getLength());
+        const scriptKind = this.getScriptKind(normalized);
+        const cached = this.sourceFileCache.get(normalized);
+        if (cached &&
+            cached.content === content &&
+            cached.languageVersion === languageVersion &&
+            cached.scriptKind === scriptKind) {
+            return this.attachVersion(cached.sourceFile, normalized);
+        }
+        const sourceFile = typescript_1.default.createSourceFile(normalized, content, languageVersion, true, scriptKind);
+        this.sourceFileCache.set(normalized, { content, languageVersion, scriptKind, sourceFile });
         return this.attachVersion(sourceFile, normalized);
     }
     patchCompilerHost() {
@@ -108,6 +256,7 @@ class CompilerContext {
             const normalized = this.normalize(fileName);
             return this.registry.has(normalized) || fs_1.default.existsSync(normalized);
         };
+        this.host.resolveModuleNameLiterals = (literals, containingFile, redirectedReference, _options, containingSourceFile) => literals.map((literal) => this.resolveImport(literal.text, containingFile, redirectedReference, typescript_1.default.getModeForUsageLocation(containingSourceFile, literal, this.compilerOptions)));
         this.host.getCanonicalFileName = (f) => this.normalize(f);
         this.host.useCaseSensitiveFileNames = () => true;
         this.host.getCurrentDirectory = () => this.rootDir;
@@ -127,7 +276,43 @@ class CompilerContext {
         return typescript_1.default.ScriptKind.Unknown;
     }
     rebuildProgram() {
-        this.program = typescript_1.default.createProgram([...this.rootNames], this.compilerOptions, this.host);
+        // options are re-read from disk with every build, so an edited nested tsconfig.json is seen
+        this.optionsByDir.clear();
+        this.withSharedCaches(() => {
+            this.programInstance = typescript_1.default.createProgram([...this.rootNames], this.compilerOptions, this.host);
+        });
+    }
+    /**
+     * Imports resolved while `fn` runs share caches, as they do in TypeScript's own host. Files may appear or
+     * go between runs, so nothing is kept after the outermost one; a run started inside another (a lazy
+     * program build inside a batch) joins it instead of dropping its caches.
+     */
+    withSharedCaches(fn) {
+        if (this.cachingDepth === 0)
+            this.resolutionCaches.clear();
+        this.cachingDepth++;
+        try {
+            return fn();
+        }
+        finally {
+            this.cachingDepth--;
+            if (this.cachingDepth === 0)
+                this.resolutionCaches.clear();
+        }
+    }
+    get program() {
+        if (!this.programInstance) {
+            this.rebuildProgram();
+        }
+        return this.programInstance;
+    }
+    /**
+     * Run `fn` with one shared module resolution cache, so resolving the imports
+     * of many files in a row (import graph after a flush) does not repeat the
+     * same directory lookups. The cache is dropped when `fn` returns.
+     */
+    withResolutionCache(fn) {
+        return this.withSharedCaches(fn);
     }
     /** Register file content without rebuilding the TS program (batch via {@link flushUpdates}). */
     stageFile(fileName, content) {
@@ -147,9 +332,65 @@ class CompilerContext {
     removeFile(fileName) {
         const normalized = this.normalize(fileName);
         this.registry.remove(normalized);
+        this.sourceFileCache.delete(normalized);
         this.rootNames.delete(normalized);
         this.rebuildProgram();
     }
+    /**
+     * Re-reads files that are in the program only because something imports them
+     * (they are not scanned sources): the disk content replaces whatever the
+     * registry cached and the program is rebuilt ONCE for the whole batch. A file
+     * that no longer exists is dropped. Returns the files whose content really
+     * changed (normalized); none of them ever becomes a root.
+     */
+    refreshFromDisk(fileNames) {
+        const changed = [];
+        for (const fileName of fileNames) {
+            const normalized = this.normalize(fileName);
+            const before = this.registry.getContent(normalized);
+            let content;
+            try {
+                content = fs_1.default.readFileSync(normalized, "utf8");
+            }
+            catch {
+                content = undefined;
+            }
+            if (before === content)
+                continue;
+            if (content === undefined) {
+                this.registry.remove(normalized);
+                this.sourceFileCache.delete(normalized);
+            }
+            else {
+                this.registry.update(normalized, content);
+            }
+            changed.push(normalized);
+        }
+        if (changed.length === 0) {
+            return changed;
+        }
+        this.rebuildProgram();
+        // a file nothing imports must not linger in the registry
+        for (const normalized of changed) {
+            if (this.registry.has(normalized) && !this.programInstance.getSourceFile(normalized)) {
+                this.registry.remove(normalized);
+                this.sourceFileCache.delete(normalized);
+            }
+        }
+        return changed;
+    }
+    /** True when the file is part of the current program (scanned or only imported). */
+    hasFile(fileName) {
+        return this.program.getSourceFile(this.normalize(fileName)) !== undefined;
+    }
+    /** Project files of the program (no TypeScript libs, no node_modules), declaration files included. */
+    getProjectFileNames() {
+        const program = this.program;
+        return program
+            .getSourceFiles()
+            .filter((sf) => !program.isSourceFileDefaultLibrary(sf) && !program.isSourceFileFromExternalLibrary(sf))
+            .map((sf) => sf.fileName);
+    }
     getProgram() {
         return this.program;
     }
@@ -173,8 +414,7 @@ class CompilerContext {
         ];
     }
     resolveModule(moduleName, fromFile) {
-        const resolved = typescript_1.default.resolveModuleName(moduleName, this.normalize(fromFile), this.compilerOptions, this.host);
-        return resolved.resolvedModule?.resolvedFileName;
+        return this.resolveImport(moduleName, this.normalize(fromFile)).resolvedModule?.resolvedFileName;
     }
     getResolvedModules(fileName) {
         const source = this.getSourceFile(fileName);

package/dist/compiler/documentRegistry.js

@@ -9,8 +9,22 @@ const path_1 = __importDefault(require("path"));
 const typescript_1 = __importDefault(require("typescript"));
 class DocumentRegistry {
     documents = new Map();
+    // path.resolve + regex ran thousands of times per scan on the same inputs;
+    // keyed on cwd because relative inputs resolve against it
+    normalizedCache = new Map();
+    normalizedCwd = "";
     normalize(fileName) {
-        return path_1.default.resolve(fileName).replace(/\\/g, "/");
+        const cwd = process.cwd();
+        if (cwd !== this.normalizedCwd) {
+            this.normalizedCache.clear();
+            this.normalizedCwd = cwd;
+        }
+        let normalized = this.normalizedCache.get(fileName);
+        if (normalized === undefined) {
+            normalized = path_1.default.resolve(fileName).replace(/\\/g, "/");
+            this.normalizedCache.set(fileName, normalized);
+        }
+        return normalized;
     }
     has(fileName) {
         return this.documents.has(this.normalize(fileName));

package/dist/compiler/importGraph.js

@@ -7,6 +7,13 @@ class ImportGraph {
     imports = new Map();
     // import -> importers
     reverse = new Map();
+    hasFile(file) {
+        return this.imports.has(file);
+    }
+    getFiles() {
+        return [...this.imports.keys()];
+    }
+    /** Returns true when the set of files this file imports changed. */
     updateFile(file, nextImports) {
         const previous = this.imports.get(file) ?? new Set();
         const next = new Set(nextImports);
@@ -36,6 +43,7 @@ class ImportGraph {
             importers.add(file);
         }
         this.imports.set(file, next);
+        return previous.size !== next.size || [...next].some((imported) => !previous.has(imported));
     }
     removeFile(file) {
         const imports = this.imports.get(file);

package/dist/compiler/workspacePackages.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findWorkspacePackages = findWorkspacePackages;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const projectDependencies_1 = require("../cli/projectDependencies");
+function readJson(file) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The packages of a monorepo (`workspaces` in package.json, or pnpm-workspace.yaml) by name, mapped to
+ * their folder. `import "@acme/lib/hooks/x"` then resolves to a folder of the repo itself, so a project
+ * whose dependencies are not installed still links its own packages together.
+ */
+function findWorkspacePackages(rootDir) {
+    const packages = new Map();
+    const rootPackage = readJson(path_1.default.join(rootDir, "package.json"));
+    if (!rootPackage)
+        return packages;
+    const workspaces = rootPackage.workspaces;
+    const fromPackageJson = Array.isArray(workspaces)
+        ? (0, projectDependencies_1.stringList)(workspaces)
+        : (0, projectDependencies_1.stringList)(workspaces?.packages);
+    let fromPnpm = [];
+    try {
+        fromPnpm = (0, projectDependencies_1.pnpmWorkspacePatterns)(fs_1.default.readFileSync(path_1.default.join(rootDir, "pnpm-workspace.yaml"), "utf8"));
+    }
+    catch {
+        // no pnpm-workspace.yaml (or an unreadable one): the package.json patterns are all there is
+    }
+    const patterns = [...fromPackageJson, ...fromPnpm].filter(projectDependencies_1.staysInsideProject);
+    if (patterns.length === 0)
+        return packages;
+    let members;
+    try {
+        members = fast_glob_1.default.sync(patterns.map(projectDependencies_1.memberGlob), { cwd: rootDir, ignore: ["**/node_modules/**"] });
+    }
+    catch {
+        // a pattern fast-glob rejects: no members
+        return packages;
+    }
+    for (const member of members.slice(0, projectDependencies_1.MAX_WORKSPACE_PACKAGES)) {
+        const name = readJson(path_1.default.join(rootDir, member))?.name;
+        if (typeof name === "string" && name !== "" && !packages.has(name)) {
+            packages.set(name, path_1.default.dirname(path_1.default.join(rootDir, member)));
+        }
+    }
+    return packages;
+}

package/dist/config/config.js

@@ -3,9 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOCAL_CONFIG_NAME = exports.CONFIG_NAME = void 0;
+exports.INIT_EXCLUDE = exports.LOCAL_CONFIG_NAME = exports.CONFIG_NAME = void 0;
 exports.normalizeConfig = normalizeConfig;
 exports.loadConfig = loadConfig;
+exports.describeConfigProblem = describeConfigProblem;
+exports.requireConfig = requireConfig;
 exports.saveConfig = saveConfig;
 exports.resolveApiKey = resolveApiKey;
 exports.saveLocalApiKey = saveLocalApiKey;
@@ -20,7 +22,22 @@ exports.CONFIG_NAME = "eventra.json";
  */
 exports.LOCAL_CONFIG_NAME = "eventra.local.json";
 const DEFAULT_INCLUDE = ["**/*.{ts,tsx,js,jsx}"];
+// what a config without `sync.exclude` has always skipped; changing it would change the scan of every
+// existing project that never wrote its own list
 const DEFAULT_EXCLUDE = ["node_modules", "dist", ".next", ".git"];
+/**
+ * What `eventra init` writes into a new eventra.json: the default above plus folders and files whose
+ * code is not the product. Events fired from a test are not features, and on a large repository the tests
+ * alone can double the files scanned. Written out, so it is visible and editable. `build` and `out` are
+ * left out on purpose: they are as likely to be a source folder as output.
+ */
+exports.INIT_EXCLUDE = [
+    ...DEFAULT_EXCLUDE,
+    "coverage",
+    "**/*.{test,spec}.{ts,tsx,js,jsx}",
+    "**/__tests__/**",
+    "**/__mocks__/**",
+];
 function normalizeSinks(sinks) {
     if (!Array.isArray(sinks))
         return [];
@@ -42,7 +59,9 @@ function normalizeConfig(config) {
         apiKey: config.apiKey ?? "",
         endpoint: config.endpoint ?? "",
         events: [...(config.events ?? [])].sort(),
-        functionWrappers: uniqueWrappers.sort((a, b) => a.name.localeCompare(b.name)),
+        // plain comparison, not localeCompare: the order in the committed file must
+        // not depend on the machine's ICU locale
+        functionWrappers: uniqueWrappers.sort((a, b) => (a.name < b.name ? -1 : 1)),
         plugins: [...(config.plugins ?? [])],
         ...(sinks.length > 0 ? { sinks } : {}),
         sync: {
@@ -64,9 +83,48 @@ async function loadConfig() {
         return null;
     }
 }
+/**
+ * Says why `loadConfig` returned null, for the CLI's error message: a missing
+ * file and a malformed one are different problems.
+ */
+async function describeConfigProblem() {
+    const configPath = path_1.default.join(process.cwd(), exports.CONFIG_NAME);
+    if (!(await fs_extra_1.default.pathExists(configPath)))
+        return `${exports.CONFIG_NAME} not found`;
+    try {
+        await fs_extra_1.default.readJSON(configPath);
+        return `${exports.CONFIG_NAME} could not be read`;
+    }
+    catch (err) {
+        // readJSON only rejects with an Error (ENOENT was ruled out above, the rest is a parse error)
+        return `${exports.CONFIG_NAME} is not valid JSON: ${err.message}`;
+    }
+}
+/**
+ * Loads the config for a command that cannot run without it. On failure it
+ * prints the reason and sets a non-zero exit code, and returns null, so every
+ * command ends the same way when there is no usable config.
+ */
+async function requireConfig() {
+    const config = await loadConfig();
+    if (config)
+        return config;
+    console.error(await describeConfigProblem());
+    process.exitCode = 1;
+    return null;
+}
+/** Writes eventra.json only when its content actually changed (watch mode re-saves often). */
 async function saveConfig(config) {
     const configPath = path_1.default.join(process.cwd(), exports.CONFIG_NAME);
-    await fs_extra_1.default.writeJSON(configPath, normalizeConfig(config), { spaces: 2 });
+    const next = `${JSON.stringify(normalizeConfig(config), null, 2)}\n`;
+    try {
+        if ((await fs_extra_1.default.readFile(configPath, "utf8")) === next)
+            return;
+    }
+    catch {
+        // missing or unreadable: write it
+    }
+    await fs_extra_1.default.writeFile(configPath, next);
 }
 async function readLocalSecrets() {
     const localPath = path_1.default.join(process.cwd(), exports.LOCAL_CONFIG_NAME);