@xuda.io/drive_module 1.1.1496 → 1.1.1497

package/index.mjs

@@ -14,7 +14,7 @@ import { imageSize } from 'image-size';
 import { getPackageManifest } from 'query-registry';
 
 // AWS SDK v3 Imports
-import { S3Client, GetObjectCommand, DeleteObjectCommand, PutObjectCommand } from '@aws-sdk/client-s3';
+import { S3Client, GetObjectCommand, DeleteObjectCommand, PutObjectCommand, CopyObjectCommand } from '@aws-sdk/client-s3';
 import { Upload } from '@aws-sdk/lib-storage';
 
 console.log('Drive Module loaded...');
@@ -1095,6 +1095,240 @@ export const move_drive_files = async (req, job_id, headers) => {
   }
 };
 
+// ─── Copy (user + workspace drives) ──────────────────────────────────────────
+// Deep-copy files/folders into dest_path: every file gets a FRESH doc AND freshly
+// duplicated bytes, every folder gets a fresh doc plus a recursive copy of its whole
+// subtree, and names auto-dedupe at the destination. Studio is filesystem-backed and,
+// like move, not supported here yet.
+
+// Duplicate ONE source file's bytes and return the storage fields for the new doc
+// ({ bucket, server_file_name }). Single R2 namespace => a bucket copy is a server-side
+// CopyObject to a fresh UUID key (no download); datacenter/deployment workspace files
+// live on the box and are cp'd there.
+const _copy_file_storage = async (src_doc, drive_type, app_id, uid, ref, new_name) => {
+  const has_bucket = src_doc.bucket && Object.keys(src_doc.bucket).length;
+
+  // Workspace files on a datacenter / deployment box live on disk, not R2.
+  if (drive_type === 'workspace' && !has_bucket && src_doc.server_file_name) {
+    const { data: app_obj } = await db_module.get_app_obj(app_id);
+    let host = null;
+    if (app_obj?.app_type === 'datacenter') {
+      host = `root@${app_obj.app_hosting_server.ip}`;
+    } else if (app_obj?.is_deployment) {
+      const { data: datacenter_obj } = await db_module.get_app_obj(app_obj.app_datacenter_id);
+      host = `root@${datacenter_obj.app_hosting_server.ip}`;
+    }
+    const new_server_file_name = 'drv_' + ref + '_' + _utils.UUID() + path.extname(new_name).toLowerCase();
+    if (host) {
+      await _utils.run_ssh_script(`ssh ${host} "cp /var/xuda/workspace_drive/${src_doc.server_file_name} /var/xuda/workspace_drive/${new_server_file_name};"`);
+    }
+    return { bucket: {}, server_file_name: new_server_file_name };
+  }
+
+  // R2 is a single namespace now (copy_file_to_another_bucket is a documented no-op),
+  // so copy within the CURRENT region's bucket regardless of the source entry's stored
+  // region or Bucket name. The stored entry.Bucket can be a stale/legacy value R2 no
+  // longer knows, which is what threw "the specified bucket does not exist". CopyObject
+  // is server-side (no download/re-upload); one copy is enough for the shared namespace.
+  const region_host = process.env.XUDA_HOSTNAME;
+  const conf = _conf.storage_bucket?.[region_host];
+  const s3 = _drive_s3_for(region_host);
+  const bucket = {};
+  const src_entry = Object.values(src_doc.bucket || {}).find((e) => e?.Key || e?.key);
+  const src_key = src_entry?.Key || src_entry?.key;
+  if (s3 && conf && src_key) {
+    const Bucket = conf.name;
+    const new_key = path.join(region_host, drive_type, ref, _utils.UUID() + '_' + new_name);
+    await s3.send(
+      new CopyObjectCommand({
+        Bucket,
+        // Encode each key segment (spaces / unicode in filenames) but keep the slashes.
+        CopySource: `${Bucket}/${src_key.split('/').map(encodeURIComponent).join('/')}`,
+        Key: new_key,
+        ContentType: _drive_content_type_for(new_name),
+        MetadataDirective: 'COPY',
+      }),
+    );
+    bucket[region_host] = { Location: _public_url_for(region_host, new_key), Bucket, Key: new_key, key: new_key };
+  }
+  return { bucket, server_file_name: new_name };
+};
+
+// Fresh id for a copied doc. Files keep the drv_<ref>_<uuid><ext> shape (the ref is in
+// the id, which get_drive_doc's workspace auth check requires); folders match
+// create_drive_folder.
+const _copy_new_id = async (type, drive_type, ref, leaf_name) => {
+  if (type === 'directory') return 'drive_folder_' + _utils.UUID();
+  return 'drv_' + ref + '_' + (await _common.xuda_get_uuid(drive_type)) + path.extname(leaf_name).toLowerCase();
+};
+
+// Strip per-instance state that must NOT ride along on a copy (revision, trash/star,
+// share link) so the new doc is a clean, independent item.
+const _clean_copied_doc = (doc) => {
+  delete doc._rev;
+  delete doc.is_trash_root;
+  delete doc.trash_root;
+  delete doc.deleted_ts;
+  delete doc.starred;
+  delete doc.access_link;
+  delete doc.share_mode;
+  return doc;
+};
+
+// req: { drive_type, app_id, uid, files_arr: [{ type, file_path }], dest_path }
+export const copy_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('Copying 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).
+    if (dest_path !== '/') {
+      await get_drive_doc('directory', drive_type, app_id, uid, dest_path, headers);
+    }
+
+    const ref = drive_type === 'user' ? await get_account_default_project_id(uid) : await _common.get_project_app_id(app_id, true);
+
+    // Names auto-dedupe at the destination ("x" -> "x copy" -> "x copy 2"), so a copy
+    // into the SAME folder is a natural duplicate instead of a conflict.
+    const dest_children = await get_folder_files(uid, app_id, drive_type, dest_path);
+    const taken = new Set((dest_children || []).map((c) => c.name));
+    const uniq_name = (name) => {
+      if (!taken.has(name)) {
+        taken.add(name);
+        return name;
+      }
+      const ext = path.extname(name);
+      const base = ext ? name.slice(0, -ext.length) : name;
+      let n = 1;
+      let candidate;
+      do {
+        candidate = `${base} copy${n > 1 ? ' ' + n : ''}${ext}`;
+        n++;
+      } while (taken.has(candidate));
+      taken.add(candidate);
+      return candidate;
+    };
+
+    const out_docs = [];
+
+    for (const item of files_arr) {
+      if (!item || !item.file_path) continue;
+      // A folder can't be copied 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 copy "${path.basename(item.file_path)}" into itself`);
+      }
+
+      const src_doc = await get_drive_doc(item.type, drive_type, app_id, uid, item.file_path, headers);
+
+      if (item.type === 'directory') {
+        const leaf = uniq_name(src_doc.folder_name);
+        out_docs.push(
+          _clean_copied_doc({
+            ...src_doc,
+            _id: await _copy_new_id('directory', drive_type, ref, leaf),
+            folder_name: leaf,
+            file_path: dest_path,
+            date_created: Date.now(),
+            date_modified: 0,
+            stat: 3,
+          }),
+        );
+
+        // Re-parent every descendant onto the new subtree (path-prefix rewrite, same as
+        // move) with fresh ids + freshly duplicated bytes for files.
+        const old_full = path.join(src_doc.file_path, src_doc.folder_name);
+        const new_full = path.join(dest_path, leaf);
+        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 + '/')) continue;
+            const remapped_parent = new_full + child.file_path.slice(old_full.length);
+            if (child.type === 'directory') {
+              out_docs.push(
+                _clean_copied_doc({
+                  ...child,
+                  _id: await _copy_new_id('directory', drive_type, ref, child.folder_name),
+                  file_path: remapped_parent,
+                  date_created: Date.now(),
+                  date_modified: 0,
+                  stat: 3,
+                }),
+              );
+            } else {
+              const storage = await _copy_file_storage(child, drive_type, app_id, uid, ref, child.originalname);
+              out_docs.push(
+                _clean_copied_doc({
+                  ...child,
+                  _id: await _copy_new_id('file', drive_type, ref, child.originalname),
+                  file_path: remapped_parent,
+                  bucket: storage.bucket,
+                  server_file_name: storage.server_file_name,
+                  date_created: Date.now(),
+                  date_modified: 0,
+                  stat: 3,
+                }),
+              );
+            }
+          } catch (error) {
+            // Skip an unreadable descendant; the rest of the subtree still copies.
+          }
+        }
+      } else {
+        const leaf = uniq_name(src_doc.originalname);
+        const storage = await _copy_file_storage(src_doc, drive_type, app_id, uid, ref, leaf);
+        out_docs.push(
+          _clean_copied_doc({
+            ...src_doc,
+            _id: await _copy_new_id('file', drive_type, ref, leaf),
+            originalname: leaf,
+            file_path: dest_path,
+            bucket: storage.bucket,
+            server_file_name: storage.server_file_name,
+            date_created: Date.now(),
+            date_modified: 0,
+            stat: 3,
+          }),
+        );
+      }
+    }
+
+    if (!out_docs.length) {
+      return { code: 200, data: { copied: 0 } };
+    }
+
+    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, out_docs);
+    if (save_ret.code < 0) {
+      throw new Error(save_ret.data);
+    }
+
+    return { code: 200, data: { copied: out_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
@@ -3793,6 +4027,16 @@ export const move_drive_files_user = async (req, job_id, headers, file_obj) => {
   return await move_drive_files(req, job_id, headers, file_obj);
 };
 
+export const copy_drive_files_workspace = async (req, job_id, headers, file_obj) => {
+  req.drive_type = 'workspace';
+  return await copy_drive_files(req, job_id, headers, file_obj);
+};
+export const copy_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 copy_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);

package/index_ms.mjs

@@ -49,6 +49,10 @@ export const move_drive_files = async function (...args) {
   return await broker.send_to_queue("move_drive_files", ...args);
 };
 
+export const copy_drive_files = async function (...args) {
+  return await broker.send_to_queue("copy_drive_files", ...args);
+};
+
 export const trash_drive_files = async function (...args) {
   return await broker.send_to_queue("trash_drive_files", ...args);
 };
@@ -297,6 +301,14 @@ export const move_drive_files_user = async function (...args) {
   return await broker.send_to_queue("move_drive_files_user", ...args);
 };
 
+export const copy_drive_files_workspace = async function (...args) {
+  return await broker.send_to_queue("copy_drive_files_workspace", ...args);
+};
+
+export const copy_drive_files_user = async function (...args) {
+  return await broker.send_to_queue("copy_drive_files_user", ...args);
+};
+
 export const get_drive_size_workspace = async function (...args) {
   return await broker.send_to_queue("get_drive_size_workspace", ...args);
 };

package/index_msa.mjs

@@ -49,6 +49,10 @@ export const move_drive_files =  function (...args) {
    broker.send_to_queue_async("move_drive_files", ...args);
 };
 
+export const copy_drive_files =  function (...args) {
+   broker.send_to_queue_async("copy_drive_files", ...args);
+};
+
 export const trash_drive_files =  function (...args) {
    broker.send_to_queue_async("trash_drive_files", ...args);
 };
@@ -297,6 +301,14 @@ export const move_drive_files_user =  function (...args) {
    broker.send_to_queue_async("move_drive_files_user", ...args);
 };
 
+export const copy_drive_files_workspace =  function (...args) {
+   broker.send_to_queue_async("copy_drive_files_workspace", ...args);
+};
+
+export const copy_drive_files_user =  function (...args) {
+   broker.send_to_queue_async("copy_drive_files_user", ...args);
+};
+
 export const get_drive_size_workspace =  function (...args) {
    broker.send_to_queue_async("get_drive_size_workspace", ...args);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/drive_module",
-  "version": "1.1.1496",
+  "version": "1.1.1497",
   "description": "Xuda Drive Server Module",
   "main": "index.mjs",
   "dependencies": {