feat(trigger): add ServiceNow provider handler with event matching

Add dedicated ServiceNow webhook provider handler with:
- verifyAuth: validates webhookSecret via Bearer token or X-Sim-Webhook-Secret
- matchEvent: filters events by trigger type and table name using
  isServiceNowEventMatch utility (matching Salesforce/GitHub pattern)

The event matcher handles incident created/updated and change request
created/updated triggers with table name enforcement and event type
normalization. The generic webhook trigger passes through all events
but still respects the optional table name filter.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: waleedlatif1

apps/sim/lib/webhooks/providers/registry.ts

@@ -28,6 +28,7 @@ import { outlookHandler } from '@/lib/webhooks/providers/outlook'
 import { resendHandler } from '@/lib/webhooks/providers/resend'
 import { rssHandler } from '@/lib/webhooks/providers/rss'
 import { salesforceHandler } from '@/lib/webhooks/providers/salesforce'
+import { servicenowHandler } from '@/lib/webhooks/providers/servicenow'
 import { slackHandler } from '@/lib/webhooks/providers/slack'
 import { stripeHandler } from '@/lib/webhooks/providers/stripe'
 import { telegramHandler } from '@/lib/webhooks/providers/telegram'
@@ -72,6 +73,7 @@ const PROVIDER_HANDLERS: Record<string, WebhookProviderHandler> = {
   outlook: outlookHandler,
   rss: rssHandler,
   salesforce: salesforceHandler,
+  servicenow: servicenowHandler,
   slack: slackHandler,
   stripe: stripeHandler,
   telegram: telegramHandler,

apps/sim/lib/webhooks/providers/servicenow.ts

@@ -0,0 +1,53 @@
+import { createLogger } from '@sim/logger'
+import { NextResponse } from 'next/server'
+import type { AuthContext, EventMatchContext, WebhookProviderHandler } from '@/lib/webhooks/providers/types'
+import { verifyTokenAuth } from '@/lib/webhooks/providers/utils'
+
+const logger = createLogger('WebhookProvider:ServiceNow')
+
+function asRecord(body: unknown): Record<string, unknown> {
+  return body && typeof body === 'object' && !Array.isArray(body)
+    ? (body as Record<string, unknown>)
+    : {}
+}
+
+export const servicenowHandler: WebhookProviderHandler = {
+  verifyAuth({ request, requestId, providerConfig }: AuthContext): NextResponse | null {
+    const secret = providerConfig.webhookSecret as string | undefined
+    if (!secret?.trim()) {
+      logger.warn(`[${requestId}] ServiceNow webhook missing webhookSecret — rejecting`)
+      return new NextResponse('Unauthorized - Webhook secret not configured', { status: 401 })
+    }
+
+    if (
+      !verifyTokenAuth(request, secret.trim(), 'x-sim-webhook-secret') &&
+      !verifyTokenAuth(request, secret.trim())
+    ) {
+      logger.warn(`[${requestId}] ServiceNow webhook secret verification failed`)
+      return new NextResponse('Unauthorized - Invalid webhook secret', { status: 401 })
+    }
+
+    return null
+  },
+
+  async matchEvent({ webhook, workflow, body, requestId, providerConfig }: EventMatchContext) {
+    const triggerId = providerConfig.triggerId as string | undefined
+    if (!triggerId) {
+      return true
+    }
+
+    const { isServiceNowEventMatch } = await import('@/triggers/servicenow/utils')
+    const configuredTableName = providerConfig.tableName as string | undefined
+    const obj = asRecord(body)
+
+    if (!isServiceNowEventMatch(triggerId, obj, configuredTableName)) {
+      logger.debug(
+        `[${requestId}] ServiceNow event mismatch for trigger ${triggerId}. Skipping execution.`,
+        { webhookId: webhook.id, workflowId: workflow.id, triggerId }
+      )
+      return false
+    }
+
+    return true
+  },
+}

apps/sim/triggers/servicenow/utils.ts

@@ -130,6 +130,137 @@ export function buildChangeRequestOutputs(): Record<string, TriggerOutput> {
   }
 }
 
