@teleporthq/teleport-plugin-next-workflows 0.43.1

package/__tests__/element-event-trigger-value.test.ts

@@ -0,0 +1,54 @@
+import { formControlPropertyReads } from '../src/trigger-generator'
+
+// Regression guard for the "SELECT onChange fires but the workflow's
+// `Trigger.value` resolver returns undefined" bug.
+//
+// The `event-element-event` trigger (used by every JSX onChange/onInput/
+// onBlur etc. that the GUI lets the user wire to a workflow) builds a
+// `triggerContext` object literal. The workflow executor's
+// `resolveContextRef` resolves `Trigger.value` by reading
+// `triggerContext.value` — without an entry for `value` (and `checked` for
+// checkboxes/radios, `files` for file inputs), every `state-update-local-
+// state` node wired to "Trigger.value" silently sets state to `undefined`
+// and the dropdown/checkbox/file picker becomes a no-op.
+//
+// This file pins the contract: the generator must emit `value`, `checked`,
+// `files` reads keyed to the right element-reference variable.
+describe('formControlPropertyReads', () => {
+  it('emits value/checked/files reads keyed off the given element reference', () => {
+    // `__te` is the convention inside the JSX-on-* matched-element
+    // handlers (event.currentTarget || event.target).
+    const snippet = formControlPropertyReads('__te')
+
+    expect(snippet).toContain('value: __te.value')
+    expect(snippet).toContain('checked: __te.checked')
+    expect(snippet).toContain('files: __te.files')
+  })
+
+  it('supports `event.target` for the document-listener fallback path', () => {
+    // The fallback handler attached via `addEventListener('change', ...)`
+    // uses `event.target` directly rather than the `__te` alias.
+    const snippet = formControlPropertyReads('event.target')
+
+    expect(snippet).toContain('value: event.target.value')
+    expect(snippet).toContain('checked: event.target.checked')
+    expect(snippet).toContain('files: event.target.files')
+  })
+
+  it('produces a snippet that drops cleanly into an object literal', () => {
+    const snippet = formControlPropertyReads('__te')
+    // Compose it into a literal the same way the trigger generators do —
+    // the trailing/leading commas and whitespace must allow inlining
+    // without producing invalid JS.
+    const literal = `{ elementId: 'x', ${snippet} }`
+
+    // Round-trip via Function to make sure the literal parses. We
+    // stub `__te` with a fake element so the reads don't throw.
+    const fn = new Function('__te', `return ${literal}`)
+    const result = fn({ value: 'rings', checked: false, files: null })
+
+    expect(result.value).toBe('rings')
+    expect(result.checked).toBe(false)
+    expect(result.files).toBe(null)
+  })
+})

package/__tests__/handler-output-shapes.test.ts

