@app-connect/core 1.7.35 → 1.7.36

package/test/lib/errorHandler.test.js

@@ -0,0 +1,246 @@
+jest.mock('../../lib/logger', () => ({
+  error: jest.fn(),
+}));
+
+const logger = require('../../lib/logger');
+const {
+  asyncHandler,
+  errorMiddleware,
+  getOperationErrorMessage,
+  handleApiError,
+  handleDatabaseError,
+} = require('../../lib/errorHandler');
+
+describe('errorHandler', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('handleApiError', () => {
+    test('maps rate limit responses to the platform rate limit message', () => {
+      const error = new Error('too many requests');
+      error.response = {
+        status: 429,
+        data: { message: 'rate limited' },
+      };
+
+      const result = handleApiError(error, 'Clio', 'createCallLog', { accountId: 'account-1' });
+
+      expect(logger.error).toHaveBeenCalledWith('createCallLog failed for platform Clio', expect.objectContaining({
+        platform: 'Clio',
+        operation: 'createCallLog',
+        statusCode: 429,
+        accountId: 'account-1',
+      }));
+      expect(result).toMatchObject({
+        successful: false,
+        extraDataTracking: { statusCode: 429 },
+      });
+      expect(result.returnMessage.message).toBe('Rate limit exceeded');
+      expect(result.returnMessage.details[0].items[0].text).toContain('Clio');
+    });
+
+    test('maps 400-409 responses to authorization messages', () => {
+      const error = new Error('unauthorized');
+      error.response = {
+        status: 401,
+        data: { message: 'unauthorized' },
+      };
+
+      const result = handleApiError(error, 'Bullhorn', 'findContact');
+
+      expect(result.successful).toBe(false);
+      expect(result.extraDataTracking).toEqual({ statusCode: 401 });
+      expect(result.returnMessage.message).toBe('Authorization error');
+      expect(result.returnMessage.details[0].items[0].text).toContain('Bullhorn');
+    });
+
+    test('maps non-auth provider errors to operation-specific messages', () => {
+      const error = new Error('provider unavailable');
+      error.response = {
+        status: 500,
+        data: { message: 'unavailable' },
+      };
+
+      const result = handleApiError(error, 'Salesforce', 'updateCallLog');
+
+      expect(result).toEqual({
+        successful: false,
+        returnMessage: {
+          message: 'Error updating call log',
+          messageType: 'warning',
+          details: [
+            {
+              title: 'Details',
+              items: [
+                {
+                  id: 1,
+                  type: 'text',
+                  text: 'Please check if the log entity still exists on Salesforce and your account has permission to EDIT logs.',
+                },
+              ],
+            },
+          ],
+          ttl: 5000,
+        },
+        extraDataTracking: {
+          statusCode: 500,
+        },
+      });
+    });
+
+    test('uses unknown status when the error has no response status', () => {
+      const result = handleApiError(new Error('network down'), 'Pipedrive', 'createContact');
+
+      expect(result.extraDataTracking).toEqual({ statusCode: 'unknown' });
+      expect(result.returnMessage.message).toBe('Error creating contact');
+    });
+  });
+
+  describe('getOperationErrorMessage', () => {
+    test('returns configured appointment messages with platform interpolation', () => {
+      const result = getOperationErrorMessage('updateAppointment', 'Google');
+
+      expect(result.message).toBe('Error updating appointment');
+      expect(result.details[0].items[0].text).toContain('exists on Google');
+      expect(result.details[0].items[0].id).toBe(1);
+    });
+
+    test('returns a generic message for unknown operations', () => {
+      const result = getOperationErrorMessage('syncCustomObject', 'CRM');
+
+      expect(result).toEqual({
+        message: 'Error performing syncCustomObject',
+        messageType: 'warning',
+        details: [
+          {
+            title: 'Details',
+            items: [
+              {
+                id: 1,
+                type: 'text',
+                text: 'Please check if your account has the necessary permissions.',
+              },
+            ],
+          },
+        ],
+        ttl: 5000,
+      });
+    });
+  });
+
+  describe('handleDatabaseError', () => {
+    test('logs context and returns the database warning response', () => {
+      const error = new Error('connection lost');
+
+      const result = handleDatabaseError(error, 'saveUser', { userId: 'user-1' });
+
+      expect(logger.error).toHaveBeenCalledWith('Database operation failed: saveUser', expect.objectContaining({
+        operation: 'saveUser',
+        errorMessage: 'connection lost',
+        userId: 'user-1',
+      }));
+      expect(result).toEqual({
+        successful: false,
+        returnMessage: {
+          message: 'Database operation failed',
+          messageType: 'warning',
+          ttl: 5000,
+        },
+      });
+    });
+  });
+
+  describe('asyncHandler', () => {
+    test('passes through successful async handlers', async () => {
+      const req = {};
+      const res = {};
+      const next = jest.fn();
+      const handler = jest.fn().mockResolvedValue('done');
+
+      asyncHandler(handler)(req, res, next);
+      await Promise.resolve();
+
+      expect(handler).toHaveBeenCalledWith(req, res, next);
+      expect(next).not.toHaveBeenCalled();
+    });
+
+    test('forwards rejected async handlers to next', async () => {
+      const req = {};
+      const res = {};
+      const next = jest.fn();
+      const error = new Error('failed');
+
+      asyncHandler(jest.fn().mockRejectedValue(error))(req, res, next);
+      await Promise.resolve();
+
+      expect(next).toHaveBeenCalledWith(error);
+    });
+  });
+
+  describe('errorMiddleware', () => {
+    const originalNodeEnv = process.env.NODE_ENV;
+
+    afterEach(() => {
+      process.env.NODE_ENV = originalNodeEnv;
+    });
+
+    test('responds with development error details and request status code', () => {
+      process.env.NODE_ENV = 'test';
+      const err = new Error('visible error');
+      err.statusCode = 418;
+      const req = {
+        platform: 'Clio',
+        method: 'POST',
+        path: '/test',
+        route: { path: '/test' },
+        correlationId: 'correlation-1',
+      };
+      const res = {
+        status: jest.fn().mockReturnThis(),
+        json: jest.fn(),
+      };
+
+      errorMiddleware(err, req, res, jest.fn());
+
+      expect(logger.error).toHaveBeenCalledWith('Request failed', expect.objectContaining({
+        platform: 'Clio',
+        operation: '/test',
+        method: 'POST',
+        path: '/test',
+        statusCode: 418,
+        correlationId: 'correlation-1',
+      }));
+      expect(res.status).toHaveBeenCalledWith(418);
+      expect(res.json).toHaveBeenCalledWith({
+        successful: false,
+        returnMessage: {
+          message: 'visible error',
+          messageType: 'error',
+          ttl: 5000,
+        },
+      });
+    });
+
+    test('hides internal error details in production', () => {
+      process.env.NODE_ENV = 'production';
+      const res = {
+        status: jest.fn().mockReturnThis(),
+        json: jest.fn(),
+      };
+
+      errorMiddleware(new Error('secret detail'), { query: { platform: 'CRM' } }, res, jest.fn());
+
+      expect(res.status).toHaveBeenCalledWith(500);
+      expect(res.json).toHaveBeenCalledWith({
+        successful: false,
+        returnMessage: {
+          message: 'An internal error occurred',
+          messageType: 'error',
+          ttl: 5000,
+        },
+      });
+    });
+  });
+});
+

