@ardrive/turbo-sdk 1.25.0 → 1.26.0

package/lib/cjs/common/events.test.js

@@ -0,0 +1,470 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = require("node:assert");
+const node_stream_1 = require("node:stream");
+const node_test_1 = require("node:test");
+const events_js_1 = require("./events.js");
+(0, node_test_1.describe)('createStreamWithUploadEvents', () => {
+    (0, node_test_1.describe)('Readable', () => {
+        (0, node_test_1.it)('should call onUploadProgress and onUploadSuccess callback and emit progress events when stream is consumed', async () => {
+            let onProgressCalled = false;
+            let progressEventEmitted = false;
+            let onSuccessCalled = false;
+            let successEventEmitted = false;
+            const emitter = new events_js_1.TurboEventEmitter({
+                onUploadProgress: () => {
+                    onProgressCalled = true;
+                },
+                onUploadSuccess: () => {
+                    onSuccessCalled = true;
+                },
+            });
+            const data = new node_stream_1.Readable({
+                read() {
+                    this.push(Buffer.from('test'));
+                    this.push(null); // End the stream
+                },
+            });
+            emitter.on('upload-progress', () => {
+                progressEventEmitted = true;
+            });
+            emitter.on('upload-success', () => {
+                successEventEmitted = true;
+            });
+            const { stream, resume } = (0, events_js_1.createStreamWithUploadEvents)({
+                data,
+                dataSize: 4,
+                emitter,
+            });
+            // Promise that resolves when all events have fired
+            const streamConsumerPromise = new Promise((resolve) => {
+                stream.on('data', () => {
+                    // data starts flowing through the stream
+                });
+                stream.on('end', () => {
+                    resolve();
+                });
+                stream.on('error', (error) => {
+                    throw error;
+                });
+            });
+            // allow bytes to start flowing
+            resume();
+            // consume the full stream
+            await streamConsumerPromise;
+            // Assert that the events were called after the stream has been fully consumed
+            node_assert_1.strict.equal(onProgressCalled, true, 'onProgressCalled should be true');
+            node_assert_1.strict.equal(progressEventEmitted, true, 'progressEventEmitted should be true');
+            node_assert_1.strict.equal(onSuccessCalled, true, 'onSuccessCalled should be true');
+            node_assert_1.strict.equal(successEventEmitted, true, 'successEventEmitted should be true');
+        });
+        (0, node_test_1.it)('should call onUploadError callback and emit error events when stream errors', async () => {
+            let onErrorCalled = false;
+            let errorEventEmitted = false;
+            const testError = new Error('Test error');
+            const emitter = new events_js_1.TurboEventEmitter({
+                onUploadError: () => {
+                    onErrorCalled = true;
+                },
+            });
+            // Create a readable stream that will emit an error
+            const data = new node_stream_1.Readable({
+                read() {
+                    this.emit('error', testError);
+                },
+            });
+            emitter.on('upload-error', () => {
+                errorEventEmitted = true;
+            });
+            const { stream, resume } = (0, events_js_1.createStreamWithUploadEvents)({
+                data,
+                dataSize: 10,
+                emitter,
+            });
+            const streamErrorPromise = new Promise((_, reject) => {
+                stream.on('error', (error) => {
+                    reject(error);
+                });
+            });
+            // allow bytes to start flowing
+            resume();
+            try {
+                // consume the full stream and wait for the error to be thrown
+                await streamErrorPromise;
+            }
+            catch (error) {
+                // Error is expected
+            }
+            node_assert_1.strict.equal(onErrorCalled, true);
+            node_assert_1.strict.equal(errorEventEmitted, true);
+        });
+    });
+    (0, node_test_1.describe)('ReadableStream', () => {
+        (0, node_test_1.it)('should call onUploadProgress and onUploadSuccess callback and emit progress events when stream is consumed', async () => {
+            let onProgressCalled = false;
+            let progressEventEmitted = false;
+            let onSuccessCalled = false;
+            let successEventEmitted = false;
+            let onErrorCalled = false;
+            let errorEventEmitted = false;
+            const emitter = new events_js_1.TurboEventEmitter({
+                onUploadProgress: () => {
+                    onProgressCalled = true;
+                },
+                onUploadSuccess: () => {
+                    onSuccessCalled = true;
+                },
+                onUploadError: () => {
+                    onErrorCalled = true;
+                },
+            });
+            const data = new ReadableStream({
+                start(controller) {
+                    controller.enqueue(Buffer.from('test test test test test'));
+                    controller.close();
+                },
+            });
+            const { stream } = (0, events_js_1.createStreamWithUploadEvents)({
+                data,
+                dataSize: 4,
+                emitter,
+            });
+            emitter.on('upload-progress', () => {
+                progressEventEmitted = true;
+            });
+            emitter.on('upload-error', () => {
+                errorEventEmitted = true;
+            });
+            emitter.on('upload-success', () => {
+                successEventEmitted = true;
+            });
+            // TODO: ideally use generics to avoid needing to cast here
+            const reader = stream.getReader();
+            // read the stream to the end
+            while (true) {
+                const { done } = await reader.read();
+                if (done) {
+                    break;
+                }
+            }
+            // progress events called
+            node_assert_1.strict.equal(onProgressCalled, true, 'onProgressCalled should be true');
+            node_assert_1.strict.equal(progressEventEmitted, true, 'progressEventEmitted should be true');
+            // error event not called
+            node_assert_1.strict.equal(errorEventEmitted, false, 'errorEventEmitted should be false');
+            node_assert_1.strict.equal(onErrorCalled, false, 'onErrorCalled should be false');
+            // success event called
+            node_assert_1.strict.equal(onSuccessCalled, true, 'onSuccessCalled should be true');
+            node_assert_1.strict.equal(successEventEmitted, true, 'successEventEmitted should be true');
+        });
+        (0, node_test_1.it)('should call onUploadError callback and emit error events when stream errors', async () => {
+            let onErrorCalled = false;
+            let errorEventEmitted = false;
+            const testError = new Error('Test error');
+            const onUploadError = () => {
+                onErrorCalled = true;
+            };
+            // Create a ReadableStream that will throw an error
+            const data = new ReadableStream({
+                pull() {
+                    throw testError;
+                },
+            });
+            const emitter = new events_js_1.TurboEventEmitter({ onUploadError });
+            const { stream } = (0, events_js_1.createStreamWithUploadEvents)({
+                data,
+                dataSize: 4,
+                emitter,
+            });
+            emitter.on('upload-error', () => {
+                errorEventEmitted = true;
+            });
+            // Trigger error
+            try {
+                const reader = stream.getReader();
+                await reader.read();
+            }
+            catch (error) {
+                // Error is expected
+            }
+            node_assert_1.strict.equal(onErrorCalled, true, 'onErrorCalled should be true');
+            node_assert_1.strict.equal(errorEventEmitted, true, 'errorEventEmitted should be true');
+        });
+    });
+});
+(0, node_test_1.describe)('createStreamWithSigningEvents', () => {
+    (0, node_test_1.describe)('Readable', () => {
+        (0, node_test_1.it)('should call onSigningProgress and onSigningSuccess callback and emit progress events when stream is consumed', async () => {
+            let onProgressCalled = false;
+            let progressEventEmitted = false;
+            let onErrorCalled = false;
+            let errorEventEmitted = false;
+            let onSuccessCalled = false;
+            let successEventEmitted = false;
+            const emitter = new events_js_1.TurboEventEmitter({
+                onSigningProgress: () => {
+                    onProgressCalled = true;
+                },
+                onSigningError: () => {
+                    onErrorCalled = true;
+                },
+                onSigningSuccess: () => {
+                    onSuccessCalled = true;
+                },
+            });
+            emitter.on('signing-progress', () => {
+                progressEventEmitted = true;
+            });
+            emitter.on('signing-success', () => {
+                successEventEmitted = true;
+            });
+            emitter.on('signing-error', () => {
+                errorEventEmitted = true;
+            });
+            const data = node_stream_1.Readable.from(['test']);
+            const { stream, resume } = (0, events_js_1.createStreamWithSigningEvents)({
+                data,
+                dataSize: 50,
+                emitter,
+            });
+            // Promise that resolves when all events have fired
+            const streamConsumerPromise = new Promise((resolve) => {
+                stream.on('data', () => {
+                    // data starts flowing through the stream
+                });
+                stream.on('end', () => {
+                    resolve();
+                });
+                stream.on('error', (error) => {
+                    throw error;
+                });
+            });
+            // allow bytes to start flowing
+            resume();
+            // consume the full stream
+            await streamConsumerPromise;
+            node_assert_1.strict.equal(onProgressCalled, true);
+            node_assert_1.strict.equal(progressEventEmitted, true);
+            node_assert_1.strict.equal(onSuccessCalled, true);
+            node_assert_1.strict.equal(successEventEmitted, true);
+            node_assert_1.strict.equal(onErrorCalled, false);
+            node_assert_1.strict.equal(errorEventEmitted, false);
+        });
+        (0, node_test_1.it)('should call onSigningError callback and emit error events when stream errors', async () => {
+            let onErrorCalled = false;
+            let errorEventEmitted = false;
+            const testError = new Error('Test error');
+            const emitter = new events_js_1.TurboEventEmitter({
+                onSigningError: () => {
+                    onErrorCalled = true;
+                },
+            });
+            // Create a readable stream that will emit an error
+            const data = new node_stream_1.Readable({
+                read() {
+                    this.emit('error', testError);
+                },
+            });
+            emitter.on('signing-error', () => {
+                errorEventEmitted = true;
+            });
+            const { stream, resume } = (0, events_js_1.createStreamWithSigningEvents)({
+                data,
+                dataSize: 10,
+                emitter,
+            });
+            const streamErrorPromise = new Promise((_, reject) => {
+                stream.on('error', (error) => {
+                    reject(error);
+                });
+            });
+            // allow bytes to start flowing
+            resume();
+            try {
+                // consume the full stream
+                await streamErrorPromise;
+            }
+            catch (error) {
+                // Error is expected
+            }
+            node_assert_1.strict.equal(onErrorCalled, true);
+            node_assert_1.strict.equal(errorEventEmitted, true);
+        });
+    });
+    (0, node_test_1.describe)('ReadableStream', () => {
+        (0, node_test_1.it)('should call onSigningProgress and onSigningSuccess callback and emit progress events when stream is consumed', async () => {
+            let onProgressCalled = false;
+            let progressEventEmitted = false;
+            let onErrorCalled = false;
+            let errorEventEmitted = false;
+            let onSuccessCalled = false;
+            let successEventEmitted = false;
+            const data = new ReadableStream({
+                start(controller) {
+                    controller.enqueue(Buffer.from('test'));
+                    controller.close();
+                },
+            });
+            const emitter = new events_js_1.TurboEventEmitter({
+                onSigningProgress: () => {
+                    onProgressCalled = true;
+                },
+                onSigningError: () => {
+                    onErrorCalled = true;
+                },
+                onSigningSuccess: () => {
+                    onSuccessCalled = true;
+                },
+            });
+            const { stream } = (0, events_js_1.createStreamWithSigningEvents)({
+                data,
+                dataSize: 10,
+                emitter,
+            });
+            emitter.on('signing-progress', () => {
+                progressEventEmitted = true;
+            });
+            emitter.on('signing-success', () => {
+                successEventEmitted = true;
+            });
+            emitter.on('signing-error', () => {
+                errorEventEmitted = true;
+            });
+            // TODO: ideally use generics to avoid needing to cast here
+            const reader = stream.getReader();
+            // read the stream to the end
+            while (true) {
+                const { done } = await reader.read();
+                if (done) {
+                    break;
+                }
+            }
+            node_assert_1.strict.equal(onProgressCalled, true);
+            node_assert_1.strict.equal(progressEventEmitted, true);
+            node_assert_1.strict.equal(onSuccessCalled, true);
+            node_assert_1.strict.equal(successEventEmitted, true);
+            node_assert_1.strict.equal(onErrorCalled, false);
+            node_assert_1.strict.equal(errorEventEmitted, false);
+        });
+        (0, node_test_1.it)('should call onSigningError callback and emit error events when stream errors', async () => {
+            let onErrorCalled = false;
+            let errorEventEmitted = false;
+            let onSuccessCalled = false;
+            let successEventEmitted = false;
+            const testError = new Error('Test error');
+            // Create a ReadableStream that will throw an error
+            const data = new ReadableStream({
+                pull() {
+                    throw testError;
+                },
+            });
+            const emitter = new events_js_1.TurboEventEmitter({
+                onSigningError: () => {
+                    onErrorCalled = true;
+                },
+                onSigningSuccess: () => {
+                    onSuccessCalled = true;
+                },
+            });
+            const { stream } = (0, events_js_1.createStreamWithSigningEvents)({
+                data,
+                dataSize: 10,
+                emitter,
+            });
+            emitter.on('signing-error', () => {
+                errorEventEmitted = true;
+            });
+            emitter.on('signing-success', () => {
+                successEventEmitted = true;
+            });
+            try {
+                // consume the full stream
+                const reader = stream.getReader();
+                while (true) {
+                    const { done } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                // Error is expected
+            }
+            node_assert_1.strict.equal(onErrorCalled, true);
+            node_assert_1.strict.equal(errorEventEmitted, true);
+            node_assert_1.strict.equal(onSuccessCalled, false);
+            node_assert_1.strict.equal(successEventEmitted, false);
+        });
+    });
+});
+(0, node_test_1.describe)('TurboEventEmitter', () => {
+    (0, node_test_1.it)('should emit overall-success event when upload-success event is emitted', () => {
+        const emitter = new events_js_1.TurboEventEmitter();
+        let overallSuccessCalled = false;
+        emitter.on('overall-success', () => {
+            overallSuccessCalled = true;
+        });
+        emitter.emit('upload-success');
+        node_assert_1.strict.equal(overallSuccessCalled, true);
+    });
+    (0, node_test_1.it)('should emit progress events when signing-progress event is emitted', () => {
+        const emitter = new events_js_1.TurboEventEmitter();
+        let overallProgressCalled = false;
+        let overallProgressPayload;
+        emitter.on('overall-progress', (event) => {
+            overallProgressCalled = true;
+            overallProgressPayload = event;
+        });
+        emitter.emit('signing-progress', {
+            processedBytes: 100,
+            totalBytes: 1000,
+        });
+        node_assert_1.strict.equal(overallProgressCalled, true);
+        node_assert_1.strict.equal(overallProgressPayload?.processedBytes, 50);
+        node_assert_1.strict.equal(overallProgressPayload?.totalBytes, 1000);
+        node_assert_1.strict.equal(overallProgressPayload?.step, 'signing');
+    });
+    (0, node_test_1.it)('should emit error events when signing-error event is emitted', () => {
+        const emitter = new events_js_1.TurboEventEmitter();
+        const testError = new Error('Signing error');
+        let overallErrorCalled = false;
+        let overallErrorPayload;
+        emitter.on('overall-error', (error) => {
+            overallErrorCalled = true;
+            overallErrorPayload = error;
+        });
+        emitter.emit('signing-error', testError);
+        node_assert_1.strict.equal(overallErrorCalled, true);
+        node_assert_1.strict.deepStrictEqual(overallErrorPayload, testError);
+    });
+    (0, node_test_1.it)('should emit error events when upload-error event is emitted', () => {
+        const emitter = new events_js_1.TurboEventEmitter();
+        const testError = new Error('Upload error');
+        let overallErrorCalled = false;
+        let overallErrorPayload;
+        emitter.on('overall-error', (event) => {
+            overallErrorCalled = true;
+            overallErrorPayload = event;
+        });
+        emitter.emit('upload-error', testError);
+        node_assert_1.strict.equal(overallErrorCalled, true);
+        node_assert_1.strict.deepStrictEqual(overallErrorPayload, testError);
+    });
+    (0, node_test_1.it)('should emit progress events when upload-progress event is emitted', () => {
+        const emitter = new events_js_1.TurboEventEmitter();
+        let overallProgressCalled = false;
+        let overallProgressPayload;
+        emitter.on('overall-progress', (event) => {
+            overallProgressCalled = true;
+            overallProgressPayload = event;
+        });
+        emitter.emit('upload-progress', {
+            processedBytes: 100,
+            totalBytes: 1000,
+        });
+        node_assert_1.strict.equal(overallProgressCalled, true);
+        node_assert_1.strict.equal(overallProgressPayload?.processedBytes, 500 + 100 / 2);
+        node_assert_1.strict.equal(overallProgressPayload?.totalBytes, 1000);
+        node_assert_1.strict.equal(overallProgressPayload?.step, 'upload');
+    });
+});

package/lib/cjs/common/http.js

@@ -26,16 +26,6 @@ class TurboHTTPService {
             axiosConfig: {
                 baseURL: url,
                 maxRedirects: 0, // prevents backpressure issues when uploading larger streams via https
-                onUploadProgress: (progressEvent) => {
-                    this.logger.debug(`Uploading...`, {
-                        percent: Math.floor((progressEvent.progress ?? 0) * 100),
-                        loaded: `${progressEvent.loaded} bytes`,
-                        total: `${progressEvent.total} bytes`,
-                    });
-                    if (progressEvent.progress === 1) {
-                        this.logger.debug(`Upload complete!`);
-                    }
-                },
             },
             retryConfig,
             logger: this.logger,
@@ -58,10 +48,11 @@ class TurboHTTPService {
             return data;
         }
         catch (error) {
-            if (error instanceof axios_1.CanceledError) {
-                throw error;
+            if (error instanceof axios_1.AxiosError &&
+                error.code === axios_1.AxiosError.ERR_CANCELED) {
+                throw new axios_1.CanceledError();
             }
-            if (error instanceof axios_1.AxiosError) {
+            else if (error instanceof axios_1.AxiosError) {
                 throw new errors_js_1.FailedRequestError(error.code ?? error.message, error.status);
             }
             throw error;

package/lib/cjs/common/turbo.js

@@ -87,11 +87,12 @@ class TurboUnauthenticatedClient {
     /**
      * Uploads a signed data item to the Turbo Upload Service.
      */
-    uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, signal, }) {
+    uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, signal, events, }) {
         return this.uploadService.uploadSignedDataItem({
             dataItemStreamFactory,
             dataItemSizeFactory,
             signal,
+            events,
         });
     }
     /**
@@ -142,18 +143,19 @@ class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
     /**
      * Signs and uploads raw data to the Turbo Upload Service.
      */
-    upload({ data, dataItemOpts, signal, }) {
-        return this.uploadService.upload({ data, dataItemOpts, signal });
+    upload({ data, dataItemOpts, signal, events, }) {
+        return this.uploadService.upload({ data, dataItemOpts, signal, events });
     }
     /**
      * Signs and uploads raw file data to the Turbo Upload Service.
      */
-    uploadFile({ fileStreamFactory, fileSizeFactory, signal, dataItemOpts, }) {
+    uploadFile({ fileStreamFactory, fileSizeFactory, signal, dataItemOpts, events, }) {
         return this.uploadService.uploadFile({
             fileStreamFactory,
             fileSizeFactory,
             signal,
             dataItemOpts,
+            events,
         });
     }
     uploadFolder(p) {