@slates/provider 1.0.0-rc.20 → 1.0.0-rc.21

package/dist/index.cjs

@@ -1210,8 +1210,38 @@ var createTextAttachment = (content, mimeType, attachmentHash) => ({
 });
 
 // src/action/directUpload.ts
+var bufferAttachmentBody = async (body, maxSizeBytes) => {
+  if (body instanceof Uint8Array) {
+    if (body.byteLength > maxSizeBytes) {
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    return body;
+  }
+  let reader = body.getReader();
+  let chunks = [];
+  let sizeBytes = 0;
+  while (true) {
+    let { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    sizeBytes += value.byteLength;
+    if (sizeBytes > maxSizeBytes) {
+      await reader.cancel();
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    chunks.push(value);
+  }
+  let buffered = new Uint8Array(sizeBytes);
+  let offset = 0;
+  for (let chunk of chunks) {
+    buffered.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return buffered;
+};
 var uploadAttachmentDirect = async (d) => {
   let baseUrl = d.live.baseUrl.replace(/\/$/, "");
+  let body = await bufferAttachmentBody(d.body, d.live.maxAttachmentSizeBytes);
   let registerRes = await fetch(`${baseUrl}/slates-hub/live-invocation/attachments`, {
     method: "POST",
     headers: {
@@ -1219,7 +1249,13 @@ var uploadAttachmentDirect = async (d) => {
       authorization: `Bearer ${d.live.token}`
     },
     body: JSON.stringify({
-      attachments: [{ mimeType: d.mimeType, filename: d.filename }]
+      attachments: [
+        {
+          mimeType: d.mimeType,
+          filename: d.filename,
+          sizeBytes: body.byteLength || void 0
+        }
+      ]
     })
   });
   if (!registerRes.ok) {
@@ -1234,9 +1270,11 @@ var uploadAttachmentDirect = async (d) => {
   }
   let putRes = await fetch(registration.uploadUrl, {
     method: "PUT",
-    ...d.body instanceof Uint8Array ? {} : { duplex: "half" },
-    headers: d.mimeType ? { "content-type": d.mimeType } : void 0,
-    body: d.body
+    headers: {
+      ...d.mimeType ? { "content-type": d.mimeType } : {},
+      "content-length": String(body.byteLength)
+    },
+    body
   });
   if (!putRes.ok) {
     throw new Error(`Failed to upload attachment content (status ${putRes.status})`);

package/dist/index.module.js

@@ -1101,8 +1101,38 @@ var createTextAttachment = (content, mimeType, attachmentHash) => ({
 });
 
 // src/action/directUpload.ts
+var bufferAttachmentBody = async (body, maxSizeBytes) => {
+  if (body instanceof Uint8Array) {
+    if (body.byteLength > maxSizeBytes) {
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    return body;
+  }
+  let reader = body.getReader();
+  let chunks = [];
+  let sizeBytes = 0;
+  while (true) {
+    let { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    sizeBytes += value.byteLength;
+    if (sizeBytes > maxSizeBytes) {
+      await reader.cancel();
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    chunks.push(value);
+  }
+  let buffered = new Uint8Array(sizeBytes);
+  let offset = 0;
+  for (let chunk of chunks) {
+    buffered.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return buffered;
+};
 var uploadAttachmentDirect = async (d) => {
   let baseUrl = d.live.baseUrl.replace(/\/$/, "");
+  let body = await bufferAttachmentBody(d.body, d.live.maxAttachmentSizeBytes);
   let registerRes = await fetch(`${baseUrl}/slates-hub/live-invocation/attachments`, {
     method: "POST",
     headers: {
@@ -1110,7 +1140,13 @@ var uploadAttachmentDirect = async (d) => {
       authorization: `Bearer ${d.live.token}`
     },
     body: JSON.stringify({
-      attachments: [{ mimeType: d.mimeType, filename: d.filename }]
+      attachments: [
+        {
+          mimeType: d.mimeType,
+          filename: d.filename,
+          sizeBytes: body.byteLength || void 0
+        }
+      ]
     })
   });
   if (!registerRes.ok) {
@@ -1125,9 +1161,11 @@ var uploadAttachmentDirect = async (d) => {
   }
   let putRes = await fetch(registration.uploadUrl, {
     method: "PUT",
-    ...d.body instanceof Uint8Array ? {} : { duplex: "half" },
-    headers: d.mimeType ? { "content-type": d.mimeType } : void 0,
-    body: d.body
+    headers: {
+      ...d.mimeType ? { "content-type": d.mimeType } : {},
+      "content-length": String(body.byteLength)
+    },
+    body
   });
   if (!putRes.ok) {
     throw new Error(`Failed to upload attachment content (status ${putRes.status})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider",
-  "version": "1.0.0-rc.20",
+  "version": "1.0.0-rc.21",
   "publishConfig": {
     "access": "public"
   },

package/src/action/directUpload.test.ts

@@ -0,0 +1,70 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { uploadAttachmentDirect } from './directUpload';
+
+let live = {
+  token: 'live-token',
+  baseUrl: 'https://hub.example/',
+  maxAttachmentSizeBytes: 10
+};
+
+describe('uploadAttachmentDirect', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('buffers streams and uploads them with their exact content length', async () => {
+    let fetchSpy = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValueOnce(
+        Response.json({
+          attachments: [
+            { referenceId: 'attachment-reference', uploadUrl: 'https://s3.example/upload' }
+          ]
+        })
+      )
+      .mockResolvedValueOnce(new Response(null, { status: 200 }));
+    let body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new Uint8Array([1, 2]));
+        controller.enqueue(new Uint8Array([3, 4, 5]));
+        controller.close();
+      }
+    });
+
+    await expect(
+      uploadAttachmentDirect({ live, body, mimeType: 'application/octet-stream' })
+    ).resolves.toEqual({
+      mimeType: 'application/octet-stream',
+      content: { type: 'upload_reference', referenceId: 'attachment-reference' }
+    });
+
+    expect(JSON.parse(fetchSpy.mock.calls[0]![1]!.body as string)).toEqual({
+      attachments: [{ mimeType: 'application/octet-stream', sizeBytes: 5 }]
+    });
+    let upload = fetchSpy.mock.calls[1]!;
+    expect(upload[0]).toBe('https://s3.example/upload');
+    expect(upload[1]).toMatchObject({
+      method: 'PUT',
+      headers: {
+        'content-type': 'application/octet-stream',
+        'content-length': '5'
+      }
+    });
+    expect(upload[1]!.body).toEqual(new Uint8Array([1, 2, 3, 4, 5]));
+    expect(upload[1]).not.toHaveProperty('duplex');
+  });
+
+  it('rejects an oversized stream before registering an upload', async () => {
+    let fetchSpy = vi.spyOn(globalThis, 'fetch');
+    let body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new Uint8Array(11));
+      }
+    });
+
+    await expect(uploadAttachmentDirect({ live, body })).rejects.toThrow(
+      'Attachment exceeds the maximum size of 10 bytes'
+    );
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+});

package/src/action/directUpload.ts

@@ -13,10 +13,48 @@ export interface SlateDirectUploadInput {
   body: ReadableStream<Uint8Array> | Uint8Array;
 }
 
+let bufferAttachmentBody = async (
+  body: SlateDirectUploadInput['body'],
+  maxSizeBytes: number
+) => {
+  if (body instanceof Uint8Array) {
+    if (body.byteLength > maxSizeBytes) {
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    return body;
+  }
+
+  let reader = body.getReader();
+  let chunks: Uint8Array[] = [];
+  let sizeBytes = 0;
+
+  while (true) {
+    let { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+
+    sizeBytes += value.byteLength;
+    if (sizeBytes > maxSizeBytes) {
+      await reader.cancel();
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    chunks.push(value);
+  }
+
+  let buffered = new Uint8Array(sizeBytes);
+  let offset = 0;
+  for (let chunk of chunks) {
+    buffered.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return buffered;
+};
+
 export let uploadAttachmentDirect = async (
   d: SlateDirectUploadInput
 ): Promise<SlateAttachment> => {
   let baseUrl = d.live.baseUrl.replace(/\/$/, '');
+  let body = await bufferAttachmentBody(d.body, d.live.maxAttachmentSizeBytes);
 
   let registerRes = await fetch(`${baseUrl}/slates-hub/live-invocation/attachments`, {
     method: 'POST',
@@ -25,7 +63,13 @@ export let uploadAttachmentDirect = async (
       authorization: `Bearer ${d.live.token}`
     },
     body: JSON.stringify({
-      attachments: [{ mimeType: d.mimeType, filename: d.filename }]
+      attachments: [
+        {
+          mimeType: d.mimeType,
+          filename: d.filename,
+          sizeBytes: body.byteLength || undefined
+        }
+      ]
     })
   });
   if (!registerRes.ok) {
@@ -44,9 +88,11 @@ export let uploadAttachmentDirect = async (
 
   let putRes = await fetch(registration.uploadUrl, {
     method: 'PUT',
-    ...(d.body instanceof Uint8Array ? {} : ({ duplex: 'half' } as any)),
-    headers: d.mimeType ? { 'content-type': d.mimeType } : undefined,
-    body: d.body
+    headers: {
+      ...(d.mimeType ? { 'content-type': d.mimeType } : {}),
+      'content-length': String(body.byteLength)
+    },
+    body
   });
   if (!putRes.ok) {
     throw new Error(`Failed to upload attachment content (status ${putRes.status})`);