@teleporthq/teleport-plugin-next-workflows 0.43.42 → 0.43.45

package/__tests__/cart-availability-add-to-cart.test.ts

@@ -352,6 +352,53 @@ describe('buildAddToCartLimitCheck — runtime semantics', () => {
     expect(result.existingItemId).toBe('cart-1')
   })
 
+  // Variant-aware de-dup: a cart line is identified by product AND variant.
+  const buildParamsV = (
+    productId: string,
+    variantId: string | null,
+    quantity: number,
+    settings: any,
+    product: any,
+    cartItems: any[]
+  ): any[] => {
+    const arr: any[] = new Array(14).fill(null)
+    arr[0] = { productId, variantId, quantity }
+    arr[2] = settings
+    arr[6] = product ? { found: true, product } : { found: false, product: null }
+    arr[13] = cartItems
+    return arr
+  }
+
+  it('same product, DIFFERENT variant already in cart → treated as a NEW line (no increment)', () => {
+    const params = buildParamsV('a', 'a__blue', 1, baseSettings(), { name: 'Tee', quantity: 5 }, [
+      { id: 'cart-red', productId: 'a', variantId: 'a__red', quantity: 1 },
+    ])
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(true)
+    expect(result.shouldIncrement).toBe(false)
+    expect(result.existingItemId).toBe(null)
+  })
+
+  it('same product, SAME variant already in cart → increments THAT line', () => {
+    const params = buildParamsV('a', 'a__red', 1, baseSettings(), { name: 'Tee', quantity: 5 }, [
+      { id: 'cart-red', productId: 'a', variantId: 'a__red', quantity: 1 },
+      { id: 'cart-blue', productId: 'a', variantId: 'a__blue', quantity: 1 },
+    ])
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(true)
+    expect(result.shouldIncrement).toBe(true)
+    expect(result.existingItemId).toBe('cart-red')
+  })
+
+  it('flat product (no variantId) matches the flat cart line', () => {
+    const params = buildParamsV('a', null, 1, baseSettings(), { name: 'Mug', quantity: 5 }, [
+      { id: 'cart-flat', productId: 'a', quantity: 2 },
+    ])
+    const result = fn({}, params)
+    expect(result.shouldIncrement).toBe(true)
+    expect(result.existingItemId).toBe('cart-flat')
+  })
+
   it('new item would exceed maxQuantityPerProduct → canAdd:false, names product', () => {
     const params = buildParams(
       'a',

package/__tests__/cron-route-loop-templateparams.test.ts

@@ -0,0 +1,144 @@
+// Regression test for the abandoned-cart reminder feature's codegen dependency:
+// a scheduled (cron) workflow must generate a route that (a) executes a
+// `general-loop` body per row and (b) merges an email node's `templateParams`
+// into its component body — the cron route previously used a naive inline loop
+// that did neither, so a per-cart reminder email would ship raw {{token}} merge
+// fields and its loop body would never run.
+import { generateCronAPIRoute } from '../src/api-route-generator'
+
+const TRIGGER_ID = 'cron-1'
+const SCAN_ID = 'scan-1'
+const LOOP_ID = 'loop-1'
+const SHIM_ID = 'shim-1'
+const CREATE_ID = 'create-1'
+const EMAIL_ID = 'email-1'
+
+const buildCronWorkflow = (): any => ({
+  id: 'wf-abandoned-cart',
+  name: 'Abandoned Cart Reminder',
+  trigger: {
+    type: 'event-cron-triggered',
+    nodeId: TRIGGER_ID,
+    scope: 'global',
+    config: { schedule: '0 * * * *', timezone: 'UTC', urlPath: 'cron_abandoned' },
+  },
+  nodes: [
+    {
+      id: SCAN_ID,
+      type: 'data-raw-query',
+      config: { dataSourceId: 'ds-1', query: 'SELECT 1', params: ['2'] },
+      executionEnv: 'server',
+      stepNumber: 1,
+      label: 'Scan Abandoned Carts',
+    },
+    {
+      id: LOOP_ID,
+      type: 'general-loop',
+      config: {
+        loopType: 'forEach',
+        collection: { type: 'workflowContext', nodeId: SCAN_ID, path: [SCAN_ID, 'result'] },
+        itemVariable: 'cart',
+      },
+      executionEnv: 'server',
+      stepNumber: 2,
+      label: 'Loop Over Each Abandoned Cart',
+    },
+    {
+      id: SHIM_ID,
+      type: 'general-custom-js',
+      config: { code: 'function customHandler(p){return {email:"a@b.c"}}', context: 'server' },
+      executionEnv: 'server',
+      stepNumber: 3,
+      label: 'Build Reminder Payload',
+    },
+    {
+      id: CREATE_ID,
+      type: 'data-create-item',
+      config: { dataSourceId: 'ds-1', tableName: 'teleport_abandoned_carts', columnMappings: [] },
+      executionEnv: 'server',
+      stepNumber: 4,
+      label: 'Record Abandoned Cart',
+    },
+    {
+      id: EMAIL_ID,
+      type: 'email-resend',
+      config: {
+        to: { type: 'workflowContext', nodeId: SHIM_ID, path: [SHIM_ID, 'email'] },
+        subject: 'You left something in your cart at {{companyName}}',
+        body: '<p>Hi {{customerName}}</p>',
+        templateParams: [
+          { key: 'customerName', value: 'Jane' },
+          { key: 'companyName', value: 'Acme' },
+        ],
+        apiKey: '',
+        emailType: 'transactional',
+      },
+      executionEnv: 'server',
+      stepNumber: 5,
+      label: 'Send Abandoned Cart Reminder',
+    },
+  ],
+  edges: [
+    { id: 'e1', source: TRIGGER_ID, target: SCAN_ID },
+    { id: 'e2', source: SCAN_ID, target: LOOP_ID },
+    {
+      id: 'e3',
+      source: LOOP_ID,
+      target: SHIM_ID,
+      sourceHandle: 'loop',
+      targetHandle: 'loop-body-in',
+    },
+    {
+      id: 'e4',
+      source: SHIM_ID,
+      target: CREATE_ID,
+      sourceHandle: 'loop-body-out',
+      targetHandle: 'loop-body-in',
+    },
+    {
+      id: 'e5',
+      source: CREATE_ID,
+      target: EMAIL_ID,
+      sourceHandle: 'loop-body-out',
+      targetHandle: 'loop-body-in',
+    },
+    {
+      id: 'e6',
+      source: EMAIL_ID,
+      target: LOOP_ID,
+      sourceHandle: 'loop-body-out',
+      targetHandle: 'loop-back',
+    },
+  ],
+})
+
+describe('generateCronAPIRoute — loop + templateParams support', () => {
+  const route = generateCronAPIRoute(buildCronWorkflow())
+
+  it('uses the loop-capable executor (handles general-loop body discovery)', () => {
+    // The shared execution loop keys the loop body off the 'loop' sourceHandle
+    // and walks 'loop-body-out' edges — markers absent from the old naive loop.
+    expect(route).toContain("e.sourceHandle === 'loop'")
+    expect(route).toContain('loop-body-out')
+  })
+
+  it('merges templateParams into email body + subject', () => {
+    // Both the top-level and loop-body execution paths apply the merge; the
+    // email node lives in the loop body here.
+    expect(route).toContain('utils.applyTemplateParams(bResolved.body, bResolved.templateParams)')
+    expect(route).toContain(
+      'utils.applyTemplateParams(bResolved.subject, bResolved.templateParams)'
+    )
+  })
+
+  it('bakes the scan + loop + email nodes into the server WORKFLOW_CONFIG', () => {
+    expect(route).toContain('"type": "general-loop"')
+    expect(route).toContain('"type": "email-resend"')
+    expect(route).toContain('"type": "data-raw-query"')
+  })
+
+  it('emits a self-contained cron handler with the schedule + success response', () => {
+    expect(route).toContain("schedule: '0 * * * *'")
+    expect(route).toContain('res.status(200).json({ success: true')
+  })
+})

package/__tests__/data-api-on-conflict-do-nothing.test.ts

@@ -0,0 +1,35 @@
+import { generateDataAPIRoute } from '../src/data-api-route-generator'
+import { dataCreateItem } from '../src/nodes/data/data-create-item'
+
+// Idempotent insert support. The "Resolve Current User" custom node re-ensures
+// a guest's anonymous `users` row on EVERY resolution so the identity is
+// self-healing after a database reset / re-provision. That insert targets a
+// row that usually already exists, so it MUST be a no-op on conflict rather
+// than a 23505 error that aborts the resolve-user (and therefore checkout).
+
+describe('data-api handleCreate — ON CONFLICT DO NOTHING', () => {
+  const code = generateDataAPIRoute()
+
+  it('appends ON CONFLICT DO NOTHING only when the caller opts in', () => {
+    expect(code).toContain('body.onConflictDoNothing')
+    expect(code).toContain('ON CONFLICT DO NOTHING')
+    // Default path stays a plain insert — the clause is gated behind the flag.
+    expect(code).toMatch(/onConflictClause\s*=\s*body\.onConflictDoNothing\s*\?/)
+  })
+
+  it('falls back to the supplied id when a conflict returns no row', () => {
+    // With ON CONFLICT DO NOTHING a pre-existing row yields no RETURNING row,
+    // so the response must still surface the intended id for downstream nodes.
+    expect(code).toContain("var idIdx = columns.indexOf('id')")
+    expect(code).toMatch(/resolvedId\s*=\s*item\s*\?/)
+  })
+})
+
+describe('data_create_item — forwards the idempotency flag', () => {
+  const handlerCode = dataCreateItem.generateHandler()
+
+  it('passes config.onConflictDoNothing through to the data-api request body', () => {
+    expect(handlerCode).toContain('config.onConflictDoNothing === true')
+    expect(handlerCode).toContain('reqBody.onConflictDoNothing = true')
+  })
+})

package/__tests__/email-body-context-resolution.test.ts

@@ -19,6 +19,8 @@ import { generateSharedRuntimeUtilsCode } from '../src'
 type SharedUtils = {
   resolveConfig: (cfg: unknown, ctx: Record<string, unknown>) => any
   resolveRichTextContext: (html: string, ctx: Record<string, unknown>) => string
+  applyTemplateParams: (text: string, params: unknown) => string
+  expandListBlocks: (text: string, lists: Record<string, unknown>) => string
 }
 
 function loadSharedRuntime(): SharedUtils {
@@ -121,3 +123,127 @@ describe('email body inline-context resolution', () => {
     expect(out).not.toContain('Reset URL</span>')
   })
 })
+
+// Guards the component-body path: a send-email node whose body is a serialized
+// email-template component carries flat {{token}} merge fields filled at runtime
+// from templateParams (resolveConfig resolves each param's context ref first,
+// then executeNodes calls applyTemplateParams on body + subject).
+describe('email template params substitution', () => {
+  const utils = loadSharedRuntime()
+
+  it('exposes applyTemplateParams from the generated runtime', () => {
+    expect(typeof utils.applyTemplateParams).toBe('function')
+  })
+
+  it('fills {{token}} in body + subject from resolved templateParams (executeNodes flow)', () => {
+    const config = {
+      subject: 'Reset {{recipientEmail}}',
+      body: '<a href="{{resetUrl}}">Reset</a> for {{recipientEmail}}',
+      templateParams: [
+        {
+          key: 'resetUrl',
+          value: { type: 'workflowContext', nodeId: 'N1', path: ['N1', 'result'] },
+        },
+        { key: 'recipientEmail', value: 'jane@example.com' },
+      ],
+    }
+    // Step 1: resolveConfig resolves each param's context ref (as executeNodes does).
+    const resolved = utils.resolveConfig(config, {
+      N1: { result: 'https://app.example.com/reset-password?token=abc' },
+    })
+    // Step 2: executeNodes applies the params to body + subject.
+    const body = utils.applyTemplateParams(resolved.body, resolved.templateParams)
+    const subject = utils.applyTemplateParams(resolved.subject, resolved.templateParams)
+    expect(body).toBe(
+      '<a href="https://app.example.com/reset-password?token=abc">Reset</a> for jane@example.com'
+    )
+    expect(subject).toBe('Reset jane@example.com')
+  })
+
+  it('leaves unknown tokens verbatim (never blanks a campaign {{name}})', () => {
+    const out = utils.applyTemplateParams('Hi {{name}}, reset: {{resetUrl}}', [
+      { key: 'resetUrl', value: 'https://x/reset?token=1' },
+    ])
+    expect(out).toBe('Hi {{name}}, reset: https://x/reset?token=1')
+  })
+
+  it('does not partial-match longer tokens ({{total}} vs {{totalAmount}})', () => {
+    const out = utils.applyTemplateParams('{{total}} of {{totalAmount}}', [
+      { key: 'total', value: '5' },
+      { key: 'totalAmount', value: '$99' },
+    ])
+    expect(out).toBe('5 of $99')
+  })
+
+  it('is a no-op when there are no params or body is not a string', () => {
+    expect(utils.applyTemplateParams('{{x}}', [])).toBe('{{x}}')
+    expect(utils.applyTemplateParams('{{x}}', undefined)).toBe('{{x}}')
+  })
+
+  // ── Array-mapper loop-block expansion (builder array mapper → email list) ──
+
+  it('expands a <!--tq:each--> block from an array templateParam, once per row', () => {
+    const body =
+      'Items:<!--tq:each products--><li>{{quantity}}x <strong>{{product_name}}</strong> — {{companyName}}</li><!--/tq:each-->end'
+    const out = utils.applyTemplateParams(body, [
+      {
+        key: 'products',
+        value: [
+          { product_name: 'Espresso Beans', quantity: 2 },
+          { product_name: 'Ceramic Mug', quantity: 1 },
+        ],
+      },
+      { key: 'companyName', value: 'Acme Inc.' },
+    ])
+    // one <li> per row, row tokens filled from the row object
+    expect(out).toContain('<li>2x <strong>Espresso Beans</strong> — Acme Inc.</li>')
+    expect(out).toContain('<li>1x <strong>Ceramic Mug</strong> — Acme Inc.</li>')
+    // the {{companyName}} inside the row (not a row field) resolved via the flat fill
+    expect(out).not.toContain('{{companyName}}')
+    // no leftover sentinels or tokens
+    expect(out).not.toContain('<!--tq:each')
+    expect(out).not.toContain('<!--/tq:each-->')
+    expect(out).not.toContain('{{product_name}}')
+  })
+
+  it('HTML-escapes per-row values (no markup injection from item data)', () => {
+    const out = utils.expandListBlocks('<!--tq:each products-->[{{name}}]<!--/tq:each-->', {
+      products: [{ name: '<b>x</b> & "y"' }],
+    })
+    expect(out).toBe('[&lt;b&gt;x&lt;/b&gt; &amp; &quot;y&quot;]')
+  })
+
+  it('renders an empty string for a missing/non-array list key', () => {
+    const body = 'a<!--tq:each products-->{{name}}<!--/tq:each-->b'
+    expect(utils.applyTemplateParams(body, [])).toBe('ab')
+    expect(utils.applyTemplateParams(body, [{ key: 'products', value: 'not-an-array' }])).toBe('ab')
+  })
+
+  it('resolveConfig preserves an array-valued templateParam so the block expands', () => {
+    // Mirrors the withdrawal send node: templateParams is an array of {key,value}
+    // where value is a workflowContext ref that resolves to the items array.
+    const config = {
+      body: 'X<!--tq:each products--><li>{{quantity}}x {{product_name}}</li><!--/tq:each-->Y',
+      templateParams: [
+        {
+          key: 'products',
+          value: {
+            type: 'workflowContext',
+            nodeId: 'assemble',
+            path: ['assemble', 'selectedItems'],
+          },
+        },
+        { key: 'companyName', value: 'Acme Inc.' },
+      ],
+    }
+    const ctx = {
+      assemble: { selectedItems: [{ product_name: 'Espresso Beans', quantity: 3 }] },
+    }
+    const resolved = utils.resolveConfig(config, ctx)
+    // the array survived resolution (was not String()-joined)
+    expect(Array.isArray(resolved.templateParams[0].value)).toBe(true)
+    const out = utils.applyTemplateParams(resolved.body, resolved.templateParams)
+    expect(out).toContain('<li>3x Espresso Beans</li>')
+    expect(out).not.toContain('<!--tq:each')
+  })
+})

package/__tests__/raw-sql-param-binding.test.ts

@@ -0,0 +1,138 @@
+import {
+  parameterizeRawSqlInterpolations,
+  parameterizeWorkflowRawSqlInterpolations,
+  parameterizeAllWorkflowRawSql,
+  WorkflowSqlInterpolationError,
+} from '../src/raw-sql-param-binding'
+
+// Generation-time net (runs in the workflows plugin's runBefore). Converts each
+// `{{ name }}` value token in a data node's raw SQL into a positional `$N` +
+// a bound params entry, keeping the published-app runtime on the standard
+// `$N` + params path. PAIRED with the GUI + worker copies.
+
+function ref(nodeId: string, ...path: string[]) {
+  return { type: 'workflowContext' as const, nodeId, path: [nodeId, ...path] }
+}
+
+describe('parameterizeRawSqlInterpolations', () => {
+  it('binds a context-ref variable token in value position', () => {
+    const value = ref('normalize', 'ids')
+    const res = parameterizeRawSqlInterpolations(
+      'DELETE FROM t WHERE id::text = ANY({{ selectedIds }}::text[])',
+      [{ name: 'selectedIds', value }]
+    )
+    expect(res.query).toBe('DELETE FROM t WHERE id::text = ANY($1::text[])')
+    expect(res.params).toEqual([value])
+    expect(res.residuals).toEqual([])
+  })
+
+  it('keeps an unmatched {{state.X}} token as its own string param', () => {
+    const res = parameterizeRawSqlInterpolations(
+      'SELECT * FROM t WHERE owner = {{state.userId}}',
+      []
+    )
+    expect(res.query).toBe('SELECT * FROM t WHERE owner = $1')
+    expect(res.params).toEqual(['{{state.userId}}'])
+  })
+
+  it('reports an identifier-position token as a residual', () => {
+    const res = parameterizeRawSqlInterpolations('SELECT * FROM {{ t }}', [
+      { name: 't', value: ref('n', 't') },
+    ])
+    expect(res.residuals).toEqual(['{{ t }}'])
+    expect(res.params).toEqual([])
+  })
+})
+
+describe('parameterizeWorkflowRawSqlInterpolations', () => {
+  it('rewrites a data-raw-query node and drops queryVariables', () => {
+    const value = ref('n', 'ids')
+    const workflow = {
+      nodes: [
+        {
+          id: 'q',
+          type: 'data-raw-query',
+          config: {
+            query: 'DELETE FROM t WHERE id = ANY({{ ids }}::text[])',
+            queryVariables: [{ name: 'ids', value }],
+          },
+        },
+      ],
+    }
+    parameterizeWorkflowRawSqlInterpolations(workflow)
+    expect(workflow.nodes[0].config).toEqual({
+      query: 'DELETE FROM t WHERE id = ANY($1::text[])',
+      params: [value],
+    })
+  })
+
+  it('rewrites a data-select rawQueryUserPart', () => {
+    const value = ref('n', 'v')
+    const workflow = {
+      nodes: [
+        {
+          id: 's',
+          type: 'data-select',
+          config: {
+            rawQueryUserPart: 'owner_id = {{ v }}',
+            rawQueryUserPartVariables: [{ name: 'v', value }],
+          },
+        },
+      ],
+    }
+    parameterizeWorkflowRawSqlInterpolations(workflow)
+    expect(workflow.nodes[0].config).toEqual({
+      rawQueryUserPart: 'owner_id = $1',
+      rawQueryUserPartParams: [value],
+    })
+  })
+
+  it('throws on an unbindable token and mutates nothing', () => {
+    const workflow = {
+      nodes: [
+        {
+          id: 'bad',
+          type: 'data-raw-query',
+          config: {
+            query: 'SELECT * FROM {{ table }}',
+            queryVariables: [{ name: 'table', value: ref('n', 't') }],
+          },
+        },
+      ],
+    }
+    expect(() => parameterizeWorkflowRawSqlInterpolations(workflow)).toThrow(
+      WorkflowSqlInterpolationError
+    )
+    expect((workflow.nodes[0].config as { query: string }).query).toContain('{{ table }}')
+  })
+})
+
+describe('parameterizeAllWorkflowRawSql', () => {
+  it('walks both workflows and customNodes (id-keyed records)', () => {
+    const value = ref('n', 'ids')
+    const uidlWorkflows = {
+      workflows: {
+        wf1: {
+          nodes: {
+            n1: {
+              type: 'data-raw-query',
+              config: {
+                query: 'DELETE FROM t WHERE id = ANY({{ ids }}::text[])',
+                queryVariables: [{ name: 'ids', value }],
+              },
+            },
+          },
+        },
+      },
+      customNodes: {},
+    }
+    parameterizeAllWorkflowRawSql(uidlWorkflows)
+    const cfg = uidlWorkflows.workflows.wf1.nodes.n1.config as { query: string; params: unknown[] }
+    expect(cfg.query).toBe('DELETE FROM t WHERE id = ANY($1::text[])')
+    expect(cfg.params).toEqual([value])
+  })
+
+  it('is a no-op when workflows is undefined', () => {
+    expect(() => parameterizeAllWorkflowRawSql(undefined)).not.toThrow()
+  })
+})

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

@@ -0,0 +1,13 @@
+export interface AccountDeleteRouteOptions {
+    authUsersTableName?: string;
+    emailProvider?: string | null;
+    fromEmail?: string;
+    emailSecretEnvName?: string | null;
+    emailSubject?: string;
+    emailBodyHtml?: string;
+    siteName?: string;
+    deletedEmailPattern?: string;
+}
+export declare const accountDeleteRouteDependencies: (provider?: string) => Record<string, string>;
+export declare const generateAccountDeleteRoute: (options?: AccountDeleteRouteOptions) => string;
+//# sourceMappingURL=account-delete-route-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"account-delete-route-generator.d.ts","sourceRoot":"","sources":["../../src/account-delete-route-generator.ts"],"names":[],"mappings":"AA0BA,MAAM,WAAW,yBAAyB;IAExC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAI3B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAID,eAAO,MAAM,8BAA8B,+CAAiC,CAAA;AAE5E,eAAO,MAAM,0BAA0B,aAAa,yBAAyB,KAAQ,MA6NpF,CAAA"}