shutro-erp 0.3.1 → 0.3.3

package/dist/integrations/index.js

@@ -0,0 +1,400 @@
+/**
+ * @packageDocumentation
+ * `shutro-erp/integrations` (RFC 0017): the Integrations app. Step 2: outbound webhook subscriptions — events of records
+ * and of modules, delivered signed, retried, logged, replayable. Routes:
+ *
+ * - `GET  /api/v1/webhooks/events`                         the events subscriptions may want here
+ * - `POST /api/v1/webhooks/subscriptions`                  `{ name, url, events, runAs? }` (URL and events checked)
+ * - `POST /api/v1/webhooks/subscriptions/:id/ping`         a test delivery
+ * - `POST /api/v1/webhooks/subscriptions/:id/rotate-secret` a new signing secret
+ * - `POST /api/v1/webhooks/deliveries/:id/replay`          the same payload, delivered again
+ *
+ * Step 3: inbound webhooks — endpoints modules declare (`inboundWebhooks`), switched on per company:
+ *
+ * - `POST /api/v1/hooks/:token`                            the provider's call (no sign-in; verified by the module)
+ * - `GET  /api/v1/webhooks/hooks`                          the endpoints modules offer
+ * - `POST /api/v1/webhooks/endpoints`                      `{ name, hook }`: an endpoint, with its path and secret
+ * - `POST /api/v1/webhooks/endpoints/:id/rotate-secret`    a new secret
+ * - `POST /api/v1/webhooks/inbound/:id/replay`             a received call, handled again
+ *
+ * Subscriptions are also edited through the generated API (`webhook.subscription`); deliveries are read there.
+ */
+import { randomUUID } from 'node:crypto';
+import { defineModule } from '../modules-sdk/index.js';
+import { base, HttpProblem } from '../server/index.js';
+import { action, form, list } from '../views/index.js';
+import { handleInbound, INBOUND_JOB, inboundHooks, receive } from './inbound.js';
+import { integrationsShutro, newSecret } from './models.js';
+import { CHANGE_EVENTS, CHANGE_TOPIC, DELIVER_JOB, deliver, fanOut, PING_EVENT, queue, ref, urlProblem, webhookEvents, } from './webhooks.js';
+export { handleInbound, hmacVerifier, INBOUND_JOB, inboundHooks, receive, } from './inbound.js';
+export { integrationsShutro, newSecret, newToken } from './models.js';
+export { CHANGE_EVENTS, DELIVER_JOB, deliver, fanOut, PING_EVENT, signature, urlProblem, webhookEvents, webhookHosts, } from './webhooks.js';
+const idOf = (params) => {
+    const id = Number(params.id);
+    if (!(Number.isInteger(id) && id > 0))
+        throw new HttpProblem(400, 'invalid-id', 'Invalid id', 'The id is a positive integer.');
+    return id;
+};
+/** The subscription `id` the caller may change, with its company. */
+async function subscriptionOf(env, id) {
+    env.access.check('webhook.subscription', 'write');
+    const set = await ref(env, 'webhook.subscription').search({ where: { id }, limit: 1 });
+    const [row] = set.length === 0 ? [] : (await set.load(['company'])).read(['id', 'company']);
+    if (row === undefined)
+        throw new HttpProblem(404, 'missing-record', 'Not found', `There is no webhook ${id}.`);
+    return { id, company: row['company'] };
+}
+function registerWebhookRoutes(context, integrations) {
+    const { app } = context;
+    const known = () => new Set(webhookEvents(context.registry).map((e) => e.event));
+    app.get('/api/v1/webhooks/events', async (request) => request.env(async (env) => {
+        env.access.check('webhook.subscription', 'read');
+        return { events: webhookEvents(context.registry) };
+    }));
+    app.post('/api/v1/webhooks/subscriptions', async (request, reply) => {
+        const body = (request.body ?? {});
+        const url = String(body['url'] ?? '').trim();
+        const problem = urlProblem(url);
+        if (problem !== null)
+            throw new HttpProblem(422, 'invalid-url', 'Invalid URL', problem);
+        const events = (Array.isArray(body['events']) ? body['events'] : String(body['events'] ?? '').split(/[\s,]+/))
+            .map(String)
+            .filter((e) => e !== '');
+        const unknown = events.filter((e) => !known().has(e));
+        if (events.length === 0 || unknown.length > 0)
+            throw new HttpProblem(422, 'invalid-events', 'Invalid events', events.length === 0
+                ? 'Choose at least one event.'
+                : `Unknown events: ${unknown.join(', ')}.`);
+        const created = await request.env(async (env) => {
+            const rows = await ref(env, 'webhook.subscription').create([
+                {
+                    name: String(body['name'] ?? '').trim() || url,
+                    url,
+                    events: [...new Set(events)].join(' '),
+                    ...(body['runAs'] === undefined ? {} : { runAs: Number(body['runAs']) }),
+                },
+            ]);
+            const id = rows.ids[0];
+            const [row] = (await ref(env, 'webhook.subscription')
+                .browse([id])
+                .load(['name', 'url', 'events', 'secret'])).read(['id', 'name', 'url', 'events', 'secret']);
+            return row;
+        }, { write: true });
+        return reply.status(201).send(created);
+    });
+    app.post('/api/v1/webhooks/subscriptions/:id/ping', async (request, reply) => {
+        const id = idOf(request.params);
+        const sub = await request.env((env) => subscriptionOf(env, id));
+        const delivery = await queue(integrations, sub.id, sub.company, PING_EVENT, {
+            id: randomUUID(),
+            event: PING_EVENT,
+            occurredAt: new Date().toISOString(),
+            data: { subscription: sub.id },
+        });
+        return reply.status(202).send({ delivery });
+    });
+    app.post('/api/v1/webhooks/subscriptions/:id/rotate-secret', async (request) => {
+        const id = idOf(request.params);
+        return request.env(async (env) => {
+            await subscriptionOf(env, id);
+            const secret = newSecret();
+            await ref(env, 'webhook.subscription').browse([id]).write({ secret });
+            return { secret };
+        }, { write: true });
+    });
+    app.post('/api/v1/webhooks/deliveries/:id/replay', async (request, reply) => {
+        const id = idOf(request.params);
+        const original = await request.env(async (env) => {
+            env.access.check('webhook.subscription', 'write');
+            const set = await ref(env, 'webhook.delivery').search({ where: { id }, limit: 1 });
+            const [row] = set.length === 0
+                ? []
+                : (await set.load(['subscription', 'event', 'payload', 'company'])).read([
+                    'subscription',
+                    'event',
+                    'payload',
+                    'company',
+                ]);
+            if (row === undefined)
+                throw new HttpProblem(404, 'missing-record', 'Not found', `There is no delivery ${id}.`);
+            return row;
+        });
+        const delivery = await queue(integrations, original['subscription'], original['company'], String(original['event']), original['payload'], id);
+        return reply.status(202).send({ delivery });
+    });
+}
+const MAX_INBOUND = 1024 * 1024;
+/** The inbound endpoint `id` the caller may change. */
+async function endpointOf(env, id) {
+    env.access.check('webhook.endpoint', 'write');
+    const set = await ref(env, 'webhook.endpoint').search({ where: { id }, limit: 1 });
+    if (set.length === 0)
+        throw new HttpProblem(404, 'missing-record', 'Not found', `There is no inbound webhook ${id}.`);
+    return id;
+}
+function registerInboundRoutes(context, integrations) {
+    const { app } = context;
+    // The providers' calls: no session (the module's check decides), rate limited per address; the body kept raw.
+    app.register(async (hook) => {
+        hook.removeAllContentTypeParsers();
+        hook.addContentTypeParser('*', { parseAs: 'string', bodyLimit: MAX_INBOUND }, (_req, body, done) => done(null, body));
+        hook.post('/api/v1/hooks/:token', { config: { auth: false } }, async (request, reply) => {
+            const token = String(request.params.token ?? '');
+            const body = typeof request.body === 'string' ? request.body : '';
+            let json = null;
+            try {
+                json = body === '' ? null : JSON.parse(body);
+            }
+            catch {
+                json = null;
+            }
+            const outcome = await receive(integrations, token, {
+                headers: Object.fromEntries(Object.entries(request.headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(', ') : v])),
+                query: Object.fromEntries(Object.entries((request.query ?? {})).map(([k, v]) => [
+                    k,
+                    String(v),
+                ])),
+                body,
+                json,
+            });
+            return reply.status(outcome.status).send(outcome.body);
+        });
+    });
+    app.get('/api/v1/webhooks/hooks', async (request) => request.env(async (env) => {
+        env.access.check('webhook.endpoint', 'read');
+        return {
+            hooks: [...inboundHooks(context.registry)].map(([hook, spec]) => ({
+                hook,
+                module: spec.module,
+                label: spec.label,
+            })),
+        };
+    }));
+    app.post('/api/v1/webhooks/endpoints', async (request, reply) => {
+        const body = (request.body ?? {});
+        const hook = String(body['hook'] ?? '').trim();
+        const spec = inboundHooks(context.registry).get(hook);
+        if (spec === undefined)
+            throw new HttpProblem(422, 'invalid-hook', 'Unknown endpoint', `No module offers the endpoint '${hook}'.`);
+        const created = await request.env(async (env) => {
+            const rows = await ref(env, 'webhook.endpoint').create([
+                { name: String(body['name'] ?? '').trim() || spec.label, hook },
+            ]);
+            const id = rows.ids[0];
+            const [row] = (await ref(env, 'webhook.endpoint').browse([id]).load(['name', 'hook', 'token', 'secret'])).read(['id', 'name', 'hook', 'token', 'secret']);
+            return row ?? {};
+        }, { write: true });
+        return reply
+            .status(201)
+            .send({ ...created, path: `/api/v1/hooks/${String(created['token'])}` });
+    });
+    app.post('/api/v1/webhooks/endpoints/:id/rotate-secret', async (request) => {
+        const id = idOf(request.params);
+        return request.env(async (env) => {
+            await endpointOf(env, id);
+            const secret = newSecret();
+            await ref(env, 'webhook.endpoint').browse([id]).write({ secret });
+            return { secret };
+        }, { write: true });
+    });
+    app.post('/api/v1/webhooks/inbound/:id/replay', async (request, reply) => {
+        const id = idOf(request.params);
+        await request.env(async (env) => {
+            env.access.check('webhook.endpoint', 'write');
+            const set = await ref(env, 'webhook.inbound').search({ where: { id }, limit: 1 });
+            const [row] = set.length === 0
+                ? []
+                : (await set.load(['verified', 'company'])).read(['verified', 'company']);
+            if (row === undefined)
+                throw new HttpProblem(404, 'missing-record', 'Not found', `There is no inbound call ${id}.`);
+            if (row['verified'] !== true)
+                throw new HttpProblem(409, 'not-verified', 'Not verified', 'A refused call is not handled.');
+            await env.asSuperuser({ reason: 'inbound webhook: replay' }, async (su) => {
+                await ref(su, 'webhook.inbound').browse([id]).write({ state: 'received', error: null });
+                await su.enqueue(INBOUND_JOB, { call: id, company: row['company'] }, { attempts: 6 });
+            });
+        }, { write: true });
+        return reply.status(202).send({ call: id });
+    });
+}
+/** The workers: events to deliveries (change events and the modules' events), and the delivery jobs. */
+export function webhookWorkers(integrations) {
+    const { shutro, registry } = integrations;
+    const changes = shutro.subscribe('integrations.webhooks.changes', CHANGE_TOPIC, async (event, env) => {
+        const payload = (event.payload ?? {});
+        const verb = CHANGE_EVENTS[String(payload['action'])];
+        const model = String(payload['model'] ?? '');
+        const ids = Array.isArray(payload['ids']) ? payload['ids'] : [];
+        if (verb === undefined || model === '' || ids.length === 0)
+            return;
+        await fanOut(integrations, {
+            event: `${model}.${verb}`,
+            model,
+            ids,
+            company: env.companyId, // the handler runs as whoever emitted the event, in their company
+        });
+    }, { pollMs: 2000 });
+    const declared = registry.loaded.modules.flatMap((m) => (m.events ?? []).map((e) => shutro.subscribe(`integrations.webhooks.${e.topic}`, e.topic, async (event, env) => {
+        const payload = (event.payload ?? {});
+        const id = Number(payload['id']);
+        if (!Number.isInteger(id))
+            return;
+        const { id: _id, ...extra } = payload;
+        await fanOut(integrations, {
+            event: e.topic,
+            model: e.model,
+            ids: [id],
+            company: env.companyId, // the handler runs as whoever emitted the event, in their company
+            extra,
+        });
+    }, { pollMs: 2000 })));
+    const jobs = shutro.work({
+        [DELIVER_JOB]: async (payload, _env, job) => {
+            const p = (payload ?? {});
+            await deliver(integrations, Number(p.delivery), Number(p.company), {
+                number: job.attempt,
+                last: job.attempt >= job.maxAttempts,
+            });
+        },
+        [INBOUND_JOB]: async (payload, _env, job) => {
+            const p = (payload ?? {});
+            await handleInbound(integrations, Number(p.call), Number(p.company), job.attempt >= job.maxAttempts);
+        },
+    }, { pollMs: 2000 });
+    return [changes, ...declared, jobs];
+}
+/** The Integrations app with explicit options (tests, installations wiring their own). */
+export function integrationsModule(options = {}) {
+    return defineModule({
+        shutro: integrationsShutro,
+        kosh: '^0.1.0',
+        depends: [base],
+        app: {
+            code: 'integrations',
+            label: 'Integrations',
+            icon: 'plug',
+            sequence: 900,
+            category: 'Administration',
+            summary: 'Webhooks: tell other systems what happens here, and hear from them',
+        },
+        accessLevels: {
+            manager: { label: 'Integrations manager', groups: ['integrations.manager'] },
+        },
+        // Webhooks may want any served model's changes: every one emits Shutro change events.
+        changeEvents: '*',
+        actions: {
+            'integrations.action_webhooks': action('webhook.subscription', {
+                label: 'Webhooks',
+                views: ['list', 'form'],
+            }),
+            'integrations.action_deliveries': action('webhook.delivery', {
+                label: 'Deliveries',
+                views: ['list', 'form'],
+            }),
+            'integrations.action_endpoints': action('webhook.endpoint', {
+                label: 'Inbound webhooks',
+                views: ['list', 'form'],
+            }),
+            'integrations.action_inbound': action('webhook.inbound', {
+                label: 'Inbound calls',
+                views: ['list', 'form'],
+            }),
+        },
+        menus: [
+            { id: 'integrations.root', label: 'Integrations', app: 'integrations' },
+            {
+                id: 'integrations.webhooks',
+                parent: 'integrations.root',
+                label: 'Webhooks',
+                action: 'integrations.action_webhooks',
+                sequence: 1,
+            },
+            {
+                id: 'integrations.deliveries',
+                parent: 'integrations.root',
+                label: 'Deliveries',
+                action: 'integrations.action_deliveries',
+                sequence: 2,
+            },
+            {
+                id: 'integrations.endpoints',
+                parent: 'integrations.root',
+                label: 'Inbound webhooks',
+                action: 'integrations.action_endpoints',
+                sequence: 3,
+            },
+            {
+                id: 'integrations.inbound',
+                parent: 'integrations.root',
+                label: 'Inbound calls',
+                action: 'integrations.action_inbound',
+                sequence: 4,
+            },
+        ],
+        views: {
+            'webhook.subscription.list': list('webhook.subscription', {
+                columns: ['name', 'url', 'events', 'active', 'failures', 'lastDeliveryAt'],
+            }),
+            'webhook.subscription.form': form('webhook.subscription', (k) => ({
+                sheet: [
+                    k.group('main', ['name', 'url', 'active', 'runAs']),
+                    k.group('events_group', ['events']),
+                    k.group('state', ['failures', 'lastDeliveryAt', 'secret']),
+                    k.component('webhook_tools', 'integrations.WebhookTools'),
+                ],
+            })),
+            'webhook.delivery.list': list('webhook.delivery', {
+                columns: ['subscription', 'event', 'state', 'attempts', 'responseStatus', 'deliveredAt'],
+            }),
+            'webhook.delivery.form': form('webhook.delivery', (k) => ({
+                sheet: [
+                    k.group('main', ['subscription', 'event', 'state', 'replayOf']),
+                    k.group('outcome', ['attempts', 'responseStatus', 'durationMs', 'deliveredAt', 'error']),
+                    k.group('content', ['payload', 'responseBody']),
+                    k.component('delivery_tools', 'integrations.DeliveryTools'),
+                ],
+                readonlyWhen: { id: { ne: 0 } },
+            })),
+            'webhook.endpoint.list': list('webhook.endpoint', { columns: ['name', 'hook', 'active'] }),
+            'webhook.endpoint.form': form('webhook.endpoint', (k) => ({
+                sheet: [
+                    k.group('main', ['name', 'hook', 'active']),
+                    k.group('access', ['token', 'secret']),
+                    k.component('endpoint_tools', 'integrations.EndpointTools'),
+                ],
+            })),
+            'webhook.inbound.list': list('webhook.inbound', {
+                columns: ['endpoint', 'eventId', 'state', 'attempts', 'handledAt'],
+            }),
+            'webhook.inbound.form': form('webhook.inbound', (k) => ({
+                sheet: [
+                    k.group('main', ['endpoint', 'eventId', 'verified', 'state']),
+                    k.group('outcome', ['attempts', 'handledAt', 'result', 'error']),
+                    k.group('content', ['headers', 'body']),
+                    k.component('inbound_tools', 'integrations.InboundTools'),
+                ],
+                readonlyWhen: { id: { ne: 0 } },
+            })),
+        },
+        routes: (context) => {
+            const integrations = {
+                shutro: context.shutro,
+                registry: context.registry,
+                auth: context.auth,
+                ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+            };
+            registerWebhookRoutes(context, integrations);
+            registerInboundRoutes(context, integrations);
+            if (!(options.workers ?? process.env['KOSH_SCHEDULES'] !== 'off'))
+                return;
+            const workers = webhookWorkers(integrations);
+            for (const w of workers)
+                w.start();
+            context.app.addHook('onClose', async () => {
+                await Promise.all(workers.map((w) => w.stop()));
+            });
+        },
+    });
+}
+/** The Integrations app (providers and workers from the environment). */
+export const integrations = integrationsModule();

