@app-connect/core 1.7.36 → 1.7.38

package/test/models/dynamo/connectorSchema.test.js

@@ -1,189 +0,0 @@
-// Mock dynamoose before requiring the module
-jest.mock('dynamoose', () => {
-  const mockModel = {
-    query: jest.fn().mockReturnThis(),
-    eq: jest.fn().mockReturnThis(),
-    using: jest.fn().mockReturnThis(),
-    exec: jest.fn()
-  };
-
-  return {
-    Schema: jest.fn().mockReturnValue({}),
-    model: jest.fn().mockReturnValue(mockModel)
-  };
-});
-
-describe('Connector Schema', () => {
-  const originalEnv = process.env.DEVELOPER_APP_SERVER_SECRET_KEY;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.resetModules();
-    process.env.DEVELOPER_APP_SERVER_SECRET_KEY = 'test-secret-key-12345678901234';
-  });
-
-  afterEach(() => {
-    if (originalEnv) {
-      process.env.DEVELOPER_APP_SERVER_SECRET_KEY = originalEnv;
-    } else {
-      delete process.env.DEVELOPER_APP_SERVER_SECRET_KEY;
-    }
-  });
-
-  describe('getProxyConfig', () => {
-    test('should return proxy config when connector found', async () => {
-      const mockProxyConfig = {
-        operations: {
-          createCallLog: { method: 'POST', url: '/api/logs' },
-          findContact: { method: 'GET', url: '/api/contacts' }
-        }
-      };
-
-      const mockConnector = {
-        proxyConfig: mockProxyConfig,
-        encodedSecretKey: null
-      };
-
-      // Import fresh module
-      const { Connector } = require('../../../models/dynamo/connectorSchema');
-
-      // Mock the query chain
-      Connector.query = jest.fn().mockReturnThis();
-      Connector.eq = jest.fn().mockReturnThis();
-      Connector.using = jest.fn().mockReturnThis();
-      Connector.exec = jest.fn().mockResolvedValue([mockConnector]);
-
-      const result = await Connector.getProxyConfig('proxy-123');
-
-      expect(Connector.query).toHaveBeenCalledWith('proxyId');
-      expect(Connector.eq).toHaveBeenCalledWith('proxy-123');
-      expect(Connector.using).toHaveBeenCalledWith('proxyIdIndex');
-      expect(result).toEqual(mockProxyConfig);
-    });
-
-    test('should return null when no connector found', async () => {
-      const { Connector } = require('../../../models/dynamo/connectorSchema');
-
-      Connector.query = jest.fn().mockReturnThis();
-      Connector.eq = jest.fn().mockReturnThis();
-      Connector.using = jest.fn().mockReturnThis();
-      Connector.exec = jest.fn().mockResolvedValue([]);
-
-      const result = await Connector.getProxyConfig('non-existent-proxy');
-
-      expect(result).toBeNull();
-    });
-
-    test('should handle proxy config without encoded secret key', async () => {
-      const mockProxyConfig = {
-        operations: {
-          findContact: { method: 'GET', url: '/api/contacts' }
-        }
-      };
-
-      const mockConnector = {
-        proxyConfig: mockProxyConfig,
-        encodedSecretKey: ''
-      };
-
-      const { Connector } = require('../../../models/dynamo/connectorSchema');
-
-      Connector.query = jest.fn().mockReturnThis();
-      Connector.eq = jest.fn().mockReturnThis();
-      Connector.using = jest.fn().mockReturnThis();
-      Connector.exec = jest.fn().mockResolvedValue([mockConnector]);
-
-      const result = await Connector.getProxyConfig('proxy-no-secret');
-
-      expect(result).toEqual(mockProxyConfig);
-      expect(result.secretKey).toBeUndefined();
-    });
-
-    test('should handle undefined encoded secret key', async () => {
-      const mockProxyConfig = {
-        operations: {
-          createCallLog: { method: 'POST', url: '/api/logs' }
-        }
-      };
-
-      const mockConnector = {
-        proxyConfig: mockProxyConfig,
-        encodedSecretKey: undefined
-      };
-
-      const { Connector } = require('../../../models/dynamo/connectorSchema');
-
-      Connector.query = jest.fn().mockReturnThis();
-      Connector.eq = jest.fn().mockReturnThis();
-      Connector.using = jest.fn().mockReturnThis();
-      Connector.exec = jest.fn().mockResolvedValue([mockConnector]);
-
-      const result = await Connector.getProxyConfig('proxy-undefined-secret');
-
-      expect(result).toEqual(mockProxyConfig);
-      expect(result.secretKey).toBeUndefined();
-    });
-  });
-
-  describe('CONNECTOR_STATUS constants', () => {
-    test('should have correct status values in schema enum', () => {
-      // The status values are defined in the schema
-      const expectedStatuses = ['private', 'under_review', 'approved', 'rejected'];
-      
-      // Import the module to verify it loads without error
-      const { Connector } = require('../../../models/dynamo/connectorSchema');
-      
-      // The module exports Connector which means schema was created successfully
-      expect(Connector).toBeDefined();
-      expect(typeof Connector.getProxyConfig).toBe('function');
-    });
-  });
-
-  describe('Module Structure', () => {
-    test('should export Connector model', () => {
-      const connectorModule = require('../../../models/dynamo/connectorSchema');
-      
-      expect(connectorModule.Connector).toBeDefined();
-    });
-
-    test('should have getProxyConfig static method', () => {
-      const { Connector } = require('../../../models/dynamo/connectorSchema');
-      
-      expect(typeof Connector.getProxyConfig).toBe('function');
-    });
-  });
-
-  describe('getDeveloperCipherKey behavior', () => {
-    // These tests verify the cipher key handling indirectly through the module
-    
-    test('should handle secret key of exactly 32 characters', async () => {
-      process.env.DEVELOPER_APP_SERVER_SECRET_KEY = '12345678901234567890123456789012'; // exactly 32 chars
-      
-      jest.resetModules();
-      
-      const { Connector } = require('../../../models/dynamo/connectorSchema');
-      
-      // If the key is exactly 32 chars, no padding/truncation needed
-      expect(Connector).toBeDefined();
-    });
-
-    test('should throw error when DEVELOPER_APP_SERVER_SECRET_KEY is not set and decode is called', async () => {
-      delete process.env.DEVELOPER_APP_SERVER_SECRET_KEY;
-      
-      jest.resetModules();
-      
-      const { Connector } = require('../../../models/dynamo/connectorSchema');
-      
-      Connector.query = jest.fn().mockReturnThis();
-      Connector.eq = jest.fn().mockReturnThis();
-      Connector.using = jest.fn().mockReturnThis();
-      Connector.exec = jest.fn().mockResolvedValue([{
-        proxyConfig: { test: true },
-        encodedSecretKey: 'some-encrypted-value'
-      }]);
-
-      // The decode function will be called which requires the secret key
-      await expect(Connector.getProxyConfig('test')).rejects.toThrow('DEVELOPER_APP_SERVER_SECRET_KEY is not defined');
-    });
-  });
-});

