@sproutboat/runtime 0.19.0 → 0.19.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @sproutboat/runtime
 
+## 0.19.1
+
+### Patch Changes
+
+- 6676ead: `env.BUCKET.put(key, request.body)`, `env.KV.put(key, request.body)` and `fetch(url, { body: request.body })` store and send the request body again. Since 0.19.0, `body` is a `ReadableStream`, and these took its string form. Incoming request bodies are also read as the bytes they are, so `arrayBuffer()`, `blob()`, `body` and KV `put` no longer UTF-8 encode a non-ASCII upload twice. R2 `put` accepts bytes as well.
+
 ## 0.19.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/native-fetch-prelude.js

@@ -4045,7 +4045,14 @@ function __sbFromUtf8(bytes) {
 // #232 — a fetch() request body for the wire: text as-is, and an ArrayBuffer or
 // any view as its bytes (one char per byte) flagged bodyBinary, instead of
 // String(view), which sent "0,1,2,...".
+// A body stream the runtime made over a value (Response/Request body): that value. Bindings
+// that take a body at once (R2 and KV put, outbound fetch) read it without draining the
+// stream, so put(key, request.body) works as in Workers. Other values pass through.
+function __sbUnwrapBody(value) {
+  return value != null && value._sbBody !== undefined ? value._sbBody : value;
+}
 function __sbRequestBody(body) {
+  body = __sbUnwrapBody(body);
   if (body == null) return { body: null };
   if (!__sbIsStr(body) && body.byteLength !== undefined) {
     const bytes = body.buffer !== undefined ? new Uint8Array(body.buffer, body.byteOffset, body.byteLength) : body;
@@ -4966,6 +4973,7 @@ globalThis.__sbInstallBindings = function (target, bindings) {
         return type === "json" ? JSON.parse(text) : text;
       },
       put(key, value, options) {
+        value = __sbUnwrapBody(value);
         const msg = { ns, key: String(key), value: "" };
         if (value != null && !__sbIsStr(value) && value.byteLength !== undefined) {
           // ArrayBuffer or any ArrayBufferView: its bytes, not String(view) ("0,1,2,...").
@@ -5011,12 +5019,15 @@ globalThis.__sbInstallBindings = function (target, bindings) {
     const name = bindings.r2[i];
     target[name] = {
       put(key, value, options) {
+        value = __sbUnwrapBody(value);
         const o = options || {};
         // #56 — the body goes out of band where the transport allows it.
+        // Bytes go in as bytes: a byte view or the bytes of a body stream (request.body).
+        const raw = value == null ? "" : !__sbIsStr(value) && value.byteLength !== undefined ? __sbToBytes(value.buffer !== undefined ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : value) : String(value);
         return __sbR2Put(
           name,
           String(key),
-          value == null ? "" : String(value),
+          raw,
           o.httpMetadata || {},
           o.customMetadata || {},
         ).object;
@@ -5802,6 +5813,8 @@ async function __sbQueueWithDrain(result, tasks) {
 function __sbDecodeIngress(request) {
   const raw = __sbRawBody(request);
   if (raw == null) return;
+  // Raw bytes, one character each: arrayBuffer(), blob() and body read them as bytes.
+  request._bodyLatin1 = true;
   let decoded = null;
   request.text = function () {
     if (decoded === null) decoded = __sbFromUtf8(raw);

package/test/native-request.ts

@@ -20,7 +20,7 @@ const CASES = [
 ];
 const handler = `export default {async fetch(request) {
   // The incoming request: its body is a ReadableStream, and text() still reads it.
-  if (request.method === "POST") return new Response((request.body instanceof ReadableStream) + ":" + (await request.text()));
+  if (request.method === "POST") { const viaStream = await new Response(request.body).text(); return new Response((request.body instanceof ReadableStream) + ":" + viaStream); }
   const cases = [
 ${CASES.map((c) => `    () => (${c}),`).join("\n")}
   ];

package/test/native-utf8.ts

@@ -17,7 +17,14 @@ const text = "/café/日本/😀/x";
 const handler = `
 const URL = "shadowed";
 export default {
-  async fetch() {
+  async fetch(request) {
+    // put(key, request.body) and fetch(url, { body: request.body }) are the Workers idiom:
+    // body is a ReadableStream, and the bindings take the value it was made from.
+    if (request.method === "POST") {
+      env.UPLOADS.put("upload", request.body);
+      await env.KV.put("upload", request.body);
+      return Response.json({ r2: env.UPLOADS.get("upload").text(), kv: await env.KV.get("upload") });
+    }
     await env.KV.put("k", ${JSON.stringify(text)});
     const kv = await env.KV.get("k");
     await env.DB.prepare("CREATE TABLE t (v TEXT)").run();
@@ -38,7 +45,7 @@ function freePort(): number {
 }
 
 const workdir = await mkdtemp(join(tmpdir(), "sb-native-utf8-"));
-const bindings = { ...EMPTY_BINDINGS, kv: ["KV"], d1: ["DB"] };
+const bindings = { ...EMPTY_BINDINGS, kv: ["KV"], d1: ["DB"], r2: ["UPLOADS"] };
 const broker = createBroker({
   db: ":memory:",
   token: "native-utf8",
@@ -113,7 +120,9 @@ try {
   );
   assert.match(body.error, /tabellà/);
   assert.equal(body.url, "shadowed");
-  console.log("Non-ASCII KV, D1 and error text round-trip through the broker; a handler-level URL stays scoped");
+  const stored = await (await fetch(`http://127.0.0.1:${port}/`, { method: "POST", body: "uploaded é" })).json();
+  assert.deepEqual(stored, { r2: "uploaded é", kv: "uploaded é" }, "put(key, request.body) stores the request body");
+  console.log("Non-ASCII KV, D1 and error text round-trip through the broker; a handler-level URL stays scoped; put(key, request.body) stores the body");
 } finally {
   if (server) {
     server.kill(9);