betterstart-cli 0.0.28 → 0.0.30

package/dist/assets/adapters/next/templates/init/lib/actions/webhooks/get-webhook-subscriptions.ts

@@ -0,0 +1,32 @@
+'use server'
+
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { webhookSubscriptions } from '@admin/db/schema'
+import { cacheLife, cacheTag } from 'next/cache'
+import type { WebhookSubscriptionEntry } from './types'
+import { webhooksCacheTags } from './types'
+
+async function readWebhookSubscriptions(): Promise<WebhookSubscriptionEntry[]> {
+  'use cache'
+  cacheLife('max')
+  cacheTag(webhooksCacheTags.subscriptions)
+
+  return db
+    .select({
+      webhookId: webhookSubscriptions.webhookId,
+      event: webhookSubscriptions.event
+    })
+    .from(webhookSubscriptions)
+}
+
+export async function getWebhookSubscriptions(): Promise<WebhookSubscriptionEntry[]> {
+  await requireRole([UserRole.ADMIN])
+
+  try {
+    return await readWebhookSubscriptions()
+  } catch (error) {
+    console.error('Error fetching webhook subscriptions:', error)
+    return []
+  }
+}

package/dist/assets/adapters/next/templates/init/lib/actions/webhooks/get-webhooks.ts

@@ -0,0 +1,154 @@
+'use server'
+
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { webhookDeliveries, webhookSubscriptions, webhooks } from '@admin/db/schema'
+import { and, asc, count, desc, eq, gte, ilike, isNull, lt, or, sql } from 'drizzle-orm'
+import type { WebhooksPage, WebhooksQuery } from './types'
+
+function getExclusiveDateUpperBound(value?: string): string | null {
+  if (!value) return null
+
+  const date = new Date(`${value}T00:00:00.000Z`)
+  if (Number.isNaN(date.getTime())) return null
+
+  date.setUTCDate(date.getUTCDate() + 1)
+  return date.toISOString().slice(0, 10)
+}
+
+// Deliberately uncached: filters and sorting depend on delivery rows written
+// inside after(), where cache invalidation is unavailable, so cached reads
+// could never be refreshed.
+export async function getWebhooks(query?: WebhooksQuery): Promise<WebhooksPage> {
+  await requireRole([UserRole.ADMIN])
+
+  try {
+    const latestDeliveries = db
+      .selectDistinctOn([webhookDeliveries.webhookId], {
+        webhookId: webhookDeliveries.webhookId,
+        success: webhookDeliveries.success,
+        createdAt: webhookDeliveries.createdAt
+      })
+      .from(webhookDeliveries)
+      .orderBy(webhookDeliveries.webhookId, desc(webhookDeliveries.createdAt))
+      .as('latest_deliveries')
+    const subscriptionCounts = db
+      .select({
+        webhookId: webhookSubscriptions.webhookId,
+        eventCount: count().as('event_count')
+      })
+      .from(webhookSubscriptions)
+      .groupBy(webhookSubscriptions.webhookId)
+      .as('subscription_counts')
+    const eventCount = sql<number>`coalesce(${subscriptionCounts.eventCount}, 0)`
+
+    const conditions = []
+    const search = query?.search
+    if (search && typeof search === 'string' && search.trim()) {
+      const searchTerm = `%${search.trim().toLowerCase()}%`
+      conditions.push(or(ilike(webhooks.name, searchTerm), ilike(webhooks.url, searchTerm)))
+    }
+    if (query?.enabled !== undefined) {
+      conditions.push(eq(webhooks.enabled, query.enabled))
+    }
+    if (query?.lastDelivery === 'delivered') {
+      conditions.push(eq(latestDeliveries.success, true))
+    }
+    if (query?.lastDelivery === 'failed') {
+      conditions.push(eq(latestDeliveries.success, false))
+    }
+    if (query?.lastDelivery === 'never') {
+      conditions.push(isNull(latestDeliveries.webhookId))
+    }
+    if (query?.createdAtFrom) {
+      conditions.push(gte(webhooks.createdAt, query.createdAtFrom))
+    }
+    const createdAtExclusiveTo = getExclusiveDateUpperBound(query?.createdAtTo)
+    if (createdAtExclusiveTo) {
+      conditions.push(lt(webhooks.createdAt, createdAtExclusiveTo))
+    }
+
+    const baseQuery = db
+      .select({
+        id: webhooks.id,
+        name: webhooks.name,
+        url: webhooks.url,
+        enabled: webhooks.enabled,
+        createdAt: webhooks.createdAt,
+        updatedAt: webhooks.updatedAt,
+        eventCount,
+        lastDeliverySuccess: latestDeliveries.success,
+        lastDeliveryAt: latestDeliveries.createdAt
+      })
+      .from(webhooks)
+      .leftJoin(subscriptionCounts, eq(subscriptionCounts.webhookId, webhooks.id))
+      .leftJoin(latestDeliveries, eq(latestDeliveries.webhookId, webhooks.id))
+
+    const sortableColumns = {
+      name: webhooks.name,
+      url: webhooks.url,
+      enabled: webhooks.enabled,
+      createdAt: webhooks.createdAt,
+      updatedAt: webhooks.updatedAt,
+      eventCount,
+      lastDeliveryAt: latestDeliveries.createdAt
+    } as const
+    const sortColumn =
+      query?.orderBy && query.orderBy in sortableColumns
+        ? sortableColumns[query.orderBy as keyof typeof sortableColumns]
+        : webhooks.createdAt
+    const sortFn = query?.orderDirection === 'desc' ? desc : asc
+    const orderClause = sortFn(sortColumn)
+
+    const orderedQuery =
+      conditions.length > 0
+        ? baseQuery.where(and(...conditions)).orderBy(orderClause)
+        : baseQuery.orderBy(orderClause)
+
+    const rawLimit = query?.limit
+    const limit =
+      typeof rawLimit === 'number'
+        ? Number.isFinite(rawLimit)
+          ? Math.max(1, rawLimit)
+          : 1
+        : undefined
+    const rawOffset = query?.offset
+    const offset =
+      typeof rawOffset === 'number' && Number.isFinite(rawOffset) ? Math.max(0, rawOffset) : 0
+    const isPaginated = typeof limit === 'number'
+    const results = isPaginated
+      ? await (offset > 0 ? orderedQuery.limit(limit).offset(offset) : orderedQuery.limit(limit))
+      : await orderedQuery
+
+    const total = isPaginated
+      ? Number(
+          (
+            await db
+              .select({ count: sql`count(*)` })
+              .from(webhooks)
+              .leftJoin(subscriptionCounts, eq(subscriptionCounts.webhookId, webhooks.id))
+              .leftJoin(latestDeliveries, eq(latestDeliveries.webhookId, webhooks.id))
+              .where(conditions.length > 0 ? and(...conditions) : undefined)
+          )[0]?.count ?? 0
+        )
+      : results.length
+
+    return {
+      webhooks: results.map((row) => ({
+        id: row.id,
+        name: row.name,
+        url: row.url,
+        enabled: row.enabled,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        eventCount: Number(row.eventCount ?? 0),
+        lastDeliverySuccess: row.lastDeliverySuccess ?? null,
+        lastDeliveryAt: row.lastDeliveryAt ?? null
+      })),
+      total
+    }
+  } catch (error) {
+    console.error('Error fetching webhooks:', error)
+    throw new Error('Failed to fetch webhooks')
+  }
+}

