@eigenpal/sdk 0.16.3 → 0.16.4

package/src/resources/files.ts

@@ -7,7 +7,37 @@ import {
   filesUploadsAbort,
   filesUploadsComplete,
   filesUploadsCreate,
+  filesUploadsGet,
+  filesUploadsPartsList,
+  filesUploadsPartsPresign,
 } from '../generated/sdk.gen';
+import {
+  byteViewToArrayBuffer,
+  destroyUnreadNodeReadable,
+  ensureNodeReadableFullySent,
+  isNodeReadableStream,
+  toPutBody,
+  type StreamableRequestInit,
+} from '../lib/fetch-body';
+import {
+  isFileDescriptor,
+  isFileInput,
+  isPathFileInput,
+  isStreamFactoryFileInput,
+  resolveFileBlob,
+  statUploadSize,
+  type FileInput,
+} from '../lib/files';
+import {
+  annotateMultipartCompleteFailure,
+  annotatePresignedPutCompleteFailure,
+  filterStorageHeaders,
+  PartUploadHttpError,
+  shouldAbortMultipartUploadSession,
+  shouldAbortPresignedPutUploadSession,
+  uploadPresignedMultipartParts,
+  type ListedUploadPart,
+} from '../lib/upload-presigned-multipart';
 
 type Dispatch = <T>(
   call: () => Promise<OperationResult<T>>,
@@ -54,58 +84,136 @@ function newIdempotencyKey(): string {
   return `upload_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
 }
 
+type UploadableFile = FileInput | Uint8Array | ArrayBuffer;
+
 export class FilesResource {
   constructor(
     private readonly client: Client,
     private readonly dispatch: Dispatch
   ) {}
 
-  async upload(file: Blob | File, options: UploadOptions = {}): Promise<AnyResponse> {
-    const filename =
-      options.filename ??
-      (typeof File !== 'undefined' && file instanceof File ? file.name : undefined);
-    if (!filename) throw new Error('filename is required when uploading a Blob');
+  async upload(file: UploadableFile, options: UploadOptions = {}): Promise<AnyResponse> {
+    const source = await resolveUploadableSource(file, options.filename);
     const idempotencyKey = options.idempotencyKey ?? newIdempotencyKey();
     const negotiation = await this.createUpload(
       {
-        filename,
-        contentType: file.type || 'application/octet-stream',
-        size: file.size,
+        filename: source.filename,
+        contentType: source.contentType,
+        size: source.size,
         idempotencyKey,
         ...(options.purpose ? { purpose: options.purpose } : {}),
       },
       options
     );
 
-    if (negotiation.transport === 'presigned-put') {
+    if (negotiation.transport === 'presigned-multipart') {
+      if (!source.replayable) {
+        throw new Error(
+          'Cannot resume a multipart upload from a one-shot stream. Pass a file path, Blob, or a reusable stream factory.'
+        );
+      }
+      let partsReady = false;
       try {
-        const response = await fetch(negotiation.url, {
-          method: 'PUT',
-          headers: Object.fromEntries(
-            Object.entries((negotiation.headers ?? {}) as Record<string, string>).filter(
-              ([name]) => name.toLowerCase() !== 'content-length'
-            )
-          ),
-          body: file,
+        await uploadPresignedMultipartParts({
+          partCount: negotiation.partCount,
+          partSizeBytes: negotiation.partSizeBytes,
+          totalSize: source.size,
           signal: options.signal,
+          onProgress: options.onProgress,
+          listParts: async () => {
+            const listed = await this.dispatch(
+              () =>
+                this.client.get({
+                  url: negotiation.partsUrl,
+                  signal: options.signal,
+                }) as Promise<OperationResult<{ parts?: ListedUploadPart[] }>>
+            );
+            return listed.parts ?? [];
+          },
+          presignPart: async (partNumber) => {
+            return this.dispatch(
+              () =>
+                this.client.post({
+                  url: negotiation.partsUrl,
+                  body: { partNumber } as never,
+                  signal: options.signal,
+                }) as Promise<
+                  OperationResult<{
+                    url: string;
+                    headers?: Record<string, string>;
+                    partSizeBytes: number;
+                  }>
+                >
+            );
+          },
+          putPart: async ({ url, headers, start, length }) => {
+            const body = await source.openPart(start, length);
+            const response = await putStorage(
+              url,
+              headers,
+              body,
+              options.signal,
+              source.stripContentLength,
+              length
+            );
+            if (!response.ok) throw new PartUploadHttpError(response.status);
+          },
         });
+        partsReady = true;
+        return await this.dispatch(
+          () =>
+            this.client.post({
+              url: negotiation.completeUrl,
+              body: {} as never,
+              signal: options.signal,
+            }) as Promise<OperationResult<AnyResponse>>
+        );
+      } catch (error) {
+        if (shouldAbortMultipartUploadSession({ partsReady })) {
+          await this.abortUpload(negotiation.uploadId, {
+            signal: uploadAbortCleanupSignal(),
+          }).catch(() => undefined);
+          throw error;
+        }
+        throw annotateMultipartCompleteFailure(negotiation.uploadId, error);
+      }
+    }
+
+    if (negotiation.transport === 'presigned-put') {
+      let putReady = false;
+      try {
+        const body = await source.openPart(0, source.size);
+        const response = await putStorage(
+          negotiation.url,
+          (negotiation.headers ?? {}) as Record<string, string>,
+          body,
+          options.signal,
+          source.stripContentLength,
+          source.size
+        );
         if (!response.ok) {
           throw new Error(`Storage upload failed (${response.status}); retry the upload`);
         }
-        options.onProgress?.(file.size, file.size);
-        return await this.completeUpload(negotiation.uploadId, options);
+        putReady = true;
+        options.onProgress?.(source.size, source.size);
       } catch (error) {
-        // Caller cancellation and response-loss also reach here. Cleanup must
-        // not inherit the failed/aborted signal, and must remain bounded.
-        await this.abortUpload(negotiation.uploadId, {
-          signal: uploadAbortCleanupSignal(),
-        }).catch(() => undefined);
+        if (shouldAbortPresignedPutUploadSession({ putReady })) {
+          await this.abortUpload(negotiation.uploadId, {
+            signal: uploadAbortCleanupSignal(),
+          }).catch(() => undefined);
+        }
         throw error;
       }
+      try {
+        return await this.completeUpload(negotiation.uploadId, options);
+      } catch (error) {
+        throw annotatePresignedPutCompleteFailure(negotiation.uploadId, error);
+      }
     }
 
+    const blob = await source.asBlob();
     const form = new FormData();
-    form.append('file', file, filename);
+    form.append('file', blob, source.filename);
     if (options.purpose) form.append('purpose', options.purpose);
     const uploaded = await this.dispatch(
       () =>
@@ -117,7 +225,7 @@ export class FilesResource {
           signal: options.signal,
         }) as Promise<OperationResult<AnyResponse>>
     );
-    options.onProgress?.(file.size, file.size);
+    options.onProgress?.(source.size, source.size);
     return uploaded;
   }
 
@@ -159,6 +267,41 @@ export class FilesResource {
     );
   }
 
+  async getUpload(uploadId: string, options: SignalOptions = {}): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      filesUploadsGet({
+        client: this.client,
+        path: { uploadId },
+        signal: options.signal,
+      })
+    );
+  }
+
+  async listUploadParts(uploadId: string, options: SignalOptions = {}): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      filesUploadsPartsList({
+        client: this.client,
+        path: { uploadId },
+        signal: options.signal,
+      })
+    );
+  }
+
+  async presignUploadPart(
+    uploadId: string,
+    partNumber: number,
+    options: SignalOptions = {}
+  ): Promise<AnyResponse> {
+    return this.dispatch(() =>
+      filesUploadsPartsPresign({
+        client: this.client,
+        path: { uploadId },
+        body: { partNumber },
+        signal: options.signal,
+      })
+    );
+  }
+
   async get(fileId: string, options: SignalOptions = {}): Promise<AnyResponse> {
     return this.dispatch(() =>
       filesGet({ client: this.client, path: { id: fileId }, signal: options.signal })
@@ -186,3 +329,179 @@ export class FilesResource {
     );
   }
 }
+
+type ResolvedUploadSource = {
+  filename: string;
+  contentType: string;
+  size: number;
+  replayable: boolean;
+  stripContentLength: boolean;
+  openPart: (start: number, length: number) => Promise<BodyInit>;
+  asBlob: () => Promise<Blob>;
+};
+
+async function resolveUploadableSource(
+  file: UploadableFile,
+  filenameOption?: string
+): Promise<ResolvedUploadSource> {
+  if (file instanceof Uint8Array) {
+    const filename = filenameOption || 'file';
+    return {
+      filename,
+      contentType: 'application/octet-stream',
+      size: file.byteLength,
+      replayable: true,
+      stripContentLength: false,
+      openPart: async (start, length) =>
+        byteViewToArrayBuffer(file.subarray(start, start + length)),
+      asBlob: async () => new Blob([file as BlobPart]),
+    };
+  }
+  if (file instanceof ArrayBuffer) {
+    const filename = filenameOption || 'file';
+    const bytes = new Uint8Array(file);
+    return {
+      filename,
+      contentType: 'application/octet-stream',
+      size: bytes.byteLength,
+      replayable: true,
+      stripContentLength: false,
+      openPart: async (start, length) =>
+        byteViewToArrayBuffer(bytes.subarray(start, start + length)),
+      asBlob: async () => new Blob([bytes as BlobPart]),
+    };
+  }
+
+  if (!isFileInput(file)) {
+    throw new Error('filename is required when uploading a Blob');
+  }
+
+  if (typeof Blob !== 'undefined' && file instanceof Blob) {
+    const filename =
+      filenameOption ??
+      (typeof File !== 'undefined' && file instanceof File ? file.name : undefined);
+    if (!filename) throw new Error('filename is required when uploading a Blob');
+    return {
+      filename,
+      contentType: file.type || 'application/octet-stream',
+      size: file.size,
+      replayable: true,
+      stripContentLength: true,
+      openPart: async (start, length) => file.slice(start, start + length),
+      asBlob: async () => file,
+    };
+  }
+
+  if (isPathFileInput(file) || hasNodePath(file)) {
+    const filePath = isPathFileInput(file) ? file.path : (file as { path: string }).path;
+    const meta = await statUploadSize(file);
+    const filename = filenameOption || meta.filename;
+    return {
+      filename,
+      contentType: meta.contentType,
+      size: meta.size,
+      replayable: true,
+      stripContentLength: false,
+      openPart: async (start, length) => {
+        if (length === 0) return byteViewToArrayBuffer(new Uint8Array());
+        const { createReadStream } = await import('node:fs');
+        return toPutBody(
+          createReadStream(filePath, {
+            start,
+            end: start + length - 1,
+          })
+        );
+      },
+      asBlob: async () => (await resolveFileBlob(file)).blob,
+    };
+  }
+
+  if (isStreamFactoryFileInput(file)) {
+    return {
+      filename: filenameOption || file.filename,
+      contentType: file.mimeType || 'application/octet-stream',
+      size: file.size,
+      replayable: true,
+      stripContentLength: false,
+      openPart: async (start, length) => {
+        const part = file.open(start, length);
+        if (part instanceof Uint8Array) return byteViewToArrayBuffer(part);
+        if (isNodeReadableStream(part)) return toPutBody(part);
+        return part;
+      },
+      asBlob: async () => (await resolveFileBlob(file)).blob,
+    };
+  }
+
+  if (isFileDescriptor(file)) {
+    const filename = filenameOption || file.filename;
+    const type = file.mimeType || 'application/octet-stream';
+    if (typeof Blob !== 'undefined' && file.content instanceof Blob) {
+      const blob = file.content;
+      return {
+        filename,
+        contentType: type,
+        size: blob.size,
+        replayable: true,
+        stripContentLength: true,
+        openPart: async (start, length) => blob.slice(start, start + length),
+        asBlob: async () => blob,
+      };
+    }
+    const bytes =
+      file.content instanceof ArrayBuffer
+        ? new Uint8Array(file.content)
+        : new Uint8Array(
+            (file.content as ArrayBufferView).buffer,
+            (file.content as ArrayBufferView).byteOffset,
+            (file.content as ArrayBufferView).byteLength
+          );
+    return {
+      filename,
+      contentType: type,
+      size: bytes.byteLength,
+      replayable: true,
+      stripContentLength: false,
+      openPart: async (start, length) =>
+        byteViewToArrayBuffer(bytes.subarray(start, start + length)),
+      asBlob: async () => new Blob([bytes as BlobPart], { type }),
+    };
+  }
+
+  throw new Error(
+    'Cannot upload a one-shot stream. Pass a file path, Blob, or a reusable stream factory.'
+  );
+}
+
+function hasNodePath(file: FileInput): file is FileInput & { path: string } {
+  return typeof (file as { path?: unknown }).path === 'string';
+}
+
+async function putStorage(
+  url: string,
+  headers: Record<string, string>,
+  body: BodyInit,
+  signal: AbortSignal | undefined,
+  stripContentLength: boolean,
+  expectedByteLength?: number
+): Promise<Response> {
+  const stream = isNodeReadableStream(body);
+  const init: StreamableRequestInit = {
+    method: 'PUT',
+    headers: filterStorageHeaders(headers, stripContentLength && !stream),
+    body,
+    signal,
+    ...(stream ? { duplex: 'half' as const } : {}),
+  };
+  let response: Response;
+  try {
+    response = await fetch(url, init);
+  } catch (error) {
+    if (stream) destroyUnreadNodeReadable(body as NodeJS.ReadableStream);
+    throw error;
+  }
+  if (stream) {
+    await ensureNodeReadableFullySent(body as NodeJS.ReadableStream, expectedByteLength);
+  }
+  return response;
+}

package/src/telemetry.ts

@@ -19,7 +19,7 @@
 export const SDK_LANGUAGE = 'typescript';
 // Rewritten at publish time by scripts/release/platform/render-sdk-versions.sh.
 // Keep this string literal exactly stable — sed matches on it.
-export const SDK_VERSION = '0.16.3';
+export const SDK_VERSION = '0.16.4';
 
 function detectRuntime(): string {
   const g = globalThis as unknown as {