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

package/__tests__/auth-password-change-ends-sessions.test.ts

@@ -0,0 +1,178 @@
+import * as crypto from 'crypto'
+import { UIDLAuthentication } from '@teleporthq/teleport-types'
+import { generateAuthOptionsFile, USER_REFRESH_INTERVAL_MS } from '../src/auth-generator'
+
+/**
+ * A password change, a password reset included, signs the account out of every
+ * session opened before it. The session token carries a short fingerprint of
+ * the stored password hash (never the hash); the periodic refresh compares it
+ * with the account's current hash and ends a session whose fingerprint no
+ * longer matches. Sign-in with the new password works as before. Run on the
+ * EMITTED auth options.
+ */
+
+const EMAIL = 'ada@example.com'
+const FINGERPRINT = '__passwordFingerprint'
+
+const auth = {
+  enabled: true,
+  dataSourceId: 'ds-1',
+  dataSourceType: 'postgresql',
+  passwordAuthEnabled: true,
+  providers: [],
+  roles: ['user'],
+  tables: {
+    users: [
+      { name: 'id', type: 'UUID', nullable: false, isPrimaryKey: true },
+      { name: 'name', type: 'VARCHAR(255)', nullable: true },
+      { name: 'email', type: 'VARCHAR(255)', nullable: true },
+      { name: 'password', type: 'TEXT', nullable: true },
+      { name: 'role', type: 'VARCHAR(255)', nullable: false },
+    ],
+  },
+  pageProtection: {},
+  folderProtection: {},
+  authPages: {},
+  callbackBaseUrl: '/api/auth/callback',
+  envKeys: {},
+  customUserProperties: [],
+} as unknown as UIDLAuthentication
+
+// The stand-in for utils/auth/hash-password.js: a "hash" the test can name.
+const hashOf = (password: string) => `hash:${password}`
+
+const bootAuthOptions = () => {
+  const store: { row: Record<string, unknown> | null; failReads: boolean } = {
+    row: { id: 'u-1', email: EMAIL, name: 'Ada', role: 'user', password: hashOf('old secret') },
+    failReads: false,
+  }
+  class FakeClient {
+    public async connect(): Promise<void> {
+      return undefined
+    }
+    public async query(): Promise<{ rows: Array<Record<string, unknown>> }> {
+      if (store.failReads) {
+        throw new Error('connection refused')
+      }
+      return { rows: store.row ? [{ ...store.row }] : [] }
+    }
+    public async end(): Promise<void> {
+      return undefined
+    }
+  }
+  const fakeRequire = (name: string): unknown => {
+    if (name === 'pg') {
+      return { Client: FakeClient }
+    }
+    if (name === 'crypto') {
+      return crypto
+    }
+    if (name === './hash-password') {
+      return { verifyPassword: (password: string, hash: string) => hash === hashOf(password) }
+    }
+    if (name === './db-health') {
+      return { classifyAuthInfrastructureError: () => 'unknown' }
+    }
+    const provider = (config: unknown) => config
+    ;(provider as any).default = provider
+    return provider
+  }
+  const moduleObject: { exports: any } = { exports: {} }
+  // tslint:disable-next-line:function-constructor
+  new Function('require', 'module', 'exports', 'process', generateAuthOptionsFile(auth, null))(
+    fakeRequire,
+    moduleObject,
+    moduleObject.exports,
+    {
+      env: { TELEPORT_DB_CONNECTION_STRING: 'postgres://stub', NEXTAUTH_SECRET: 'secret-1' },
+    }
+  )
+  const authOptions = moduleObject.exports
+  const authorize = (password: string) =>
+    authOptions.providers[0].authorize({ email: EMAIL, password })
+  const signIn = async (password: string) =>
+    authOptions.callbacks.jwt({ token: {}, user: await authorize(password) })
+  // The refresh /api/auth/session runs once the token's interval has passed.
+  const refresh = (token: Record<string, unknown>) =>
+    authOptions.callbacks.jwt({
+      token: { ...token, __userRefreshedAt: Date.now() - USER_REFRESH_INTERVAL_MS - 1 },
+    })
+  return { authOptions, store, authorize, signIn, refresh }
+}
+
+describe('a password change ends the sessions opened before it', () => {
+  it('keeps a session whose password has not changed', async () => {
+    const site = bootAuthOptions()
+    const token = await site.signIn('old secret')
+
+    expect(typeof token[FINGERPRINT]).toBe('string')
+    const refreshed = await site.refresh(token)
+    expect(refreshed.email).toBe(EMAIL)
+    expect(refreshed[FINGERPRINT]).toBe(token[FINGERPRINT])
+  })
+
+  it('refuses the older session at its next refresh once the hash changed', async () => {
+    const site = bootAuthOptions()
+    const before = await site.signIn('old secret')
+
+    site.store.row!.password = hashOf('new secret')
+
+    await expect(site.refresh(before)).rejects.toThrow()
+    // A profile save refreshes at once, and is refused the same way.
+    await expect(
+      site.authOptions.callbacks.jwt({ token: { ...before }, trigger: 'update' })
+    ).rejects.toThrow()
+  })
+
+  it('signs in with the new password, and keeps that session', async () => {
+    const site = bootAuthOptions()
+    site.store.row!.password = hashOf('new secret')
+
+    await expect(site.authorize('old secret')).rejects.toThrow('InvalidCredentials')
+    const after = await site.signIn('new secret')
+    const refreshed = await site.refresh(after)
+    expect(refreshed.email).toBe(EMAIL)
+  })
+
+  it('fingerprints a session that has none at its first refresh, then holds it to that', async () => {
+    const site = bootAuthOptions()
+    const legacy = { id: 'u-1', email: EMAIL, name: 'Ada', role: 'user' }
+
+    const adopted = await site.refresh(legacy)
+    expect(typeof adopted[FINGERPRINT]).toBe('string')
+
+    site.store.row!.password = hashOf('new secret')
+    await expect(site.refresh(adopted)).rejects.toThrow()
+  })
+
+  it('never carries the hash, and never shows the fingerprint on session.user', async () => {
+    const site = bootAuthOptions()
+    const token = await site.signIn('old secret')
+
+    expect(JSON.stringify(token)).not.toContain(hashOf('old secret'))
+    const session = await site.authOptions.callbacks.session({
+      session: { user: {}, expires: '' },
+      token,
+    })
+    expect(session.user.email).toBe(EMAIL)
+    expect(FINGERPRINT in session.user).toBe(false)
+  })
+
+  it('keeps the session when the database cannot be read', async () => {
+    const site = bootAuthOptions()
+    const token = await site.signIn('old secret')
+
+    site.store.failReads = true
+    const kept = await site.refresh(token)
+    expect(kept.email).toBe(EMAIL)
+  })
+
+  it('reads nothing within the refresh interval', async () => {
+    const site = bootAuthOptions()
+    const token = await site.refresh(await site.signIn('old secret'))
+
+    site.store.row!.password = hashOf('new secret')
+    const within = await site.authOptions.callbacks.jwt({ token: { ...token } })
+    expect(within.email).toBe(EMAIL)
+  })
+})