package/dist/assets/adapters/next/templates/init/lib/actions/webhooks/index.ts

@@ -0,0 +1,30 @@
+// Client-safe barrel: only types and server actions. Server-only modules are
+// imported by path — emitWebhookEvent from './dispatch' and
+// registerWebhookHooks from './register' — so client components can import
+// this barrel without pulling node:crypto into the bundle.
+
+export { createWebhook } from './create-webhook'
+export { deleteWebhook } from './delete-webhook'
+export { getWebhookDeliveries } from './get-webhook-deliveries'
+export { getWebhookSecret } from './get-webhook-secret'
+export { getWebhookSubscriptions } from './get-webhook-subscriptions'
+export { getWebhooks } from './get-webhooks'
+export { regenerateWebhookSecret } from './regenerate-webhook-secret'
+export { sendTestWebhook } from './send-test-webhook'
+export type {
+  CreateWebhookInput,
+  SendTestWebhookResult,
+  UpdateWebhookInput,
+  WebhookDeliveriesPage,
+  WebhookDeliveriesQuery,
+  WebhookDeliveryEntry,
+  WebhookEndpointData,
+  WebhookEndpointListItem,
+  WebhookResult,
+  WebhookSecretResult,
+  WebhookSubscriptionEntry,
+  WebhooksPage,
+  WebhooksQuery
+} from './types'
+export { webhooksCacheTags } from './types'
+export { updateWebhook } from './update-webhook'

