@homecloud-platform/sdk 0.5.9 → 0.5.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homecloud-platform/sdk",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "description": "HomeCloud Functions SDK for Node.js (ADR-033 / ADR-025e)",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/client.js

@@ -153,6 +153,10 @@ class HomeCloud {
     if (!this.accessToken) throw new NotLoggedInError();
   }
 
+  get hasAccessKey() {
+    return Boolean(this.accessKeyId && this.secretAccessKey);
+  }
+
   baseUrl(service) {
     if (this.dataPlaneBases[service]) return this.dataPlaneBases[service].replace(/\/$/, "");
     if (service === "so") return soUrl(this.apex);
@@ -320,6 +324,50 @@ class HomeCloud {
     return data;
   }
 
+  async consoleSignedRequest(method, pathSeg, { json, params } = {}) {
+    this.requireAccessKey();
+    await this.ensureAccountId();
+    const base = (this.consoleBaseUrl || consoleUrl(this.apex)).replace(/\/$/, "");
+    const rel = String(pathSeg).replace(/^\/+/, "");
+    const url = new URL(`${base}/${rel}`);
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        if (v !== undefined && v !== null) url.searchParams.set(k, String(v));
+      }
+    }
+    const headers = signRequestHeaders({
+      accessKeyId: this.accessKeyId,
+      secret: this.secretAccessKey,
+      method,
+      path: `/api/v1/${rel}`,
+      accountId: this.accountId,
+      sessionToken: this.sessionToken,
+    });
+    const init = { method, headers, signal: AbortSignal.timeout(this.timeoutMs) };
+    if (json !== undefined) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(json);
+    }
+    const res = await fetch(url, init);
+    if (method === "DELETE" && res.status === 204) return null;
+    const text = await res.text();
+    let data = null;
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch (_) {
+        data = { raw: text };
+      }
+    }
+    if (!res.ok) {
+      throw errorFromStatus(res.status, {
+        detail: data && (data.detail !== undefined ? data.detail : data),
+        url: String(url),
+      });
+    }
+    return data;
+  }
+
   async consoleRequestBytes(method, pathSeg) {
     this.requireConsole();
     const base = (this.consoleBaseUrl || consoleUrl(this.apex)).replace(/\/$/, "");

package/src/management.js

@@ -40,21 +40,26 @@ class QueuesAPI {
   }
 
   async list({ live = false } = {}) {
+    await this._c.ensureAccountId();
+    const path = `accounts/${this._c.accountId}/queues`;
+    const params = live ? { live: "true" } : undefined;
+    if (this._c.hasAccessKey) {
+      const data = await this._c.consoleSignedRequest("GET", path, { params });
+      return data.items || [];
+    }
     this._c.requireConsole();
-    const data = await this._c.consoleRequest(
-      "GET",
-      `accounts/${this._c.accountId}/queues`,
-      { params: live ? { live: "true" } : undefined }
-    );
+    const data = await this._c.consoleRequest("GET", path, { params });
     return data.items || [];
   }
 
   async get(queueName) {
+    await this._c.ensureAccountId();
+    const path = `accounts/${this._c.accountId}/queues/${encodeURIComponent(queueName)}`;
+    if (this._c.hasAccessKey) {
+      return this._c.consoleSignedRequest("GET", path);
+    }
     this._c.requireConsole();
-    return this._c.consoleRequest(
-      "GET",
-      `accounts/${this._c.accountId}/queues/${encodeURIComponent(queueName)}`
-    );
+    return this._c.consoleRequest("GET", path);
   }
 }
 

package/src/so.js

