@teleporthq/teleport-plugin-next-workflows 0.43.75 → 0.44.1

package/__tests__/page-arrival-remount.test.ts

@@ -0,0 +1,247 @@
+// A page keeps its instance when a navigation lands on the page already on
+// screen (a link to the current URL, another record of the same dynamic route,
+// another query string), so a trigger that fires when the page appears —
+// page-loaded, element-visible, component-loaded — ran only on the first
+// arrival. Such pages are wrapped in `remountOnPageArrival`, which starts them
+// fresh on every arrival; pages whose workflows only answer interactions keep
+// their plain export.
+
+import generator from '@babel/generator'
+import * as types from '@babel/types'
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+
+const PAGE_ID = 'page-dashboard'
+const ROOT_ID = 'thq_container_root'
+
+const workflow = (type: string, scope: string, config: Record<string, unknown>) => ({
+  id: `wf-${type}`,
+  name: type,
+  trigger: { type, nodeId: 'trigger-1', scope, config },
+  nodes: [
+    {
+      id: 'update-1',
+      type: 'state-update-local-state',
+      config: { property: 'isLoading', value: false },
+      stepNumber: 1,
+      label: 'Update',
+    },
+  ],
+  edges: [{ id: 'e1', source: 'trigger-1', target: 'update-1' }],
+})
+
+const jsxComponentChunk = (rootId: string) => ({
+  type: 'AST',
+  name: 'jsx-component',
+  content: types.variableDeclaration('const', [
+    types.variableDeclarator(
+      types.identifier('Dashboard'),
+      types.arrowFunctionExpression(
+        [types.identifier('props')],
+        types.blockStatement([
+          types.returnStatement(
+            types.jsxElement(
+              types.jsxOpeningElement(types.jsxIdentifier('div'), [
+                types.jsxAttribute(types.jsxIdentifier('id'), types.stringLiteral(rootId)),
+              ]),
+              types.jsxClosingElement(types.jsxIdentifier('div')),
+              []
+            )
+          ),
+        ])
+      )
+    ),
+  ]),
+})
+
+interface RunOptions {
+  isPage?: boolean
+  rootId?: string
+  pageNode?: unknown
+  projectComponents?: Record<string, unknown>
+}
+
+const run = async (
+  workflows: Array<ReturnType<typeof workflow>>,
+  {
+    isPage = true,
+    rootId = ROOT_ID,
+    pageNode = { type: 'element', content: { elementType: 'container' } },
+    projectComponents,
+  }: RunOptions = {}
+) => {
+  const structure: any = {
+    uidl: {
+      name: 'Dashboard',
+      node: pageNode,
+      stateDefinitions: { isLoading: { type: 'boolean', defaultValue: true } },
+      outputOptions: { pageId: PAGE_ID, folderPath: [] },
+    },
+    chunks: [
+      jsxComponentChunk(rootId),
+      {
+        type: 'AST',
+        name: 'export',
+        content: types.exportDefaultDeclaration(types.identifier('Dashboard')),
+      },
+    ],
+    options: {
+      workflows: {
+        workflows: workflows.reduce(
+          (byId: Record<string, unknown>, wf) => ({ ...byId, [wf.id]: wf }),
+          {}
+        ),
+        customNodes: {},
+      },
+      pagesPath: ['pages'],
+      extractedResources: {},
+      projectComponents,
+    },
+    dependencies: {},
+  }
+  await createNextWorkflowPlugin({ isPage })(structure)
+  const exportChunk = structure.chunks.find((chunk: any) => chunk.name === 'export')
+  const moduleChunk = structure.chunks.find((chunk: any) => chunk.name === 'workflow-module')
+  return {
+    exportCode: generator(exportChunk.content).code,
+    moduleCode: moduleChunk ? String(moduleChunk.content) : '',
+    dependencies: structure.dependencies,
+    extractedResources: structure.options.extractedResources,
+  }
+}
+
+const BANNER_ID = 'thq_container_banner'
+
+/** An instance of a project component, as local dependencies are resolved for pages. */
+const componentInstance = (name: string) => ({
+  type: 'element',
+  content: { elementType: 'component', semanticType: name, dependency: { type: 'local' } },
+})
+
+const pageRendering = (componentName: string) => ({
+  type: 'element',
+  content: { elementType: 'container', children: [componentInstance(componentName)] },
+})
+
+const bannerComponent = () => ({
+  name: 'Banner',
+  node: {
+    type: 'element',
+    content: { elementType: 'container', attrs: { id: { type: 'static', content: BANNER_ID } } },
+  },
+})
+
+const WRAPPED_EXPORT = 'export default remountOnPageArrival(Dashboard);'
+const PLAIN_EXPORT = 'export default Dashboard;'
+
+describe('workflow plugin — remount on page arrival', () => {
+  it('wraps a page whose workflow runs when the page loads', async () => {
+    const result = await run([workflow('event-page-loaded', 'page', { pageId: PAGE_ID })])
+
+    expect(result.exportCode).toBe(WRAPPED_EXPORT)
+    expect(result.dependencies.remountOnPageArrival).toEqual({
+      type: 'local',
+      path: '../utils/page-arrival',
+    })
+    expect(result.extractedResources['utils/page-arrival']).toBeDefined()
+  })
+
+  it('wraps a page whose workflow runs when its root element becomes visible', async () => {
+    const result = await run([
+      workflow('event-element-visible', 'element', { elementHtmlId: ROOT_ID, once: true }),
+    ])
+
+    expect(result.exportCode).toBe(WRAPPED_EXPORT)
+  })
+
+  it('leaves the page alone when the visible element is rendered elsewhere', async () => {
+    const result = await run(
+      [workflow('event-element-visible', 'element', { elementHtmlId: ROOT_ID, once: true })],
+      { rootId: 'thq_container_other' }
+    )
+
+    expect(result.exportCode).toBe(PLAIN_EXPORT)
+    expect(result.dependencies.remountOnPageArrival).toBeUndefined()
+    expect(result.extractedResources).toEqual({})
+  })
+
+  it('leaves the page alone when its workflows only answer interactions', async () => {
+    const result = await run([
+      workflow('event-element-clicked', 'element', { elementHtmlId: ROOT_ID }),
+      workflow('event-interval', 'page', { pageId: PAGE_ID, intervalMs: 1000 }),
+    ])
+
+    expect(result.moduleCode).not.toBe('')
+    expect(result.exportCode).toBe(PLAIN_EXPORT)
+  })
+
+  it('never wraps a component', async () => {
+    const result = await run(
+      [workflow('event-component-loaded', 'component', { componentName: 'Dashboard' })],
+      { isPage: false }
+    )
+
+    expect(result.moduleCode).toContain('Component loaded')
+    expect(result.exportCode).toBe(PLAIN_EXPORT)
+  })
+
+  it('wraps a page that renders a component running a workflow when its element is visible', async () => {
+    const result = await run(
+      [workflow('event-element-visible', 'element', { elementHtmlId: BANNER_ID, once: true })],
+      { pageNode: pageRendering('Banner'), projectComponents: { Banner: bannerComponent() } }
+    )
+
+    expect(result.moduleCode).toBe('')
+    expect(result.exportCode).toBe(WRAPPED_EXPORT)
+  })
+
+  it('finds the component through the components it is nested in', async () => {
+    const result = await run(
+      [workflow('event-element-visible', 'element', { elementHtmlId: BANNER_ID, once: true })],
+      {
+        pageNode: pageRendering('Layout'),
+        projectComponents: {
+          Layout: { name: 'Layout', node: componentInstance('Banner') },
+          Banner: bannerComponent(),
+        },
+      }
+    )
+
+    expect(result.exportCode).toBe(WRAPPED_EXPORT)
+  })
+
+  it('wraps a page that renders a component running a workflow when it loads', async () => {
+    const result = await run(
+      [workflow('event-component-loaded', 'component', { componentName: 'Banner' })],
+      { pageNode: pageRendering('Banner'), projectComponents: { Banner: bannerComponent() } }
+    )
+
+    expect(result.exportCode).toBe(WRAPPED_EXPORT)
+  })
+
+  it('leaves the page alone when no rendered component observes the element', async () => {
+    const result = await run(
+      [
+        workflow('event-element-visible', 'element', {
+          elementHtmlId: 'thq_elsewhere',
+          once: true,
+        }),
+      ],
+      { pageNode: pageRendering('Banner'), projectComponents: { Banner: bannerComponent() } }
+    )
+
+    expect(result.exportCode).toBe(PLAIN_EXPORT)
+  })
+
+  it('cancels a delayed page-loaded run together with the other triggers', async () => {
+    const result = await run([
+      workflow('event-page-loaded', 'page', { pageId: PAGE_ID, delay: 500 }),
+    ])
+
+    expect(result.moduleCode).toContain(
+      'const __delay_wf_event_page_loaded = setTimeout(function() { __execWf(__wfConfig_wf_event_page_loaded'
+    )
+    expect(result.moduleCode).toContain(
+      'cleanups.push(function() { clearTimeout(__delay_wf_event_page_loaded); });'
+    )
+  })
+})

