Watch modifications of externally included files

misha-db · misha-db · commit 863715b7072a · 2026-06-29T13:28:45.000+04:00
diff --git a/packages/databricks-vscode/src/bundle/BundleFileSet.test.ts b/packages/databricks-vscode/src/bundle/BundleFileSet.test.ts
@@ -139,6 +139,43 @@ describe(__filename, async function () {
                 )
             ).to.be.false;
         });
+
+        it("getExternalIncludeWatchTargets should only return bases outside the project root", async () => {
+            const sharedDir = path.join(tmpdir.path, "shared");
+            const projectDir = path.join(tmpdir.path, "project", "sub");
+            await fs.mkdir(sharedDir, {recursive: true});
+            await fs.mkdir(projectDir, {recursive: true});
+
+            const rootBundleData: BundleSchema = {
+                include: [
+                    "../../shared/config.yml",
+                    "../../shared/*.yml",
+                    "local.yml",
+                    "includes/**/*.yml",
+                ],
+            };
+            await fs.writeFile(
+                path.join(projectDir, "databricks.yml"),
+                yaml.stringify(rootBundleData)
+            );
+
+            const bundleFileSet = new BundleFileSet(
+                getWorkspaceFolderManagerMock(projectDir)
+            );
+
+            const targets =
+                await bundleFileSet.getExternalIncludeWatchTargets();
+
+            // Only the two ../../shared patterns escape the project root; the
+            // in-tree patterns (local.yml, includes/**) are covered by the
+            // default recursive watcher and must be excluded.
+            const summary = targets
+                .map((t) => `${t.baseUri.fsPath}|${t.pattern}`)
+                .sort();
+            expect(summary).to.deep.equal(
+                [`${sharedDir}|config.yml`, `${sharedDir}|*.yml`].sort()
+            );
+        });
     });
 
     describe("file listing", async () => {
diff --git a/packages/databricks-vscode/src/bundle/BundleFileSet.ts b/packages/databricks-vscode/src/bundle/BundleFileSet.ts
@@ -55,6 +55,35 @@ function toGlobPath(path: string) {
     return path;
 }
 
+const globMagicChars = /[*?{}[\]!+@()]/;
+
+/**
+ * Splits an absolute glob path into its static base directory (the leading
+ * segments that contain no glob magic characters) and the remaining glob
+ * pattern. e.g. "/a/b/sub/**\/*.yml" -> {base: "/a/b/sub", pattern: "**\/*.yml"}.
+ * A pattern without any magic characters is treated as a literal file: its
+ * directory becomes the base and its filename the pattern.
+ */
+function splitGlobBase(absolutePath: string): {base: string; pattern: string} {
+    const segments = absolutePath.split(path.sep);
+    const staticSegments: string[] = [];
+    let i = 0;
+    for (; i < segments.length; i++) {
+        if (globMagicChars.test(segments[i])) {
+            break;
+        }
+        staticSegments.push(segments[i]);
+    }
+    // If no segment contains magic chars, treat the path as a literal file and
+    // use its parent directory as the base.
+    if (i === segments.length) {
+        staticSegments.pop();
+    }
+    const base = staticSegments.join(path.sep) || path.sep;
+    const pattern = segments.slice(staticSegments.length).join("/");
+    return {base, pattern};
+}
+
 export class BundleFileSet {
     public readonly bundleDataCache: CachedValue<BundleSchema> =
         new CachedValue<BundleSchema>(async () => {
@@ -120,6 +149,41 @@ export class BundleFileSet {
         return [...new Set(allFiles)].map((f) => Uri.file(f));
     }
 
+    /**
+     * Returns watch targets for include patterns whose static base resolves
+     * outside the active project root (e.g. "../../shared/*.yml"). The default
+     * recursive workspace watcher only observes files under the project root,
+     * so these external bases need dedicated watchers. Each target is a base
+     * directory plus a relative glob suitable for a vscode RelativePattern.
+     */
+    async getExternalIncludeWatchTargets(): Promise<
+        {baseUri: Uri; pattern: string}[]
+    > {
+        const patterns = await this.getIncludePatterns();
+        const projectRoot = path.normalize(this.projectRoot.fsPath);
+        const targets = new Map<string, {baseUri: Uri; pattern: string}>();
+
+        for (const pattern of patterns) {
+            const resolved = path.resolve(projectRoot, pattern);
+            const {base, pattern: relativePattern} = splitGlobBase(resolved);
+            // Keep only bases that escape the project root. The default
+            // recursive watcher already covers everything under the root.
+            const relativeToRoot = path.relative(projectRoot, base);
+            if (!relativeToRoot.startsWith("..")) {
+                continue;
+            }
+            const key = `${base}\0${relativePattern}`;
+            if (!targets.has(key)) {
+                targets.set(key, {
+                    baseUri: Uri.file(base),
+                    pattern: relativePattern,
+                });
+            }
+        }
+
+        return [...targets.values()];
+    }
+
     async allFiles() {
         const rootFile = await this.getRootFile();
         if (rootFile === undefined) {
diff --git a/packages/databricks-vscode/src/bundle/BundleWatcher.ts b/packages/databricks-vscode/src/bundle/BundleWatcher.ts
@@ -1,7 +1,14 @@
-import {Disposable, EventEmitter, Uri, workspace} from "vscode";
+import {
+    Disposable,
+    EventEmitter,
+    RelativePattern,
+    Uri,
+    workspace,
+} from "vscode";
 import {BundleFileSet, getAbsoluteGlobPath} from "./BundleFileSet";
 import path from "path";
 import {WorkspaceFolderManager} from "../vscode-objs/WorkspaceFolderManager";
+import {Mutex} from "../locking";
 
 export class BundleWatcher implements Disposable {
     private disposables: Disposable[] = [];
@@ -19,15 +26,24 @@ export class BundleWatcher implements Disposable {
     public readonly onDidDelete = this._onDidDelete.event;
 
     private initCleanup: Disposable;
+    // Watchers for include files that resolve outside the active project root.
+    // Tracked separately so they can be rebuilt when the include list changes
+    // without tearing down the main in-tree watcher.
+    private externalWatchersCleanup: Disposable | undefined;
+    // Serializes refreshExternalWatchers() so overlapping invocations (e.g. a
+    // burst of root-file changes) don't leak watchers or create duplicates.
+    private readonly externalWatchersMutex = new Mutex();
     constructor(
         private readonly bundleFileSet: BundleFileSet,
         private readonly workspaceFolderManager: WorkspaceFolderManager
     ) {
         this.initCleanup = this.init();
+        void this.refreshExternalWatchers();
         this.disposables.push(
             this.workspaceFolderManager.onDidChangeActiveProjectFolder(() => {
                 this.initCleanup.dispose();
                 this.initCleanup = this.init();
+                void this.refreshExternalWatchers();
                 this.bundleFileSet.bundleDataCache.invalidate();
             })
         );
@@ -61,6 +77,51 @@ export class BundleWatcher implements Disposable {
         };
     }
 
+    /**
+     * (Re)create watchers for include files that live outside the active
+     * project root. The default recursive watcher created in init() only
+     * observes files under the project root, so parent-folder includes
+     * (e.g. "../../shared/databricks-shared.yml") need dedicated watchers
+     * to keep the bundle cache and downstream models in sync.
+     */
+    private async refreshExternalWatchers() {
+        return this.externalWatchersMutex.synchronise(async () => {
+            this.externalWatchersCleanup?.dispose();
+            this.externalWatchersCleanup = undefined;
+
+            const targets =
+                await this.bundleFileSet.getExternalIncludeWatchTargets();
+            if (targets.length === 0) {
+                return;
+            }
+
+            const disposables: Disposable[] = [];
+            for (const {baseUri, pattern} of targets) {
+                const watcher = workspace.createFileSystemWatcher(
+                    new RelativePattern(baseUri, pattern)
+                );
+                disposables.push(
+                    watcher,
+                    watcher.onDidCreate((e) => {
+                        this.yamlFileChangeHandler(e, "CREATE");
+                    }),
+                    watcher.onDidChange((e) => {
+                        this.yamlFileChangeHandler(e, "CHANGE");
+                    }),
+                    watcher.onDidDelete((e) => {
+                        this.yamlFileChangeHandler(e, "DELETE");
+                    })
+                );
+            }
+
+            this.externalWatchersCleanup = {
+                dispose: () => {
+                    disposables.forEach((i) => i.dispose());
+                },
+            };
+        });
+    }
+
     private async yamlFileChangeHandler(
         e: Uri,
         type: "CREATE" | "CHANGE" | "DELETE"
@@ -74,6 +135,9 @@ export class BundleWatcher implements Disposable {
         // to provide additional granularity, we also fire an event when the root bundle file changes
         if (this.bundleFileSet.isRootBundleFile(e)) {
             this._onDidChangeRootFile.fire();
+            // The include list lives in the root file, so its set of external
+            // include locations may have changed. Rebuild those watchers.
+            void this.refreshExternalWatchers();
         }
         switch (type) {
             case "CREATE":
@@ -88,5 +152,6 @@ export class BundleWatcher implements Disposable {
     dispose() {
         this.disposables.forEach((i) => i.dispose());
         this.initCleanup.dispose();
+        this.externalWatchersCleanup?.dispose();
     }
 }
