@edgestore/sdk 1.0.0-next.1 → 1.0.0-next.2

package/src/managementUpload.ts

@@ -0,0 +1,139 @@
+import type { ManagementUploadOperations } from './internal/managementUploadOperations';
+import type { OperationBody, OperationResult } from './internal/operationTypes';
+import type { Transport } from './internal/transport';
+import { executeUploadLifecycle } from './internal/uploadLifecycle';
+import { throwIfAborted } from './internal/uploadRetry';
+import {
+  normalizeUploadMetadata,
+  prepareUploadSource,
+  reportUploadProgress,
+} from './internal/uploadSource';
+import { assertNonNegative } from './internal/uploadValidation';
+import { planMultipartUpload } from './multipartPlan';
+import type {
+  UploadDefaults,
+  UploadMetadataValue,
+  UploadProgress,
+  UploadSource,
+} from './uploadTypes';
+import { DEFAULT_PROCESSING_TIMEOUT_MS } from './uploadTypes';
+
+type RequestBody = OperationBody<'v2.management.uploads.request'>;
+type RequestResult = OperationResult<'v2.management.uploads.request'>;
+type GetResult = OperationResult<'v2.management.uploads.get'>;
+type CompletedUpload = Extract<GetResult, { upload: { status: 'completed' } }>;
+
+/** Input for a complete administrative upload managed by the SDK. */
+export type ManagementUploadInput = Omit<
+  RequestBody,
+  'sizeBytes' | 'metadata' | 'multipart'
+> & {
+  project: string;
+  bucket: string;
+  source: UploadSource;
+  metadata?: Record<string, UploadMetadataValue>;
+  signal?: AbortSignal;
+  onProgress?: (progress: UploadProgress) => void;
+  multipart?:
+    | boolean
+    | {
+        partSizeBytes?: number;
+        concurrency?: number;
+      };
+  processingTimeoutMs?: number;
+};
+
+/** Completed administrative file upload. */
+export type ManagementUploadResult = CompletedUpload & {
+  signedReadUrl?: RequestResult['signedReadUrl'];
+};
+
+export async function uploadManagementFile(
+  context: {
+    transport: Transport;
+    operations: ManagementUploadOperations;
+  },
+  input: ManagementUploadInput,
+  defaults: UploadDefaults = {},
+): Promise<ManagementUploadResult> {
+  const { transport, operations } = context;
+  const {
+    project,
+    bucket,
+    source,
+    metadata,
+    signal,
+    onProgress,
+    multipart,
+    processingTimeoutMs = defaults.processingTimeoutMs ??
+      DEFAULT_PROCESSING_TIMEOUT_MS,
+    ...requestInput
+  } = input;
+  const prepared = prepareUploadSource(source);
+  const totalBytes = prepared.sizeBytes;
+  assertNonNegative(processingTimeoutMs, 'processingTimeoutMs');
+  throwIfAborted(signal);
+  reportUploadProgress(onProgress, {
+    transferredBytes: 0,
+    totalBytes,
+    phase: 'preparing',
+  });
+
+  const multipartPlan = planMultipartUpload({
+    sizeBytes: totalBytes,
+    thresholdBytes: defaults.multipartThresholdBytes,
+    preferredPartSizeBytes:
+      typeof multipart === 'object'
+        ? (multipart.partSizeBytes ?? defaults.multipartPartSizeBytes)
+        : defaults.multipartPartSizeBytes,
+    forceMultipart:
+      prepared.kind === 'stream' ||
+      multipart === true ||
+      typeof multipart === 'object',
+  });
+  const requested = await operations.request({
+    project,
+    bucket,
+    signal,
+    ...requestInput,
+    fileName: requestInput.fileName ?? prepared.fileName,
+    mimeType: requestInput.mimeType ?? prepared.mimeType,
+    sizeBytes: totalBytes,
+    metadata: normalizeUploadMetadata(metadata),
+    multipart: multipartPlan
+      ? { partNumbers: multipartPlan.partNumbers }
+      : undefined,
+  });
+  const completed = await executeUploadLifecycle<GetResult>({
+    transport,
+    requested,
+    prepared,
+    multipartPlan,
+    multipartConcurrency:
+      typeof multipart === 'object'
+        ? multipart.concurrency
+        : defaults.multipartConcurrency,
+    defaultMultipartConcurrency: defaults.multipartConcurrency,
+    processingTimeoutMs,
+    signal,
+    onProgress,
+    operations: {
+      completeMultipart: ({ uploadId, parts, signal: requestSignal }) =>
+        operations.completeMultipart({
+          project,
+          uploadId,
+          parts,
+          signal: requestSignal,
+        }),
+      get: ({ uploadId, signal: requestSignal }) =>
+        operations.getWithResponse({
+          project,
+          uploadId,
+          signal: requestSignal,
+        }),
+      cancel: ({ uploadId }) => operations.cancel({ project, uploadId }),
+    },
+    cleanupPolicy: 'report-failure',
+  });
+  return { ...completed, signedReadUrl: requested.signedReadUrl };
+}