+function normalizeToken(s: string): string {
+  return s.trim().toLowerCase().replace(/[\s-]+/g, '_')
+}
+
+/**
+ * Extracts the table name from a ServiceNow webhook payload.
+ * Business Rule scripts can send tableName in multiple formats.
+ */
+function extractTableName(body: Record<string, unknown>): string | undefined {
+  const candidates = [body.tableName, body.table_name, body.table, body.sys_class_name]
+  for (const c of candidates) {
+    if (typeof c === 'string' && c.trim()) {
+      return c.trim()
+    }
+  }
+  return undefined
+}
+
+/**
+ * Extracts the event type from a ServiceNow webhook payload.
+ */
+function extractEventType(body: Record<string, unknown>): string | undefined {
+  const candidates = [body.eventType, body.event_type, body.action, body.operation]
+  for (const c of candidates) {
+    if (typeof c === 'string' && c.trim()) {
+      return c.trim()
+    }
+  }
+  return undefined
+}
+
+const INCIDENT_CREATED = new Set([
+  'incident_created',
+  'insert',
+  'created',
+  'create',
+  'after_insert',
+  'afterinsert',
+])
+
+const INCIDENT_UPDATED = new Set([
+  'incident_updated',
+  'update',
+  'updated',
+  'after_update',
+  'afterupdate',
+])
+
+const CHANGE_REQUEST_CREATED = new Set([
+  'change_request_created',
+  'insert',
+  'created',
+  'create',
+  'after_insert',
+  'afterinsert',
+])
+
+const CHANGE_REQUEST_UPDATED = new Set([
+  'change_request_updated',
+  'update',
+  'updated',
+  'after_update',
+  'afterupdate',
+])
+
+/**
+ * Checks whether a ServiceNow webhook payload matches the configured trigger.
+ * Used by the ServiceNow provider handler to filter events at runtime.
+ */
+export function isServiceNowEventMatch(
+  triggerId: string,
+  body: Record<string, unknown>,
+  configuredTableName?: string
+): boolean {
+  const payloadTable = extractTableName(body)
+  const eventType = extractEventType(body)
+
+  if (triggerId === 'servicenow_webhook') {
+    if (!configuredTableName?.trim()) {
+      return true
+    }
+    if (!payloadTable) {
+      return true
+    }
+    return normalizeToken(payloadTable) === normalizeToken(configuredTableName)
+  }
+
+  if (triggerId === 'servicenow_incident_created' || triggerId === 'servicenow_incident_updated') {
+    if (configuredTableName?.trim()) {
+      if (payloadTable && normalizeToken(payloadTable) !== normalizeToken(configuredTableName)) {
+        return false
+      }
+    } else if (payloadTable && normalizeToken(payloadTable) !== 'incident') {
+      return false
+    }
+
+    if (!eventType) {
+      return true
+    }
+
+    const normalized = normalizeToken(eventType)
+    return triggerId === 'servicenow_incident_created'
+      ? INCIDENT_CREATED.has(normalized)
+      : INCIDENT_UPDATED.has(normalized)
+  }
+
+  if (
+    triggerId === 'servicenow_change_request_created' ||
+    triggerId === 'servicenow_change_request_updated'
+  ) {
+    if (configuredTableName?.trim()) {
+      if (payloadTable && normalizeToken(payloadTable) !== normalizeToken(configuredTableName)) {
+        return false
+      }
+    } else if (payloadTable && normalizeToken(payloadTable) !== 'change_request') {
+      return false
+    }
+
+    if (!eventType) {
+      return true
+    }
+
+    const normalized = normalizeToken(eventType)
+    return triggerId === 'servicenow_change_request_created'
+      ? CHANGE_REQUEST_CREATED.has(normalized)
+      : CHANGE_REQUEST_UPDATED.has(normalized)
+  }
+
+  return true
+}
+
 /**
  * Outputs for the generic webhook trigger (all events)
  */