Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
| 1 | import * as crypto from 'node:crypto'; |
| 2 | import { describe, it, expect, vi, beforeEach } from 'vitest'; |
| 3 | import { Triggers } from '../../src/models/Triggers'; |
| 4 | import ComposioClient from '@composio/client'; |
| 5 | import { |
| 6 | WebhookPayloadV1, |
| 7 | WebhookPayloadV2, |
| 8 | WebhookPayloadV3, |
| 9 | WebhookVersions, |
| 10 | VerifyWebhookParams, |
| 11 | } from '../../src/types/triggers.types'; |
| 12 | import { ValidationError } from '../../src/errors'; |
| 13 | import { |
| 14 | ComposioWebhookSignatureVerificationError, |
| 15 | ComposioWebhookPayloadError, |
| 16 | } from '../../src/errors/TriggerErrors'; |
| 17 | import type { BaseComposioProvider } from '../../src/provider/BaseProvider'; |
| 18 | |
| 19 | /** Shape of the `cause` payload attached to {@link ComposioWebhookPayloadError} when no version schema matches. */ |
| 20 | type WebhookVersionMismatchCause = { |
| 21 | v1Error: string; |
| 22 | v2Error: string; |
| 23 | v3Error: string; |
| 24 | }; |
| 25 | |
| 26 | // Mock dependencies |
| 27 | vi.mock('../../src/utils/logger'); |
| 28 | vi.mock('../../src/telemetry/Telemetry', () => ({ |
| 29 | telemetry: { |
| 30 | instrument: vi.fn(), |
| 31 | }, |
| 32 | })); |
| 33 | vi.mock('../../src/services/pusher/Pusher'); |
| 34 | |
| 35 | // Create mock client |
| 36 | const createMockClient = () => ({ |
| 37 | baseURL: 'https://api.composio.dev', |
| 38 | apiKey: 'test-api-key', |
| 39 | triggerInstances: { |
| 40 | listActive: vi.fn(), |
| 41 | upsert: vi.fn(), |
| 42 | manage: { |
| 43 | delete: vi.fn(), |
| 44 | update: vi.fn(), |
| 45 | }, |
| 46 | }, |
| 47 | triggersTypes: { |
| 48 | list: vi.fn(), |
| 49 | retrieve: vi.fn(), |
| 50 | retrieveEnum: vi.fn(), |
| 51 | }, |
| 52 | connectedAccounts: { |
| 53 | list: vi.fn(), |
| 54 | }, |
| 55 | }); |
| 56 | |
| 57 | /** |
| 58 | * Helper to create a valid webhook signature in the format used by Composio. |
| 59 | * Format: v1,base64(HMAC-SHA256(msgId.timestamp.payload, secret)) |
| 60 | */ |
| 61 | const createSignature = ( |
| 62 | webhookId: string, |
| 63 | webhookTimestamp: string, |
| 64 | payload: string, |
| 65 | secret: string |
| 66 | ): string => { |
| 67 | const toSign = `${webhookId}.${webhookTimestamp}.${payload}`; |
| 68 | const signature = crypto.createHmac('sha256', secret).update(toSign, 'utf8').digest('base64'); |
| 69 | return `v1,${signature}`; |
| 70 | }; |
| 71 | |
| 72 | // Mock V1 webhook payload |
| 73 | const createMockV1Payload = (overrides: Partial<WebhookPayloadV1> = {}): WebhookPayloadV1 => ({ |
| 74 | trigger_name: 'GITHUB_PUSH_EVENT', |
| 75 | connection_id: 'conn-123', |
| 76 | trigger_id: 'trigger-123', |
| 77 | payload: { action: 'push', repository: 'test-repo' }, |
| 78 | log_id: 'log-123', |
| 79 | ...overrides, |
| 80 | }); |
| 81 | |
| 82 | // Mock V2 webhook payload |
| 83 | const createMockV2Payload = (overrides: Partial<WebhookPayloadV2> = {}): WebhookPayloadV2 => ({ |
| 84 | type: 'github_push_event', |
| 85 | timestamp: new Date().toISOString(), |
| 86 | log_id: 'log-123', |
| 87 | data: { |
| 88 | connection_id: 'conn-123', |
| 89 | connection_nano_id: 'conn-nano-123', |
| 90 | trigger_nano_id: 'trigger-nano-123', |
| 91 | trigger_id: 'trigger-123', |
| 92 | user_id: 'user-456', |
| 93 | action: 'push', |
| 94 | repository: 'test-repo', |
| 95 | }, |
| 96 | ...overrides, |
| 97 | }); |
| 98 | |
| 99 | // Mock V3 webhook payload |
| 100 | const createMockV3Payload = (overrides: Partial<WebhookPayloadV3> = {}): WebhookPayloadV3 => ({ |
| 101 | id: 'msg_abc123', |
| 102 | timestamp: new Date().toISOString(), |
| 103 | type: 'composio.trigger.message', |
| 104 | metadata: { |
| 105 | log_id: 'log-123', |
| 106 | trigger_slug: 'GITHUB_PUSH_EVENT', |
| 107 | trigger_id: 'trigger-nano-123', |
| 108 | connected_account_id: 'conn-nano-123', |
| 109 | auth_config_id: 'auth-nano-123', |
| 110 | user_id: 'user-456', |
| 111 | }, |
| 112 | data: { action: 'push', repository: 'test-repo' }, |
| 113 | ...overrides, |
| 114 | }); |
| 115 | |
| 116 | describe('Triggers.verifyWebhook', () => { |
| 117 | let triggers: Triggers<BaseComposioProvider<unknown, unknown, unknown>>; |
| 118 | let mockClient: ReturnType<typeof createMockClient>; |
| 119 | const testSecret = 'test-webhook-secret-12345'; |
| 120 | const testWebhookId = 'msg_test123'; |
| 121 | const testTimestamp = Math.floor(Date.now() / 1000).toString(); |
| 122 | |
| 123 | beforeEach(() => { |
| 124 | vi.clearAllMocks(); |
| 125 | mockClient = createMockClient(); |
| 126 | triggers = new Triggers(mockClient as unknown as ComposioClient); |
| 127 | }); |
| 128 | |
| 129 | describe('successful verification with V3 payload', () => { |
| 130 | it('should verify a valid V3 webhook payload and signature', async () => { |
| 131 | const v3Payload = createMockV3Payload(); |
| 132 | const payloadStr = JSON.stringify(v3Payload); |
| 133 | const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret); |
| 134 | |
| 135 | const result = await triggers.verifyWebhook({ |
| 136 | payload: payloadStr, |
| 137 | signature, |
| 138 | secret: testSecret, |
| 139 | id: testWebhookId, |
| 140 | timestamp: testTimestamp, |
| 141 | }); |
| 142 | |
| 143 | expect(result).toBeDefined(); |
| 144 | expect(result.version).toBe(WebhookVersions.V3); |
| 145 | expect(result.payload.triggerSlug).toBe('GITHUB_PUSH_EVENT'); |
| 146 | expect(result.payload.userId).toBe('user-456'); |
| 147 | expect(result.rawPayload).toEqual(v3Payload); |
| 148 | }); |
| 149 | |
| 150 | it('should correctly normalize V3 payload to IncomingTriggerPayload format', async () => { |
| 151 | const v3Payload = createMockV3Payload(); |
| 152 | const payloadStr = JSON.stringify(v3Payload); |
| 153 | const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret); |
| 154 | |
| 155 | const result = await triggers.verifyWebhook({ |
| 156 | payload: payloadStr, |
| 157 | signature, |
| 158 | secret: testSecret, |
| 159 | id: testWebhookId, |
| 160 | timestamp: testTimestamp, |
| 161 | }); |
| 162 | |
| 163 | expect(result.payload.metadata.connectedAccount).toEqual({ |
| 164 | id: 'conn-nano-123', |
| 165 | uuid: 'conn-nano-123', |
| 166 | authConfigId: 'auth-nano-123', |
| 167 | authConfigUUID: 'auth-nano-123', |
| 168 | userId: 'user-456', |
| 169 | status: 'ACTIVE', |
| 170 | }); |
| 171 | }); |
| 172 | |
| 173 | it('should detect V3 payload with non-trigger event type (e.g., connected_account.expired)', async () => { |
| 174 | // This test uses realistic connection metadata (project_id, org_id) |
| 175 | // instead of fabricated trigger metadata, verifying that V3 detection |
| 176 | // works for events with different metadata shapes. |
| 177 | const payload = { |
| 178 | id: 'msg_abc123', |
| 179 | timestamp: new Date().toISOString(), |
| 180 | type: 'composio.connected_account.expired', |
| 181 | metadata: { |
| 182 | project_id: 'pr_koucdrMIwRsf', |
| 183 | org_id: '4a4ded8f-d3ae-4dea-a229-c30234298b05', |
| 184 | }, |
| 185 | data: { |
| 186 | toolkit: { slug: 'gmail' }, |
| 187 | id: 'ca__IvSeEzEBjVt', |
| 188 | user_id: 'test-user', |
| 189 | status: 'EXPIRED', |
| 190 | }, |
| 191 | }; |
| 192 | const payloadStr = JSON.stringify(payload); |
| 193 | const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret); |
| 194 | |
| 195 | const result = await triggers.verifyWebhook({ |
| 196 | payload: payloadStr, |
| 197 | signature, |
| 198 | secret: testSecret, |
| 199 | id: testWebhookId, |
| 200 | timestamp: testTimestamp, |
| 201 | }); |
| 202 | |
| 203 | expect(result.version).toBe(WebhookVersions.V3); |
| 204 | expect(result.rawPayload).toEqual(payload); |
| 205 | }); |
| 206 | }); |
| 207 | |
| 208 | describe('successful verification with V2 payload', () => { |
| 209 | it('should verify a valid V2 webhook payload and signature', async () => { |
| 210 | const v2Payload = createMockV2Payload(); |
| 211 | const payloadStr = JSON.stringify(v2Payload); |
| 212 | const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret); |
| 213 | |
| 214 | const result = await triggers.verifyWebhook({ |
| 215 | payload: payloadStr, |
| 216 | signature, |
| 217 | secret: testSecret, |
| 218 | id: testWebhookId, |
| 219 | timestamp: testTimestamp, |
| 220 | }); |
| 221 | |
| 222 | expect(result).toBeDefined(); |
| 223 | expect(result.version).toBe(WebhookVersions.V2); |
| 224 | expect(result.payload.triggerSlug).toBe('GITHUB_PUSH_EVENT'); |
| 225 | expect(result.payload.userId).toBe('user-456'); |
| 226 | }); |
| 227 | }); |
| 228 | |
| 229 | describe('successful verification with V1 payload', () => { |
| 230 | it('should verify a valid V1 webhook payload and signature', async () => { |
| 231 | const v1Payload = createMockV1Payload(); |
| 232 | const payloadStr = JSON.stringify(v1Payload); |
| 233 | const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret); |
| 234 | |
| 235 | const result = await triggers.verifyWebhook({ |
| 236 | payload: payloadStr, |
| 237 | signature, |
| 238 | secret: testSecret, |
| 239 | id: testWebhookId, |
| 240 | timestamp: testTimestamp, |
| 241 | }); |
| 242 | |
| 243 | expect(result).toBeDefined(); |
| 244 | expect(result.version).toBe(WebhookVersions.V1); |
| 245 | expect(result.payload.triggerSlug).toBe('GITHUB_PUSH_EVENT'); |
| 246 | expect(result.payload.id).toBe('trigger-123'); |
| 247 | }); |
| 248 | }); |
| 249 | |
| 250 | describe('tolerance settings', () => { |
| 251 | it('should verify webhook with tolerance set to 0 (skip timestamp validation)', async () => { |
| 252 | const v3Payload = createMockV3Payload(); |
| 253 | const payloadStr = JSON.stringify(v3Payload); |
| 254 | // Use an old timestamp |
| 255 | const oldTimestamp = Math.floor((Date.now() - 60 * 60 * 1000) / 1000).toString(); |
| 256 | const signature = createSignature(testWebhookId, oldTimestamp, payloadStr, testSecret); |
| 257 | |
| 258 | const result = await triggers.verifyWebhook({ |
| 259 | payload: payloadStr, |
| 260 | signature, |
| 261 | secret: testSecret, |
| 262 | id: testWebhookId, |
| 263 | timestamp: oldTimestamp, |
| 264 | tolerance: 0, |
| 265 | }); |
| 266 | |
| 267 | expect(result).toBeDefined(); |
| 268 | expect(result.version).toBe(WebhookVersions.V3); |
| 269 | }); |
| 270 | |
| 271 | it('should verify webhook with custom tolerance', async () => { |
| 272 | const v3Payload = createMockV3Payload(); |
| 273 | const payloadStr = JSON.stringify(v3Payload); |
| 274 | const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret); |
| 275 | |
| 276 | const result = await triggers.verifyWebhook({ |
| 277 | payload: payloadStr, |
| 278 | signature, |
| 279 | secret: testSecret, |
| 280 | id: testWebhookId, |
| 281 | timestamp: testTimestamp, |
| 282 | tolerance: 600, // 10 minutes |
| 283 | }); |
| 284 | |
| 285 | expect(result).toBeDefined(); |
| 286 | }); |
| 287 | }); |
| 288 | |
| 289 | describe('signature verification errors', () => { |
| 290 | it('should throw error when payload is empty', async () => { |
| 291 | await expect(() => |
| 292 | triggers.verifyWebhook({ |
| 293 | payload: '', |
| 294 | signature: 'v1,somesignature', |
| 295 | secret: testSecret, |
| 296 | id: testWebhookId, |
| 297 | timestamp: testTimestamp, |
| 298 | }) |
| 299 | ).rejects.toThrow(ComposioWebhookSignatureVerificationError); |
| 300 | |
| 301 | await expect(() => |
| 302 | triggers.verifyWebhook({ |
| 303 | payload: '', |
| 304 | signature: 'v1,somesignature', |
| 305 | secret: testSecret, |
| 306 | id: testWebhookId, |
| 307 | timestamp: testTimestamp, |
| 308 | }) |
| 309 | ).rejects.toThrow('No webhook payload was provided.'); |
| 310 | }); |
| 311 | |
| 312 | it('should throw error when signature is empty', async () => { |
| 313 | const payloadStr = JSON.stringify(createMockV3Payload()); |
| 314 | |
| 315 | await expect(() => |
| 316 | triggers.verifyWebhook({ |
| 317 | payload: payloadStr, |
| 318 | signature: '', |
| 319 | secret: testSecret, |
| 320 | id: testWebhookId, |
| 321 | timestamp: testTimestamp, |
| 322 | }) |
| 323 | ).rejects.toThrow(ComposioWebhookSignatureVerificationError); |
| 324 | |
| 325 | await expect(() => |
| 326 | triggers.verifyWebhook({ |
| 327 | payload: payloadStr, |
| 328 | signature: '', |
| 329 | secret: testSecret, |
| 330 | id: testWebhookId, |
| 331 | timestamp: testTimestamp, |
| 332 | }) |
| 333 | ).rejects.toThrow('No signature header value was provided.'); |
| 334 | }); |
| 335 | |
| 336 | it('should throw error when secret is empty', async () => { |
| 337 | const payloadStr = JSON.stringify(createMockV3Payload()); |
| 338 | |
| 339 | await expect(() => |
| 340 | triggers.verifyWebhook({ |
| 341 | payload: payloadStr, |
| 342 | signature: 'v1,somesignature', |
| 343 | secret: '', |
| 344 | id: testWebhookId, |
| 345 | timestamp: testTimestamp, |
| 346 | }) |
| 347 | ).rejects.toThrow(ComposioWebhookSignatureVerificationError); |
| 348 | |
| 349 | await expect(() => |
| 350 | triggers.verifyWebhook({ |
| 351 | payload: payloadStr, |
| 352 | signature: 'v1,somesignature', |
| 353 | secret: '', |
| 354 | id: testWebhookId, |
| 355 | timestamp: testTimestamp, |
| 356 | }) |
| 357 | ).rejects.toThrow('No webhook secret was provided.'); |
| 358 | }); |
| 359 | |
| 360 | it('should throw error when webhookId is empty', async () => { |
| 361 | const payloadStr = JSON.stringify(createMockV3Payload()); |
| 362 | |
| 363 | await expect(() => |
| 364 | triggers.verifyWebhook({ |
| 365 | payload: payloadStr, |
| 366 | signature: 'v1,somesignature', |
| 367 | secret: testSecret, |
| 368 | id: '', |
| 369 | timestamp: testTimestamp, |
| 370 | }) |
| 371 | ).rejects.toThrow(ComposioWebhookSignatureVerificationError); |
| 372 | |
| 373 | await expect(() => |
| 374 | triggers.verifyWebhook({ |
| 375 | payload: payloadStr, |
| 376 | signature: 'v1,somesignature', |
| 377 | secret: testSecret, |
| 378 | id: '', |
| 379 | timestamp: testTimestamp, |
| 380 | }) |
| 381 | ).rejects.toThrow('No webhook ID was provided.'); |
| 382 | }); |
| 383 | |
| 384 | it('should throw error when webhookTimestamp is empty', async () => { |
| 385 | const payloadStr = JSON.stringify(createMockV3Payload()); |
| 386 | |
| 387 | // Empty timestamp is treated as invalid timestamp format (parseInt('') = NaN) |
| 388 | await expect(() => |
| 389 | triggers.verifyWebhook({ |
| 390 | payload: payloadStr, |
| 391 | signature: 'v1,somesignature', |
| 392 | secret: testSecret, |
| 393 | id: testWebhookId, |
| 394 | timestamp: '', |
| 395 | }) |
| 396 | ).rejects.toThrow(ComposioWebhookPayloadError); |
| 397 | |
| 398 | await expect(() => |
| 399 | triggers.verifyWebhook({ |
| 400 | payload: payloadStr, |
| 401 | signature: 'v1,somesignature', |
| 402 | secret: testSecret, |
| 403 | id: testWebhookId, |
| 404 | timestamp: '', |
| 405 | }) |
| 406 | ).rejects.toThrow('Invalid webhook timestamp'); |
| 407 | }); |
| 408 | |
| 409 | it('should throw error when signature format is invalid (no v1 prefix)', async () => { |
| 410 | const payloadStr = JSON.stringify(createMockV3Payload()); |
| 411 | |
| 412 | await expect(() => |
| 413 | triggers.verifyWebhook({ |
| 414 | payload: payloadStr, |
| 415 | signature: 'invalid-signature-no-prefix', |
| 416 | secret: testSecret, |
| 417 | id: testWebhookId, |
| 418 | timestamp: testTimestamp, |
| 419 | }) |
| 420 | ).rejects.toThrow(ComposioWebhookSignatureVerificationError); |
| 421 | |
| 422 | await expect(() => |
| 423 | triggers.verifyWebhook({ |
| 424 | payload: payloadStr, |
| 425 | signature: 'invalid-signature-no-prefix', |
| 426 | secret: testSecret, |
| 427 | id: testWebhookId, |
| 428 | timestamp: testTimestamp, |
| 429 | }) |
| 430 | ).rejects.toThrow('No valid v1 signature found'); |
| 431 | }); |
| 432 | |
| 433 | it('should throw error when signature is invalid', async () => { |
| 434 | const payloadStr = JSON.stringify(createMockV3Payload()); |
| 435 | |
| 436 | await expect(() => |
| 437 | triggers.verifyWebhook({ |
| 438 | payload: payloadStr, |
| 439 | signature: 'v1,invalidbase64signature==', |
| 440 | secret: testSecret, |
| 441 | id: testWebhookId, |
| 442 | timestamp: testTimestamp, |
| 443 | }) |
| 444 | ).rejects.toThrow(ComposioWebhookSignatureVerificationError); |
| 445 | |
| 446 | await expect(() => |
| 447 | triggers.verifyWebhook({ |
| 448 | payload: payloadStr, |
| 449 | signature: 'v1,invalidbase64signature==', |
| 450 | secret: testSecret, |
| 451 | id: testWebhookId, |
| 452 | timestamp: testTimestamp, |
| 453 | }) |
| 454 | ).rejects.toThrow('The signature provided is invalid.'); |
| 455 | }); |
| 456 | |
| 457 | it('should throw error when signature was created with different secret', async () => { |
| 458 | const payloadStr = JSON.stringify(createMockV3Payload()); |
| 459 | const signatureWithDifferentSecret = createSignature( |
| 460 | testWebhookId, |
| 461 | testTimestamp, |
| 462 | payloadStr, |
| 463 | 'different-secret' |
| 464 | ); |
| 465 | |
| 466 | await expect(() => |
| 467 | triggers.verifyWebhook({ |
| 468 | payload: payloadStr, |
| 469 | signature: signatureWithDifferentSecret, |
| 470 | secret: testSecret, |
| 471 | id: testWebhookId, |
| 472 | timestamp: testTimestamp, |
| 473 | }) |
| 474 | ).rejects.toThrow(ComposioWebhookSignatureVerificationError); |
| 475 | }); |
| 476 | |
| 477 | it('should throw error when payload was modified after signing', async () => { |
| 478 | const originalPayload = createMockV3Payload(); |
| 479 | const payloadStr = JSON.stringify(originalPayload); |
| 480 | const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret); |
| 481 | |
| 482 | const modifiedPayload = JSON.stringify({ |
| 483 | ...originalPayload, |
| 484 | data: { modified: true }, |
| 485 | }); |
| 486 | |
| 487 | await expect(() => |
| 488 | triggers.verifyWebhook({ |
| 489 | payload: modifiedPayload, |
| 490 | signature, |
| 491 | secret: testSecret, |
| 492 | id: testWebhookId, |
| 493 | timestamp: testTimestamp, |
| 494 | }) |
| 495 | ).rejects.toThrow(ComposioWebhookSignatureVerificationError); |
| 496 | }); |
| 497 | }); |
| 498 | |
| 499 | describe('payload parsing errors', () => { |
| 500 | it('should throw error when payload is not valid JSON', async () => { |
| 501 | const invalidJson = 'not-valid-json{'; |
| 502 | const signature = createSignature(testWebhookId, testTimestamp, invalidJson, testSecret); |
| 503 | |
| 504 | await expect(() => |
| 505 | triggers.verifyWebhook({ |
| 506 | payload: invalidJson, |
| 507 | signature, |
| 508 | secret: testSecret, |
| 509 | id: testWebhookId, |
| 510 | timestamp: testTimestamp, |
| 511 | }) |
| 512 | ).rejects.toThrow(ComposioWebhookPayloadError); |
| 513 | |
| 514 | await expect(() => |
| 515 | triggers.verifyWebhook({ |
| 516 | payload: invalidJson, |
| 517 | signature, |
| 518 | secret: testSecret, |
| 519 | id: testWebhookId, |
| 520 | timestamp: testTimestamp, |
| 521 | }) |
| 522 | ).rejects.toThrow('Failed to parse webhook payload as JSON'); |
| 523 | }); |
| 524 | |
| 525 | it('should throw error for unrecognized payload format', async () => { |
| 526 | const unknownPayload = JSON.stringify({ unknown: 'format' }); |
| 527 | const signature = createSignature(testWebhookId, testTimestamp, unknownPayload, testSecret); |
| 528 | |
| 529 | await expect(() => |
| 530 | triggers.verifyWebhook({ |
| 531 | payload: unknownPayload, |
| 532 | signature, |
| 533 | secret: testSecret, |
| 534 | id: testWebhookId, |
| 535 | timestamp: testTimestamp, |
| 536 | }) |
| 537 | ).rejects.toThrow(ComposioWebhookPayloadError); |
| 538 | |
| 539 | await expect(() => |
| 540 | triggers.verifyWebhook({ |
| 541 | payload: unknownPayload, |
| 542 | signature, |
| 543 | secret: testSecret, |
| 544 | id: testWebhookId, |
| 545 | timestamp: testTimestamp, |
| 546 | }) |
| 547 | ).rejects.toThrow('does not match any known version'); |
| 548 | }); |
| 549 | |
| 550 | it('should include detailed schema errors when payload does not match any version', async () => { |
| 551 | const invalidPayload = JSON.stringify({ invalid: 'data' }); |
| 552 | const signature = createSignature(testWebhookId, testTimestamp, invalidPayload, testSecret); |
| 553 | |
| 554 | try { |
| 555 | await triggers.verifyWebhook({ |
| 556 | payload: invalidPayload, |
| 557 | signature, |
| 558 | secret: testSecret, |
| 559 | id: testWebhookId, |
| 560 | timestamp: testTimestamp, |
| 561 | }); |
| 562 | expect.fail('Should have thrown'); |
| 563 | } catch (error) { |
| 564 | expect(error).toBeInstanceOf(ComposioWebhookPayloadError); |
| 565 | const webhookError = error as ComposioWebhookPayloadError; |
| 566 | expect(webhookError.cause).toBeDefined(); |
| 567 | // The cause should contain v1Error, v2Error, and v3Error with schema validation messages |
| 568 | const cause = webhookError.cause as unknown as WebhookVersionMismatchCause; |
| 569 | expect(cause.v1Error).toBeDefined(); |
| 570 | expect(cause.v2Error).toBeDefined(); |
| 571 | expect(cause.v3Error).toBeDefined(); |
| 572 | } |
| 573 | }); |
| 574 | }); |
| 575 | |
| 576 | describe('timestamp validation', () => { |
| 577 | it('should pass when webhook timestamp is within tolerance', async () => { |
| 578 | const v3Payload = createMockV3Payload(); |
| 579 | const payloadStr = JSON.stringify(v3Payload); |
| 580 | const recentTimestamp = Math.floor(Date.now() / 1000).toString(); |
| 581 | const signature = createSignature(testWebhookId, recentTimestamp, payloadStr, testSecret); |
| 582 | |
| 583 | const result = await triggers.verifyWebhook({ |
| 584 | payload: payloadStr, |
| 585 | signature, |
| 586 | secret: testSecret, |
| 587 | id: testWebhookId, |
| 588 | timestamp: recentTimestamp, |
| 589 | tolerance: 300, |
| 590 | }); |
| 591 | |
| 592 | expect(result).toBeDefined(); |
| 593 | }); |
| 594 | |
| 595 | it('should throw error when webhook timestamp is outside tolerance', async () => { |
| 596 | const v3Payload = createMockV3Payload(); |
| 597 | const payloadStr = JSON.stringify(v3Payload); |
| 598 | // 10 minutes ago |
| 599 | const oldTimestamp = Math.floor((Date.now() - 10 * 60 * 1000) / 1000).toString(); |
| 600 | const signature = createSignature(testWebhookId, oldTimestamp, payloadStr, testSecret); |
| 601 | |
| 602 | await expect(() => |
| 603 | triggers.verifyWebhook({ |
| 604 | payload: payloadStr, |
| 605 | signature, |
| 606 | secret: testSecret, |
| 607 | id: testWebhookId, |
| 608 | timestamp: oldTimestamp, |
| 609 | tolerance: 300, // 5 minutes |
| 610 | }) |
| 611 | ).rejects.toThrow(ComposioWebhookSignatureVerificationError); |
| 612 | |
| 613 | await expect(() => |
| 614 | triggers.verifyWebhook({ |
| 615 | payload: payloadStr, |
| 616 | signature, |
| 617 | secret: testSecret, |
| 618 | id: testWebhookId, |
| 619 | timestamp: oldTimestamp, |
| 620 | tolerance: 300, |
| 621 | }) |
| 622 | ).rejects.toThrow('The webhook timestamp is outside the allowed tolerance'); |
| 623 | }); |
| 624 | |
| 625 | it('should throw error for invalid timestamp format', async () => { |
| 626 | const v3Payload = createMockV3Payload(); |
| 627 | const payloadStr = JSON.stringify(v3Payload); |
| 628 | const invalidTimestamp = 'not-a-timestamp'; |
| 629 | const signature = createSignature(testWebhookId, invalidTimestamp, payloadStr, testSecret); |
| 630 | |
| 631 | await expect(() => |
| 632 | triggers.verifyWebhook({ |
| 633 | payload: payloadStr, |
| 634 | signature, |
| 635 | secret: testSecret, |
| 636 | id: testWebhookId, |
| 637 | timestamp: invalidTimestamp, |
| 638 | tolerance: 300, |
| 639 | }) |
| 640 | ).rejects.toThrow(ComposioWebhookPayloadError); |
| 641 | |
| 642 | await expect(() => |
| 643 | triggers.verifyWebhook({ |
| 644 | payload: payloadStr, |
| 645 | signature, |
| 646 | secret: testSecret, |
| 647 | id: testWebhookId, |
| 648 | timestamp: invalidTimestamp, |
| 649 | tolerance: 300, |
| 650 | }) |
| 651 | ).rejects.toThrow('Invalid webhook timestamp'); |
| 652 | }); |
| 653 | }); |
| 654 | |
| 655 | describe('input validation', () => { |
| 656 | it('should throw ValidationError for missing payload parameter', async () => { |
| 657 | await expect(() => |
| 658 | triggers.verifyWebhook({ |
| 659 | signature: 'v1,sig', |
| 660 | secret: testSecret, |
| 661 | webhookId: testWebhookId, |
| 662 | webhookTimestamp: testTimestamp, |
| 663 | } as unknown as VerifyWebhookParams) |
| 664 | ).rejects.toThrow(ValidationError); |
| 665 | }); |
| 666 | |
| 667 | it('should throw ValidationError for missing signature parameter', async () => { |
| 668 | await expect(() => |
| 669 | triggers.verifyWebhook({ |
| 670 | payload: '{}', |
| 671 | secret: testSecret, |
| 672 | webhookId: testWebhookId, |
| 673 | webhookTimestamp: testTimestamp, |
| 674 | } as unknown as VerifyWebhookParams) |
| 675 | ).rejects.toThrow(ValidationError); |
| 676 | }); |
| 677 | |
| 678 | it('should throw ValidationError for missing secret parameter', async () => { |
| 679 | await expect(() => |
| 680 | triggers.verifyWebhook({ |
| 681 | payload: '{}', |
| 682 | signature: 'v1,sig', |
| 683 | webhookId: testWebhookId, |
| 684 | webhookTimestamp: testTimestamp, |
| 685 | } as unknown as VerifyWebhookParams) |
| 686 | ).rejects.toThrow(ValidationError); |
| 687 | }); |
| 688 | |
| 689 | it('should throw ValidationError for missing webhookId parameter', async () => { |
| 690 | await expect(() => |
| 691 | triggers.verifyWebhook({ |
| 692 | payload: '{}', |
| 693 | signature: 'v1,sig', |
| 694 | secret: testSecret, |
| 695 | webhookTimestamp: testTimestamp, |
| 696 | } as unknown as VerifyWebhookParams) |
| 697 | ).rejects.toThrow(ValidationError); |
| 698 | }); |
| 699 | |
| 700 | it('should throw ValidationError for missing webhookTimestamp parameter', async () => { |
| 701 | await expect(() => |
| 702 | triggers.verifyWebhook({ |
| 703 | payload: '{}', |
| 704 | signature: 'v1,sig', |
| 705 | secret: testSecret, |
| 706 | webhookId: testWebhookId, |
| 707 | } as unknown as VerifyWebhookParams) |
| 708 | ).rejects.toThrow(ValidationError); |
| 709 | }); |
| 710 | |
| 711 | it('should throw ValidationError for invalid tolerance type', async () => { |
| 712 | await expect(() => |
| 713 | triggers.verifyWebhook({ |
| 714 | payload: '{}', |
| 715 | signature: 'v1,sig', |
| 716 | secret: testSecret, |
| 717 | id: testWebhookId, |
| 718 | timestamp: testTimestamp, |
| 719 | tolerance: 'invalid' as unknown as number, |
| 720 | }) |
| 721 | ).rejects.toThrow(ValidationError); |
| 722 | }); |
| 723 | }); |
| 724 | |
| 725 | describe('security considerations', () => { |
| 726 | it('should use timing-safe comparison for signatures', async () => { |
| 727 | const v3Payload = createMockV3Payload(); |
| 728 | const payloadStr = JSON.stringify(v3Payload); |
| 729 | const validSignature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret); |
| 730 | |
| 731 | // Valid signature should work |
| 732 | await expect( |
| 733 | triggers.verifyWebhook({ |
| 734 | payload: payloadStr, |
| 735 | signature: validSignature, |
| 736 | secret: testSecret, |
| 737 | id: testWebhookId, |
| 738 | timestamp: testTimestamp, |
| 739 | }) |
| 740 | ).resolves.toBeDefined(); |
| 741 | |
| 742 | // Invalid signature with same format should fail |
| 743 | const invalidSignature = 'v1,' + 'a'.repeat(44); // base64 SHA256 is 44 chars |
| 744 | await expect(() => |
| 745 | triggers.verifyWebhook({ |
| 746 | payload: payloadStr, |
| 747 | signature: invalidSignature, |
| 748 | secret: testSecret, |
| 749 | id: testWebhookId, |
| 750 | timestamp: testTimestamp, |
| 751 | }) |
| 752 | ).rejects.toThrow(ComposioWebhookSignatureVerificationError); |
| 753 | }); |
| 754 | |
| 755 | it('should handle unicode in payload correctly', async () => { |
| 756 | const v3Payload = createMockV3Payload({ data: { message: '你好世界 🌍 مرحبا' } }); |
| 757 | const payloadStr = JSON.stringify(v3Payload); |
| 758 | const signature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret); |
| 759 | |
| 760 | const result = await triggers.verifyWebhook({ |
| 761 | payload: payloadStr, |
| 762 | signature, |
| 763 | secret: testSecret, |
| 764 | id: testWebhookId, |
| 765 | timestamp: testTimestamp, |
| 766 | }); |
| 767 | |
| 768 | expect(result).toBeDefined(); |
| 769 | expect(result.payload.payload).toEqual({ message: '你好世界 🌍 مرحبا' }); |
| 770 | }); |
| 771 | |
| 772 | it('should handle special characters in secret', async () => { |
| 773 | const specialSecret = 'secret!@#$%^&*()_+-=[]{}|;:,.<>?'; |
| 774 | const v3Payload = createMockV3Payload(); |
| 775 | const payloadStr = JSON.stringify(v3Payload); |
| 776 | const signature = createSignature(testWebhookId, testTimestamp, payloadStr, specialSecret); |
| 777 | |
| 778 | const result = await triggers.verifyWebhook({ |
| 779 | payload: payloadStr, |
| 780 | signature, |
| 781 | secret: specialSecret, |
| 782 | id: testWebhookId, |
| 783 | timestamp: testTimestamp, |
| 784 | }); |
| 785 | |
| 786 | expect(result).toBeDefined(); |
| 787 | }); |
| 788 | |
| 789 | it('should support multiple signatures in header', async () => { |
| 790 | const v3Payload = createMockV3Payload(); |
| 791 | const payloadStr = JSON.stringify(v3Payload); |
| 792 | const validSignature = createSignature(testWebhookId, testTimestamp, payloadStr, testSecret); |
| 793 | // Multiple signatures space-separated |
| 794 | const multipleSignatures = `v1,invalidsig== ${validSignature}`; |
| 795 | |
| 796 | const result = await triggers.verifyWebhook({ |
| 797 | payload: payloadStr, |
| 798 | signature: multipleSignatures, |
| 799 | secret: testSecret, |
| 800 | id: testWebhookId, |
| 801 | timestamp: testTimestamp, |
| 802 | }); |
| 803 | |
| 804 | expect(result).toBeDefined(); |
| 805 | }); |
| 806 | }); |
| 807 | |
| 808 | describe('error properties', () => { |
| 809 | it('should include proper error class for signature verification error', async () => { |
| 810 | const payloadStr = JSON.stringify(createMockV3Payload()); |
| 811 | |
| 812 | try { |
| 813 | await triggers.verifyWebhook({ |
| 814 | payload: payloadStr, |
| 815 | signature: 'v1,invalid', |
| 816 | secret: testSecret, |
| 817 | id: testWebhookId, |
| 818 | timestamp: testTimestamp, |
| 819 | }); |
| 820 | expect.fail('Should have thrown'); |
| 821 | } catch (error) { |
| 822 | expect(error).toBeInstanceOf(ComposioWebhookSignatureVerificationError); |
| 823 | expect((error as ComposioWebhookSignatureVerificationError).name).toBe( |
| 824 | 'ComposioWebhookSignatureVerificationError' |
| 825 | ); |
| 826 | } |
| 827 | }); |
| 828 | |
| 829 | it('should include proper error class for payload error', async () => { |
| 830 | const invalidPayload = 'not-json'; |
| 831 | const signature = createSignature(testWebhookId, testTimestamp, invalidPayload, testSecret); |
| 832 | |
| 833 | try { |
| 834 | await triggers.verifyWebhook({ |
| 835 | payload: invalidPayload, |
| 836 | signature, |
| 837 | secret: testSecret, |
| 838 | id: testWebhookId, |
| 839 | timestamp: testTimestamp, |
| 840 | }); |
| 841 | expect.fail('Should have thrown'); |
| 842 | } catch (error) { |
| 843 | expect(error).toBeInstanceOf(ComposioWebhookPayloadError); |
| 844 | expect((error as ComposioWebhookPayloadError).name).toBe('ComposioWebhookPayloadError'); |
| 845 | } |
| 846 | }); |
| 847 | }); |
| 848 | }); |