package/dist/integrations/models.d.ts

@@ -0,0 +1,6 @@
+import { orm } from '../server/orm.js';
+/** A new signing secret. */
+export declare const newSecret: () => string;
+/** A new endpoint token (the URL's last part: who knows it may call; the signature decides what is genuine). */
+export declare const newToken: () => string;
+export declare const integrationsShutro: ReturnType<typeof orm.defineModule>;

package/dist/integrations/models.js

@@ -0,0 +1,119 @@
+/**
+ * The integrations platform's models (RFC 0017 §5.3): webhook subscriptions (a URL, the events it wants, the secret
+ * deliveries are signed with, the user whose read rights shape the payloads) and deliveries (each event sent to a
+ * subscription: the payload, every attempt's outcome, replays). Managed by `integrations.manager`.
+ */
+import { randomBytes } from 'node:crypto';
+import { baseShutro } from '../server/index.js';
+import { orm } from '../server/orm.js';
+const { defineGroup, defineModel, defineModule, f } = orm;
+const ALL = ['read', 'write', 'create', 'unlink', 'export', 'import'];
+/** A new signing secret. */
+export const newSecret = () => `whsec_${randomBytes(24).toString('base64url')}`;
+/** Where events are sent. */
+const Subscription = defineModel('webhook.subscription', {
+    label: 'Webhook',
+    recName: 'name',
+    companyScoped: { required: true },
+    order: ['name asc', 'id asc'],
+    tracking: ['url', 'events', 'active', 'runAs'],
+    access: { 'integrations.manager': ALL },
+    fields: {
+        name: f.char({ required: true }),
+        /** https (http only for localhost), on the webhook host allow-list. */
+        url: f.char({ required: true, label: 'URL' }),
+        /** Space-separated: `res.partner.created`, `sale.order.updated`, `account.move.posted`… */
+        events: f.text({ required: true }),
+        active: f.boolean({ default: true }),
+        /** Deliveries carry `X-Shutro-Signature: t=<time>,v1=<HMAC-SHA256 of "<time>.<body>">`. */
+        secret: f.char({ required: true, default: newSecret, label: 'Signing secret' }),
+        /** Whose read rights decide what payloads contain (default: who made the webhook). */
+        runAs: f.many2one('res.users', { label: 'Acts as' }),
+        /** Deliveries that failed in a row (reset by a success). */
+        failures: f.integer({ required: true, default: 0, label: 'Failures in a row' }),
+        lastDeliveryAt: f.datetime({ label: 'Last delivery' }),
+        deliveries: f.one2many('webhook.delivery', 'subscription'),
+    },
+});
+/** One event sent to one subscription, with its attempts. */
+const Delivery = defineModel('webhook.delivery', {
+    label: 'Webhook delivery',
+    companyScoped: { required: true },
+    order: ['id desc'],
+    access: { 'integrations.manager': ['read', 'export'] },
+    fields: {
+        subscription: f.many2one('webhook.subscription', { required: true, ondelete: 'cascade' }),
+        event: f.char({ required: true }),
+        /** The JSON body sent (`{ id, event, occurredAt, data }`). */
+        payload: f.json({ required: true }),
+        state: f.selection({ pending: 'Pending', done: 'Delivered', failed: 'Failed' }, { required: true, default: 'pending' }),
+        attempts: f.integer({ required: true, default: 0 }),
+        responseStatus: f.integer({ label: 'Response status' }),
+        /** The start of the response body (2 KB). */
+        responseBody: f.text({ label: 'Response' }),
+        durationMs: f.integer({ label: 'Duration (ms)' }),
+        error: f.text(),
+        deliveredAt: f.datetime({ label: 'Delivered at' }),
+        /** A replay: the delivery it sends again. */
+        replayOf: f.many2one('webhook.delivery', { label: 'Replay of' }),
+    },
+});
+/** A new endpoint token (the URL's last part: who knows it may call; the signature decides what is genuine). */
+export const newToken = () => randomBytes(18).toString('base64url');
+/** A company's inbound webhook (RFC 0017 §5.4): a module's endpoint, its URL token and the secret calls are checked with. */
+const Endpoint = defineModel('webhook.endpoint', {
+    label: 'Inbound webhook',
+    recName: 'name',
+    companyScoped: { required: true },
+    order: ['name asc', 'id asc'],
+    tracking: ['active'],
+    access: { 'integrations.manager': ALL },
+    fields: {
+        name: f.char({ required: true }),
+        /** `<module>.<key>` of a declared inbound webhook. */
+        hook: f.char({ required: true, label: 'Endpoint' }),
+        token: f.char({ required: true, index: 'unique', default: newToken }),
+        /** What the module's check uses: the HMAC key, or the provider's signing secret. */
+        secret: f.char({ required: true, default: newSecret, label: 'Secret' }),
+        active: f.boolean({ default: true }),
+        calls: f.one2many('webhook.inbound', 'endpoint'),
+    },
+});
+/** A call an inbound webhook received: verified or not, handled once per event id, with the outcome. */
+const Inbound = defineModel('webhook.inbound', {
+    label: 'Inbound call',
+    companyScoped: { required: true },
+    order: ['id desc'],
+    access: { 'integrations.manager': ['read', 'export'] },
+    fields: {
+        endpoint: f.many2one('webhook.endpoint', { required: true, ondelete: 'cascade' }),
+        /** The provider's event id (null when the call was refused). */
+        eventId: f.char({ label: 'Event id' }),
+        headers: f.json({ required: true }),
+        body: f.text({ required: true }),
+        verified: f.boolean({ required: true, default: false }),
+        state: f.selection({
+            refused: 'Refused (not verified)',
+            received: 'Received',
+            done: 'Handled',
+            failed: 'Failed',
+        }, { required: true, default: 'received' }),
+        attempts: f.integer({ required: true, default: 0 }),
+        result: f.text(),
+        error: f.text(),
+        handledAt: f.datetime({ label: 'Handled at' }),
+    },
+});
+export const integrationsShutro = defineModule({
+    name: 'integrations',
+    version: '0.1.0',
+    depends: [baseShutro],
+    groups: [
+        defineGroup({
+            code: 'integrations.manager',
+            label: 'Integrations manager (webhooks)',
+            implies: ['base.user'],
+        }),
+    ],
+    models: [Subscription, Delivery, Endpoint, Inbound],
+});

