@app-connect/core 1.7.34 → 1.7.36

package/test/mcp/tools/appointmentTools.test.js

@@ -0,0 +1,362 @@
+jest.mock('../../../lib/jwt');
+jest.mock('../../../connector/registry');
+jest.mock('../../../handlers/appointment');
+
+const jwt = require('../../../lib/jwt');
+const connectorRegistry = require('../../../connector/registry');
+const appointmentCore = require('../../../handlers/appointment');
+const listAppointments = require('../../../mcp/tools/listAppointments');
+const createAppointment = require('../../../mcp/tools/createAppointment');
+const updateAppointment = require('../../../mcp/tools/updateAppointment');
+const confirmAppointment = require('../../../mcp/tools/confirmAppointment');
+const cancelAppointment = require('../../../mcp/tools/cancelAppointment');
+
+describe('MCP appointment tools', () => {
+  const decodedToken = {
+    id: 'user-123',
+    platform: 'testCRM'
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jwt.decodeJwt.mockReturnValue(decodedToken);
+    connectorRegistry.getConnector.mockReturnValue({
+      listAppointments: jest.fn(),
+      createAppointment: jest.fn(),
+      updateAppointment: jest.fn(),
+      confirmAppointment: jest.fn(),
+      cancelAppointment: jest.fn()
+    });
+  });
+
+  test('defines appointment tool schemas and annotations', () => {
+    expect(listAppointments.definition.name).toBe('listAppointments');
+    expect(listAppointments.definition.annotations.readOnlyHint).toBe(true);
+    expect(createAppointment.definition.inputSchema.required).toEqual(['title', 'startTimeUtc', 'durationMinutes']);
+    expect(updateAppointment.definition.inputSchema.required).toEqual(['appointmentId']);
+    expect(confirmAppointment.definition.inputSchema.required).toEqual(['appointmentId']);
+    expect(cancelAppointment.definition.annotations.destructiveHint).toBe(true);
+  });
+
+  test('listAppointments resolves filters, custom ranges, success, and handler failure', async () => {
+    appointmentCore.listAppointments.mockResolvedValueOnce({
+      successful: true,
+      appointments: [{ id: 'appt-1' }],
+      returnMessage: { message: 'Listed' }
+    });
+
+    const upcomingResult = await listAppointments.execute({
+      jwtToken: 'jwt-token',
+      filter: 'upcoming',
+      mineOnly: true
+    });
+
+    expect(upcomingResult.success).toBe(true);
+    expect(upcomingResult.data.filter).toBe('upcoming');
+    expect(upcomingResult.data.totalCount).toBe(1);
+    expect(appointmentCore.listAppointments).toHaveBeenCalledWith({
+      platform: 'testCRM',
+      userId: 'user-123',
+      range: expect.objectContaining({
+        startDate: expect.any(String),
+        endDate: expect.any(String)
+      }),
+      mineOnly: true,
+      forceSync: false
+    });
+
+    appointmentCore.listAppointments.mockResolvedValueOnce({
+      successful: true,
+      appointments: []
+    });
+    const customResult = await listAppointments.execute({
+      jwtToken: 'jwt-token',
+      filter: 'custom',
+      startDate: '2026-07-01',
+      endDate: '2026-07-31'
+    });
+    expect(customResult.data.range).toEqual({
+      startDate: '2026-07-01',
+      endDate: '2026-07-31'
+    });
+
+    appointmentCore.listAppointments.mockResolvedValueOnce({
+      successful: false,
+      returnMessage: { message: 'List failed' }
+    });
+    const failedResult = await listAppointments.execute({
+      jwtToken: 'jwt-token',
+      filter: 'past'
+    });
+    expect(failedResult).toMatchObject({
+      success: false,
+      error: 'List failed'
+    });
+  });
+
+  test('listAppointments validates auth and connector capability errors', async () => {
+    await expect(listAppointments.execute({})).resolves.toMatchObject({
+      success: false,
+      error: 'Please go to Settings and authorize CRM platform'
+    });
+
+    jwt.decodeJwt.mockReturnValueOnce(null);
+    await expect(listAppointments.execute({ jwtToken: 'bad' })).resolves.toMatchObject({
+      success: false,
+      error: 'Invalid JWT token'
+    });
+
+    jwt.decodeJwt.mockReturnValueOnce({ platform: 'testCRM' });
+    await expect(listAppointments.execute({ jwtToken: 'jwt-token' })).resolves.toMatchObject({
+      success: false,
+      error: 'Invalid JWT token: userId not found'
+    });
+
+    connectorRegistry.getConnector.mockReturnValueOnce(null);
+    await expect(listAppointments.execute({ jwtToken: 'jwt-token' })).resolves.toMatchObject({
+      success: false,
+      error: 'Platform connector not found for: testCRM'
+    });
+
+    connectorRegistry.getConnector.mockReturnValueOnce({});
+    await expect(listAppointments.execute({ jwtToken: 'jwt-token' })).resolves.toMatchObject({
+      success: false,
+      error: 'listAppointments is not implemented for platform: testCRM'
+    });
+  });
+
+  test('createAppointment validates payload and returns success or handler failure', async () => {
+    await expect(createAppointment.execute({})).resolves.toMatchObject({
+      success: false,
+      error: 'Please go to Settings and authorize CRM platform'
+    });
+    await expect(createAppointment.execute({ jwtToken: 'jwt-token' })).resolves.toMatchObject({
+      success: false,
+      error: 'title is required'
+    });
+    await expect(createAppointment.execute({ jwtToken: 'jwt-token', title: 'Meet' })).resolves.toMatchObject({
+      success: false,
+      error: expect.stringContaining('startTimeUtc is required')
+    });
+    await expect(createAppointment.execute({
+      jwtToken: 'jwt-token',
+      title: 'Meet',
+      startTimeUtc: '2026-07-20T19:00:00.000Z'
+    })).resolves.toMatchObject({
+      success: false,
+      error: 'durationMinutes is required'
+    });
+
+    appointmentCore.createAppointment.mockResolvedValueOnce({
+      successful: true,
+      appointmentId: 'appt-1',
+      appointment: { id: 'appt-1' },
+      returnMessage: { message: 'Created' }
+    });
+    const result = await createAppointment.execute({
+      jwtToken: 'jwt-token',
+      title: 'Meet',
+      summary: 'Summary',
+      startTimeUtc: '2026-07-20T19:00:00.000Z',
+      durationMinutes: '45',
+      contacts: ['contact-1']
+    });
+
+    expect(result).toEqual({
+      success: true,
+      data: {
+        appointmentId: 'appt-1',
+        appointment: { id: 'appt-1' },
+        message: 'Created'
+      }
+    });
+    expect(appointmentCore.createAppointment).toHaveBeenCalledWith({
+      platform: 'testCRM',
+      userId: 'user-123',
+      payload: {
+        title: 'Meet',
+        summary: 'Summary',
+        startTimeUtc: '2026-07-20T19:00:00.000Z',
+        durationMinutes: 45,
+        contacts: ['contact-1']
+      }
+    });
+
+    appointmentCore.createAppointment.mockResolvedValueOnce({
+      successful: false,
+      returnMessage: { message: 'Create failed' }
+    });
+    await expect(createAppointment.execute({
+      jwtToken: 'jwt-token',
+      title: 'Meet',
+      startTimeUtc: '2026-07-20T19:00:00.000Z',
+      durationMinutes: 30
+    })).resolves.toMatchObject({
+      success: false,
+      error: 'Create failed'
+    });
+  });
+
+  test('createAppointment validates connector availability and implementation', async () => {
+    connectorRegistry.getConnector.mockReturnValueOnce(null);
+    await expect(createAppointment.execute({
+      jwtToken: 'jwt-token',
+      title: 'Meet',
+      startTimeUtc: '2026-07-20T19:00:00.000Z',
+      durationMinutes: 30
+    })).resolves.toMatchObject({
+      success: false,
+      error: 'Platform connector not found for: testCRM'
+    });
+
+    connectorRegistry.getConnector.mockReturnValueOnce({});
+    await expect(createAppointment.execute({
+      jwtToken: 'jwt-token',
+      title: 'Meet',
+      startTimeUtc: '2026-07-20T19:00:00.000Z',
+      durationMinutes: 30
+    })).resolves.toMatchObject({
+      success: false,
+      error: 'createAppointment is not implemented for platform: testCRM'
+    });
+  });
+
+  test('updateAppointment builds sparse patch body and handles failures', async () => {
+    await expect(updateAppointment.execute({ jwtToken: 'jwt-token' })).resolves.toMatchObject({
+      success: false,
+      error: 'appointmentId is required'
+    });
+
+    appointmentCore.updateAppointment.mockResolvedValueOnce({
+      successful: true,
+      appointment: { id: 'appt-1' },
+      returnMessage: { message: 'Updated' }
+    });
+    const result = await updateAppointment.execute({
+      jwtToken: 'jwt-token',
+      appointmentId: 'appt-1',
+      title: 'Updated',
+      summary: 'Summary',
+      startTimeUtc: '2026-07-20T19:00:00.000Z',
+      durationMinutes: '60',
+      contacts: [{ id: 'contact-1' }]
+    });
+
+    expect(result).toEqual({
+      success: true,
+      data: {
+        appointment: { id: 'appt-1' },
+        message: 'Updated'
+      }
+    });
+    expect(appointmentCore.updateAppointment).toHaveBeenCalledWith({
+      platform: 'testCRM',
+      userId: 'user-123',
+      appointmentId: 'appt-1',
+      patchBody: {
+        title: 'Updated',
+        summary: 'Summary',
+        startTimeUtc: '2026-07-20T19:00:00.000Z',
+        durationMinutes: 60,
+        contacts: [{ id: 'contact-1' }]
+      }
+    });
+
+    appointmentCore.updateAppointment.mockResolvedValueOnce({
+      successful: false,
+      returnMessage: { message: 'Update failed' }
+    });
+    await expect(updateAppointment.execute({
+      jwtToken: 'jwt-token',
+      appointmentId: 'appt-1'
+    })).resolves.toMatchObject({
+      success: false,
+      error: 'Update failed'
+    });
+  });
+
+  test('updateAppointment validates connector availability and implementation', async () => {
+    connectorRegistry.getConnector.mockReturnValueOnce(null);
+    await expect(updateAppointment.execute({
+      jwtToken: 'jwt-token',
+      appointmentId: 'appt-1'
+    })).resolves.toMatchObject({
+      success: false,
+      error: 'Platform connector not found for: testCRM'
+    });
+
+    connectorRegistry.getConnector.mockReturnValueOnce({});
+    await expect(updateAppointment.execute({
+      jwtToken: 'jwt-token',
+      appointmentId: 'appt-1'
+    })).resolves.toMatchObject({
+      success: false,
+      error: 'updateAppointment is not implemented for platform: testCRM'
+    });
+  });
+
+  test.each([
+    ['confirmAppointment', confirmAppointment, 'confirmAppointment', appointmentCore.confirmAppointment, 'Appointment confirmed successfully', 'Failed to confirm appointment'],
+    ['cancelAppointment', cancelAppointment, 'cancelAppointment', appointmentCore.cancelAppointment, 'Appointment cancelled successfully', 'Failed to cancel appointment']
+  ])('%s validates, succeeds, fails, and checks capability', async (name, tool, capabilityName, handlerFn, defaultMessage, defaultError) => {
+    await expect(tool.execute({})).resolves.toMatchObject({
+      success: false,
+      error: 'Please go to Settings and authorize CRM platform'
+    });
+    await expect(tool.execute({ jwtToken: 'jwt-token' })).resolves.toMatchObject({
+      success: false,
+      error: 'appointmentId is required'
+    });
+
+    handlerFn.mockResolvedValueOnce({
+      successful: true,
+      appointment: { id: 'appt-1' },
+      returnMessage: {}
+    });
+    await expect(tool.execute({
+      jwtToken: 'jwt-token',
+      appointmentId: 'appt-1'
+    })).resolves.toEqual({
+      success: true,
+      data: {
+        appointment: { id: 'appt-1' },
+        message: defaultMessage
+      }
+    });
+    expect(handlerFn).toHaveBeenCalledWith({
+      platform: 'testCRM',
+      userId: 'user-123',
+      appointmentId: 'appt-1'
+    });
+
+    handlerFn.mockResolvedValueOnce({
+      successful: false,
+      returnMessage: {}
+    });
+    await expect(tool.execute({
+      jwtToken: 'jwt-token',
+      appointmentId: 'appt-1'
+    })).resolves.toMatchObject({
+      success: false,
+      error: defaultError
+    });
+
+    connectorRegistry.getConnector.mockReturnValueOnce(null);
+    await expect(tool.execute({
+      jwtToken: 'jwt-token',
+      appointmentId: 'appt-1'
+    })).resolves.toMatchObject({
+      success: false,
+      error: 'Platform connector not found for: testCRM'
+    });
+
+    connectorRegistry.getConnector.mockReturnValueOnce({});
+    await expect(tool.execute({
+      jwtToken: 'jwt-token',
+      appointmentId: 'appt-1'
+    })).resolves.toMatchObject({
+      success: false,
+      error: `${capabilityName} is not implemented for platform: testCRM`
+    });
+  });
+});