package/dist/assets/adapters/next/templates/init/lib/actions/webhooks/internal-get-active-endpoints.ts

@@ -0,0 +1,20 @@
+// Dispatcher-only read. Deliberately unguarded and uncached: it runs inside
+// `after()` where no session or cache scope is guaranteed. Never export this
+// from the actions barrel.
+import db from '@admin/db'
+import { webhookSubscriptions, webhooks } from '@admin/db/schema'
+import { and, eq } from 'drizzle-orm'
+
+export interface ActiveWebhookEndpoint {
+  id: string
+  url: string
+  secret: string
+}
+
+export async function getActiveEndpointsForEvent(event: string): Promise<ActiveWebhookEndpoint[]> {
+  return db
+    .select({ id: webhooks.id, url: webhooks.url, secret: webhooks.secret })
+    .from(webhookSubscriptions)
+    .innerJoin(webhooks, eq(webhookSubscriptions.webhookId, webhooks.id))
+    .where(and(eq(webhookSubscriptions.event, event), eq(webhooks.enabled, true)))
+}

package/dist/assets/adapters/next/templates/init/lib/actions/webhooks/regenerate-webhook-secret.ts

@@ -0,0 +1,35 @@
+'use server'
+
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { webhooks } from '@admin/db/schema'
+import { generateWebhookSecret } from '@admin/utils/webhook/signature'
+import { eq } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import type { WebhookSecretResult } from './types'
+import { webhooksCacheTags } from './types'
+
+export async function regenerateWebhookSecret(id: string): Promise<WebhookSecretResult> {
+  await requireRole([UserRole.ADMIN])
+
+  try {
+    const [row] = await db
+      .update(webhooks)
+      .set({
+        secret: generateWebhookSecret(),
+        updatedAt: new Date().toISOString()
+      })
+      .where(eq(webhooks.id, id))
+      .returning({ secret: webhooks.secret })
+
+    if (!row) return { success: false, error: 'Webhook not found' }
+    updateTag(webhooksCacheTags.endpoints)
+    return { success: true, secret: row.secret }
+  } catch (error) {
+    console.error('Error regenerating webhook secret:', error)
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to regenerate webhook secret'
+    }
+  }
+}

package/dist/assets/adapters/next/templates/init/lib/actions/webhooks/register.ts

