@uploadista/client-core 0.0.3

package/dist/upload/single-upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-upload.d.ts","sourceRoot":"","sources":["../../src/upload/single-upload.ts"],"names":[],"mappings":"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"}

package/dist/upload/single-upload.js

@@ -0,0 +1,332 @@
+import { UploadistaError } from "../error";
+import { shouldRetry, uploadChunk, } from "./chunk-upload";
+import { removeFromClientStorage, saveUploadInClientStorage, } from "./upload-storage";
+import { encodeMetadata, inStatusCategory } from "./upload-utils";
+/**
+ * Start uploading the file using PATCH requests. The file will be divided
+ * into chunks as specified in the chunkSize option. During the upload
+ * the onProgress event handler may be invoked multiple times.
+ */
+export async function performUpload({ uploadId, offset, source, uploadLengthDeferred, retryAttempt = 0, abortController, retryDelays, smartChunker, uploadistaApi, logger, smartChunking, metrics, platformService, onRetry, ...callbacks }) {
+    let offsetBeforeRetry = offset;
+    let currentOffset = offset;
+    try {
+        const res = await uploadChunk({
+            uploadId,
+            source,
+            offset,
+            uploadLengthDeferred,
+            onProgress: callbacks.onProgress,
+            abortController,
+            smartChunker,
+            uploadistaApi,
+            logger,
+        });
+        if (!inStatusCategory(res.status, 200) || res.upload == null) {
+            throw new UploadistaError({
+                name: "NETWORK_UNEXPECTED_RESPONSE",
+                message: "Unexpected response while uploading chunk",
+            });
+        }
+        currentOffset = res.upload.offset;
+        callbacks.onProgress?.(uploadId, currentOffset, res.upload.size ?? 0);
+        callbacks.onChunkComplete?.(currentOffset - offset, offset, res.upload?.size ?? 0);
+        // Record detailed chunk metrics
+        if (smartChunking?.enabled !== false) {
+            const chunkIndex = Math.floor(offset / (currentOffset - offset || 1));
+            const chunkSize = currentOffset - offset;
+            const chunkDuration = Date.now() - (Date.now() - 100); // Approximate, real timing is in uploadChunk
+            const lastDecision = smartChunker.getLastDecision();
+            metrics.recordChunk({
+                chunkIndex,
+                size: chunkSize,
+                duration: chunkDuration,
+                speed: chunkSize / (chunkDuration / 1000),
+                success: true,
+                retryCount: retryAttempt,
+                networkCondition: lastDecision?.networkCondition?.type,
+                chunkingStrategy: lastDecision?.strategy,
+            });
+            // Update smart chunker with connection metrics for pooling optimization
+            const connectionMetrics = uploadistaApi.getConnectionMetrics();
+            smartChunker.updateConnectionMetrics(connectionMetrics);
+        }
+        if (currentOffset >= (source.size ?? 0)) {
+            if (source)
+                source.close();
+            // Complete metrics session
+            if (smartChunking?.enabled !== false) {
+                const sessionMetrics = metrics.endSession();
+                if (sessionMetrics) {
+                    logger.log(`Upload completed: ${sessionMetrics.totalSize} bytes in ${sessionMetrics.totalDuration}ms, avg speed: ${Math.round(sessionMetrics.averageSpeed / 1024)}KB/s`);
+                }
+            }
+            callbacks.onSuccess?.(res.upload);
+            return;
+        }
+        await performUpload({
+            uploadId,
+            offset: currentOffset,
+            source,
+            uploadLengthDeferred,
+            retryDelays,
+            smartChunker,
+            platformService,
+            uploadistaApi,
+            logger,
+            smartChunking,
+            metrics,
+            onRetry,
+            abortController,
+            ...callbacks,
+        });
+    }
+    catch (err) {
+        // Check if we should retry, when enabled, before sending the error to the user.
+        if (retryDelays != null) {
+            // We will reset the attempt counter if
+            // - we were already able to connect to the server (offset != null) and
+            // - we were able to upload a small chunk of data to the server
+            const shouldResetDelays = offset != null && currentOffset > offsetBeforeRetry;
+            if (shouldResetDelays) {
+                retryAttempt = 0;
+            }
+            const castedErr = !(err instanceof UploadistaError)
+                ? new UploadistaError({
+                    name: "NETWORK_ERROR",
+                    message: "Network error",
+                    cause: err,
+                })
+                : err;
+            if (shouldRetry(platformService, castedErr, retryAttempt, retryDelays, callbacks.onShouldRetry)) {
+                const delay = retryDelays[retryAttempt];
+                offsetBeforeRetry = offset;
+                const timeout = platformService.setTimeout(async () => {
+                    await performUpload({
+                        uploadId,
+                        offset,
+                        source,
+                        retryAttempt: retryAttempt + 1,
+                        uploadLengthDeferred,
+                        retryDelays,
+                        smartChunker,
+                        platformService,
+                        uploadistaApi,
+                        logger,
+                        smartChunking,
+                        metrics,
+                        onRetry,
+                        abortController,
+                        ...callbacks,
+                    });
+                }, delay);
+                onRetry?.(timeout);
+            }
+            else {
+                throw new UploadistaError({
+                    name: "UPLOAD_CHUNK_FAILED",
+                    message: `failed to upload chunk for ${uploadId} at offset ${offset}`,
+                    cause: err,
+                });
+            }
+        }
+    }
+}
+/**
+ * Create a new upload using the creation extension by sending a POST
+ * request to the endpoint. After successful creation the file will be
+ * uploaded
+ */
+export async function createUpload({ fingerprint, storageId, source, uploadLengthDeferred, metadata, uploadistaApi, logger, checksumService, clientStorage, generateId, storeFingerprintForResuming, openWebSocket, closeWebSocket, computeChecksum = true, checksumAlgorithm = "sha256", platformService, ...callbacks }) {
+    if (!uploadLengthDeferred && source.size == null) {
+        const error = new UploadistaError({
+            name: "UPLOAD_SIZE_NOT_SPECIFIED",
+            message: "expected size to be set",
+        });
+        callbacks.onError?.(error);
+        throw error;
+    }
+    // Compute checksum if enabled and file is a File object
+    let checksum;
+    if (computeChecksum && platformService.isFileLike(source.input)) {
+        try {
+            logger.log("Computing file checksum...");
+            checksum = await checksumService.computeChecksum(new Uint8Array(source.input));
+            logger.log(`Checksum computed: ${checksum}`);
+        }
+        catch (error) {
+            logger.log(`Warning: Failed to compute checksum: ${error instanceof Error ? error.message : "Unknown error"}`);
+            // Continue without checksum if computation fails
+        }
+    }
+    const createUploadData = {
+        uploadLengthDeferred,
+        storageId,
+        size: source.size ?? 0,
+        metadata: metadata ? encodeMetadata(metadata) : undefined,
+        fileName: source.name ?? undefined,
+        type: source.type ?? "",
+        lastModified: source.lastModified ?? undefined,
+        checksum,
+        checksumAlgorithm: checksum ? checksumAlgorithm : undefined,
+    };
+    const { upload, status } = await uploadistaApi.createUpload(createUploadData);
+    if (!inStatusCategory(status, 200) || upload == null) {
+        const error = new UploadistaError({
+            name: "NETWORK_UNEXPECTED_RESPONSE",
+            message: "Unexpected response while creating upload",
+        });
+        callbacks.onError?.(error);
+        throw error;
+    }
+    logger.log(`Created upload ${upload.id}`);
+    openWebSocket(upload.id);
+    if (upload.size === 0) {
+        // Nothing to upload and file was successfully created
+        callbacks.onSuccess?.(upload);
+        if (source)
+            source.close();
+        closeWebSocket(upload.id);
+        return;
+    }
+    const uploadIdStorageKey = await saveUploadInClientStorage({
+        clientStorage,
+        fingerprint,
+        size: upload.size ?? 0,
+        metadata: upload.metadata ?? {},
+        clientStorageKey: null,
+        storeFingerprintForResuming,
+        generateId,
+    });
+    callbacks.onStart?.({
+        uploadId: upload.id,
+        size: upload.size ?? null,
+    });
+    return {
+        uploadIdStorageKey,
+        uploadId: upload.id,
+        offset: upload.offset,
+    };
+}
+/**
+ * Try to resume an existing upload. First a HEAD request will be sent
+ * to retrieve the offset. If the request fails a new upload will be
+ * created. In the case of a successful response the file will be uploaded.
+ */
+export async function resumeUpload({ uploadId, storageId, uploadIdStorageKey, fingerprint, source, uploadLengthDeferred, uploadistaApi, logger, platformService, checksumService, clientStorage, generateId, storeFingerprintForResuming, openWebSocket, ...callbacks }) {
+    const res = await uploadistaApi.getUpload(uploadId);
+    const status = res.status;
+    if (!inStatusCategory(status, 200)) {
+        // If the upload is locked (indicated by the 423 Locked status code), we
+        // emit an error instead of directly starting a new upload. This way the
+        // retry logic can catch the error and will retry the upload. An upload
+        // is usually locked for a short period of time and will be available
+        // afterwards.
+        if (status === 423) {
+            const error = new UploadistaError({
+                name: "UPLOAD_LOCKED",
+                message: "upload is currently locked; retry later",
+            });
+            callbacks.onError?.(error);
+            throw error;
+        }
+        if (inStatusCategory(status, 400)) {
+            // Remove stored fingerprint and corresponding endpoint,
+            // on client errors since the file can not be found
+            await removeFromClientStorage(clientStorage, uploadIdStorageKey);
+        }
+        // Try to create a new upload
+        return await createUpload({
+            platformService,
+            fingerprint,
+            storageId,
+            source,
+            uploadLengthDeferred,
+            metadata: {},
+            uploadistaApi,
+            logger,
+            checksumService,
+            clientStorage,
+            generateId,
+            storeFingerprintForResuming,
+            openWebSocket,
+            closeWebSocket: () => { }, // Placeholder, will be provided by caller
+            ...callbacks,
+        });
+    }
+    const upload = res.upload;
+    if (upload == null) {
+        const error = new UploadistaError({
+            name: "NETWORK_UNEXPECTED_RESPONSE",
+            message: "Unexpected response while resuming upload",
+        });
+        callbacks.onError?.(error);
+        throw error;
+    }
+    await saveUploadInClientStorage({
+        clientStorage,
+        fingerprint,
+        size: upload.size ?? 0,
+        metadata: upload.metadata ?? {},
+        clientStorageKey: uploadIdStorageKey,
+        storeFingerprintForResuming,
+        generateId,
+    });
+    // Upload has already been completed and we do not need to send additional
+    // data to the server
+    if (upload.offset === upload.size) {
+        return undefined;
+    }
+    openWebSocket(upload.id);
+    return {
+        uploadId,
+        uploadIdStorageKey,
+        offset: upload.offset,
+    };
+}
+/**
+ * Initiate the uploading procedure for a non-parallel upload. Here the entire file is
+ * uploaded in a sequential matter.
+ */
+export async function startSingleUpload({ source, uploadId, uploadIdStorageKey, storageId, fingerprint, platformService, uploadLengthDeferred, uploadistaApi, checksumService, logger, clientStorage, generateId, storeFingerprintForResuming, openWebSocket, closeWebSocket, ...callbacks }) {
+    // The upload had been started previously and we should reuse this URL.
+    if (uploadId != null && uploadIdStorageKey != null) {
+        logger.log(`Resuming upload from previous id: ${uploadId}`);
+        return await resumeUpload({
+            uploadId,
+            uploadIdStorageKey,
+            storageId,
+            fingerprint,
+            source,
+            checksumService,
+            uploadLengthDeferred,
+            uploadistaApi,
+            logger,
+            platformService,
+            clientStorage,
+            generateId,
+            storeFingerprintForResuming,
+            openWebSocket,
+            ...callbacks,
+        });
+    }
+    // An upload has not started for the file yet, so we start a new one
+    logger.log("Creating a new upload");
+    return await createUpload({
+        fingerprint,
+        storageId,
+        source,
+        uploadLengthDeferred,
+        metadata: {},
+        uploadistaApi,
+        logger,
+        checksumService,
+        platformService,
+        clientStorage,
+        generateId,
+        storeFingerprintForResuming,
+        openWebSocket,
+        closeWebSocket,
+        ...callbacks,
+    });
+}

