@unito/integration-sdk 2.3.4 → 2.3.6

package/dist/src/index.cjs

@@ -165,9 +165,10 @@ class Logger {
             const coloredMessage = Logger.colorize(message, processedLogs, logLevel);
             const metadata = {
                 date: new Date(processedLogs.date).toISOString(),
-                ...processedMetadata,
+                ...(processedMetadata.error && { error: processedMetadata.error }),
             };
-            console[logLevel](`${coloredMessage} ${JSON.stringify(metadata, null, 2)}`);
+            const metadataString = Object.keys(metadata).length > 1 ? ` ${JSON.stringify(metadata, null, 2)}` : ` ${JSON.stringify(metadata)}`;
+            console[logLevel](`${coloredMessage}${metadataString}`);
         }
         else {
             console[logLevel](JSON.stringify(processedLogs));
@@ -219,9 +220,8 @@ class Logger {
      */
     static colorize(message, metadata, logLevel) {
         if (!process.stdout.isTTY) {
-            return message;
+            return `${logLevel}: ${message}`;
         }
-        const logOutput = `${logLevel}: ${message}`;
         // Extract status code from logs
         let statusCode;
         if (metadata.http && typeof metadata.http === 'object' && !Array.isArray(metadata.http)) {
@@ -236,28 +236,28 @@ class Logger {
         // Color based on status code first
         if (statusCode) {
             if (statusCode >= 400) {
-                return util.styleText('red', logOutput);
+                return `${util.styleText('red', logLevel)}: ${util.styleText('red', message)}`;
             }
             else if (statusCode >= 300) {
-                return util.styleText('yellow', logOutput);
+                return `${util.styleText('yellow', logLevel)}: ${util.styleText('yellow', message)}`;
             }
             else if (statusCode >= 200) {
-                return util.styleText('green', logOutput);
+                return `${util.styleText('green', logLevel)}: ${util.styleText('green', message)}`;
             }
         }
         // Fall back to log level if no status code found
         switch (logLevel) {
             case LogLevel.ERROR:
-                return util.styleText('red', logOutput);
+                return `${util.styleText('red', logLevel)}: ${util.styleText('red', message)}`;
             case LogLevel.WARN:
-                return util.styleText('yellow', logOutput);
+                return `${util.styleText('yellow', logLevel)}: ${util.styleText('yellow', message)}`;
             case LogLevel.INFO:
             case LogLevel.LOG:
-                return util.styleText('green', logOutput);
+                return `${util.styleText('green', logLevel)}: ${util.styleText('green', message)}`;
             case LogLevel.DEBUG:
-                return util.styleText('cyan', logOutput);
+                return `${util.styleText('cyan', logLevel)}: ${util.styleText('cyan', message)}`;
             default:
-                return logOutput;
+                return `${logLevel}: ${message}`;
         }
     }
 }
@@ -1440,13 +1440,18 @@ class Provider {
      * @param options RequestOptions used to adjust the call made to the provider (use to override default headers).
      * @returns The {@link Response} extracted from the provider.
      */
-    async delete(endpoint, options) {
-        return this.fetchWrapper(endpoint, null, {
+    async delete(endpoint, options, body = null) {
+        const defaultHeaders = {
+            Accept: 'application/json',
+        };
+        // Only add Content-Type header when body is provided
+        if (body !== null) {
+            defaultHeaders['Content-Type'] = 'application/json';
+        }
+        return this.fetchWrapper(endpoint, body, {
             ...options,
             method: 'DELETE',
-            defaultHeaders: {
-                Accept: 'application/json',
-            },
+            defaultHeaders,
         });
     }
     generateAbsoluteUrl(providerUrl, endpoint, queryParams) {

package/dist/src/resources/logger.js

@@ -137,9 +137,10 @@ export default class Logger {
             const coloredMessage = Logger.colorize(message, processedLogs, logLevel);
             const metadata = {
                 date: new Date(processedLogs.date).toISOString(),
-                ...processedMetadata,
+                ...(processedMetadata.error && { error: processedMetadata.error }),
             };
-            console[logLevel](`${coloredMessage} ${JSON.stringify(metadata, null, 2)}`);
+            const metadataString = Object.keys(metadata).length > 1 ? ` ${JSON.stringify(metadata, null, 2)}` : ` ${JSON.stringify(metadata)}`;
+            console[logLevel](`${coloredMessage}${metadataString}`);
         }
         else {
             console[logLevel](JSON.stringify(processedLogs));
@@ -191,9 +192,8 @@ export default class Logger {
      */
     static colorize(message, metadata, logLevel) {
         if (!process.stdout.isTTY) {
-            return message;
+            return `${logLevel}: ${message}`;
         }
-        const logOutput = `${logLevel}: ${message}`;
         // Extract status code from logs
         let statusCode;
         if (metadata.http && typeof metadata.http === 'object' && !Array.isArray(metadata.http)) {
@@ -208,28 +208,28 @@ export default class Logger {
         // Color based on status code first
         if (statusCode) {
             if (statusCode >= 400) {
-                return styleText('red', logOutput);
+                return `${styleText('red', logLevel)}: ${styleText('red', message)}`;
             }
             else if (statusCode >= 300) {
-                return styleText('yellow', logOutput);
+                return `${styleText('yellow', logLevel)}: ${styleText('yellow', message)}`;
             }
             else if (statusCode >= 200) {
-                return styleText('green', logOutput);
+                return `${styleText('green', logLevel)}: ${styleText('green', message)}`;
             }
         }
         // Fall back to log level if no status code found
         switch (logLevel) {
             case LogLevel.ERROR:
-                return styleText('red', logOutput);
+                return `${styleText('red', logLevel)}: ${styleText('red', message)}`;
             case LogLevel.WARN:
-                return styleText('yellow', logOutput);
+                return `${styleText('yellow', logLevel)}: ${styleText('yellow', message)}`;
             case LogLevel.INFO:
             case LogLevel.LOG:
-                return styleText('green', logOutput);
+                return `${styleText('green', logLevel)}: ${styleText('green', message)}`;
             case LogLevel.DEBUG:
-                return styleText('cyan', logOutput);
+                return `${styleText('cyan', logLevel)}: ${styleText('cyan', message)}`;
             default:
-                return logOutput;
+                return `${logLevel}: ${message}`;
         }
     }
 }

package/dist/src/resources/provider.d.ts

@@ -207,7 +207,7 @@ export declare class Provider {
      * @param options RequestOptions used to adjust the call made to the provider (use to override default headers).
      * @returns The {@link Response} extracted from the provider.
      */
-    delete<T = undefined>(endpoint: string, options: RequestOptions): Promise<Response<T>>;
+    delete<T = undefined>(endpoint: string, options: RequestOptions, body?: RequestBody | null): Promise<Response<T>>;
     private generateAbsoluteUrl;
     private fetchWrapper;
     private handleError;

package/dist/src/resources/provider.js

@@ -241,13 +241,18 @@ export class Provider {
      * @param options RequestOptions used to adjust the call made to the provider (use to override default headers).
      * @returns The {@link Response} extracted from the provider.
      */
-    async delete(endpoint, options) {
-        return this.fetchWrapper(endpoint, null, {
+    async delete(endpoint, options, body = null) {
+        const defaultHeaders = {
+            Accept: 'application/json',
+        };
+        // Only add Content-Type header when body is provided
+        if (body !== null) {
+            defaultHeaders['Content-Type'] = 'application/json';
+        }
+        return this.fetchWrapper(endpoint, body, {
             ...options,
             method: 'DELETE',
-            defaultHeaders: {
-                Accept: 'application/json',
-            },
+            defaultHeaders,
         });
     }
     generateAbsoluteUrl(providerUrl, endpoint, queryParams) {

package/dist/test/resources/logger.test.js

@@ -250,4 +250,61 @@ describe('Logger', () => {
             });
         }
     });
+    it('only logs date for metadata of successful requests in development', testContext => {
+        const originalEnv = process.env.NODE_ENV;
+        try {
+            process.env.NODE_ENV = 'development';
+            const infoSpy = testContext.mock.method(global.console, 'info', () => { });
+            const metadata = {
+                correlation_id: '123456789',
+                http: { method: 'GET', status_code: 200 },
+                user_id: 'user123',
+                request_id: 'req456',
+            };
+            const logger = new Logger(metadata);
+            logger.info('Test message without error');
+            assert.strictEqual(infoSpy.mock.calls.length, 1);
+            const loggedOutput = infoSpy.mock.calls[0]?.arguments[0];
+            assert.ok(loggedOutput.includes('Test message without error'));
+            // Should only contain date in metadata JSON
+            const metadataMatch = loggedOutput.match(/({.*})/);
+            assert.ok(metadataMatch);
+            const parsedMetadata = JSON.parse(metadataMatch[1]);
+            assert.ok(parsedMetadata.date);
+            assert.strictEqual(Object.keys(parsedMetadata).length, 1); // What matters: Only the date
+        }
+        finally {
+            process.env.NODE_ENV = originalEnv;
+        }
+    });
+    it('logs date & error stack for metadata of failed requests in development', testContext => {
+        const originalEnv = process.env.NODE_ENV;
+        try {
+            process.env.NODE_ENV = 'development';
+            const metadata = {
+                correlation_id: '123456789',
+                http: { method: 'GET', status_code: 200 },
+                user_id: 'user123',
+                request_id: 'req456',
+            };
+            const logger = new Logger(metadata);
+            // Test with error metadata
+            const errorSpy = testContext.mock.method(global.console, 'error', () => { });
+            logger.error('Test message with error', { error: { code: 500, message: 'Internal Server Error' } });
+            assert.strictEqual(errorSpy.mock.calls.length, 1);
+            const errorLoggedOutput = errorSpy.mock.calls[0]?.arguments[0];
+            assert.ok(errorLoggedOutput.includes('Test message with error'));
+            // Should contain both date and error in metadata JSON
+            const errorMetadataMatch = errorLoggedOutput.match(/({.*})/s);
+            assert.ok(errorMetadataMatch);
+            const parsedErrorMetadata = JSON.parse(errorMetadataMatch[1]);
+            assert.ok(parsedErrorMetadata.date);
+            assert.ok(parsedErrorMetadata.error);
+            assert.deepEqual(parsedErrorMetadata.error, { code: 500, message: 'Internal Server Error' });
+            assert.strictEqual(Object.keys(parsedErrorMetadata).length, 2); // What matters: Date and error only
+        }
+        finally {
+            process.env.NODE_ENV = originalEnv;
+        }
+    });
 });

package/dist/test/resources/provider.test.js

@@ -404,6 +404,37 @@ describe('Provider', () => {
         ]);
         assert.deepEqual(actualResponse, { status: 204, headers: response.headers, body: undefined });
     });
+    it('deleteWithBody', async (context) => {
+        const response = new Response('{"success": true}', {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        const requestBody = { webhookIds: [1, 2, 3] };
+        const actualResponse = await provider.delete('/webhook', {
+            credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+            logger: logger,
+            signal: new AbortController().signal,
+            additionnalheaders: { 'X-Additional-Header': 'value1' },
+        }, requestBody);
+        assert.equal(fetchMock.mock.calls.length, 1);
+        assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+            'www.myApi.com/webhook',
+            {
+                method: 'DELETE',
+                body: JSON.stringify(requestBody),
+                signal: new AbortController().signal,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': 'apikey#1111',
+                    'X-Additional-Header': 'value1',
+                },
+            },
+        ]);
+        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { success: true } });
+    });
     it('uses rate limiter if provided', async (context) => {
         const mockRateLimiter = context.mock.fn((_context, request) => Promise.resolve(request()));
         const rateLimitedProvider = new Provider({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "2.3.4",
+  "version": "2.3.6",
   "description": "Integration SDK",
   "type": "module",
   "types": "dist/src/index.d.ts",

package/src/resources/logger.ts

@@ -168,10 +168,13 @@ export default class Logger {
 
       const metadata = {
         date: new Date(processedLogs.date).toISOString(),
-        ...processedMetadata,
+        ...(processedMetadata.error && { error: processedMetadata.error }),
       };
 
-      console[logLevel](`${coloredMessage} ${JSON.stringify(metadata, null, 2)}`);
+      const metadataString =
+        Object.keys(metadata).length > 1 ? ` ${JSON.stringify(metadata, null, 2)}` : ` ${JSON.stringify(metadata)}`;
+
+      console[logLevel](`${coloredMessage}${metadataString}`);
     } else {
       console[logLevel](JSON.stringify(processedLogs));
     }
@@ -228,11 +231,9 @@ export default class Logger {
    */
   private static colorize(message: string, metadata: Value, logLevel: LogLevel): string {
     if (!process.stdout.isTTY) {
-      return message;
+      return `${logLevel}: ${message}`;
     }
 
-    const logOutput = `${logLevel}: ${message}`;
-
     // Extract status code from logs
     let statusCode: number | undefined;
     if (metadata.http && typeof metadata.http === 'object' && !Array.isArray(metadata.http)) {
@@ -248,27 +249,27 @@ export default class Logger {
     // Color based on status code first
     if (statusCode) {
       if (statusCode >= 400) {
-        return styleText('red', logOutput);
+        return `${styleText('red', logLevel)}: ${styleText('red', message)}`;
       } else if (statusCode >= 300) {
-        return styleText('yellow', logOutput);
+        return `${styleText('yellow', logLevel)}: ${styleText('yellow', message)}`;
       } else if (statusCode >= 200) {
-        return styleText('green', logOutput);
+        return `${styleText('green', logLevel)}: ${styleText('green', message)}`;
       }
     }
 
     // Fall back to log level if no status code found
     switch (logLevel) {
       case LogLevel.ERROR:
-        return styleText('red', logOutput);
+        return `${styleText('red', logLevel)}: ${styleText('red', message)}`;
       case LogLevel.WARN:
-        return styleText('yellow', logOutput);
+        return `${styleText('yellow', logLevel)}: ${styleText('yellow', message)}`;
       case LogLevel.INFO:
       case LogLevel.LOG:
-        return styleText('green', logOutput);
+        return `${styleText('green', logLevel)}: ${styleText('green', message)}`;
       case LogLevel.DEBUG:
-        return styleText('cyan', logOutput);
+        return `${styleText('cyan', logLevel)}: ${styleText('cyan', message)}`;
       default:
-        return logOutput;
+        return `${logLevel}: ${message}`;
     }
   }
 }

package/src/resources/provider.ts

@@ -336,13 +336,24 @@ export class Provider {
    * @param options RequestOptions used to adjust the call made to the provider (use to override default headers).
    * @returns The {@link Response} extracted from the provider.
    */
-  public async delete<T = undefined>(endpoint: string, options: RequestOptions): Promise<Response<T>> {
-    return this.fetchWrapper<T>(endpoint, null, {
+  public async delete<T = undefined>(
+    endpoint: string,
+    options: RequestOptions,
+    body: RequestBody | null = null,
+  ): Promise<Response<T>> {
+    const defaultHeaders: { Accept: string; 'Content-Type'?: string } = {
+      Accept: 'application/json',
+    };
+
+    // Only add Content-Type header when body is provided
+    if (body !== null) {
+      defaultHeaders['Content-Type'] = 'application/json';
+    }
+
+    return this.fetchWrapper<T>(endpoint, body, {
       ...options,
       method: 'DELETE',
-      defaultHeaders: {
-        Accept: 'application/json',
-      },
+      defaultHeaders,
     });
   }
 

package/test/resources/logger.test.ts

@@ -291,4 +291,73 @@ describe('Logger', () => {
       });
     }
   });
+
+  it('only logs date for metadata of successful requests in development', testContext => {
+    const originalEnv = process.env.NODE_ENV;
+
+    try {
+      process.env.NODE_ENV = 'development';
+
+      const infoSpy = testContext.mock.method(global.console, 'info', () => {});
+      const metadata = {
+        correlation_id: '123456789',
+        http: { method: 'GET', status_code: 200 },
+        user_id: 'user123',
+        request_id: 'req456',
+      };
+
+      const logger = new Logger(metadata);
+
+      logger.info('Test message without error');
+      assert.strictEqual(infoSpy.mock.calls.length, 1);
+
+      const loggedOutput = infoSpy.mock.calls[0]?.arguments[0];
+      assert.ok(loggedOutput.includes('Test message without error'));
+
+      // Should only contain date in metadata JSON
+      const metadataMatch = loggedOutput.match(/({.*})/);
+      assert.ok(metadataMatch);
+      const parsedMetadata = JSON.parse(metadataMatch[1]);
+      assert.ok(parsedMetadata.date);
+      assert.strictEqual(Object.keys(parsedMetadata).length, 1); // What matters: Only the date
+    } finally {
+      process.env.NODE_ENV = originalEnv;
+    }
+  });
+
+  it('logs date & error stack for metadata of failed requests in development', testContext => {
+    const originalEnv = process.env.NODE_ENV;
+
+    try {
+      process.env.NODE_ENV = 'development';
+
+      const metadata = {
+        correlation_id: '123456789',
+        http: { method: 'GET', status_code: 200 },
+        user_id: 'user123',
+        request_id: 'req456',
+      };
+
+      const logger = new Logger(metadata);
+
+      // Test with error metadata
+      const errorSpy = testContext.mock.method(global.console, 'error', () => {});
+      logger.error('Test message with error', { error: { code: 500, message: 'Internal Server Error' } });
+      assert.strictEqual(errorSpy.mock.calls.length, 1);
+
+      const errorLoggedOutput = errorSpy.mock.calls[0]?.arguments[0];
+      assert.ok(errorLoggedOutput.includes('Test message with error'));
+
+      // Should contain both date and error in metadata JSON
+      const errorMetadataMatch = errorLoggedOutput.match(/({.*})/s);
+      assert.ok(errorMetadataMatch);
+      const parsedErrorMetadata = JSON.parse(errorMetadataMatch[1]);
+      assert.ok(parsedErrorMetadata.date);
+      assert.ok(parsedErrorMetadata.error);
+      assert.deepEqual(parsedErrorMetadata.error, { code: 500, message: 'Internal Server Error' });
+      assert.strictEqual(Object.keys(parsedErrorMetadata).length, 2); // What matters: Date and error only
+    } finally {
+      process.env.NODE_ENV = originalEnv;
+    }
+  });
 });

package/test/resources/provider.test.ts

@@ -486,6 +486,45 @@ describe('Provider', () => {
     assert.deepEqual(actualResponse, { status: 204, headers: response.headers, body: undefined });
   });
 
+  it('deleteWithBody', async context => {
+    const response = new Response('{"success": true}', {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    });
+
+    const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+
+    const requestBody = { webhookIds: [1, 2, 3] };
+    const actualResponse = await provider.delete(
+      '/webhook',
+      {
+        credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+        logger: logger,
+        signal: new AbortController().signal,
+        additionnalheaders: { 'X-Additional-Header': 'value1' },
+      },
+      requestBody,
+    );
+
+    assert.equal(fetchMock.mock.calls.length, 1);
+    assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+      'www.myApi.com/webhook',
+      {
+        method: 'DELETE',
+        body: JSON.stringify(requestBody),
+        signal: new AbortController().signal,
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+          'X-Custom-Provider-Header': 'value',
+          'X-Provider-Credential-Header': 'apikey#1111',
+          'X-Additional-Header': 'value1',
+        },
+      },
+    ]);
+    assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { success: true } });
+  });
+
   it('uses rate limiter if provided', async context => {
     const mockRateLimiter = context.mock.fn((_context, request) => Promise.resolve(request()));