@xuda.io/drive_module 1.1.1487 → 1.1.1489

package/index.mjs

@@ -1803,97 +1803,76 @@ export const get_drive_size = async (req) => {
   }
 };
 
-const upload_file_to_spaces = async (tempPath, ref, drive_type, file_name) => {
-  const spacesEndpoint = new S3Client({
-    endpoint: _conf.storage_bucket[process.env.XUDA_HOSTNAME].endpoint,
-    region: _conf.storage_bucket[process.env.XUDA_HOSTNAME].region,
-    credentials: {
-      accessKeyId: _conf.digitalocean.spaces_access_key,
-      secretAccessKey: _conf.digitalocean.spaces_secret_key,
-    },
-    forcePathStyle: false,
-  });
+// --- Object storage (S3 / R2) helpers ------------------------------------
+// Credentials: prefer R2 (post-migration), fall back to DO Spaces so the same
+// code runs before and after the cutover.
+const _storage_credentials = () => {
+  if (_conf.r2?.access_key_id && _conf.r2?.secret_access_key) {
+    return { accessKeyId: _conf.r2.access_key_id, secretAccessKey: _conf.r2.secret_access_key };
+  }
+  return {
+    accessKeyId: _conf.digitalocean?.spaces_access_key,
+    secretAccessKey: _conf.digitalocean?.spaces_secret_key,
+  };
+};
 
-  const fileContent = fs.createReadStream(tempPath);
+// R2 addresses buckets path-style against the account endpoint; DO Spaces uses
+// virtual-hosted style.
+const _is_r2 = () => !!(_conf.r2?.access_key_id);
 
-  // const uploadParams = {
-  //   Bucket: `${process.env.XUDA_HOSTNAME}/${drive_type}`,
-  //   Key: path.join(ref, _utils.UUID() + '_' + file_name),
-  //   Body: fileContent,
-  //   ACL: 'public-read',
-  // };
+// Public URL for a stored object, ALWAYS rebuilt from the Key. Post-migration
+// every bucket is served from one custom domain (r2.public_base); pre-migration
+// we reconstruct the virtual-hosted DO Spaces URL. Rebuilding from the Key means
+// existing docs that still carry old DO Locations resolve to the live backend.
+const _public_url_for = (region_host, key) => {
+  const k = String(key || '').replace(/^\/+/, '');
+  if (!k) return null;
+  if (_conf.r2?.public_base) return `${String(_conf.r2.public_base).replace(/\/+$/, '')}/${k}`;
+  const conf = _conf.storage_bucket?.[region_host];
+  if (!conf) return null;
+  const host = String(conf.endpoint || '').replace(/^https?:\/\//, '').replace(/\/+$/, '');
+  return host ? `https://${conf.name}.${host}/${k}` : null;
+};
 
-  const uploadParams = {
-    Bucket: _conf.storage_bucket[process.env.XUDA_HOSTNAME].name,
-    Key: path.join(process.env.XUDA_HOSTNAME, drive_type, ref, _utils.UUID() + '_' + file_name),
-    Body: fileContent,
-    ACL: 'public-read',
-  };
+const upload_file_to_spaces = async (tempPath, ref, drive_type, file_name) => {
+  const region_host = process.env.XUDA_HOSTNAME;
+  const conf = _conf.storage_bucket?.[region_host];
+  const s3 = _drive_s3_for(region_host);
+  if (!s3 || !conf) {
+    console.error('upload_file_to_spaces: no storage config for', region_host);
+    return;
+  }
+  const Bucket = conf.name;
+  const Key = path.join(region_host, drive_type, ref, _utils.UUID() + '_' + file_name);
 
   try {
     const upload = new Upload({
-      client: spacesEndpoint,
-      params: uploadParams,
+      client: s3,
+      params: { Bucket, Key, Body: fs.createReadStream(tempPath), ContentType: _drive_content_type_for(file_name) },
     });
 
     const data = await upload.done();
-    return data;
+    // Override the SDK Location with the canonical public URL (custom domain on
+    // R2), and pin Bucket/Key so the stored doc.bucket entry is backend-correct.
+    return { ...data, Location: _public_url_for(region_host, Key), Bucket, Key, key: Key };
   } catch (err) {
     console.error('Error', err);
   }
 };
 
+// Retired under the single R2 namespace: every region resolves to the same
+// bucket, so there is nothing to copy. Kept as a no-op so existing callers keep
+// working — returns a backend-correct location rebuilt from the Key.
 export const copy_file_to_another_bucket = async (source_region, target_region, file_name) => {
-  const sourceS3 = new S3Client({
-    endpoint: _conf.storage_bucket[source_region].endpoint,
-    region: _conf.storage_bucket[source_region].region,
-    credentials: {
-      accessKeyId: _conf.digitalocean.spaces_access_key,
-      secretAccessKey: _conf.digitalocean.spaces_secret_key,
-    },
-    forcePathStyle: false,
-  });
-
-  const targetS3 = new S3Client({
-    endpoint: _conf.storage_bucket[target_region].endpoint,
-    region: _conf.storage_bucket[target_region].region,
-    credentials: {
-      accessKeyId: _conf.digitalocean.spaces_access_key,
-      secretAccessKey: _conf.digitalocean.spaces_secret_key,
+  return {
+    code: 1,
+    data: {
+      Location: _public_url_for(target_region, file_name),
+      key: file_name,
+      Key: file_name,
+      Bucket: _conf.storage_bucket?.[target_region]?.name,
     },
-    forcePathStyle: false,
-  });
-
-  try {
-    const { Body } = await sourceS3.send(
-      new GetObjectCommand({
-        Bucket: source_region,
-        Key: file_name,
-      }),
-    );
-
-    const upload = new Upload({
-      client: targetS3,
-      params: {
-        Bucket: target_region,
-        Key: file_name,
-        Body,
-        ACL: 'public-read',
-      },
-    });
-
-    const ret = await upload.done();
-
-    ret.Location = `${_conf.storage_bucket[target_region].endpoint}/${target_region}/${file_name}`;
-    ret.key = file_name;
-    ret.Key = file_name;
-    ret.Bucket = target_region;
-
-    return { code: 1, data: ret };
-  } catch (err) {
-    console.error('Error copying file:', err);
-    return { code: -1, data: err.message };
-  }
+  };
 };
 
 const get_folder_size = async (dir, drive_type, app_id, uid) => {
@@ -1976,19 +1955,17 @@ const get_file_info = async (file_path) => {
 };
 
 export const delete_file_from_bucket = async (bucket) => {
-  const s3 = new S3Client({
-    endpoint: _conf.storage_bucket[process.env.XUDA_HOSTNAME].endpoint,
-    region: _conf.storage_bucket[process.env.XUDA_HOSTNAME].region,
-    credentials: {
-      accessKeyId: _conf.digitalocean.spaces_access_key,
-      secretAccessKey: _conf.digitalocean.spaces_secret_key,
-    },
-    forcePathStyle: false,
-  });
-
   try {
-    for await (let [key, val] of Object.entries(bucket)) {
-      await s3.send(new DeleteObjectCommand({ Bucket: val.Bucket, Key: val.key || val.Key }));
+    for await (let [region_host, val] of Object.entries(bucket || {})) {
+      const Key = val?.key || val?.Key;
+      if (!Key) continue;
+      // Resolve the client + bucket NAME from config for the file's region (fall
+      // back to this server's region). Never trust the stored val.Bucket — after
+      // the R2 cutover that name (e.g. xuda-bucket-nyc) no longer exists.
+      const s3 = _drive_s3_for(region_host) || _drive_s3_for(process.env.XUDA_HOSTNAME);
+      const Bucket = _conf.storage_bucket?.[region_host]?.name || _conf.storage_bucket?.[process.env.XUDA_HOSTNAME]?.name;
+      if (!s3 || !Bucket) continue;
+      await s3.send(new DeleteObjectCommand({ Bucket, Key }));
     }
   } catch (err) {
     console.error('Error', err);
@@ -2920,11 +2897,8 @@ const _drive_s3_for = (region_host) => {
     _drive_s3_cache[region_host] = new S3Client({
       endpoint: conf.endpoint,
       region: conf.region,
-      credentials: {
-        accessKeyId: _conf.digitalocean.spaces_access_key,
-        secretAccessKey: _conf.digitalocean.spaces_secret_key,
-      },
-      forcePathStyle: false,
+      credentials: _storage_credentials(),
+      forcePathStyle: _is_r2(),
     });
   }
   return _drive_s3_cache[region_host];
@@ -3044,10 +3018,6 @@ export const put_site_files = async (req) => {
     const Bucket = conf.name;
     if (!s3 || !Bucket) return { code: -1, data: `no S3 client for region ${region_host}` };
 
-    const endpoint_host = String(conf.endpoint || '')
-      .replace(/^https?:\/\//, '')
-      .replace(/\/+$/, '');
-
     const manifest = {};
     let bytes = 0;
     for (const f of files) {
@@ -3062,11 +3032,11 @@ export const put_site_files = async (req) => {
       const Key = `sites/${site_id}/${version}${norm}`;
       const up = new Upload({
         client: s3,
-        params: { Bucket, Key, Body: body, ACL: 'public-read', ContentType: content_type },
+        params: { Bucket, Key, Body: body, ContentType: content_type },
       });
-      const res = await up.done();
-      // Prefer the SDK-reported Location; reconstruct a virtual-hosted URL if absent.
-      const location = res?.Location || (endpoint_host ? `https://${Bucket}.${endpoint_host}/${Key}` : null);
+      await up.done();
+      // Canonical public URL, rebuilt from the Key (custom domain on R2).
+      const location = _public_url_for(region_host, Key);
       manifest[norm] = { key: Key, bucket: Bucket, region: region_host, location, content_type, bytes: body.length };
       bytes += body.length;
     }