Add folder delete and rename behavior (#355)

* Add folder delete and rename behavior

* Remove unused files state

* Fix lint warnings

Author: benjreinhart

packages/api/apps/disk.mts

@@ -1,3 +1,4 @@
+import type { RmOptions } from 'node:fs';
 import fs from 'node:fs/promises';
 import Path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -152,6 +153,19 @@ export async function createDirectory(
   };
 }
 
+export function deleteDirectory(app: DBAppType, path: string) {
+  return deleteEntry(app, path, { recursive: true, force: true });
+}
+
+export async function renameDirectory(
+  app: DBAppType,
+  path: string,
+  name: string,
+): Promise<DirEntryType> {
+  const result = await rename(app, path, name);
+  return { ...result, type: 'directory' as const, children: null };
+}
+
 export async function loadFile(app: DBAppType, path: string): Promise<FileType> {
   const projectDir = Path.join(APPS_DIR, app.externalId);
   const filePath = Path.join(projectDir, path);
@@ -184,29 +198,32 @@ export async function createFile(
 }
 
 export function deleteFile(app: DBAppType, path: string) {
-  const filePath = Path.join(APPS_DIR, app.externalId, path);
-  return fs.rm(filePath);
+  return deleteEntry(app, path);
 }
 
 export async function renameFile(
   app: DBAppType,
   path: string,
   name: string,
 ): Promise<FileEntryType> {
+  const result = await rename(app, path, name);
+  return { ...result, type: 'file' as const };
+}
+
+async function rename(app: DBAppType, path: string, name: string) {
   const projectDir = Path.join(APPS_DIR, app.externalId);
   const oldPath = Path.join(projectDir, path);
   const dirname = Path.dirname(oldPath);
   const newPath = Path.join(dirname, name);
   await fs.rename(oldPath, newPath);
-
   const relativePath = Path.relative(projectDir, newPath);
   const basename = Path.basename(newPath);
+  return { name: basename, path: relativePath };
+}
 
-  return {
-    type: 'file' as const,
-    name: basename,
-    path: relativePath,
-  };
+function deleteEntry(app: DBAppType, path: string, options: RmOptions = {}) {
+  const filePath = Path.join(APPS_DIR, app.externalId, path);
+  return fs.rm(filePath, options);
 }
 
 // TODO: This does not scale.

packages/api/server/http.mts

@@ -42,6 +42,8 @@ import {
   loadFile,
   createFile,
   createDirectory,
+  renameDirectory,
+  deleteDirectory,
 } from '../apps/disk.mjs';
 import { CreateAppSchema } from '../apps/schemas.mjs';
 
@@ -515,6 +517,51 @@ router.post('/apps/:id/directories', cors(), async (req, res) => {
   }
 });
 
+router.options('/apps/:id/directories', cors());
+router.delete('/apps/:id/directories', cors(), async (req, res) => {
+  const { id } = req.params;
+
+  // TODO: validate and ensure path is not absolute
+  const path = typeof req.query.path === 'string' ? req.query.path : '.';
+
+  try {
+    const app = await loadApp(id);
+
+    if (!app) {
+      return res.status(404).json({ error: 'App not found' });
+    }
+
+    await deleteDirectory(app, path);
+
+    return res.json({ data: { deleted: true } });
+  } catch (e) {
+    return error500(res, e as Error);
+  }
+});
+
+router.options('/apps/:id/directories/rename', cors());
+router.post('/apps/:id/directories/rename', cors(), async (req, res) => {
+  const { id } = req.params;
+
+  // TODO: validate and ensure path is not absolute
+  const path = typeof req.query.path === 'string' ? req.query.path : '.';
+  const name = req.query.name as string;
+
+  try {
+    const app = await loadApp(id);
+
+    if (!app) {
+      return res.status(404).json({ error: 'App not found' });
+    }
+
+    const directory = await renameDirectory(app, path, name);
+
+    return res.json({ data: directory });
+  } catch (e) {
+    return error500(res, e as Error);
+  }
+});
+
 router.options('/apps/:id/files', cors());
 router.get('/apps/:id/files', cors(), async (req, res) => {
   const { id } = req.params;

packages/web/src/clients/http/apps.ts

@@ -103,6 +103,45 @@ export async function createDirectory(
   return response.json();
 }
 
+export async function deleteDirectory(
+  id: string,
+  path: string,
+): Promise<{ data: { deleted: true } }> {
+  const queryParams = new URLSearchParams({ path });
+
+  const response = await fetch(API_BASE_URL + `/apps/${id}/directories?${queryParams}`, {
+    method: 'DELETE',
+    headers: { 'content-type': 'application/json' },
+  });
+
+  if (!response.ok) {
+    console.error(response);
+    throw new Error('Request failed');
+  }
+
+  return response.json();
+}
+
+export async function renameDirectory(
+  id: string,
+  path: string,
+  name: string,
+): Promise<{ data: DirEntryType }> {
+  const queryParams = new URLSearchParams({ path, name });
+
+  const response = await fetch(API_BASE_URL + `/apps/${id}/directories/rename?${queryParams}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+  });
+
+  if (!response.ok) {
+    console.error(response);
+    throw new Error('Request failed');
+  }
+
+  return response.json();
+}
+
 export async function loadFile(id: string, path: string): Promise<{ data: FileType }> {
   const queryParams = new URLSearchParams({ path });
 

packages/web/src/components/apps/lib/file-tree.ts

@@ -101,6 +101,44 @@ function merge(oldChildren: FsEntryTreeType | null, newChildren: FsEntryTreeType
   });
 }
 
+export function renameDirNode(
+  tree: DirEntryType,
+  oldNode: DirEntryType,
+  newNode: DirEntryType,
+): DirEntryType {
+  return sortTree(doRenameDirNode(tree, oldNode, newNode));
+}
+
+function doRenameDirNode(
+  tree: DirEntryType,
+  oldNode: DirEntryType,
+  newNode: DirEntryType,
+): DirEntryType {
+  const children =
+    tree.children === null
+      ? null
+      : tree.children.map((entry) => {
+          if (entry.type === 'directory') {
+            return doRenameDirNode(entry, oldNode, newNode);
+          } else {
+            if (entry.path.startsWith(oldNode.path)) {
+              return { ...entry, path: entry.path.replace(oldNode.path, newNode.path) };
+            } else {
+              return entry;
+            }
+          }
+        });
+
+  if (tree.path === oldNode.path) {
+    return { ...newNode, children };
+  } else if (tree.path.startsWith(oldNode.path)) {
+    const path = tree.path.replace(oldNode.path, newNode.path);
+    return { ...tree, path, children };
+  } else {
+    return { ...tree, children };
+  }
+}
+
 export function updateFileNode(
   tree: DirEntryType,
   oldNode: FileEntryType,