@teleporthq/teleport-plugin-next-workflows 0.43.1

package/__tests__/data-api-uuid-coercion.test.ts

@@ -0,0 +1,214 @@
+import { generateDataAPIRoute } from '../src/data-api-route-generator'
+
+// Regression guard for "guest checkout 500s with `invalid input syntax for
+// type uuid: \"user\"`" — surfaced when the e-commerce "Resolve Current
+// User" custom node falls back to the string sentinel `"user"` for a not-
+// logged-in buyer and that sentinel is fed into the `teleport_orders.user_id`
+// column (nullable uuid). Before the fix only the PK `id` column got UUID
+// coercion; every other uuid column passed the value straight through to PG.
+//
+// The fix introduces `coerceUuidColumnValue(col, val, colTypes)` and applies
+// it inside both `handleCreate` and `handleUpdate` in the emitted
+// `/api/data/[...params].js` route. Empty / null / non-UUID strings land as
+// NULL in the database; valid UUIDs pass verbatim. The PK `id` column is
+// deliberately skipped — that one still gets a freshly generated UUID via
+// the existing branch.
+//
+// This file pins the exact runtime semantics so a refactor of the generator
+// cannot silently re-open the regression.
+describe('data-api route generator: non-`id` UUID column coercion', () => {
+  const code = generateDataAPIRoute()
+
+  it('emits a coerceUuidColumnValue helper that skips the `id` PK column', () => {
+    // The PK keeps the existing "generate a fresh UUID if missing/invalid"
+    // branch; the helper must early-return on col === 'id' so we do not
+    // overwrite that branch's output with NULL.
+    expect(code).toContain('function coerceUuidColumnValue')
+    expect(code).toContain("if (col === 'id') return val")
+  })
+
+  it('only operates on uuid-typed columns', () => {
+    // A non-uuid column (e.g. text) must NOT be affected — text columns
+    // legitimately carry arbitrary strings; UUID-shape checks would corrupt
+    // them.
+    expect(code).toContain("if (colTypes[col] !== 'uuid') return val")
+  })
+
+  it('keeps null / undefined / non-string values as-is', () => {
+    // null/undefined → null is what PG wants for nullable uuid columns.
+    // Numbers, booleans, arrays etc. for a uuid column would already throw
+    // at PG; this helper deliberately does not invent values for those.
+    expect(code).toContain('if (val == null) return val')
+    expect(code).toContain("if (typeof val !== 'string') return val")
+  })
+
+  it('keeps valid UUID strings verbatim and drops invalid strings to NULL', () => {
+    // The UUID_RE check is the discriminator: matching strings pass
+    // through; non-matching strings (e.g. "user", "anonymous", "abc") are
+    // coerced to null so the INSERT does not 500 with "invalid input
+    // syntax for type uuid" — UNLESS the column is a user-ownership
+    // column and the workflow handed us a valid anonymousUserId hint,
+    // in which case the row is attributed to the guest session. That
+    // ownership-column branch is pinned by `data-api-anon-user-id-fallback.test.ts`.
+    expect(code).toContain('if (UUID_RE.test(val)) return val')
+    expect(code).toContain('return null')
+  })
+
+  it('invokes the helper inside handleCreate AND handleUpdate', () => {
+    // Both writes are vulnerable to the same sentinel-strings-from-workflow
+    // path. Wiring the helper into one path but not the other would let a
+    // workflow that later updates an order (e.g. `data-update-item`
+    // stamping `user_id` post-login) silently re-open the regression.
+    const handleCreateIdx = code.indexOf('async function handleCreate')
+    const handleUpdateIdx = code.indexOf('async function handleUpdate')
+    expect(handleCreateIdx).toBeGreaterThan(0)
+    expect(handleUpdateIdx).toBeGreaterThan(handleCreateIdx)
+
+    const handleCreateBody = code.slice(handleCreateIdx, handleUpdateIdx)
+    const handleUpdateBody = code.slice(
+      handleUpdateIdx,
+      code.indexOf('async function handleDelete')
+    )
+
+    // Both call sites now pass the optional `anonymousUserIdFallback` —
+    // see `data-api-anon-user-id-fallback.test.ts` for the rationale.
+    expect(handleCreateBody).toContain(
+      'coerceUuidColumnValue(col, val, colTypes, anonymousUserIdFallback)'
+    )
+    expect(handleUpdateBody).toContain(
+      'coerceUuidColumnValue(col, val, colTypes, anonymousUserIdFallback)'
+    )
+  })
+
+  it('leaves the existing PK auto-generation branch intact', () => {
+    // Defensive: the new helper runs AFTER the "id PK gets generateUUID()"
+    // branch in handleCreate. If a refactor accidentally moves the helper
+    // before the PK branch, the PK would also get NULL'd here, and the
+    // INSERT would either fail (NOT NULL) or land with a NULL PK.
+    expect(code).toContain("if (col === 'id' && colTypes[col] === 'uuid'")
+    expect(code).toContain('return generateUUID()')
+  })
+})
+
+// Behaviour tests: spin up the emitted helper in a fresh JS sandbox and
+// exercise every coercion path. Pure-string regex checks above pin the
+// source shape; these tests prove the resulting code behaves correctly
+// when run.
+describe('data-api route generator: coerceUuidColumnValue runtime behaviour', () => {
+  const code = generateDataAPIRoute()
+
+  // Extract the helper by matching balanced braces from `function
+  // coerceUuidColumnValue` until its closing brace. The generated file is
+  // one big string template literal so we cannot import the helper; we
+  // build it back into a callable inside the test.
+  const extractFunctionSource = (haystack: string, funcDecl: string): string => {
+    const startIdx = haystack.indexOf(funcDecl)
+    if (startIdx === -1) {
+      throw new Error('Helper not found in generated code: ' + funcDecl)
+    }
+    let depth = 0
+    let i = haystack.indexOf('{', startIdx)
+    if (i === -1) {
+      throw new Error('No opening brace after ' + funcDecl)
+    }
+    for (; i < haystack.length; i++) {
+      const ch = haystack.charAt(i)
+      if (ch === '{') {
+        depth++
+      } else if (ch === '}') {
+        depth--
+        if (depth === 0) {
+          return haystack.slice(startIdx, i + 1)
+        }
+      }
+    }
+    throw new Error('Unbalanced braces for ' + funcDecl)
+  }
+
+  const helperSource = extractFunctionSource(code, 'function coerceUuidColumnValue')
+  // `coerceUuidColumnValue` now depends on `isUserOwnershipColumn` for
+  // its ownership-column predicate; pull that into the sandbox too.
+  const predicateSource = extractFunctionSource(code, 'function isUserOwnershipColumn')
+  const uuidReSource =
+    'var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;'
+
+  // Evaluate the helper in an isolated scope so the test does not leak
+  // globals.
+  const factory = new Function(
+    uuidReSource + '\n' + predicateSource + '\n' + helperSource + '\nreturn coerceUuidColumnValue;'
+  )
+  const coerceUuidColumnValue = factory() as (
+    col: string,
+    val: unknown,
+    colTypes: Record<string, string>
+  ) => unknown
+
+  const userIdCol = 'user_id'
+  const idCol = 'id'
+  const textCol = 'name'
+  const colTypes: Record<string, string> = {
+    user_id: 'uuid',
+    id: 'uuid',
+    name: 'text',
+  }
+
+  it('skips the id PK column even for garbage strings', () => {
+    // The PK branch lives elsewhere in handleCreate; this helper must not
+    // override it.
+    expect(coerceUuidColumnValue(idCol, 'not-a-uuid', colTypes)).toBe('not-a-uuid')
+  })
+
+  it('skips non-uuid columns entirely', () => {
+    // A text column may legitimately hold "user" — never null it out.
+    expect(coerceUuidColumnValue(textCol, 'user', colTypes)).toBe('user')
+  })
+
+  it('passes null / undefined through unchanged', () => {
+    expect(coerceUuidColumnValue(userIdCol, null, colTypes)).toBe(null)
+    expect(coerceUuidColumnValue(userIdCol, undefined, colTypes)).toBe(undefined)
+  })
+
+  it('passes non-string non-null values through unchanged', () => {
+    // A number for a uuid column will fail at PG, but this helper is not
+    // the place to invent a UUID — that would silently mask a real bug
+    // (someone fed an integer where a uuid is expected).
+    expect(coerceUuidColumnValue(userIdCol, 123, colTypes)).toBe(123)
+    expect(coerceUuidColumnValue(userIdCol, true, colTypes)).toBe(true)
+  })
+
+  it('keeps valid UUID strings verbatim', () => {
+    const uuid = '550e8400-e29b-41d4-a716-446655440000'
+    expect(coerceUuidColumnValue(userIdCol, uuid, colTypes)).toBe(uuid)
+  })
+
+  it('coerces the canonical guest-checkout sentinels to NULL', () => {
+    // These four sentinels are emitted by the AI-generated "Resolve Current
+    // User" custom node for non-logged-in buyers. All four must land in PG
+    // as NULL on a nullable uuid column rather than crash the INSERT.
+    expect(coerceUuidColumnValue(userIdCol, 'user', colTypes)).toBe(null)
+    expect(coerceUuidColumnValue(userIdCol, 'anonymous', colTypes)).toBe(null)
+    expect(coerceUuidColumnValue(userIdCol, '', colTypes)).toBe(null)
+    expect(coerceUuidColumnValue(userIdCol, 'guest', colTypes)).toBe(null)
+  })
+
+  it('coerces case-insensitive valid UUIDs', () => {
+    // UUID_RE has the /i flag; either case must pass.
+    expect(coerceUuidColumnValue(userIdCol, '550E8400-E29B-41D4-A716-446655440000', colTypes)).toBe(
+      '550E8400-E29B-41D4-A716-446655440000'
+    )
+  })
+
+  it('coerces shape-but-not-canonical strings to NULL', () => {
+    // 8-4-4-4-12 is the only accepted shape — too few hex digits, missing
+    // hyphens, or extraneous characters all fail.
+    expect(coerceUuidColumnValue(userIdCol, '550e8400e29b41d4a716446655440000', colTypes)).toBe(
+      null
+    )
+    expect(coerceUuidColumnValue(userIdCol, '550e8400-e29b-41d4-a716-44665544000', colTypes)).toBe(
+      null
+    )
+    expect(
+      coerceUuidColumnValue(userIdCol, '550e8400-e29b-41d4-a716-446655440000-extra', colTypes)
+    ).toBe(null)
+  })
+})

