@open-mercato/webhooks 0.8.1-develop.7228.1.b7ea09d2d3 → 0.8.1-develop.7237.1.635faf2c7a

package/src/modules/webhooks/lib/__tests__/subscription-cache-invalidation.test.ts

@@ -0,0 +1,207 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { createCacheService, type CacheStrategy } from '@open-mercato/cache'
+import {
+  getCachedActiveWebhooks,
+  invalidateWebhookSubscriptionCacheFor,
+  setCachedActiveWebhooks,
+} from '../subscription-cache'
+import { processWebhookDeliveryJob } from '../delivery'
+
+jest.mock('../../events', () => ({
+  emitWebhooksEvent: jest.fn(async () => undefined),
+}))
+
+jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
+  findOneWithDecryption: jest.fn(),
+}))
+
+jest.mock('../integration-state', () => ({
+  isWebhookIntegrationEnabled: jest.fn(async () => true),
+  WEBHOOK_INTEGRATION_DISABLED_MESSAGE: 'disabled',
+}))
+
+jest.mock('@open-mercato/shared/lib/webhooks', () => ({
+  buildWebhookHeaders: jest.fn(() => ({})),
+  generateMessageId: jest.fn(() => 'msg-1'),
+}))
+
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+
+const findOneWithDecryptionMock = findOneWithDecryption as jest.MockedFunction<typeof findOneWithDecryption>
+
+async function seed(cache: CacheStrategy): Promise<void> {
+  await setCachedActiveWebhooks(
+    cache,
+    'tenant-1',
+    'org-1',
+    [{ id: 'w-1', tenantId: 'tenant-1', organizationId: 'org-1', subscribedEvents: ['a.b.c'] }],
+    60_000,
+  )
+}
+
+describe('invalidateWebhookSubscriptionCacheFor', () => {
+  it('accepts a bare resolve function', async () => {
+    const cache = createCacheService({ strategy: 'memory' })
+    await seed(cache)
+    await invalidateWebhookSubscriptionCacheFor((token: string) => (token === 'cache' ? cache : null), 'tenant-1')
+    expect(await getCachedActiveWebhooks(cache, 'tenant-1', 'org-1')).toBeNull()
+  })
+
+  it('accepts a container', async () => {
+    const cache = createCacheService({ strategy: 'memory' })
+    await seed(cache)
+    await invalidateWebhookSubscriptionCacheFor({ resolve: (token: string) => (token === 'cache' ? cache : null) }, 'tenant-1')
+    expect(await getCachedActiveWebhooks(cache, 'tenant-1', 'org-1')).toBeNull()
+  })
+
+  it('is a no-op when no cache resolves, when the resolver throws, and when the tenant is missing', async () => {
+    const cache = createCacheService({ strategy: 'memory' })
+    await seed(cache)
+
+    await expect(invalidateWebhookSubscriptionCacheFor(undefined, 'tenant-1')).resolves.toBeUndefined()
+    await expect(invalidateWebhookSubscriptionCacheFor(() => null, 'tenant-1')).resolves.toBeUndefined()
+    await expect(invalidateWebhookSubscriptionCacheFor(() => { throw new Error('unavailable') }, 'tenant-1')).resolves.toBeUndefined()
+    await expect(invalidateWebhookSubscriptionCacheFor({ resolve: () => cache }, '  ')).resolves.toBeUndefined()
+
+    expect(await getCachedActiveWebhooks(cache, 'tenant-1', 'org-1')).not.toBeNull()
+  })
+
+  it('swallows a cache backend failure instead of throwing', async () => {
+    const brokenCache = {
+      get: jest.fn(async () => null),
+      set: jest.fn(async () => undefined),
+      deleteByTags: jest.fn(async () => { throw new Error('redis down') }),
+    }
+    await expect(invalidateWebhookSubscriptionCacheFor(() => brokenCache, 'tenant-1')).resolves.toBeUndefined()
+    expect(brokenCache.deleteByTags).toHaveBeenCalled()
+  })
+})
+
+describe('processWebhookDeliveryJob auto-disable invalidates the subscription cache', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    process.env.OM_WEBHOOKS_ALLOW_PRIVATE_URLS = '1'
+    globalThis.fetch = jest.fn(async () => new Response('nope', { status: 500 })) as unknown as typeof fetch
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    delete process.env.OM_WEBHOOKS_ALLOW_PRIVATE_URLS
+  })
+
+  function buildDelivery() {
+    return {
+      id: 'delivery-1',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      webhookId: 'w-1',
+      status: 'pending',
+      payload: { type: 'a.b.c', timestamp: new Date().toISOString(), data: {} },
+      enqueuedAt: new Date(),
+      eventType: 'a.b.c',
+      maxAttempts: 1,
+      attemptNumber: 0,
+      messageId: 'msg-1',
+      responseBody: null,
+      responseHeaders: null,
+      responseStatus: null,
+      nextRetryAt: null,
+      errorMessage: null,
+      lastAttemptAt: null,
+      deliveredAt: null,
+      durationMs: null,
+    }
+  }
+
+  function buildWebhook(autoDisableThreshold: number) {
+    return {
+      id: 'w-1',
+      url: 'http://127.0.0.1:3001/hook',
+      isActive: true,
+      timeoutMs: 1000,
+      httpMethod: 'POST',
+      customHeaders: null,
+      consecutiveFailures: 0,
+      lastFailureAt: null,
+      lastSuccessAt: null,
+      autoDisableThreshold,
+      maxRetries: 1,
+      secret: 'secret',
+      previousSecret: null,
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+    }
+  }
+
+  function buildEm(delivery: Record<string, unknown>) {
+    return {
+      findOne: jest.fn(async () => delivery),
+      flush: jest.fn(async () => undefined),
+    } as unknown as EntityManager
+  }
+
+  it('drops the cached tenant list when the webhook is auto-disabled', async () => {
+    const cache = createCacheService({ strategy: 'memory' })
+    await seed(cache)
+
+    const webhook = buildWebhook(1)
+    findOneWithDecryptionMock.mockResolvedValueOnce(webhook as never)
+
+    await processWebhookDeliveryJob(buildEm(buildDelivery()), {
+      deliveryId: 'delivery-1',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+    }, { scheduleRetries: false, resolver: () => cache })
+
+    expect(webhook.isActive).toBe(false)
+    expect(await getCachedActiveWebhooks(cache, 'tenant-1', 'org-1')).toBeNull()
+  })
+
+  it('commits isActive=false before emitting and invalidating, so no concurrent read can repopulate a stale entry', async () => {
+    const webhook = buildWebhook(1)
+    const delivery = buildDelivery()
+    const calls: string[] = []
+
+    const cache = {
+      get: jest.fn(async () => null),
+      set: jest.fn(async () => undefined),
+      deleteByTags: jest.fn(async () => { calls.push('deleteByTags') }),
+    }
+    const em = {
+      findOne: jest.fn(async () => delivery),
+      flush: jest.fn(async () => { calls.push(`flush:isActive=${webhook.isActive}`) }),
+    } as unknown as EntityManager
+
+    findOneWithDecryptionMock.mockResolvedValueOnce(webhook as never)
+
+    await processWebhookDeliveryJob(em, {
+      deliveryId: 'delivery-1',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+    }, { scheduleRetries: false, resolver: () => cache })
+
+    const invalidateIndex = calls.indexOf('deleteByTags')
+    expect(invalidateIndex).toBeGreaterThan(-1)
+    expect(calls.slice(0, invalidateIndex)).toContain('flush:isActive=false')
+    expect(calls.slice(invalidateIndex)).not.toContain('flush:isActive=true')
+  })
+
+  it('keeps the cached tenant list when the failure does not trip auto-disable', async () => {
+    const cache = createCacheService({ strategy: 'memory' })
+    await seed(cache)
+
+    const webhook = buildWebhook(0)
+    findOneWithDecryptionMock.mockResolvedValueOnce(webhook as never)
+
+    await processWebhookDeliveryJob(buildEm(buildDelivery()), {
+      deliveryId: 'delivery-1',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+    }, { scheduleRetries: false, resolver: () => cache })
+
+    expect(webhook.isActive).toBe(true)
+    expect(await getCachedActiveWebhooks(cache, 'tenant-1', 'org-1')).not.toBeNull()
+  })
+})