package/src/sdk.ts

@@ -80,7 +80,7 @@ export function createEdgeStoreSdk(
   return credentials.kind === 'bearer'
     ? {
         runtime: createExplicitProjectRuntimeClient(transport, options.upload),
-        management: createManagementClient(transport),
+        management: createManagementClient(transport, options.upload),
         system,
       }
     : {

package/src/upload.ts

@@ -1,39 +1,25 @@
-import {
-  EdgeStoreAbortError,
-  EdgeStoreNetworkError,
-  EdgeStoreUploadCanceledError,
-  EdgeStoreUploadProcessingTimeoutError,
-} from './errors';
-import { uploadParts, uploadStreamParts } from './internal/multipartUpload';
+import { EdgeStoreAbortError, EdgeStoreNetworkError } from './errors';
 import {
   createGetUploadRequest,
   type RuntimeOperations,
 } from './internal/runtimeOperations';
 import type { Transport } from './internal/transport';
+import { executeUploadLifecycle } from './internal/uploadLifecycle';
+import { isAbortError, throwIfAborted } from './internal/uploadRetry';
 import {
-  getRetryAfterMs,
-  isAbortError,
-  retryOperation,
-  sleep,
-  throwIfAborted,
-} from './internal/uploadRetry';
-import { putWithRetry } from './internal/uploadTransfer';
-import {
-  assertNonNegative,
-  getPositiveInteger,
-} from './internal/uploadValidation';
+  normalizeUploadMetadata,
+  prepareUploadSource,
+  reportUploadProgress,
+} from './internal/uploadSource';
+import { assertNonNegative } from './internal/uploadValidation';
 import { planMultipartUpload } from './multipartPlan';
 import {
-  DEFAULT_MULTIPART_CONCURRENCY,
   DEFAULT_PROCESSING_TIMEOUT_MS,
-  type CompletedUpload,
   type RuntimeUploadFromUrlInput,
   type RuntimeUploadInput,
   type RuntimeUploadResult,
   type UploadDefaults,
-  type UploadMetadataValue,
   type UploadSource,
-  type UploadStreamSource,
 } from './uploadTypes';
 
 type ExplicitUploadInput = RuntimeUploadInput & { project: string };
@@ -41,17 +27,6 @@ type ExplicitUploadFromUrlInput = RuntimeUploadFromUrlInput & {
   project: string;
 };
 
-type PreparedUploadDetails = {
-  sizeBytes: number;
-  fileName?: string;
-  mimeType?: string;
-};
-type PreparedUploadSource =
-  | (PreparedUploadDetails & { kind: 'body'; body: Blob })
-  | (PreparedUploadDetails & {
-      kind: 'stream';
-      stream: ReadableStream<Uint8Array>;
-    });
 type UploadContext = {
   transport: Transport;
   operations: RuntimeOperations;
@@ -81,12 +56,12 @@ export async function uploadRuntimeFile(
     processingTimeoutMs = defaults.processingTimeoutMs ??
       DEFAULT_PROCESSING_TIMEOUT_MS,
   } = input;
-  const prepared = prepareSource(source);
+  const prepared = prepareUploadSource(source);
   const totalBytes = prepared.sizeBytes;
   assertNonNegative(processingTimeoutMs, 'processingTimeoutMs');
 
   throwIfAborted(signal);
-  reportProgress(onProgress, {
+  reportUploadProgress(onProgress, {
     transferredBytes: 0,
     totalBytes,
     phase: 'preparing',
@@ -123,101 +98,51 @@ export async function uploadRuntimeFile(
     temporary,
     path,
     extension,
-    metadata: normalizeMetadata(metadata),
+    metadata: normalizeUploadMetadata(metadata),
     replaceTarget,
     multipart: partNumbers ? { partNumbers } : undefined,
     signedReadUrl,
     signal,
   });
-  const uploadId = requested.upload.id;
-
-  try {
-    reportProgress(onProgress, {
-      transferredBytes: 0,
-      totalBytes,
-      phase: 'uploading',
-    });
-
-    if (prepared.kind === 'body' && requested.upload.kind === 'single') {
-      await putWithRetry(transport, {
-        uploadId,
-        url: requested.upload.signedUrl,
-        body: prepared.body,
-        signal,
-      });
-      reportProgress(onProgress, {
-        transferredBytes: totalBytes,
-        totalBytes,
-        phase: 'uploading',
-      });
-    } else {
-      if (requested.upload.kind !== 'multipart') {
-        throw new TypeError(
-          'The API returned a single upload URL for a stream source.',
-        );
-      }
-      if (!multipartPlan) {
-        throw new TypeError(
-          'The API returned a multipart upload for a single-upload request.',
-        );
-      }
-      const concurrency = getPositiveInteger(
-        typeof multipart === 'object'
-          ? multipart.concurrency
-          : defaults.multipartConcurrency,
-        defaults.multipartConcurrency ?? DEFAULT_MULTIPART_CONCURRENCY,
-        'multipart.concurrency',
-      );
-      const transferOptions = {
-        uploadId,
-        parts: requested.upload.parts,
-        partSizeBytes: multipartPlan.partSizeBytes,
-        signal,
-        onProgress,
-      };
-      const completedParts =
-        prepared.kind === 'stream'
-          ? await uploadStreamParts(transport, {
-              ...transferOptions,
-              stream: prepared.stream,
-              totalBytes,
-            })
-          : await uploadParts(transport, {
-              ...transferOptions,
-              body: prepared.body,
-              concurrency,
-            });
-      await operations.uploads.completeMultipart({
-        project,
-        uploadId,
-        parts: completedParts,
-        signal,
-      });
-    }
-
-    reportProgress(onProgress, {
-      transferredBytes: totalBytes,
-      totalBytes,
-      phase: 'processing',
-    });
-
-    const completed = await waitForUpload(context, {
-      project,
-      uploadId,
-      signal,
-      timeoutMs: processingTimeoutMs,
-    });
+  const completed = await executeUploadLifecycle({
+    transport,
+    requested,
+    prepared,
+    multipartPlan,
+    multipartConcurrency:
+      typeof multipart === 'object'
+        ? multipart.concurrency
+        : defaults.multipartConcurrency,
+    defaultMultipartConcurrency: defaults.multipartConcurrency,
+    processingTimeoutMs,
+    signal,
+    onProgress,
+    operations: {
+      completeMultipart: ({ uploadId, parts, signal: requestSignal }) =>
+        operations.uploads.completeMultipart({
+          project,
+          uploadId,
+          parts,
+          signal: requestSignal,
+        }),
+      get: ({ uploadId, signal: requestSignal }) =>
+        context.transport.executeWithResponse(
+          createGetUploadRequest({
+            project,
+            uploadId,
+            signal: requestSignal,
+          }),
+        ),
+      cancel: ({ uploadId }) =>
+        operations.uploads.cancel({ project, uploadId }),
+    },
+    cleanupPolicy: 'preserve-original',
+  });
 
-    return {
-      ...completed,
-      signedReadUrl: requested.signedReadUrl,
-    };
-  } catch (error) {
-    if (!(error instanceof EdgeStoreUploadProcessingTimeoutError)) {
-      await cancelUpload(operations, project, uploadId);
-    }
-    throw error;
-  }
+  return {
+    ...completed,
+    signedReadUrl: requested.signedReadUrl,
+  };
 }
 
 export async function uploadRuntimeFileFromUrl(
@@ -303,156 +228,6 @@ async function cancelResponseBody(
   await body.cancel().catch(() => undefined);
 }
 
-async function waitForUpload(
-  context: UploadContext,
-  options: {
-    project: string;
-    uploadId: string;
-    signal?: AbortSignal;
-    timeoutMs: number;
-  },
-): Promise<CompletedUpload> {
-  const deadline = Date.now() + options.timeoutMs;
-  const timeoutError = () =>
-    new EdgeStoreUploadProcessingTimeoutError(
-      'Timed out while EdgeStore was processing the upload.',
-      options.uploadId,
-    );
-
-  while (true) {
-    const { data, response } = await retryOperation(
-      (signal) =>
-        context.transport.executeWithResponse(
-          createGetUploadRequest({
-            project: options.project,
-            uploadId: options.uploadId,
-            signal,
-          }),
-        ),
-      {
-        signal: options.signal,
-        deadline,
-        timeoutError,
-      },
-    );
-
-    if (data.upload.status === 'completed' && 'file' in data) return data;
-    if (data.upload.status === 'canceled') {
-      throw new EdgeStoreUploadCanceledError(
-        'The EdgeStore upload was canceled.',
-        options.uploadId,
-      );
-    }
-
-    const delayMs = getRetryAfterMs(response) ?? 1000;
-    if (Date.now() + delayMs > deadline) {
-      throw timeoutError();
-    }
-    await sleep(delayMs, options.signal);
-  }
-}
-
-async function cancelUpload(
-  operations: RuntimeOperations,
-  project: string,
-  uploadId: string,
-) {
-  try {
-    await operations.uploads.cancel({ project, uploadId });
-  } catch {
-    // Preserve the original upload failure.
-  }
-}
-
-function normalizeMetadata(
-  metadata?: Record<string, UploadMetadataValue>,
-): Record<string, string> | undefined {
-  if (!metadata) return undefined;
-  const entries = Object.entries(metadata).flatMap(([key, value]) =>
-    value === null || value === undefined ? [] : [[key, String(value)]],
-  );
-  return entries.length ? Object.fromEntries(entries) : undefined;
-}
-
-function prepareSource(source: UploadSource): PreparedUploadSource {
-  if (typeof source === 'string') {
-    const body = new Blob([source], { type: 'text/plain' });
-    return {
-      kind: 'body',
-      body,
-      sizeBytes: body.size,
-      mimeType: body.type,
-    };
-  }
-  if (isStreamSource(source)) {
-    if (!Number.isSafeInteger(source.sizeBytes) || source.sizeBytes < 0) {
-      throw new RangeError('source.sizeBytes must be a non-negative integer.');
-    }
-    return {
-      kind: 'stream',
-      stream: source.stream,
-      sizeBytes: source.sizeBytes,
-    };
-  }
-  if (source instanceof Blob) {
-    return {
-      kind: 'body',
-      body: source,
-      sizeBytes: source.size,
-      fileName:
-        'name' in source && typeof source.name === 'string'
-          ? source.name
-          : undefined,
-      mimeType: source.type || undefined,
-    };
-  }
-  if (source instanceof ArrayBuffer) {
-    const body = new Blob([source]);
-    return { kind: 'body', body, sizeBytes: body.size };
-  }
-  const body = new Blob([
-    Uint8Array.from(
-      new Uint8Array(source.buffer, source.byteOffset, source.byteLength),
-    ),
-  ]);
-  return { kind: 'body', body, sizeBytes: body.size };
-}
-
-function isStreamSource(source: UploadSource): source is UploadStreamSource {
-  const stream =
-    typeof source === 'object' && source !== null && 'stream' in source
-      ? Reflect.get(source, 'stream')
-      : undefined;
-  return (
-    typeof stream === 'object' &&
-    stream !== null &&
-    'getReader' in stream &&
-    typeof Reflect.get(stream, 'getReader') === 'function'
-  );
-}
-
-function reportProgress(
-  onProgress: RuntimeUploadInput['onProgress'],
-  progress: {
-    transferredBytes: number;
-    totalBytes: number;
-    phase: 'preparing' | 'uploading' | 'processing';
-  },
-) {
-  const { transferredBytes, totalBytes, phase } = progress;
-  onProgress?.({
-    transferredBytes,
-    totalBytes,
-    percentage:
-      totalBytes === 0
-        ? phase === 'preparing'
-          ? 0
-          : 100
-        : Math.round((transferredBytes / totalBytes) * 10_000) / 100,
-    phase,
-  });
-}
-
 function getFileNameFromUrl(url: string): string | undefined {
   const name = new URL(url).pathname.split('/').filter(Boolean).at(-1);
   return name ? decodeURIComponent(name) : undefined;

package/src/version.ts

@@ -1,2 +1,2 @@
 export const EDGE_STORE_PACKAGE_NAME = '@edgestore/sdk';
-export const EDGE_STORE_PACKAGE_VERSION = '1.0.0-next.1';
+export const EDGE_STORE_PACKAGE_VERSION = '1.0.0-next.2';