Add approvals and signals

import { z } from 'zod';
import { createStep, createWorkflow, fromInit, template, Integrations } from 'lua-cli';

const RefundRequest = z.object({ chargeId: z.string(), amount: z.number() });

const postRefund = createStep({
  id: 'postRefund',
  inputSchema: z.object({ approved: z.boolean(), editedPayload: RefundRequest.optional() }).passthrough(),
  outputSchema: z.object({ refundId: z.string().nullable() }),
  sideEffects: 'external',
  onError: 'park',
  requiredConnections: ['stripe'],
  async execute({ inputData, getStepResult, once }) {
    if (!inputData.approved) return { refundId: null };
    // The approval does not echo its payload back: read the edited copy, else the one it showed.
    const request = inputData.editedPayload ?? getStepResult<z.infer<typeof RefundRequest>>('request');
    const refundId = await once(`refund:${request.chargeId}`, async () => {
      const res = await Integrations.passthrough('stripe', {
        method: 'POST',
        path: '/v1/refunds',
        data: { charge: request.chargeId, amount: request.amount },
      });
      return (res.data as { id: string }).id;
    });
    return { refundId };
  },
});

export const refundApproval = createWorkflow({
  name: 'refund-approval',
  description: 'Ask a support lead to approve a refund, then post it through Stripe.',
  inputSchema: RefundRequest,
  outputSchema: z.object({ refundId: z.string().nullable() }),
  budget: { maxCredits: 5, maxDurationSeconds: 14 * 24 * 3600 },
  connections: [{ key: 'stripe', integrationType: 'stripe', required: true, description: 'Posts refunds' }],
})
  .map({ chargeId: fromInit('chargeId'), amount: fromInit('amount') }, { id: 'request' })
  .approval('approveRefund', {
    title: 'Refund request',
    details: template('Refund ${initData.amount} on charge ${initData.chargeId}'),
    approver: { role: 'support-lead' },
    excludeInitiator: true,
    timeoutHours: 8,
    businessHours: { tz: 'Europe/London', calendar: 'mon-fri' },
    onTimeout: [{ escalateTo: 'org-admins', timeoutHours: 24 }, 'deny'],
    onDeny: 'continue',
    editablePaths: ['amount'],
    editedPayloadSchema: RefundRequest.extend({ amount: z.number().positive().max(500) }),
  })
  .then(postRefund)
  .commit();

import { z } from 'zod';
import { createStep, createWorkflow, fromInit, Data } from 'lua-cli';

const Payment = z.object({ invoiceId: z.string(), amount: z.number() });

const closeInvoice = createStep({
  id: 'closeInvoice',
  inputSchema: z.object({ received: z.boolean().optional(), payload: Payment.optional() }).passthrough(),
  outputSchema: z.object({ closed: z.boolean() }),
  async execute({ inputData, getInitData, once }) {
    if (!inputData.payload) return { closed: false };
    const { invoiceId } = getInitData<{ invoiceId: string }>();
    await once(`close:${invoiceId}`, async () => (await Data.create('closed-invoices', { invoiceId })).id);
    return { closed: true };
  },
});

export const invoicePaid = createWorkflow({
  name: 'invoice-paid',
  description: 'Wait for a payment webhook, then close the invoice.',
  inputSchema: z.object({ invoiceId: z.string() }),
  outputSchema: z.object({ closed: z.boolean() }),
})
  .map({ invoiceId: fromInit('invoiceId') }, { id: 'sent' })
  .waitForSignal('payment', {
    signal: 'payment.received',
    schema: Payment,
    timeoutHours: 72,
    onTimeout: 'continue',
    acceptedSources: ['webhook', 'api'],
  })
  .then(closeInvoice)
  .commit();

import { z } from 'zod';
import { LuaWebhook, Workflows } from 'lua-cli';

export default new LuaWebhook({
  name: 'payment-received',
  description: 'Payment provider callback: signals the waiting invoice-paid run',
  bodySchema: z.object({ eventId: z.string(), invoiceId: z.string(), amount: z.number() }),
  async execute(event) {
    const { eventId, invoiceId, amount } = event.body as { eventId: string; invoiceId: string; amount: number };
    const { delivered } = await Workflows.signalByKey(
      'invoice-paid',
      `invoice:${invoiceId}`,
      'payment.received',
      { invoiceId, amount },
      { dedupeKey: eventId }
    );
    return { delivered };
  },
});

🧾 Approval wfa_d162baea11142a5922c1306fa932eafd · revision 0 · fingerprint sha256-cj1:854973c69edea38625bfebf2b0308a189eceefcd321145a90888984674738606
   Editable: yes — drafts, drafts[*].body · 708 bytes
   Payload:
     {
       "drafts": [
         {
           "to": "[email protected]",
           "subject": "Quick intro for Acme",
…
✨ Edit and approve against this revision:
   Approve:  `lua workflows approve wfr_dbd92cd2-034e-48e5-bfb7-cf758ece98bf --approval wfa_d162baea11142a5922c1306fa932eafd --edit @edited.json --fingerprint sha256-cj1:854973c69edea38625bfebf2b0308a189eceefcd321145a90888984674738606`

🧭 Running workflow locally: refund-approval
[18:04:09] run local-1789236249226 · 3 planned step(s)
[18:04:09] request · completed
[18:04:09] approveRefund · completed
[18:04:09] postRefund · completed
[18:04:09] run · completed

Workflow returned: Object — fields: refundId
Output:
{ refundId: null }
…