package/test/models/dynamo/lockSchema.test.js

@@ -1,37 +0,0 @@
-jest.mock('dynamoose', () => ({
-  Schema: jest.fn((definition, options) => ({
-    definition,
-    options,
-  })),
-  model: jest.fn((name, schema, options) => ({
-    modelName: name,
-    schema,
-    options,
-  })),
-}));
-
-const { Lock } = require('../../../models/dynamo/lockSchema');
-
-describe('lockSchema', () => {
-  test('defines userId as the hash key', () => {
-    expect(Lock.schema.definition.userId).toEqual({
-      type: String,
-      hashKey: true,
-    });
-  });
-
-  test('defines ttl as a number field', () => {
-    expect(Lock.schema.definition.ttl).toEqual({
-      type: Number,
-    });
-  });
-
-  test('creates the expected Dynamoose model and table options', () => {
-    expect(Lock.modelName).toBe('-token-refresh-lock');
-    expect(Lock.options).toEqual({
-      prefix: process.env.DYNAMODB_TABLE_PREFIX,
-      expires: 60,
-    });
-  });
-});
-

package/test/models/dynamo/noteCacheSchema.test.js

@@ -1,45 +0,0 @@
-jest.mock('dynamoose', () => ({
-  Schema: jest.fn((definition, options) => ({
-    definition,
-    options,
-  })),
-  model: jest.fn((name, schema, options) => ({
-    modelName: name,
-    schema,
-    options,
-  })),
-}));
-
-const { NoteCache } = require('../../../models/dynamo/noteCacheSchema');
-
-describe('noteCacheSchema', () => {
-  test('defines sessionId as the hash key', () => {
-    expect(NoteCache.schema.definition.sessionId).toEqual({
-      type: String,
-      hashKey: true,
-    });
-  });
-
-  test('requires the cached note value', () => {
-    expect(NoteCache.schema.definition.note).toEqual({
-      type: String,
-      required: true,
-    });
-  });
-
-  test('requires ttl as a number field', () => {
-    expect(NoteCache.schema.definition.ttl).toEqual({
-      type: Number,
-      required: true,
-    });
-  });
-
-  test('creates the expected Dynamoose model and table options', () => {
-    expect(NoteCache.modelName).toBe('-note-cache');
-    expect(NoteCache.options).toEqual({
-      prefix: process.env.DYNAMODB_TABLE_PREFIX,
-      expires: 60,
-    });
-  });
-});
-

