@noya-app/noya-file-explorer 0.0.2

package/src/__tests__/moveMediaInsideFolder.test.ts

@@ -0,0 +1,348 @@
+import { MediaMap } from "@noya-app/noya-schemas";
+import { expect, it } from "bun:test";
+import { moveMediaInsideFolder } from "../utils/files";
+import {
+  createMediaAsset,
+  createMediaFolder,
+  createMediaItemTree,
+  rootMediaItem,
+} from "../utils/mediaItemTree";
+
+it("should move an item into a target folder", () => {
+  // Create a folder structure:
+  // Root
+  // ├── Folder 1
+  // └── Asset 1
+  const folder1 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+  const media: MediaMap = {
+    folder1,
+    asset1,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Move Asset 1 into Folder 1
+  const result = moveMediaInsideFolder({
+    sourceItemIds: [asset1.id],
+    targetItemId: folder1.id,
+    media,
+    tree,
+  });
+
+  // Asset 1 should now have Folder 1 as its parent
+  const movedAsset = result["folder1/asset1"];
+  expect(movedAsset).toEqual(asset1);
+
+  // Folder 1 should remain unchanged
+  const folder = result["folder1"];
+  expect(folder).toEqual(folder1);
+});
+
+it("should move an item to the root level", () => {
+  // Create a folder structure:
+  // Root
+  // └── Folder 1
+  //     └── Asset 1
+  const folder1 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+  const media: MediaMap = {
+    folder1,
+    "folder1/asset1": asset1,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Move Asset 1 to root
+  const result = moveMediaInsideFolder({
+    sourceItemIds: [asset1.id],
+    targetItemId: rootMediaItem.id,
+    media,
+    tree,
+  });
+
+  // Asset 1 should now have undefined as its parentId (root)
+  const movedAsset = result["asset1"];
+  expect(movedAsset).toEqual(asset1);
+  const oldAssetKey = "folder1/asset1";
+  expect(result[oldAssetKey]).toBeUndefined();
+});
+
+it("should move a folder into another folder", () => {
+  // Create a folder structure:
+  // Root
+  // ├── Folder 1
+  // └── Folder 2
+  const folder1 = createMediaFolder();
+  const folder2 = createMediaFolder();
+  const media: MediaMap = {
+    folder1,
+    folder2,
+  };
+  const tree = createMediaItemTree(media);
+  // Move Folder 2 into Folder 1
+  const result = moveMediaInsideFolder({
+    sourceItemIds: [folder2.id],
+    targetItemId: folder1.id,
+    media,
+    tree,
+  });
+
+  // Folder 2 should now have Folder 1 as its parent
+  const movedFolder = result["folder1/folder2"];
+  expect(movedFolder).toEqual(folder2);
+  const oldFolderKey = "folder2";
+  expect(result[oldFolderKey]).toBeUndefined();
+
+  // Folder 1 should remain unchanged
+  const folder = result["folder1"];
+  expect(folder).toEqual(folder1);
+});
+
+it("should not modify other items in the array", () => {
+  // Create a folder structure:
+  // Root
+  // ├── Folder 1
+  // ├── Folder 2
+  // └── Asset 1
+  const folder1 = createMediaFolder();
+  const folder2 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+  const media: MediaMap = {
+    folder1,
+    folder2,
+    asset1,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Move Asset 1 into Folder 1
+  const result = moveMediaInsideFolder({
+    sourceItemIds: [asset1.id],
+    targetItemId: folder1.id,
+    media,
+    tree,
+  });
+
+  // Only Asset 1 should be modified
+  expect(result["folder1"]).toEqual(folder1);
+  expect(result["folder2"]).toEqual(folder2);
+  const movedAsset = result["folder1/asset1"];
+  expect(movedAsset).toEqual(asset1);
+  const oldAssetKey = "asset1";
+  expect(result[oldAssetKey]).toBeUndefined();
+});
+
+it("should handle moving an item that doesn't exist", () => {
+  const folder1 = createMediaFolder();
+  const media: MediaMap = {
+    folder1,
+  };
+  const tree = createMediaItemTree(media);
+  // Try to move a non-existent item
+  const result = moveMediaInsideFolder({
+    sourceItemIds: ["nonexistent"],
+    targetItemId: folder1.id,
+    media,
+    tree,
+  });
+
+  // The result should be the same as the input
+  expect(result).toEqual(media);
+});
+
+it("should handle moving to a target that doesn't exist", () => {
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+  const media: MediaMap = {
+    asset1,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Try to move to a non-existent folder
+  const result = moveMediaInsideFolder({
+    sourceItemIds: [asset1.id],
+    targetItemId: "nonexistent",
+    media,
+    tree,
+  });
+
+  // The item should still be moved to the specified target
+  const movedAsset = result["nonexistent/asset1"];
+  expect(movedAsset).toBeUndefined();
+});
+
+it("should move a folder and all its descendants into another folder", () => {
+  // Create a nested folder structure:
+  // Root
+  // ├── Folder 1
+  // └── Folder 2
+  //     └── Folder 3
+  //         └── Asset 1
+  const folder1 = createMediaFolder();
+  const folder2 = createMediaFolder();
+  const folder3 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+  const media: MediaMap = {
+    folder1,
+    folder2,
+    "folder2/folder3": folder3,
+    "folder2/folder3/asset1": asset1,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Move Folder 2 (and its descendants) into Folder 1
+  const result = moveMediaInsideFolder({
+    sourceItemIds: [folder2.id],
+    targetItemId: folder1.id,
+    media,
+    tree,
+  });
+
+  // Folder 2 should now be inside Folder 1
+  expect(result["folder1/folder2"]).toEqual(folder2);
+
+  // Asset 1 should be inside Folder 3, which is inside Folder 2, which is inside Folder 1
+  expect(result["folder1/folder2/folder3/asset1"]).toEqual(asset1);
+
+  // Original paths should be removed
+  expect(result["folder2"]).toBeUndefined();
+  expect(result["folder2/asset1"]).toBeUndefined();
+
+  // Folder 1 should remain unchanged
+  expect(result["folder1"]).toEqual(folder1);
+});
+
+it("should move a folder and all its descendants to the root", () => {
+  // Create a nested folder structure:
+  // Root
+  // └── Folder 1
+  //     └── Folder 2
+  //         └── Asset 1
+  const folder1 = createMediaFolder();
+  const folder2 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+  const media: MediaMap = {
+    folder1,
+    "folder1/folder2": folder2,
+    "folder1/folder2/asset1": asset1,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Move Folder 2 (and its descendants) to the root
+  const result = moveMediaInsideFolder({
+    sourceItemIds: [folder2.id],
+    targetItemId: rootMediaItem.id,
+    media,
+    tree,
+  });
+
+  // Folder 2 should now be at the root
+  expect(result["folder2"]).toEqual(folder2);
+
+  // Asset 1 should be inside Folder 2 at the root
+  expect(result["folder2/asset1"]).toEqual(asset1);
+
+  // Original paths should be removed
+  expect(result["folder1/folder2"]).toBeUndefined();
+  expect(result["folder1/folder2/asset1"]).toBeUndefined();
+
+  // Folder 1 should remain unchanged
+  expect(result["folder1"]).toEqual(folder1);
+});
+
+it("should preserve the structure when moving a folder with multiple levels of nesting", () => {
+  // Create a deeply nested folder structure:
+  // Root
+  // ├── Target Folder
+  // └── Source Folder
+  //     └── Level 1
+  //         └── Level 2
+  //             └── Asset 1
+  const targetFolder = createMediaFolder();
+  const sourceFolder = createMediaFolder();
+  const level1 = createMediaFolder();
+  const level2 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+  const media: MediaMap = {
+    targetFolder,
+    sourceFolder,
+    "sourceFolder/level1": level1,
+    "sourceFolder/level1/level2": level2,
+    "sourceFolder/level1/level2/asset1": asset1,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Move the source folder to the target folder
+  const result = moveMediaInsideFolder({
+    sourceItemIds: [sourceFolder.id],
+    targetItemId: targetFolder.id,
+    media,
+    tree,
+  });
+
+  // The entire structure should be preserved but moved under the target folder
+  expect(result["targetFolder/sourceFolder"]).toEqual(sourceFolder);
+  expect(result["targetFolder/sourceFolder/level1"]).toEqual(level1);
+  expect(result["targetFolder/sourceFolder/level1/level2"]).toEqual(level2);
+  expect(result["targetFolder/sourceFolder/level1/level2/asset1"]).toEqual(
+    asset1
+  );
+
+  // Original paths should be removed
+  expect(result["sourceFolder"]).toBeUndefined();
+  expect(result["sourceFolder/level1"]).toBeUndefined();
+  expect(result["sourceFolder/level1/level2"]).toBeUndefined();
+  expect(result["sourceFolder/level1/level2/asset1"]).toBeUndefined();
+
+  // Target folder should remain unchanged
+  expect(result["targetFolder"]).toEqual(targetFolder);
+});
+
+it("should handle moving both a sibling item and a folder to another folder", () => {
+  // Create a folder structure:
+  // Root
+  // ├── Folder 1
+  // └── Folder 2
+  //     └── Asset 1
+  //     └── Folder 3
+  //  └── Asset 2
+  const folder1 = createMediaFolder();
+  const folder2 = createMediaFolder();
+  const folder3 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+  const asset2 = createMediaAsset({
+    assetId: "asset2",
+  });
+  const media: MediaMap = {
+    folder1,
+    folder2,
+    "folder2/asset1": asset1,
+    "folder2/folder3": folder3,
+    asset2: asset2,
+  };
+  const tree = createMediaItemTree(media);
+  //    move folder 3 and asset 1 to folder 1
+  const result = moveMediaInsideFolder({
+    sourceItemIds: [folder3.id, asset1.id],
+    targetItemId: folder1.id,
+    media,
+    tree,
+  });
+  expect(result["folder1/folder3"]).toEqual(folder3);
+  expect(result["folder1/asset1"]).toEqual(asset1);
+  expect(result["folder2"]).toEqual(folder2);
+  expect(result["folder2/asset1"]).toBeUndefined();
+});

package/src/__tests__/movePathsIntoTarget.test.ts

@@ -0,0 +1,229 @@
+import { MediaMap } from "@noya-app/noya-schemas";
+import { expect, it } from "bun:test";
+import { movePathsIntoTarget } from "../utils/files";
+import {
+  createMediaAsset,
+  createMediaFolder,
+  createMediaItemTree,
+} from "../utils/mediaItemTree";
+
+it("should move a single file to a target directory", () => {
+  // Setup
+  const file1 = createMediaAsset({ assetId: "1" });
+  const targetFolder = createMediaFolder();
+  const media: MediaMap = {
+    "file1.jpg": file1,
+    target: targetFolder,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Execute
+  const result = movePathsIntoTarget({
+    media: media,
+    sourceItemPaths: ["file1.jpg"],
+    targetItemPath: "target",
+    tree,
+  });
+
+  // Verify
+  expect(result["file1.jpg"]).toBeUndefined();
+  expect(result["target/file1.jpg"]).toEqual(file1);
+  expect(result["target"]).toEqual(targetFolder);
+});
+
+it("should move a folder and its contents to a target directory", () => {
+  // Setup
+  const sourceFolder = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+  const file2 = createMediaAsset({ assetId: "2" });
+  const targetFolder = createMediaFolder();
+
+  const media: MediaMap = {
+    source: sourceFolder,
+    "source/file1.jpg": file1,
+    "source/file2.jpg": file2,
+    target: targetFolder,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Execute
+  const result = movePathsIntoTarget({
+    media: media,
+    sourceItemPaths: ["source"],
+    targetItemPath: "target",
+    tree,
+  });
+
+  // Verify
+  expect(result["source"]).toBeUndefined();
+  expect(result["source/file1.jpg"]).toBeUndefined();
+  expect(result["source/file2.jpg"]).toBeUndefined();
+  expect(result["target"]).toEqual(targetFolder);
+  expect(result["target/source"]).toEqual(sourceFolder);
+  expect(result["target/source/file1.jpg"]).toEqual(file1);
+  expect(result["target/source/file2.jpg"]).toEqual(file2);
+});
+
+it("should move multiple items to a target directory", () => {
+  // Setup
+  const file1 = createMediaAsset({ assetId: "1" });
+  const file2 = createMediaAsset({ assetId: "2" });
+  const targetFolder = createMediaFolder();
+
+  const media: MediaMap = {
+    "file1.jpg": file1,
+    "file2.jpg": file2,
+    target: targetFolder,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Execute
+  const result = movePathsIntoTarget({
+    media: media,
+    sourceItemPaths: ["file1.jpg", "file2.jpg"],
+    targetItemPath: "target",
+    tree,
+  });
+
+  // Verify
+  expect(result["file1.jpg"]).toBeUndefined();
+  expect(result["file2.jpg"]).toBeUndefined();
+  expect(result["target"]).toEqual(targetFolder);
+  expect(result["target/file1.jpg"]).toEqual(file1);
+  expect(result["target/file2.jpg"]).toEqual(file2);
+});
+
+it("should handle nested folder structures correctly", () => {
+  // Setup
+  const folder1 = createMediaFolder();
+  const folder2 = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+  const file2 = createMediaAsset({ assetId: "2" });
+  const targetFolder = createMediaFolder();
+
+  const media: MediaMap = {
+    folder1: folder1,
+    "folder1/folder2": folder2,
+    "folder1/folder2/file1.jpg": file1,
+    "folder1/file2.jpg": file2,
+    target: targetFolder,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Execute
+  const result = movePathsIntoTarget({
+    media: media,
+    sourceItemPaths: ["folder1"],
+    targetItemPath: "target",
+    tree,
+  });
+
+  // Verify
+  expect(result["folder1"]).toBeUndefined();
+  expect(result["folder1/folder2"]).toBeUndefined();
+  expect(result["folder1/folder2/file1.jpg"]).toBeUndefined();
+  expect(result["folder1/file2.jpg"]).toBeUndefined();
+  expect(result["target"]).toEqual(targetFolder);
+  expect(result["target/folder1"]).toEqual(folder1);
+  expect(result["target/folder1/folder2"]).toEqual(folder2);
+  expect(result["target/folder1/folder2/file1.jpg"]).toEqual(file1);
+  expect(result["target/folder1/file2.jpg"]).toEqual(file2);
+});
+
+it("should handle moving items to the root directory", () => {
+  // Setup
+  const folder = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+
+  const media: MediaMap = {
+    folder: folder,
+    "folder/file1.jpg": file1,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Execute
+  const result = movePathsIntoTarget({
+    media: media,
+    sourceItemPaths: ["folder/file1.jpg"],
+    targetItemPath: ".",
+    tree,
+  });
+
+  // Verify
+  expect(result["folder"]).toEqual(folder);
+  expect(result["folder/file1.jpg"]).toBeUndefined();
+  expect(result["file1.jpg"]).toEqual(file1);
+});
+
+it("should handle moving items with the same basename", () => {
+  // Setup
+  const folder1 = createMediaFolder();
+  const folder2 = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+  const file2 = createMediaAsset({ assetId: "2" });
+
+  const media: MediaMap = {
+    folder1: folder1,
+    "folder1/file.jpg": file1,
+    folder2: folder2,
+    "folder2/file.jpg": file2,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Execute
+  const result = movePathsIntoTarget({
+    media: media,
+    sourceItemPaths: ["folder1/file.jpg", "folder2/file.jpg"],
+    targetItemPath: ".",
+    tree,
+  });
+
+  // Verify - the second file should overwrite the first one with the same name
+  expect(result["folder1"]).toEqual(folder1);
+  expect(result["folder2"]).toEqual(folder2);
+  expect(result["folder1/file.jpg"]).toBeUndefined();
+  expect(result["folder2/file.jpg"]).toBeUndefined();
+  expect(result["file.jpg"]).toEqual(file2); // Last one wins
+});
+
+it("should handle empty source paths array", () => {
+  // Setup
+  const targetFolder = createMediaFolder();
+
+  const media: MediaMap = {
+    target: targetFolder,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Execute
+  const result = movePathsIntoTarget({
+    media: media,
+    sourceItemPaths: [],
+    targetItemPath: "target",
+    tree,
+  });
+
+  // Verify nothing changed
+  expect(result).toEqual(media);
+});
+
+it("should handle non-existent source paths", () => {
+  // Setup
+  const targetFolder = createMediaFolder();
+
+  const media: MediaMap = {
+    target: targetFolder,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Execute
+  const result = movePathsIntoTarget({
+    media: media,
+    sourceItemPaths: ["non-existent.jpg"],
+    targetItemPath: "target",
+    tree,
+  });
+
+  // Verify nothing changed
+  expect(result).toEqual(media);
+});