@wyw-in-js/transform 1.1.0 → 2.0.0-alpha.1

package/types/cache.d.ts

@@ -1,4 +1,4 @@
-import type { BarrelManifestCacheEntry } from './transform/barrelManifest';
+import type { BarrelManifestCacheEntry } from './transform/barrelManifest.types';
 import type { Entrypoint } from './transform/Entrypoint';
 import type { IEvaluatedEntrypoint } from './transform/EvaluatedEntrypoint';
 interface IBaseCachedEntrypoint {
@@ -27,7 +27,13 @@ export declare class TransformCacheCollection<TEntrypoint extends IBaseCachedEnt
     private contentHashes;
     private fileMtimes;
     private readonly exportDependencies;
+    private keySalt;
+    private invalidatedFiles;
+    private consumedInvalidationVersions;
     constructor(caches?: Partial<ICaches<TEntrypoint>>);
+    setKeySalt(keySalt: string | null): void;
+    private getKey;
+    getKeySalt(): string | null;
     add<TCache extends CacheNames, TValue extends MapValue<ICaches<TEntrypoint>[TCache]>>(cacheName: TCache, key: string, value: TValue): void;
     clear(cacheName: CacheNames | 'all'): void;
     delete(cacheName: CacheNames, key: string): void;
@@ -35,18 +41,21 @@ export declare class TransformCacheCollection<TEntrypoint extends IBaseCachedEnt
     has(cacheName: CacheNames, key: string): boolean;
     invalidate(cacheName: CacheNames, key: string): void;
     invalidateForFile(filename: string): void;
-    invalidateIfChanged(filename: string, content: string, previousVisitedFiles?: Set<string>, source?: 'fs' | 'loaded', changedFiles?: Set<string>): boolean;
+    consumeInvalidation(filename: string): boolean;
+    invalidateIfChanged(filename: string, content: string, previousVisitedFiles?: Set<string>, source?: 'fs' | 'loaded', changedFiles?: Set<string>, dependencyChangeMemo?: Map<string, boolean>, forceContentCheck?: boolean): boolean;
+    private getDependenciesToCheck;
+    private didDependencyChange;
+    private didFileContentHashChange;
     setCacheDependencies(cacheName: 'barrelManifests' | 'exports', key: string, dependencies: Iterable<string>): void;
-    private clearCacheDependencies;
-    private getCachedDependencies;
-    private getDependencyCache;
-    private hasCachedDependencies;
     /**
      * Fast check if a file changed on disk since last seen.
-     * Uses mtime as a fast path — only reads the file if mtime differs.
-     * Returns true if the file changed (cache was invalidated).
+     * Uses mtime as a fast path and only reads the file if mtime differs.
      */
     checkFreshness(filename: string, strippedFilename: string): boolean;
+    private clearCacheDependencies;
+    private getCachedDependencies;
+    private getDependencyCache;
+    private hasCachedDependencies;
     private setContentHash;
 }
 export {};

package/types/cache.js