@@ -0,0 +1,70 @@
+import { webhookEventSources } from '@admin/data/webhook-events'
+import { registerHook } from '@admin/lib/lifecycle-hooks/registry'
+import type {
+  AfterLifecycleHookEvent,
+  LifecycleHookContext
+} from '@admin/lib/lifecycle-hooks/types'
+import { emitWebhookEvent } from './dispatch'
+
+let webhookHooksRegistered = false
+
+const ENTITY_EVENT_HOOKS: Array<{
+  hook: AfterLifecycleHookEvent
+  suffix: string
+}> = [
+  { hook: 'afterCreate', suffix: 'created' },
+  { hook: 'afterUpdate', suffix: 'updated' },
+  { hook: 'afterDelete', suffix: 'deleted' },
+  { hook: 'afterPublish', suffix: 'published' },
+  { hook: 'afterUnpublish', suffix: 'unpublished' },
+  { hook: 'afterRestore', suffix: 'restored' },
+  { hook: 'afterReorder', suffix: 'reordered' }
+]
+
+function entityEventPayload(hook: AfterLifecycleHookEvent, context: LifecycleHookContext): unknown {
+  if (hook === 'afterRestore') {
+    return {
+      record: context.data ?? null,
+      restoredFromVersion: context.metadata?.restoredFromVersion ?? null
+    }
+  }
+  if (hook === 'afterDelete') {
+    return context.data ?? { id: context.entityId ?? null }
+  }
+  return context.data ?? null
+}
+
+export function registerWebhookHooks(): void {
+  if (webhookHooksRegistered) return
+  webhookHooksRegistered = true
+
+  for (const source of webhookEventSources) {
+    if (source.kind === 'entity') {
+      for (const { hook, suffix } of ENTITY_EVENT_HOOKS) {
+        const event = `${source.schema}.${suffix}`
+        if (!source.events.includes(event)) continue
+        registerHook(source.schema, hook, (context) => {
+          emitWebhookEvent(event, entityEventPayload(hook, context))
+        })
+      }
+      continue
+    }
+
+    if (source.kind === 'single') {
+      const event = `${source.schema}.updated`
+      if (!source.events.includes(event)) continue
+      const emitUpdated = (context: LifecycleHookContext) => {
+        emitWebhookEvent(event, context.data ?? null)
+      }
+      registerHook(source.schema, 'afterCreate', emitUpdated)
+      registerHook(source.schema, 'afterUpdate', emitUpdated)
+      continue
+    }
+
+    const event = source.events[0]
+    if (!event) continue
+    registerHook(source.schema, 'afterCreate', (context) => {
+      emitWebhookEvent(event, context.data ?? null)
+    })
+  }
+}

package/dist/assets/adapters/next/templates/init/lib/actions/webhooks/send-test-webhook.ts

@@ -0,0 +1,81 @@
+'use server'
+
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { webhooks } from '@admin/db/schema'
+import { createWebhookEventId, signWebhookPayload } from '@admin/utils/webhook/signature'
+import { eq } from 'drizzle-orm'
+import { recordWebhookDelivery } from './dispatch'
+import type { SendTestWebhookResult } from './types'
+
+const TEST_REQUEST_TIMEOUT_MS = 10_000
+
+export async function sendTestWebhook(id: string): Promise<SendTestWebhookResult> {
+  await requireRole([UserRole.ADMIN])
+
+  try {
+    const [endpoint] = await db
+      .select({ id: webhooks.id, url: webhooks.url, secret: webhooks.secret })
+      .from(webhooks)
+      .where(eq(webhooks.id, id))
+      .limit(1)
+
+    if (!endpoint) return { success: false, error: 'Webhook not found' }
+
+    const eventId = createWebhookEventId()
+    const body = JSON.stringify({
+      id: eventId,
+      event: 'webhook.test',
+      timestamp: new Date().toISOString(),
+      data: { message: 'This is a test webhook from BetterStart' }
+    })
+    const timestamp = Math.floor(Date.now() / 1000).toString()
+    const startedAt = Date.now()
+    let statusCode: number | null = null
+    let errorMessage: string | null = null
+
+    try {
+      const response = await fetch(endpoint.url, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+          'x-webhook-id': eventId,
+          'x-webhook-timestamp': timestamp,
+          'x-webhook-signature': signWebhookPayload(endpoint.secret, timestamp, body)
+        },
+        body,
+        signal: AbortSignal.timeout(TEST_REQUEST_TIMEOUT_MS)
+      })
+      statusCode = response.status
+      if (!response.ok) errorMessage = `Webhook returned status ${response.status}`
+    } catch (error) {
+      errorMessage = error instanceof Error ? error.message : 'Webhook request failed'
+    }
+
+    await recordWebhookDelivery({
+      webhookId: endpoint.id,
+      event: 'webhook.test',
+      eventId,
+      attempt: 1,
+      success: errorMessage === null,
+      statusCode,
+      durationMs: Date.now() - startedAt,
+      error: errorMessage
+    })
+
+    if (errorMessage !== null) {
+      return {
+        success: false,
+        ...(statusCode !== null ? { statusCode } : {}),
+        error: errorMessage
+      }
+    }
+    return { success: true, ...(statusCode !== null ? { statusCode } : {}) }
+  } catch (error) {
+    console.error('Error sending test webhook:', error)
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to send test webhook'
+    }
+  }
+}