package/test/models/callDownListModel.test.js

@@ -0,0 +1,125 @@
+const { CallDownListModel } = require('../../models/callDownListModel');
+
+describe('CallDownListModel', () => {
+  beforeAll(async () => {
+    await CallDownListModel.sync({ force: true });
+  });
+
+  afterEach(async () => {
+    await CallDownListModel.destroy({ where: {} });
+  });
+
+  test('defines the expected fields and indexes', () => {
+    const attributes = CallDownListModel.rawAttributes;
+
+    expect(attributes.id.primaryKey).toBe(true);
+    expect(attributes.userId.type.key).toBe('STRING');
+    expect(attributes.contactId.type.key).toBe('STRING');
+    expect(attributes.contactType.type.key).toBe('STRING');
+    expect(attributes.status.type.key).toBe('STRING');
+    expect(attributes.scheduledAt.type.key).toBe('DATE');
+    expect(attributes.lastCallAt.type.key).toBe('DATE');
+    expect(CallDownListModel.options.timestamps).toBe(true);
+    expect(CallDownListModel.options.indexes).toEqual(expect.arrayContaining([
+      expect.objectContaining({ fields: ['userId'] }),
+      expect.objectContaining({ fields: ['status'] }),
+      expect.objectContaining({ fields: ['scheduledAt'] }),
+      expect.objectContaining({ fields: ['userId', 'status'] }),
+    ]));
+  });
+
+  test('creates and reads a scheduled callback record', async () => {
+    const scheduledAt = new Date('2026-07-02T10:00:00.000Z');
+
+    await CallDownListModel.create({
+      id: 'call-down-1',
+      userId: 'user-1',
+      contactId: 'contact-1',
+      contactType: 'Lead',
+      status: 'Pending',
+      scheduledAt,
+    });
+
+    const record = await CallDownListModel.findByPk('call-down-1');
+
+    expect(record).toMatchObject({
+      id: 'call-down-1',
+      userId: 'user-1',
+      contactId: 'contact-1',
+      contactType: 'Lead',
+      status: 'Pending',
+    });
+    expect(record.scheduledAt.toISOString()).toBe('2026-07-02T10:00:00.000Z');
+    expect(record.lastCallAt).toBeNull();
+  });
+
+  test('allows nullable fields under the current schema', async () => {
+    await CallDownListModel.create({
+      id: 'minimal-call-down',
+    });
+
+    const record = await CallDownListModel.findByPk('minimal-call-down');
+
+    expect(record.userId).toBeNull();
+    expect(record.contactId).toBeNull();
+    expect(record.status).toBeNull();
+    expect(record.scheduledAt).toBeNull();
+    expect(record.lastCallAt).toBeNull();
+  });
+
+  test('updates callback status and last call time', async () => {
+    await CallDownListModel.create({
+      id: 'call-down-update',
+      userId: 'user-1',
+      contactId: 'contact-1',
+      contactType: 'Contact',
+      status: 'Pending',
+      scheduledAt: new Date('2026-07-02T10:00:00.000Z'),
+    });
+
+    const lastCallAt = new Date('2026-07-02T10:30:00.000Z');
+    await CallDownListModel.update({
+      status: 'Called',
+      lastCallAt,
+    }, {
+      where: { id: 'call-down-update' },
+    });
+
+    const record = await CallDownListModel.findByPk('call-down-update');
+    expect(record.status).toBe('Called');
+    expect(record.lastCallAt.toISOString()).toBe('2026-07-02T10:30:00.000Z');
+  });
+
+  test('queries by user and status together', async () => {
+    await CallDownListModel.bulkCreate([
+      {
+        id: 'call-down-user-1-pending',
+        userId: 'user-1',
+        status: 'Pending',
+        scheduledAt: new Date('2026-07-02T10:00:00.000Z'),
+      },
+      {
+        id: 'call-down-user-1-called',
+        userId: 'user-1',
+        status: 'Called',
+        scheduledAt: new Date('2026-07-02T11:00:00.000Z'),
+      },
+      {
+        id: 'call-down-user-2-pending',
+        userId: 'user-2',
+        status: 'Pending',
+        scheduledAt: new Date('2026-07-02T12:00:00.000Z'),
+      },
+    ]);
+
+    const records = await CallDownListModel.findAll({
+      where: {
+        userId: 'user-1',
+        status: 'Pending',
+      },
+    });
+
+    expect(records).toHaveLength(1);
+    expect(records[0].id).toBe('call-down-user-1-pending');
+  });
+});

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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,45 @@
+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

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