@teleporthq/teleport-plugin-next-workflows 0.45.4 → 0.45.6

package/__tests__/automations-bus.test.ts

@@ -2887,6 +2887,360 @@ describe('in-app event bus — the mail automations send', () => {
   })
 })
 
+describe('in-app event bus — a run that sent nothing', () => {
+  const mail = (id: string, to: unknown, label: string, stepNumber: number, extra: Row = {}) => ({
+    id,
+    type: 'email-resend',
+    config: {
+      apiKey: 'k',
+      from: 'shop@example.com',
+      to,
+      subject: 'Order paid',
+      body: '<p>Order paid</p>',
+      ...extra,
+    },
+    stepNumber,
+    label,
+  })
+  const gate = (stepNumber: number, left: unknown, rightValue: string) => ({
+    id: 'gate',
+    type: 'general-if-statement',
+    config: { leftValue: left, operator: 'equals', rightValue },
+    stepNumber,
+    label: 'Check',
+  })
+  const OWNER = 'owner@shop.test'
+  const orderNumber = ref('t', ['order', 'number'])
+  const userEmail = ref('t', ['user', 'email'])
+  const onPaid = (id: string, nodes: Row[], edges: Row[]) => ({
+    id,
+    name: id,
+    trigger: trigger('order-paid'),
+    nodes,
+    edges,
+  })
+  const toGate = { id: 'e1', source: 't', target: 'gate' }
+  const whenTrue = { id: 'e2', source: 'gate', target: 'send', sourceHandle: 'true' }
+  const guarded = (id: string, rightValue: string) =>
+    onPaid(
+      id,
+      [gate(1, orderNumber, rightValue), mail('send', OWNER, 'Send Email to Owner', 2)],
+      [toGate, whenTrue]
+    )
+  const afterPost = { id: 'e0', source: 't', target: 'hold' }
+  const holdToGate = { id: 'e1', source: 'hold', target: 'gate' }
+  const parks = {
+    id: 'wait',
+    type: 'general-wait',
+    config: { amount: 1, unit: 'days' },
+    label: 'Wait a day',
+  }
+  const WORKFLOWS: Record<string, Row> = {
+    'wf-skipped': guarded('wf-skipped', 'NOT-THIS-ORDER'),
+    'wf-sent': guarded('wf-sent', 'ORD-1042'),
+    'wf-no-recipient': onPaid(
+      'wf-no-recipient',
+      [mail('send', ref('t', ['order', 'nobody']), 'Send', 1)],
+      [{ id: 'e1', source: 't', target: 'send' }]
+    ),
+    'wf-failed-and-went-on': onPaid(
+      'wf-failed-and-went-on',
+      [mail('send', ref('t', ['order', 'nobody']), 'Send', 1, { continueOnError: true })],
+      [{ id: 'e1', source: 't', target: 'send' }]
+    ),
+    'wf-one-of-two': onPaid(
+      'wf-one-of-two',
+      [
+        gate(1, orderNumber, 'NOT-THIS-ORDER'),
+        mail('send', OWNER, 'Skipped', 2),
+        mail('other', OWNER, 'Sent', 3),
+      ],
+      [toGate, whenTrue, { id: 'e3', source: 'gate', target: 'other', sourceHandle: 'false' }]
+    ),
+    'wf-slow-skipped': onPaid(
+      'wf-slow-skipped',
+      [
+        post('hold', '/hold', 1),
+        gate(2, orderNumber, 'NOT-THIS-ORDER'),
+        mail('send', OWNER, 'Send Email to Owner', 3),
+      ],
+      [afterPost, holdToGate, whenTrue]
+    ),
+    'wf-wait-then-skipped': {
+      id: 'wf-wait-then-skipped',
+      name: 'wf-wait-then-skipped',
+      trigger: trigger('user-signed-up'),
+      nodes: [
+        { ...parks, stepNumber: 1 },
+        post('hold', '/hold', 2),
+        gate(3, userEmail, 'nobody@example.com'),
+        mail('send', OWNER, 'Send Email to Owner', 4),
+      ],
+      edges: [
+        { id: 'e0', source: 't', target: 'wait' },
+        { id: 'e1', source: 'wait', target: 'hold' },
+        holdToGate,
+        whenTrue,
+      ],
+    },
+    'wf-mail-then-wait': {
+      id: 'wf-mail-then-wait',
+      name: 'wf-mail-then-wait',
+      trigger: trigger('user-signed-up'),
+      nodes: [
+        mail('send', OWNER, 'Welcome', 1),
+        { ...parks, stepNumber: 2 },
+        post('after', '/after', 3),
+      ],
+      edges: [
+        { id: 'e0', source: 't', target: 'send' },
+        { id: 'e1', source: 'send', target: 'wait' },
+        { id: 'e2', source: 'wait', target: 'after' },
+      ],
+    },
+  }
+  const NOTE = JSON.stringify({ sentNothing: ['Send Email to Owner'] })
+  let files: Map<string, string>
+
+  beforeAll(async () => {
+    files = sources(await generate(WORKFLOWS))
+  })
+
+  const paidOrder = (workflowId: string) => {
+    const db = new FakeDatabase()
+    seedOrderPaid(db)
+    db.automations = [automationRow(workflowId, 'order-paid')]
+    return db
+  }
+  const signup = (workflowId: string) => {
+    const db = new FakeDatabase()
+    db.users.push({ id: 'user-1', email: 'noah@example.com', name: 'Noah', created_at: ago(1000) })
+    db.automations = [automationRow(workflowId, 'user-signed-up')]
+    db.events.push(
+      eventRow({
+        id: 'evt-signup',
+        event_type: 'user-signed-up',
+        entity_type: 'user',
+        entity_id: 'user-1',
+        actor: 'noah@example.com',
+        actor_type: 'customer',
+      })
+    )
+    return db
+  }
+  const dispatch = (db: FakeDatabase) =>
+    withEcho(() =>
+      silenced(() => (createApp(files, db)('lib/automations/event-bus.js') as Bus).dispatch({}))
+    )
+  /** A dispatch waiting 20 ms for a handler held at its first fetch, released afterwards. */
+  const dispatchHeldOpen = async (db: FakeDatabase) => {
+    const held: Array<() => void> = []
+    const scope = globalThis as Record<string, unknown>
+    const previousFetch = scope.fetch
+    scope.fetch = () =>
+      new Promise((resolve) => {
+        held.push(() =>
+          resolve({
+            ok: true,
+            status: 200,
+            headers: new Map([['content-type', 'application/json']]),
+            json: async () => ({}),
+            text: async () => '{}',
+          })
+        )
+      })
+    try {
+      await withEnv(ENV, () =>
+        silenced(async () => {
+          await (createApp(files, db)('lib/automations/event-bus.js') as Bus).dispatch({
+            handlerTimeoutMs: 20,
+          })
+          expect(held).toHaveLength(1)
+          held[0]()
+          await new Promise((resolve) => setTimeout(resolve, 10))
+        })
+      )
+    } finally {
+      scope.fetch = previousFetch
+    }
+  }
+
+  it('records the send steps a condition skipped, and the run stays delivered', async () => {
+    const db = paidOrder('wf-skipped')
+
+    const result = await dispatch(db)
+
+    expect(result).toEqual({ claimed: 1, delivered: 1, failed: 0, resumed: 0 })
+    expect(db.mailSent).toEqual([])
+    expect(db.delivery('wf-skipped')).toMatchObject({ status: 'delivered', error: NOTE })
+    expect(db.events[0]).toMatchObject({ status: 'delivered', attempts: 1 })
+  })
+
+  it('records nothing when a send step sent, or when the automation has none', async () => {
+    const sent = paidOrder('wf-sent')
+    await dispatch(sent)
+    expect(sent.mailSent).toHaveLength(1)
+    expect(sent.delivery('wf-sent')).toMatchObject({ status: 'delivered', error: null })
+
+    const oneOfTwo = paidOrder('wf-one-of-two')
+    await dispatch(oneOfTwo)
+    expect(oneOfTwo.mailSent).toHaveLength(1)
+    expect(oneOfTwo.delivery('wf-one-of-two')).toMatchObject({ status: 'delivered', error: null })
+  })
+
+  it('counts a send that failed and went on as unsent', async () => {
+    const db = paidOrder('wf-failed-and-went-on')
+    await dispatch(db)
+    expect(db.delivery('wf-failed-and-went-on')).toMatchObject({
+      status: 'delivered',
+      error: JSON.stringify({ sentNothing: ['Send'] }),
+    })
+  })
+
+  it('leaves a send that stops the run failing as before, with its own error', async () => {
+    const db = paidOrder('wf-no-recipient')
+    const result = await dispatch(db)
+    expect(result).toEqual({ claimed: 1, delivered: 0, failed: 1, resumed: 0 })
+    expect(db.mailSent).toEqual([])
+    expect(db.delivery('wf-no-recipient')).toMatchObject({
+      status: 'failed',
+      error: 'No recipient',
+    })
+  })
+
+  it('records it for a run that ends after the dispatcher stopped waiting', async () => {
+    const db = paidOrder('wf-slow-skipped')
+    await dispatchHeldOpen(db)
+    expect(db.delivery('wf-slow-skipped')).toMatchObject({ status: 'delivered', error: NOTE })
+  })
+
+  it('records it for a run resumed after its Wait', async () => {
+    const db = signup('wf-wait-then-skipped')
+    await dispatch(db)
+    expect(db.delivery('wf-wait-then-skipped')).toMatchObject({ status: 'waiting', error: null })
+
+    db.waits[0].run_at = ago(1000)
+    await dispatch(db)
+
+    expect(db.delivery('wf-wait-then-skipped')).toMatchObject({
+      status: 'delivered',
+      error: NOTE,
+    })
+  })
+
+  it('records it for a resume that ends after the dispatcher stopped waiting', async () => {
+    const db = signup('wf-wait-then-skipped')
+    await dispatch(db)
+    db.waits[0].run_at = ago(1000)
+    await dispatchHeldOpen(db)
+    expect(db.delivery('wf-wait-then-skipped')).toMatchObject({
+      status: 'delivered',
+      error: NOTE,
+    })
+  })
+
+  it('counts a mail sent before the Wait when the run resumes after it', async () => {
+    const db = signup('wf-mail-then-wait')
+    await dispatch(db)
+    db.waits[0].run_at = ago(1000)
+    await dispatch(db)
+    expect(db.mailSent).toHaveLength(1)
+    expect(db.delivery('wf-mail-then-wait')).toMatchObject({ status: 'delivered', error: null })
+  })
+
+  it('records it for a test event, whose row stays a test', async () => {
+    const db = paidOrder('wf-skipped')
+    db.events = []
+
+    const result = await withEcho(() =>
+      silenced(() => {
+        const { runTest } = createApp(files, db)('lib/automations/dispatcher.js') as {
+          runTest(input: Row, options: Row): Promise<Totals>
+        }
+        return runTest(
+          {
+            workflowId: 'wf-skipped',
+            event: { order: { number: 'ORD-TEST', customer: { email: 'test@example.com' } } },
+          },
+          {}
+        )
+      })
+    )
+
+    expect(result).toEqual({ claimed: 1, delivered: 1, failed: 0, resumed: 0 })
+    expect(db.delivery('wf-skipped')).toMatchObject({ status: 'test', error: NOTE })
+  })
+
+  describe('which steps a run can report', () => {
+    const sendStepsOf = async (workflow: Row): Promise<Row[]> => {
+      const { generateHandlerFunction } = await import('../src/api-route-generator')
+      const source = generateHandlerFunction(JSON.parse(JSON.stringify(workflow)))
+      return JSON.parse(/var SEND_STEPS = (.*);/.exec(source)![1])
+    }
+    const sms = {
+      id: 'text',
+      type: 'sms-twilio',
+      config: { to: '+15550142', message: 'Paid' },
+      stepNumber: 3,
+      label: 'Text the owner',
+    }
+    const email = mail('send', OWNER, 'Send Email to Owner', 2)
+    const steps = [
+      { id: 'send', label: 'Send Email to Owner' },
+      { id: 'text', label: 'Text the owner' },
+    ]
+
+    it('lists the email and SMS steps, and nothing else', async () => {
+      expect(await sendStepsOf(onPaid('w', [post('p', '/p', 1), email, sms], []))).toEqual(steps)
+      expect(await sendStepsOf(onPaid('w', [post('p', '/p', 1)], []))).toEqual([])
+    })
+
+    it('leaves out the steps of the error branch, which a run that ends well never reaches', async () => {
+      const onError = mail('alarm', OWNER, 'Tell me it broke', 4)
+      const workflow = {
+        ...onPaid(
+          'w',
+          [
+            email,
+            { id: 'err', type: 'event-workflow-error', config: {}, stepNumber: 3, label: 'Error' },
+            onError,
+          ],
+          [{ id: 'e1', source: 'err', target: 'alarm' }]
+        ),
+        errorHandler: { nodeId: 'err' },
+      }
+      expect(await sendStepsOf(workflow)).toEqual([{ id: 'send', label: 'Send Email to Owner' }])
+    })
+
+    it('reports nothing when a step it cannot see may have sent', async () => {
+      const customNode = {
+        id: 'custom',
+        type: 'general-custom-node',
+        config: {},
+        stepNumber: 1,
+        label: 'Custom',
+      }
+      const parallel = (config: Row) => ({
+        id: 'both',
+        type: 'general-parallel',
+        config,
+        stepNumber: 1,
+        label: 'Both',
+      })
+      expect(await sendStepsOf(onPaid('w', [customNode, email], []))).toEqual([])
+      expect(await sendStepsOf(onPaid('w', [parallel({ waitForAll: false }), email], []))).toEqual(
+        []
+      )
+      expect(await sendStepsOf(onPaid('w', [parallel({ waitForAll: true }), email], []))).toEqual([
+        { id: 'send', label: 'Send Email to Owner' },
+      ])
+      expect(await sendStepsOf(onPaid('w', [parallel({}), email], []))).toEqual([
+        { id: 'send', label: 'Send Email to Owner' },
+      ])
+    })
+  })
+})
+
 describe('in-app event bus — emitting and the dispatch route', () => {
   let files: Map<string, string>
 

package/__tests__/public-step-guards.test.ts

@@ -3,6 +3,7 @@ import adminFileWorkflows from './fixtures/admin-file-workflows.json'
 import {
   PUBLIC_STEP_REFUSAL_CODE,
   PublicStepRefusalError,
+  assertNoPublicRestrictedSteps,
   findPublicRestrictedSteps,
 } from '../src/public-step-guards'
 
@@ -234,6 +235,31 @@ describe('restricted steps on a public route', () => {
     expect(error).toBeInstanceOf(PublicStepRefusalError)
   })
 
+  it('on a site without sign-in, says to enable authentication before any role can be asked', () => {
+    const workflows = {
+      workflows: { w1: pageWorkflow([node('n1', 'file-storage-delete', 'Delete Upload')]) },
+    }
+    const refusedWith = (authentication: unknown): string => {
+      try {
+        assertNoPublicRestrictedSteps(workflows, authentication as never)
+      } catch (error) {
+        return shownSentence(error as Error)
+      }
+      throw new Error('not refused')
+    }
+
+    for (const withoutSignIn of [refusedWith(null), refusedWith({ enabled: false, roles: [] })]) {
+      expect(withoutSignIn).toContain('"Delete Upload"')
+      expect(withoutSignIn).toContain('has no sign-in')
+      expect(withoutSignIn).toContain('enable authentication')
+      expect(withoutSignIn).not.toContain('let only the role')
+      expect(withoutSignIn.length).toBeLessThanOrEqual(400)
+    }
+    const withSignIn = refusedWith({ enabled: true, roles: ['admin', 'user'] })
+    expect(withSignIn).toContain('let only the role "admin" start it')
+    expect(withSignIn).not.toContain('has no sign-in')
+  })
+
   it('stays one short sentence for many steps', () => {
     const nodes = Array.from({ length: 12 }, (_, i) =>
       node(

package/dist/cjs/account-delete-route-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"account-delete-route-generator.d.ts","sourceRoot":"","sources":["../../src/account-delete-route-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AAcxE,MAAM,WAAW,yBAAyB;IAExC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAI3B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;IAGtB,kBAAkB,CAAC,EAAE,2BAA2B,CAAA;IAEhD,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAG5B,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAID,eAAO,MAAM,8BAA8B,+CAAiC,CAAA;AAE5E,eAAO,MAAM,0BAA0B,aAAa,yBAAyB,KAAQ,MAwbpF,CAAA"}
+{"version":3,"file":"account-delete-route-generator.d.ts","sourceRoot":"","sources":["../../src/account-delete-route-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AAcxE,MAAM,WAAW,yBAAyB;IAExC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAI3B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;IAGtB,kBAAkB,CAAC,EAAE,2BAA2B,CAAA;IAEhD,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAG5B,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAID,eAAO,MAAM,8BAA8B,+CAAiC,CAAA;AAE5E,eAAO,MAAM,0BAA0B,aAAa,yBAAyB,KAAQ,MAicpF,CAAA"}

package/dist/cjs/account-delete-route-generator.js

@@ -275,19 +275,28 @@ function readRequestPassword(req) {
   return String(body.password);
 }
 
-// The sign-in check (utils/auth/hash-password.js verifyPassword): bcrypt over
-// the SHA-256 of the password and AUTH_PEPPER. An account without a stored
-// password (a social sign-in) matches no password.
+// The sign-in check (utils/auth/hash-password.js checkPassword): bcrypt over
+// the SHA-256 of the password and a pepper, the project's own
+// (AUTH_PEPPER_SECRET) first, then the one every earlier hash used
+// (AUTH_PEPPER). An account without a stored password (a social sign-in)
+// matches no password.
 function passwordMatches(password, storedHash) {
   if (!storedHash || password.length > 1000) { return false; }
   var bcrypt = require('bcryptjs');
   var crypto = require('crypto');
-  var prepared = crypto.createHash('sha256').update(password + (process.env.AUTH_PEPPER || '')).digest('base64');
-  try {
-    return bcrypt.compareSync(prepared, String(storedHash));
-  } catch (e) {
-    return false;
+  var secret = process.env.AUTH_PEPPER_SECRET;
+  var peppers = typeof secret === 'string' && secret && secret.indexOf('teleporthq.secrets.') !== 0
+    ? [secret, process.env.AUTH_PEPPER || '']
+    : [process.env.AUTH_PEPPER || ''];
+  for (var i = 0; i < peppers.length; i++) {
+    var prepared = crypto.createHash('sha256').update(password + peppers[i]).digest('base64');
+    try {
+      if (bcrypt.compareSync(prepared, String(storedHash))) { return true; }
+    } catch (e) {
+      return false;
+    }
   }
+  return false;
 }
 
 ${(0, transactional_email_code_1.generateFillTemplateFn)()}

package/dist/cjs/account-delete-route-generator.js.map

@@ -1 +1 @@
-{"version":3,"file":"account-delete-route-generator.js","sourceRoot":"","sources":["../../src/account-delete-route-generator.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"account-delete-route-generator.js","sourceRoot":"","sources":["../../src/account-delete-route-generator.ts"],"names":[],"mappings":"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"}

package/dist/cjs/api-route-generator.d.ts

@@ -65,6 +65,8 @@ export declare const generateWebhookWorkflowAPIRoute: (workflow: UIDLWorkflow, c
  * nothing and resolves `{ waiting: true, wouldWait }`; a Wait with no step
  * after it stores nothing and the run ends there). A run that fails rejects,
  * after the error-handler branch ran, so the dispatcher records the failure.
+ * A run that ends with its email and SMS steps all unsent resolves with their
+ * names under `sentNothing`, so the History can say so instead of Done.
  */
 export declare const generateHandlerFunction: (workflow: UIDLWorkflow, customNodes?: Record<string, UIDLCustomWorkflowNode>) => string;
 export declare const getWebhookRouteFileName: (workflow: UIDLWorkflow) => string;

package/dist/cjs/api-route-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-route-generator.d.ts","sourceRoot":"","sources":["../../src/api-route-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EAGb,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AAkEvE,MAAM,WAAW,yBAAyB;IACxC,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB;;;;OAIG;IACH,KAAK,CAAC,EAAE,YAAY,CAAA;IACpB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;CACrD;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAA;AAEhC,wEAAwE;AACxE,eAAO,MAAM,wBAAwB;;;CAAiC,CAAA;AAEtE,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,4CAA4C,CAAA;AA+O7E,eAAO,MAAM,6BAA6B,YAC/B,eAAe,iBACT,MAAM,eACR,sBAAsB,YAC1B,yBAAyB,KACjC,MAyXF,CAAA;AAED,eAAO,MAAM,kBAAkB,YAAa,eAAe,KAAG,OAE7D,CAAA;AAED,eAAO,MAAM,sCAAsC,YACxC,eAAe,iBACT,MAAM,eACR,sBAAsB,YAC1B,yBAAyB,KACjC,MAycF,CAAA;AA6ID;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,aA4D5B,CAAA;AAEF,qDAAqD;AACrD,MAAM,WAAW,0BAA0B;IACzC,kEAAkE;IAClE,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAqBD,eAAO,MAAM,oBAAoB,aACrB,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,YAC3C,0BAA0B,KAClC,MA0HF,CAAA;AAED,eAAO,MAAM,mBAAmB,eAClB,MAAM,aACP,MAAM,iBACF,MAAM,KACpB,MA4BF,CAAA;AAED,eAAO,MAAM,oBAAoB,aAAc,YAAY,KAAG,MAa7D,CAAA;AAsTD,uHAAuH;AACvH,eAAO,MAAM,uBAAuB,kBAAmB,iBAAiB,KAAG,OAES,CAAA;AAEpF,eAAO,MAAM,+BAA+B,aAChC,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,YAC3C,0BAA0B,KAClC,MAkOF,CAAA;AAuCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,uBAAuB,aACxB,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MA8JF,CAAA;AAED,eAAO,MAAM,uBAAuB,aAAc,YAAY,KAAG,MAiBhE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,cAC1B,aAAa,GAAG,SAAS,cACxB,MAAM,KACjB,MAAM,GAAG,IAYX,CAAA;AAED,eAAO,MAAM,mBAAmB,aAAc,YAAY,KAAG,MAAM,EAqBlE,CAAA"}
+{"version":3,"file":"api-route-generator.d.ts","sourceRoot":"","sources":["../../src/api-route-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EAGb,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AAuEvE,MAAM,WAAW,yBAAyB;IACxC,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB;;;;OAIG;IACH,KAAK,CAAC,EAAE,YAAY,CAAA;IACpB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;CACrD;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAA;AAEhC,wEAAwE;AACxE,eAAO,MAAM,wBAAwB;;;CAAiC,CAAA;AAEtE,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,4CAA4C,CAAA;AA+O7E,eAAO,MAAM,6BAA6B,YAC/B,eAAe,iBACT,MAAM,eACR,sBAAsB,YAC1B,yBAAyB,KACjC,MAyXF,CAAA;AAED,eAAO,MAAM,kBAAkB,YAAa,eAAe,KAAG,OAE7D,CAAA;AAED,eAAO,MAAM,sCAAsC,YACxC,eAAe,iBACT,MAAM,eACR,sBAAsB,YAC1B,yBAAyB,KACjC,MAycF,CAAA;AA6ID;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,aA4D5B,CAAA;AAEF,qDAAqD;AACrD,MAAM,WAAW,0BAA0B;IACzC,kEAAkE;IAClE,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAqBD,eAAO,MAAM,oBAAoB,aACrB,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,YAC3C,0BAA0B,KAClC,MA0HF,CAAA;AAED,eAAO,MAAM,mBAAmB,eAClB,MAAM,aACP,MAAM,iBACF,MAAM,KACpB,MA4BF,CAAA;AAED,eAAO,MAAM,oBAAoB,aAAc,YAAY,KAAG,MAa7D,CAAA;AAsTD,uHAAuH;AACvH,eAAO,MAAM,uBAAuB,kBAAmB,iBAAiB,KAAG,OAES,CAAA;AAEpF,eAAO,MAAM,+BAA+B,aAChC,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,YAC3C,0BAA0B,KAClC,MAkOF,CAAA;AAkED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,uBAAuB,aACxB,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MA8KF,CAAA;AAED,eAAO,MAAM,uBAAuB,aAAc,YAAY,KAAG,MAiBhE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,cAC1B,aAAa,GAAG,SAAS,cACxB,MAAM,KACjB,MAAM,GAAG,IAYX,CAAA;AAED,eAAO,MAAM,mBAAmB,aAAc,YAAY,KAAG,MAAM,EAqBlE,CAAA"}

package/dist/cjs/api-route-generator.js

@@ -8,6 +8,7 @@ const nodes_1 = require("./nodes");
 const types_1 = require("./nodes/types");
 const general_wait_1 = require("./nodes/general/general-wait");
 const visitor_request_1 = require("./nodes/general/visitor-request");
+const message_trust_1 = require("./nodes/email/message-trust");
 const outbound_message_guard_1 = require("./nodes/email/outbound-message-guard");
 const ai_provider_utils_1 = require("./nodes/ai/ai-provider-utils");
 const automations_scope_1 = require("./automations/automations-scope");
@@ -1916,6 +1917,29 @@ const generateErrorHandlerRunBlock = (failureLabel) => `    if (ERROR_HANDLER_NO
         console.error('${failureLabel}', innerErr);
       }
     }`;
+/**
+ * The email and SMS steps a run of this automation can report as not having
+ * sent. None when it could not tell: a custom node may send by itself, and a
+ * parallel branch the run does not wait for has no result when the run ends.
+ * Steps on the error branch do not count: a run that ends well never reaches them.
+ */
+const reportableSendSteps = (workflow, errorHandlerNodes) => {
+    const nodes = workflow.nodes || [];
+    const couldNotTell = nodes.some((node) => {
+        var _a;
+        return node.type === 'general-custom-node' ||
+            (node.type === 'general-parallel' &&
+                ((_a = node.config) === null || _a === void 0 ? void 0 : _a.waitForAll) !== undefined &&
+                node.config.waitForAll !== true);
+    });
+    if (couldNotTell) {
+        return [];
+    }
+    const errorBranch = new Set((errorHandlerNodes || []).map((node) => node.id));
+    return nodes
+        .filter((node) => (0, visitor_request_1.isOutboundMessageNodeType)(node.type) && !errorBranch.has(node.id))
+        .map((node) => ({ id: node.id, label: (0, message_trust_1.stepNameOf)(node) }));
+};
 /**
  * An automation's handler module (`lib/automations/handlers/<file>.js`, see
  * automations/handler-module-generator.ts): the webhook route's node loop as
@@ -1935,6 +1959,8 @@ const generateErrorHandlerRunBlock = (failureLabel) => `    if (ERROR_HANDLER_NO
  * nothing and resolves `{ waiting: true, wouldWait }`; a Wait with no step
  * after it stores nothing and the run ends there). A run that fails rejects,
  * after the error-handler branch ran, so the dispatcher records the failure.
+ * A run that ends with its email and SMS steps all unsent resolves with their
+ * names under `sentNothing`, so the History can say so instead of Done.
  */
 const generateHandlerFunction = (workflow, customNodes) => {
     var _a;
@@ -1992,6 +2018,8 @@ const WORKFLOW_CONFIG = ${workflowConfig};
 
 var ERROR_HANDLER_NODES = ${errorHandlerNodesJson};
 
+var SEND_STEPS = ${JSON.stringify(reportableSendSteps(workflow, errorHandlerNodes))};
+
 const nodeHandlers = {
 ${nodeHandlersEntries}
 };
@@ -2033,6 +2061,17 @@ ${executionLoop}
     return { waiting: false };
 }
 
+// The names of the send steps when the run has some and none of them sent: a
+// step a condition skipped has no result, one that failed and went on says so.
+function unsentSendSteps(context) {
+  if (SEND_STEPS.length === 0) return null;
+  var sent = SEND_STEPS.some(function(step) {
+    var result = context[step.id];
+    return !!result && !utils.isFatalNodeResult(result);
+  });
+  return sent ? null : SEND_STEPS.map(function(step) { return step.label; });
+}
+
 async function run(event, context, resumeFrom) {
   context = context && typeof context === 'object' ? context : {};
   // Shared fire-and-forget queue — drained before the run settles.
@@ -2065,13 +2104,16 @@ async function run(event, context, resumeFrom) {
     sourceRef: WORKFLOW_ID,
     orderId: trigger.order && trigger.order.id ? String(trigger.order.id) : null,
   };
+  var outcome;
   try {
-    return await runNodes(context, resumeFrom || null);
+    outcome = await runNodes(context, resumeFrom || null);
   } catch (error) {
 ${generateErrorHandlerRunBlock('Automation error handler failed:')}
     await utils.settlePendingNodePromises(context);
     throw error;
   }
+  var unsent = outcome.waiting ? null : unsentSendSteps(context);
+  return unsent ? Object.assign({}, outcome, { sentNothing: unsent }) : outcome;
 }
 
 module.exports.run = run;