package/__tests__/payment-drivers-module.test.ts

@@ -163,6 +163,25 @@ describe('writing the module', () => {
     )
   })
 
+  it('reads the providers of a site paid without a store, never both blocks at once', () => {
+    const paymentSettings = {
+      paymentProviders: [
+        { type: 'mollie', credentials: { apiKey: 'CONFIGURATION_MOLLIE_API_KEY' } },
+      ],
+    }
+    expect(readDeclaredPaymentCredentials({ paymentSettings } as any)).toEqual({
+      mollie: { apiKey: 'CONFIGURATION_MOLLIE_API_KEY' },
+    })
+    expect(resolveStorePaymentDriverIds({ paymentSettings } as any, [])).toContain('mollie')
+    // A store's own providers win: the editor never exports both.
+    expect(
+      readDeclaredPaymentCredentials({
+        paymentSettings,
+        ecommerceSettings: { paymentProviders: [] },
+      } as any)
+    ).toEqual({})
+  })
+
   it('writes nothing for a store that takes no online payment', () => {
     const target = structure()
     ensurePaymentDriversModule(target as any, [])

package/__tests__/raw-query-error-code.test.ts

@@ -0,0 +1,47 @@
+import { loadHandler } from './_helpers/load-handler'
+
+// A statement that raises on purpose (a seat race lost, a slot taken) is told
+// apart from a broken one by the SQLSTATE the data route answers with — the
+// route keeps the database's message in its own log, so the code is all a
+// workflow can read.
+
+async function runAgainst(response: { ok: boolean; body: unknown }): Promise<any> {
+  const fetchMock = jest.fn(async () => ({
+    ok: response.ok,
+    json: async () => response.body,
+  }))
+  const originalFetch = (globalThis as any).fetch
+  ;(globalThis as any).fetch = fetchMock
+  try {
+    const handler = loadHandler('data-raw-query')
+    return await handler({ dataSourceId: 'ds', query: 'SELECT 1', params: [] }, {})
+  } finally {
+    ;(globalThis as any).fetch = originalFetch
+  }
+}
+
+describe('data-raw-query — a database error reaches the workflow with its SQLSTATE', () => {
+  it('passes the route’s code on beside the error', async () => {
+    const result = await runAgainst({
+      ok: false,
+      body: { error: 'Internal server error', code: '2203A' },
+    })
+    expect(result).toEqual({
+      rows: [],
+      result: [],
+      error: 'Internal server error',
+      code: '2203A',
+    })
+  })
+
+  it('answers no code when the route gave none', async () => {
+    const result = await runAgainst({ ok: false, body: { error: 'INVALID_SQL_IDENTIFIER' } })
+    expect(result).toEqual({ rows: [], result: [], error: 'INVALID_SQL_IDENTIFIER' })
+    expect('code' in result).toBe(false)
+  })
+
+  it('answers the rows of a statement that went through', async () => {
+    const result = await runAgainst({ ok: true, body: { rows: [{ code: 'ok' }] } })
+    expect(result).toEqual({ rows: [{ code: 'ok' }], result: [{ code: 'ok' }] })
+  })
+})

package/__tests__/runtime-template-token-resolution.test.ts

@@ -132,6 +132,22 @@ describe('workflow runtime template-token resolution', () => {
       expect(cfg.columnMappings[0].value).toBeNull()
     })
 
+    it('never walks into a live element or around a cycle (a trigger target in a custom-js param)', () => {
+      const fiber: Record<string, unknown> = {}
+      const element: Record<string, unknown> = {
+        nodeType: 1,
+        nodeName: 'INPUT',
+        __reactFiber$abc: fiber,
+      }
+      fiber.stateNode = element
+      const loop: Record<string, unknown> = { a: 1 }
+      loop.self = loop
+      const cfg = { code: 'x', params: { event: { target: element, value: SENTINEL }, loop } }
+      expect(utils.finalizeResolvedConfig('general-custom-js', cfg)).toBeNull()
+      expect(cfg.params.event.value).toBeNull()
+      expect(cfg.params.event.target).toBe(element)
+    })
+
     it('leaves configs without sentinels untouched', () => {
       const cfg = { filters: [{ field: 'id', value: null, operator: '=' }] }
       expect(utils.finalizeResolvedConfig('data-select', cfg)).toBeNull()

package/__tests__/segment-reply-changed-keys.test.ts

@@ -111,6 +111,37 @@ describe('generated server segment — what it replies with', () => {
     expect(results).not.toHaveProperty('__pendingNodePromises')
   })
 
+  it('keeps a result marked keepResultOnServer on the server, for the nodes after it only', async () => {
+    const kept: WorkflowSegment = {
+      ...segment,
+      nodes: [
+        { ...calcNode, config: { ...calcNode.config, keepResultOnServer: true } },
+        gateNode,
+        bigNode,
+      ],
+    }
+    const results = (await bootRoute(kept)(request())).body.results || {}
+    expect(results).not.toHaveProperty('calc')
+    // The gate read it on the server: 42 is not above 100.
+    expect(results.gate).toEqual({ result: false })
+    expect(results.__skippedNodes).toEqual({ big: true })
+    // Nothing is signed for a result that never left.
+    expect((results.__sig as Record<string, string>).calc).toBeUndefined()
+  })
+
+  it('still replies with a branching node marked keepResultOnServer: the client branches on it', async () => {
+    const kept: WorkflowSegment = {
+      ...segment,
+      nodes: [
+        calcNode,
+        { ...gateNode, config: { ...gateNode.config, keepResultOnServer: true } },
+        bigNode,
+      ],
+    }
+    const results = (await bootRoute(kept)(request())).body.results || {}
+    expect(results.gate).toEqual({ result: false })
+  })
+
   it('still replies with what the route itself adds to the run', async () => {
     const results = (await bootRoute(segment)(request())).body.results || {}
     // The route learns the deployment's origin; a custom node called next

package/__tests__/segment-route-skipped-branch.test.ts

@@ -0,0 +1,101 @@
+import { generateServerSegmentAPIRoute } from '../src/api-route-generator'
+import type { WorkflowSegment } from '../src/types'
+import { loadServerRuntime } from './_helpers/load-server-runtime'
+
+/**
+ * A server segment never runs a node of an if-statement branch it did not
+ * take — an if-statement there included. It used to evaluate those before
+ * checking the skip list, and hand their `{ result }`s back: a custom node
+ * answers the output of the last node it ran, so the email senders of
+ * teleport-gui (one "is it this email?" → send → "was it accepted?" → report
+ * branch per purpose, all in one server segment) answered `{ result: false }`
+ * instead of their report, and every caller read "not sent" whatever happened.
+ */
+
+const purpose = { type: 'workflowContext', nodeId: 'read', path: ['read', 'purpose'] }
+
+const ifNode = (id: string, stepNumber: number, leftValue: unknown, rightValue: unknown) => ({
+  id,
+  type: 'general-if-statement',
+  label: id,
+  config: { conditionType: 'simple-comparison', leftValue, operator: '===', rightValue },
+  executionEnv: 'server',
+  stepNumber,
+})
+
+const segment = {
+  id: 'server-1',
+  env: 'server',
+  nodeIds: ['isA', 'acceptedA', 'isB', 'acceptedB'],
+  nodes: [
+    ifNode('isA', 1, purpose, 'a'),
+    ifNode('acceptedA', 2, 'yes', 'yes'),
+    ifNode('isB', 2, purpose, 'b'),
+    // Numbered after the branch that runs: the one an answer used to pick.
+    ifNode('acceptedB', 3, 'yes', 'yes'),
+  ],
+  edges: [
+    { id: 'e1', source: 'isA', target: 'acceptedA', sourceHandle: 'true' },
+    { id: 'e2', source: 'isA', target: 'isB', sourceHandle: 'false' },
+    { id: 'e3', source: 'isB', target: 'acceptedB', sourceHandle: 'true' },
+  ],
+} as unknown as WorkflowSegment
+
+async function runSegment(incoming: Record<string, unknown>): Promise<Record<string, any>> {
+  const runtime = loadServerRuntime()
+  const requireShim = (id: string) => {
+    if (id.endsWith('/utils/workflows/server-runtime')) {
+      return runtime
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(id)
+  }
+  const module = { exports: null as any }
+  // eslint-disable-next-line no-new-func
+  new Function('module', 'exports', 'require', generateServerSegmentAPIRoute(segment, 'Sender'))(
+    module,
+    {},
+    requireShim
+  )
+  const reply = { status: 0, body: null as any }
+  const res = {
+    status(code: number) {
+      reply.status = code
+      return {
+        json(payload: unknown) {
+          reply.body = payload
+        },
+      }
+    },
+    setHeader: () => undefined,
+  }
+  await module.exports(
+    {
+      method: 'POST',
+      url: '/api/workflows/sender-seg-1',
+      headers: { host: 'shop.test', 'x-forwarded-proto': 'https' },
+      body: { context: incoming },
+    },
+    res
+  )
+  expect(reply.status).toBe(200)
+  return reply.body.results
+}
+
+describe('generated server segment route — a branch not taken', () => {
+  it('answers the branch it took, and nothing of the one it skipped', async () => {
+    const results = await runSegment({ read: { purpose: 'a' } })
+    expect(results.isA).toEqual({ result: true })
+    expect(results.acceptedA).toEqual({ result: true })
+    expect(results).not.toHaveProperty('isB')
+    expect(results).not.toHaveProperty('acceptedB')
+    expect(results.__skippedNodes).toMatchObject({ isB: true, acceptedB: true })
+  })
+
+  it('runs the other branch when that one is taken', async () => {
+    const results = await runSegment({ read: { purpose: 'b' } })
+    expect(results.isB).toEqual({ result: true })
+    expect(results.acceptedB).toEqual({ result: true })
+    expect(results).not.toHaveProperty('acceptedA')
+  })
+})