fix(vscode): update local node paths after file moves

vscode/src/flydeEditor.ts

@@ -39,6 +39,7 @@ import { customCodeNodeFromCode } from "@flyde/core/dist/misc/custom-code-node-f
 import { createAiCompletion } from "./ai";
 import { getAvailableSecrets, addNewSecret, getSecrets } from "./secretsService";
 import { createNodeFinderWithOverrides } from "./createNodeFinderWithOverrides";
+import { updateFileReferencesOnRename } from "./update-file-references-on-rename";
 
 // Helper functions
 // export type EditorPortType = keyof any;
@@ -105,7 +106,44 @@ export class FlydeEditorEditorProvider
       provider
     );
 
-    return providerRegistration;
+    const renameSubscription = vscode.workspace.onDidRenameFiles(async (event) => {
+      const renamedFiles = event.files.map((file) => ({
+        oldPath: file.oldUri.fsPath,
+        newPath: file.newUri.fsPath,
+      }));
+      const flowFiles = await vscode.workspace.findFiles(
+        "**/*.flyde",
+        "**/{node_modules,.git}/**"
+      );
+      const edit = new vscode.WorkspaceEdit();
+
+      for (const flowUri of flowFiles) {
+        const document = await vscode.workspace.openTextDocument(flowUri);
+        try {
+          const flow = deserializeFlow(document.getText(), flowUri.fsPath);
+          if (!updateFileReferencesOnRename(flow, flowUri.fsPath, renamedFiles)) {
+            continue;
+          }
+
+          edit.replace(
+            flowUri,
+            new vscode.Range(
+              document.positionAt(0),
+              document.positionAt(document.getText().length)
+            ),
+            serializeFlow(flow)
+          );
+        } catch (error) {
+          console.warn(`Skipping ${flowUri.fsPath} while updating moved imports`, error);
+        }
+      }
+
+      if (edit.size > 0) {
+        await vscode.workspace.applyEdit(edit);
+      }
+    });
+
+    return vscode.Disposable.from(providerRegistration, renameSubscription);
   }
 
   private static readonly viewType = "flydeEditor";

vscode/src/update-file-references-on-rename.spec.ts

@@ -0,0 +1,79 @@
+import assert = require("assert");
+import * as path from "path";
+import { FlydeFlow } from "@flyde/core";
+import { updateFileReferencesOnRename } from "./update-file-references-on-rename";
+
+describe("updateFileReferencesOnRename", () => {
+  it("updates a local reference when its source file is moved", () => {
+    const flow: FlydeFlow = {
+      imports: {},
+      node: {
+        id: "Consumer",
+        inputs: {},
+        inputsPosition: {},
+        outputs: {},
+        outputsPosition: {},
+        instances: [
+          {
+            id: "producer",
+            type: "visual",
+            nodeId: "Producer",
+            source: { type: "file", data: "./Producer.flyde" },
+            inputConfig: {},
+            pos: { x: 0, y: 0 },
+          },
+        ],
+        connections: [],
+      },
+    };
+    const workspace = path.resolve("workspace");
+    const consumerPath = path.join(workspace, "flows", "Consumer.flyde");
+    const oldProducerPath = path.join(workspace, "flows", "Producer.flyde");
+    const newProducerPath = path.join(workspace, "shared", "Producer.flyde");
+
+    const changed = updateFileReferencesOnRename(
+      flow,
+      consumerPath,
+      [{
+        oldPath: oldProducerPath,
+        newPath: newProducerPath,
+      }]
+    );
+
+    assert.strictEqual(changed, true);
+    const source = flow.node.instances[0].source;
+    assert.strictEqual(source.type, "file");
+    assert.strictEqual(source.data, path.relative(path.dirname(consumerPath), newProducerPath));
+  });
+
+  it("does not change package references", () => {
+    const flow: FlydeFlow = {
+      imports: {},
+      node: {
+        id: "Consumer",
+        inputs: {},
+        inputsPosition: {},
+        outputs: {},
+        outputsPosition: {},
+        instances: [
+          {
+            id: "node",
+            type: "code",
+            nodeId: "Add",
+            source: { type: "package", data: "@flyde/nodes" },
+            config: {},
+            inputConfig: {},
+            pos: { x: 0, y: 0 },
+          },
+        ],
+        connections: [],
+      },
+    };
+
+    const changed = updateFileReferencesOnRename(flow, "/workspace/Consumer.flyde", [
+      { oldPath: "/workspace/Producer.flyde", newPath: "/workspace/Other.flyde" },
+    ]);
+
+    assert.strictEqual(changed, false);
+  });
+});

vscode/src/update-file-references-on-rename.ts

@@ -0,0 +1,49 @@
+import * as path from "path";
+
+import { FlydeFlow, NodeInstance, VisualNode } from "@flyde/core";
+
+/**
+ * Updates local node sources after a file was renamed or moved.
+ *
+ * File sources are stored relative to the flow containing the instance, so
+ * comparing absolute paths lets the same move be handled from every flow.
+ */
+export function updateFileReferencesOnRename(
+  flow: FlydeFlow,
+  flowPath: string,
+  renamedFiles: ReadonlyArray<{ oldPath: string; newPath: string }>
+): boolean {
+  let changed = false;
+
+  const updateNode = (node: VisualNode) => {
+    for (const instance of node.instances) {
+      updateInstance(instance);
+    }
+  };
+
+  const updateInstance = (instance: NodeInstance) => {
+    if (instance.source.type === "inline") {
+      updateNode(instance.source.data);
+      return;
+    }
+
+    if (instance.source.type !== "file") {
+      return;
+    }
+
+    const currentPath = path.resolve(path.dirname(flowPath), instance.source.data);
+    const renamedFile = renamedFiles.find(
+      ({ oldPath }) => path.normalize(oldPath) === path.normalize(currentPath)
+    );
+
+    if (!renamedFile) {
+      return;
+    }
+
+    instance.source.data = path.relative(path.dirname(flowPath), renamedFile.newPath);
+    changed = true;
+  };
+
+  updateNode(flow.node);
+  return changed;
+}