@teleporthq/teleport-plugin-next-workflows 0.43.67 → 0.43.69

package/__tests__/data-node-not-awaited.test.ts

@@ -451,7 +451,9 @@ describe('generated server segment route', () => {
   it('settles in-flight queries BEFORE responding (the platform can freeze us)', () => {
     expect(route).toContain('await utils.settlePendingNodePromises(context);')
     const settleAt = route.indexOf('await utils.settlePendingNodePromises(context);')
-    const respondAt = route.indexOf('res.status(200).json({ success: true, results: context });')
+    const respondAt = route.indexOf(
+      'res.status(200).json({ success: true, results: utils.segmentReply(SEGMENT_CONFIG, context, __incomingSnapshot) });'
+    )
     expect(settleAt).toBeGreaterThan(-1)
     expect(respondAt).toBeGreaterThan(settleAt)
   })
@@ -477,7 +479,7 @@ describe('generated client runtime', () => {
 
   it('dispatches an all-fire-and-forget segment without awaiting the round trip', () => {
     expect(client).toContain('if (segIsFireAndForget) {')
-    expect(client).toContain('callServerSegment(ffUrl, context).catch(')
+    expect(client).toContain('callServerSegment(ffUrl, context, seg.stateKeys).catch(')
     // The nodes still get their null entries so downstream reads are defined.
     expect(client).toContain('context[seg.nodes[ffi].id] = null;')
   })
@@ -494,7 +496,9 @@ describe('generated client runtime', () => {
   })
 
   it('keeps awaiting a normal server segment', () => {
-    expect(client).toContain('const serverResults = await callServerSegment(url, context);')
+    expect(client).toContain(
+      'const serverResults = await callServerSegment(url, context, seg.stateKeys);'
+    )
   })
 
   it('never serializes the in-flight promise list to the server', () => {

package/__tests__/data-write-missing-filter.test.ts

@@ -0,0 +1,119 @@
+import { generateDataAPIRoute } from '../src/data-api-route-generator'
+import { loadHandler } from './_helpers/load-handler'
+
+// An UPDATE or DELETE whose filter lost its value — its binding produced
+// nothing, or the hand-off to the server dropped it — used to leave the filter
+// OUT, so one request rewrote every row of the table (every user's password).
+// The write nodes now do nothing, and the data API refuses such a write from
+// any caller.
+
+interface FetchCall {
+  url: string
+  body: Record<string, unknown>
+}
+
+function withFetch(calls: FetchCall[]): () => void {
+  const original = (globalThis as any).fetch
+  ;(globalThis as any).fetch = async (url: string, init: { body: string }) => {
+    calls.push({ url, body: JSON.parse(init.body) })
+    return { ok: true, json: async () => ({ updatedCount: 1, deletedCount: 1 }) }
+  }
+  return () => {
+    ;(globalThis as any).fetch = original
+  }
+}
+
+describe.each([
+  ['data-update-item', { columnMappings: [{ column: 'password', value: 'hash' }] }],
+  ['data-delete-item', {}],
+])('%s with a filter that has no value', (nodeType, extra) => {
+  const handler = loadHandler(nodeType)
+  const config = (value: unknown) => ({
+    dataSourceId: 'ds',
+    tableName: 'users',
+    filters: [{ field: 'email', operator: '=', value }],
+    ...extra,
+  })
+
+  it.each([
+    ['missing', undefined],
+    ['cut off in the hand-off', { __truncated: true, type: 'string' }],
+  ])('changes nothing when the value is %s', async (_label, value) => {
+    const calls: FetchCall[] = []
+    const restore = withFetch(calls)
+    try {
+      const result = (await handler(config(value), { __baseUrl: 'http://x' })) as Record<
+        string,
+        unknown
+      >
+      expect(calls).toHaveLength(0)
+      expect(result).toMatchObject({ __skippedMissingFilter: true, success: true })
+    } finally {
+      restore()
+    }
+  })
+
+  it('still writes when every filter has a value', async () => {
+    const calls: FetchCall[] = []
+    const restore = withFetch(calls)
+    try {
+      await handler(config('owner@shop.test'), { __baseUrl: 'http://x' })
+      expect(calls).toHaveLength(1)
+      expect(calls[0].body.filters).toEqual([
+        { field: 'email', operator: '=', value: 'owner@shop.test' },
+      ])
+    } finally {
+      restore()
+    }
+  })
+})
+
+describe('data API — the WHERE clause of an UPDATE or DELETE', () => {
+  const code = generateDataAPIRoute()
+  const pick = (name: string): string => {
+    const start = code.indexOf(`function ${name}(`)
+    const end = code.indexOf('\n}\n', start)
+    return code.slice(start, end + 2)
+  }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  const buildWhereClause = new Function(
+    'validateFilters',
+    [
+      pick('isMissingFilterValue'),
+      pick('refuseUnscopedWrite'),
+      pick('isSkippableFilterValue'),
+      pick('isAllSentinelFilterValue'),
+      pick('buildWhereClause'),
+      'return buildWhereClause;',
+    ].join('\n')
+  )(() => undefined) as (
+    filters: unknown[],
+    params: unknown[],
+    start: number,
+    options?: Record<string, unknown>
+  ) => { clause: string }
+
+  it('uses the strict clause for every UPDATE and DELETE', () => {
+    expect(code.match(/buildWhereClause\([^)]*\{ strict: true \}\)/g)).toHaveLength(2)
+  })
+
+  it('refuses a filter with no value instead of leaving it out', () => {
+    expect(() =>
+      buildWhereClause([{ field: 'email', operator: '=' }], [], 1, { strict: true })
+    ).toThrow('Refused: the filter on "email" has no value')
+    expect(() =>
+      buildWhereClause([{ field: 'email', value: { __truncated: true } }], [], 1, { strict: true })
+    ).toThrow('Refused')
+    expect(() => buildWhereClause([{ value: 'x' }], [], 1, { strict: true })).toThrow('Refused')
+  })
+
+  it('matches no row for an empty list', () => {
+    expect(buildWhereClause([{ field: 'id', value: [] }], [], 1, { strict: true }).clause).toBe(
+      ' WHERE FALSE'
+    )
+  })
+
+  it('keeps a read lenient: an optional filter without a value is left out', () => {
+    expect(buildWhereClause([{ field: 'email' }], [], 1).clause).toBe('')
+  })
+})

package/__tests__/ecommerce-rewriter-product-options.test.ts

@@ -0,0 +1,143 @@
+import { ProductOptions } from '@teleporthq/teleport-shared'
+import { rewriteLowStockCustomHandlers } from '../src/ecommerce-customhandler-rewriter'
+import { __testables as cartAvailability } from '../src/ecommerce/cart-availability'
+
+/**
+ * The export-time rewriters recognise the editor's baked scripts by the tokens
+ * they contain and swap in their own code. Product options put a large helper
+ * block (and new fields) into the add-to-cart, checkout and order scripts, so
+ * the block must never carry a rewriter's trigger tokens — a script it lands
+ * in would be silently replaced — while the add-to-cart limit check, which
+ * learned the configuration key, must still be the one script replaced.
+ */
+
+const HELPERS = ProductOptions.generateProductOptionsHelperCode()
+
+// The editor's "Evaluate Cart Item Limit" script with the line identity
+// extended by the configuration key (`params[7]` is the priced product).
+const EVALUATE_WITH_CONFIGURATION = `function customHandler(previousContext, params) {
+  var settingsCtx = params[2];
+  var extractCtx = params[0];
+  var checkResult = params[7];
+  var cartItems = params[13];
+  var productId = extractCtx ? extractCtx.productId : "";
+  var variantId = extractCtx ? (extractCtx.variantId || null) : null;
+  var configurationKey = checkResult && checkResult.productConfigurationKey ? checkResult.productConfigurationKey : "";
+  var items = cartItems && Array.isArray(cartItems) ? cartItems : [];
+  var existingItem = null;
+  var existingQuantity = 0;
+  for (var i = 0; i < items.length; i++) {
+    if (items[i].productId === productId && (items[i].variantId || null) === (variantId || null) && (items[i].configurationKey || "") === configurationKey) {
+      existingItem = items[i];
+      existingQuantity = Number(items[i].quantity) || 0;
+      break;
+    }
+  }
+  var maxQty = settingsCtx ? settingsCtx.maxQuantityPerProduct : null;
+  if (maxQty !== null && maxQty !== undefined && Number(maxQty) > 0 && existingQuantity >= Number(maxQty)) {
+    return { canAdd: false, message: "Limit", existingItemId: existingItem ? existingItem.id : null, shouldIncrement: false };
+  }
+  return { canAdd: true, message: "", existingItemId: existingItem ? existingItem.id : null, shouldIncrement: existingItem !== null };
+}`
+
+// The shapes the helper block is baked into: a custom node's first script (the
+// block inside the handler body), and a workflow script (the block ahead of
+// the handler), each reading the priced product the way the editor does.
+const PRICE_CHECK_WITH_HELPERS = `async function customHandler(previousContext, params) {
+${HELPERS}
+  var result = params[6];
+  var rows = result && result.rows ? result.rows : [];
+  var found = rows.length > 0;
+  var product = found ? rows[0] : null;
+  var resolved = __poResolveForRow(product, product ? Number(product.price) : 0, params.optionsConfig);
+  return { found: found, product: product, productPrice: resolved.delta, productConfigurationKey: resolved.key, optionsOk: resolved.valid ? 'true' : 'false' };
+}`
+
+const ASSEMBLE_WITH_HELPERS = `${HELPERS}
+function customHandler(params) {
+  var lines = [];
+  var cartItems = params[2] && params[2].items ? params[2].items : [];
+  for (var i = 0; i < cartItems.length; i++) {
+    var res = __poResolveForRow(null, Number(cartItems[i].basePrice) || 0, cartItems[i].configuration);
+    lines.push({ id: cartItems[i].id, label: res.label, snapshot: JSON.stringify({ v: 1, entries: res.entries }) });
+  }
+  return { product_option_lines: lines };
+}`
+
+const buildUidl = (codes: string[]) =>
+  ({
+    workflows: {
+      workflows: {
+        checkout: {
+          id: 'checkout',
+          nodes: codes.map((code, index) => ({
+            id: 'wf-' + index,
+            type: 'general-custom-js',
+            config: { code },
+          })),
+        },
+      },
+      customNodes: {
+        atc: {
+          id: 'atc',
+          name: 'Add Product To Cart Logic',
+          nodes: codes.map((code, index) => ({
+            id: 'cn-' + index,
+            type: 'general-custom-js',
+            config: { code },
+          })),
+        },
+      },
+    },
+    ecommerceSettings: {
+      stockManagement: true,
+      stockManagementConfig: {
+        allowBackorders: false,
+        lowStockThreshold: 5,
+        lowStockAlerts: false,
+        maxQuantityPerProduct: 5,
+      },
+    },
+  } as any)
+
+const TOTAL_REWRITES = (summary: ReturnType<typeof rewriteLowStockCustomHandlers>): number =>
+  summary.selectBuilderRewrites +
+  summary.emailPayloadRewrites +
+  summary.paymentMetadataBuilderRewrites +
+  summary.stockDecrementBuilderRewrites +
+  summary.placeOrderAvailabilityRewrites +
+  summary.addToCartStockCheckRewrites +
+  summary.addToCartLimitCheckRewrites +
+  summary.orderNumberGeneratorRewrites +
+  summary.orderOwnershipRewrites +
+  summary.variantPickerGateRewrites
+
+describe('export-time rewriters and the product options helper block', () => {
+  it('carries none of the add-to-cart limit check trigger tokens', () => {
+    for (const token of ['canAdd', 'shouldIncrement', 'existingItemId', 'maxQuantityPerProduct']) {
+      expect(HELPERS).not.toContain(token)
+    }
+  })
+
+  it('leaves every script the block is baked into untouched', () => {
+    const codes = [PRICE_CHECK_WITH_HELPERS, ASSEMBLE_WITH_HELPERS]
+    const uidl = buildUidl(codes)
+    const summary = rewriteLowStockCustomHandlers(uidl)
+    expect(TOTAL_REWRITES(summary)).toBe(0)
+    expect(uidl.workflows.workflows.checkout.nodes.map((node: any) => node.config.code)).toEqual(
+      codes
+    )
+    expect(uidl.workflows.customNodes.atc.nodes.map((node: any) => node.config.code)).toEqual(codes)
+  })
+
+  it('still replaces the limit check once it compares the configuration key', () => {
+    expect(cartAvailability.looksLikeAddToCartLimitCheck(EVALUATE_WITH_CONFIGURATION)).toBe(true)
+    const uidl = buildUidl([EVALUATE_WITH_CONFIGURATION, PRICE_CHECK_WITH_HELPERS])
+    const summary = rewriteLowStockCustomHandlers(uidl)
+    expect(summary.addToCartLimitCheckRewrites).toBe(2)
+    expect(TOTAL_REWRITES(summary)).toBe(2)
+    const [limitCheck, priceCheck] = uidl.workflows.customNodes.atc.nodes
+    expect(limitCheck.config.code).toBe(cartAvailability.buildAddToCartLimitCheck())
+    expect(priceCheck.config.code).toBe(PRICE_CHECK_WITH_HELPERS)
+  })
+})

package/__tests__/email-locale-senders.test.ts

@@ -207,7 +207,7 @@ describe('invoice email', () => {
     expect(route).toContain('var invoiceLocale = emailLocale.normalizeEmailLocale(orderRow.locale)')
     expect(route).toContain('|| emailLocale.normalizeEmailLocale(body.locale)')
     expect(route).toContain('|| emailLocale.resolveRequestLocale(req);')
-    expect(route).toContain('locale: invoiceLocale,')
+    expect(route).toContain('invoiceData.locale = invoiceLocale;')
   })
 
   it('a project without email delivery needs no locale module', () => {

package/__tests__/file-storage-upload-picked-files.test.ts

@@ -121,6 +121,26 @@ describe('file-storage-upload: PickedFile array from state', () => {
     expect(entries[0].fileName).toBe('ok.png')
   })
 
+  it('marks the upload private only when asked, as a form field the proxy streams through', async () => {
+    const picked = [
+      {
+        name: 'guide.pdf',
+        size: 9,
+        type: 'application/pdf',
+        lastModified: 1,
+        dataURL: toDataURL('application/pdf', 'pdf-bytes'),
+      },
+    ]
+
+    await handler({ file: picked, private: true }, {})
+    const privateBody = fetchMock.mock.calls[0][1].body as FormDataStub
+    expect(privateBody.getAll('private').map((entry) => entry.value)).toEqual(['true'])
+
+    await handler({ file: picked }, {})
+    const publicBody = fetchMock.mock.calls[1][1].body as FormDataStub
+    expect(publicBody.getAll('private')).toHaveLength(0)
+  })
+
   it('returns an error without fetching when no array entry is convertible', async () => {
     const result = await handler({ file: [{ name: 'x.png', type: 'image/png' }] }, {})
 

package/__tests__/input-debounce-per-field.test.ts

@@ -0,0 +1,141 @@
+import { parse } from '@babel/parser'
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+
+// A debounced `event-input-updated` handler is generated once per element id
+// and shared by every row a repeater renders with that id. It used to keep ONE
+// timer: typing in the next row within the debounce window cleared the pending
+// run of the row before, so that row's value never reached its workflow. Each
+// field now debounces on its own; a field typed into twice still runs once.
+
+const ELEMENT_ID = 'option-input'
+const WORKFLOW_ID = 'wf-option-input'
+const DEBOUNCE = 250
+
+const inputWorkflow = {
+  id: WORKFLOW_ID,
+  name: 'Enter Product Option',
+  trigger: {
+    type: 'event-input-updated',
+    nodeId: 'trigger-input',
+    scope: 'element',
+    config: { elementHtmlId: ELEMENT_ID, debounce: DEBOUNCE },
+  },
+  nodes: [
+    {
+      id: 'update-1',
+      type: 'state-update-local-state',
+      config: { property: 'typedOption', value: 'x' },
+      stepNumber: 1,
+    },
+  ],
+  edges: [{ id: 'e1', source: 'trigger-input', target: 'update-1' }],
+}
+
+const generateHandlerSource = async (): Promise<string> => {
+  const ast = parse(
+    `const OptionsPage = (props) => {
+      return (
+        <div>
+          <input id="${ELEMENT_ID}" type="text" />
+        </div>
+      )
+    }`,
+    { plugins: ['jsx'] }
+  )
+  const structure: any = {
+    uidl: {
+      name: 'OptionsPage',
+      outputOptions: { pageId: 'page-options', fileName: 'options-page' },
+      stateDefinitions: {},
+      node: { type: 'element', content: { elementType: 'container', name: 'Container' } },
+    },
+    chunks: [{ type: 'chunk-type-ast', name: 'jsx-component', content: ast.program.body[0] }],
+    options: {
+      workflows: { workflows: { [WORKFLOW_ID]: inputWorkflow }, customNodes: {} },
+    },
+    dependencies: {},
+  }
+  await createNextWorkflowPlugin({ isPage: true })(structure)
+  const moduleChunk = structure.chunks.find((chunk: any) => chunk.name === 'workflow-module')
+  const match = String(moduleChunk?.content ?? '').match(
+    new RegExp(`elementTriggers\\['${ELEMENT_ID}'\\] = \\{\\n {4}\\w+: ([\\s\\S]*?)\\n {2}\\};`)
+  )
+  if (!match) {
+    throw new Error('no element trigger emitted for the input')
+  }
+  return match[1]
+}
+
+interface Run {
+  value: unknown
+  triggerElement: unknown
+}
+
+const loadHandler = async (runs: Run[]): Promise<(event: unknown) => void> => {
+  const source = await generateHandlerSource()
+  const safeId = WORKFLOW_ID.replace(/[^a-zA-Z0-9]/g, '_')
+  // tslint:disable-next-line:function-constructor
+  const factory = new Function(
+    '__execWf',
+    `__wfConfig_${safeId}`,
+    `__wfServerUrls_${safeId}`,
+    'CustomEvent',
+    `return ${source}`
+  )
+  const execWf = (_config: unknown, triggerContext: Run) => {
+    runs.push({ value: triggerContext.value, triggerElement: triggerContext.triggerElement })
+  }
+  return factory(
+    execWf,
+    {},
+    {},
+    class {
+      constructor(public type: string, public init: unknown) {}
+    }
+  )
+}
+
+const field = (value: string) => ({ value, dispatchEvent: jest.fn() })
+
+describe('debounced input trigger', () => {
+  beforeEach(() => {
+    jest.useFakeTimers()
+  })
+  afterEach(() => {
+    jest.useRealTimers()
+  })
+
+  it('runs the workflow for every field typed into within the window', async () => {
+    const runs: Run[] = []
+    const handler = await loadHandler(runs)
+    const line1 = field('John')
+    const line2 = field('Doe')
+
+    handler({ target: line1 })
+    jest.advanceTimersByTime(DEBOUNCE - 20)
+    handler({ target: line2 })
+    jest.advanceTimersByTime(DEBOUNCE)
+
+    expect(runs).toEqual([
+      { value: 'John', triggerElement: line1 },
+      { value: 'Doe', triggerElement: line2 },
+    ])
+  })
+
+  it('still runs once, with the last value, for a field typed into twice', async () => {
+    const runs: Run[] = []
+    const handler = await loadHandler(runs)
+    const line1 = field('Jo')
+
+    handler({ target: line1 })
+    jest.advanceTimersByTime(DEBOUNCE - 20)
+    line1.value = 'John'
+    handler({ target: line1 })
+    jest.advanceTimersByTime(DEBOUNCE - 1)
+    expect(runs).toEqual([])
+    jest.advanceTimersByTime(1)
+
+    expect(runs).toEqual([{ value: 'John', triggerElement: line1 }])
+    expect(line1.dispatchEvent).toHaveBeenCalledTimes(2)
+  })
+})

package/__tests__/internal-request-headers.test.ts

@@ -6,6 +6,10 @@ import {
 import { nodeRegistry } from '../src/nodes'
 import type { WorkflowSegment } from '../src/types'
 
+// The one expression that turns the context into the reply body (see
+// segmentReply in runtime-utils): whatever is deleted before it is gone.
+const REPLY_MARKER = 'utils.segmentReply(SEGMENT_CONFIG, context, __incomingSnapshot)'
+
 /**
  * A generated app's data nodes reach the database by having the server call its
  * OWN `/api/data/<id>/<op>` route over HTTP. On a deployment behind Vercel
@@ -137,7 +141,7 @@ describe('the segment routes supply the headers but never echo them back', () =>
     // would undo the httpOnly flag it was set with.
     const deleteAt = route.indexOf('delete context.__internalHeaders')
     expect(deleteAt).toBeGreaterThan(-1)
-    const firstEcho = route.indexOf('results: context')
+    const firstEcho = route.indexOf(REPLY_MARKER)
     expect(firstEcho).toBeGreaterThan(-1)
     expect(deleteAt).toBeLessThan(firstEcho)
   })
@@ -146,10 +150,10 @@ describe('the segment routes supply the headers but never echo them back', () =>
     // Guards the assertion above: a second `results: context` added later would
     // sit outside the delete's reach unless it is also after it.
     const positions: number[] = []
-    let idx = route.indexOf('results: context')
+    let idx = route.indexOf(REPLY_MARKER)
     while (idx !== -1) {
       positions.push(idx)
-      idx = route.indexOf('results: context', idx + 1)
+      idx = route.indexOf(REPLY_MARKER, idx + 1)
     }
     const deleteAt = route.indexOf('delete context.__internalHeaders')
     for (const position of positions) {