@teleporthq/teleport-plugin-next-workflows 0.44.8 → 0.44.9

package/__tests__/pending-work-after-reply.test.ts

@@ -0,0 +1,294 @@
+import { generateServerSegmentAPIRoute } from '../src/api-route-generator'
+import { generateSharedRuntimeUtilsCode } from '../src/executor-generator'
+import { isFireAndForgetNode } from '../src/await-result'
+import { NextWorkflowProjectPlugin } from '../src/workflow-project-plugin'
+import { VERCEL_FUNCTIONS_PACKAGE, VERCEL_FUNCTIONS_VERSION } from '../src/vercel-functions'
+import type { WorkflowSegment } from '../src/types'
+import { loadServerRuntime } from './_helpers/load-server-runtime'
+
+/**
+ * A step the author chose not to wait for still has to finish on the server,
+ * but the visitor no longer waits for it: a cash order's invoice (rendered,
+ * stored and mailed, 8–14 s) runs on after the segment has replied. On Vercel
+ * the route hands that work to waitUntil; anywhere else it awaits it before
+ * replying, as before.
+ */
+
+const REQUEST_CONTEXT = Symbol.for('@vercel/request-context')
+
+const invoiceNode = (awaitResult?: boolean) => ({
+  id: 'invoice',
+  type: 'ecommerce-generate-invoice',
+  label: 'Generate Invoice',
+  stepNumber: 1,
+  config: { orderId: 'order-1', ...(awaitResult === undefined ? {} : { awaitResult }) },
+})
+
+const segmentOf = (node: ReturnType<typeof invoiceNode>): WorkflowSegment =>
+  ({
+    id: 'seg-cash',
+    env: 'server',
+    nodeIds: [node.id],
+    nodes: [node],
+    edges: [],
+  } as unknown as WorkflowSegment)
+
+const deferred = () => {
+  let resolve: () => void = () => undefined
+  const promise = new Promise<void>((done) => {
+    resolve = done
+  })
+  return { promise, resolve }
+}
+
+const settleMicrotasks = () => new Promise((done) => setTimeout(done, 20))
+
+interface Reply {
+  status: number
+  body: any
+}
+
+const originalFetch = globalThis.fetch
+
+beforeEach(() => {
+  jest.spyOn(console, 'info').mockImplementation(() => undefined)
+})
+
+afterEach(() => {
+  jest.restoreAllMocks()
+  globalThis.fetch = originalFetch
+  delete (globalThis as Record<symbol, unknown>)[REQUEST_CONTEXT]
+})
+
+/**
+ * Boots the generated segment route with `modules` installed, and an invoice
+ * route that answers only once `invoiceGate` opens.
+ */
+const bootRoute = (node: ReturnType<typeof invoiceNode>, modules: Record<string, unknown>) => {
+  const invoiceGate = deferred()
+  const progress = { invoiceFinished: false }
+  globalThis.fetch = (async () => {
+    await invoiceGate.promise
+    progress.invoiceFinished = true
+    return { ok: true, status: 200, json: async () => ({ invoiceId: 'inv-1' }) }
+  }) as unknown as typeof fetch
+
+  const runtime = loadServerRuntime(modules)
+  const routeModule: { exports: unknown } = { exports: {} }
+  // tslint:disable-next-line:function-constructor
+  new Function('module', 'exports', 'require', generateServerSegmentAPIRoute(segmentOf(node)))(
+    routeModule,
+    routeModule.exports,
+    (id: string) => {
+      if (id.endsWith('server-runtime')) {
+        return runtime
+      }
+      throw new Error('Unexpected require: ' + id)
+    }
+  )
+  const handler = routeModule.exports as (req: unknown, res: unknown) => Promise<void>
+  const reply: Reply = { status: 0, body: undefined }
+  const res = {
+    status(code: number) {
+      reply.status = code
+      return this
+    },
+    json(payload: unknown) {
+      reply.body = payload
+      return this
+    },
+    setHeader: (): void => undefined,
+  }
+  const handled = handler(
+    { method: 'POST', body: { context: {} }, headers: { host: 'shop.example' } },
+    res
+  )
+  return { handled, reply, progress, openInvoiceGate: invoiceGate.resolve }
+}
+
+const onVercel = () => {
+  ;(globalThis as Record<symbol, unknown>)[REQUEST_CONTEXT] = {
+    get: () => ({ waitUntil: (): void => undefined }),
+  }
+}
+
+const fakeVercelFunctions = () => {
+  const handedOff: Array<Promise<unknown>> = []
+  return {
+    handedOff,
+    module: {
+      waitUntil: (promise: Promise<unknown>) => {
+        handedOff.push(promise)
+      },
+    },
+  }
+}
+
+describe('the invoice step may be left not awaited', () => {
+  it('is fire-and-forget only on an explicit awaitResult: false', () => {
+    expect(isFireAndForgetNode(invoiceNode(false) as never)).toBe(true)
+    expect(isFireAndForgetNode(invoiceNode(true) as never)).toBe(false)
+    expect(isFireAndForgetNode(invoiceNode() as never)).toBe(false)
+  })
+
+  it('is mirrored inside the generated runtime', () => {
+    const shared: { exports: Record<string, any> } = { exports: {} }
+    // tslint:disable-next-line:function-constructor
+    new Function('module', 'exports', generateSharedRuntimeUtilsCode())(shared, shared.exports)
+    expect(shared.exports.isFireAndForgetNode(invoiceNode(false))).toBe(true)
+    expect(shared.exports.isFireAndForgetNode(invoiceNode())).toBe(false)
+  })
+})
+
+describe('a segment route with a not-awaited step', () => {
+  it('replies on Vercel before the step finishes, and hands the step to waitUntil', async () => {
+    onVercel()
+    const vercel = fakeVercelFunctions()
+    const run = bootRoute(invoiceNode(false), { [VERCEL_FUNCTIONS_PACKAGE]: vercel.module })
+
+    const outcome = await Promise.race([
+      run.handled.then(() => 'replied'),
+      settleMicrotasks().then(() => 'still waiting'),
+    ])
+
+    expect(outcome).toBe('replied')
+    expect(run.reply.status).toBe(200)
+    expect(run.reply.body.success).toBe(true)
+    expect(run.progress.invoiceFinished).toBe(false)
+    expect(vercel.handedOff).toHaveLength(1)
+
+    run.openInvoiceGate()
+    await vercel.handedOff[0]
+    expect(run.progress.invoiceFinished).toBe(true)
+  })
+
+  it('waits for the step before replying outside a Vercel request', async () => {
+    const vercel = fakeVercelFunctions()
+    const run = bootRoute(invoiceNode(false), { [VERCEL_FUNCTIONS_PACKAGE]: vercel.module })
+
+    await settleMicrotasks()
+    expect(run.reply.status).toBe(0)
+
+    run.openInvoiceGate()
+    await run.handled
+    expect(run.progress.invoiceFinished).toBe(true)
+    expect(run.reply.status).toBe(200)
+    expect(vercel.handedOff).toHaveLength(0)
+  })
+
+  it('waits for the step before replying when @vercel/functions is not installed', async () => {
+    onVercel()
+    const run = bootRoute(invoiceNode(false), {})
+
+    await settleMicrotasks()
+    expect(run.reply.status).toBe(0)
+
+    run.openInvoiceGate()
+    await run.handled
+    expect(run.progress.invoiceFinished).toBe(true)
+    expect(run.reply.status).toBe(200)
+  })
+
+  it('still runs an awaited invoice step before replying, on Vercel too', async () => {
+    onVercel()
+    const vercel = fakeVercelFunctions()
+    const run = bootRoute(invoiceNode(), { [VERCEL_FUNCTIONS_PACKAGE]: vercel.module })
+
+    await settleMicrotasks()
+    expect(run.reply.status).toBe(0)
+
+    run.openInvoiceGate()
+    await run.handled
+    expect(run.reply.body.results.invoice.invoiceId).toBe('inv-1')
+    expect(vercel.handedOff).toHaveLength(0)
+  })
+})
+
+describe('the generated project declares @vercel/functions', () => {
+  const generate = async (
+    workflows: Record<string, unknown>,
+    dependencies: Record<string, string> = {}
+  ) => {
+    const structure: any = {
+      uidl: {
+        name: 'Store',
+        globals: { settings: { title: 'Store', language: 'en' }, env: {} },
+        root: {
+          name: 'Root',
+          stateDefinitions: {
+            route: { type: 'string', defaultValue: 'Home', values: [{ value: 'Home' }] },
+          },
+          node: { type: 'element', content: { elementType: 'container', children: [] } },
+        },
+        components: {},
+        workflows: { workflows },
+      },
+      strategy: { pages: { options: {} } },
+      files: new Map(),
+      dependencies: { ...dependencies },
+      devDependencies: {},
+    }
+    await new NextWorkflowProjectPlugin().runAfter(structure)
+    return structure
+  }
+
+  const cronWorkflow = {
+    id: 'wf-cron',
+    name: 'Nightly count',
+    trigger: {
+      type: 'event-cron-triggered',
+      nodeId: 't',
+      scope: 'global',
+      config: { schedule: '0 * * * *', urlPath: 'cron_nightly' },
+    },
+    nodes: [
+      {
+        id: 'count',
+        type: 'data-count',
+        config: { dataSourceId: 'ds-1', tableName: 'orders', filters: [] },
+        stepNumber: 1,
+        label: 'Count orders',
+      },
+    ],
+    edges: [{ id: 'e1', source: 't', target: 'count' }],
+  }
+
+  const filesRequiringIt = (structure: any): string[] => {
+    const names: string[] = []
+    for (const record of structure.files.values()) {
+      for (const file of record.files || []) {
+        if (
+          typeof file.content === 'string' &&
+          file.content.includes(`require('${VERCEL_FUNCTIONS_PACKAGE}')`)
+        ) {
+          names.push([...record.path, file.name].join('/'))
+        }
+      }
+    }
+    return names
+  }
+
+  it('when an emitted file requires it', async () => {
+    const structure = await generate({ [cronWorkflow.id]: cronWorkflow })
+
+    expect(filesRequiringIt(structure)).toContain('utils/workflows/server-runtime')
+    expect(structure.dependencies[VERCEL_FUNCTIONS_PACKAGE]).toBe(VERCEL_FUNCTIONS_VERSION)
+  })
+
+  it('keeps a version the project already declares', async () => {
+    const structure = await generate(
+      { [cronWorkflow.id]: cronWorkflow },
+      { [VERCEL_FUNCTIONS_PACKAGE]: '^2.2.10' }
+    )
+
+    expect(filesRequiringIt(structure)).toContain('utils/workflows/server-runtime')
+    expect(structure.dependencies[VERCEL_FUNCTIONS_PACKAGE]).toBe('^2.2.10')
+  })
+
+  it('never without a file that requires it', async () => {
+    const structure = await generate({})
+
+    expect(filesRequiringIt(structure)).toEqual([])
+    expect(structure.dependencies[VERCEL_FUNCTIONS_PACKAGE]).toBeUndefined()
+  })
+})