package/__tests__/data-create-item-order-notification.test.ts

@@ -0,0 +1,108 @@
+import { dataCreateItem } from '../src/nodes/data/data-create-item'
+
+// The order-confirmation email used to ship empty: "Items: 0", no
+// shipping address, no fulfillment, no currency, no item detail.
+// Root cause was the `data_create_item` piggyback in
+// `nodes/data/data-create-item.ts` building a minimal payload from
+// only a handful of `data.item` fields. This file pins the upgraded
+// behaviour: walk context for cart items, normalise them, assemble
+// the shipping address from whichever column shape the orders table
+// happens to use, and pass orderNumber separately from orderId.
+
+const handlerCode = dataCreateItem.generateHandler()
+
+describe('data_create_item — order-notification piggyback payload', () => {
+  it('walks workflow context looking for a cart-items array (not hardcoded params index)', () => {
+    expect(handlerCode).toContain('cartItems')
+    expect(handlerCode).toContain('Array.isArray(__v.items)')
+    // The detector must require a cart-item-shaped sample so it
+    // doesn't pick up an unrelated "{items:[]}" envelope from
+    // another node by accident.
+    expect(handlerCode).toMatch(/['"]price['"]\s+in\s+sample/)
+    expect(handlerCode).toMatch(/['"]productId['"]\s+in\s+sample/)
+  })
+
+  it('normalises items into a stable shape (name, sku, quantity, unitPrice, totalPrice)', () => {
+    expect(handlerCode).toContain('normalisedItems')
+    expect(handlerCode).toContain('name:')
+    expect(handlerCode).toContain('sku:')
+    expect(handlerCode).toContain('quantity:')
+    expect(handlerCode).toContain('unitPrice:')
+    expect(handlerCode).toContain('totalPrice:')
+  })
+
+  it('coerces missing/invalid quantity to 1 — a cart line is always at least one unit', () => {
+    expect(handlerCode).toMatch(
+      /qty\s*=\s*isFinite\(quantity\).*quantity\s*>\s*0\s*\?\s*quantity\s*:\s*1/
+    )
+  })
+
+  it('rounds unitPrice and totalPrice to cents to avoid floating-point cruft in the email', () => {
+    expect(handlerCode).toMatch(/Math\.round\(unitPrice\s*\*\s*100\)\s*\/\s*100/)
+    expect(handlerCode).toMatch(/Math\.round\(unitPrice\s*\*\s*qty\s*\*\s*100\)\s*\/\s*100/)
+  })
+
+  it('assembles shippingAddress from the single shipping_address column when it is a string', () => {
+    expect(handlerCode).toMatch(/typeof item\.shipping_address\s*===\s*['"]string['"]/)
+    expect(handlerCode).toContain('shippingAddress = item.shipping_address')
+  })
+
+  it('assembles shippingAddress from an object shipping_address column (JSON shape)', () => {
+    expect(handlerCode).toMatch(/sa\.name\s*\|\|\s*sa\.recipient/)
+    expect(handlerCode).toMatch(/sa\.line1\s*\|\|\s*sa\.address1\s*\|\|\s*sa\.street/)
+    expect(handlerCode).toMatch(/sa\.postal_code\s*\|\|\s*sa\.zip/)
+  })
+
+  it('assembles shippingAddress from separate shipping_* columns as the third fallback', () => {
+    expect(handlerCode).toContain('item.shipping_name')
+    expect(handlerCode).toContain('item.shipping_address1')
+    expect(handlerCode).toContain('item.shipping_city')
+    expect(handlerCode).toContain('item.shipping_country')
+  })
+
+  it('joins address parts with \\n so the email endpoint can convert to <br>', () => {
+    // The endpoint side runs .split(/\r?\n/).join('<br>') — these
+    // contracts must stay in sync. If either side changes, the
+    // shipping address renders as one long line.
+    expect(handlerCode).toMatch(/\.join\(['"][\\n][\\n]?['"]\)/)
+  })
+
+  it('passes orderNumber as a separate field from orderId in the email payload', () => {
+    // Older behaviour folded order_number into the `orderId` field,
+    // making the email show a UUID where the merchant configured
+    // {{orderNumber}}. The two MUST be passed independently.
+    expect(handlerCode).toContain('orderNumber: item.order_number || item.id')
+    expect(handlerCode).toContain('orderId: item.id')
+  })
+
+  it('passes currency, fulfillmentMethod, orderDate from the inserted row', () => {
+    expect(handlerCode).toContain('currency: item.currency')
+    expect(handlerCode).toContain('fulfillmentMethod: item.fulfillment_method')
+    expect(handlerCode).toContain('orderDate: item.created_at')
+  })
+
+  it('only fires for INSERTs into the orders table (other tables are NOT notified)', () => {
+    expect(handlerCode).toContain("tableName === 'teleport_orders'")
+  })
+
+  it('the fetch call is fire-and-forget — no await on the email POST', () => {
+    // Grep for the actual call shape: `fetch(baseUrl + '/api/ecommerce/order-notification', { method: 'POST', ... }).catch(...)`
+    // The presence of `.catch(function () {` immediately after the fetch
+    // call (no `await`) is the load-bearing assertion.
+    expect(handlerCode).toMatch(
+      /fetch\([\s\S]*?\/api\/ecommerce\/order-notification[\s\S]*?\}\)\s*\.catch/
+    )
+    const fetchSection = handlerCode.slice(
+      handlerCode.indexOf('/api/ecommerce/order-notification'),
+      handlerCode.indexOf('/api/ecommerce/order-notification') + 800
+    )
+    expect(fetchSection).not.toMatch(/await\s+fetch/)
+  })
+})
+
+// Runtime semantics tests would need the TypeScript `__awaiter` /
+// `__assign` helpers in scope to eval the serialised handler, which
+// is not worth the wiring noise — the source-text assertions above
+// cover the contract (which fields are read, where they default,
+// fire-and-forget shape, etc.). The full integration is exercised
+// by the existing end-to-end test in the dist project.