@xuda.io/drive_module 1.1.1498 → 1.1.1500

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';
@@ -28,6 +29,10 @@ const { get_account_default_project_id } = await import(path.join(process.env.XU
 const module_path = path.join(process.env.XUDA_HOME, 'cpi') + (!_conf.is_debug ? '/node_modules/@xuda.io' : '');
 const fs_module = await import(`${module_path}/fs_module/index.mjs`);
 const db_module = await import(`${module_path}/db_module/index.mjs`);
+// UI-113: the Drive storage ladder is one line item on the consolidated
+// subscription, so drive_set_plan drives Stripe the same way every other module
+// tier does (add_subscription_item to buy or reprice, remove on the free tier).
+const stripe_ms = await import(`${module_path}/stripe_module/index_ms.mjs`);
 
 // const account_msa = await import(`${module_path}/account_module/index_msa.mjs`);
 
@@ -3763,6 +3768,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
@@ -4369,3 +4474,172 @@ export const file_upload_validator = function (file_name) {
       return { valid: false, error: `Unsupported file extension: .${ext}` };
   }
 };
+
+///////////////////////////////////////////////////////////////////////////////
+// DRIVE PLANS (UI-113)
+//
+// Drive is sold on its own drive_* ladder and what the ladder sells is SPACE.
+// A tier's `flags.extra_gb` is added on top of the storage the account already
+// has from its membership plan and its AI workspace plan, it does not replace
+// either, so an account that never picks a tier is on drive_free and nothing
+// about its Drive changes.
+//
+// The money is one line item on the consolidated subscription, the same shape
+// every other module tier uses: a paid tier creates or reprices the line, free
+// removes it. Billing moves FIRST and the plan is only written once Stripe
+// agreed, so a failed charge can never leave an account holding space it is
+// not paying for.
+///////////////////////////////////////////////////////////////////////////////
+
+const DRIVE_CATEGORY = 'drive';
+const GB = 1073741824;
+
+const _drive_tiers = () =>
+  Object.values(_conf.PLAN_OBJ || {})
+    .filter((p) => p.category === DRIVE_CATEGORY)
+    .sort((a, b) => (Number(a.rank) || 0) - (Number(b.rank) || 0));
+
+const _drive_plan = (plan_id) => {
+  const plan = _conf.PLAN_OBJ?.[plan_id];
+  return plan && plan.category === DRIVE_CATEGORY ? plan : null;
+};
+
+const _drive_account_doc = async (uid) => {
+  const ret = await db_module.get_couch_doc('xuda_accounts', uid);
+  return ret.code < 0 || !ret.data ? {} : ret.data;
+};
+
+// An account that never touched the ladder is on free. Same default the billing
+// Modules card applies, kept identical on purpose so the two never disagree.
+const _drive_account_plan = (account) => (_drive_plan(account?.drive_plan) ? account.drive_plan : 'drive_free');
+
+// What the account is storing, using the SAME sum the overage metering charges
+// on (account_module increment_account_usage). project_data_size is deliberately
+// out of it there, so it is out of it here: a guard that counted bytes the
+// metering ignores would refuse a downgrade the customer is not billed for.
+const _drive_used_bytes = (account) =>
+  (account?.user_drive_size || 0) +
+  (account?.studio_drive_size || 0) +
+  (account?.workspace_drive_size || 0) +
+  (account?.builds_drive_size || 0) +
+  (account?.plugins_drive_size || 0);
+
+// The quota the account WOULD have on a given tier, in bytes. Delegates to
+// account_module's get_effective_entitlements rather than re-deriving the stack,
+// because that function is what the metering and every storage bar already use.
+// Imported lazily: this is the only place in the drive module that needs it and
+// account_module pulls in a large tree of its own.
+const _drive_quota_bytes = async (account, plan_id) => {
+  const { get_effective_entitlements } = await import(`${module_path}/account_module/index.mjs`);
+  const ent = get_effective_entitlements({ ...account, drive_plan: plan_id ?? account?.drive_plan });
+  return {
+    unlimited: !Number.isFinite(ent.drive_gb),
+    bytes: Number.isFinite(ent.drive_gb) ? Math.round(ent.drive_gb * GB) : 0,
+    breakdown: ent.drive_breakdown || {},
+  };
+};
+
+const _drive_pretty = (bytes) => {
+  if (bytes >= 1099511627776) return `${Math.round((bytes / 1099511627776) * 10) / 10} TB`;
+  if (bytes >= GB) return `${Math.round((bytes / GB) * 10) / 10} GB`;
+  return `${Math.round(bytes / 1048576)} MB`;
+};
+
+export const get_drive_plans = async function (req) {
+  try {
+    const uid = req?.uid;
+    if (!uid) return { code: -401, data: 'not authenticated' };
+    const account = await _drive_account_doc(uid);
+    if (!account._id) return { code: -404, data: 'account not found' };
+
+    const plan_id = _drive_account_plan(account);
+    const used = _drive_used_bytes(account);
+    const quota = await _drive_quota_bytes(account, plan_id);
+
+    // Every tier carries the quota it WOULD give and whether the account already
+    // stores more than that, so the screen can mark a tier as out of reach
+    // without doing the entitlement arithmetic itself.
+    const plans = [];
+    for (const p of _drive_tiers()) {
+      const q = await _drive_quota_bytes(account, p.id);
+      plans.push({
+        ...p,
+        quota_bytes: q.bytes,
+        quota_unlimited: q.unlimited,
+        fits: q.unlimited || used <= q.bytes,
+      });
+    }
+
+    return {
+      code: 1,
+      data: {
+        plan_id,
+        plan_name: _drive_plan(plan_id)?.name || '',
+        changed_ts: account.drive_plan_changed || null,
+        // The line on the invoice. Free holds no item at all.
+        subscribed: !!account?.stripe_subscription_items?.[DRIVE_CATEGORY],
+        used_bytes: used,
+        quota_bytes: quota.bytes,
+        quota_unlimited: quota.unlimited,
+        // Where the space comes from, so a full bar can point at the plan that
+        // would actually fix it rather than at this one by default.
+        quota_from: {
+          membership_bytes: Math.round((quota.breakdown.membership_gb === Infinity ? 0 : quota.breakdown.membership_gb || 0) * GB),
+          workspace_bytes: Math.round((quota.breakdown.workspace_gb || 0) * GB),
+          drive_plan_bytes: Math.round((quota.breakdown.drive_plan_gb || 0) * GB),
+        },
+        membership_plan: account.membership_plan || 'free',
+        ai_workspace_plan: account.ai_workspace_plan || '',
+        plans,
+      },
+    };
+  } catch (err) {
+    return { code: -1, data: err.message || String(err) };
+  }
+};
+
+export const drive_set_plan = async function (req) {
+  try {
+    const uid = req?.uid;
+    if (!uid) return { code: -401, data: 'not authenticated' };
+    const plan_id = req?.plan_id || '';
+    const plan = _drive_plan(plan_id);
+    if (!plan) return { code: -1, data: 'unknown drive plan' };
+
+    const account = await _drive_account_doc(uid);
+    if (!account._id) return { code: -404, data: 'account not found' };
+    const current = _drive_account_plan(account);
+    if (current === plan_id) return await get_drive_plans({ uid });
+
+    // Downgrade guard. Taking space away from an account that is already using it
+    // would drop it straight into metered overage on files it cannot see a way to
+    // remove, so name the gap instead and let the customer clear it first.
+    const target = await _drive_quota_bytes(account, plan_id);
+    const used = _drive_used_bytes(account);
+    if (!target.unlimited && used > target.bytes) {
+      return {
+        code: -1,
+        data: `You are storing ${_drive_pretty(used)} and the ${plan.name} plan would leave you with ${_drive_pretty(target.bytes)}. Free up ${_drive_pretty(used - target.bytes)} in Drive first.`,
+      };
+    }
+
+    const paid = Number(plan.price) > 0;
+    if (paid) {
+      const ret = await stripe_ms.add_subscription_item({ uid, plan_id });
+      if (!ret || ret.code < 0) return { code: ret?.code === -402 || ret?.code === -3 ? -402 : -1, data: ret?.data || 'could not change the plan' };
+    } else if (account.stripe_subscription_items?.[DRIVE_CATEGORY]) {
+      const ret = await stripe_ms.remove_subscription_item({ uid, category: DRIVE_CATEGORY });
+      if (!ret || ret.code < 0) return { code: -1, data: ret?.data || 'could not remove the subscription line' };
+    }
+
+    // Re-read: the stripe call just wrote stripe_subscription_items on this doc.
+    const fresh = await _drive_account_doc(uid);
+    fresh.drive_plan = plan_id;
+    fresh.drive_plan_changed = Date.now();
+    await db_module.save_couch_doc('xuda_accounts', fresh);
+
+    return await get_drive_plans({ uid });
+  } catch (err) {
+    return { code: -1, data: err.message || String(err) };
+  }
+};

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);
 };
@@ -417,6 +421,14 @@ export const file_upload_validator = async function (...args) {
   return await broker.send_to_queue("file_upload_validator", ...args);
 };
 
+export const get_drive_plans = async function (...args) {
+  return await broker.send_to_queue("get_drive_plans", ...args);
+};
+
+export const drive_set_plan = async function (...args) {
+  return await broker.send_to_queue("drive_set_plan", ...args);
+};
+
 export const get_drive_files_studio = async function (...args) {
   return await broker.send_to_queue("get_drive_files_studio", ...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);
 };
@@ -417,6 +421,14 @@ export const file_upload_validator =  function (...args) {
    broker.send_to_queue_async("file_upload_validator", ...args);
 };
 
+export const get_drive_plans =  function (...args) {
+   broker.send_to_queue_async("get_drive_plans", ...args);
+};
+
+export const drive_set_plan =  function (...args) {
+   broker.send_to_queue_async("drive_set_plan", ...args);
+};
+
 export const get_drive_files_studio =  function (...args) {
    broker.send_to_queue_async("get_drive_files_studio", ...args);
 };

package/package.json

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