@ardrive/turbo-sdk 1.0.1 → 1.1.0-alpha.1

package/lib/cjs/common/factory.js

@@ -1,16 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboBaseFactory = void 0;
+const logger_js_1 = require("./logger.js");
 const payment_js_1 = require("./payment.js");
 const turbo_js_1 = require("./turbo.js");
 const upload_js_1 = require("./upload.js");
 class TurboBaseFactory {
+    static setLogLevel(level) {
+        this.logger.setLogLevel(level);
+    }
+    static setLogFormat(format) {
+        this.logger.setLogFormat(format);
+    }
     static unauthenticated({ paymentServiceConfig = {}, uploadServiceConfig = {}, } = {}) {
         const paymentService = new payment_js_1.TurboUnauthenticatedPaymentService({
             ...paymentServiceConfig,
+            logger: this.logger,
         });
         const uploadService = new upload_js_1.TurboUnauthenticatedUploadService({
             ...uploadServiceConfig,
+            logger: this.logger,
         });
         return new turbo_js_1.TurboUnauthenticatedClient({
             uploadService,
@@ -19,3 +28,4 @@ class TurboBaseFactory {
     }
 }
 exports.TurboBaseFactory = TurboBaseFactory;
+TurboBaseFactory.logger = new logger_js_1.TurboWinstonLogger();

package/lib/cjs/common/http.js

@@ -4,12 +4,24 @@ exports.TurboHTTPService = void 0;
 const axiosClient_js_1 = require("../utils/axiosClient.js");
 const errors_js_1 = require("../utils/errors.js");
 class TurboHTTPService {
-    constructor({ url, retryConfig, }) {
+    constructor({ url, retryConfig, logger, }) {
+        this.logger = logger;
         this.axios = (0, axiosClient_js_1.createAxiosInstance)({
             axiosConfig: {
                 baseURL: url,
+                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,
         });
     }
     async get({ endpoint, signal, allowedStatuses = [200, 202], headers, }) {

package/lib/cjs/common/logger.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurboWinstonLogger = void 0;
+/**
+ * Copyright (C) 2022-2023 Permanent Data Solutions, Inc. All Rights Reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+const winston_1 = require("winston");
+const version_js_1 = require("../version.js");
+class TurboWinstonLogger {
+    constructor({ level = 'info', logFormat = 'simple', } = {}) {
+        this.logger = (0, winston_1.createLogger)({
+            level,
+            defaultMeta: { client: 'turbo-sdk', version: version_js_1.version },
+            silent: level === 'none',
+            format: getLogFormat(logFormat),
+            transports: [new winston_1.transports.Console()],
+        });
+    }
+    info(message, ...args) {
+        this.logger.info(message, ...args);
+    }
+    warn(message, ...args) {
+        this.logger.warn(message, ...args);
+    }
+    error(message, ...args) {
+        this.logger.error(message, ...args);
+    }
+    debug(message, ...args) {
+        this.logger.debug(message, ...args);
+    }
+    setLogLevel(level) {
+        this.logger.level = level;
+    }
+    setLogFormat(logFormat) {
+        this.logger.format = getLogFormat(logFormat);
+    }
+}
+exports.TurboWinstonLogger = TurboWinstonLogger;
+function getLogFormat(logFormat) {
+    return winston_1.format.combine((0, winston_1.format)((info) => {
+        if (info.stack && info.level !== 'error') {
+            delete info.stack;
+        }
+        return info;
+    })(), winston_1.format.errors({ stack: true }), // Ensure errors show a stack trace
+    winston_1.format.timestamp(), logFormat === 'json' ? winston_1.format.json() : winston_1.format.simple());
+}

package/lib/cjs/common/payment.js

@@ -2,13 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboAuthenticatedPaymentService = exports.TurboUnauthenticatedPaymentService = exports.defaultPaymentServiceURL = exports.developmentPaymentServiceURL = void 0;
 const http_js_1 = require("./http.js");
+const logger_js_1 = require("./logger.js");
 exports.developmentPaymentServiceURL = 'https://payment.ardrive.dev';
 exports.defaultPaymentServiceURL = 'https://payment.ardrive.io';
 class TurboUnauthenticatedPaymentService {
-    constructor({ url = exports.defaultPaymentServiceURL, retryConfig, }) {
+    constructor({ url = exports.defaultPaymentServiceURL, retryConfig, logger = new logger_js_1.TurboWinstonLogger(), }) {
+        this.logger = logger;
         this.httpService = new http_js_1.TurboHTTPService({
             url: `${url}/v1`,
             retryConfig,
+            logger: this.logger,
         });
     }
     getFiatRates() {
@@ -70,8 +73,8 @@ class TurboUnauthenticatedPaymentService {
 exports.TurboUnauthenticatedPaymentService = TurboUnauthenticatedPaymentService;
 // NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
 class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentService {
-    constructor({ url = exports.defaultPaymentServiceURL, retryConfig, signer, }) {
-        super({ url, retryConfig });
+    constructor({ url = exports.defaultPaymentServiceURL, retryConfig, signer, logger, }) {
+        super({ url, retryConfig, logger });
         this.signer = signer;
     }
     async getBalance() {

package/lib/cjs/common/upload.js

@@ -1,18 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TurboAuthenticatedUploadService = exports.TurboUnauthenticatedUploadService = exports.developmentUploadServiceURL = exports.defaultUploadServiceURL = void 0;
+exports.TurboAuthenticatedUploadService = exports.TurboUnauthenticatedUploadService = exports.defaultUploadServiceURL = exports.developmentUploadServiceURL = void 0;
 const http_js_1 = require("./http.js");
-exports.defaultUploadServiceURL = 'https://upload.ardrive.io';
+const logger_js_1 = require("./logger.js");
 exports.developmentUploadServiceURL = 'https://upload.ardrive.dev';
+exports.defaultUploadServiceURL = 'https://upload.ardrive.io';
 class TurboUnauthenticatedUploadService {
-    constructor({ url = exports.defaultUploadServiceURL, retryConfig, }) {
+    constructor({ url = exports.defaultUploadServiceURL, retryConfig, logger = new logger_js_1.TurboWinstonLogger(), }) {
+        this.logger = logger;
         this.httpService = new http_js_1.TurboHTTPService({
             url: `${url}/v1`,
             retryConfig,
+            logger: this.logger,
         });
     }
     async uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, signal, }) {
         const fileSize = dataItemSizeFactory();
+        this.logger.debug('Uploading signed data item...');
         // TODO: add p-limit constraint or replace with separate upload class
         return this.httpService.post({
             endpoint: `/tx`,
@@ -28,8 +32,8 @@ class TurboUnauthenticatedUploadService {
 exports.TurboUnauthenticatedUploadService = TurboUnauthenticatedUploadService;
 // NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
 class TurboAuthenticatedUploadService extends TurboUnauthenticatedUploadService {
-    constructor({ url = 'https://upload.ardrive.dev', retryConfig, signer, }) {
-        super({ url, retryConfig });
+    constructor({ url = exports.defaultUploadServiceURL, retryConfig, signer, logger, }) {
+        super({ url, retryConfig, logger });
         this.signer = signer;
     }
     async uploadFile({ fileStreamFactory, fileSizeFactory, signal, }) {
@@ -39,6 +43,7 @@ class TurboAuthenticatedUploadService extends TurboUnauthenticatedUploadService
         });
         const signedDataItem = dataItemStreamFactory();
         const fileSize = dataItemSizeFactory();
+        this.logger.debug('Uploading signed data item...');
         // TODO: add p-limit constraint or replace with separate upload class
         return this.httpService.post({
             endpoint: `/tx`,

package/lib/cjs/node/factory.js

@@ -22,14 +22,19 @@ const index_js_1 = require("../common/index.js");
 const signer_js_1 = require("./signer.js");
 class TurboFactory extends factory_js_1.TurboBaseFactory {
     static authenticated({ privateKey, paymentServiceConfig = {}, uploadServiceConfig = {}, }) {
-        const signer = new signer_js_1.TurboNodeArweaveSigner({ privateKey });
+        const signer = new signer_js_1.TurboNodeArweaveSigner({
+            privateKey,
+            logger: this.logger,
+        });
         const paymentService = new index_js_1.TurboAuthenticatedPaymentService({
             ...paymentServiceConfig,
             signer,
+            logger: this.logger,
         });
         const uploadService = new index_js_1.TurboAuthenticatedUploadService({
             ...uploadServiceConfig,
             signer,
+            logger: this.logger,
         });
         return new index_js_1.TurboAuthenticatedClient({
             uploadService,

package/lib/cjs/node/signer.js

@@ -26,14 +26,17 @@ const node_crypto_1 = require("node:crypto");
 const base64_js_1 = require("../utils/base64.js");
 class TurboNodeArweaveSigner {
     // TODO: replace with internal signer class
-    constructor({ privateKey }) {
+    constructor({ privateKey, logger, }) {
         this.privateKey = privateKey;
+        this.logger = logger;
         this.signer = new arbundles_1.ArweaveSigner(this.privateKey);
     }
     async signDataItem({ fileStreamFactory, fileSizeFactory, }) {
         // TODO: replace with our own signer implementation
+        this.logger.debug('Signing data item...');
         const [stream1, stream2] = [fileStreamFactory(), fileStreamFactory()];
         const signedDataItem = await (0, arbundles_1.streamSigner)(stream1, stream2, this.signer);
+        this.logger.debug('Successfully signed data item...');
         // TODO: support target, anchor, and tags
         const signedDataItemSize = this.calculateSignedDataHeadersSize({
             dataSize: fileSizeFactory(),

package/lib/cjs/utils/axiosClient.js

@@ -45,12 +45,13 @@ exports.createAxiosInstance = exports.defaultRequestHeaders = void 0;
  */
 const axios_1 = __importStar(require("axios"));
 const axios_retry_1 = __importDefault(require("axios-retry"));
+const logger_js_1 = require("../common/logger.js");
 const version_js_1 = require("../version.js");
 exports.defaultRequestHeaders = {
     'x-turbo-source-version': version_js_1.version,
     'x-turbo-source-identifier': 'turbo-sdk',
 };
-const createAxiosInstance = ({ axiosConfig = {}, retryConfig = {
+const createAxiosInstance = ({ logger = new logger_js_1.TurboWinstonLogger(), axiosConfig = {}, retryConfig = {
     retryDelay: axios_retry_1.default.exponentialDelay,
     retries: 3,
     retryCondition: (error) => {
@@ -58,12 +59,15 @@ const createAxiosInstance = ({ axiosConfig = {}, retryConfig = {
             axios_retry_1.default.isNetworkOrIdempotentRequestError(error));
     },
     onRetry: (retryCount, error) => {
-        console.debug(`Request failed, ${error}. Retry attempt #${retryCount}...`);
+        logger.debug(`Request failed, ${error}. Retry attempt #${retryCount}...`);
     },
-}, }) => {
+}, } = {}) => {
     const axiosInstance = axios_1.default.create({
         ...axiosConfig,
-        headers: exports.defaultRequestHeaders,
+        headers: {
+            ...axiosConfig.headers,
+            ...exports.defaultRequestHeaders,
+        },
         validateStatus: () => true, // don't throw on non-200 status codes
     });
     // eslint-disable-next-line

package/lib/cjs/version.js

@@ -18,4 +18,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-exports.version = '1.0.1';
+exports.version = '1.1.0-alpha.1';

package/lib/cjs/web/factory.js

@@ -22,14 +22,19 @@ const index_js_1 = require("../common/index.js");
 const signer_js_1 = require("./signer.js");
 class TurboFactory extends factory_js_1.TurboBaseFactory {
     static authenticated({ privateKey, paymentServiceConfig = {}, uploadServiceConfig = {}, }) {
-        const signer = new signer_js_1.TurboWebArweaveSigner({ privateKey });
+        const signer = new signer_js_1.TurboWebArweaveSigner({
+            privateKey,
+            logger: this.logger,
+        });
         const paymentService = new index_js_1.TurboAuthenticatedPaymentService({
             ...paymentServiceConfig,
             signer,
+            logger: this.logger,
         });
         const uploadService = new index_js_1.TurboAuthenticatedUploadService({
             ...uploadServiceConfig,
             signer,
+            logger: this.logger,
         });
         return new index_js_1.TurboAuthenticatedClient({
             uploadService,

package/lib/cjs/web/signer.js

@@ -26,8 +26,9 @@ const node_crypto_1 = require("node:crypto");
 const base64_js_1 = require("../utils/base64.js");
 const readableStream_js_1 = require("../utils/readableStream.js");
 class TurboWebArweaveSigner {
-    constructor({ privateKey }) {
+    constructor({ privateKey, logger, }) {
         this.privateKey = privateKey;
+        this.logger = logger;
         this.signer = new arbundles_1.ArweaveSigner(this.privateKey);
     }
     async signDataItem({ fileStreamFactory, fileSizeFactory, }) {
@@ -36,9 +37,11 @@ class TurboWebArweaveSigner {
             stream: fileStreamFactory(),
             size: fileSizeFactory(),
         });
+        this.logger.debug('Signing data item...');
         // TODO: support target, anchor and tags for upload
         const signedDataItem = (0, arbundles_1.createData)(buffer, this.signer, {});
         await signedDataItem.sign(this.signer);
+        this.logger.debug('Successfully signed data item...');
         return {
             // while this returns a Buffer - it needs to match our return type for uploading
             dataItemStreamFactory: () => signedDataItem.getRaw(),

package/lib/esm/common/factory.js

@@ -1,13 +1,22 @@
+import { TurboWinstonLogger } from './logger.js';
 import { TurboUnauthenticatedPaymentService } from './payment.js';
 import { TurboUnauthenticatedClient } from './turbo.js';
 import { TurboUnauthenticatedUploadService } from './upload.js';
 export class TurboBaseFactory {
+    static setLogLevel(level) {
+        this.logger.setLogLevel(level);
+    }
+    static setLogFormat(format) {
+        this.logger.setLogFormat(format);
+    }
     static unauthenticated({ paymentServiceConfig = {}, uploadServiceConfig = {}, } = {}) {
         const paymentService = new TurboUnauthenticatedPaymentService({
             ...paymentServiceConfig,
+            logger: this.logger,
         });
         const uploadService = new TurboUnauthenticatedUploadService({
             ...uploadServiceConfig,
+            logger: this.logger,
         });
         return new TurboUnauthenticatedClient({
             uploadService,
@@ -15,3 +24,4 @@ export class TurboBaseFactory {
         });
     }
 }
+TurboBaseFactory.logger = new TurboWinstonLogger();

package/lib/esm/common/http.js

@@ -1,12 +1,24 @@
 import { createAxiosInstance } from '../utils/axiosClient.js';
 import { FailedRequestError } from '../utils/errors.js';
 export class TurboHTTPService {
-    constructor({ url, retryConfig, }) {
+    constructor({ url, retryConfig, logger, }) {
+        this.logger = logger;
         this.axios = createAxiosInstance({
             axiosConfig: {
                 baseURL: url,
+                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,
         });
     }
     async get({ endpoint, signal, allowedStatuses = [200, 202], headers, }) {

package/lib/esm/common/logger.js

@@ -0,0 +1,56 @@
+/**
+ * Copyright (C) 2022-2023 Permanent Data Solutions, Inc. All Rights Reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+import { createLogger, format, transports } from 'winston';
+import { version } from '../version.js';
+export class TurboWinstonLogger {
+    constructor({ level = 'info', logFormat = 'simple', } = {}) {
+        this.logger = createLogger({
+            level,
+            defaultMeta: { client: 'turbo-sdk', version },
+            silent: level === 'none',
+            format: getLogFormat(logFormat),
+            transports: [new transports.Console()],
+        });
+    }
+    info(message, ...args) {
+        this.logger.info(message, ...args);
+    }
+    warn(message, ...args) {
+        this.logger.warn(message, ...args);
+    }
+    error(message, ...args) {
+        this.logger.error(message, ...args);
+    }
+    debug(message, ...args) {
+        this.logger.debug(message, ...args);
+    }
+    setLogLevel(level) {
+        this.logger.level = level;
+    }
+    setLogFormat(logFormat) {
+        this.logger.format = getLogFormat(logFormat);
+    }
+}
+function getLogFormat(logFormat) {
+    return format.combine(format((info) => {
+        if (info.stack && info.level !== 'error') {
+            delete info.stack;
+        }
+        return info;
+    })(), format.errors({ stack: true }), // Ensure errors show a stack trace
+    format.timestamp(), logFormat === 'json' ? format.json() : format.simple());
+}

package/lib/esm/common/payment.js

@@ -1,11 +1,14 @@
 import { TurboHTTPService } from './http.js';
+import { TurboWinstonLogger } from './logger.js';
 export const developmentPaymentServiceURL = 'https://payment.ardrive.dev';
 export const defaultPaymentServiceURL = 'https://payment.ardrive.io';
 export class TurboUnauthenticatedPaymentService {
-    constructor({ url = defaultPaymentServiceURL, retryConfig, }) {
+    constructor({ url = defaultPaymentServiceURL, retryConfig, logger = new TurboWinstonLogger(), }) {
+        this.logger = logger;
         this.httpService = new TurboHTTPService({
             url: `${url}/v1`,
             retryConfig,
+            logger: this.logger,
         });
     }
     getFiatRates() {
@@ -66,8 +69,8 @@ export class TurboUnauthenticatedPaymentService {
 }
 // NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
 export class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentService {
-    constructor({ url = defaultPaymentServiceURL, retryConfig, signer, }) {
-        super({ url, retryConfig });
+    constructor({ url = defaultPaymentServiceURL, retryConfig, signer, logger, }) {
+        super({ url, retryConfig, logger });
         this.signer = signer;
     }
     async getBalance() {

package/lib/esm/common/upload.js

@@ -1,15 +1,19 @@
 import { TurboHTTPService } from './http.js';
-export const defaultUploadServiceURL = 'https://upload.ardrive.io';
+import { TurboWinstonLogger } from './logger.js';
 export const developmentUploadServiceURL = 'https://upload.ardrive.dev';
+export const defaultUploadServiceURL = 'https://upload.ardrive.io';
 export class TurboUnauthenticatedUploadService {
-    constructor({ url = defaultUploadServiceURL, retryConfig, }) {
+    constructor({ url = defaultUploadServiceURL, retryConfig, logger = new TurboWinstonLogger(), }) {
+        this.logger = logger;
         this.httpService = new TurboHTTPService({
             url: `${url}/v1`,
             retryConfig,
+            logger: this.logger,
         });
     }
     async uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, signal, }) {
         const fileSize = dataItemSizeFactory();
+        this.logger.debug('Uploading signed data item...');
         // TODO: add p-limit constraint or replace with separate upload class
         return this.httpService.post({
             endpoint: `/tx`,
@@ -24,8 +28,8 @@ export class TurboUnauthenticatedUploadService {
 }
 // NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
 export class TurboAuthenticatedUploadService extends TurboUnauthenticatedUploadService {
-    constructor({ url = 'https://upload.ardrive.dev', retryConfig, signer, }) {
-        super({ url, retryConfig });
+    constructor({ url = defaultUploadServiceURL, retryConfig, signer, logger, }) {
+        super({ url, retryConfig, logger });
         this.signer = signer;
     }
     async uploadFile({ fileStreamFactory, fileSizeFactory, signal, }) {
@@ -35,6 +39,7 @@ export class TurboAuthenticatedUploadService extends TurboUnauthenticatedUploadS
         });
         const signedDataItem = dataItemStreamFactory();
         const fileSize = dataItemSizeFactory();
+        this.logger.debug('Uploading signed data item...');
         // TODO: add p-limit constraint or replace with separate upload class
         return this.httpService.post({
             endpoint: `/tx`,

package/lib/esm/node/factory.js

@@ -19,14 +19,19 @@ import { TurboAuthenticatedClient, TurboAuthenticatedPaymentService, TurboAuthen
 import { TurboNodeArweaveSigner } from './signer.js';
 export class TurboFactory extends TurboBaseFactory {
     static authenticated({ privateKey, paymentServiceConfig = {}, uploadServiceConfig = {}, }) {
-        const signer = new TurboNodeArweaveSigner({ privateKey });
+        const signer = new TurboNodeArweaveSigner({
+            privateKey,
+            logger: this.logger,
+        });
         const paymentService = new TurboAuthenticatedPaymentService({
             ...paymentServiceConfig,
             signer,
+            logger: this.logger,
         });
         const uploadService = new TurboAuthenticatedUploadService({
             ...uploadServiceConfig,
             signer,
+            logger: this.logger,
         });
         return new TurboAuthenticatedClient({
             uploadService,

package/lib/esm/node/signer.js

@@ -20,14 +20,17 @@ import { randomBytes } from 'node:crypto';
 import { toB64Url } from '../utils/base64.js';
 export class TurboNodeArweaveSigner {
     // TODO: replace with internal signer class
-    constructor({ privateKey }) {
+    constructor({ privateKey, logger, }) {
         this.privateKey = privateKey;
+        this.logger = logger;
         this.signer = new ArweaveSigner(this.privateKey);
     }
     async signDataItem({ fileStreamFactory, fileSizeFactory, }) {
         // TODO: replace with our own signer implementation
+        this.logger.debug('Signing data item...');
         const [stream1, stream2] = [fileStreamFactory(), fileStreamFactory()];
         const signedDataItem = await streamSigner(stream1, stream2, this.signer);
+        this.logger.debug('Successfully signed data item...');
         // TODO: support target, anchor, and tags
         const signedDataItemSize = this.calculateSignedDataHeadersSize({
             dataSize: fileSizeFactory(),

package/lib/esm/utils/axiosClient.js

@@ -16,12 +16,13 @@
  */
 import axios, { CanceledError } from 'axios';
 import axiosRetry from 'axios-retry';
+import { TurboWinstonLogger } from '../common/logger.js';
 import { version } from '../version.js';
 export const defaultRequestHeaders = {
     'x-turbo-source-version': version,
     'x-turbo-source-identifier': 'turbo-sdk',
 };
-export const createAxiosInstance = ({ axiosConfig = {}, retryConfig = {
+export const createAxiosInstance = ({ logger = new TurboWinstonLogger(), axiosConfig = {}, retryConfig = {
     retryDelay: axiosRetry.exponentialDelay,
     retries: 3,
     retryCondition: (error) => {
@@ -29,12 +30,15 @@ export const createAxiosInstance = ({ axiosConfig = {}, retryConfig = {
             axiosRetry.isNetworkOrIdempotentRequestError(error));
     },
     onRetry: (retryCount, error) => {
-        console.debug(`Request failed, ${error}. Retry attempt #${retryCount}...`);
+        logger.debug(`Request failed, ${error}. Retry attempt #${retryCount}...`);
     },
-}, }) => {
+}, } = {}) => {
     const axiosInstance = axios.create({
         ...axiosConfig,
-        headers: defaultRequestHeaders,
+        headers: {
+            ...axiosConfig.headers,
+            ...defaultRequestHeaders,
+        },
         validateStatus: () => true, // don't throw on non-200 status codes
     });
     // eslint-disable-next-line

package/lib/esm/version.js

@@ -15,4 +15,4 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-export const version = '1.0.1';
+export const version = '1.1.0-alpha.1';

package/lib/esm/web/factory.js

@@ -19,14 +19,19 @@ import { TurboAuthenticatedClient, TurboAuthenticatedPaymentService, TurboAuthen
 import { TurboWebArweaveSigner } from './signer.js';
 export class TurboFactory extends TurboBaseFactory {
     static authenticated({ privateKey, paymentServiceConfig = {}, uploadServiceConfig = {}, }) {
-        const signer = new TurboWebArweaveSigner({ privateKey });
+        const signer = new TurboWebArweaveSigner({
+            privateKey,
+            logger: this.logger,
+        });
         const paymentService = new TurboAuthenticatedPaymentService({
             ...paymentServiceConfig,
             signer,
+            logger: this.logger,
         });
         const uploadService = new TurboAuthenticatedUploadService({
             ...uploadServiceConfig,
             signer,
+            logger: this.logger,
         });
         return new TurboAuthenticatedClient({
             uploadService,

package/lib/esm/web/signer.js

@@ -20,8 +20,9 @@ import { randomBytes } from 'node:crypto';
 import { toB64Url } from '../utils/base64.js';
 import { readableStreamToBuffer } from '../utils/readableStream.js';
 export class TurboWebArweaveSigner {
-    constructor({ privateKey }) {
+    constructor({ privateKey, logger, }) {
         this.privateKey = privateKey;
+        this.logger = logger;
         this.signer = new ArweaveSigner(this.privateKey);
     }
     async signDataItem({ fileStreamFactory, fileSizeFactory, }) {
@@ -30,9 +31,11 @@ export class TurboWebArweaveSigner {
             stream: fileStreamFactory(),
             size: fileSizeFactory(),
         });
+        this.logger.debug('Signing data item...');
         // TODO: support target, anchor and tags for upload
         const signedDataItem = createData(buffer, this.signer, {});
         await signedDataItem.sign(this.signer);
+        this.logger.debug('Successfully signed data item...');
         return {
             // while this returns a Buffer - it needs to match our return type for uploading
             dataItemStreamFactory: () => signedDataItem.getRaw(),

package/lib/types/common/factory.d.ts

@@ -15,8 +15,12 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 import { TurboUnauthenticatedConfiguration } from '../types.js';
+import { TurboWinstonLogger } from './logger.js';
 import { TurboUnauthenticatedClient } from './turbo.js';
 export declare class TurboBaseFactory {
+    protected static logger: TurboWinstonLogger;
+    static setLogLevel(level: string): void;
+    static setLogFormat(format: string): void;
     static unauthenticated({ paymentServiceConfig, uploadServiceConfig, }?: TurboUnauthenticatedConfiguration): TurboUnauthenticatedClient;
 }
 //# sourceMappingURL=factory.d.ts.map

package/lib/types/common/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/common/factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,iCAAiC,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAGxD,qBAAa,gBAAgB;IAC3B,MAAM,CAAC,eAAe,CAAC,EACrB,oBAAyB,EACzB,mBAAwB,GACzB,GAAE,iCAAsC;CAY1C"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/common/factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,iCAAiC,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAGxD,qBAAa,gBAAgB;IAC3B,SAAS,CAAC,MAAM,CAAC,MAAM,qBAA4B;IAEnD,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAIhC,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM;IAIlC,MAAM,CAAC,eAAe,CAAC,EACrB,oBAAyB,EACzB,mBAAwB,GACzB,GAAE,iCAAsC;CAc1C"}