@xuda.io/drive_module 1.1.1489 → 1.1.1491

package/index.mjs

@@ -19,11 +19,7 @@ import { Upload } from '@aws-sdk/lib-storage';
 
 console.log('Drive Module loaded...');
 
-global._conf = (
-  await import(path.join(process.env.XUDA_HOME, process.env.XUDA_CONFIG), {
-    with: { type: 'json' },
-  })
-).default;
+global._conf = (await import(path.join(process.env.XUDA_HOME, "common", "load_conf.mjs"))).loadConf();
 
 const _common = await import(path.join(process.env.XUDA_HOME, 'common', 'xuda_node_common.mjs'));
 const _utils = await import(path.join(process.env.XUDA_HOME, 'common', 'xuda-cpi-utils.mjs'));
@@ -102,8 +98,12 @@ export const get_drive_files = async (req) => {
 
     // The Starred view is flat — bookmarked items across ALL folders — so it
     // ignores the folder path; the normal listing scopes to the current folder.
+    // `recent` (the Recent view) and `global` (the ⌘K drive search) are flat
+    // the same way — cross-folder, no path scope.
     if (req.starred) {
       opt.selector.starred = true;
+    } else if (req.recent || req.global) {
+      // flat cross-folder listing
     } else if (file_path) {
       opt.selector.file_path = file_path;
     }
@@ -990,6 +990,351 @@ export const rename_drive_folder = async (req) => {
   }
 };
 
