chore: import upstream snapshot with attribution

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

@@ -0,0 +1,190 @@
+import { createLogger } from '@sim/logger'
+import { safeCompare } from '@sim/security/compare'
+import { hmacSha256Hex } from '@sim/security/hmac'
+import { isRecordLike } from '@sim/utils/object'
+import type {
+  EventMatchContext,
+  FormatInputContext,
+  FormatInputResult,
+  WebhookProviderHandler,
+} from '@/lib/webhooks/providers/types'
+import { createHmacVerifier } from '@/lib/webhooks/providers/utils'
+
+const logger = createLogger('WebhookProvider:Jira')
+
+/**
+ * `changelog.items[].field` lists the Jira field names that changed in this
+ * update (only present on issue_updated deliveries). Empty filter list means
+ * no restriction — match on any field change.
+ */
+function matchesFieldFilters(body: Record<string, unknown>, fieldFilters: string): boolean {
+  const wanted = fieldFilters
+    .split(',')
+    .map((f) => f.trim().toLowerCase())
+    .filter(Boolean)
+  if (wanted.length === 0) return true
+
+  const changelog = body.changelog as Record<string, unknown> | undefined
+  const items = Array.isArray(changelog?.items) ? changelog.items : []
+  const changedFields = items
+    .map((item) => (isRecordLike(item) && typeof item.field === 'string' ? item.field : ''))
+    .map((f) => f.toLowerCase())
+
+  return wanted.some((field) => changedFields.includes(field))
+}
+
+export function validateJiraSignature(secret: string, signature: string, body: string): boolean {
+  try {
+    if (!secret || !signature || !body) {
+      logger.warn('Jira signature validation missing required fields', {
+        hasSecret: !!secret,
+        hasSignature: !!signature,
+        hasBody: !!body,
+      })
+      return false
+    }
+    if (!signature.startsWith('sha256=')) {
+      logger.warn('Jira signature has invalid format (expected sha256=)', {
+        signaturePrefix: signature.substring(0, 10),
+      })
+      return false
+    }
+    const providedSignature = signature.substring(7)
+    const computedHash = hmacSha256Hex(body, secret)
+    logger.debug('Jira signature comparison', {
+      computedLength: computedHash.length,
+      providedLength: providedSignature.length,
+    })
+    return safeCompare(computedHash, providedSignature)
+  } catch (error) {
+    logger.error('Error validating Jira signature:', error)
+    return false
+  }
+}
+
+export const jiraHandler: WebhookProviderHandler = {
+  verifyAuth: createHmacVerifier({
+    configKey: 'webhookSecret',
+    headerName: 'X-Hub-Signature',
+    validateFn: validateJiraSignature,
+    providerLabel: 'Jira',
+  }),
+
+  async formatInput({ body, webhook }: FormatInputContext): Promise<FormatInputResult> {
+    const {
+      extractIssueData,
+      extractCommentData,
+      extractWorklogData,
+      extractSprintData,
+      extractProjectData,
+      extractVersionData,
+    } = await import('@/triggers/jira/utils')
+    const providerConfig = (webhook.providerConfig as Record<string, unknown>) || {}
+    const triggerId = providerConfig.triggerId as string | undefined
+
+    if (
+      triggerId === 'jira_issue_commented' ||
+      triggerId === 'jira_comment_updated' ||
+      triggerId === 'jira_comment_deleted'
+    ) {
+      return { input: extractCommentData(body) }
+    }
+    if (
+      triggerId === 'jira_worklog_created' ||
+      triggerId === 'jira_worklog_updated' ||
+      triggerId === 'jira_worklog_deleted'
+    ) {
+      return { input: extractWorklogData(body) }
+    }
+    if (
+      triggerId === 'jira_sprint_created' ||
+      triggerId === 'jira_sprint_started' ||
+      triggerId === 'jira_sprint_closed'
+    ) {
+      return { input: extractSprintData(body) }
+    }
+    if (triggerId === 'jira_project_created') {
+      return { input: extractProjectData(body) }
+    }
+    if (triggerId === 'jira_version_released') {
+      return { input: extractVersionData(body) }
+    }
+
+    if (!triggerId || triggerId === 'jira_webhook') {
+      const obj = isRecordLike(body) ? body : {}
+      return {
+        input: {
+          webhookEvent: obj.webhookEvent,
+          timestamp: obj.timestamp,
+          user: obj.user || null,
+          issue_event_type_name: obj.issue_event_type_name,
+          issue: obj.issue || {},
+          changelog: obj.changelog,
+          comment: obj.comment,
+          worklog: obj.worklog,
+          sprint: obj.sprint,
+          project: obj.project,
+          version: obj.version,
+        },
+      }
+    }
+
+    return { input: extractIssueData(body) }
+  },
+
+  async matchEvent({ webhook, workflow, body, requestId, providerConfig }: EventMatchContext) {
+    const triggerId = providerConfig.triggerId as string | undefined
+    const obj = isRecordLike(body) ? body : {}
+
+    if (triggerId && triggerId !== 'jira_webhook') {
+      const webhookEvent = obj.webhookEvent as string | undefined
+      const issueEventTypeName = obj.issue_event_type_name as string | undefined
+
+      const { isJiraEventMatch } = await import('@/triggers/jira/utils')
+      if (!isJiraEventMatch(triggerId, webhookEvent || '', issueEventTypeName)) {
+        logger.debug(
+          `[${requestId}] Jira event mismatch for trigger ${triggerId}. Event: ${webhookEvent}. Skipping execution.`,
+          {
+            webhookId: webhook.id,
+            workflowId: workflow.id,
+            triggerId,
+            receivedEvent: webhookEvent,
+          }
+        )
+        return false
+      }
+
+      const fieldFilters = providerConfig.fieldFilters as string | undefined
+      if (
+        triggerId === 'jira_issue_updated' &&
+        fieldFilters &&
+        !matchesFieldFilters(obj, fieldFilters)
+      ) {
+        logger.debug(
+          `[${requestId}] Jira issue_updated field filter did not match for trigger ${triggerId}. Skipping execution.`,
+          { webhookId: webhook.id, workflowId: workflow.id, fieldFilters }
+        )
+        return false
+      }
+    }
+
+    return true
+  },
+
+  extractIdempotencyId(body: unknown) {
+    const obj = isRecordLike(body) ? body : {}
+    const issue = obj.issue as Record<string, unknown> | undefined
+    const comment = obj.comment as Record<string, unknown> | undefined
+    const worklog = obj.worklog as Record<string, unknown> | undefined
+    const project = obj.project as Record<string, unknown> | undefined
+    const sprint = obj.sprint as Record<string, unknown> | undefined
+    const version = obj.version as Record<string, unknown> | undefined
+    const entityId =
+      comment?.id || worklog?.id || issue?.id || project?.id || sprint?.id || version?.id
+    if (obj.webhookEvent && entityId) {
+      const ts = obj.timestamp ?? ''
+      return `${obj.webhookEvent}:${entityId}:${ts}`
+    }
+    return null
+  },
+}