package/__tests__/continue-on-error.test.ts

@@ -102,6 +102,33 @@ describe('executeNodes — a refused result on a continueOnError node', () => {
   })
 })
 
+describe('executeNodes — an email node that reached some of its recipients', () => {
+  it('reports success with the refused addresses and the chain goes on, flag or not', async () => {
+    const utils = loadSharedRuntime()
+    const partlyDelivered = {
+      id: 're-1',
+      success: true,
+      error: 'refused for blocked@lumen.test (only the owner)',
+      deliveries: [
+        { to: 'jane@lumen.test', success: true, id: 're-1' },
+        { to: 'blocked@lumen.test', success: false, error: 'only the owner' },
+      ],
+    }
+    const ran: string[] = []
+    const handlers = {
+      'email-resend': async () => partlyDelivered,
+      'toast-show': async () => {
+        ran.push('toast')
+        return { shown: true }
+      },
+    }
+    const context: Record<string, unknown> = {}
+    await utils.executeNodes([sendNode(), afterNode], edges, context, handlers, {}, null, 'x4')
+    expect(context.send).toEqual(partlyDelivered)
+    expect(ran).toEqual(['toast'])
+  })
+})
+
 describe('generated server segment route', () => {
   const segment: WorkflowSegment = {
     id: 'server-1',

package/__tests__/data-api-invalid-body.test.ts

@@ -0,0 +1,110 @@
+/* tslint:disable:function-constructor */
+import { generateDataAPIRoute } from '../src/data-api-route-generator'
+
+/**
+ * The generated `/api/data/<ds>/<op>` route answers a request whose body is
+ * empty or is not a JSON object with 400, without opening a database
+ * connection; it used to fail with a 500 parsing it.
+ */
+
+const SECRET = 'server-secret'
+
+interface RouteResult {
+  status: number
+  body: any
+  connections: number
+  queries: string[]
+}
+
+function bootRoute() {
+  const queries: string[] = []
+  let connections = 0
+  class FakeClient {
+    public async connect(): Promise<void> {
+      connections++
+    }
+    public async end(): Promise<void> {
+      return
+    }
+    public async query(sql: string): Promise<{ rows: any[]; rowCount: number }> {
+      queries.push(sql)
+      if (/^SELECT COUNT/i.test(sql)) {
+        return { rows: [{ count: '0' }], rowCount: 1 }
+      }
+      return { rows: [], rowCount: 0 }
+    }
+  }
+  const moduleObj: { exports: any } = { exports: {} }
+  const fakeRequire = (name: string): any => {
+    if (name === 'pg') {
+      return { Client: FakeClient }
+    }
+    if (name === 'next-auth/jwt') {
+      return { getToken: async () => null }
+    }
+    throw new Error('unexpected require: ' + name)
+  }
+  new Function('require', 'module', 'exports', 'process', 'console', generateDataAPIRoute())(
+    fakeRequire,
+    moduleObj,
+    moduleObj.exports,
+    { env: { NEXTAUTH_SECRET: SECRET, TELEPORT_DB_CONNECTION_STRING: 'postgresql://x' } },
+    { error: () => undefined, warn: () => undefined, log: () => undefined }
+  )
+  const handler = moduleObj.exports
+  return async (body: unknown): Promise<RouteResult> => {
+    queries.length = 0
+    connections = 0
+    const result: RouteResult = { status: 0, body: null, connections: 0, queries: [] }
+    const res = {
+      status(statusCode: number) {
+        result.status = statusCode
+        return this
+      },
+      json(payload: any) {
+        result.body = payload
+        return this
+      },
+    }
+    await handler(
+      {
+        method: 'POST',
+        query: { params: ['ds-1', 'select'] },
+        headers: { 'x-internal-data-secret': SECRET },
+        body,
+      },
+      res
+    )
+    result.connections = connections
+    result.queries = queries.slice()
+    return result
+  }
+}
+
+describe('data API — a request body that is not a JSON object', () => {
+  const run = bootRoute()
+
+  it.each([
+    ['an empty body', ''],
+    ['text that is not JSON', 'tableName=products'],
+    ['truncated JSON', '{"tableName": "prod'],
+    ['no body', undefined],
+    ['a JSON null', 'null'],
+    ['a JSON array', '[{"tableName":"products"}]'],
+    ['a parsed array', [{ tableName: 'products' }]],
+  ])('answers 400 to %s, without touching the database', async (_label, body) => {
+    const result = await run(body)
+
+    expect(result.status).toBe(400)
+    expect(result.body).toEqual({ error: 'Invalid request body. Expected a JSON object.' })
+    expect(result.connections).toBe(0)
+    expect(result.queries).toEqual([])
+  })
+
+  it('still reads a JSON object sent as a string', async () => {
+    const result = await run(JSON.stringify({ tableName: 'products' }))
+
+    expect(result.status).toBe(200)
+    expect(result.queries.some((sql) => /FROM "?products"?/i.test(sql))).toBe(true)
+  })
+})

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

@@ -18,8 +18,9 @@ import type { WorkflowSegment } from '../src/types'
 //   1. the workflow does not wait for the query;
 //   2. the node's context entry is `null` — never a partial or stale value;
 //   3. a failure cannot abort the workflow (it is logged, not thrown);
-//   4. the server route STILL settles the query before it responds, because a
-//      serverless function may be frozen the instant it replies;
+//   4. the server route STILL lands the query, because a serverless function
+//      may be frozen the instant it replies: on Vercel through waitUntil, after
+//      the reply; elsewhere before it (pending-work-after-reply.test.ts);
 //   5. the client dispatches an all-fire-and-forget SEGMENT without awaiting the
 //      round trip, which is where the latency the visitor feels actually goes.
 
@@ -448,9 +449,9 @@ describe('generated server segment route', () => {
     expect(route).toContain('context[node.id] = null;')
   })
 
-  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);')
+  it('hands in-flight queries off (or settles them) BEFORE responding (the platform can freeze us)', () => {
+    expect(route).toContain('await utils.handOffPendingNodePromises(context);')
+    const settleAt = route.indexOf('await utils.handOffPendingNodePromises(context);')
     const respondAt = route.indexOf(
       'res.status(200).json({ success: true, results: utils.segmentReply(SEGMENT_CONFIG, context, __incomingSnapshot) });'
     )
@@ -464,7 +465,7 @@ describe('generated server segment route', () => {
 
   it('drains even when the segment throws', () => {
     expect(route).toContain(
-      'if (__wfContext) { await utils.settlePendingNodePromises(__wfContext); }'
+      'if (__wfContext) { await utils.handOffPendingNodePromises(__wfContext); }'
     )
   })
 

package/__tests__/email-node-recipients.test.ts

@@ -0,0 +1,288 @@
+import { loadHandler } from './_helpers/load-handler'
+
+/**
+ * A workflow email node given several recipients sends one provider call per
+ * address: a refused address (a sender that only delivers to the account
+ * owner's address, an account still pending approval) no longer blocks the
+ * others, and the result says who got the email. One recipient behaves as it
+ * always did. Executed against fake provider SDKs that refuse an address the
+ * way each real provider does.
+ */
+
+const REASON = 'You can only send testing emails to your own email address'
+const BUYER = 'buyer@lumen.test'
+const ANA = 'ana@lumen.test'
+const BLOCKED = 'blocked@lumen.test'
+const BLOCKED_TOO = 'blocked-too@lumen.test'
+
+const addressesOf = (to: unknown): string[] => {
+  const list = Array.isArray(to) ? to : String(to).split(',')
+  return list.map((entry: any) => (typeof entry === 'object' ? entry.email : String(entry).trim()))
+}
+
+const refuses = (to: unknown): boolean =>
+  addressesOf(to).some((address) => address.toLowerCase().startsWith('blocked'))
+
+interface ProviderCall {
+  to: string[]
+  cc: string[]
+}
+
+/** Fake provider SDKs that record every call's recipients and refuse the blocked ones. */
+const fakeSdks = (calls: ProviderCall[]): Record<string, unknown> => {
+  const record = (to: unknown, cc: unknown) => {
+    calls.push({ to: addressesOf(to), cc: cc ? addressesOf(cc) : [] })
+    return calls.length
+  }
+  const sendgrid = {
+    setApiKey: (): void => undefined,
+    send: async (msg: { to: unknown; cc?: unknown }) => {
+      const n = record(msg.to, msg.cc)
+      if (refuses(msg.to)) {
+        const err: any = new Error('Bad Request')
+        err.response = { body: { errors: [{ message: REASON }] } }
+        throw err
+      }
+      return [{ statusCode: 202, headers: { 'x-message-id': 'sg-' + n } }]
+    },
+  }
+  const chainable = () => {
+    const params: Record<string, unknown> = {}
+    for (const key of ['From', 'To', 'Subject', 'Html', 'ReplyTo', 'Cc', 'Bcc', 'Attachments']) {
+      params['set' + key] = (value: unknown) => {
+        params[key.toLowerCase()] = value
+        return params
+      }
+    }
+    return params
+  }
+  return {
+    postmark: {
+      ServerClient: function ServerClient() {
+        return {
+          sendEmail: async (payload: { To: unknown; Cc?: unknown }) => {
+            const n = record(payload.To, payload.Cc)
+            if (refuses(payload.To)) {
+              throw new Error(REASON)
+            }
+            return { MessageID: 'pm-' + n }
+          },
+        }
+      },
+    },
+    resend: {
+      Resend: function Resend() {
+        return {
+          emails: {
+            send: async (payload: {
+              to: unknown
+              cc?: unknown
+            }): Promise<{
+              data: { id: string } | null
+              error: { name: string; message: string } | null
+            }> => {
+              const n = record(payload.to, payload.cc)
+              if (refuses(payload.to)) {
+                return { data: null, error: { name: 'validation_error', message: REASON } }
+              }
+              return { data: { id: 're-' + n }, error: null }
+            },
+          },
+        }
+      },
+    },
+    '@sendgrid/mail': {
+      ...sendgrid,
+      MailService: function MailService() {
+        return sendgrid
+      },
+    },
+    'mailgun.js': function Mailgun() {
+      return {
+        client: () => ({
+          messages: {
+            create: async (_domain: string, payload: { to: unknown; cc?: unknown }) => {
+              const n = record(payload.to, payload.cc)
+              if (refuses(payload.to)) {
+                throw new Error(REASON)
+              }
+              return { id: 'mg-' + n }
+            },
+          },
+        }),
+      }
+    },
+    'form-data': function FormData() {
+      return {}
+    },
+    mailersend: {
+      MailerSend: function MailerSend() {
+        return {
+          email: {
+            send: async (params: { to: unknown; cc?: unknown }) => {
+              const n = record(params.to, params.cc)
+              if (refuses(params.to)) {
+                return { statusCode: 422, body: { message: REASON } }
+              }
+              return { statusCode: 202, headers: { 'x-message-id': 'ms-' + n } }
+            },
+          },
+        }
+      },
+      Sender: function Sender(email: string, name: string) {
+        return { email, name }
+      },
+      Recipient: function Recipient(email: string, name: string) {
+        return { email, name }
+      },
+      Attachment: function Attachment() {
+        return {}
+      },
+      EmailParams: function EmailParams() {
+        return chainable()
+      },
+    },
+  }
+}
+
+// The handler loads its SDK through `__non_webpack_require__` whenever that
+// exists, so the fakes take the SDKs' place through the same global.
+const withSdks = async <T>(sdks: Record<string, unknown>, run: () => Promise<T>): Promise<T> => {
+  const scope = globalThis as { __non_webpack_require__?: unknown }
+  scope.__non_webpack_require__ = (id: string) => {
+    if (!(id in sdks)) {
+      throw new Error('unexpected require: ' + id)
+    }
+    return sdks[id]
+  }
+  try {
+    return await run()
+  } finally {
+    delete scope.__non_webpack_require__
+  }
+}
+
+type IdKey = 'id' | 'messageId'
+
+const NODES: Array<[string, string, IdKey]> = [
+  ['email-postmark', 'pm', 'messageId'],
+  ['email-resend', 're', 'id'],
+  ['email-sendgrid', 'sg', 'messageId'],
+  ['email-mailgun', 'mg', 'messageId'],
+  ['email-mailersend', 'ms', 'messageId'],
+]
+
+const baseConfig = {
+  apiKey: 'key',
+  serverToken: 'token',
+  domain: 'mg.lumen.test',
+  from: 'shop@lumen.test',
+  fromName: 'Lumen Pottery',
+  subject: 'Your order',
+  body: '<p>Thanks</p>',
+}
+
+const sendThrough = async (nodeType: string, to: unknown, extra: Record<string, unknown> = {}) => {
+  const calls: ProviderCall[] = []
+  const handler = loadHandler(nodeType)
+  const result = (await withSdks(fakeSdks(calls), () =>
+    handler({ ...baseConfig, to, ...extra }, {})
+  )) as Record<string, unknown>
+  return { calls, result }
+}
+
+describe('workflow email nodes send to each recipient separately', () => {
+  for (const [nodeType, prefix, idKey] of NODES) {
+    const idOf = (n: number) => ({ [idKey]: prefix + '-' + n })
+
+    describe(nodeType, () => {
+      it('one recipient: one provider call and the result as before', async () => {
+        const asString = await sendThrough(nodeType, BUYER)
+        expect(asString.calls).toEqual([{ to: [BUYER], cc: [] }])
+        expect(asString.result).toEqual({ ...idOf(1), success: true })
+
+        const asList = await sendThrough(nodeType, [BUYER])
+        expect(asList.calls).toEqual([{ to: [BUYER], cc: [] }])
+        expect(asList.result).toEqual({ ...idOf(1), success: true })
+      })
+
+      it('one refused recipient: the failure as before', async () => {
+        const { calls, result } = await sendThrough(nodeType, BLOCKED)
+        expect(calls).toEqual([{ to: [BLOCKED], cc: [] }])
+        expect(result).toEqual({ [idKey]: '', success: false, error: REASON })
+      })
+
+      it('several recipients, one refused: one call per address, the others delivered', async () => {
+        const { calls, result } = await sendThrough(nodeType, [BUYER, BLOCKED, ANA], {
+          cc: 'ops@lumen.test',
+        })
+        expect(calls).toEqual([
+          { to: [BUYER], cc: ['ops@lumen.test'] },
+          { to: [BLOCKED], cc: ['ops@lumen.test'] },
+          { to: [ANA], cc: ['ops@lumen.test'] },
+        ])
+        expect(result).toEqual({
+          ...idOf(1),
+          success: true,
+          error: 'refused for ' + BLOCKED + ' (' + REASON + ')',
+          deliveries: [
+            { to: BUYER, success: true, ...idOf(1) },
+            { to: BLOCKED, success: false, error: REASON },
+            { to: ANA, success: true, ...idOf(3) },
+          ],
+        })
+      })
+
+      it('every recipient refused: a failed result naming each', async () => {
+        const { calls, result } = await sendThrough(nodeType, [BLOCKED, BLOCKED_TOO])
+        expect(calls).toHaveLength(2)
+        expect(result).toEqual({
+          [idKey]: '',
+          success: false,
+          error:
+            'refused for ' + BLOCKED + ' (' + REASON + '); ' + BLOCKED_TOO + ' (' + REASON + ')',
+          deliveries: [
+            { to: BLOCKED, success: false, error: REASON },
+            { to: BLOCKED_TOO, success: false, error: REASON },
+          ],
+        })
+      })
+
+      it('drops empty entries and sends to an address once, whatever its case', async () => {
+        const { calls, result } = await sendThrough(nodeType, [
+          BUYER,
+          '',
+          'Buyer@Lumen.test',
+          null,
+          ANA,
+        ])
+        expect(calls).toEqual([
+          { to: [BUYER], cc: [] },
+          { to: [ANA], cc: [] },
+        ])
+        expect((result.deliveries as unknown[]).map((d: any) => d.to)).toEqual([BUYER, ANA])
+      })
+
+      it('refuses to send without a recipient', async () => {
+        for (const to of ['', [], undefined, [null, '']]) {
+          const { calls, result } = await sendThrough(nodeType, to)
+          expect(calls).toEqual([])
+          expect(result).toEqual({ [idKey]: '', success: false, error: 'No recipient' })
+        }
+      })
+    })
+  }
+
+  it('mailersend keeps a named recipient and matches named entries by address', async () => {
+    const { calls, result } = await sendThrough('email-mailersend', [
+      { email: BUYER, name: 'Ana' },
+      { email: 'Buyer@lumen.test', name: 'Ana again' },
+      { email: ANA },
+    ])
+    expect(calls).toEqual([
+      { to: [BUYER], cc: [] },
+      { to: [ANA], cc: [] },
+    ])
+    expect((result.deliveries as unknown[]).map((d: any) => d.to)).toEqual([BUYER, ANA])
+  })
+})