betterstart-cli 0.0.28 → 0.0.30

package/dist/assets/adapters/next/templates/init/components/shared/page-header.tsx

@@ -23,7 +23,7 @@ export function PageHeader({
 
   return (
     <>
-      <header className="fixed top-0 border-t right-0 left-(--admin-shell-content-left) z-20 grid h-14 grid-cols-[minmax(0,1fr)_auto_minmax(0,1fr)] items-center border-b border-border/80 px-4 bg-sidebar transition-[left] duration-200 ease-linear">
+      <header className="fixed z-200 top-0 border-t right-0 left-(--admin-shell-content-left) grid h-14 grid-cols-[minmax(0,1fr)_auto_minmax(0,1fr)] items-center border-b border-border/80 px-4 bg-sidebar transition-[left] duration-200 ease-linear">
         <div className="flex w-full items-center justify-start gap-2">
           {hasBackButton && (
             <Button variant="ghost" size="icon" onClick={() => router.back()}>

package/dist/assets/adapters/next/templates/init/data/webhook-events.ts

@@ -0,0 +1,5 @@
+import type { WebhookEventSource } from '@admin/types/webhooks'
+
+export type { WebhookEventSource } from '@admin/types/webhooks'
+
+export const webhookEventSources: WebhookEventSource[] = []

package/dist/assets/adapters/next/templates/init/hooks/use-table-utils.ts

@@ -174,15 +174,35 @@ export function useTableUtils<TData extends RowData>({
     setColumnSizing((current) => {
       const next: ColumnSizingState = {}
       let changed = Object.keys(current).length !== baseColumns.length
+      const targetTotal = Math.round(Math.max(containerWidth, fixedTotal + flexibleMinTotal))
+      const flexibleSizing = flexibleColumns.map((column) => {
+        const columnShrinkRoom = Math.max(column.size - column.minSize, 0)
+        const shrink = shrinkRoom > 0 ? shrinkNeeded * (columnShrinkRoom / shrinkRoom) : 0
+        const grow = extraPerColumn
+        return {
+          id: column.id,
+          size: Math.round(column.size + grow - shrink)
+        }
+      })
+      const flexibleSizingById = new Map(flexibleSizing.map((column) => [column.id, column.size]))
+      const roundedFixedTotal = baseColumns
+        .filter((column) => !flexibleColumnIds.has(column.id))
+        .reduce((total, column) => total + Math.round(column.size), 0)
+      const roundedFlexibleTotal = flexibleSizing.reduce((total, column) => total + column.size, 0)
+      const roundingDelta = targetTotal - roundedFixedTotal - roundedFlexibleTotal
+      const lastFlexibleColumn = flexibleSizing.at(-1)
+
+      if (lastFlexibleColumn) {
+        flexibleSizingById.set(
+          lastFlexibleColumn.id,
+          Math.max(lastFlexibleColumn.size + roundingDelta, 0)
+        )
+      }
 
       for (const column of baseColumns) {
-        const columnShrinkRoom = Math.max(column.size - column.minSize, 0)
-        const shrink =
-          flexibleColumnIds.has(column.id) && shrinkRoom > 0
-            ? shrinkNeeded * (columnShrinkRoom / shrinkRoom)
-            : 0
-        const grow = flexibleColumnIds.has(column.id) ? extraPerColumn : 0
-        const size = Math.round(column.size + grow - shrink)
+        const size = flexibleColumnIds.has(column.id)
+          ? (flexibleSizingById.get(column.id) ?? Math.round(column.size))
+          : Math.round(column.size)
         next[column.id] = size
         if (current[column.id] !== size) {
           changed = true

package/dist/assets/adapters/next/templates/init/hooks/use-webhooks.ts

@@ -0,0 +1,211 @@
+'use client'
+
+import type { FormSettingsData } from '@admin/actions/forms'
+import { getAllFormSettings } from '@admin/actions/forms'
+import type {
+  WebhookDeliveriesPage,
+  WebhookDeliveriesQuery,
+  WebhookSubscriptionEntry,
+  WebhooksPage,
+  WebhooksQuery
+} from '@admin/actions/webhooks'
+import {
+  getWebhookDeliveries,
+  getWebhookSubscriptions,
+  getWebhooks,
+  sendTestWebhook,
+  updateWebhook
+} from '@admin/actions/webhooks'
+import { type UseQueryResult, useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import { toast } from 'sonner'
+
+export function useWebhooks(
+  search?: string,
+  enabled?: string,
+  lastDelivery?: string,
+  createdAtFrom?: string,
+  createdAtTo?: string,
+  page?: number,
+  pageSize?: number,
+  orderBy?: string,
+  orderDirection?: 'asc' | 'desc',
+  options?: { enabled?: boolean }
+): UseQueryResult<WebhooksPage, Error> {
+  const safePage = Number.isFinite(page ?? 0) && (page ?? 0) > 0 ? (page ?? 0) : 0
+  const safePageSize =
+    pageSize === -1 || (Number.isFinite(pageSize ?? 20) && (pageSize ?? 20) > 0)
+      ? (pageSize ?? 20)
+      : 20
+
+  return useQuery({
+    queryKey: [
+      'webhooks',
+      search ?? '',
+      enabled ?? '',
+      lastDelivery ?? '',
+      createdAtFrom ?? '',
+      createdAtTo ?? '',
+      safePage,
+      safePageSize,
+      orderBy ?? '',
+      orderDirection ?? ''
+    ],
+    queryFn: () => {
+      const filters: WebhooksQuery = {}
+      if (search) filters.search = search
+      if (enabled === 'enabled') filters.enabled = true
+      if (enabled === 'disabled') filters.enabled = false
+      if (lastDelivery === 'delivered' || lastDelivery === 'failed' || lastDelivery === 'never') {
+        filters.lastDelivery = lastDelivery
+      }
+      if (createdAtFrom) filters.createdAtFrom = createdAtFrom
+      if (createdAtTo) filters.createdAtTo = createdAtTo
+      if (safePageSize !== -1) {
+        filters.limit = safePageSize
+        filters.offset = safePage * safePageSize
+      }
+      if (orderBy) filters.orderBy = orderBy
+      if (orderDirection) filters.orderDirection = orderDirection
+      return getWebhooks(Object.keys(filters).length > 0 ? filters : undefined)
+    },
+    enabled: options?.enabled ?? true
+  })
+}
+
+export function useWebhookOptions(): UseQueryResult<WebhooksPage, Error> {
+  return useQuery({
+    queryKey: ['webhooks', 'options'],
+    queryFn: () => getWebhooks()
+  })
+}
+
+export function useToggleWebhookEnabled() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: async (input: { id: string; enabled: boolean }) => {
+      const result = await updateWebhook(input.id, { enabled: input.enabled })
+      if (!result.success) {
+        throw new Error(result.error || 'Failed to update webhook')
+      }
+
+      return result
+    },
+    onMutate: async (input) => {
+      await queryClient.cancelQueries({ queryKey: ['webhooks'] })
+      const previous = queryClient.getQueriesData<WebhooksPage>({
+        queryKey: ['webhooks']
+      })
+      queryClient.setQueriesData<WebhooksPage>({ queryKey: ['webhooks'] }, (page) =>
+        page
+          ? {
+              ...page,
+              webhooks: page.webhooks.map((webhook) =>
+                webhook.id === input.id ? { ...webhook, enabled: input.enabled } : webhook
+              )
+            }
+          : page
+      )
+      return { previous }
+    },
+    onError: (error: Error, _input, context) => {
+      for (const [queryKey, data] of context?.previous ?? []) {
+        queryClient.setQueryData(queryKey, data)
+      }
+      toast.error(error.message || 'Failed to update webhook')
+    },
+    onSettled: async () => {
+      await queryClient.invalidateQueries({ queryKey: ['webhooks'] })
+    }
+  })
+}
+
+export function useSendTestWebhook() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: async (id: string) => {
+      const result = await sendTestWebhook(id)
+      if (!result.success) {
+        throw new Error(result.error || 'Test webhook failed')
+      }
+
+      return result
+    },
+    onSuccess: async (result) => {
+      toast.success(
+        result.statusCode ? `Test delivered (status ${result.statusCode})` : 'Test delivered'
+      )
+      await queryClient.invalidateQueries({ queryKey: ['webhook-deliveries'] })
+      await queryClient.invalidateQueries({ queryKey: ['webhooks'] })
+    },
+    onError: async (error: Error) => {
+      toast.error(error.message || 'Test webhook failed')
+      await queryClient.invalidateQueries({ queryKey: ['webhook-deliveries'] })
+      await queryClient.invalidateQueries({ queryKey: ['webhooks'] })
+    }
+  })
+}
+
+export function useWebhookSubscriptions() {
+  return useQuery<WebhookSubscriptionEntry[]>({
+    queryKey: ['webhook-subscriptions'],
+    queryFn: () => getWebhookSubscriptions()
+  })
+}
+
+export function useWebhookDeliveries(
+  search?: string,
+  status?: string,
+  endpoint?: string,
+  createdAtFrom?: string,
+  createdAtTo?: string,
+  page?: number,
+  pageSize?: number,
+  orderBy?: string,
+  orderDirection?: 'asc' | 'desc'
+): UseQueryResult<WebhookDeliveriesPage, Error> {
+  const safePage = Number.isFinite(page ?? 0) && (page ?? 0) > 0 ? (page ?? 0) : 0
+  const safePageSize =
+    pageSize === -1 || (Number.isFinite(pageSize ?? 20) && (pageSize ?? 20) > 0)
+      ? (pageSize ?? 20)
+      : 20
+
+  return useQuery({
+    queryKey: [
+      'webhook-deliveries',
+      search ?? '',
+      status ?? '',
+      endpoint ?? '',
+      createdAtFrom ?? '',
+      createdAtTo ?? '',
+      safePage,
+      safePageSize,
+      orderBy ?? '',
+      orderDirection ?? ''
+    ],
+    queryFn: () => {
+      const filters: WebhookDeliveriesQuery = {}
+      if (search) filters.search = search
+      if (status === 'success') filters.success = true
+      if (status === 'failed') filters.success = false
+      if (endpoint) filters.webhookId = endpoint
+      if (createdAtFrom) filters.createdAtFrom = createdAtFrom
+      if (createdAtTo) filters.createdAtTo = createdAtTo
+      if (safePageSize !== -1) {
+        filters.limit = safePageSize
+        filters.offset = safePage * safePageSize
+      }
+      if (orderBy) filters.orderBy = orderBy
+      if (orderDirection) filters.orderDirection = orderDirection
+      return getWebhookDeliveries(Object.keys(filters).length > 0 ? filters : undefined)
+    }
+  })
+}
+
+export function useFormSettingsList() {
+  return useQuery<FormSettingsData[]>({
+    queryKey: ['form-settings'],
+    queryFn: () => getAllFormSettings()
+  })
+}

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

@@ -13,6 +13,8 @@ export const AUDIT_LOG_ACTIONS = [
   'delete',
   'publish',
   'unpublish',
+  'restore',
+  'reorder',
   'cleanup'
 ] as const
 export const AUDIT_LOG_SOURCE_TYPES = ['admin_ui', 'server_action', 'system_job'] as const

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

@@ -1,6 +1,5 @@
 export { getAllFormSettings } from './get-all-form-settings'
 export { getFormSettings } from './get-form-settings'
-export { testFormWebhook } from './test-form-webhook'
 export type {
   FormSettingsData,
   FormSettingsResult,

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

@@ -1,16 +1,12 @@
 export interface FormSettingsData {
   id: string
   formName: string
-  webhookUrl: string | null
-  webhookEnabled: boolean
   notificationEmails: string | null
   createdAt: string
   updatedAt: string
 }
 
 export interface UpsertFormSettingsInput {
-  webhookUrl?: string | null
-  webhookEnabled?: boolean
   notificationEmails?: string | null
 }
 

package/dist/assets/adapters/next/templates/init/lib/actions/forms/upsert-form-settings.ts

@@ -18,8 +18,6 @@ export async function upsertFormSettings(
       .insert(formSettings)
       .values({
         formName,
-        webhookUrl: data.webhookUrl ?? null,
-        webhookEnabled: data.webhookEnabled ?? false,
         notificationEmails: data.notificationEmails ?? null
       })
       .onConflictDoUpdate({

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

@@ -0,0 +1,55 @@
+'use server'
+
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { webhookSubscriptions, webhooks } from '@admin/db/schema'
+import { generateWebhookSecret } from '@admin/utils/webhook/signature'
+import { updateTag } from 'next/cache'
+import type { CreateWebhookInput, WebhookResult } from './types'
+import { webhooksCacheTags } from './types'
+
+export async function createWebhook(input: CreateWebhookInput): Promise<WebhookResult> {
+  await requireRole([UserRole.ADMIN])
+
+  try {
+    const created = await db.transaction(async (tx) => {
+      const [row] = await tx
+        .insert(webhooks)
+        .values({
+          name: input.name,
+          url: input.url,
+          secret: generateWebhookSecret(),
+          enabled: input.enabled
+        })
+        .returning()
+
+      if (input.events.length > 0) {
+        await tx
+          .insert(webhookSubscriptions)
+          .values(input.events.map((event) => ({ webhookId: row.id, event })))
+      }
+
+      return row
+    })
+
+    updateTag(webhooksCacheTags.endpoints)
+    updateTag(webhooksCacheTags.subscriptions)
+    return {
+      success: true,
+      webhook: {
+        id: created.id,
+        name: created.name,
+        url: created.url,
+        enabled: created.enabled,
+        createdAt: created.createdAt,
+        updatedAt: created.updatedAt
+      }
+    }
+  } catch (error) {
+    console.error('Error creating webhook:', error)
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to create webhook'
+    }
+  }
+}

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

@@ -0,0 +1,26 @@
+'use server'
+
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { webhooks } from '@admin/db/schema'
+import { eq } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import type { WebhookResult } from './types'
+import { webhooksCacheTags } from './types'
+
+export async function deleteWebhook(id: string): Promise<WebhookResult> {
+  await requireRole([UserRole.ADMIN])
+
+  try {
+    await db.delete(webhooks).where(eq(webhooks.id, id))
+    updateTag(webhooksCacheTags.endpoints)
+    updateTag(webhooksCacheTags.subscriptions)
+    return { success: true }
+  } catch (error) {
+    console.error('Error deleting webhook:', error)
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to delete webhook'
+    }
+  }
+}

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

@@ -0,0 +1,135 @@
+import db from '@admin/db'
+import { webhookDeliveries } from '@admin/db/schema'
+import { createWebhookEventId, signWebhookPayload } from '@admin/utils/webhook/signature'
+import { and, desc, eq, notInArray } from 'drizzle-orm'
+import { after } from 'next/server'
+import type { ActiveWebhookEndpoint } from './internal-get-active-endpoints'
+import { getActiveEndpointsForEvent } from './internal-get-active-endpoints'
+
+const MAX_ATTEMPTS = 3
+const RETRY_DELAYS_MS = [1_000, 5_000]
+const REQUEST_TIMEOUT_MS = 10_000
+const DELIVERY_LOG_LIMIT = 100
+
+export function emitWebhookEvent(event: string, data: unknown): void {
+  const eventId = createWebhookEventId()
+  const body = JSON.stringify({
+    id: eventId,
+    event,
+    timestamp: new Date().toISOString(),
+    data
+  })
+
+  // A missing request scope must never crash the mutation that emitted the event.
+  try {
+    after(() => deliverWebhookEvent(eventId, event, body))
+  } catch (error) {
+    console.error('Webhook dispatch skipped (no request scope):', {
+      event,
+      error
+    })
+  }
+}
+
+async function deliverWebhookEvent(eventId: string, event: string, body: string): Promise<void> {
+  try {
+    const endpoints = await getActiveEndpointsForEvent(event)
+    if (endpoints.length === 0) return
+
+    await Promise.allSettled(
+      endpoints.map((endpoint) => deliverToEndpoint(endpoint, eventId, event, body))
+    )
+  } catch (error) {
+    console.error('Webhook delivery failed:', { event, error })
+  }
+}
+
+async function deliverToEndpoint(
+  endpoint: ActiveWebhookEndpoint,
+  eventId: string,
+  event: string,
+  body: string
+): Promise<void> {
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    const startedAt = Date.now()
+    let statusCode: number | null = null
+    let errorMessage: string | null = null
+
+    try {
+      const timestamp = Math.floor(Date.now() / 1000).toString()
+      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(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,
+      eventId,
+      attempt,
+      success: errorMessage === null,
+      statusCode,
+      durationMs: Date.now() - startedAt,
+      error: errorMessage
+    })
+
+    if (errorMessage === null) return
+    if (attempt < MAX_ATTEMPTS) {
+      await new Promise((resolve) => setTimeout(resolve, RETRY_DELAYS_MS[attempt - 1]))
+    }
+  }
+}
+
+export async function recordWebhookDelivery(entry: {
+  webhookId: string
+  event: string
+  eventId: string
+  attempt: number
+  success: boolean
+  statusCode: number | null
+  durationMs: number
+  error: string | null
+}): Promise<void> {
+  try {
+    await db.insert(webhookDeliveries).values(entry)
+    await pruneWebhookDeliveries(entry.webhookId)
+  } catch (error) {
+    console.error('Failed to record webhook delivery:', {
+      event: entry.event,
+      error
+    })
+  }
+}
+
+async function pruneWebhookDeliveries(webhookId: string): Promise<void> {
+  const keepRows = await db
+    .select({ id: webhookDeliveries.id })
+    .from(webhookDeliveries)
+    .where(eq(webhookDeliveries.webhookId, webhookId))
+    .orderBy(desc(webhookDeliveries.createdAt))
+    .limit(DELIVERY_LOG_LIMIT)
+
+  if (keepRows.length < DELIVERY_LOG_LIMIT) return
+
+  await db.delete(webhookDeliveries).where(
+    and(
+      eq(webhookDeliveries.webhookId, webhookId),
+      notInArray(
+        webhookDeliveries.id,
+        keepRows.map((row) => row.id)
+      )
+    )
+  )
+}

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

@@ -0,0 +1,124 @@
+'use server'
+
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { webhookDeliveries, webhooks } from '@admin/db/schema'
+import { and, asc, desc, eq, gte, ilike, lt, or, sql } from 'drizzle-orm'
+import type { WebhookDeliveriesPage, WebhookDeliveriesQuery } 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)
+}
+
+const SORTABLE_COLUMNS = {
+  createdAt: webhookDeliveries.createdAt,
+  event: webhookDeliveries.event,
+  webhookName: webhooks.name,
+  attempt: webhookDeliveries.attempt,
+  durationMs: webhookDeliveries.durationMs,
+  statusCode: webhookDeliveries.statusCode,
+  success: webhookDeliveries.success
+} as const
+
+// Deliberately uncached: delivery rows are written inside after(), where cache
+// invalidation is unavailable, so cached reads could never be refreshed.
+export async function getWebhookDeliveries(
+  query?: WebhookDeliveriesQuery
+): Promise<WebhookDeliveriesPage> {
+  await requireRole([UserRole.ADMIN])
+
+  try {
+    const conditions = []
+    const search = query?.search
+    if (search && typeof search === 'string' && search.trim()) {
+      const searchTerm = `%${search.trim().toLowerCase()}%`
+      conditions.push(
+        or(
+          ilike(webhookDeliveries.event, searchTerm),
+          ilike(webhookDeliveries.eventId, searchTerm),
+          ilike(webhooks.name, searchTerm)
+        )
+      )
+    }
+    if (query?.success !== undefined) {
+      conditions.push(eq(webhookDeliveries.success, query.success))
+    }
+    if (query?.webhookId) {
+      conditions.push(eq(webhookDeliveries.webhookId, query.webhookId))
+    }
+    if (query?.createdAtFrom) {
+      conditions.push(gte(webhookDeliveries.createdAt, query.createdAtFrom))
+    }
+    const createdAtExclusiveTo = getExclusiveDateUpperBound(query?.createdAtTo)
+    if (createdAtExclusiveTo) {
+      conditions.push(lt(webhookDeliveries.createdAt, createdAtExclusiveTo))
+    }
+
+    const baseQuery = db
+      .select({
+        id: webhookDeliveries.id,
+        webhookId: webhookDeliveries.webhookId,
+        webhookName: webhooks.name,
+        event: webhookDeliveries.event,
+        eventId: webhookDeliveries.eventId,
+        attempt: webhookDeliveries.attempt,
+        success: webhookDeliveries.success,
+        statusCode: webhookDeliveries.statusCode,
+        durationMs: webhookDeliveries.durationMs,
+        error: webhookDeliveries.error,
+        createdAt: webhookDeliveries.createdAt
+      })
+      .from(webhookDeliveries)
+      .innerJoin(webhooks, eq(webhookDeliveries.webhookId, webhooks.id))
+
+    const sortColumn =
+      query?.orderBy && query.orderBy in SORTABLE_COLUMNS
+        ? SORTABLE_COLUMNS[query.orderBy as keyof typeof SORTABLE_COLUMNS]
+        : webhookDeliveries.createdAt
+    const sortFn = query?.orderDirection === 'asc' ? asc : desc
+    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 deliveries = 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(webhookDeliveries)
+              .innerJoin(webhooks, eq(webhookDeliveries.webhookId, webhooks.id))
+              .where(conditions.length > 0 ? and(...conditions) : undefined)
+          )[0]?.count ?? 0
+        )
+      : deliveries.length
+
+    return { deliveries, total }
+  } catch (error) {
+    console.error('Error fetching webhook deliveries:', error)
+    throw new Error('Failed to fetch webhook deliveries')
+  }
+}

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

@@ -0,0 +1,28 @@
+'use server'
+
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { webhooks } from '@admin/db/schema'
+import { eq } from 'drizzle-orm'
+import type { WebhookSecretResult } from './types'
+
+export async function getWebhookSecret(id: string): Promise<WebhookSecretResult> {
+  await requireRole([UserRole.ADMIN])
+
+  try {
+    const [row] = await db
+      .select({ secret: webhooks.secret })
+      .from(webhooks)
+      .where(eq(webhooks.id, id))
+      .limit(1)
+
+    if (!row) return { success: false, error: 'Webhook not found' }
+    return { success: true, secret: row.secret }
+  } catch (error) {
+    console.error('Error fetching webhook secret:', error)
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to fetch webhook secret'
+    }
+  }
+}