package/__tests__/runtime-condition-operands.test.ts

@@ -0,0 +1,86 @@
+import { generateSharedRuntimeUtilsCode } from '../src'
+
+/**
+ * The editor's workflow templates (delete account, password reset request,
+ * bookings, reviews, social, loyalty) write an if-statement's sides as
+ * `leftOperand` / `rightOperand` with the operator `'='`. The runtime read only
+ * `leftValue` / `rightValue`, so each of those checks compared undefined with
+ * undefined and always took its "true" branch. Both spellings are read now,
+ * and `'='` is equality.
+ */
+
+type SharedUtils = {
+  resolveConfig: (cfg: unknown, ctx: Record<string, unknown>) => Record<string, unknown>
+  evaluateCondition: (cfg: unknown, ctx: Record<string, unknown>) => boolean
+}
+
+function loadSharedRuntime(): SharedUtils {
+  const wrapper: { exports: Record<string, unknown> } = { exports: {} }
+  // tslint:disable-next-line:function-constructor
+  new Function('module', 'exports', generateSharedRuntimeUtilsCode())(wrapper, wrapper.exports)
+  return wrapper.exports as unknown as SharedUtils
+}
+
+const ref = (nodeId: string, ...path: string[]) => ({
+  type: 'workflowContext',
+  nodeId,
+  path: [nodeId, ...path],
+})
+
+// The "Is Password Correct?" step of the editor's delete-account template.
+const isPasswordCorrect = {
+  conditionType: 'simple-comparison',
+  leftOperand: ref('verify-password', 'isMatch'),
+  operator: '=',
+  rightOperand: true,
+}
+
+describe('an if-statement written with leftOperand / rightOperand', () => {
+  const utils = loadSharedRuntime()
+  // What every route does with an if-statement node: resolve, then evaluate.
+  const evaluate = (config: unknown, context: Record<string, unknown>) =>
+    utils.evaluateCondition(utils.resolveConfig(config, context), context)
+
+  it('takes the branch its operands choose', () => {
+    expect(evaluate(isPasswordCorrect, { 'verify-password': { isMatch: true } })).toBe(true)
+    expect(evaluate(isPasswordCorrect, { 'verify-password': { isMatch: false } })).toBe(false)
+  })
+
+  it('reads a missing operand as missing, not as equal to the other side', () => {
+    expect(evaluate(isPasswordCorrect, {})).toBe(false)
+  })
+
+  it("treats '=' as equality without warning about the operator", () => {
+    const warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+    try {
+      expect(evaluate({ leftOperand: 'a', operator: '=', rightOperand: 'a' }, {})).toBe(true)
+      expect(evaluate({ leftOperand: 'a', operator: '=', rightOperand: 'b' }, {})).toBe(false)
+      expect(evaluate({ leftValue: 3, operator: '=', rightValue: '3' }, {})).toBe(true)
+      expect(warn).not.toHaveBeenCalled()
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
+  it('applies inside multiple conditions', () => {
+    const both = {
+      conditionType: 'multiple-conditions',
+      logicOperator: 'AND',
+      conditions: [
+        { leftOperand: ref('form', 'agreed'), operator: '=', rightOperand: true },
+        { leftOperand: ref('form', 'email'), operator: 'is-not-empty' },
+      ],
+    }
+    expect(evaluate(both, { form: { agreed: true, email: 'a@b.c' } })).toBe(true)
+    expect(evaluate(both, { form: { agreed: false, email: 'a@b.c' } })).toBe(false)
+  })
+
+  it('keeps leftValue / rightValue first when a config carries both', () => {
+    expect(
+      evaluate(
+        { leftValue: 'x', leftOperand: 'y', operator: '===', rightValue: 'x', rightOperand: 'z' },
+        {}
+      )
+    ).toBe(true)
+  })
+})

package/__tests__/webhook-delivery-lease.test.ts

@@ -76,30 +76,92 @@ const loadLease = (options: {
 }
 
 describe('webhook delivery lease module', () => {
-  it('creates its table once, claims with a fresh token and releases only its own claim', async () => {
+  it('creates a missing table once, claims with a fresh token and releases only its own claim', async () => {
     const lease = loadLease({})
     try {
       const first = await lease.claim('webhooks/stripe-payment', Buffer.from('{"id":"evt_1"}'), {
         id: 'evt_1',
       })
       expect(first.claimed).toBe(true)
-      expect(lease.queries[0].sql).toMatch(
+      expect(lease.queries[0]).toEqual({
+        sql: 'SELECT to_regclass($1) IS NOT NULL AS present',
+        values: ['teleport_webhook_deliveries'],
+      })
+      expect(lease.queries[1].sql).toMatch(
         /^CREATE TABLE IF NOT EXISTS "teleport_webhook_deliveries"/
       )
-      const claim = lease.queries[1]
+      const claim = lease.queries[2]
       expect(claim.sql).toContain('ON CONFLICT (delivery_key) DO UPDATE')
       expect(claim.sql).toContain('WHERE d.claimed_at < NOW() - make_interval(secs => $3::int)')
       expect(claim.values[0]).toMatch(/^[0-9a-f]{64}$/)
       expect(claim.values[2]).toBe(300)
       await first.release()
-      const release = lease.queries[2]
+      const release = lease.queries[3]
       expect(release.sql).toMatch(
         /^DELETE FROM "teleport_webhook_deliveries" WHERE \(delivery_key = \$1 AND claim_token = \$2\)/
       )
       expect(release.values).toEqual([claim.values[0], claim.values[1]])
-      // The table is not created again by the next delivery.
+      // The table is neither looked up nor created again by the next delivery.
       await lease.claim('webhooks/stripe-payment', Buffer.from('{"id":"evt_2"}'), { id: 'evt_2' })
-      expect(lease.queries[3].sql).toMatch(/^INSERT INTO/)
+      expect(lease.queries[4].sql).toMatch(/^INSERT INTO/)
+    } finally {
+      lease.restore()
+    }
+  })
+
+  it('uses a table that exists without trying to create it', async () => {
+    // The site's role may write the table the editor made, not create one.
+    const lease = loadLease({
+      queryImpl: async (sql: string, values: unknown[]) => {
+        if (sql.startsWith('SELECT to_regclass')) {
+          return { rows: [{ present: true }] }
+        }
+        if (sql.startsWith('CREATE')) {
+          throw Object.assign(new Error('permission denied for schema public'), { code: '42501' })
+        }
+        return sql.startsWith('INSERT') ? { rows: [{ claim_token: values[1] }] } : { rows: [] }
+      },
+    })
+    try {
+      const first = await lease.claim('webhooks/stripe-payment', Buffer.from('{"id":"evt_1"}'), {
+        id: 'evt_1',
+      })
+      expect(first.claimed).toBe(true)
+      expect(lease.queries.map((query) => query.sql.split(' ')[0])).toEqual(['SELECT', 'INSERT'])
+
+      // A twin of a held delivery is turned away: the lease is in force.
+      const twin = loadLease({
+        queryImpl: async (sql: string) =>
+          sql.startsWith('SELECT to_regclass') ? { rows: [{ present: true }] } : { rows: [] },
+      })
+      try {
+        expect((await twin.claim('w', Buffer.from('{}'), {})).claimed).toBe(false)
+        expect(twin.queries.some((query) => query.sql.startsWith('CREATE'))).toBe(false)
+      } finally {
+        twin.restore()
+      }
+    } finally {
+      lease.restore()
+    }
+  })
+
+  it('lets every delivery run when the table is missing and cannot be created', async () => {
+    const lease = loadLease({
+      queryImpl: async (sql: string) => {
+        if (sql.startsWith('SELECT to_regclass')) {
+          return { rows: [{ present: false }] }
+        }
+        if (sql.startsWith('CREATE')) {
+          throw Object.assign(new Error('permission denied for schema public'), { code: '42501' })
+        }
+        return { rows: [] }
+      },
+    })
+    try {
+      expect((await lease.claim('w', Buffer.from('{}'), {})).claimed).toBe(true)
+      const tried = lease.queries.length
+      expect((await lease.claim('w', Buffer.from('{}'), {})).claimed).toBe(true)
+      expect(lease.queries).toHaveLength(tried)
     } finally {
       lease.restore()
     }

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

@@ -4,9 +4,14 @@
  *
  * The client node calls this route, which:
  *   1. resolves the current user from the NextAuth session (never trusting a
- *      client-supplied id),
+ *      client-supplied id) and, when the request carries a password, goes on
+ *      only if it is the account's own,
  *   2. runs a single DB transaction that detaches + anonymises business/legal
- *      records (orders, withdrawal requests, bookings) so tracking survives,
+ *      records (orders, withdrawal requests, bookings, downloads, gift cards
+ *      the user bought or received) so tracking survives, takes the user's
+ *      email out of the activity log and the sent-email ledger, leaves the
+ *      invoices already issued as they are (an invoice must keep naming its
+ *      buyer),
  *      deletes the user's personal data (reviews, cart, favourites, chat
  *      history), deletes the rows the user owns in the project's own tables —
  *      the ones the AI made for the site, each through the one column the

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

@@ -1 +1 @@
-{"version":3,"file":"account-delete-route-generator.d.ts","sourceRoot":"","sources":["../../src/account-delete-route-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AAaxE,MAAM,WAAW,yBAAyB;IAExC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAI3B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;IAGtB,kBAAkB,CAAC,EAAE,2BAA2B,CAAA;IAEhD,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,MAqXpF,CAAA"}
+{"version":3,"file":"account-delete-route-generator.d.ts","sourceRoot":"","sources":["../../src/account-delete-route-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AAaxE,MAAM,WAAW,yBAAyB;IAExC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAI3B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;IAGtB,kBAAkB,CAAC,EAAE,2BAA2B,CAAA;IAEhD,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,MAoapF,CAAA"}