package/dist/integrations/web/DeliveryTools.d.ts

@@ -0,0 +1,4 @@
+/** On a delivery's form (RFC 0017 §5.3): send it again (the same event, for receivers that deduplicate by its id). */
+import { type NodeComponentProps } from '../../ui/index.js';
+import type { ReactElement } from 'react';
+export declare function DeliveryTools({ api, record }: NodeComponentProps): ReactElement | null;

package/dist/integrations/web/DeliveryTools.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** On a delivery's form (RFC 0017 §5.3): send it again (the same event, for receivers that deduplicate by its id). */
+import { Alert, ApiError, Button } from '../../ui/index.js';
+import { useMutation } from '@tanstack/react-query';
+import { useTranslation } from 'react-i18next';
+export function DeliveryTools({ api, record }) {
+    const { t } = useTranslation('integrations');
+    const id = record?.['id'];
+    const replay = useMutation({
+        mutationFn: () => api.call('POST', `/api/v1/webhooks/deliveries/${id}/replay`),
+    });
+    if (typeof id !== 'number')
+        return null;
+    return (_jsxs("div", { className: "grid gap-2", children: [_jsx("div", { children: _jsx(Button, { variant: "secondary", busy: replay.isPending, onClick: () => replay.mutate(), children: t('tools.replay') }) }), replay.isSuccess ? _jsx(Alert, { tone: "info", children: t('tools.replayed') }) : null, replay.error === null ? null : (_jsx(Alert, { tone: "danger", children: replay.error instanceof ApiError ? replay.error.message : String(replay.error) }))] }));
+}