package/dist/assets/adapters/next/templates/init/lib/actions/webhooks/types.ts

@@ -0,0 +1,104 @@
+export interface WebhookEndpointData {
+  id: string
+  name: string
+  url: string
+  enabled: boolean
+  createdAt: string
+  updatedAt: string
+}
+
+export interface WebhookEndpointListItem extends WebhookEndpointData {
+  eventCount: number
+  lastDeliverySuccess: boolean | null
+  lastDeliveryAt: string | null
+}
+
+export interface WebhooksQuery {
+  search?: string
+  enabled?: boolean
+  lastDelivery?: 'delivered' | 'failed' | 'never'
+  createdAtFrom?: string
+  createdAtTo?: string
+  limit?: number
+  offset?: number
+  orderBy?: string
+  orderDirection?: 'asc' | 'desc'
+}
+
+export interface WebhooksPage {
+  webhooks: WebhookEndpointListItem[]
+  total: number
+}
+
+export interface WebhookDeliveriesQuery {
+  search?: string
+  success?: boolean
+  webhookId?: string
+  createdAtFrom?: string
+  createdAtTo?: string
+  limit?: number
+  offset?: number
+  orderBy?: string
+  orderDirection?: 'asc' | 'desc'
+}
+
+export interface WebhookDeliveriesPage {
+  deliveries: WebhookDeliveryEntry[]
+  total: number
+}
+
+export interface CreateWebhookInput {
+  name: string
+  url: string
+  enabled: boolean
+  events: string[]
+}
+
+export interface UpdateWebhookInput {
+  name?: string
+  url?: string
+  enabled?: boolean
+  events?: string[]
+}
+
+export interface WebhookResult {
+  success: boolean
+  error?: string
+  webhook?: WebhookEndpointData
+}
+
+export interface WebhookSecretResult {
+  success: boolean
+  error?: string
+  secret?: string
+}
+
+export interface WebhookSubscriptionEntry {
+  webhookId: string
+  event: string
+}
+
+export interface WebhookDeliveryEntry {
+  id: string
+  webhookId: string
+  webhookName: string
+  event: string
+  eventId: string
+  attempt: number
+  success: boolean
+  statusCode: number | null
+  durationMs: number
+  error: string | null
+  createdAt: string
+}
+
+export interface SendTestWebhookResult {
+  success: boolean
+  statusCode?: number
+  error?: string
+}
+
+export const webhooksCacheTags = {
+  endpoints: 'webhooks:endpoints',
+  subscriptions: 'webhooks:subscriptions'
+} as const

package/dist/assets/adapters/next/templates/init/lib/actions/webhooks/update-webhook.ts

@@ -0,0 +1,72 @@
+'use server'
+
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { webhookSubscriptions, webhooks } from '@admin/db/schema'
+import { and, eq, notInArray } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import type { UpdateWebhookInput, WebhookResult } from './types'
+import { webhooksCacheTags } from './types'
+
+export async function updateWebhook(id: string, input: UpdateWebhookInput): Promise<WebhookResult> {
+  await requireRole([UserRole.ADMIN])
+
+  try {
+    const updated = await db.transaction(async (tx) => {
+      const [row] = await tx
+        .update(webhooks)
+        .set({
+          ...(input.name !== undefined ? { name: input.name } : {}),
+          ...(input.url !== undefined ? { url: input.url } : {}),
+          ...(input.enabled !== undefined ? { enabled: input.enabled } : {}),
+          updatedAt: new Date().toISOString()
+        })
+        .where(eq(webhooks.id, id))
+        .returning()
+
+      if (!row) throw new Error('Webhook not found')
+
+      if (input.events !== undefined) {
+        const events = input.events
+        if (events.length > 0) {
+          await tx
+            .delete(webhookSubscriptions)
+            .where(
+              and(
+                eq(webhookSubscriptions.webhookId, id),
+                notInArray(webhookSubscriptions.event, events)
+              )
+            )
+          await tx
+            .insert(webhookSubscriptions)
+            .values(events.map((event) => ({ webhookId: id, event })))
+            .onConflictDoNothing()
+        } else {
+          await tx.delete(webhookSubscriptions).where(eq(webhookSubscriptions.webhookId, id))
+        }
+      }
+
+      return row
+    })
+
+    updateTag(webhooksCacheTags.endpoints)
+    updateTag(webhooksCacheTags.subscriptions)
+    return {
+      success: true,
+      webhook: {
+        id: updated.id,
+        name: updated.name,
+        url: updated.url,
+        enabled: updated.enabled,
+        createdAt: updated.createdAt,
+        updatedAt: updated.updatedAt
+      }
+    }
+  } catch (error) {
+    console.error('Error updating webhook:', error)
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to update webhook'
+    }
+  }
+}