package/test/lib/generalErrorMessage.test.js

@@ -0,0 +1,82 @@
+const {
+  authorizationErrorMessage,
+  rateLimitErrorMessage,
+} = require('../../lib/generalErrorMessage');
+
+describe('generalErrorMessage', () => {
+  describe('rateLimitErrorMessage', () => {
+    test('builds the standard rate limit warning message', () => {
+      const result = rateLimitErrorMessage({ platform: 'Clio' });
+
+      expect(result).toEqual({
+        message: 'Rate limit exceeded',
+        messageType: 'warning',
+        details: [
+          {
+            title: 'Details',
+            items: [
+              {
+                id: '1',
+                type: 'text',
+                text: 'You have exceeded the maximum number of requests allowed by Clio. Please try again in the next minute. If the problem persists please contact support.',
+              },
+            ],
+          },
+        ],
+        ttl: 5000,
+      });
+    });
+
+    test('keeps current interpolation behavior for empty platform input', () => {
+      const result = rateLimitErrorMessage({ platform: '' });
+
+      expect(result.details[0].items[0].text).toContain('allowed by .');
+      expect(result.ttl).toBe(5000);
+    });
+
+    test('keeps current interpolation behavior for missing platform input', () => {
+      const result = rateLimitErrorMessage({});
+
+      expect(result.details[0].items[0].text).toContain('allowed by undefined.');
+    });
+  });
+
+  describe('authorizationErrorMessage', () => {
+    test('builds the standard authorization warning message', () => {
+      const result = authorizationErrorMessage({ platform: 'Bullhorn' });
+
+      expect(result).toEqual({
+        message: 'Authorization error',
+        messageType: 'warning',
+        details: [
+          {
+            title: 'Details',
+            items: [
+              {
+                id: '1',
+                type: 'text',
+                text: "It seems like there's something wrong with your authorization of Bullhorn. Please Logout and then Connect your Bullhorn account within this extension.",
+              },
+            ],
+          },
+        ],
+        ttl: 5000,
+      });
+    });
+
+    test('keeps current interpolation behavior for empty platform input', () => {
+      const result = authorizationErrorMessage({ platform: '' });
+
+      expect(result.details[0].items[0].text).toContain('authorization of .');
+      expect(result.details[0].items[0].text).toContain('Connect your  account');
+    });
+
+    test('keeps current interpolation behavior for missing platform input', () => {
+      const result = authorizationErrorMessage({});
+
+      expect(result.details[0].items[0].text).toContain('authorization of undefined.');
+      expect(result.details[0].items[0].text).toContain('Connect your undefined account');
+    });
+  });
+});
+

