@tinycloud/sdk-services 2.3.0-beta.5 → 2.3.0-beta.6

package/dist/index.cjs

@@ -921,6 +921,18 @@ var PrefixedKVService = class _PrefixedKVService {
     const fullKey = this.getFullKey(key);
     return this._kv.put(fullKey, value, { ...options, prefix: "" });
   }
+  /**
+   * Store multiple values within this prefix in one TinyCloud KV invocation.
+   */
+  async batchPut(items, options) {
+    return this._kv.batchPut(
+      items.map((item) => ({
+        ...item,
+        key: this.getFullKey(item.key)
+      })),
+      { ...options, prefix: "" }
+    );
+  }
   /**
    * List keys within this prefix.
    */
@@ -974,6 +986,12 @@ var KVAction = {
 };
 
 // src/kv/KVService.ts
+function encodeKvBatchPartName(path) {
+  return encodeURIComponent(path).replace(
+    /[!'()*]/g,
+    (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
 var KVService = class extends BaseService {
   /**
    * Create a new KVService instance.
@@ -1082,6 +1100,53 @@ var KVService = class extends BaseService {
       signal: this.combineSignals(signal)
     });
   }
+  serializeBatchPutValue(item) {
+    const contentType = item.contentType;
+    if (item.value instanceof Blob) {
+      if (!contentType || item.value.type === contentType) {
+        return item.value;
+      }
+      return new Blob([item.value], { type: contentType });
+    }
+    if (item.value instanceof ArrayBuffer) {
+      return new Blob([item.value], {
+        type: contentType ?? "application/octet-stream"
+      });
+    }
+    if (ArrayBuffer.isView(item.value)) {
+      const value = item.value;
+      const bytes = new Uint8Array(value.byteLength);
+      bytes.set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+      return new Blob([bytes], {
+        type: contentType ?? "application/octet-stream"
+      });
+    }
+    if (typeof item.value === "string") {
+      return new Blob([item.value], {
+        type: contentType ?? "text/plain;charset=UTF-8"
+      });
+    }
+    const json = JSON.stringify(item.value);
+    if (json === void 0) {
+      throw new Error(`Cannot JSON serialize KV batch value for key "${item.key}"`);
+    }
+    return new Blob([json], {
+      type: contentType ?? "application/json"
+    });
+  }
+  normalizeBatchPutResponse(data) {
+    if (!data || typeof data !== "object") {
+      return void 0;
+    }
+    const response = data;
+    if (!Array.isArray(response.written) || !response.written.every((key) => typeof key === "string") || typeof response.count !== "number") {
+      return void 0;
+    }
+    return {
+      written: response.written,
+      count: response.count
+    };
+  }
   /**
    * Create KVResponseHeaders from fetch response headers.
    *
@@ -1283,6 +1348,107 @@ var KVService = class extends BaseService {
       }
     });
   }
+  /**
+   * Store multiple values in one TinyCloud KV invocation.
+   */
+  async batchPut(items, options) {
+    return this.withTelemetry("batchPut", String(items.length), async () => {
+      if (!this.requireAuth()) {
+        return err(authRequiredError("kv"));
+      }
+      if (items.length === 0) {
+        return ok({ written: [], count: 0 });
+      }
+      if (!this.context.invokeAny) {
+        return err(
+          serviceError(
+            ErrorCodes.INVALID_INPUT,
+            "KV batchPut requires SDK runtime support for multi-resource invocations",
+            "kv"
+          )
+        );
+      }
+      const session = this.context.session;
+      const paths = items.map((item) => this.getFullPath(item.key, options?.prefix));
+      const seen = /* @__PURE__ */ new Set();
+      for (const path of paths) {
+        if (seen.has(path)) {
+          return err(
+            serviceError(
+              ErrorCodes.INVALID_INPUT,
+              `KV batchPut received duplicate key after prefix resolution: ${path}`,
+              "kv"
+            )
+          );
+        }
+        seen.add(path);
+      }
+      try {
+        const body = new FormData();
+        for (let index = 0; index < items.length; index++) {
+          body.append(
+            encodeKvBatchPartName(paths[index]),
+            this.serializeBatchPutValue(items[index])
+          );
+        }
+        const headers = this.context.invokeAny(
+          session,
+          paths.map((path) => ({
+            spaceId: session.spaceId,
+            service: "kv",
+            path,
+            action: KVAction.PUT
+          }))
+        );
+        const response = await this.context.fetch(`${this.host}/invoke`, {
+          method: "POST",
+          headers,
+          body,
+          signal: this.combineSignals(options?.signal)
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          if (response.status === 401 || response.status === 403) {
+            const { resource, action } = parseAuthError(errorText);
+            return err(authUnauthorizedError("kv", errorText, {
+              status: response.status,
+              ...action && { requiredAction: action },
+              ...resource && { resource }
+            }));
+          }
+          const quotaError = this.handleQuotaErrorResponse(
+            response,
+            errorText,
+            "batch"
+          );
+          if (quotaError) {
+            return quotaError;
+          }
+          return err(
+            serviceError(
+              ErrorCodes.KV_WRITE_FAILED,
+              `Failed to batch put ${items.length} key(s): ${response.status} - ${errorText}`,
+              "kv",
+              { meta: { status: response.status, statusText: response.statusText } }
+            )
+          );
+        }
+        const batchResponse = this.normalizeBatchPutResponse(await response.json());
+        if (!batchResponse || batchResponse.count !== batchResponse.written.length) {
+          return err(
+            serviceError(
+              ErrorCodes.NETWORK_ERROR,
+              "KV batchPut response did not include matching written keys and count",
+              "kv"
+            )
+          );
+        }
+        return ok(batchResponse);
+      } catch (error) {
+        return err(wrapError("kv", error));
+      }
+    });
+  }
   /**
    * List keys with optional prefix filtering.
    */