package/dist/upload/upload-manager.d.ts

@@ -0,0 +1,30 @@
+import type { UploadistaApi } from "../client/uploadista-api";
+import type { AbortControllerLike } from "../services/abort-controller-service";
+import { type PlatformService, type Timeout } from "../services/platform-service";
+import type { ClientStorage } from "../storage/client-storage";
+/**
+ * Use the Termination extension to delete an upload from the server by sending a DELETE
+ * request to the specified upload URL. This is only possible if the server supports the
+ * Termination extension. If the `retryDelays` property is set, the method will
+ * also retry if an error occurs.
+ */
+export declare function terminate(uploadId: string, uploadistaApi: UploadistaApi, platformService: PlatformService, retryDelays: number[] | undefined, retryAttempt?: number): Promise<void>;
+/**
+ * Abort any running request and stop the current upload. After abort is called, no event
+ * handler will be invoked anymore. You can use the `start` method to resume the upload
+ * again.
+ * If `shouldTerminate` is true, the `terminate` function will be called to remove the
+ * current upload from the server.
+ */
+export declare function abort({ uploadId, uploadIdStorageKey, retryTimeout, shouldTerminate, abortController, uploadistaApi, platformService, retryDelays, clientStorage, }: {
+    uploadId: string;
+    uploadIdStorageKey: string | undefined;
+    retryTimeout: Timeout | null;
+    shouldTerminate: boolean;
+    abortController: AbortControllerLike;
+    uploadistaApi: UploadistaApi;
+    platformService: PlatformService;
+    retryDelays?: number[];
+    clientStorage: ClientStorage;
+}): Promise<void>;
+//# sourceMappingURL=upload-manager.d.ts.map