package/test/models/llmSessionModel.test.js

@@ -1,91 +0,0 @@
-const { LlmSessionModel } = require('../../models/llmSessionModel');
-
-describe('LlmSessionModel', () => {
-  beforeAll(async () => {
-    await LlmSessionModel.sync({ force: true });
-  });
-
-  afterEach(async () => {
-    await LlmSessionModel.destroy({ where: {} });
-  });
-
-  test('defines the expected session fields', () => {
-    const attributes = LlmSessionModel.rawAttributes;
-
-    expect(attributes.id.primaryKey).toBe(true);
-    expect(attributes.jwtToken.type.key).toBe('STRING');
-    expect(attributes.expiry.type.key).toBe('DATE');
-  });
-
-  test('creates and reads a persisted LLM session', async () => {
-    await LlmSessionModel.create({
-      id: 'llm-session-1',
-      jwtToken: 'jwt-token-1',
-      expiry: new Date('2026-07-02T11:00:00.000Z'),
-    });
-
-    const record = await LlmSessionModel.findByPk('llm-session-1');
-
-    expect(record.id).toBe('llm-session-1');
-    expect(record.jwtToken).toBe('jwt-token-1');
-    expect(record.expiry.toISOString()).toBe('2026-07-02T11:00:00.000Z');
-  });
-
-  test('allows nullable token and expiry under the current schema', async () => {
-    await LlmSessionModel.create({
-      id: 'minimal-llm-session',
-    });
-
-    const record = await LlmSessionModel.findByPk('minimal-llm-session');
-
-    expect(record.jwtToken).toBeNull();
-    expect(record.expiry).toBeNull();
-  });
-
-  test('updates session token and expiry', async () => {
-    await LlmSessionModel.create({
-      id: 'llm-session-update',
-      jwtToken: 'old-token',
-      expiry: new Date('2026-07-02T11:00:00.000Z'),
-    });
-
-    await LlmSessionModel.update({
-      jwtToken: 'new-token',
-      expiry: new Date('2026-07-02T12:00:00.000Z'),
-    }, {
-      where: { id: 'llm-session-update' },
-    });
-
-    const record = await LlmSessionModel.findByPk('llm-session-update');
-    expect(record.jwtToken).toBe('new-token');
-    expect(record.expiry.toISOString()).toBe('2026-07-02T12:00:00.000Z');
-  });
-
-  test('deletes expired session records by expiry query', async () => {
-    await LlmSessionModel.bulkCreate([
-      {
-        id: 'expired-llm-session',
-        jwtToken: 'expired-token',
-        expiry: new Date('2026-07-02T10:59:59.000Z'),
-      },
-      {
-        id: 'active-llm-session',
-        jwtToken: 'active-token',
-        expiry: new Date('2026-07-02T11:00:01.000Z'),
-      },
-    ]);
-
-    const { Op } = require('sequelize');
-    await LlmSessionModel.destroy({
-      where: {
-        expiry: {
-          [Op.lt]: new Date('2026-07-02T11:00:00.000Z'),
-        },
-      },
-    });
-
-    await expect(LlmSessionModel.findByPk('expired-llm-session')).resolves.toBeNull();
-    await expect(LlmSessionModel.findByPk('active-llm-session')).resolves.not.toBeNull();
-  });
-});
-