package/dist/integrations/web/EndpointTools.d.ts

@@ -0,0 +1,7 @@
+/**
+ * On an inbound webhook's form (RFC 0017 §5.4): the URL to give the provider, a new secret, and the endpoints the
+ * installed modules offer. The server checks every call; the panel shows what it answers.
+ */
+import { type NodeComponentProps } from '../../ui/index.js';
+import type { ReactElement } from 'react';
+export declare function EndpointTools({ api, record, reload }: NodeComponentProps): ReactElement;

package/dist/integrations/web/EndpointTools.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * On an inbound webhook's form (RFC 0017 §5.4): the URL to give the provider, a new secret, and the endpoints the
+ * installed modules offer. The server checks every call; the panel shows what it answers.
+ */
+import { Alert, ApiError, Button } from '../../ui/index.js';
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { useTranslation } from 'react-i18next';
+export function EndpointTools({ api, record, reload }) {
+    const { t } = useTranslation('integrations');
+    const id = record?.['id'];
+    const token = record?.['token'];
+    const hooks = useQuery({
+        queryKey: ['integrations', 'hooks'],
+        queryFn: () => api.call('GET', '/api/v1/webhooks/hooks'),
+    });
+    const rotate = useMutation({
+        mutationFn: () => api.call('POST', `/api/v1/webhooks/endpoints/${id}/rotate-secret`),
+        onSuccess: () => reload(),
+    });
+    const url = typeof token === 'string' && token !== ''
+        ? `${window.location.origin}/api/v1/hooks/${token}`
+        : null;
+    return (_jsxs("section", { className: "grid gap-3 rounded-lg border p-4", "aria-label": t('endpoint.title'), children: [url === null ? null : (_jsxs("div", { className: "grid gap-1", children: [_jsx("span", { className: "text-sm font-medium", children: t('endpoint.url') }), _jsx("code", { className: "break-all rounded bg-muted px-2 py-1 font-mono text-xs", "data-testid": "endpoint-url", children: url }), _jsx("p", { className: "text-xs text-muted-foreground", children: t('endpoint.urlHint') })] })), typeof id !== 'number' ? null : (_jsx("div", { children: _jsx(Button, { variant: "secondary", busy: rotate.isPending, onClick: () => rotate.mutate(), children: t('endpoint.rotate') }) })), rotate.error === null ? null : (_jsx(Alert, { tone: "danger", children: rotate.error instanceof ApiError ? rotate.error.message : String(rotate.error) })), _jsxs("details", { open: typeof id !== 'number', children: [_jsx("summary", { className: "cursor-pointer text-sm", children: t('endpoint.hooks') }), _jsx("p", { className: "mt-2 text-xs text-muted-foreground", children: t('endpoint.hooksHint') }), _jsx("ul", { className: "mt-2 grid gap-1 text-sm", children: (hooks.data?.hooks ?? []).map((h) => (_jsxs("li", { children: [_jsx("code", { className: "font-mono text-xs", children: h.hook }), ' ', _jsx("span", { className: "text-muted-foreground", children: h.label })] }, h.hook))) }), hooks.data !== undefined && hooks.data.hooks.length === 0 ? (_jsx("p", { className: "mt-2 text-sm text-muted-foreground", children: t('endpoint.none') })) : null] })] }));
+}