@@ -0,0 +1,252 @@
+import { loadHandler, HandlerFn } from './_helpers/load-handler'
+
+// Regression guard for "handler returns the wrong keys" bugs.
+//
+// Every workflow node has a schema-declared output shape. The workflow
+// editor uses that shape to advertise bindable fields — when a user clicks
+// "bind to <node>.foo", the GUI lists exactly the keys the schema says are
+// available. The runtime handler must materialise those keys at execution
+// time or the binding silently resolves to undefined and the user has no
+// idea why their workflow misbehaves.
+//
+// Audit (see /Users/pasca/.claude/plans/refactored-discovering-teacup.md)
+// found five handlers whose return shapes were missing keys their schemas
+// promised. This file pins the corrected contracts so they can never
+// regress, plus the edge cases each handler has to honour:
+//   - storage-*-get: `exists` distinguishes empty-string slots from absent
+//     slots; the storage-API-unavailable path still returns the schema-
+//     shaped envelope (with exists:false)
+//   - state-get-*: `key` echoes the user-typed property name even when
+//     __stateValues is missing (returns { value: undefined, key })
+//   - general-delay: `timestamp` is post-await wall-clock; `duration` is
+//     the resolved input
+
+type StorageStub = {
+  store: Record<string, string>
+  setItem(k: string, v: string): void
+  getItem(k: string): string | null
+  removeItem(k: string): void
+  clear(): void
+}
+
+const makeStorageStub = (): StorageStub => {
+  const store: Record<string, string> = {}
+  return {
+    store,
+    setItem(k, v) {
+      store[k] = String(v)
+    },
+    getItem(k) {
+      return Object.prototype.hasOwnProperty.call(store, k) ? store[k] : null
+    },
+    removeItem(k) {
+      delete store[k]
+    },
+    clear() {
+      for (const k of Object.keys(store)) {
+        delete store[k]
+      }
+    },
+  }
+}
+
+const installStorage = (property: 'localStorage' | 'sessionStorage'): StorageStub => {
+  const stub = makeStorageStub()
+  ;(globalThis as any)[property] = stub
+  return stub
+}
+
+const uninstallStorage = (property: 'localStorage' | 'sessionStorage') => {
+  delete (globalThis as any)[property]
+}
+
+describe('general-delay — emits { duration, timestamp }', () => {
+  let handler: HandlerFn
+
+  beforeAll(() => {
+    handler = loadHandler('general-delay')
+  })
+
+  it('returns the configured duration verbatim', async () => {
+    const result = (await handler({ duration: 25 }, {})) as Record<string, unknown>
+    expect(result.duration).toBe(25)
+  })
+
+  it('sets timestamp to the post-await wall clock', async () => {
+    const before = Date.now()
+    const result = (await handler({ duration: 5 }, {})) as Record<string, unknown>
+    const after = Date.now()
+    expect(typeof result.timestamp).toBe('number')
+    expect(result.timestamp).toBeGreaterThanOrEqual(before)
+    expect(result.timestamp).toBeLessThanOrEqual(after)
+  })
+
+  it('falls back to duration:0 and returns immediately when not configured', async () => {
+    const before = Date.now()
+    const result = (await handler({}, {})) as Record<string, unknown>
+    const after = Date.now()
+    expect(result.duration).toBe(0)
+    // `timestamp` must still be set even when duration is 0 — the schema
+    // promises it unconditionally.
+    expect(typeof result.timestamp).toBe('number')
+    expect(result.timestamp).toBeGreaterThanOrEqual(before)
+    expect(result.timestamp).toBeLessThanOrEqual(after)
+  })
+
+  it('never returns the legacy { success:true } shape', async () => {
+    // Locking in the migration: if this assertion ever flips, someone
+    // reverted to the old shape and downstream `<delay>.duration` bindings
+    // will silently resolve to undefined again.
+    const result = (await handler({ duration: 0 }, {})) as Record<string, unknown>
+    expect(result).not.toEqual({ success: true })
+  })
+})
+
+describe.each([['state-get-global-state'], ['state-get-local-state']])(
+  '%s — emits { value, key } from __stateValues',
+  (nodeType) => {
+    let handler: HandlerFn
+
+    beforeAll(() => {
+      handler = loadHandler(nodeType)
+    })
+
+    it('returns the slot value and the configured property name', async () => {
+      const result = (await handler(
+        { property: 'cartTotal' },
+        { __stateValues: { cartTotal: 42 } }
+      )) as Record<string, unknown>
+      expect(result.value).toBe(42)
+      expect(result.key).toBe('cartTotal')
+    })
+
+    it('echoes the original config.property even when the slot is absent', async () => {
+      // Honest-undefined: schema declares key as string, but if the GUI
+      // emits a malformed config the handler returns whatever the user
+      // typed (or undefined) — we don't fabricate a name.
+      const result = (await handler({ property: 'missingProp' }, { __stateValues: {} })) as Record<
+        string,
+        unknown
+      >
+      expect(result.value).toBeUndefined()
+      expect(result.key).toBe('missingProp')
+    })
+
+    it('handles missing __stateValues without throwing', async () => {
+      const result = (await handler({ property: 'whatever' }, {})) as Record<string, unknown>
+      expect(result.value).toBeUndefined()
+      expect(result.key).toBe('whatever')
+    })
+  }
+)
+
+describe.each([
+  ['storage-local-get', 'localStorage' as const],
+  ['storage-session-get', 'sessionStorage' as const],
+])('%s — emits { value, key, exists } from %s', (nodeType, backend) => {
+  let handler: HandlerFn
+  let stub: StorageStub
+
+  beforeAll(() => {
+    handler = loadHandler(nodeType)
+  })
+
+  beforeEach(() => {
+    stub = installStorage(backend)
+  })
+
+  afterEach(() => {
+    uninstallStorage(backend)
+  })
+
+  it('returns parsed JSON values with exists:true', async () => {
+    stub.setItem('order', JSON.stringify({ id: 'o-1', total: 99 }))
+    const result = (await handler({ key: 'order' }, {})) as Record<string, unknown>
+    expect(result.value).toEqual({ id: 'o-1', total: 99 })
+    expect(result.key).toBe('order')
+    expect(result.exists).toBe(true)
+  })
+
+  it('returns the raw string when the slot is not JSON, with exists:true', async () => {
+    stub.setItem('flag', 'a-plain-token')
+    const result = (await handler({ key: 'flag' }, {})) as Record<string, unknown>
+    expect(result.value).toBe('a-plain-token')
+    expect(result.exists).toBe(true)
+  })
+
+  it('treats an EMPTY STRING slot as a real value (exists:true)', async () => {
+    // Edge case: localStorage.getItem returns "" for empty-string slots and
+    // null for absent slots. The `exists` flag must distinguish the two.
+    stub.setItem('was-cleared', '')
+    const result = (await handler({ key: 'was-cleared' }, {})) as Record<string, unknown>
+    expect(result.value).toBe('')
+    expect(result.exists).toBe(true)
+  })
+
+  it('returns the configured defaultValue with exists:false when slot is absent', async () => {
+    const result = (await handler({ key: 'never-set', defaultValue: 'fallback' }, {})) as Record<
+      string,
+      unknown
+    >
+    expect(result.value).toBe('fallback')
+    expect(result.key).toBe('never-set')
+    expect(result.exists).toBe(false)
+  })
+
+  it('returns null + exists:false when slot is absent and no defaultValue', async () => {
+    const result = (await handler({ key: 'never-set' }, {})) as Record<string, unknown>
+    expect(result.value).toBeNull()
+    expect(result.exists).toBe(false)
+  })
+
+  it('returns the schema-shaped envelope when storage API is unavailable', async () => {
+    // Simulate SSR / incognito / hardened browser by removing the global.
+    uninstallStorage(backend)
+    const result = (await handler({ key: 'order', defaultValue: 'fb' }, {})) as Record<
+      string,
+      unknown
+    >
+    // We can't verify the slot, so exists is honestly false and value falls
+    // back to the configured default — matching the absent-slot branch.
+    expect(result.value).toBe('fb')
+    expect(result.key).toBe('order')
+    expect(result.exists).toBe(false)
+    // Restore so the afterEach uninstall() is a no-op rather than throwing.
+    installStorage(backend)
+  })
+})
+
+describe('overall return-shape contract', () => {
+  // A single matrix assertion that every handler this file covers exposes
+  // exactly the keys the schema declares (no missing keys, no surprises).
+  // If a future change drops a key, this fails fast with a clear diff.
+  it.each([
+    ['general-delay', { duration: 0 }, ['duration', 'timestamp']],
+    ['state-get-global-state', { property: 'foo' }, ['value', 'key']],
+    ['state-get-local-state', { property: 'foo' }, ['value', 'key']],
+  ])('%s exposes exactly the schema keys', async (nodeType, config, expectedKeys) => {
+    const handler = loadHandler(nodeType)
+    const ctx = nodeType.indexOf('state-get') === 0 ? { __stateValues: { foo: 'bar' } } : {}
+    const result = (await handler(config, ctx)) as Record<string, unknown>
+    for (const k of expectedKeys) {
+      expect(result).toHaveProperty(k)
+    }
+  })
+
+  it.each([
+    ['storage-local-get', 'localStorage' as const],
+    ['storage-session-get', 'sessionStorage' as const],
+  ])('%s exposes value, key, exists', async (nodeType, backend) => {
+    const stub = installStorage(backend)
+    stub.setItem('probe', '"v"')
+    try {
+      const handler = loadHandler(nodeType)
+      const result = (await handler({ key: 'probe' }, {})) as Record<string, unknown>
+      expect(result).toHaveProperty('value')
+      expect(result).toHaveProperty('key')
+      expect(result).toHaveProperty('exists')
+    } finally {
+      uninstallStorage(backend)
+    }
+  })
+})

