@orthacms/webhooks-admin 0.5.0

package/dist/lib/infrastructure/webhookMapper/index.js

@@ -0,0 +1,49 @@
+/** Maps an endpoint from the wire. */
+export function toWebhookEndpoint(dto) {
+    return {
+        ...dto,
+        lastDelivery: dto.lastDelivery ? toLastDelivery(dto.lastDelivery) : null
+    };
+}
+/** Maps the last-delivery summary. */
+function toLastDelivery(dto) {
+    return { ...dto, status: dto.status };
+}
+/** Maps one delivery row. */
+export function toWebhookDelivery(dto) {
+    return { ...dto, status: dto.status };
+}
+/** Maps one delivery with its bodies. */
+export function toWebhookDeliveryDetail(dto) {
+    return {
+        ...toWebhookDelivery(dto),
+        payload: dto.payload,
+        responseSnippet: dto.responseSnippet
+    };
+}
+/** Maps one event descriptor. */
+export function toWebhookEventOption(dto) {
+    return { ...dto };
+}
+/** Maps a workspace row to the picker's option shape. */
+export function toWorkspaceOption(dto) {
+    return {
+        id: dto.id,
+        name: dto.name,
+        description: dto.description,
+        // Absent is read as "granted nothing", which is what an empty grant set
+        // means on the server too. The picker degrades to free entry rather
+        // than to a wrong list.
+        contentTypes: dto.content ?? []
+    };
+}
+/**
+ * Maps one content type from the registry.
+ *
+ * Only the two fields the picker needs — the rest of a summary (kind, path,
+ * `i18n`, …) describes how the type behaves, which the subscription filter has
+ * no opinion about.
+ */
+export function toContentTypeOption(dto) {
+    return { name: dto.name, label: dto.label };
+}

package/dist/lib/infrastructure/webhooksKeys/index.d.ts