package/dist/integrations/web/InboundTools.d.ts

@@ -0,0 +1,4 @@
+/** On an inbound call's form (RFC 0017 §5.4): handle a verified call again (after fixing what made it fail). */
+import { type NodeComponentProps } from '../../ui/index.js';
+import type { ReactElement } from 'react';
+export declare function InboundTools({ api, record }: NodeComponentProps): ReactElement | null;

package/dist/integrations/web/InboundTools.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** On an inbound call's form (RFC 0017 §5.4): handle a verified call again (after fixing what made it fail). */
+import { Alert, ApiError, Button } from '../../ui/index.js';
+import { useMutation } from '@tanstack/react-query';
+import { useTranslation } from 'react-i18next';
+export function InboundTools({ api, record }) {
+    const { t } = useTranslation('integrations');
+    const id = record?.['id'];
+    const replay = useMutation({
+        mutationFn: () => api.call('POST', `/api/v1/webhooks/inbound/${id}/replay`),
+    });
+    if (typeof id !== 'number' || record?.['verified'] !== true)
+        return null;
+    return (_jsxs("div", { className: "grid gap-2", children: [_jsx("div", { children: _jsx(Button, { variant: "secondary", busy: replay.isPending, onClick: () => replay.mutate(), children: t('inbound.replay') }) }), replay.isSuccess ? _jsx(Alert, { tone: "info", children: t('inbound.replayed') }) : null, replay.error === null ? null : (_jsx(Alert, { tone: "danger", children: replay.error instanceof ApiError ? replay.error.message : String(replay.error) }))] }));
+}