@@ -40,6 +40,15 @@ class SoAPI {
   }
 
   async listBuckets() {
+    await this._c.ensureAccountId();
+    if (this._c.hasAccessKey) {
+      const data = await this._c.dataPlaneRequest(
+        "so",
+        "GET",
+        `/${this._c.accountId}/buckets`
+      );
+      return data.items || [];
+    }
     this._c.requireConsole();
     const data = await this._c.consoleRequest(
       "GET",
@@ -49,18 +58,25 @@ class SoAPI {
   }
 
   async createBucket(name) {
+    await this._c.ensureAccountId();
+    const path = `accounts/${this._c.accountId}/storage/buckets`;
+    const body = { name: String(name).trim().toLowerCase() };
+    if (this._c.hasAccessKey) {
+      return this._c.consoleSignedRequest("POST", path, { json: body });
+    }
     this._c.requireConsole();
-    return this._c.consoleRequest("POST", `accounts/${this._c.accountId}/storage/buckets`, {
-      json: { name: String(name).trim().toLowerCase() },
-    });
+    return this._c.consoleRequest("POST", path, { json: body });
   }
 
   async deleteBucket(name) {
+    await this._c.ensureAccountId();
+    const path = `accounts/${this._c.accountId}/storage/buckets/${String(name).trim().toLowerCase()}`;
+    if (this._c.hasAccessKey) {
+      await this._c.consoleSignedRequest("DELETE", path);
+      return;
+    }
     this._c.requireConsole();
-    await this._c.consoleRequest(
-      "DELETE",
-      `accounts/${this._c.accountId}/storage/buckets/${String(name).trim().toLowerCase()}`
-    );
+    await this._c.consoleRequest("DELETE", path);
   }
 
   async listObjects(bucketName, { prefix = "", recursive = false, page = 1, pageSize = 100 } = {}) {
@@ -213,6 +229,19 @@ class SoAPI {
     };
   }
 
+  async copy(bucketName, sourceKey, destinationKey, { sourceBucket = null } = {}) {
+    this._c.requireAccessKey();
+    const { signPath, urlPath } = soObjectPaths(this._c.accountId, bucketName, sourceKey);
+    return this._c.dataPlaneRequest("so", "POST", `${signPath}/copy`, {
+      urlPath: `${urlPath}/copy`,
+      signPath: `${signPath}/copy`,
+      json: {
+        destination_key: destinationKey,
+        source_bucket: sourceBucket || null,
+      },
+    });
+  }
+
   async deleteRecursive(bucketName, prefix = "") {
     const items = await this.listAllObjects(bucketName, { prefix, recursive: true });
     for (const item of items) {
@@ -221,7 +250,135 @@ class SoAPI {
     return items.length;
   }
 
-  async syncLocalToBucket(localDir, bucketName, { prefix = "", deleteExtra = false } = {}) {
+  _isSoUri(target) {
+    const lowered = String(target || "").toLowerCase();
+    return lowered.startsWith("so://") || lowered.startsWith("s3://");
+  }
+
+  _parseSoUri(target) {
+    let text = String(target || "").trim();
+    const lowered = text.toLowerCase();
+    if (lowered.startsWith("so://")) text = text.slice(5);
+    else if (lowered.startsWith("s3://")) text = text.slice(5);
+    text = text.replace(/^\/+|\/+$/g, "");
+    if (!text) throw new HomeCloudError("URI must include a bucket name");
+    const slash = text.indexOf("/");
+    if (slash < 0) return { bucket: text, prefix: "" };
+    return { bucket: text.slice(0, slash), prefix: text.slice(slash + 1) };
+  }
+
+  _syncJoinPrefix(prefixClean, relative) {
+    const rel = String(relative || "").replace(/^\/+/, "");
+    if (!prefixClean) return rel;
+    if (!rel) return prefixClean;
+    return `${prefixClean}/${rel}`;
+  }
+
+  _syncRelativePath(key, prefixClean) {
+    if (!prefixClean) return key;
+    if (key === prefixClean) return key.split("/").pop();
+    if (key.startsWith(`${prefixClean}/`)) return key.slice(prefixClean.length + 1);
+    return key;
+  }
+
+  /**
+   * Unified sync: local↔bucket or bucket↔bucket.
+   * Prefer this over syncLocalToBucket / syncBucketToLocal.
+   */
+  async sync(source, destination, { deleteExtra = false, skip = false } = {}) {
+    const srcRemote = this._isSoUri(source);
+    const dstRemote = this._isSoUri(destination);
+    if (srcRemote && dstRemote) {
+      const src = this._parseSoUri(source);
+      const dst = this._parseSoUri(destination);
+      return this._syncBucketToBucket(src.bucket, dst.bucket, {
+        sourcePrefix: src.prefix,
+        destinationPrefix: dst.prefix,
+        deleteExtra,
+        skip,
+      });
+    }
+    if (srcRemote && !dstRemote) {
+      const src = this._parseSoUri(source);
+      return this.syncBucketToLocal(src.bucket, destination, {
+        prefix: src.prefix,
+        deleteExtra,
+        skip,
+      });
+    }
+    if (!srcRemote && dstRemote) {
+      const dst = this._parseSoUri(destination);
+      return this.syncLocalToBucket(source, dst.bucket, {
+        prefix: dst.prefix,
+        deleteExtra,
+        skip,
+      });
+    }
+    throw new HomeCloudError(
+      "One or both sides must be an so:// URI (local↔bucket or bucket↔bucket)"
+    );
+  }
+
+  async _syncBucketToBucket(
+    sourceBucket,
+    destinationBucket,
+    { sourcePrefix = "", destinationPrefix = "", deleteExtra = false, skip = false } = {}
+  ) {
+    this._c.requireAccessKey();
+    const srcPrefix = String(sourcePrefix || "").replace(/^\/+|\/+$/g, "");
+    const dstPrefix = String(destinationPrefix || "").replace(/^\/+|\/+$/g, "");
+    if (sourceBucket === destinationBucket && srcPrefix === dstPrefix) {
+      throw new HomeCloudError(`Source and destination are the same: so://${sourceBucket}/${srcPrefix}`);
+    }
+
+    const sourceItems = await this.listAllObjects(sourceBucket, {
+      prefix: srcPrefix,
+      recursive: true,
+    });
+    const destItems = await this.listAllObjects(destinationBucket, {
+      prefix: dstPrefix,
+      recursive: true,
+    });
+
+    const sourceRels = new Map();
+    for (const item of sourceItems) {
+      const rel = this._syncRelativePath(item.key, srcPrefix);
+      sourceRels.set(rel, { key: item.key, size: Number(item.size || 0) });
+    }
+    const destRels = new Map();
+    for (const item of destItems) {
+      const rel = this._syncRelativePath(item.key, dstPrefix);
+      destRels.set(rel, { key: item.key, size: Number(item.size || 0) });
+    }
+
+    let copied = 0;
+    let skipped = 0;
+    for (const [rel, src] of sourceRels) {
+      const dest = destRels.get(rel);
+      if (skip && dest && dest.size === src.size) {
+        skipped += 1;
+        continue;
+      }
+      const dstKey = this._syncJoinPrefix(dstPrefix, rel);
+      await this.copy(destinationBucket, src.key, dstKey, {
+        sourceBucket: sourceBucket !== destinationBucket ? sourceBucket : null,
+      });
+      copied += 1;
+    }
+
+    let deleted = 0;
+    if (deleteExtra) {
+      for (const [rel, dest] of destRels) {
+        if (sourceRels.has(rel)) continue;
+        await this.delete(destinationBucket, dest.key);
+        deleted += 1;
+      }
+    }
+    return { copied, skipped, deleted };
+  }
+
+  /** Prefer sync("./dir", "so://bucket/prefix"). */
+  async syncLocalToBucket(localDir, bucketName, { prefix = "", deleteExtra = false, skip = false } = {}) {
     this._c.requireAccessKey();
     const root = path.resolve(localDir);
     const prefixClean = String(prefix || "").replace(/^\/+|\/+$/g, "");
@@ -232,43 +389,83 @@ class SoAPI {
         const st = fs.statSync(full);
         const rel = path.relative(base, full).split(path.sep).join("/");
         if (st.isDirectory()) out.push(...walk(full, base));
-        else out.push(rel);
+        else out.push({ rel, size: st.size });
       }
       return out;
     };
     const locals = walk(root, root);
-    for (const rel of locals) {
-      const key = prefixClean ? `${prefixClean}/${rel}` : rel;
+    const remote = await this.listAllObjects(bucketName, { prefix: prefixClean, recursive: true });
+    const remoteByKey = new Map(remote.map((item) => [item.key, item]));
+
+    let uploaded = 0;
+    let skipped = 0;
+    for (const { rel, size } of locals) {
+      const key = this._syncJoinPrefix(prefixClean, rel);
+      const existing = remoteByKey.get(key);
+      if (skip && existing && Number(existing.size || 0) === size) {
+        skipped += 1;
+        continue;
+      }
       await this.upload(bucketName, path.join(root, rel), { key });
+      uploaded += 1;
     }
+    let deleted = 0;
     if (deleteExtra) {
-      const remote = await this.listAllObjects(bucketName, { prefix: prefixClean, recursive: true });
-      const localKeys = new Set(
-        locals.map((rel) => (prefixClean ? `${prefixClean}/${rel}` : rel))
-      );
+      const localKeys = new Set(locals.map(({ rel }) => this._syncJoinPrefix(prefixClean, rel)));
       for (const item of remote) {
-        if (!localKeys.has(item.key)) await this.delete(bucketName, item.key);
+        if (!localKeys.has(item.key)) {
+          await this.delete(bucketName, item.key);
+          deleted += 1;
+        }
       }
     }
-    return { uploaded: locals.length };
+    return { uploaded, skipped, deleted };
   }
 
-  async syncBucketToLocal(bucketName, localDir, { prefix = "" } = {}) {
+  /** Prefer sync("so://bucket/prefix", "./dir"). */
+  async syncBucketToLocal(bucketName, localDir, { prefix = "", deleteExtra = false, skip = false } = {}) {
     this._c.requireAccessKey();
     const root = path.resolve(localDir);
     const prefixClean = String(prefix || "").replace(/^\/+|\/+$/g, "");
     const items = await this.listAllObjects(bucketName, { prefix: prefixClean, recursive: true });
+    let downloaded = 0;
+    let skippedCount = 0;
+    const remoteRels = new Set();
     for (const item of items) {
-      let rel = item.key;
-      if (prefixClean && item.key.startsWith(`${prefixClean}/`)) {
-        rel = item.key.slice(prefixClean.length + 1);
-      } else if (prefixClean && item.key === prefixClean) {
-        rel = path.basename(item.key);
-      }
+      const rel = this._syncRelativePath(item.key, prefixClean);
+      remoteRels.add(rel);
       const dest = path.join(root, rel);
+      if (
+        skip &&
+        fs.existsSync(dest) &&
+        fs.statSync(dest).isFile() &&
+        fs.statSync(dest).size === Number(item.size || 0)
+      ) {
+        skippedCount += 1;
+        continue;
+      }
       await this.download(bucketName, item.key, { destPath: dest });
+      downloaded += 1;
+    }
+    let deleted = 0;
+    if (deleteExtra && fs.existsSync(root)) {
+      const walk = (dir, base) => {
+        const out = [];
+        for (const name of fs.readdirSync(dir)) {
+          const full = path.join(dir, name);
+          const st = fs.statSync(full);
+          if (st.isDirectory()) out.push(...walk(full, base));
+          else out.push(path.relative(base, full).split(path.sep).join("/"));
+        }
+        return out;
+      };
+      for (const rel of walk(root, root)) {
+        if (remoteRels.has(rel)) continue;
+        fs.unlinkSync(path.join(root, rel));
+        deleted += 1;
+      }
     }
-    return { downloaded: items.length };
+    return { downloaded, skipped: skippedCount, deleted };
   }
 }