@@ -0,0 +1,35 @@
+/** Filters and paging accepted by `GET /api/webhooks/:id/deliveries`. */
+export type DeliveriesListParams = {
+    /** Only deliveries in this state. */
+    status?: string;
+    /** Only deliveries of this event kind. */
+    eventKind?: string;
+    /** 1-based page number. */
+    page?: number;
+    /** Rows per page. */
+    pageSize?: number;
+};
+/**
+ * Query keys for the webhooks cache.
+ *
+ * Deliveries hang off their endpoint's key rather than a flat root, so
+ * refreshing one endpoint's log after a redelivery does not invalidate every
+ * other endpoint's — the log is the one query here that is actively polled.
+ */
+export declare const webhooksKeys: {
+    /** Root key covering every webhooks query. */
+    all: readonly ["webhooks"];
+    /** The endpoint list. */
+    list: () => readonly ["webhooks", "list"];
+    /** One endpoint. */
+    detail: (id: string) => readonly ["webhooks", "detail", string];
+    /** Every delivery query for one endpoint. */
+    deliveriesOf: (id: string) => readonly ["webhooks", "deliveries", string];
+    /** One page of one endpoint's log. */
+    deliveries: (id: string, params: DeliveriesListParams) => readonly ["webhooks", "deliveries", string, DeliveriesListParams];
+    /** The subscribable event catalogue. */
+    events: () => readonly ["webhooks", "events"];
+    /** The code-defined content-type catalogue, for the editor's picker. */
+    contentTypes: () => readonly ["webhooks", "content-types"];
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/infrastructure/webhooksKeys/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/infrastructure/webhooksKeys/index.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,MAAM,MAAM,oBAAoB,GAAG;IAC/B,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2BAA2B;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qBAAqB;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;IACrB,8CAA8C;;IAE9C,yBAAyB;;IAEzB,oBAAoB;iBACP,MAAM;IACnB,6CAA6C;uBAC1B,MAAM;IACzB,sCAAsC;qBACrB,MAAM,UAAU,oBAAoB;IAErD,wCAAwC;;IAExC,wEAAwE;;CAE3E,CAAC"}

package/dist/lib/infrastructure/webhooksKeys/index.js

@@ -0,0 +1,23 @@
+/**
+ * Query keys for the webhooks cache.
+ *
+ * Deliveries hang off their endpoint's key rather than a flat root, so
+ * refreshing one endpoint's log after a redelivery does not invalidate every
+ * other endpoint's — the log is the one query here that is actively polled.
+ */
+export const webhooksKeys = {
+    /** Root key covering every webhooks query. */
+    all: ['webhooks'],
+    /** The endpoint list. */
+    list: () => ['webhooks', 'list'],
+    /** One endpoint. */
+    detail: (id) => ['webhooks', 'detail', id],
+    /** Every delivery query for one endpoint. */
+    deliveriesOf: (id) => ['webhooks', 'deliveries', id],
+    /** One page of one endpoint's log. */
+    deliveries: (id, params) => ['webhooks', 'deliveries', id, params],
+    /** The subscribable event catalogue. */
+    events: () => ['webhooks', 'events'],
+    /** The code-defined content-type catalogue, for the editor's picker. */
+    contentTypes: () => ['webhooks', 'content-types']
+};

package/dist/lib/presentation/components/DeliveryStatusBadge/index.d.ts

@@ -0,0 +1,6 @@
+import type { DeliveryStatus } from '../../../domain/types/webhook';
+/** The state of one delivery, as a chip. */
+export declare function DeliveryStatusBadge({ status }: {
+    status: DeliveryStatus;
+}): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/components/DeliveryStatusBadge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/components/DeliveryStatusBadge/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AA8BpE,4CAA4C;AAC5C,wBAAgB,mBAAmB,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,cAAc,CAAA;CAAE,+BAOzE"}

package/dist/lib/presentation/components/DeliveryStatusBadge/index.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { defineMessages, useIntl } from 'react-intl';
+import { Badge } from '@orthacms/design-system';
+const messages = defineMessages({
+    pending: { id: 'webhooks.status.pending', defaultMessage: 'Queued' },
+    delivering: { id: 'webhooks.status.delivering', defaultMessage: 'Sending' },
+    succeeded: { id: 'webhooks.status.succeeded', defaultMessage: 'Delivered' },
+    failed: { id: 'webhooks.status.failed', defaultMessage: 'Retrying' },
+    dead: { id: 'webhooks.status.dead', defaultMessage: 'Failed' }
+});
+/**
+ * How each state reads and looks.
+ *
+ * The wording is the point: `failed` on a row that will be tried again says
+ * **Retrying**, and only `dead` — the state nothing will act on again — says
+ * "Failed". Calling both of them "failed" is what makes an operator chase a
+ * delivery that was about to succeed on its own.
+ */
+const LOOK = {
+    pending: { variant: 'outline' },
+    delivering: { variant: 'secondary' },
+    succeeded: { variant: 'default' },
+    failed: { variant: 'secondary' },
+    dead: { variant: 'destructive' }
+};
+/** The state of one delivery, as a chip. */
+export function DeliveryStatusBadge({ status }) {
+    const intl = useIntl();
+    return (_jsx(Badge, { variant: LOOK[status].variant, children: intl.formatMessage(messages[status]) }));
+}

package/dist/lib/presentation/components/RevealWebhookSecretDialog/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shows a signing secret **once**.
+ *
+ * The secret cannot be hashed — it is used to sign, not to verify — so it lives
+ * in the parent's state until this dialog is dismissed and is never fetchable
+ * again. Three things follow, all of them load-bearing and all of them mirroring
+ * the API-token reveal:
+ *
+ * - the secret is a focusable, labelled `readOnly` input that selects itself on
+ *   focus, so it can be read and copied without the Copy button;
+ * - the clipboard write is wrapped, because `writeText` rejects on an insecure
+ *   origin, a denied permission, or an unfocused document — and a silent
+ *   rejection loses the credential;
+ * - dismissing before copying asks first, because Esc, the overlay and the
+ *   close button are all reached by reflex.
+ */
+export declare function RevealWebhookSecretDialog({ secret, rotated, open, onOpenChange }: {
+    /** The plaintext secret, or `null` when there is nothing to reveal. */
+    secret: string | null;
+    /** Whether this replaced an existing secret rather than minting the first. */
+    rotated?: boolean;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/components/RevealWebhookSecretDialog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/components/RevealWebhookSecretDialog/index.tsx"],"names":[],"mappings":"AA+DA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,yBAAyB,CAAC,EACtC,MAAM,EACN,OAAO,EACP,IAAI,EACJ,YAAY,EACf,EAAE;IACC,uEAAuE;IACvE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACzC,+BA4HA"}

package/dist/lib/presentation/components/RevealWebhookSecretDialog/index.js

@@ -0,0 +1,107 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { defineMessages, useIntl } from 'react-intl';
+import { Check, Copy, TriangleAlert } from 'lucide-react';
+import { Alert, AlertDescription, Button, Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, toast } from '@orthacms/design-system';
+const messages = defineMessages({
+    title: {
+        id: 'webhooks.reveal.title',
+        defaultMessage: 'Copy your signing secret'
+    },
+    description: {
+        id: 'webhooks.reveal.description',
+        defaultMessage: 'This is the only time the secret is shown. Your receiver needs it to verify that a delivery really came from this CMS.'
+    },
+    warning: {
+        id: 'webhooks.reveal.warning',
+        defaultMessage: 'Every delivery is signed with this secret. Anyone who has it can forge a delivery your receiver will accept.'
+    },
+    rotated: {
+        id: 'webhooks.reveal.rotated',
+        defaultMessage: 'The new secret is already in use, including for deliveries that were queued before the rotation. Put it in place on the receiver now.'
+    },
+    secretLabel: {
+        id: 'webhooks.reveal.secretLabel',
+        defaultMessage: 'Webhook signing secret'
+    },
+    copy: { id: 'webhooks.reveal.copy', defaultMessage: 'Copy' },
+    copied: {
+        id: 'webhooks.reveal.copied',
+        defaultMessage: 'Copied to clipboard'
+    },
+    copyFailed: {
+        id: 'webhooks.reveal.copyFailed',
+        defaultMessage: 'Couldn’t reach the clipboard. Select the secret above and copy it manually.'
+    },
+    done: { id: 'webhooks.reveal.done', defaultMessage: 'Done' },
+    uncopied: {
+        id: 'webhooks.reveal.uncopied',
+        defaultMessage: 'You haven’t copied the secret yet, and it can’t be shown again. Closing now means rotating to a new one.'
+    },
+    closeAnyway: {
+        id: 'webhooks.reveal.closeAnyway',
+        defaultMessage: 'Close without copying'
+    },
+    keepOpen: { id: 'webhooks.reveal.keepOpen', defaultMessage: 'Keep it open' }
+});
+/**
+ * Shows a signing secret **once**.
+ *
+ * The secret cannot be hashed — it is used to sign, not to verify — so it lives
+ * in the parent's state until this dialog is dismissed and is never fetchable
+ * again. Three things follow, all of them load-bearing and all of them mirroring
+ * the API-token reveal:
+ *
+ * - the secret is a focusable, labelled `readOnly` input that selects itself on
+ *   focus, so it can be read and copied without the Copy button;
+ * - the clipboard write is wrapped, because `writeText` rejects on an insecure
+ *   origin, a denied permission, or an unfocused document — and a silent
+ *   rejection loses the credential;
+ * - dismissing before copying asks first, because Esc, the overlay and the
+ *   close button are all reached by reflex.
+ */
+export function RevealWebhookSecretDialog({ secret, rotated, open, onOpenChange }) {
+    const intl = useIntl();
+    const [copied, setCopied] = useState(false);
+    const [confirmingClose, setConfirmingClose] = useState(false);
+    // A new secret is a new chance to lose it — clear the guard whenever one
+    // arrives, so a rotation does not inherit the first one's "copied".
+    useEffect(() => {
+        if (secret !== null) {
+            setCopied(false);
+            setConfirmingClose(false);
+        }
+    }, [secret]);
+    const copy = async () => {
+        if (!secret)
+            return;
+        try {
+            await navigator.clipboard.writeText(secret);
+            setCopied(true);
+            toast.success(intl.formatMessage(messages.copied));
+        }
+        catch {
+            toast.error(intl.formatMessage(messages.copyFailed));
+        }
+    };
+    /** Close for real, clearing the guard. */
+    const close = () => {
+        setConfirmingClose(false);
+        onOpenChange(false);
+    };
+    /** Every dismissal path funnels through here so none can slip past. */
+    const requestClose = () => {
+        if (copied) {
+            close();
+            return;
+        }
+        setConfirmingClose(true);
+    };
+    return (_jsx(Dialog, { open: open, onOpenChange: (next) => {
+            if (next) {
+                onOpenChange(true);
+                return;
+            }
+            requestClose();
+        }, children: _jsxs(DialogContent, { children: [_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { children: intl.formatMessage(messages.title) }), _jsx(DialogDescription, { children: intl.formatMessage(messages.description) })] }), _jsxs("div", { className: "flex min-w-0 items-center gap-2", children: [_jsx("input", { readOnly: true, value: secret ?? '', "aria-label": intl.formatMessage(messages.secretLabel), onFocus: (event) => event.currentTarget.select(), className: "min-w-0 flex-1 truncate rounded-md bg-muted px-3 py-2 font-mono text-sm" }), _jsxs(Button, { type: "button", variant: "outline", className: "shrink-0", onClick: copy, children: [copied ? _jsx(Check, { "aria-hidden": true }) : _jsx(Copy, { "aria-hidden": true }), intl.formatMessage(messages.copy)] })] }), _jsxs(Alert, { children: [_jsx(TriangleAlert, { "aria-hidden": true }), _jsx(AlertDescription, { children: intl.formatMessage(rotated ? messages.rotated : messages.warning) })] }), confirmingClose ? (_jsxs(Alert, { variant: "destructive", role: "alert", children: [_jsx(TriangleAlert, { "aria-hidden": true }), _jsx(AlertDescription, { children: intl.formatMessage(messages.uncopied) })] })) : null, _jsx(DialogFooter, { children: confirmingClose ? (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", onClick: () => setConfirmingClose(false), children: intl.formatMessage(messages.keepOpen) }), _jsx(Button, { variant: "destructive", onClick: close, children: intl.formatMessage(messages.closeAnyway) })] })) : (_jsx(Button, { onClick: requestClose, children: intl.formatMessage(messages.done) })) })] }) }));
+}

package/dist/lib/presentation/components/WebhookDeliveriesPanel/DeliveryDetailSheet/index.d.ts

@@ -0,0 +1,19 @@
+import type { WebhookDeliveryDetail } from '../../../../domain/types/webhook';
+/**
+ * One delivery in full — the body that was posted, the response that came back,
+ * and the button to send it again.
+ *
+ * The request body is shown verbatim rather than re-derived, because it is
+ * stored verbatim: what is on screen is byte-for-byte what the receiver was
+ * sent, which is the only version worth debugging against.
+ */
+export declare function DeliveryDetailSheet({ delivery, open, onOpenChange, canRedeliver, redelivering, onRedeliver }: {
+    /** The delivery, or `undefined` while it loads. */
+    delivery: WebhookDeliveryDetail | undefined;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    canRedeliver: boolean;
+    redelivering: boolean;
+    onRedeliver: (deliveryId: string) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/components/WebhookDeliveriesPanel/DeliveryDetailSheet/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/presentation/components/WebhookDeliveriesPanel/DeliveryDetailSheet/index.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAgE9E;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,EAChC,QAAQ,EACR,IAAI,EACJ,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,WAAW,EACd,EAAE;IACC,mDAAmD;IACnD,QAAQ,EAAE,qBAAqB,GAAG,SAAS,CAAC;IAC5C,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACtC,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7C,+BAmHA"}

package/dist/lib/presentation/components/WebhookDeliveriesPanel/DeliveryDetailSheet/index.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { defineMessages, useIntl } from 'react-intl';
+import { RefreshCw } from 'lucide-react';
+import { Button, Sheet, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, Spinner } from '@orthacms/design-system';
+import { DeliveryStatusBadge } from '../../DeliveryStatusBadge';
+const messages = defineMessages({
+    title: { id: 'webhooks.delivery.title', defaultMessage: 'Delivery' },
+    description: {
+        id: 'webhooks.delivery.description',
+        defaultMessage: 'What was sent, and what came back.'
+    },
+    request: {
+        id: 'webhooks.delivery.request',
+        defaultMessage: 'Request body'
+    },
+    response: {
+        id: 'webhooks.delivery.response',
+        defaultMessage: 'Response'
+    },
+    noResponse: {
+        id: 'webhooks.delivery.noResponse',
+        defaultMessage: 'The receiver sent no body.'
+    },
+    error: { id: 'webhooks.delivery.error', defaultMessage: 'Error' },
+    event: { id: 'webhooks.delivery.event', defaultMessage: 'Event' },
+    attempts: { id: 'webhooks.delivery.attempts', defaultMessage: 'Attempts' },
+    statusCode: {
+        id: 'webhooks.delivery.statusCode',
+        defaultMessage: 'HTTP status'
+    },
+    duration: { id: 'webhooks.delivery.duration', defaultMessage: 'Took' },
+    durationValue: {
+        id: 'webhooks.delivery.durationValue',
+        defaultMessage: '{ms} ms'
+    },
+    nextAttempt: {
+        id: 'webhooks.delivery.nextAttempt',
+        defaultMessage: 'Next attempt'
+    },
+    eventId: {
+        id: 'webhooks.delivery.eventId',
+        defaultMessage: 'Event id (deduplicate on this)'
+    },
+    redeliver: {
+        id: 'webhooks.delivery.redeliver',
+        defaultMessage: 'Send again'
+    },
+    none: { id: 'webhooks.delivery.none', defaultMessage: '—' }
+});
+/** One labelled fact in the summary grid. */
+function Fact({ label, children }) {
+    return (_jsxs("div", { className: "flex flex-col gap-0.5", children: [_jsx("dt", { className: "text-xs text-muted-foreground", children: label }), _jsx("dd", { className: "text-sm", children: children })] }));
+}
+/**
+ * One delivery in full — the body that was posted, the response that came back,
+ * and the button to send it again.
+ *
+ * The request body is shown verbatim rather than re-derived, because it is
+ * stored verbatim: what is on screen is byte-for-byte what the receiver was
+ * sent, which is the only version worth debugging against.
+ */
+export function DeliveryDetailSheet({ delivery, open, onOpenChange, canRedeliver, redelivering, onRedeliver }) {
+    const intl = useIntl();
+    return (_jsx(Sheet, { open: open, onOpenChange: onOpenChange, children: _jsxs(SheetContent, { className: "flex w-full flex-col gap-4 overflow-y-auto sm:max-w-xl", children: [_jsxs(SheetHeader, { children: [_jsx(SheetTitle, { children: intl.formatMessage(messages.title) }), _jsx(SheetDescription, { children: intl.formatMessage(messages.description) })] }), !delivery ? (_jsx("div", { className: "flex justify-center py-8", children: _jsx(Spinner, {}) })) : (_jsxs(_Fragment, { children: [_jsxs("dl", { className: "grid grid-cols-2 gap-3 px-4", children: [_jsx(Fact, { label: intl.formatMessage(messages.event), children: _jsx("span", { className: "font-mono text-xs", children: delivery.eventKind }) }), _jsx(Fact, { label: intl.formatMessage(messages.statusCode), children: _jsxs("span", { className: "flex items-center gap-2", children: [_jsx(DeliveryStatusBadge, { status: delivery.status }), delivery.statusCode ??
+                                                intl.formatMessage(messages.none)] }) }), _jsx(Fact, { label: intl.formatMessage(messages.attempts), children: delivery.attempts }), _jsx(Fact, { label: intl.formatMessage(messages.duration), children: delivery.durationMs === null
+                                        ? intl.formatMessage(messages.none)
+                                        : intl.formatMessage(messages.durationValue, { ms: delivery.durationMs }) }), delivery.nextAttemptAt ? (_jsx(Fact, { label: intl.formatMessage(messages.nextAttempt), children: intl.formatDate(delivery.nextAttemptAt, {
+                                        dateStyle: 'medium',
+                                        timeStyle: 'short'
+                                    }) })) : null, _jsx(Fact, { label: intl.formatMessage(messages.eventId), children: _jsx("span", { className: "font-mono text-xs break-all", children: delivery.eventId }) })] }), delivery.error ? (_jsxs("section", { className: "px-4", children: [_jsx("h3", { className: "mb-1 text-xs text-muted-foreground", children: intl.formatMessage(messages.error) }), _jsx("p", { className: "rounded-md bg-destructive/10 px-3 py-2 text-sm text-destructive", children: delivery.error })] })) : null, _jsxs("section", { className: "px-4", children: [_jsx("h3", { className: "mb-1 text-xs text-muted-foreground", children: intl.formatMessage(messages.request) }), _jsx("pre", { className: "max-h-72 overflow-auto rounded-md bg-muted p-3 font-mono text-xs", children: JSON.stringify(delivery.payload, null, 2) })] }), _jsxs("section", { className: "px-4", children: [_jsx("h3", { className: "mb-1 text-xs text-muted-foreground", children: intl.formatMessage(messages.response) }), _jsx("pre", { className: "max-h-48 overflow-auto rounded-md bg-muted p-3 font-mono text-xs", children: delivery.responseSnippet ??
+                                        intl.formatMessage(messages.noResponse) })] }), canRedeliver ? (_jsx(SheetFooter, { children: _jsxs(Button, { variant: "outline", disabled: redelivering, onClick: () => onRedeliver(delivery.id), children: [_jsx(RefreshCw, { "aria-hidden": true }), intl.formatMessage(messages.redeliver)] }) })) : null] }))] }) }));
+}

package/dist/lib/presentation/components/WebhookDeliveriesPanel/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * One endpoint's delivery log.
+ *
+ * The list polls itself while anything in it is still in flight (see
+ * `useWebhookDeliveries`), so a queued delivery becomes a delivered one on
+ * screen without anybody pressing refresh.
+ */
+export declare function WebhookDeliveriesPanel({ endpointId, canRedeliver }: {
+    endpointId: string;
+    canRedeliver: boolean;
+}): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/components/WebhookDeliveriesPanel/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/components/WebhookDeliveriesPanel/index.tsx"],"names":[],"mappings":"AAwGA;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,EACnC,UAAU,EACV,YAAY,EACf,EAAE;IACC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACzB,+BAmNA"}

package/dist/lib/presentation/components/WebhookDeliveriesPanel/index.js

@@ -0,0 +1,132 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { defineMessages, useIntl } from 'react-intl';
+import { Alert, AlertDescription, Button, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, Table, TableBody, TableCell, TableHead, TableHeader, TableRow, toast } from '@orthacms/design-system';
+import { DELIVERY_STATUSES } from '../../../domain/types/webhook';
+import { DEFAULT_PAGE_SIZE, useWebhookDeliveries, useWebhookDelivery } from '../../../application/useWebhookDeliveries';
+import { useRedeliverWebhook } from '../../../application/useWebhookMutations';
+import { DeliveryStatusBadge } from '../DeliveryStatusBadge';
+import { DeliveryDetailSheet } from './DeliveryDetailSheet';
+const messages = defineMessages({
+    caption: {
+        id: 'webhooks.deliveries.caption',
+        defaultMessage: 'Delivery log'
+    },
+    event: { id: 'webhooks.deliveries.event', defaultMessage: 'Event' },
+    status: { id: 'webhooks.deliveries.status', defaultMessage: 'Status' },
+    code: { id: 'webhooks.deliveries.code', defaultMessage: 'Response' },
+    attempts: {
+        id: 'webhooks.deliveries.attempts',
+        defaultMessage: 'Attempts'
+    },
+    when: { id: 'webhooks.deliveries.when', defaultMessage: 'Queued' },
+    empty: {
+        id: 'webhooks.deliveries.empty',
+        defaultMessage: 'Nothing has been sent yet. A delivery appears here the moment content this endpoint subscribes to changes.'
+    },
+    error: {
+        id: 'webhooks.deliveries.error',
+        defaultMessage: 'Couldn’t load the delivery log. Please try again.'
+    },
+    retry: { id: 'webhooks.deliveries.retry', defaultMessage: 'Retry' },
+    filterAll: {
+        id: 'webhooks.deliveries.filterAll',
+        defaultMessage: 'All states'
+    },
+    filterLabel: {
+        id: 'webhooks.deliveries.filterLabel',
+        defaultMessage: 'Filter by state'
+    },
+    view: { id: 'webhooks.deliveries.view', defaultMessage: 'View' },
+    actions: { id: 'webhooks.deliveries.actions', defaultMessage: 'Actions' },
+    prev: { id: 'webhooks.deliveries.prev', defaultMessage: 'Previous' },
+    next: { id: 'webhooks.deliveries.next', defaultMessage: 'Next' },
+    pageOf: {
+        id: 'webhooks.deliveries.pageOf',
+        defaultMessage: 'Page {page} of {pageCount}'
+    },
+    redelivered: {
+        id: 'webhooks.deliveries.redelivered',
+        defaultMessage: 'Queued to send again'
+    },
+    redeliverFailed: {
+        id: 'webhooks.deliveries.redeliverFailed',
+        defaultMessage: 'Couldn’t queue it again. Please try again.'
+    },
+    statusPending: {
+        id: 'webhooks.status.pending',
+        defaultMessage: 'Queued'
+    },
+    statusDelivering: {
+        id: 'webhooks.status.delivering',
+        defaultMessage: 'Sending'
+    },
+    statusSucceeded: {
+        id: 'webhooks.status.succeeded',
+        defaultMessage: 'Delivered'
+    },
+    statusFailed: { id: 'webhooks.status.failed', defaultMessage: 'Retrying' },
+    statusDead: { id: 'webhooks.status.dead', defaultMessage: 'Failed' }
+});
+/** The filter dropdown's label for each state — same wording as the chips. */
+const STATUS_LABELS = {
+    pending: messages.statusPending,
+    delivering: messages.statusDelivering,
+    succeeded: messages.statusSucceeded,
+    failed: messages.statusFailed,
+    dead: messages.statusDead
+};
+/** Sentinel for "no state filter" — a `Select` cannot hold an empty value. */
+const ALL = 'all';
+/**
+ * One endpoint's delivery log.
+ *
+ * The list polls itself while anything in it is still in flight (see
+ * `useWebhookDeliveries`), so a queued delivery becomes a delivered one on
+ * screen without anybody pressing refresh.
+ */
+export function WebhookDeliveriesPanel({ endpointId, canRedeliver }) {
+    const intl = useIntl();
+    const [status, setStatus] = useState(ALL);
+    const [page, setPage] = useState(1);
+    const [openDeliveryId, setOpenDeliveryId] = useState(null);
+    const { data, isPending, isError, refetch } = useWebhookDeliveries(endpointId, {
+        page,
+        pageSize: DEFAULT_PAGE_SIZE,
+        ...(status === ALL ? {} : { status })
+    });
+    const { data: detail } = useWebhookDelivery(endpointId, openDeliveryId);
+    const redeliver = useRedeliverWebhook();
+    // The log shrinks under the reader — retention prunes it, a filter narrows
+    // it — so a page number that was valid a moment ago can point past the end.
+    // Following the server's clamp keeps the pager and the rows in agreement
+    // instead of showing an empty page with no way back.
+    useEffect(() => {
+        if (data && page > data.pageCount) {
+            setPage(data.pageCount);
+        }
+    }, [data, page]);
+    if (isError) {
+        return (_jsx(Alert, { variant: "destructive", role: "alert", className: "mt-4", children: _jsxs(AlertDescription, { className: "flex items-center justify-between gap-4", children: [intl.formatMessage(messages.error), _jsx(Button, { size: "sm", variant: "outline", onClick: () => void refetch(), children: intl.formatMessage(messages.retry) })] }) }));
+    }
+    const items = data?.items ?? [];
+    return (_jsxs("div", { className: "flex flex-col gap-3", children: [_jsx("div", { className: "flex items-center justify-end", children: _jsxs(Select, { value: status, onValueChange: (next) => {
+                        setStatus(next);
+                        setPage(1);
+                    }, children: [_jsx(SelectTrigger, { className: "w-48", "aria-label": intl.formatMessage(messages.filterLabel), children: _jsx(SelectValue, {}) }), _jsxs(SelectContent, { children: [_jsx(SelectItem, { value: ALL, children: intl.formatMessage(messages.filterAll) }), DELIVERY_STATUSES.map((value) => (_jsx(SelectItem, { value: value, children: intl.formatMessage(STATUS_LABELS[value]) }, value)))] })] }) }), !isPending && items.length === 0 ? (_jsx("p", { className: "py-8 text-center text-sm text-muted-foreground", children: intl.formatMessage(messages.empty) })) : (_jsx("div", { className: "overflow-hidden rounded-xl border bg-card shadow-xs", children: _jsxs(Table, { children: [_jsx("caption", { className: "sr-only", children: intl.formatMessage(messages.caption) }), _jsx(TableHeader, { children: _jsxs(TableRow, { children: [_jsx(TableHead, { children: intl.formatMessage(messages.event) }), _jsx(TableHead, { children: intl.formatMessage(messages.status) }), _jsx(TableHead, { children: intl.formatMessage(messages.code) }), _jsx(TableHead, { children: intl.formatMessage(messages.attempts) }), _jsx(TableHead, { children: intl.formatMessage(messages.when) }), _jsx(TableHead, { className: "w-20", children: _jsx("span", { className: "sr-only", children: intl.formatMessage(messages.actions) }) })] }) }), _jsx(TableBody, { children: items.map((delivery) => (_jsxs(TableRow, { children: [_jsx(TableCell, { className: "font-mono text-xs", children: delivery.eventKind }), _jsx(TableCell, { children: _jsx(DeliveryStatusBadge, { status: delivery.status }) }), _jsx(TableCell, { className: "tabular-nums", children: delivery.statusCode ?? '—' }), _jsx(TableCell, { className: "tabular-nums", children: delivery.attempts }), _jsx(TableCell, { className: "text-sm text-muted-foreground", children: intl.formatDate(delivery.createdAt, {
+                                            dateStyle: 'medium',
+                                            timeStyle: 'short'
+                                        }) }), _jsx(TableCell, { className: "text-right", children: _jsx(Button, { size: "sm", variant: "ghost", onClick: () => setOpenDeliveryId(delivery.id), children: intl.formatMessage(messages.view) }) })] }, delivery.id))) })] }) })), data && data.pageCount > 1 ? (_jsxs("div", { className: "flex items-center justify-between", children: [_jsx("span", { className: "text-sm text-muted-foreground", children: intl.formatMessage(messages.pageOf, {
+                            page: data.page,
+                            pageCount: data.pageCount
+                        }) }), _jsxs("div", { className: "flex gap-2", children: [_jsx(Button, { size: "sm", variant: "outline", disabled: data.page <= 1, onClick: () => setPage((prev) => prev - 1), children: intl.formatMessage(messages.prev) }), _jsx(Button, { size: "sm", variant: "outline", disabled: data.page >= data.pageCount, onClick: () => setPage((prev) => prev + 1), children: intl.formatMessage(messages.next) })] })] })) : null, _jsx(DeliveryDetailSheet, { delivery: detail, open: openDeliveryId !== null, onOpenChange: (next) => {
+                    if (!next)
+                        setOpenDeliveryId(null);
+                }, canRedeliver: canRedeliver, redelivering: redeliver.isPending, onRedeliver: (deliveryId) => redeliver.mutate({ endpointId, deliveryId }, {
+                    onSuccess: () => {
+                        toast.success(intl.formatMessage(messages.redelivered));
+                        setOpenDeliveryId(null);
+                    },
+                    onError: () => toast.error(intl.formatMessage(messages.redeliverFailed))
+                }) })] }));
+}

package/dist/lib/presentation/components/WebhookForm/index.d.ts

@@ -0,0 +1,46 @@
+import type { WebhookEndpoint, WebhookEventOption } from '../../../domain/types/webhook';
+import type { ContentTypeOption } from '../../../domain/types/contentTypeOption';
+import type { WorkspaceOption } from '../../../domain/types/workspaceOption';
+import { type HeaderRow } from '../../../domain/headerRules';
+import type { SaveWebhookInput } from '../../../infrastructure/webhookGateway';
+/** What the dialog is currently editing. */
+export type WebhookFormValues = {
+    name: string;
+    url: string;
+    enabled: boolean;
+    allWorkspaces: boolean;
+    workspaceIds: string[];
+    allEvents: boolean;
+    eventKinds: string[];
+    allContentTypes: boolean;
+    contentTypes: string[];
+    headers: HeaderRow[];
+};
+/**
+ * Create and edit an endpoint.
+ *
+ * The three filters are each an "All…" toggle over a picker, and the toggle is
+ * not cosmetic: it is the difference between "everything, including what does
+ * not exist yet" and an enumerated list that silently stops covering the next
+ * workspace or event kind. Turning one on sends **no** value for that filter,
+ * which is exactly how the server reads "all".
+ */
+export declare function WebhookForm({ endpoint, events, workspaces, contentTypes, pending, error, onSubmit, onCancel }: {
+    /** The endpoint being edited, or `undefined` when creating one. */
+    endpoint?: WebhookEndpoint;
+    events: WebhookEventOption[];
+    workspaces: WorkspaceOption[];
+    /**
+     * The code-defined content types. Empty is a legitimate state — an
+     * unreachable catalogue, or a build with no types yet — and the picker
+     * still accepts a typed-in machine name.
+     */
+    contentTypes: ContentTypeOption[];
+    pending: boolean;
+    /** A server-side refusal to show above the footer (a rejected URL, say). */
+    error: string | null;
+    onSubmit: (input: SaveWebhookInput) => void;
+    /** Leaves without saving — the page decides where that goes. */
+    onCancel: () => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/components/WebhookForm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/components/WebhookForm/index.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACR,eAAe,EACf,kBAAkB,EACrB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAIH,KAAK,SAAS,EACjB,MAAM,6BAA6B,CAAC;AAOrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AA4K/E,4CAA4C;AAC5C,MAAM,MAAM,iBAAiB,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,eAAe,EAAE,OAAO,CAAC;IACzB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE,SAAS,EAAE,CAAC;CACxB,CAAC;AAwCF;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,EACxB,QAAQ,EACR,MAAM,EACN,UAAU,EACV,YAAY,EACZ,OAAO,EACP,KAAK,EACL,QAAQ,EACR,QAAQ,EACX,EAAE;IACC,mEAAmE;IACnE,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B;;;;OAIG;IACH,YAAY,EAAE,iBAAiB,EAAE,CAAC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,4EAA4E;IAC5E,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC5C,gEAAgE;IAChE,QAAQ,EAAE,MAAM,IAAI,CAAC;CACxB,+BAkmBA"}