+// Move files/folders into another folder within the same drive. The user +
+// workspace drives store their hierarchy purely in CouchDB (file docs carry
+// file_path = parent dir; folder docs file_path = parent dir + folder_name;
+// the stored bytes are keyed by _id/bucket) — so a move is a metadata rewrite
+// with zero storage I/O. Folders move their ENTIRE subtree
+// (collect_folder_descendants + parent-path prefix rewrite). The studio drive
+// is filesystem-keyed (doc _id = fs path) and is not supported here yet.
+// req: { drive_type, app_id, uid, files_arr: [{ type, file_path }], dest_path }
+export const move_drive_files = async (req, job_id, headers) => {
+  try {
+    const { drive_type, app_id, uid, files_arr, dest_path } = req;
+    validate_drive_type(drive_type);
+
+    if (drive_type === 'studio') {
+      throw new Error('Moving items in the studio drive is not supported yet');
+    }
+    if (!Array.isArray(files_arr) || !files_arr.length) {
+      return { code: -400, data: 'error - files_arr must be a non-empty Array' };
+    }
+    if (typeof dest_path !== 'string' || !dest_path.startsWith('/')) {
+      return { code: -400, data: 'error - dest_path must be an absolute drive path' };
+    }
+
+    // Destination must be an existing folder (root always exists) — throws when missing.
+    if (dest_path !== '/') {
+      await get_drive_doc('directory', drive_type, app_id, uid, dest_path, headers);
+    }
+
+    // Existing names at the destination — refuse to silently overwrite.
+    const dest_children = await get_folder_files(uid, app_id, drive_type, dest_path);
+    const dest_names = new Set((dest_children || []).map((c) => c.name));
+
+    const conflicts = [];
+    const moving = [];
+    for (const item of files_arr) {
+      if (!item || !item.file_path) continue;
+      const item_name = path.basename(item.file_path);
+      // Already in the destination — a no-op, skip silently.
+      if (path.dirname(item.file_path) === dest_path) continue;
+      // A folder can't be moved into itself or its own subtree.
+      if (item.type === 'directory' && (dest_path === item.file_path || dest_path.startsWith(item.file_path + '/'))) {
+        throw new Error(`Cannot move "${item_name}" into itself`);
+      }
+      if (dest_names.has(item_name)) {
+        conflicts.push(item_name);
+        continue;
+      }
+      moving.push(item);
+    }
+    if (conflicts.length) {
+      return { code: -764, data: { error: 'name_conflict', conflicts } };
+    }
+    if (!moving.length) {
+      return { code: 200, data: { moved: 0 } };
+    }
+
+    const docs = [];
+    for (const item of moving) {
+      const doc = await get_drive_doc(item.type, drive_type, app_id, uid, item.file_path, headers);
+      if (item.type === 'directory') {
+        const old_full = path.join(doc.file_path, doc.folder_name);
+        const new_full = path.join(dest_path, doc.folder_name);
+        // Rewrite every descendant's parent-path prefix old_full → new_full.
+        // Collected BEFORE the bulk save, so the queries still see old paths.
+        const descendants = await collect_folder_descendants(uid, app_id, drive_type, old_full);
+        for (const entry of descendants) {
+          try {
+            const child = await get_drive_doc(entry.type, drive_type, app_id, uid, entry.file_path, headers);
+            if (child.file_path === old_full || child.file_path.startsWith(old_full + '/')) {
+              child.file_path = new_full + child.file_path.slice(old_full.length);
+              child.date_modified = Date.now();
+              docs.push(child);
+            }
+          } catch (error) {
+            // Skip unreadable descendants; the rest of the subtree still moves.
+          }
+        }
+      }
+      doc.file_path = dest_path;
+      doc.date_modified = Date.now();
+      docs.push(doc);
+    }
+
+    let app_id_save;
+    switch (drive_type) {
+      case 'workspace':
+        app_id_save = await _common.get_project_app_id(app_id);
+        break;
+      case 'user':
+        app_id_save = await get_account_default_project_id(uid);
+        break;
+      default:
+        break;
+    }
+    const save_ret = await db_module.sava_app_couch_bulk_docs(app_id_save, docs);
+    if (save_ret.code < 0) {
+      throw new Error(save_ret.data);
+    }
+
+    return { code: 200, data: { moved: moving.length, docs: docs.length } };
+  } catch (err) {
+    return { code: -200, data: err.message };
+  }
+};
+
+// ─── Trash (user + workspace drives) ─────────────────────────────────────────
+// Soft-delete with restore. Unlike delete_drive_files (stat=4 + storage purge),
+// trashing only marks docs: stat=4, deleted_ts, trash_root = the trashed item's
+// full path (every doc in a trashed folder subtree carries the SAME trash_root,
+// so restore/purge can address the whole batch), is_trash_root on the top doc
+// (what the Trash view lists). Bytes stay in the bucket until purge. The studio
+// drive is filesystem-backed (files would keep being served from disk) — not
+// supported; the UI keeps hard-delete there.
+
+const _trash_app_id = async (drive_type, app_id, uid) => {
+  if (drive_type === 'workspace') return await _common.get_project_app_id(app_id);
+  return await get_account_default_project_id(uid);
+};
+
+const _validate_trash_drive = (drive_type) => {
+  validate_drive_type(drive_type);
+  if (drive_type === 'studio') {
+    throw new Error('Trash is not supported for the studio drive');
+  }
+};
+
+// req: { drive_type, app_id, uid, files_arr: [{ type, file_path }] }
+export const trash_drive_files = async (req, job_id, headers) => {
+  try {
+    const { drive_type, app_id, uid, files_arr } = req;
+    _validate_trash_drive(drive_type);
+    if (!Array.isArray(files_arr) || !files_arr.length) {
+      return { code: -400, data: 'error - files_arr must be a non-empty Array' };
+    }
+
+    const now = Date.now();
+    const docs = [];
+    for (const item of files_arr) {
+      if (!item || !item.file_path) continue;
+      const doc = await get_drive_doc(item.type, drive_type, app_id, uid, item.file_path, headers);
+      const root_path = item.type === 'directory' ? path.join(doc.file_path, doc.folder_name) : path.join(doc.file_path, doc.originalname);
+      if (item.type === 'directory') {
+        const descendants = await collect_folder_descendants(uid, app_id, drive_type, root_path);
+        for (const entry of descendants) {
+          try {
+            const child = await get_drive_doc(entry.type, drive_type, app_id, uid, entry.file_path, headers);
+            child.stat = 4;
+            child.deleted_ts = now;
+            child.trash_root = root_path;
+            docs.push(child);
+          } catch (error) {
+            // Unreadable descendant — the rest of the subtree still trashes.
+          }
+        }
+      }
+      doc.stat = 4;
+      doc.deleted_ts = now;
+      doc.trash_root = root_path;
+      doc.is_trash_root = true;
+      docs.push(doc);
+    }
+
+    const app_id_save = await _trash_app_id(drive_type, app_id, uid);
+    const save_ret = await db_module.sava_app_couch_bulk_docs(app_id_save, docs);
+    if (save_ret.code < 0) throw new Error(save_ret.data);
+    return { code: 200, data: { trashed: docs.length } };
+  } catch (err) {
+    return { code: -200, data: err.message };
+  }
+};
+
+// Lists trash ROOTS (the items the user actually deleted, not every subtree doc).
+export const get_trashed_files = async (req) => {
+  try {
+    const { drive_type, app_id, uid } = req;
+    _validate_trash_drive(drive_type);
+    const app_id_q = await _trash_app_id(drive_type, app_id, uid);
+    const ret = await db_module.find_app_couch_query(app_id_q, {
+      selector: { docType: `${drive_type}_drive`, stat: 4, is_trash_root: true },
+      limit: 500,
+    });
+    const docs = ret?.data?.docs || ret?.docs || [];
+    const children = docs
+      .map((d) => ({
+        name: d.type === 'directory' ? d.folder_name : d.originalname,
+        type: d.type,
+        // Trash rows are addressed by their trash_root batch key.
+        file_path: d.trash_root,
+        trash_root: d.trash_root,
+        orig_path: d.file_path,
+        deleted_ts: d.deleted_ts,
+        date_created: d.date_created,
+        size: d.size ? (d.size < 1048576 ? (d.size / 1024).toFixed(1) + ' KB' : (d.size / 1048576).toFixed(1) + ' MB') : '',
+        sizeInBytes: d.size || 0,
+        tags: d.tags || [],
+        extension: d?.file_ext?.substr(1),
+        is_trashed: true,
+      }))
+      .sort((a, b) => (b.deleted_ts || 0) - (a.deleted_ts || 0));
+    return { code: 200, data: { file_path: '/', name: 'Trash', children } };
+  } catch (err) {
+    return { code: -200, data: err.message };
+  }
+};
+
+// req: { drive_type, app_id, uid, trash_roots: [paths] } — restores each batch.
+export const restore_trashed_files = async (req) => {
+  try {
+    const { drive_type, app_id, uid, trash_roots } = req;
+    _validate_trash_drive(drive_type);
+    if (!Array.isArray(trash_roots) || !trash_roots.length) {
+      return { code: -400, data: 'error - trash_roots must be a non-empty Array' };
+    }
+    const app_id_q = await _trash_app_id(drive_type, app_id, uid);
+    const ret = await db_module.find_app_couch_query(app_id_q, {
+      selector: { docType: `${drive_type}_drive`, stat: 4, trash_root: { $in: trash_roots } },
+      limit: 10000,
+    });
+    const docs = ret?.data?.docs || ret?.docs || [];
+    for (const doc of docs) {
+      doc.stat = 3;
+      delete doc.deleted_ts;
+      delete doc.trash_root;
+      delete doc.is_trash_root;
+    }
+    const save_ret = await db_module.sava_app_couch_bulk_docs(app_id_q, docs);
+    if (save_ret.code < 0) throw new Error(save_ret.data);
+    return { code: 200, data: { restored: docs.length } };
+  } catch (err) {
+    return { code: -200, data: err.message };
+  }
+};
+
+// req: { drive_type, app_id, uid, trash_roots: [paths] } — permanently removes
+// the batches: docs stay as stat=4 tombstones (same as delete_drive_files) but
+// lose their trash markers, and the stored bytes are cleaned up best-effort.
+export const purge_trashed_files = async (req) => {
+  try {
+    const { drive_type, app_id, uid, trash_roots } = req;
+    _validate_trash_drive(drive_type);
+    if (!Array.isArray(trash_roots) || !trash_roots.length) {
+      return { code: -400, data: 'error - trash_roots must be a non-empty Array' };
+    }
+    const app_id_q = await _trash_app_id(drive_type, app_id, uid);
+    const ret = await db_module.find_app_couch_query(app_id_q, {
+      selector: { docType: `${drive_type}_drive`, stat: 4, trash_root: { $in: trash_roots } },
+      limit: 10000,
+    });
+    const docs = ret?.data?.docs || ret?.docs || [];
+    for (const doc of docs) {
+      delete doc.trash_root;
+      delete doc.is_trash_root;
+    }
+    const save_ret = await db_module.sava_app_couch_bulk_docs(app_id_q, docs);
+    if (save_ret.code < 0) throw new Error(save_ret.data);
+
+    // Storage cleanup — mirrors delete_drive_files' deferred best-effort pass.
+    setTimeout(async () => {
+      for (const doc of docs) {
+        if (doc.type !== 'file') continue;
+        try {
+          if (doc.bucket) {
+            await delete_file_from_bucket(doc.bucket);
+          } else if (drive_type === 'workspace') {
+            const { data: app_obj } = await db_module.get_app_obj(app_id);
+            if (app_obj?.app_type === 'datacenter') {
+              const host = `root@${app_obj.app_hosting_server.ip}`;
+              await _utils.run_ssh_script(`ssh ${host} "mv /var/xuda/workspace_drive/${doc.server_file_name} /tmp/;" `);
+            }
+          }
+        } catch (error) {}
+      }
+    }, 1000);
+
+    return { code: 200, data: { purged: docs.length } };
+  } catch (err) {
+    return { code: -200, data: err.message };
+  }
+};
+
+// ─── Storage breakdown + duplicate finder (user + workspace) ─────────────────
+// One Mango sweep over the drive's file docs → totals by category + duplicate
+// groups (same name + same byte size), largest waste first.
+export const get_drive_breakdown = async (req) => {
+  try {
+    const { drive_type, app_id, uid } = req;
+    validate_drive_type(drive_type);
+    if (drive_type === 'studio') {
+      return { code: -400, data: 'Breakdown is not supported for the studio drive yet' };
+    }
+    const app_id_q = await _trash_app_id(drive_type, app_id, uid);
+    const ret = await db_module.find_app_couch_query(app_id_q, {
+      selector: { docType: `${drive_type}_drive`, stat: 3, type: 'file' },
+      fields: ['originalname', 'size', 'file_ext', 'mime', 'file_path'],
+      limit: 50000,
+    });
+    const docs = ret?.data?.docs || ret?.docs || [];
+
+    const cat_of = (d) => {
+      const mime = d.mime || '';
+      const ext = (d.file_ext || '').replace('.', '').toLowerCase();
+      if (mime.startsWith('image/') || ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'tiff', 'psd'].includes(ext)) return 'images';
+      if (mime.startsWith('video/') || ['mp4', 'mov', 'avi', 'webm'].includes(ext)) return 'video';
+      if (mime.startsWith('audio/') || ['mp3', 'wav', 'ogg', 'flac'].includes(ext)) return 'audio';
+      if (['pdf', 'doc', 'docx', 'txt', 'md', 'xls', 'xlsx', 'csv', 'ppt', 'pptx', 'plist'].includes(ext)) return 'documents';
+      if (['zip', 'rar', '7z', 'tar', 'gz'].includes(ext)) return 'archives';
+      if (['js', 'html', 'css', 'json', 'ts', 'vue', 'py'].includes(ext)) return 'code';
+      return 'other';
+    };
+
+    const by_type = {};
+    const groups = {};
+    let total = 0;
+    for (const d of docs) {
+      const size = d.size || 0;
+      total += size;
+      const cat = cat_of(d);
+      if (!by_type[cat]) by_type[cat] = { type: cat, bytes: 0, count: 0 };
+      by_type[cat].bytes += size;
+      by_type[cat].count++;
+      const key = (d.originalname || '') + '|' + size;
+      if (!groups[key]) groups[key] = { name: d.originalname, size, count: 0, paths: [] };
+      groups[key].count++;
+      groups[key].paths.push(path.join(d.file_path || '/', d.originalname || ''));
+    }
+    const duplicates = Object.values(groups)
+      .filter((g) => g.count > 1 && g.size > 0)
+      .map((g) => ({ ...g, wasted: g.size * (g.count - 1) }))
+      .sort((a, b) => b.wasted - a.wasted)
+      .slice(0, 20);
+
+    return {
+      code: 200,
+      data: {
+        total,
+        count: docs.length,
+        by_type: Object.values(by_type).sort((a, b) => b.bytes - a.bytes),
+        duplicates,
+      },
+    };
+  } catch (err) {
+    return { code: -200, data: err.message };
+  }
+};
+
 export const update_drive_file_sharing_mode = async (req, job_id, headers) => {
   try {
     const { type, drive_type, uid, app_id, file_path, is_public } = req;
@@ -3238,6 +3583,80 @@ export const star_drive_file_user = async (req, job_id, headers, file_obj) => {
   return await star_drive_file(req, job_id, headers, file_obj);
 };
 
+export const move_drive_files_workspace = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'workspace';
+  return await move_drive_files(req, job_id, headers, file_obj);
+};
+export const move_drive_files_studio = _common.location_sensitive(async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'studio';
+  return await move_drive_files(req, job_id, headers, file_obj);
+});
+export const move_drive_files_user = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'user';
+  if (!req.uid && req.token_ret?.data?.uid) req.uid = req.token_ret.data.uid; // user-drive ops resolve the project from the authenticated uid
+  return await move_drive_files(req, job_id, headers, file_obj);
+};
+
+export const get_drive_size_workspace = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'workspace';
+  return await get_drive_size(req, job_id, headers, file_obj);
+};
+export const get_drive_size_studio = _common.location_sensitive(async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'studio';
+  return await get_drive_size(req, job_id, headers, file_obj);
+});
+export const get_drive_size_user = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'user';
+  if (!req.uid && req.token_ret?.data?.uid) req.uid = req.token_ret.data.uid; // user-drive ops resolve the project from the authenticated uid
+  return await get_drive_size(req, job_id, headers, file_obj);
+};
+
+export const trash_drive_files_workspace = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'workspace';
+  return await trash_drive_files(req, job_id, headers, file_obj);
+};
+export const trash_drive_files_user = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'user';
+  if (!req.uid && req.token_ret?.data?.uid) req.uid = req.token_ret.data.uid;
+  return await trash_drive_files(req, job_id, headers, file_obj);
+};
+export const get_trashed_files_workspace = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'workspace';
+  return await get_trashed_files(req, job_id, headers, file_obj);
+};
+export const get_trashed_files_user = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'user';
+  if (!req.uid && req.token_ret?.data?.uid) req.uid = req.token_ret.data.uid;
+  return await get_trashed_files(req, job_id, headers, file_obj);
+};
+export const restore_trashed_files_workspace = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'workspace';
+  return await restore_trashed_files(req, job_id, headers, file_obj);
+};
+export const restore_trashed_files_user = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'user';
+  if (!req.uid && req.token_ret?.data?.uid) req.uid = req.token_ret.data.uid;
+  return await restore_trashed_files(req, job_id, headers, file_obj);
+};
+export const purge_trashed_files_workspace = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'workspace';
+  return await purge_trashed_files(req, job_id, headers, file_obj);
+};
+export const purge_trashed_files_user = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'user';
+  if (!req.uid && req.token_ret?.data?.uid) req.uid = req.token_ret.data.uid;
+  return await purge_trashed_files(req, job_id, headers, file_obj);
+};
+export const get_drive_breakdown_workspace = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'workspace';
+  return await get_drive_breakdown(req, job_id, headers, file_obj);
+};
+export const get_drive_breakdown_user = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'user';
+  if (!req.uid && req.token_ret?.data?.uid) req.uid = req.token_ret.data.uid;
+  return await get_drive_breakdown(req, job_id, headers, file_obj);
+};
+
 export const delete_file_bulk_workspace = async (req, job_id, headers, file_obj) => {
   req.drive_type = 'workspace';
   return await delete_file_bulk(req, job_id, headers, file_obj);