@app-connect/core 1.7.36 → 1.7.38

package/test/lib/debugTracer.test.js

@@ -1,328 +0,0 @@
-const { DebugTracer } = require('../../lib/debugTracer');
-
-describe('DebugTracer', () => {
-  let tracer;
-
-  beforeEach(() => {
-    tracer = new DebugTracer();
-  });
-
-  describe('constructor', () => {
-    test('should initialize with empty traces array', () => {
-      expect(tracer.traces).toEqual([]);
-    });
-
-    test('should set start time', () => {
-      expect(tracer.startTime).toBeDefined();
-      expect(typeof tracer.startTime).toBe('number');
-    });
-
-    test('should generate unique request ID', () => {
-      const tracer2 = new DebugTracer();
-      expect(tracer.requestId).toBeDefined();
-      expect(tracer.requestId).toMatch(/^req_\d+_[a-z0-9]+$/);
-      expect(tracer.requestId).not.toBe(tracer2.requestId);
-    });
-
-    test('should accept headers parameter', () => {
-      const headers = { 'x-request-id': 'custom-id' };
-      const tracerWithHeaders = new DebugTracer(headers);
-      expect(tracerWithHeaders.requestId).toBeDefined();
-    });
-  });
-
-  describe('trace', () => {
-    test('should add trace entry with method name and data', () => {
-      tracer.trace('testMethod', { name: 'value', count: 42 });
-
-      expect(tracer.traces).toHaveLength(1);
-      expect(tracer.traces[0].methodName).toBe('testMethod');
-      expect(tracer.traces[0].data).toEqual({ name: 'value', count: 42 });
-    });
-
-    test('should include timestamp and elapsed time', () => {
-      tracer.trace('testMethod', {});
-
-      expect(tracer.traces[0].timestamp).toBeDefined();
-      expect(tracer.traces[0].elapsed).toBeGreaterThanOrEqual(0);
-    });
-
-    test('should default to info level', () => {
-      tracer.trace('testMethod', {});
-
-      expect(tracer.traces[0].level).toBe('info');
-    });
-
-    test('should allow custom log level', () => {
-      tracer.trace('testMethod', {}, { level: 'warn' });
-
-      expect(tracer.traces[0].level).toBe('warn');
-    });
-
-    test('should include stack trace by default', () => {
-      tracer.trace('testMethod', {});
-
-      expect(tracer.traces[0].stackTrace).toBeDefined();
-      expect(Array.isArray(tracer.traces[0].stackTrace)).toBe(true);
-    });
-
-    test('should exclude stack trace when disabled', () => {
-      tracer.trace('testMethod', {}, { includeStack: false });
-
-      expect(tracer.traces[0].stackTrace).toBeUndefined();
-    });
-
-    test('should return this for chaining', () => {
-      const result = tracer.trace('method1', {});
-      expect(result).toBe(tracer);
-
-      tracer.trace('method2', {}).trace('method3', {});
-      expect(tracer.traces).toHaveLength(3);
-    });
-
-    test('should handle empty data object', () => {
-      tracer.trace('testMethod');
-
-      expect(tracer.traces[0].data).toEqual({});
-    });
-  });
-
-  describe('traceError', () => {
-    test('should add error trace with Error object', () => {
-      const error = new Error('Test error message');
-      tracer.traceError('failingMethod', error);
-
-      expect(tracer.traces).toHaveLength(1);
-      expect(tracer.traces[0].methodName).toBe('failingMethod');
-      expect(tracer.traces[0].level).toBe('error');
-      expect(tracer.traces[0].data.message).toBe('Test error message');
-      expect(tracer.traces[0].data.errorStack).toContain('Error: Test error message');
-    });
-
-    test('should handle string error', () => {
-      tracer.traceError('failingMethod', 'Something went wrong');
-
-      expect(tracer.traces[0].data.message).toBe('Something went wrong');
-      expect(tracer.traces[0].data.errorStack).toBeNull();
-    });
-
-    test('should include additional data', () => {
-      const error = new Error('Test error');
-      tracer.traceError('failingMethod', error, { userId: 'user-123', action: 'create' });
-
-      expect(tracer.traces[0].data.userId).toBe('user-123');
-      expect(tracer.traces[0].data.action).toBe('create');
-    });
-
-    test('should return this for chaining', () => {
-      const result = tracer.traceError('method', new Error('test'));
-      expect(result).toBe(tracer);
-    });
-  });
-
-  describe('_sanitizeData', () => {
-    test('should redact sensitive fields', () => {
-      tracer.trace('testMethod', {
-        accessToken: 'secret-token',
-        refreshToken: 'secret-refresh',
-        apiKey: 'api-key-123',
-        password: 'secret-password',
-        username: 'normal-field'
-      });
-
-      const data = tracer.traces[0].data;
-      expect(data.accessToken).toBe('[REDACTED]');
-      expect(data.refreshToken).toBe('[REDACTED]');
-      expect(data.apiKey).toBe('[REDACTED]');
-      expect(data.password).toBe('[REDACTED]');
-      expect(data.username).toBe('normal-field');
-    });
-
-    test('should sanitize nested objects', () => {
-      tracer.trace('testMethod', {
-        user: {
-          name: 'John',
-          userPassword: 'secret123',
-          userAccessToken: 'token123'
-        }
-      });
-
-      const data = tracer.traces[0].data;
-      expect(data.user.name).toBe('John');
-      expect(data.user.userPassword).toBe('[REDACTED]');
-      expect(data.user.userAccessToken).toBe('[REDACTED]');
-    });
-
-    test('should handle arrays', () => {
-      tracer.trace('testMethod', {
-        users: [
-          { name: 'User1', apiKey: 'key1' },
-          { name: 'User2', apiKey: 'key2' }
-        ]
-      });
-
-      const data = tracer.traces[0].data;
-      expect(data.users[0].name).toBe('User1');
-      expect(data.users[0].apiKey).toBe('[REDACTED]');
-      expect(data.users[1].apiKey).toBe('[REDACTED]');
-    });
-
-    test('should handle null and undefined data', () => {
-      tracer.trace('testMethod', null);
-      tracer.trace('testMethod2');
-
-      expect(tracer.traces[0].data).toBeNull();
-      // When undefined is passed, it defaults to {} from the default parameter
-      expect(tracer.traces[1].data).toEqual({});
-    });
-
-    test('should handle primitive data', () => {
-      tracer.trace('testMethod', 'string-value');
-      tracer.trace('testMethod2', 42);
-
-      expect(tracer.traces[0].data).toBe('string-value');
-      expect(tracer.traces[1].data).toBe(42);
-    });
-
-    test('should redact case-insensitive sensitive fields', () => {
-      tracer.trace('testMethod', {
-        AccessToken: 'secret1',
-        APIKEY: 'secret2',
-        clientSecret: 'secret3'
-      });
-
-      const data = tracer.traces[0].data;
-      expect(data.AccessToken).toBe('[REDACTED]');
-      expect(data.APIKEY).toBe('[REDACTED]');
-      expect(data.clientSecret).toBe('[REDACTED]');
-    });
-
-    test('should redact partial matches', () => {
-      tracer.trace('testMethod', {
-        userAuthToken: 'secret',
-        adminCredentials: 'secret',
-        myPrivateKey: 'secret'
-      });
-
-      const data = tracer.traces[0].data;
-      expect(data.userAuthToken).toBe('[REDACTED]');
-      expect(data.adminCredentials).toBe('[REDACTED]');
-      expect(data.myPrivateKey).toBe('[REDACTED]');
-    });
-  });
-
-  describe('getTraceData', () => {
-    test('should return complete trace data', () => {
-      tracer.trace('method1', { step: 1 });
-      tracer.trace('method2', { step: 2 });
-
-      const traceData = tracer.getTraceData();
-
-      expect(traceData.requestId).toBe(tracer.requestId);
-      expect(traceData.totalDuration).toMatch(/\d+ms$/);
-      expect(traceData.traceCount).toBe(2);
-      expect(traceData.traces).toHaveLength(2);
-    });
-
-    test('should return empty traces for new tracer', () => {
-      const traceData = tracer.getTraceData();
-
-      expect(traceData.traceCount).toBe(0);
-      expect(traceData.traces).toEqual([]);
-    });
-  });
-
-  describe('wrapResponse', () => {
-    test('should add debug trace to response', () => {
-      tracer.trace('processRequest', { action: 'test' });
-
-      const response = { success: true, data: { id: 123 } };
-      const wrappedResponse = tracer.wrapResponse(response);
-
-      expect(wrappedResponse.success).toBe(true);
-      expect(wrappedResponse.data).toEqual({ id: 123 });
-      expect(wrappedResponse._debug).toBeDefined();
-      expect(wrappedResponse._debug.requestId).toBe(tracer.requestId);
-    });
-
-    test('should preserve original response properties', () => {
-      const response = {
-        status: 200,
-        message: 'OK',
-        nested: { key: 'value' }
-      };
-
-      const wrapped = tracer.wrapResponse(response);
-
-      expect(wrapped.status).toBe(200);
-      expect(wrapped.message).toBe('OK');
-      expect(wrapped.nested.key).toBe('value');
-    });
-  });
-
-  describe('static fromRequest', () => {
-    test('should create tracer from Express request', () => {
-      const req = {
-        headers: {
-          'x-request-id': 'req-123',
-          'content-type': 'application/json'
-        }
-      };
-
-      const tracer = DebugTracer.fromRequest(req);
-
-      expect(tracer).toBeInstanceOf(DebugTracer);
-      expect(tracer.requestId).toBeDefined();
-    });
-
-    test('should handle request without headers', () => {
-      const req = {};
-
-      const tracer = DebugTracer.fromRequest(req);
-
-      expect(tracer).toBeInstanceOf(DebugTracer);
-    });
-  });
-
-  describe('_captureStackTrace', () => {
-    test('should return array of stack trace lines', () => {
-      tracer.trace('testMethod', {});
-
-      const stackTrace = tracer.traces[0].stackTrace;
-      expect(Array.isArray(stackTrace)).toBe(true);
-      stackTrace.forEach(line => {
-        expect(line).toMatch(/^at /);
-      });
-    });
-  });
-
-  describe('integration', () => {
-    test('should track multiple operations', () => {
-      tracer
-        .trace('startOperation', { userId: 'user-123' })
-        .trace('fetchData', { query: 'SELECT *' })
-        .trace('processData', { count: 100 })
-        .trace('saveResult', { success: true });
-
-      const traceData = tracer.getTraceData();
-      expect(traceData.traceCount).toBe(4);
-
-      // Verify elapsed times are increasing
-      for (let i = 1; i < tracer.traces.length; i++) {
-        expect(tracer.traces[i].elapsed).toBeGreaterThanOrEqual(tracer.traces[i-1].elapsed);
-      }
-    });
-
-    test('should handle error in the middle of operations', () => {
-      tracer
-        .trace('startOperation', { step: 1 })
-        .traceError('failedOperation', new Error('Database error'), { query: 'INSERT' })
-        .trace('cleanupOperation', { step: 3 });
-
-      expect(tracer.traces).toHaveLength(3);
-      expect(tracer.traces[1].level).toBe('error');
-      expect(tracer.traces[2].level).toBe('info');
-    });
-  });
-});
-