@@ -1,16 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransformCacheCollection = void 0;
-const crypto_1 = require("crypto");
-const node_fs_1 = __importDefault(require("node:fs"));
-const shared_1 = require("@wyw-in-js/shared");
-const getFileIdx_1 = require("./utils/getFileIdx");
-const parseRequest_1 = require("./utils/parseRequest");
+import { createHash } from 'crypto';
+import fs from 'node:fs';
+import { logger } from '@wyw-in-js/shared';
+import { getFileIdx } from './utils/getFileIdx';
+import { stripQueryAndHash } from './utils/parseRequest';
 function hashContent(content) {
-    return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+    return createHash('sha256').update(content).digest('hex');
 }
 function isMissingFileError(error) {
     if (!error || typeof error !== 'object') {
@@ -19,13 +13,13 @@ function isMissingFileError(error) {
     const { code } = error;
     return code === 'ENOENT' || code === 'ENOTDIR';
 }
-const cacheLogger = shared_1.logger.extend('cache');
+const cacheLogger = logger.extend('cache');
 const cacheNames = ['barrelManifests', 'entrypoints', 'exports'];
 const loggers = cacheNames.reduce((acc, key) => ({
     ...acc,
     [key]: cacheLogger.extend(key),
 }), {});
-class TransformCacheCollection {
+export class TransformCacheCollection {
     barrelManifests;
     entrypoints;
     exports;
@@ -33,30 +27,67 @@ class TransformCacheCollection {
     contentHashes = new Map();
     fileMtimes = new Map();
     exportDependencies = new Map();
+    keySalt = null;
+    invalidatedFiles = new Map();
+    consumedInvalidationVersions = new Map();
     constructor(caches = {}) {
         this.barrelManifests = caches.barrelManifests || new Map();
         this.entrypoints = caches.entrypoints || new Map();
         this.exports = caches.exports || new Map();
     }
+    setKeySalt(keySalt) {
+        if (this.keySalt === keySalt)
+            return;
+        const prevKeySalt = this.keySalt;
+        this.keySalt = keySalt;
+        if (prevKeySalt === null && keySalt) {
+            const migrate = (cache) => {
+                const entries = Array.from(cache.entries());
+                cache.clear();
+                entries.forEach(([key, value]) => {
+                    cache.set(this.getKey(key), value);
+                });
+            };
+            migrate(this.barrelManifests);
+            migrate(this.entrypoints);
+            migrate(this.exports);
+            migrate(this.barrelManifestDependencies);
+            migrate(this.exportDependencies);
+            return;
+        }
+        this.barrelManifests.clear();
+        this.entrypoints.clear();
+        this.exports.clear();
+        this.clearCacheDependencies('all');
+    }
+    getKey(key) {
+        if (!this.keySalt)
+            return key;
+        return `${key}::${this.keySalt}`;
+    }
+    getKeySalt() {
+        return this.keySalt;
+    }
     add(cacheName, key, value) {
         const cache = this[cacheName];
-        loggers[cacheName]('%s:add %s %f', (0, getFileIdx_1.getFileIdx)(key), key, () => {
+        const cacheKey = this.getKey(key);
+        loggers[cacheName]('%s:add %s %f', getFileIdx(key), key, () => {
             if (value === undefined) {
-                return cache.has(key) ? 'removed' : 'noop';
+                return cache.has(cacheKey) ? 'removed' : 'noop';
             }
-            if (!cache.has(key)) {
+            if (!cache.has(cacheKey)) {
                 return 'added';
             }
-            return cache.get(key) === value ? 'unchanged' : 'updated';
+            return cache.get(cacheKey) === value ? 'unchanged' : 'updated';
         });
         if (value === undefined) {
-            cache.delete(key);
+            cache.delete(cacheKey);
             this.contentHashes.delete(key);
             this.clearCacheDependencies(cacheName, key);
             return;
         }
         this.clearCacheDependencies(cacheName, key);
-        cache.set(key, value);
+        cache.set(cacheKey, value);
         if ('initialCode' in value) {
             const maybeOriginalCode = value
                 .originalCode;
@@ -74,7 +105,7 @@ class TransformCacheCollection {
                 return;
             }
             try {
-                const fileContent = node_fs_1.default.readFileSync((0, parseRequest_1.stripQueryAndHash)(key), 'utf8');
+                const fileContent = fs.readFileSync(stripQueryAndHash(key), 'utf8');
                 this.setContentHash(key, source, hashContent(fileContent));
             }
             catch {
@@ -82,9 +113,9 @@ class TransformCacheCollection {
             }
             return;
         }
-        if (cacheName === 'barrelManifests') {
+        if (cacheName === 'barrelManifests' || cacheName === 'exports') {
             try {
-                const fileContent = node_fs_1.default.readFileSync((0, parseRequest_1.stripQueryAndHash)(key), 'utf8');
+                const fileContent = fs.readFileSync(stripQueryAndHash(key), 'utf8');
                 this.setContentHash(key, 'fs', hashContent(fileContent));
             }
             catch {
@@ -109,76 +140,65 @@ class TransformCacheCollection {
     }
     get(cacheName, key) {
         const cache = this[cacheName];
-        const res = cache.get(key);
+        const res = cache.get(this.getKey(key));
         loggers[cacheName]('get', key, res === undefined ? 'miss' : 'hit');
         return res;
     }
     has(cacheName, key) {
         const cache = this[cacheName];
-        const res = cache.has(key);
+        const res = cache.has(this.getKey(key));
         loggers[cacheName]('has', key, res);
         return res;
     }
     invalidate(cacheName, key) {
         const cache = this[cacheName];
-        if (!cache.has(key)) {
+        const cacheKey = this.getKey(key);
+        if (!cache.has(cacheKey)) {
             return;
         }
         loggers[cacheName]('invalidate', key);
-        cache.delete(key);
+        cache.delete(cacheKey);
         this.clearCacheDependencies(cacheName, key);
     }
     invalidateForFile(filename) {
         cacheNames.forEach((cacheName) => {
             this.invalidate(cacheName, filename);
         });
+        const key = stripQueryAndHash(filename);
+        const version = this.invalidatedFiles.get(key) ?? 0;
+        this.invalidatedFiles.set(key, version + 1);
+    }
+    consumeInvalidation(filename) {
+        const key = stripQueryAndHash(filename);
+        const invalidationVersion = this.invalidatedFiles.get(key);
+        if (invalidationVersion === undefined) {
+            return false;
+        }
+        const consumedVersion = this.consumedInvalidationVersions.get(filename) ?? 0;
+        if (consumedVersion >= invalidationVersion) {
+            return false;
+        }
+        this.consumedInvalidationVersions.set(filename, invalidationVersion);
+        return true;
     }
-    invalidateIfChanged(filename, content, previousVisitedFiles, source = 'loaded', changedFiles = new Set()) {
+    invalidateIfChanged(filename, content, previousVisitedFiles, source = 'loaded', changedFiles = new Set(), dependencyChangeMemo = new Map(), forceContentCheck = false) {
         if (changedFiles.has(filename)) {
             return true;
         }
         const visitedFiles = new Set(previousVisitedFiles);
         const fileEntrypoint = this.get('entrypoints', filename);
         let anyDepChanged = false;
-        // We need to check all dependencies of the file
-        // because they might have changed as well.
         if (!visitedFiles.has(filename) &&
             (fileEntrypoint || this.hasCachedDependencies(filename))) {
             visitedFiles.add(filename);
             const invalidateOnDependencyChange = fileEntrypoint?.invalidateOnDependencyChange;
-            const dependenciesToCheck = new Map();
-            for (const [key, dependency] of fileEntrypoint?.dependencies ?? []) {
-                dependenciesToCheck.set(key, dependency);
-            }
-            for (const [key, dependency,] of fileEntrypoint?.invalidationDependencies ?? []) {
-                if (!dependenciesToCheck.has(key)) {
-                    dependenciesToCheck.set(key, dependency);
-                }
-            }
-            for (const dependencyFilename of this.getCachedDependencies(filename)) {
-                if (![...dependenciesToCheck.values()].some((dependency) => dependency.resolved === dependencyFilename)) {
-                    dependenciesToCheck.set(dependencyFilename, {
-                        resolved: dependencyFilename,
-                    });
-                }
-            }
+            const dependenciesToCheck = this.getDependenciesToCheck(filename, fileEntrypoint);
             for (const [, dependency] of dependenciesToCheck) {
                 const dependencyFilename = dependency.resolved;
                 if (dependencyFilename) {
-                    let dependencyContent;
-                    try {
-                        dependencyContent = node_fs_1.default.readFileSync((0, parseRequest_1.stripQueryAndHash)(dependencyFilename), 'utf8');
-                    }
-                    catch (error) {
-                        if (!isMissingFileError(error)) {
-                            throw error;
-                        }
-                        this.invalidateForFile(dependencyFilename);
-                        anyDepChanged = true;
-                        // eslint-disable-next-line no-continue
-                        continue;
-                    }
-                    const dependencyChanged = this.invalidateIfChanged(dependencyFilename, dependencyContent, visitedFiles, 'fs', changedFiles);
+                    const dependencyChanged = this.didDependencyChange(dependencyFilename, visitedFiles, changedFiles, dependencyChangeMemo, forceContentCheck ||
+                        invalidateOnDependencyChange?.has(dependencyFilename) ||
+                        false);
                     if (dependencyChanged &&
                         invalidateOnDependencyChange?.has(dependencyFilename)) {
                         cacheLogger('dependency affecting output has changed, invalidate all for %s', filename);
@@ -222,14 +242,171 @@ class TransformCacheCollection {
         }
         return false;
     }
+    getDependenciesToCheck(filename, fileEntrypoint) {
+        const dependenciesToCheck = new Map();
+        for (const [key, dependency] of fileEntrypoint?.dependencies ?? []) {
+            dependenciesToCheck.set(key, dependency);
+        }
+        for (const [key, dependency] of fileEntrypoint?.invalidationDependencies ??
+            []) {
+            if (!dependenciesToCheck.has(key)) {
+                dependenciesToCheck.set(key, dependency);
+            }
+        }
+        for (const dependencyFilename of this.getCachedDependencies(filename)) {
+            if (![...dependenciesToCheck.values()].some((dependency) => dependency.resolved === dependencyFilename)) {
+                dependenciesToCheck.set(dependencyFilename, {
+                    resolved: dependencyFilename,
+                });
+            }
+        }
+        return dependenciesToCheck;
+    }
+    didDependencyChange(dependencyFilename, visitedFiles, changedFiles, dependencyChangeMemo, forceContentCheck = false) {
+        if (changedFiles.has(dependencyFilename)) {
+            return true;
+        }
+        const memoized = dependencyChangeMemo.get(dependencyFilename);
+        if (memoized !== undefined) {
+            return memoized;
+        }
+        if (visitedFiles.has(dependencyFilename)) {
+            return false;
+        }
+        const strippedDependencyFilename = stripQueryAndHash(dependencyFilename);
+        const cachedMtime = this.fileMtimes.get(dependencyFilename);
+        const cachedEntrypoint = this.get('entrypoints', dependencyFilename);
+        if (cachedMtime !== undefined) {
+            let currentMtime;
+            try {
+                currentMtime = fs.statSync(strippedDependencyFilename).mtimeMs;
+            }
+            catch (error) {
+                if (!isMissingFileError(error)) {
+                    throw error;
+                }
+                this.invalidateForFile(dependencyFilename);
+                changedFiles.add(dependencyFilename);
+                dependencyChangeMemo.set(dependencyFilename, true);
+                return true;
+            }
+            if (currentMtime === cachedMtime) {
+                const nestedDependencies = this.getDependenciesToCheck(dependencyFilename, cachedEntrypoint);
+                if (forceContentCheck &&
+                    this.didFileContentHashChange(dependencyFilename, strippedDependencyFilename, changedFiles)) {
+                    dependencyChangeMemo.set(dependencyFilename, true);
+                    return true;
+                }
+                // A cached file without a cached entrypoint was invalidated earlier.
+                // If the caller forced a content check and the content hash is stable,
+                // the missing entrypoint is only cache churn and must not invalidate
+                // output-dependent parents.
+                if (!cachedEntrypoint && nestedDependencies.size === 0) {
+                    if (forceContentCheck &&
+                        this.contentHashes.get(dependencyFilename)?.fs !== undefined) {
+                        dependencyChangeMemo.set(dependencyFilename, false);
+                        return false;
+                    }
+                    dependencyChangeMemo.set(dependencyFilename, true);
+                    return true;
+                }
+                if (nestedDependencies.size === 0) {
+                    dependencyChangeMemo.set(dependencyFilename, false);
+                    return false;
+                }
+                const nextVisitedFiles = new Set(visitedFiles);
+                nextVisitedFiles.add(dependencyFilename);
+                for (const [, nestedDependency] of nestedDependencies) {
+                    if (nestedDependency.resolved &&
+                        this.didDependencyChange(nestedDependency.resolved, nextVisitedFiles, changedFiles, dependencyChangeMemo, forceContentCheck)) {
+                        this.invalidateForFile(dependencyFilename);
+                        changedFiles.add(dependencyFilename);
+                        dependencyChangeMemo.set(dependencyFilename, true);
+                        return true;
+                    }
+                }
+                dependencyChangeMemo.set(dependencyFilename, false);
+                return false;
+            }
+        }
+        let dependencyContent;
+        try {
+            dependencyContent = fs.readFileSync(strippedDependencyFilename, 'utf8');
+        }
+        catch (error) {
+            if (!isMissingFileError(error)) {
+                throw error;
+            }
+            this.invalidateForFile(dependencyFilename);
+            changedFiles.add(dependencyFilename);
+            dependencyChangeMemo.set(dependencyFilename, true);
+            return true;
+        }
+        const invalidated = this.invalidateIfChanged(dependencyFilename, dependencyContent, visitedFiles, 'fs', changedFiles, dependencyChangeMemo, forceContentCheck);
+        dependencyChangeMemo.set(dependencyFilename, invalidated);
+        return invalidated;
+    }
+    didFileContentHashChange(filename, strippedFilename, changedFiles) {
+        const previousHash = this.contentHashes.get(filename)?.fs;
+        if (previousHash === undefined) {
+            return false;
+        }
+        let content;
+        try {
+            content = fs.readFileSync(strippedFilename, 'utf8');
+        }
+        catch (error) {
+            if (!isMissingFileError(error)) {
+                throw error;
+            }
+            this.invalidateForFile(filename);
+            changedFiles.add(filename);
+            return true;
+        }
+        const nextHash = hashContent(content);
+        if (previousHash === nextHash) {
+            return false;
+        }
+        this.setContentHash(filename, 'fs', nextHash);
+        this.invalidateForFile(filename);
+        changedFiles.add(filename);
+        return true;
+    }
     setCacheDependencies(cacheName, key, dependencies) {
         const cache = this.getDependencyCache(cacheName);
         const nextDependencies = new Set([...dependencies].filter((dependency) => dependency.length > 0));
+        const cacheKey = this.getKey(key);
         if (nextDependencies.size === 0) {
-            cache.delete(key);
+            cache.delete(cacheKey);
             return;
         }
-        cache.set(key, nextDependencies);
+        cache.set(cacheKey, nextDependencies);
+    }
+    /**
+     * Fast check if a file changed on disk since last seen.
+     * Uses mtime as a fast path and only reads the file if mtime differs.
+     */
+    checkFreshness(filename, strippedFilename) {
+        try {
+            const currentMtime = fs.statSync(strippedFilename).mtimeMs;
+            const cachedMtime = this.fileMtimes.get(filename);
+            if (cachedMtime !== undefined && currentMtime === cachedMtime) {
+                return false;
+            }
+            const content = fs.readFileSync(strippedFilename, 'utf8');
+            this.fileMtimes.set(filename, currentMtime);
+            if (this.invalidateIfChanged(filename, content, undefined, 'fs')) {
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            if (!isMissingFileError(error)) {
+                throw error;
+            }
+            this.invalidateForFile(filename);
+            return true;
+        }
     }
     clearCacheDependencies(cacheName, key) {
         if (cacheName === 'all') {
@@ -242,7 +419,7 @@ class TransformCacheCollection {
                 this.barrelManifestDependencies.clear();
             }
             else {
-                this.barrelManifestDependencies.delete(key);
+                this.barrelManifestDependencies.delete(this.getKey(key));
             }
             return;
         }
@@ -251,14 +428,15 @@ class TransformCacheCollection {
                 this.exportDependencies.clear();
             }
             else {
-                this.exportDependencies.delete(key);
+                this.exportDependencies.delete(this.getKey(key));
             }
         }
     }
     getCachedDependencies(filename) {
+        const key = this.getKey(filename);
         return new Set([
-            ...(this.barrelManifestDependencies.get(filename) ?? []),
-            ...(this.exportDependencies.get(filename) ?? []),
+            ...(this.barrelManifestDependencies.get(key) ?? []),
+            ...(this.exportDependencies.get(key) ?? []),
         ]);
     }
     getDependencyCache(cacheName) {
@@ -269,33 +447,6 @@ class TransformCacheCollection {
     hasCachedDependencies(filename) {
         return this.getCachedDependencies(filename).size > 0;
     }
-    /**
-     * Fast check if a file changed on disk since last seen.
-     * Uses mtime as a fast path — only reads the file if mtime differs.
-     * Returns true if the file changed (cache was invalidated).
-     */
-    checkFreshness(filename, strippedFilename) {
-        try {
-            const currentMtime = node_fs_1.default.statSync(strippedFilename).mtimeMs;
-            const cachedMtime = this.fileMtimes.get(filename);
-            if (cachedMtime !== undefined && currentMtime === cachedMtime) {
-                return false;
-            }
-            const content = node_fs_1.default.readFileSync(strippedFilename, 'utf-8');
-            this.fileMtimes.set(filename, currentMtime);
-            if (this.invalidateIfChanged(filename, content, undefined, 'fs')) {
-                return true;
-            }
-            return false;
-        }
-        catch (error) {
-            if (!isMissingFileError(error)) {
-                throw error;
-            }
-            this.invalidateForFile(filename);
-            return true;
-        }
-    }
     setContentHash(filename, source, hash) {
         const current = this.contentHashes.get(filename);
         if (current) {
@@ -306,7 +457,7 @@ class TransformCacheCollection {
         }
         if (source === 'fs') {
             try {
-                this.fileMtimes.set(filename, node_fs_1.default.statSync((0, parseRequest_1.stripQueryAndHash)(filename)).mtimeMs);
+                this.fileMtimes.set(filename, fs.statSync(stripQueryAndHash(filename)).mtimeMs);
             }
             catch {
                 // ignore
@@ -314,4 +465,3 @@ class TransformCacheCollection {
         }
     }
 }
-exports.TransformCacheCollection = TransformCacheCollection;