@xuda.io/drive_module 1.1.1499 → 1.1.1500

package/index.mjs

@@ -29,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`);
 
@@ -4470,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

@@ -421,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

@@ -421,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.1499",
+  "version": "1.1.1500",
   "description": "Xuda Drive Server Module",
   "main": "index.mjs",
   "dependencies": {