package/test/lib/encode.test.js

@@ -1,59 +0,0 @@
-const { decoded, encode } = require('../../lib/encode');
-
-describe('encode', () => {
-  const originalSecret = process.env.APP_SERVER_SECRET_KEY;
-
-  afterEach(() => {
-    if (originalSecret === undefined) {
-      delete process.env.APP_SERVER_SECRET_KEY;
-    } else {
-      process.env.APP_SERVER_SECRET_KEY = originalSecret;
-    }
-  });
-
-  test('encodes and decodes a string with a 32-character secret', () => {
-    process.env.APP_SERVER_SECRET_KEY = '12345678901234567890123456789012';
-
-    const encrypted = encode('sensitive token value');
-
-    expect(encrypted).toMatch(/^[0-9a-f]+$/);
-    expect(encrypted).not.toBe('sensitive token value');
-    expect(decoded(encrypted)).toBe('sensitive token value');
-  });
-
-  test('throws a deterministic error when secret is missing', () => {
-    delete process.env.APP_SERVER_SECRET_KEY;
-
-    expect(() => encode('data')).toThrow('APP_SERVER_SECRET_KEY is not defined');
-    expect(() => decoded('abcd')).toThrow('APP_SERVER_SECRET_KEY is not defined');
-  });
-
-  test('pads short secrets with spaces to 32 bytes', () => {
-    process.env.APP_SERVER_SECRET_KEY = 'short-secret';
-    const encryptedWithShortSecret = encode('payload');
-
-    process.env.APP_SERVER_SECRET_KEY = 'short-secret'.padEnd(32, ' ');
-    const encryptedWithPaddedSecret = encode('payload');
-
-    expect(encryptedWithShortSecret).toBe(encryptedWithPaddedSecret);
-    expect(decoded(encryptedWithShortSecret)).toBe('payload');
-  });
-
-  test('truncates long secrets to 32 bytes', () => {
-    process.env.APP_SERVER_SECRET_KEY = '12345678901234567890123456789012-first-suffix';
-    const encryptedWithLongSecret = encode('payload');
-
-    process.env.APP_SERVER_SECRET_KEY = '12345678901234567890123456789012-second-suffix';
-    const encryptedWithSamePrefix = encode('payload');
-
-    expect(encryptedWithLongSecret).toBe(encryptedWithSamePrefix);
-    expect(decoded(encryptedWithLongSecret)).toBe('payload');
-  });
-
-  test('throws when encrypted input is not valid hex ciphertext', () => {
-    process.env.APP_SERVER_SECRET_KEY = '12345678901234567890123456789012';
-
-    expect(() => decoded('not-valid-ciphertext')).toThrow();
-  });
-});
-

package/test/lib/errorHandler.test.js

@@ -1,246 +0,0 @@
-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,
-        },
-      });
-    });
-  });
-});
-