package/__tests__/invoice-generate-hydration.test.ts

@@ -0,0 +1,131 @@
+import { generateInvoiceGenerateRouteCode } from '../src/invoice/api-routes-code'
+import { generateDataAccessCode } from '../src/invoice/data-access-code'
+import type { UIDLInvoiceSettings } from '@teleporthq/teleport-types'
+
+// Regression guards for the orderId-only payload path in /api/invoices/generate.
+//
+// Before the fix, the endpoint rejected any POST without `body.items`
+// with HTTP 400 "At least one item is required". The `ecommerce-generate-invoice`
+// workflow node only sends `{ orderId, sendEmail }` — so every webhook-driven
+// invoice call hit the reject path and no invoice was ever created.
+//
+// The fix hydrates the request from `teleport_orders` + `teleport_order_items`
+// when orderId is given. These tests lock in:
+//
+//   1. The data-access layer exposes a `getOrderWithItems` helper that
+//      returns the order row + items array (or null when the order
+//      doesn't exist).
+//   2. The invoice route calls that helper when `body.orderId` is truthy.
+//   3. The hydrated items flow into the `items` array when the caller
+//      didn't provide any, but body.items still wins when explicitly
+//      passed (future admin-side callers may want to override).
+//   4. Customer/payment fields fall back to the order columns so the
+//      rendered PDF has the buyer's name/address/payment info without
+//      the caller rebuilding the payload.
+
+// Minimal UIDLInvoiceSettings shape — the generators don't check
+// fields we don't exercise here.
+const FAKE_SETTINGS = {
+  invoicePrefix: 'INV-',
+  defaultTaxRate: 0,
+  showDiscount: false,
+  template: { document: null as unknown },
+  tables: { invoicesTable: 'teleport_invoices', invoiceItemsTable: 'teleport_invoice_items' },
+  emailDelivery: { enabled: false },
+} as unknown as UIDLInvoiceSettings
+
+describe('invoice data-access — getOrderWithItems', () => {
+  it('is exported from the PostgreSQL data-access module', () => {
+    const code = generateDataAccessCode(FAKE_SETTINGS, 'postgresql', null)
+    expect(code).toContain('async function getOrderWithItems(orderId)')
+    expect(code).toMatch(/SELECT \* FROM teleport_orders WHERE id = \$1 LIMIT 1/)
+    expect(code).toMatch(
+      /SELECT \* FROM teleport_order_items WHERE order_id = \$1 ORDER BY created_at ASC/
+    )
+    expect(code).toContain('getOrderWithItems: getOrderWithItems,')
+  })
+
+  it('returns null when the caller passes a falsy orderId', () => {
+    // Defensive guard — the invoice route relies on this. Without it, the
+    // downstream query would error with "invalid input syntax for type uuid".
+    const code = generateDataAccessCode(FAKE_SETTINGS, 'postgresql', null)
+    expect(code).toContain('if (!orderId) return null;')
+  })
+
+  it('generates MySQL + Supabase variants that also export getOrderWithItems', () => {
+    const mysql = generateDataAccessCode(FAKE_SETTINGS, 'mysql', null)
+    expect(mysql).toContain('async function getOrderWithItems(orderId)')
+    expect(mysql).toContain("execute('SELECT * FROM teleport_orders WHERE id = ? LIMIT 1'")
+    expect(mysql).toContain('getOrderWithItems: getOrderWithItems,')
+
+    const supabase = generateDataAccessCode(FAKE_SETTINGS, 'supabase', null)
+    expect(supabase).toContain('async function getOrderWithItems(orderId)')
+    expect(supabase).toContain(".from('teleport_orders')")
+    expect(supabase).toContain(".from('teleport_order_items')")
+    expect(supabase).toContain('getOrderWithItems: getOrderWithItems,')
+  })
+})
+
+describe('/api/invoices/generate — orderId hydration', () => {
+  const route = generateInvoiceGenerateRouteCode(FAKE_SETTINGS)
+
+  it('calls getOrderWithItems when body.orderId is provided', () => {
+    // This is the ONLY thing that lets the webhook-driven invoice call
+    // succeed — the workflow node sends {orderId, sendEmail} with no
+    // items, and without the hydration call the endpoint's "at least
+    // one item" guard rejects every payment webhook with HTTP 400.
+    expect(route).toContain('if (body.orderId) {')
+    expect(route).toContain('await dataAccess.getOrderWithItems(body.orderId)')
+  })
+
+  it('maps hydrated items from DB column names to invoice shape', () => {
+    // `teleport_order_items` rows carry `product_name`, `unit_price`,
+    // `total_price`. The invoice payload expects `name`, `unitPrice`,
+    // `totalPrice`. Locking in the mapping prevents silent drift.
+    expect(route).toContain("name: row.product_name || row.name || 'Item'")
+    expect(route).toContain('unitPrice: Number(row.unit_price || row.unitPrice || row.price) || 0')
+    expect(route).toContain('totalPrice: Number(row.total_price || row.totalPrice) || 0')
+  })
+
+  it('prefers body.items over hydrated items when both exist', () => {
+    // Admin "regenerate invoice with custom items" use cases need
+    // body.items to win. The condition checks length > 0 so an empty
+    // explicit array still falls back to DB-hydrated items.
+    expect(route).toContain('var items = Array.isArray(body.items) && body.items.length > 0')
+  })
+
+  it('falls back to order.billing_* / shipping_* fields for customer data', () => {
+    // teleport_orders carries billing_name/email/address for the buyer
+    // plus shipping_name/city/state/zip/country for the recipient. The
+    // invoice fields mirror this — we use billing fields primarily and
+    // fall back to shipping when billing is unset (matches "bill to
+    // different address" checkout path where only shipping is filled).
+    expect(route).toContain(
+      'orderRow.billing_name || orderRow.shipping_name || orderRow.customer_name'
+    )
+    expect(route).toContain('orderRow.billing_email || orderRow.customer_email')
+    expect(route).toContain('orderRow.billing_address || orderRow.shipping_address')
+    expect(route).toContain('orderRow.shipping_city')
+    expect(route).toContain('orderRow.payment_method')
+    expect(route).toContain('orderRow.payment_provider')
+    expect(route).toContain('orderRow.payment_intent_id')
+  })
+
+  it('uses the hydrated order.currency when body.currency is absent', () => {
+    // Same currency the buyer checked out with — otherwise an invoice
+    // generated from an EUR order would render as USD (the default).
+    expect(route).toContain(
+      'body.currency || (hydratedOrder && hydratedOrder.currency) || DEFAULT_CURRENCY'
+    )
+  })
+
+  it('isolates hydration failures so they never break the request', () => {
+    // If the DB query itself throws, we log and proceed with the
+    // caller-provided payload — any explicit body.items still works.
+    // Locking in the try/catch prevents a future refactor from
+    // surfacing DB errors to Stripe/PayPal as 5xx responses (which
+    // would trigger infinite webhook retries).
+    expect(route).toMatch(/try\s*\{[\s\S]*?await dataAccess\.getOrderWithItems/m)
+    expect(route).toContain('Invoice generation: order hydration failed')
+  })
+})