@xuda.io/drive_module 1.1.1497 → 1.1.1499

package/index.mjs

@@ -4,6 +4,7 @@ import { rimraf } from 'rimraf';
 import fse from 'fs-extra';
 import unzipper from 'unzipper';
 import fs from 'fs';
+import os from 'os';
 import tesseract from 'node-tesseract-ocr';
 import countryLanguage from 'country-language';
 import url from 'url';
@@ -219,7 +220,6 @@ export const get_drive_files = async (req) => {
           } else if (app_obj?.app_build_id) {
             ts = '?ts=' + app_obj?.app_build_id;
           }
-          debugger;
           try {
             files.sizeInBytes += doc.size;
             files.children.push({
@@ -900,7 +900,6 @@ export const rename_drive_file = async (req, job_id, headers) => {
 
 export const rename_drive_folder = async (req) => {
   try {
-    debugger;
     const { drive_type, app_id, curr_path, new_path, uid } = req;
     validate_drive_type(drive_type);
 
@@ -3765,6 +3764,106 @@ export const read_user_drive_folder = async (req) => {
   }
 };
 
+// fetch_drive_file_to_tmp: copy ONE drive file's bytes onto this box as a temp
+// file so a server-side document generator can open it, edit it and save the
+// result back as a new drive file. This is what lets the office plugins (pptx,
+// docx, xlsx) modify a deck/document the user already has instead of only
+// creating new ones: user + workspace files live in object storage, so there is
+// otherwise no path on disk to hand to a parser.
+//
+// The file is resolved by drive doc id (drv_...) or by its drive path
+// (/Folder/name.ext). The caller owns the temp file and must unlink it.
+//
+// req: { uid, app_id?, drive_type: 'user'|'workspace'|'studio', file }
+// -> { tmp_path, originalname, file_path, doc_id, size, mime, drive_type }
+export const fetch_drive_file_to_tmp = async (req) => {
+  try {
+    const { uid, app_id, drive_type = 'user' } = req || {};
+    const file_ref = String(req?.file || req?.file_id || req?.file_path || '').trim();
+
+    if (!uid) return { code: -1, data: 'uid required' };
+    if (!file_ref) return { code: -1, data: 'file required' };
+    validate_drive_type(drive_type);
+
+    const write_tmp = async (buffer, name) => {
+      const tmp_path = path.join(os.tmpdir(), `xuda_drive_${await _common.xuda_get_uuid('tmp')}${path.extname(name) || ''}`);
+      await fs.promises.writeFile(tmp_path, buffer);
+      return tmp_path;
+    };
+
+    // studio drive is plain files on this box, addressed by their relative path.
+    if (drive_type === 'studio') {
+      const ref = await _common.get_project_app_id(app_id, true);
+      const rel = file_ref.replace(/^\/+/, '');
+      const full = path.join(_conf.studio_drive_path, ref, rel);
+      // Contain the read inside the app's own studio folder.
+      const root = path.join(_conf.studio_drive_path, ref);
+      if (!path.resolve(full).startsWith(path.resolve(root) + path.sep)) {
+        return { code: -1, data: 'file_path unauthorized' };
+      }
+      if (!(await fs_module.file_exists(full))) return { code: -1, data: `file not found: ${file_ref}` };
+      const buffer = await fs.promises.readFile(full);
+      const originalname = path.basename(full);
+      return {
+        code: 1,
+        data: {
+          tmp_path: await write_tmp(buffer, originalname),
+          originalname,
+          file_path: path.posix.join('/', path.dirname(rel) === '.' ? '' : path.dirname(rel)),
+          doc_id: rel,
+          size: buffer.length,
+          mime: _drive_content_type_for(originalname),
+          drive_type,
+        },
+      };
+    }
+
+    const project_id = drive_type === 'user' ? await get_account_default_project_id(uid) : await _common.get_project_app_id(app_id);
+
+    // Either the doc id itself, or a /folder/name.ext path within the drive.
+    const by_id = /^drv_/.test(file_ref);
+    const selector = { docType: `${drive_type}_drive`, type: 'file', stat: 3 };
+    if (by_id) {
+      selector._id = file_ref;
+    } else {
+      const with_slash = file_ref.startsWith('/') ? file_ref : `/${file_ref}`;
+      const dir = path.posix.dirname(with_slash);
+      selector.file_path = dir === '.' ? '/' : dir;
+      selector.originalname = path.posix.basename(with_slash);
+    }
+
+    const find_ret = await db_module.find_app_couch_query(project_id, { selector, limit: 1 });
+    const doc = find_ret?.docs?.[0];
+    if (!doc) return { code: -1, data: `file not found: ${file_ref}` };
+
+    const region = _pick_file_region(doc);
+    const b = (region && doc.bucket?.[region]) || {};
+    const Bucket = b.Bucket || b.bucket || (region && _conf.storage_bucket?.[region]?.name);
+    const Key = b.Key || b.key;
+    const s3 = region ? _drive_s3_for(region) : null;
+    if (!s3 || !Bucket || !Key) return { code: -1, data: 'file bytes unavailable' };
+
+    const obj = await s3.send(new GetObjectCommand({ Bucket, Key }));
+    const buffer = await _stream_to_buffer(obj.Body);
+    const originalname = doc.originalname || path.basename(Key);
+
+    return {
+      code: 1,
+      data: {
+        tmp_path: await write_tmp(buffer, originalname),
+        originalname,
+        file_path: doc.file_path || '/',
+        doc_id: doc._id,
+        size: buffer.length,
+        mime: doc.mime || _drive_content_type_for(originalname),
+        drive_type,
+      },
+    };
+  } catch (err) {
+    return { code: -400, data: err.message };
+  }
+};
+
 // put_site_files — snapshot a set of static-site files into ONE region's
 // Spaces bucket under sites/{site_id}/{version}/{path}, public-read. Each
 // deploy writes a fresh immutable version directory, so older versions stay

package/index_ms.mjs

@@ -197,6 +197,10 @@ export const read_user_drive_folder = async function (...args) {
   return await broker.send_to_queue("read_user_drive_folder", ...args);
 };
 
+export const fetch_drive_file_to_tmp = async function (...args) {
+  return await broker.send_to_queue("fetch_drive_file_to_tmp", ...args);
+};
+
 export const put_site_files = async function (...args) {
   return await broker.send_to_queue("put_site_files", ...args);
 };

package/index_msa.mjs

@@ -197,6 +197,10 @@ export const read_user_drive_folder =  function (...args) {
    broker.send_to_queue_async("read_user_drive_folder", ...args);
 };
 
+export const fetch_drive_file_to_tmp =  function (...args) {
+   broker.send_to_queue_async("fetch_drive_file_to_tmp", ...args);
+};
+
 export const put_site_files =  function (...args) {
    broker.send_to_queue_async("put_site_files", ...args);
 };

package/package.json

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