package/test/lib/s3ErrorLogReport.test.js

@@ -0,0 +1,187 @@
+const mockS3Send = jest.fn();
+const mockGetSignedUrl = jest.fn();
+const mockShortIdGenerate = jest.fn();
+
+jest.mock('@aws-sdk/client-s3', () => {
+  class HeadBucketCommand {
+    constructor(input) {
+      this.input = input;
+      this.commandName = 'HeadBucketCommand';
+    }
+  }
+
+  class CreateBucketCommand {
+    constructor(input) {
+      this.input = input;
+      this.commandName = 'CreateBucketCommand';
+    }
+  }
+
+  class PutObjectCommand {
+    constructor(input) {
+      this.input = input;
+      this.commandName = 'PutObjectCommand';
+    }
+  }
+
+  class GetObjectCommand {
+    constructor(input) {
+      this.input = input;
+      this.commandName = 'GetObjectCommand';
+    }
+  }
+
+  return {
+    S3Client: jest.fn(() => ({
+      send: mockS3Send,
+    })),
+    HeadBucketCommand,
+    CreateBucketCommand,
+    PutObjectCommand,
+    GetObjectCommand,
+  };
+});
+
+jest.mock('@aws-sdk/s3-request-presigner', () => ({
+  getSignedUrl: mockGetSignedUrl,
+}));
+
+jest.mock('shortid', () => ({
+  generate: mockShortIdGenerate,
+}));
+
+const { getSignedUrl } = require('@aws-sdk/s3-request-presigner');
+const {
+  CreateBucketCommand,
+  HeadBucketCommand,
+  PutObjectCommand,
+} = require('@aws-sdk/client-s3');
+const {
+  ensureBucketExists,
+  getUploadUrl,
+} = require('../../lib/s3ErrorLogReport');
+
+describe('s3ErrorLogReport', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockShortIdGenerate.mockReturnValue('report-123');
+    mockGetSignedUrl.mockResolvedValue('https://signed-upload.example.com/report');
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('ensureBucketExists', () => {
+    test('checks bucket existence and does not create when the bucket exists', async () => {
+      mockS3Send.mockResolvedValueOnce({});
+
+      await ensureBucketExists();
+
+      expect(mockS3Send).toHaveBeenCalledTimes(1);
+      expect(mockS3Send.mock.calls[0][0]).toBeInstanceOf(HeadBucketCommand);
+      expect(mockS3Send.mock.calls[0][0].input).toEqual({
+        Bucket: 'error-reports-bucket',
+      });
+    });
+
+    test('creates the bucket when the local bucket is missing by name', async () => {
+      const notFound = new Error('missing');
+      notFound.name = 'NotFound';
+      mockS3Send
+        .mockRejectedValueOnce(notFound)
+        .mockResolvedValueOnce({});
+
+      await ensureBucketExists();
+
+      expect(mockS3Send).toHaveBeenCalledTimes(2);
+      expect(mockS3Send.mock.calls[0][0]).toBeInstanceOf(HeadBucketCommand);
+      expect(mockS3Send.mock.calls[1][0]).toBeInstanceOf(CreateBucketCommand);
+      expect(mockS3Send.mock.calls[1][0].input).toEqual({
+        Bucket: 'error-reports-bucket',
+      });
+    });
+
+    test('creates the bucket when the local bucket is missing by 404 metadata', async () => {
+      const notFound = new Error('missing');
+      notFound.$metadata = { httpStatusCode: 404 };
+      mockS3Send
+        .mockRejectedValueOnce(notFound)
+        .mockResolvedValueOnce({});
+
+      await ensureBucketExists();
+
+      expect(mockS3Send).toHaveBeenCalledTimes(2);
+      expect(mockS3Send.mock.calls[1][0]).toBeInstanceOf(CreateBucketCommand);
+    });
+
+    test('keeps current behavior of swallowing non-404 bucket check errors', async () => {
+      const accessDenied = new Error('access denied');
+      accessDenied.name = 'AccessDenied';
+      accessDenied.$metadata = { httpStatusCode: 403 };
+      mockS3Send.mockRejectedValueOnce(accessDenied);
+
+      await expect(ensureBucketExists()).resolves.toBeUndefined();
+
+      expect(mockS3Send).toHaveBeenCalledTimes(1);
+      expect(mockS3Send.mock.calls[0][0]).toBeInstanceOf(HeadBucketCommand);
+    });
+  });
+
+  describe('getUploadUrl', () => {
+    test('checks the local bucket, composes metadata and key, then requests a presigned URL', async () => {
+      jest.useFakeTimers().setSystemTime(new Date('2026-07-02T09:20:00.000Z'));
+      mockS3Send.mockResolvedValueOnce({});
+
+      const uploadUrl = await getUploadUrl({
+        userId: 'user-1',
+        platform: 'clio',
+        metadata: {
+          source: 'test-suite',
+          severity: 'warning',
+        },
+      });
+
+      expect(uploadUrl).toBe('https://signed-upload.example.com/report');
+      expect(mockS3Send).toHaveBeenCalledTimes(1);
+      expect(mockS3Send.mock.calls[0][0]).toBeInstanceOf(HeadBucketCommand);
+      expect(getSignedUrl).toHaveBeenCalledTimes(1);
+      expect(getSignedUrl.mock.calls[0][0]).toEqual(expect.objectContaining({
+        send: mockS3Send,
+      }));
+      expect(getSignedUrl.mock.calls[0][1]).toBeInstanceOf(PutObjectCommand);
+      expect(getSignedUrl.mock.calls[0][1].input).toEqual({
+        Bucket: 'error-reports-bucket',
+        Key: 'error-reports/2026-07-02/user-1-report-123.json',
+        ContentType: 'application/json',
+        Metadata: {
+          'user-id': 'user-1',
+          platform: 'clio',
+          source: 'test-suite',
+          severity: 'warning',
+        },
+      });
+      expect(getSignedUrl.mock.calls[0][2]).toEqual({
+        expiresIn: 300,
+      });
+    });
+
+    test('uses default metadata when no metadata object is provided', async () => {
+      jest.useFakeTimers().setSystemTime(new Date('2026-07-03T01:02:03.000Z'));
+      mockS3Send.mockResolvedValueOnce({});
+
+      await getUploadUrl({
+        userId: 'user-2',
+        platform: 'bullhorn',
+      });
+
+      expect(getSignedUrl.mock.calls[0][1].input).toMatchObject({
+        Key: 'error-reports/2026-07-03/user-2-report-123.json',
+        Metadata: {
+          'user-id': 'user-2',
+          platform: 'bullhorn',
+        },
+      });
+    });
+  });
+});