@unito/integration-sdk 5.0.0 → 5.1.1

package/test/middlewares/finish.test.ts

@@ -2,6 +2,7 @@ import express from 'express';
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 import onFinish from '../../src/middlewares/finish.js';
+import { RequestMetrics } from '../../src/resources/requestMetrics.js';
 
 describe('finish middleware', () => {
   it('logs info', () => {
@@ -10,11 +11,11 @@ describe('finish middleware', () => {
 
     const request = { originalUrl: '/' } as express.Request;
     const response = {
-      on: (_event, func: () => void) => {
+      on: (_event: string, func: () => void) => {
         eventHandler = func;
       },
       locals: {
-        requestStartTime: 0n,
+        requestMetrics: RequestMetrics.startRequest(),
         logger: {
           info: (_message: string) => {
             expected = 'works!';
@@ -22,7 +23,7 @@ describe('finish middleware', () => {
         },
       },
       statusCode: 200,
-    } as express.Response;
+    } as unknown as express.Response;
 
     onFinish(request, response, () => {});
     eventHandler();
@@ -36,11 +37,11 @@ describe('finish middleware', () => {
 
     const request = { originalUrl: '/' } as express.Request;
     const response = {
-      on: (_event, func: () => void) => {
+      on: (_event: string, func: () => void) => {
         eventHandler = func;
       },
       locals: {
-        requestStartTime: 0n,
+        requestMetrics: RequestMetrics.startRequest(),
         logger: {
           error: (_message: string) => {
             expected = 'works!';
@@ -48,7 +49,7 @@ describe('finish middleware', () => {
         },
       },
       statusCode: 500,
-    } as express.Response;
+    } as unknown as express.Response;
 
     onFinish(request, response, () => {});
     eventHandler();
@@ -62,11 +63,11 @@ describe('finish middleware', () => {
 
     const request = { originalUrl: '/health' } as express.Request;
     const response = {
-      on: (_event, func: () => void) => {
+      on: (_event: string, func: () => void) => {
         eventHandler = func;
       },
       locals: {
-        requestStartTime: 0n,
+        requestMetrics: RequestMetrics.startRequest(),
         logger: {
           info: (_message: string) => {
             expected = 'ohoh!';
@@ -74,7 +75,7 @@ describe('finish middleware', () => {
         },
       },
       statusCode: 200,
-    } as express.Response;
+    } as unknown as express.Response;
 
     onFinish(request, response, () => {});
     eventHandler();
@@ -88,11 +89,11 @@ describe('finish middleware', () => {
 
     const request = { originalUrl: '/health' } as express.Request;
     const response = {
-      on: (_event, func: () => void) => {
+      on: (_event: string, func: () => void) => {
         eventHandler = func;
       },
       locals: {
-        requestStartTime: 0n,
+        requestMetrics: RequestMetrics.startRequest(),
         logger: {
           error: (_message: string) => {
             expected = 'works!';
@@ -100,7 +101,7 @@ describe('finish middleware', () => {
         },
       },
       statusCode: 500,
-    } as express.Response;
+    } as unknown as express.Response;
 
     onFinish(request, response, () => {});
     eventHandler();

package/test/middlewares/start.test.ts

@@ -2,13 +2,24 @@ import express from 'express';
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 import start from '../../src/middlewares/start.js';
+import { RequestMetrics } from '../../src/resources/requestMetrics.js';
 
 describe('start middleware', () => {
-  it('adds request start time to locals', () => {
+  it('initializes request metrics on locals', () => {
     const request = {} as express.Request;
     const response = { locals: {} } as express.Response;
+    start(request, response, () => {});
+    assert.ok(response.locals.requestMetrics instanceof RequestMetrics);
+  });
 
+  it('records request start time in metrics', () => {
+    const request = {} as express.Request;
+    const response = { locals: {} } as express.Response;
+    const before = process.hrtime.bigint();
     start(request, response, () => {});
-    assert.ok(response.locals.requestStartTime);
+    const result = response.locals.requestMetrics.endRequest();
+    const after = process.hrtime.bigint();
+    assert.ok(result.durationNs >= 0n);
+    assert.ok(result.durationNs <= after - before);
   });
 });

package/test/resources/provider.test.ts

@@ -8,6 +8,7 @@ import https from 'https';
 import { Provider } from '../../src/resources/provider.js';
 import * as HttpErrors from '../../src/httpErrors.js';
 import Logger from '../../src/resources/logger.js';
+import { RequestMetrics } from '../../src/resources/requestMetrics.js';
 
 // There is currently an issue with node 20.12 and fetch mocking. A quick fix is to first call fetch so it's getter
 // get properly instantiated, which allow it to be mocked properly.
@@ -1586,4 +1587,129 @@ describe('Provider', () => {
       }
     });
   });
+
+  describe('request metrics', () => {
+    it('records api call duration in requestMetrics via fetchWrapper', async context => {
+      const metrics = RequestMetrics.startRequest();
+      const response = new Response('{"data": "value"}', {
+        status: 200,
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+      });
+
+      context.mock.method(global, 'fetch', () => Promise.resolve(response));
+
+      await provider.get('/endpoint', {
+        credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+        logger,
+        requestMetrics: metrics,
+      });
+
+      const result = metrics.endRequest();
+      assert.equal(result.apiCallCount, 1);
+      assert.ok(result.totalApiDurationNs >= 0, 'Duration should be recorded');
+    });
+
+    it('records multiple api calls in the same requestMetrics', async context => {
+      const metrics = RequestMetrics.startRequest();
+
+      context.mock.method(global, 'fetch', () =>
+        Promise.resolve(
+          new Response('{"data": "value"}', {
+            status: 200,
+            headers: new Headers({ 'Content-Type': 'application/json' }),
+          }),
+        ),
+      );
+
+      await provider.get('/endpoint1', {
+        credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+        logger,
+        requestMetrics: metrics,
+      });
+
+      await provider.post(
+        '/endpoint2',
+        { key: 'value' },
+        {
+          credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+          logger,
+          requestMetrics: metrics,
+        },
+      );
+
+      const result = metrics.endRequest();
+      assert.equal(result.apiCallCount, 2);
+      assert.ok(result.totalApiDurationNs >= 0);
+    });
+
+    it('works without requestMetrics (backward compatible)', async context => {
+      const response = new Response('{"data": "value"}', {
+        status: 200,
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+      });
+
+      context.mock.method(global, 'fetch', () => Promise.resolve(response));
+
+      // No requestMetrics passed — should not throw
+      const result = await provider.get('/endpoint', {
+        credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+        logger,
+      });
+
+      assert.equal(result.status, 200);
+    });
+
+    it('records api call duration from postForm', async () => {
+      const metrics = RequestMetrics.startRequest();
+      const httpsProvider = new Provider({
+        prepareRequest: () => ({
+          url: 'https://www.myApi.com',
+          headers: {},
+        }),
+      });
+
+      const scope = nock('https://www.myApi.com').post('/upload').reply(201, { success: true });
+
+      const FormData = (await import('form-data')).default;
+      const form = new FormData();
+      form.append('file', Buffer.from('test data'), 'test.txt');
+
+      await httpsProvider.postForm('/upload', form, {
+        credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+        logger,
+        requestMetrics: metrics,
+      });
+
+      const postFormResult = metrics.endRequest();
+      assert.equal(postFormResult.apiCallCount, 1);
+      assert.ok(postFormResult.totalApiDurationNs > 0);
+      scope.isDone();
+    });
+
+    it('records api call duration from postStream', async () => {
+      const metrics = RequestMetrics.startRequest();
+      const testData = 'binary stream data';
+      const httpsProvider = new Provider({
+        prepareRequest: () => ({
+          url: 'https://www.myApi.com',
+          headers: {},
+        }),
+      });
+
+      const scope = nock('https://www.myApi.com').post('/upload', testData).reply(201, { success: true });
+
+      const stream = Readable.from(Buffer.from(testData));
+
+      await httpsProvider.postStream('/upload', stream, {
+        credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+        logger,
+        requestMetrics: metrics,
+      });
+
+      const postStreamResult = metrics.endRequest();
+      assert.equal(postStreamResult.apiCallCount, 1);
+      assert.ok(postStreamResult.totalApiDurationNs > 0);
+      scope.isDone();
+    });
+  });
 });

package/test/resources/requestMetrics.test.ts

@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { RequestMetrics } from '../../src/resources/requestMetrics.js';
+
+describe('RequestMetrics', () => {
+  describe('initial state', () => {
+    it('starts with zero api call count', () => {
+      const metrics = RequestMetrics.startRequest();
+      const result = metrics.endRequest();
+      assert.equal(result.apiCallCount, 0);
+    });
+
+    it('starts with zero total api duration', () => {
+      const metrics = RequestMetrics.startRequest();
+      const result = metrics.endRequest();
+      assert.equal(result.totalApiDurationNs, 0);
+    });
+  });
+
+  describe('endRequest', () => {
+    it('returns elapsed duration since construction', () => {
+      const before = process.hrtime.bigint();
+      const metrics = RequestMetrics.startRequest();
+      const result = metrics.endRequest();
+      const after = process.hrtime.bigint();
+      assert.ok(result.durationNs >= 0n);
+      assert.ok(result.durationNs <= after - before);
+    });
+  });
+
+  describe('recordExternalApiCall', () => {
+    it('increments api call count', () => {
+      const metrics = RequestMetrics.startRequest();
+      const start1 = process.hrtime.bigint();
+      metrics.recordExternalApiCall(start1);
+      const start2 = process.hrtime.bigint();
+      metrics.recordExternalApiCall(start2);
+      const result = metrics.endRequest();
+      assert.equal(result.apiCallCount, 2);
+    });
+
+    it('accumulates api duration', () => {
+      const metrics = RequestMetrics.startRequest();
+      const start = process.hrtime.bigint();
+      metrics.recordExternalApiCall(start);
+      const result = metrics.endRequest();
+      assert.ok(result.totalApiDurationNs >= 0);
+    });
+  });
+});