package/dist/upload/upload-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-manager.d.ts","sourceRoot":"","sources":["../../src/upload/upload-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,OAAO,EAEb,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAI/D;;;;;GAKG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe,EAChC,WAAW,EAAE,MAAM,EAAE,GAAG,SAAS,EACjC,YAAY,SAAI,GACf,OAAO,CAAC,IAAI,CAAC,CAkCf;AAED;;;;;;GAMG;AACH,wBAAsB,KAAK,CAAC,EAC1B,QAAQ,EACR,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,eAAe,EACf,aAAa,EACb,eAAe,EACf,WAAW,EACX,aAAa,GACd,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,YAAY,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7B,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,mBAAmB,CAAC;IACrC,aAAa,EAAE,aAAa,CAAC;IAC7B,eAAe,EAAE,eAAe,CAAC;IACjC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,EAAE,aAAa,CAAC;CAC9B,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBhB"}

package/dist/upload/upload-manager.js

@@ -0,0 +1,57 @@
+import { UploadistaError } from "../error";
+import { wait, } from "../services/platform-service";
+import { shouldRetry } from "./chunk-upload";
+import { removeFromClientStorage } from "./upload-storage";
+/**
+ * Use the Termination extension to delete an upload from the server by sending a DELETE
+ * request to the specified upload URL. This is only possible if the server supports the
+ * Termination extension. If the `retryDelays` property is set, the method will
+ * also retry if an error occurs.
+ */
+export async function terminate(uploadId, uploadistaApi, platformService, retryDelays, retryAttempt = 0) {
+    try {
+        const res = await uploadistaApi.deleteUpload(uploadId);
+        // A 204 response indicates a successful request
+        if (res.status === 204) {
+            return;
+        }
+        throw new UploadistaError({
+            name: "NETWORK_UNEXPECTED_RESPONSE",
+            message: "Unexpected response while terminating upload",
+        });
+    }
+    catch (err) {
+        const error = err;
+        if (!shouldRetry(platformService, error, retryAttempt, retryDelays)) {
+            throw err;
+        }
+        // Instead of keeping track of the retry attempts, we remove the first element from the delays
+        // array. If the array is empty, all retry attempts are used up and we will bubble up the error.
+        // We recursively call the terminate function will removing elements from the retryDelays array.
+        const delay = retryDelays?.[retryAttempt] ?? 0;
+        await wait(platformService, delay);
+        return await terminate(uploadId, uploadistaApi, platformService, retryDelays, retryAttempt + 1);
+    }
+}
+/**
+ * Abort any running request and stop the current upload. After abort is called, no event
+ * handler will be invoked anymore. You can use the `start` method to resume the upload
+ * again.
+ * If `shouldTerminate` is true, the `terminate` function will be called to remove the
+ * current upload from the server.
+ */
+export async function abort({ uploadId, uploadIdStorageKey, retryTimeout, shouldTerminate, abortController, uploadistaApi, platformService, retryDelays, clientStorage, }) {
+    // Stop any current running request.
+    abortController.abort();
+    // Stop any timeout used for initiating a retry.
+    if (retryTimeout != null) {
+        platformService.clearTimeout(retryTimeout);
+    }
+    if (!shouldTerminate || uploadId == null) {
+        return;
+    }
+    await terminate(uploadId, uploadistaApi, platformService, retryDelays);
+    if (uploadIdStorageKey != null) {
+        return removeFromClientStorage(clientStorage, uploadIdStorageKey);
+    }
+}