package/dist/assets/adapters/next/templates/init/lib/db/core/schema.ts

@@ -80,8 +80,6 @@ export const formSettings = pgTable(
   {
     id: uuid().defaultRandom().primaryKey().notNull(),
     formName: varchar('formName', { length: 100 }).notNull(),
-    webhookUrl: text('webhookUrl'),
-    webhookEnabled: boolean('webhookEnabled').default(false).notNull(),
     notificationEmails: text('notificationEmails'),
     createdAt: timestamp('createdAt', { precision: 3, mode: 'string' })
       .default(sql`CURRENT_TIMESTAMP`)
@@ -98,6 +96,77 @@ export const formSettings = pgTable(
   ]
 )
 
+// ============================================================================
+// Webhooks (endpoint registry, event subscriptions, delivery log)
+// ============================================================================
+
+export const webhooks = pgTable('Webhooks', {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  name: varchar('name', { length: 200 }).notNull(),
+  url: text('url').notNull(),
+  secret: text('secret').notNull(),
+  enabled: boolean('enabled').default(true).notNull(),
+  createdAt: timestamp('createdAt', { precision: 3, mode: 'string' })
+    .default(sql`CURRENT_TIMESTAMP`)
+    .notNull(),
+  updatedAt: timestamp('updatedAt', { precision: 3, mode: 'string' })
+    .default(sql`CURRENT_TIMESTAMP`)
+    .notNull()
+})
+
+export const webhookSubscriptions = pgTable(
+  'WebhookSubscriptions',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    webhookId: uuid('webhookId')
+      .notNull()
+      .references(() => webhooks.id, { onDelete: 'cascade' }),
+    event: varchar('event', { length: 200 }).notNull(),
+    createdAt: timestamp('createdAt', { precision: 3, mode: 'string' })
+      .default(sql`CURRENT_TIMESTAMP`)
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('WebhookSubscriptions_webhookId_event_key').using(
+      'btree',
+      table.webhookId.asc().nullsLast().op('uuid_ops'),
+      table.event.asc().nullsLast().op('text_ops')
+    ),
+    index('WebhookSubscriptions_event_idx').using(
+      'btree',
+      table.event.asc().nullsLast().op('text_ops')
+    )
+  ]
+)
+
+export const webhookDeliveries = pgTable(
+  'WebhookDeliveries',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    webhookId: uuid('webhookId')
+      .notNull()
+      .references(() => webhooks.id, { onDelete: 'cascade' }),
+    event: varchar('event', { length: 200 }).notNull(),
+    eventId: varchar('eventId', { length: 64 }).notNull(),
+    attempt: integer('attempt').notNull(),
+    success: boolean('success').notNull(),
+    statusCode: integer('statusCode'),
+    durationMs: integer('durationMs').notNull(),
+    error: text('error'),
+    createdAt: timestamp('createdAt', { precision: 3, mode: 'string' })
+      .default(sql`CURRENT_TIMESTAMP`)
+      .notNull()
+  },
+  (table) => [
+    index('WebhookDeliveries_webhookId_createdAt_idx').using(
+      'btree',
+      table.webhookId.asc().nullsLast().op('uuid_ops'),
+      table.createdAt.desc().nullsLast()
+    ),
+    index('WebhookDeliveries_createdAt_idx').using('btree', table.createdAt.desc().nullsLast())
+  ]
+)
+
 // ============================================================================
 // Entity Versions
 // ============================================================================