@homecloud-platform/sdk 0.5.1 → 0.5.4

package/README.md

@@ -32,6 +32,11 @@ exports.handler = async (event, context) => {
     accountId: context.account_id,
   });
   await client.so.putJson("my-bucket", "proof/ok.json", { ok: true });
+  await client.so.upload("my-bucket", null, {
+    body: Buffer.from("..."),
+    key: "videos/clip.mp4",
+    contentType: "video/mp4",
+  });
   return { ok: true };
 };
 ```

package/package.json

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

package/src/mq.js

@@ -60,13 +60,13 @@ class MqAPI {
     return this._c.dataPlaneRequest("mq", "POST", reqPath, { json: payload });
   }
 
-  async receive(queueName, { maxMessages = 1, waitSeconds = 20 } = {}) {
+  async receive(queueName, { maxMessages = 1, waitSeconds = 20, delete: shouldDelete = false } = {}) {
     this._c.requireAccessKey();
     const accountId = this._c.accountId;
     const reqPath = `/${accountId}/${queueName}/messages`;
-    const data = await this._c.dataPlaneRequest("mq", "GET", reqPath, {
-      params: { max_messages: maxMessages, wait_seconds: waitSeconds },
-    });
+    const params = { max_messages: maxMessages, wait_seconds: waitSeconds };
+    if (shouldDelete) params.delete = "true";
+    const data = await this._c.dataPlaneRequest("mq", "GET", reqPath, { params });
     return data.items || [];
   }
 
@@ -84,13 +84,13 @@ class MqAPI {
     await this._c.dataPlaneRequest("mq", "POST", reqPath);
   }
 
-  async receiveDlq(queueName, { maxMessages = 1, waitSeconds = 20 } = {}) {
+  async receiveDlq(queueName, { maxMessages = 1, waitSeconds = 20, delete: shouldDelete = false } = {}) {
     this._c.requireAccessKey();
     const accountId = this._c.accountId;
     const reqPath = `/${accountId}/${queueName}/dlq/messages`;
-    const data = await this._c.dataPlaneRequest("mq", "GET", reqPath, {
-      params: { max_messages: maxMessages, wait_seconds: waitSeconds },
-    });
+    const params = { max_messages: maxMessages, wait_seconds: waitSeconds };
+    if (shouldDelete) params.delete = "true";
+    const data = await this._c.dataPlaneRequest("mq", "GET", reqPath, { params });
     return data.items || [];
   }
 

package/src/so.js

@@ -2,10 +2,38 @@
 
 const fs = require("fs");
 const path = require("path");
-const os = require("os");
 const { soObjectPaths } = require("./signing");
 const { HomeCloudError } = require("./errors");
 
+const MIME_BY_EXT = {
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".pdf": "application/pdf",
+  ".json": "application/json",
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".xml": "application/xml",
+  ".csv": "text/csv",
+  ".zip": "application/zip",
+};
+
+function _guessContentType(name) {
+  const ext = path.extname(String(name || "")).toLowerCase();
+  return MIME_BY_EXT[ext] || null;
+}
+
 class SoAPI {
   constructor(client) {
     this._c = client;
@@ -58,34 +86,56 @@ class SoAPI {
     return items;
   }
 
-  async upload(bucketName, filePath, { key } = {}) {
+  async upload(bucketName, filePath, { key, body, contentType } = {}) {
     this._c.requireAccessKey();
-    if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
-      throw new HomeCloudError(`File not found: ${filePath}`);
+    const hasBody = body !== undefined && body !== null;
+    if (hasBody && filePath != null && filePath !== "") {
+      throw new HomeCloudError("Pass either filePath or body, not both");
+    }
+    if (!hasBody && (filePath == null || filePath === "")) {
+      throw new HomeCloudError("filePath or body is required");
     }
-    const objectKey = key || path.basename(filePath);
+    if (hasBody && (!key || !String(key).trim())) {
+      throw new HomeCloudError("key is required when uploading body");
+    }
+
+    let objectKey;
+    let filename;
+    let payload;
+
+    if (hasBody) {
+      objectKey = String(key).trim().replace(/^\/+/, "");
+      filename = path.basename(objectKey) || "object";
+      payload = body;
+    } else {
+      if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+        throw new HomeCloudError(`File not found: ${filePath}`);
+      }
+      objectKey = key || path.basename(filePath);
+      filename = path.basename(filePath);
+      payload = fs.readFileSync(filePath);
+    }
+
+    const mime =
+      contentType ||
+      _guessContentType(objectKey) ||
+      _guessContentType(filename) ||
+      "application/octet-stream";
     const accountId = this._c.accountId;
     const uploadPath = `/${accountId}/${bucketName}/objects`;
-    const blob = fs.readFileSync(filePath);
     const form = new FormData();
     form.append("key", objectKey);
-    form.append("file", new Blob([blob]), path.basename(filePath));
+    form.append("file", new Blob([payload], { type: mime }), filename);
     return this._c.dataPlaneRequest("so", "POST", uploadPath, { formData: form });
   }
 
   async putJson(bucketName, objectKey, value) {
-    const tmp = path.join(
-      os.tmpdir(),
-      `hc-sdk-${Date.now()}-${Math.random().toString(16).slice(2)}.json`
-    );
-    fs.writeFileSync(tmp, JSON.stringify(value, null, 2), "utf8");
-    try {
-      return await this.upload(bucketName, tmp, { key: objectKey });
-    } finally {
-      try {
-        fs.unlinkSync(tmp);
-      } catch (_) {}
-    }
+    const data = Buffer.from(JSON.stringify(value, null, 2), "utf8");
+    return this.upload(bucketName, null, {
+      key: objectKey,
+      body: data,
+      contentType: "application/json",
+    });
   }
 
   async delete(bucketName, objectKey) {