package/dist/upload/upload-metrics.d.ts

@@ -0,0 +1,37 @@
+import type { ChunkMetrics } from "../types/chunk-metrics";
+import type { PerformanceInsights } from "../types/performance-insights";
+import type { UploadSessionMetrics } from "../types/upload-session-metrics";
+export interface UploadMetricsConfig {
+    maxChunkHistory?: number;
+    enableDetailedMetrics?: boolean;
+    performanceThresholds?: {
+        slowSpeed: number;
+        fastSpeed: number;
+        highRetryRate: number;
+    };
+}
+export declare class UploadMetrics {
+    private config;
+    private chunkHistory;
+    private currentSession;
+    private sessionStartTime;
+    constructor(config?: UploadMetricsConfig);
+    startSession(uploadId: string, totalSize: number, adaptiveChunkingEnabled: boolean): void;
+    recordChunk(metrics: Omit<ChunkMetrics, "timestamp">): void;
+    endSession(): UploadSessionMetrics | null;
+    getCurrentSessionMetrics(): Partial<UploadSessionMetrics>;
+    getChunkHistory(count?: number): ChunkMetrics[];
+    getPerformanceInsights(): PerformanceInsights;
+    exportMetrics(): {
+        session: Partial<UploadSessionMetrics>;
+        chunks: ChunkMetrics[];
+        insights: PerformanceInsights;
+    };
+    reset(): void;
+    private calculateVariance;
+    private calculateChunkingEffectiveness;
+    private groupChunksBySize;
+    private generateRecommendations;
+    private calculateOptimalChunkSizeRange;
+}
+//# sourceMappingURL=upload-metrics.d.ts.map

package/dist/upload/upload-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-metrics.d.ts","sourceRoot":"","sources":["../../src/upload/upload-metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAE5E,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,qBAAqB,CAAC,EAAE;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,cAAc,CAAqC;IAC3D,OAAO,CAAC,gBAAgB,CAAK;gBAEjB,MAAM,GAAE,mBAAwB;IAa5C,YAAY,CACV,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,uBAAuB,EAAE,OAAO,GAC/B,IAAI;IAeP,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,GAAG,IAAI;IAwB3D,UAAU,IAAI,oBAAoB,GAAG,IAAI;IA2CzC,wBAAwB,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAIzD,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,YAAY,EAAE;IAK/C,sBAAsB,IAAI,mBAAmB;IA6D7C,aAAa,IAAI;QACf,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;QACvC,MAAM,EAAE,YAAY,EAAE,CAAC;QACvB,QAAQ,EAAE,mBAAmB,CAAC;KAC/B;IAQD,KAAK,IAAI,IAAI;IAMb,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,8BAA8B;IAwBtC,OAAO,CAAC,iBAAiB;IAyBzB,OAAO,CAAC,uBAAuB;IAiD/B,OAAO,CAAC,8BAA8B;CAwBvC"}