package/src/modules/webhooks/lib/delivery.ts

@@ -11,6 +11,10 @@ import {
   safeWebhookFetch,
   UnsafeWebhookUrlError,
 } from './url-safety'
+import {
+  invalidateWebhookSubscriptionCacheFor,
+  type WebhookCacheDependencyResolver,
+} from './subscription-cache'
 
 export interface WebhookDeliveryJob {
   deliveryId: string
@@ -27,6 +31,7 @@ export interface CreateWebhookDeliveryInput {
 
 type ProcessWebhookDeliveryOptions = {
   scheduleRetries?: boolean
+  resolver?: WebhookCacheDependencyResolver
 }
 
 type WebhookBody = {
@@ -211,6 +216,7 @@ export async function processWebhookDeliveryJob(
       delivery,
       canRetry: shouldRetryStatus(response.status),
       scheduleRetries: options.scheduleRetries !== false,
+      resolver: options.resolver,
       fallbackMessage: `HTTP ${response.status}`,
     })
 
@@ -254,6 +260,7 @@ export async function processWebhookDeliveryJob(
       delivery,
       canRetry: true,
       scheduleRetries: options.scheduleRetries !== false,
+      resolver: options.resolver,
       fallbackMessage: delivery.errorMessage,
     })
 
@@ -318,6 +325,7 @@ type HandleFailedDeliveryInput = {
   canRetry: boolean
   scheduleRetries: boolean
   fallbackMessage: string
+  resolver?: WebhookCacheDependencyResolver
 }
 
 async function handleFailedDelivery(input: HandleFailedDeliveryInput): Promise<void> {
@@ -364,17 +372,19 @@ async function handleFailedDelivery(input: HandleFailedDeliveryInput): Promise<v
     })
   }
 