package/dist/integrations/web/WebhookTools.d.ts

@@ -0,0 +1,7 @@
+/**
+ * On a webhook's form (RFC 0017 §5.3): send a test event, rotate the signing secret, and the events this
+ * installation offers. The server checks and sends; the panel shows what it answers.
+ */
+import { type NodeComponentProps } from '../../ui/index.js';
+import type { ReactElement } from 'react';
+export declare function WebhookTools({ api, record, reload }: NodeComponentProps): ReactElement | null;

package/dist/integrations/web/WebhookTools.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * On a webhook's form (RFC 0017 §5.3): send a test event, rotate the signing secret, and the events this
+ * installation offers. The server checks and sends; the panel shows what it answers.
+ */
+import { Alert, ApiError, Button } from '../../ui/index.js';
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { useTranslation } from 'react-i18next';
+export function WebhookTools({ api, record, reload }) {
+    const { t } = useTranslation('integrations');
+    const id = record?.['id'];
+    const events = useQuery({
+        queryKey: ['integrations', 'events'],
+        queryFn: () => api.call('GET', '/api/v1/webhooks/events'),
+    });
+    const ping = useMutation({
+        mutationFn: () => api.call('POST', `/api/v1/webhooks/subscriptions/${id}/ping`),
+    });
+    const rotate = useMutation({
+        mutationFn: () => api.call('POST', `/api/v1/webhooks/subscriptions/${id}/rotate-secret`),
+        onSuccess: () => reload(),
+    });
+    const error = ping.error ?? rotate.error;
+    return (_jsxs("section", { className: "grid gap-3 rounded-lg border p-4", "aria-label": t('tools.title'), children: [typeof id !== 'number' ? null : (_jsxs("div", { className: "flex flex-wrap gap-2", children: [_jsx(Button, { variant: "secondary", busy: ping.isPending, onClick: () => ping.mutate(), children: t('tools.ping') }), _jsx(Button, { variant: "secondary", busy: rotate.isPending, onClick: () => rotate.mutate(), children: t('tools.rotate') })] })), ping.isSuccess ? _jsx(Alert, { tone: "info", children: t('tools.pinged') }) : null, error === null ? null : (_jsx(Alert, { tone: "danger", children: error instanceof ApiError ? error.message : String(error) })), _jsxs("details", { children: [_jsx("summary", { className: "cursor-pointer text-sm", children: t('tools.events') }), _jsx("p", { className: "mt-2 text-xs text-muted-foreground", children: t('tools.eventsHint') }), _jsx("ul", { className: "mt-2 grid max-h-64 gap-1 overflow-auto text-sm sm:grid-cols-2", children: (events.data?.events ?? []).map((e) => (_jsxs("li", { children: [_jsx("code", { className: "font-mono text-xs", children: e.event }), ' ', _jsx("span", { className: "text-muted-foreground", children: e.label })] }, e.event))) })] })] }));
+}