Management contracts

import { createManagement } from 'good-webhooks/management'
import type {
  EndpointManagement,
  EndpointSource,
  EndpointResolution,
  ManagementScope,
  ManagementOptions,
  ManagementRepository,
  SecretCipher,
  StoredEndpoint,
  StoredEndpointPatch,
  ManagedEndpoint,
  CreateManagedEndpoint,
  UpdateManagedEndpoint,
  ManagedEndpointWithSecret,
} from 'good-webhooks/management'

interface EndpointManagement {
  readonly source: EndpointSource
  create(scope: ManagementScope, input: CreateManagedEndpoint): Promise<ManagedEndpointWithSecret>
  list(scope: ManagementScope): Promise<ManagedEndpoint[]>
  get(scope: ManagementScope, id: string): Promise<ManagedEndpoint>
  update(scope: ManagementScope, id: string, patch: UpdateManagedEndpoint): Promise<ManagedEndpoint>
  pause(scope: ManagementScope, id: string): Promise<ManagedEndpoint>
  resume(scope: ManagementScope, id: string): Promise<ManagedEndpoint>
  remove(scope: ManagementScope, id: string): Promise<ManagedEndpoint>
  rotateSecret(
    scope: ManagementScope,
    id: string,
    options?: { graceMs?: number },
  ): Promise<ManagedEndpointWithSecret>
  removeScope(scope: ManagementScope): Promise<void>
  reencrypt(scope: ManagementScope): Promise<number>
}

import { createPostgresManagement } from 'good-webhooks/management/postgres'
import { Pool } from 'pg'

const management = createPostgresManagement({
  database: new Pool({ connectionString: process.env.DATABASE_URL }),
  eventTypes: ['invoice.paid'],
  encryptionKey: process.env.WEBHOOK_ENCRYPTION_KEY!,
})

const scope = { type: 'organization', id: 'org_123' }
const { endpoint, secret } = await management.create(scope, {
  url: 'https://receiver.example/webhooks',
  eventTypes: ['invoice.paid'],
})
await management.pause(scope, endpoint.id)

interface EndpointSource {
  matchRecipients(scope: ManagementScope, eventType: string): Promise<readonly string[]>
  resolveEndpoint(scope: ManagementScope, id: string): Promise<EndpointResolution>
}

type EndpointResolution =
  { status: 'active'; url: string; secrets: readonly string[] } | { status: 'paused' | 'deleted' }

import { createDelivery } from 'good-webhooks/delivery'
import type { EndpointSource } from 'good-webhooks/management'
import { Pool } from 'pg'
import { z } from 'zod'

// A fixed, single-endpoint source. Real sources read your endpoint storage.
const source: EndpointSource = {
  async matchRecipients() {
    return ['endpoint-1']
  },
  async resolveEndpoint() {
    return {
      status: 'active',
      url: 'https://receiver.example/webhooks',
      secrets: [process.env.WEBHOOK_SECRET!],
    }
  },
}

const delivery = createDelivery({
  database: new Pool({ connectionString: process.env.DATABASE_URL }),
  events: { 'invoice.paid': z.object({ invoiceId: z.string() }) },
  source,
})

createManagement(options: ManagementOptions): EndpointManagement

import { createManagement } from 'good-webhooks/management'
import { createPostgresManagementRepository } from 'good-webhooks/management/postgres'
import { Pool } from 'pg'
import { cipher } from './cipher.js' // Your SecretCipher, for example backed by a KMS.

export const management = createManagement({
  repository: createPostgresManagementRepository(
    new Pool({ connectionString: process.env.DATABASE_URL }),
  ),
  cipher,
  eventTypes: ['invoice.paid', 'invoice.voided'],
})

interface ManagementRepository {
  list(scope: ManagementScope): Promise<StoredEndpoint[]>
  get(scope: ManagementScope, id: string): Promise<StoredEndpoint | null>
  create(scope: ManagementScope, endpoint: Omit<StoredEndpoint, 'id'>): Promise<StoredEndpoint>
  update(
    scope: ManagementScope,
    id: string,
    revision: number,
    patch: StoredEndpointPatch,
  ): Promise<StoredEndpoint | null>
}

interface SecretCipher {
  encrypt(value: string): Promise<string>
  decrypt(value: string): Promise<string>
}