+  await input.em.flush()
+
   if (webhook.autoDisableThreshold > 0 && webhook.consecutiveFailures >= webhook.autoDisableThreshold) {
     webhook.isActive = false
+    await input.em.flush()
     await emitWebhooksEvent('webhooks.webhook.disabled', {
       webhookId: webhook.id,
       organizationId: webhook.organizationId,
       tenantId: webhook.tenantId,
       consecutiveFailures: webhook.consecutiveFailures,
     })
+    await invalidateWebhookSubscriptionCacheFor(input.resolver, webhook.tenantId)
   }
-
-  await input.em.flush()
 }
 
 function normalizeWebhookBody(eventType: string, payload: Record<string, unknown>): WebhookBody {

package/src/modules/webhooks/lib/queue.ts

@@ -48,7 +48,7 @@ async function ensureLocalWebhookQueueWorkerStarted(): Promise<void> {
 
       const container = await createRequestContainer()
       const em = (container.resolve('em') as EntityManager).fork()
-      await processWebhookDeliveryJob(em, job.payload)
+      await processWebhookDeliveryJob(em, job.payload, { resolver: container })
     })
   })().catch((error) => {
     delete globalStore[LOCAL_WORKER_PROMISE_KEY]

package/src/modules/webhooks/lib/subscription-cache.ts

@@ -0,0 +1,135 @@
+import type { CacheStrategy } from '@open-mercato/cache'
+import { runWithCacheTenant } from '@open-mercato/cache'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('webhooks').child({ component: 'subscription-cache' })
+
+const DEFAULT_TTL_MS = 60_000
+const GLOBAL_SCOPE_SEGMENT = 'global'
+
+export type CachedActiveWebhook = {
+  id: string
+  tenantId: string
+  organizationId: string | null
+  subscribedEvents: string[]
+}
+
+export type WebhookSubscriptionCache = Pick<CacheStrategy, 'get' | 'set' | 'deleteByTags'>
+
+export function isWebhookSubscriptionCache(value: unknown): value is WebhookSubscriptionCache {
+  if (!value || typeof value !== 'object') return false
+  const candidate = value as Partial<WebhookSubscriptionCache>
+  return (
+    typeof candidate.get === 'function'
+    && typeof candidate.set === 'function'
+    && typeof candidate.deleteByTags === 'function'
+  )
+}
+
+export type WebhookCacheDependencyResolver =
+  | ((token: string) => unknown)
+  | { resolve: (token: string) => unknown }
+
+export function resolveWebhookSubscriptionCache(resolve: (token: string) => unknown): WebhookSubscriptionCache | null {
+  try {
+    const cache = resolve('cache')
+    return isWebhookSubscriptionCache(cache) ? cache : null
+  } catch {
+    return null
+  }
+}
+
+function toResolveFunction(source: WebhookCacheDependencyResolver | null | undefined): ((token: string) => unknown) | null {
+  if (typeof source === 'function') return source
+  if (source && typeof source.resolve === 'function') return source.resolve.bind(source)
+  return null
+}
+
+export function getWebhookSubscriptionCacheTtlMs(): number {
+  const raw = process.env.OM_WEBHOOKS_SUBSCRIPTION_CACHE_TTL_MS
+  if (raw === undefined || raw.trim() === '') return DEFAULT_TTL_MS
+  const parsed = Number.parseInt(raw, 10)
+  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_TTL_MS
+  return parsed
+}
+
+function normalizeScopeSegment(organizationId: string | null | undefined): string {
+  return organizationId ?? GLOBAL_SCOPE_SEGMENT
+}
+
+export function getWebhookSubscriptionCacheKey(tenantId: string, organizationId: string | null | undefined): string {
+  return `webhooks:subscriptions:${tenantId}:${normalizeScopeSegment(organizationId)}`
+}
+
+export function getWebhookSubscriptionCacheTag(tenantId: string): string {
+  return `webhooks:subscriptions:tenant:${tenantId}`
+}
+
+function isCachedActiveWebhookList(value: unknown): value is CachedActiveWebhook[] {
+  return Array.isArray(value) && value.every((entry) => (
+    entry !== null
+    && typeof entry === 'object'
+    && typeof (entry as CachedActiveWebhook).id === 'string'
+    && typeof (entry as CachedActiveWebhook).tenantId === 'string'
+    && Array.isArray((entry as CachedActiveWebhook).subscribedEvents)
+  ))
+}
+
+export async function getCachedActiveWebhooks(
+  cache: WebhookSubscriptionCache | null,
+  tenantId: string,
+  organizationId: string | null | undefined,
+): Promise<CachedActiveWebhook[] | null> {
+  if (!cache) return null
+  try {
+    const value = await runWithCacheTenant(tenantId, () => cache.get(getWebhookSubscriptionCacheKey(tenantId, organizationId)))
+    return isCachedActiveWebhookList(value) ? value : null
+  } catch (error) {
+    logger.warn('Failed to read webhook subscription cache', { err: error })
+    return null
+  }
+}
+
+export async function setCachedActiveWebhooks(
+  cache: WebhookSubscriptionCache | null,
+  tenantId: string,
+  organizationId: string | null | undefined,
+  webhooks: CachedActiveWebhook[],
+  ttlMs: number,
+): Promise<void> {
+  if (!cache || ttlMs <= 0) return
+  try {
+    await runWithCacheTenant(tenantId, () => cache.set(
+      getWebhookSubscriptionCacheKey(tenantId, organizationId),
+      webhooks,
+      { ttl: ttlMs, tags: [getWebhookSubscriptionCacheTag(tenantId)] },
+    ))
+  } catch (error) {
+    logger.warn('Failed to write webhook subscription cache', { err: error })
+  }
+}
+
+export async function invalidateWebhookSubscriptionCache(
+  cache: WebhookSubscriptionCache | null,
+  tenantId: string | null | undefined,
+): Promise<void> {
+  if (!cache) return
+  const normalizedTenantId = tenantId?.trim()
+  if (!normalizedTenantId) return
+  try {
+    await runWithCacheTenant(normalizedTenantId, () => cache.deleteByTags([getWebhookSubscriptionCacheTag(normalizedTenantId)]))
+  } catch (error) {
+    logger.warn('Failed to invalidate webhook subscription cache', { err: error })
+  }
+}
+
+export async function invalidateWebhookSubscriptionCacheFor(
+  source: WebhookCacheDependencyResolver | null | undefined,
+  tenantId: string | null | undefined,
+): Promise<void> {
+  const normalizedTenantId = tenantId?.trim()
+  if (!normalizedTenantId) return
+  const resolve = toResolveFunction(source)
+  if (!resolve) return
+  await invalidateWebhookSubscriptionCache(resolveWebhookSubscriptionCache(resolve), normalizedTenantId)
+}