@beam-network/sdk 0.2.0 → 0.2.2

package/dist/client.d.ts

@@ -28,6 +28,7 @@ export declare class BeamClient {
         urlsExpiresAt?: string;
     }): Promise<AttachSignedUrlsResponse>;
     prepareProviderTransfer(input: ProviderTransferCreateInput): Promise<TransferPrepareResponse>;
+    private signProviderRoute;
     createAndDistribute(input: RawTransferCreateInput): Promise<TransferCreateResponse>;
     waitForTransfer(transferId: string, options?: {
         timeoutMs?: number;

package/dist/client.js

@@ -1,4 +1,4 @@
-import { abortMultipartUpload, createMultipartUpload, nowIso, prepareProviderDestination, prepareProviderSource, signAbortMultipartUpload, signCompleteMultipartUpload, signDestinationRoute } from "./provider-signing.js";
+import { abortMultipartUpload, createMultipartUpload, nowIso, prepareProviderDestination, prepareProviderSource, signAbortMultipartUpload, signCompleteMultipartUpload, signDeleteObject, signDestinationRoute, signListMultipartUpload, signUploadPartCopy } from "./provider-signing.js";
 export const BEAM_DEFAULT_URL = "https://beamcore.b1m.ai";
 export class BeamApiError extends Error {
     status;
@@ -119,6 +119,7 @@ export class BeamClient {
                                 uploadId: "",
                                 completeUrl: "",
                                 abortUrl: "",
+                                listUrl: "",
                                 multipartGroupId: multipartKey,
                                 multipartCreatedAt
                             };
@@ -131,28 +132,24 @@ export class BeamClient {
                                 uploadId,
                                 completeUrl: await signCompleteMultipartUpload(destination, finalObjectKey, uploadId, expiresIn),
                                 abortUrl: await signAbortMultipartUpload(destination, finalObjectKey, uploadId, expiresIn),
+                                listUrl: await signListMultipartUpload(destination, finalObjectKey, uploadId, expiresIn),
                                 multipartGroupId: multipartKey,
                                 multipartCreatedAt
                             };
                         }
                         multipartUploads.set(multipartKey, upload);
                     }
-                    routes.push(await signDestinationRoute({
+                    routes.push(await this.signProviderRoute({
                         chunk,
                         target,
                         destination,
                         expiresIn,
-                        uploadId: upload.uploadId,
+                        upload,
+                        transferId: prepared.transfer_id,
+                        finalObjectKey,
                         partNumber: typeof metadata.part_number === "number"
                             ? metadata.part_number
-                            : chunk.source_chunk_index + 1,
-                        multipartObjectKey: finalObjectKey,
-                        completeUrl: upload.completeUrl,
-                        abortUrl: upload.abortUrl,
-                        transferId: prepared.transfer_id,
-                        multipartGroupId: upload.multipartGroupId,
-                        multipartCreatedAt: upload.multipartCreatedAt,
-                        fetchImpl: this.fetchImpl
+                            : chunk.source_chunk_index + 1
                     }));
                 }
             }
@@ -179,6 +176,46 @@ export class BeamClient {
         }
         return prepared;
     }
+    async signProviderRoute(input) {
+        if (isHippiusDestination(input.destination)) {
+            return signDestinationRoute({
+                chunk: input.chunk,
+                target: input.target,
+                destination: input.destination,
+                expiresIn: input.expiresIn,
+                transferId: input.transferId,
+                multipartGroupId: input.upload.multipartGroupId,
+                multipartCreatedAt: input.upload.multipartCreatedAt,
+                fetchImpl: this.fetchImpl
+            });
+        }
+        if (!input.target.object_key) {
+            throw new Error("destination signing target is missing object_key");
+        }
+        const { copyUrl, copySource } = await signUploadPartCopy(input.destination, input.finalObjectKey, input.target.object_key, input.upload.uploadId, input.partNumber, input.expiresIn);
+        const deleteUrl = await signDeleteObject(input.destination, input.target.object_key, input.expiresIn);
+        return signDestinationRoute({
+            chunk: input.chunk,
+            target: input.target,
+            destination: input.destination,
+            expiresIn: input.expiresIn,
+            uploadId: input.upload.uploadId,
+            partNumber: input.partNumber,
+            multipartObjectKey: input.finalObjectKey,
+            completeUrl: input.upload.completeUrl,
+            abortUrl: input.upload.abortUrl,
+            listUrl: input.upload.listUrl,
+            transferId: input.transferId,
+            multipartGroupId: input.upload.multipartGroupId,
+            multipartCreatedAt: input.upload.multipartCreatedAt,
+            commitMethod: "upload_part_copy",
+            stagingObjectKey: input.target.object_key,
+            copyUrl,
+            copySource,
+            deleteUrl,
+            fetchImpl: this.fetchImpl
+        });
+    }
     async createAndDistribute(input) {
         const transfer = await this.createRawTransfer(input);
         if (transfer.success) {

package/dist/provider-signing.d.ts

@@ -13,6 +13,12 @@ export declare function prepareProviderDestination(destination: ProviderDestinat
 export declare function createMultipartUpload(destination: ProviderDestinationConfig, objectKey: string): Promise<string>;
 export declare function signCompleteMultipartUpload(destination: ProviderDestinationConfig, objectKey: string, uploadId: string, expiresIn: number): Promise<string>;
 export declare function signAbortMultipartUpload(destination: ProviderDestinationConfig, objectKey: string, uploadId: string, expiresIn: number): Promise<string>;
+export declare function signListMultipartUpload(destination: ProviderDestinationConfig, objectKey: string, uploadId: string, expiresIn: number): Promise<string>;
+export declare function signUploadPartCopy(destination: ProviderDestinationConfig, finalObjectKey: string, stagingObjectKey: string, uploadId: string, partNumber: number, expiresIn: number): Promise<{
+    copyUrl: string;
+    copySource: string;
+}>;
+export declare function signDeleteObject(destination: ProviderDestinationConfig, objectKey: string, expiresIn: number): Promise<string>;
 export declare function abortMultipartUpload(destination: ProviderDestinationConfig, objectKey: string, uploadId: string): Promise<void>;
 export declare function signDestinationRoute(input: {
     chunk: ChunkSigningPlanItem;
@@ -24,9 +30,15 @@ export declare function signDestinationRoute(input: {
     multipartObjectKey?: string;
     completeUrl?: string;
     abortUrl?: string;
+    listUrl?: string;
     transferId?: string;
     multipartGroupId?: string;
     multipartCreatedAt?: string;
+    commitMethod?: "upload_part_copy";
+    stagingObjectKey?: string;
+    copyUrl?: string;
+    copySource?: string;
+    deleteUrl?: string;
     fetchImpl?: typeof fetch;
 }): Promise<SignedChunkRoute>;
 export declare function isS3CompatibleProvider(config: ProviderSourceConfig | ProviderDestinationConfig): config is AnyS3CompatibleProviderConfig;

package/dist/provider-signing.js

@@ -1,4 +1,4 @@
-import { AbortMultipartUploadCommand, CompleteMultipartUploadCommand, CreateMultipartUploadCommand, GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client, UploadPartCommand } from "@aws-sdk/client-s3";
+import { AbortMultipartUploadCommand, CompleteMultipartUploadCommand, CreateMultipartUploadCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListPartsCommand, PutObjectCommand, S3Client, UploadPartCopyCommand, UploadPartCommand } from "@aws-sdk/client-s3";
 import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 export function nowIso() {
     return new Date().toISOString();
@@ -52,7 +52,9 @@ export function prepareProviderDestination(destination, options = {}) {
             destination_id: destinationId,
             provider: destination.provider,
             logical_prefix: destination.key,
-            metadata: s3CompatibleMetadata(destination, endpoint)
+            metadata: {
+                ...s3CompatibleMetadata(destination, endpoint)
+            }
         };
     }
     if (isHippiusProvider(destination)) {
@@ -60,7 +62,11 @@ export function prepareProviderDestination(destination, options = {}) {
             destination_id: destinationId,
             provider: "hippius",
             logical_prefix: destination.key.replace(/\/+$/, ""),
-            metadata: { bucket: destination.bucket, key: destination.key, base_url: destination.base_url ?? "https://api.hippius.com" }
+            metadata: {
+                bucket: destination.bucket,
+                key: destination.key,
+                base_url: destination.base_url ?? "https://api.hippius.com"
+            }
         };
     }
     return unsupportedProviderConfig(destination);
@@ -90,6 +96,37 @@ export async function signAbortMultipartUpload(destination, objectKey, uploadId,
     }
     throw new Error(`multipart abort is not supported for ${destination.provider}`);
 }
+export async function signListMultipartUpload(destination, objectKey, uploadId, expiresIn) {
+    if (isS3CompatibleProvider(destination)) {
+        const client = createS3CompatibleClient(destination);
+        return getSignedUrl(client, new ListPartsCommand({ Bucket: destination.bucket, Key: objectKey, UploadId: uploadId }), { expiresIn });
+    }
+    throw new Error(`multipart list-parts is not supported for ${destination.provider}`);
+}
+export async function signUploadPartCopy(destination, finalObjectKey, stagingObjectKey, uploadId, partNumber, expiresIn) {
+    if (isS3CompatibleProvider(destination)) {
+        const client = createS3CompatibleClient(destination);
+        const copySource = copySourceHeader(destination, stagingObjectKey);
+        return {
+            copySource,
+            copyUrl: await getSignedUrl(client, new UploadPartCopyCommand({
+                Bucket: destination.bucket,
+                Key: finalObjectKey,
+                UploadId: uploadId,
+                PartNumber: partNumber,
+                CopySource: copySource
+            }), { expiresIn })
+        };
+    }
+    throw new Error(`multipart copy is not supported for ${destination.provider}`);
+}
+export async function signDeleteObject(destination, objectKey, expiresIn) {
+    if (isS3CompatibleProvider(destination)) {
+        const client = createS3CompatibleClient(destination);
+        return getSignedUrl(client, new DeleteObjectCommand({ Bucket: destination.bucket, Key: objectKey }), { expiresIn });
+    }
+    throw new Error(`object delete signing is not supported for ${destination.provider}`);
+}
 export async function abortMultipartUpload(destination, objectKey, uploadId) {
     if (isS3CompatibleProvider(destination)) {
         await createS3CompatibleClient(destination).send(new AbortMultipartUploadCommand({ Bucket: destination.bucket, Key: objectKey, UploadId: uploadId }));
@@ -110,6 +147,7 @@ export async function signDestinationRoute(input) {
         expiresIn: input.expiresIn,
         uploadId: input.uploadId,
         partNumber: input.partNumber,
+        useStagingPut: input.commitMethod === "upload_part_copy",
         fetchImpl: input.fetchImpl
     });
     return {
@@ -126,17 +164,23 @@ export async function signDestinationRoute(input) {
             ...(input.transferId ? { transfer_id: input.transferId } : {}),
             ...(input.multipartGroupId ? { multipart_group_id: input.multipartGroupId } : {}),
             ...(input.multipartCreatedAt ? { multipart_created_at: input.multipartCreatedAt } : {}),
+            ...(input.commitMethod ? { commit_method: input.commitMethod } : {}),
+            ...(input.stagingObjectKey ? { staging_object_key: input.stagingObjectKey } : {}),
+            ...(input.copyUrl ? { copy_url: input.copyUrl } : {}),
+            ...(input.copySource ? { copy_source: input.copySource } : {}),
+            ...(input.deleteUrl ? { delete_url: input.deleteUrl } : {}),
             ...(input.uploadId ? { upload_id: input.uploadId } : {}),
             ...(input.partNumber ? { part_number: input.partNumber } : {}),
             ...(input.completeUrl ? { complete_url: input.completeUrl } : {}),
-            ...(input.abortUrl ? { abort_url: input.abortUrl } : {})
+            ...(input.abortUrl ? { abort_url: input.abortUrl } : {}),
+            ...(input.listUrl ? { list_url: input.listUrl } : {})
         }
     };
 }
 async function signDestinationUrl(input) {
     if (isS3CompatibleProvider(input.destination)) {
         const client = createS3CompatibleClient(input.destination);
-        if (input.uploadId && input.partNumber) {
+        if (input.uploadId && input.partNumber && !input.useStagingPut) {
             return getSignedUrl(client, new UploadPartCommand({
                 Bucket: input.destination.bucket,
                 Key: input.uploadPartObjectKey,
@@ -255,3 +299,6 @@ function hasText(value) {
 function unsupportedProviderConfig(value) {
     throw new Error(`Unsupported provider config: ${JSON.stringify(value)}`);
 }
+function copySourceHeader(destination, objectKey) {
+    return `/${destination.bucket}/${objectKey.split("/").map(encodeURIComponent).join("/")}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beam-network/sdk",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "TypeScript SDK for BEAM transfer creation and management.",
   "type": "module",
   "license": "MIT",