@teleporthq/teleport-plugin-next-workflows 0.43.1

package/__tests__/order-ownership.test.ts

@@ -0,0 +1,163 @@
+import {
+  looksLikeOrderOwnershipHandler,
+  buildOrderOwnershipReplacement,
+} from '../src/ecommerce/order-ownership'
+import { STOCK_DECREMENT_MARKER } from '../src/ecommerce/stock-decrement'
+
+// Verbatim copy of the AI's `orders-list-page-load` customHandler —
+// the one that builds the WHERE clause for the orders-list page.
+// Trimmed to just the auth + ownership construction (the downstream
+// SELECT/FROM string-building is irrelevant to the rewriter).
+const AI_ORDERS_LIST_HANDLER = `function customHandler(params) {
+  var authResult = null;
+  for (var i = 0; i < params.length; i++) {
+    var p = params[i];
+    if (p && typeof p === "object" && "isLoggedIn" in p && "userId" in p &&
+        typeof p.isAnonymous !== "boolean") {
+      authResult = p;
+      break;
+    }
+  }
+  if (!authResult) authResult = {};
+  var userId = authResult.userId != null ? String(authResult.userId) : "";
+  var anonymousUserId = authResult.anonymousUserId != null ? String(authResult.anonymousUserId) : "";
+  var role = authResult.role != null ? String(authResult.role) : "";
+  function escapeSqlString(value) {
+    return String(value).replace(/'/g, "''");
+  }
+  var safeUserId = escapeSqlString(userId);
+  var safeAnonUserId = escapeSqlString(anonymousUserId);
+  var __ownership;
+  if (role === "admin") {
+    __ownership = "1=1";
+  } else if (anonymousUserId && anonymousUserId !== userId) {
+    __ownership = "(o.user_id::text = '" + safeUserId + "' OR o.user_id::text = '" + safeAnonUserId + "')";
+  } else {
+    __ownership = "o.user_id::text = '" + safeUserId + "'";
+  }
+  var SELECT_COLS = "o.id AS order_id, o.order_number AS order_number";
+  var FROM_CLAUSE = "FROM teleport_orders o";
+  var query =
+    "SELECT " + SELECT_COLS + " " +
+    FROM_CLAUSE + " " +
+    "WHERE " + __ownership + " " +
+    "ORDER BY o.created_at DESC";
+  return { query: query };
+}`
+
+// Helper to evaluate the rewritten customHandler with controlled
+// upstream inputs. Returns the SQL query string the handler builds.
+const runHandler = (code: string, authResult: Record<string, unknown>): string => {
+  const fn = new Function('params', code + '\nreturn customHandler(params);') as (
+    params: unknown[]
+  ) => { query: string }
+  return fn([authResult]).query
+}
+
+describe('looksLikeOrderOwnershipHandler — pattern detection', () => {
+  it('matches the AI verbatim ownership-handler shape', () => {
+    expect(looksLikeOrderOwnershipHandler(AI_ORDERS_LIST_HANDLER)).toBe(true)
+  })
+
+  it('rejects already-rewritten code (carries the marker)', () => {
+    const rewritten = buildOrderOwnershipReplacement(AI_ORDERS_LIST_HANDLER)
+    expect(rewritten).toContain(STOCK_DECREMENT_MARKER)
+    expect(looksLikeOrderOwnershipHandler(rewritten)).toBe(false)
+  })
+
+  it('rejects handlers missing any of the load-bearing fragments', () => {
+    expect(looksLikeOrderOwnershipHandler('function customHandler() { return {}; }')).toBe(false)
+    // Has __ownership and user_id::text but no safeAnonUserId — not the
+    // pattern we're after (some future AI variant might emit a single-
+    // identity flow we don't want to touch).
+    expect(
+      looksLikeOrderOwnershipHandler(
+        `var __ownership = "o.user_id::text = 'x'"; var safeUserId = "x";`
+      )
+    ).toBe(false)
+  })
+
+  it('rejects non-string inputs without throwing', () => {
+    expect(looksLikeOrderOwnershipHandler(null as unknown as string)).toBe(false)
+    expect(looksLikeOrderOwnershipHandler(undefined as unknown as string)).toBe(false)
+    expect(looksLikeOrderOwnershipHandler(42 as unknown as string)).toBe(false)
+  })
+})
+
+describe('buildOrderOwnershipReplacement — runtime semantics', () => {
+  const rewritten = buildOrderOwnershipReplacement(AI_ORDERS_LIST_HANDLER)
+
+  it('still emits a function customHandler(params) declaration', () => {
+    expect(rewritten).toContain('function customHandler(params)')
+  })
+
+  it('stamps the STOCK_DECREMENT_MARKER for idempotent re-runs', () => {
+    expect(rewritten).toContain(STOCK_DECREMENT_MARKER)
+  })
+
+  it('logged-in user → query scopes to their auth userId ONLY (no anon OR-merge)', () => {
+    const q = runHandler(rewritten, {
+      userId: 'real-uuid-aaa',
+      anonymousUserId: 'spoofed-anon-bbb',
+      role: 'user',
+      isLoggedIn: 'true',
+    })
+    // The strict variant must NOT include the anon UUID in the WHERE.
+    expect(q).toContain("o.user_id::text = 'real-uuid-aaa'")
+    expect(q).not.toContain('spoofed-anon-bbb')
+    expect(q).not.toContain(' OR ')
+  })
+
+  it('pure-anonymous browser → query scopes to the anon UUID only', () => {
+    const q = runHandler(rewritten, {
+      userId: '',
+      anonymousUserId: 'anon-uuid-xxx',
+      role: '',
+      isLoggedIn: 'false',
+    })
+    expect(q).toContain("o.user_id::text = 'anon-uuid-xxx'")
+    expect(q).not.toContain(' OR ')
+  })
+
+  it('admin role on the buyer "My Orders" page → still scoped to their own auth UUID', () => {
+    // This customHandler is wired into the BUYER-facing /orders-list
+    // page (titled "My Orders") — an admin landing here should see
+    // their own personal purchases, NOT every customer's orders. The
+    // admin-wide order view lives at /admin/orders, a separate
+    // workflow this rewriter doesn't touch.
+    const q = runHandler(rewritten, {
+      userId: 'admin-uuid',
+      anonymousUserId: '',
+      role: 'admin',
+      isLoggedIn: 'true',
+    })
+    expect(q).toContain("o.user_id::text = 'admin-uuid'")
+    expect(q).not.toContain('WHERE 1=1')
+    expect(q).not.toContain(' OR ')
+  })
+
+  it('no identity at all → query matches no rows (1=0)', () => {
+    const q = runHandler(rewritten, {
+      userId: '',
+      anonymousUserId: '',
+      role: '',
+      isLoggedIn: 'false',
+    })
+    expect(q).toContain('WHERE 1=0')
+    // No accidental `user_id::text = ''` that could leak rows with
+    // empty user_id strings.
+    expect(q).not.toMatch(/user_id::text\s*=\s*''/)
+  })
+
+  it('logged-in user with a quote in their userId → still safely escaped', () => {
+    // The original handler already escapes single quotes via
+    // \`escapeSqlString\`. We must not regress that.
+    const q = runHandler(rewritten, {
+      userId: "abc'or'1'='1",
+      anonymousUserId: '',
+      role: 'user',
+      isLoggedIn: 'true',
+    })
+    expect(q).toContain("o.user_id::text = 'abc''or''1''=''1'")
+  })
+})

package/__tests__/payment-redirect-and-order-notification.test.ts

@@ -0,0 +1,131 @@
+import { paymentChargeUser } from '../src/nodes/payment/payment-charge-user'
+import { dataCreateItem } from '../src/nodes/data/data-create-item'
+
+// Two regressions pinned in this file, both surfaced in a single
+// guest-checkout attempt against the freshly generated project:
+//
+//   1) Clicking "Pay Now" with the Stripe payment method left the
+//      button stuck at "Processing…". Root cause: the
+//      payment-charge-user server handler returns
+//      { checkoutUrl, sessionId, __terminal: true } and the client
+//      runtime honors __terminal but does NOT navigate the buyer
+//      to Stripe's hosted checkout page. The buyer never reaches
+//      the payment form, the Stripe webhook never fires, and
+//      isPlacingOrder is never reset back to "false".
+//
+//   2) No order-confirmation email was delivered. The
+//      ecommerceSettings.orderNotificationConfig is wired into a
+//      /api/ecommerce/order-notification endpoint, but the
+//      endpoint was only called from the PayPal webhook —
+//      COD orders and synchronous Stripe flows silently skipped
+//      it. Auto-firing the notification from data-create-item on
+//      every INSERT into teleport_orders covers BOTH paths
+//      without requiring the AI to add an explicit email-send
+//      workflow node.
+
+describe('payment-charge-user emits __redirectUrl alongside __terminal', () => {
+  const handlerSource = paymentChargeUser.generateHandler()
+
+  it('Stripe path returns __redirectUrl set to the session URL', () => {
+    // The exact JSON shape the workflow runtime consumes — we
+    // assert on the source string because exercising the live
+    // handler would require a real Stripe API key. ts-jest may
+    // downlevel `const` to `var` in some configs, so match on the
+    // assignment substring rather than the declaration keyword.
+    expect(handlerSource).toContain('__redirectUrl: checkoutUrl')
+    expect(handlerSource).toMatch(/checkoutUrl = session\.url/)
+  })
+
+  it('PayPal path returns __redirectUrl set to the PayPal approval link', () => {
+    // Mirrors the Stripe wiring so both gateways drive the same
+    // client-runtime redirect step. Without the PayPal half the
+    // PayPal-only stores would hit the same stuck-Processing bug.
+    expect(handlerSource).toContain('__redirectUrl: approveUrl')
+    expect(handlerSource).toContain('approveUrl = approveLink ? approveLink.href')
+  })
+
+  it('still sets __terminal: true so the workflow stops at the redirect', () => {
+    // The runtime stops on __terminal regardless of __redirectUrl;
+    // both flags must be present so the redirect happens AND
+    // downstream nodes (cart-clear, navigate-to-order-details,
+    // reset-isPlacingOrder) are NOT executed before the buyer
+    // leaves for Stripe — the cart should only clear on the
+    // payment-success return URL.
+    const stripeBlock = handlerSource.slice(
+      handlerSource.indexOf('checkoutUrl: checkoutUrl'),
+      handlerSource.indexOf('checkoutUrl: checkoutUrl') + 300
+    )
+    expect(stripeBlock).toContain('__terminal: true')
+    expect(stripeBlock).toContain('__redirectUrl: checkoutUrl')
+  })
+
+  it('returns an error object (not __redirectUrl) when Stripe API call fails', () => {
+    // The catch block must NOT add __redirectUrl — the client
+    // runtime should render the toast/error path instead of
+    // navigating to an empty URL on a failed charge. ts-jest may
+    // rename `err` to `err_1` etc. during downleveling — match
+    // the substring that proves the error message is surfaced.
+    expect(handlerSource).toMatch(/error:\s*\w+\.message/)
+  })
+})
+
+describe('data-create-item auto-fires order-notification for teleport_orders inserts', () => {
+  const src = dataCreateItem.generateHandler() as string
+
+  it('detects the teleport_orders table by name', () => {
+    expect(src).toContain("tableName === 'teleport_orders'")
+  })
+
+  it('POSTs to /api/ecommerce/order-notification with the inserted row', () => {
+    expect(src).toContain("'/api/ecommerce/order-notification'")
+    // orderId is the raw UUID (used by support/debug); orderNumber is
+    // the human-friendly identifier the merchant templates use. Older
+    // code folded order_number into the orderId slot which made
+    // {{orderNumber}} render as a UUID. We now pass both, with
+    // orderNumber falling back to the id if no order_number column
+    // exists.
+    expect(src).toContain('orderId: item.id')
+    expect(src).toContain('orderNumber: item.order_number || item.id')
+    expect(src).toContain('customerEmail: item.billing_email')
+    expect(src).toContain('customerName: item.billing_name')
+    expect(src).toContain('paymentMethod: item.payment_method')
+  })
+
+  it('fires-and-forgets — does NOT await the notification call', () => {
+    // Awaiting an email provider that times out would block the
+    // workflow's success response back to the buyer, leaving the
+    // checkout button stuck at Processing for the duration of the
+    // provider's TCP timeout. Fire-and-forget is the right shape
+    // here — failures are swallowed by .catch().
+    expect(src).not.toMatch(/await\s+fetch\([^)]*order-notification/)
+    expect(src).toContain('.catch(function')
+  })
+
+  it('only fires when the create succeeded with a row payload', () => {
+    // A guarded block ensures we don't try to email out an empty
+    // shell when handleCreate errored — that would surface a
+    // confusing "Order # null" message to the merchant.
+    expect(src).toMatch(/data && data\.item/)
+  })
+
+  it('does not touch the response shape the existing workflow consumes', () => {
+    // The original return shape — { id, ...item } — must remain
+    // identical so any downstream workflow node that reads
+    // result.id keeps working. ts-jest's ES5 downleveling rewrites
+    // the spread to __assign, so match the precise sub-fragments
+    // rather than the full literal.
+    expect(src).toMatch(
+      /id:\s*data\.id\s*\|\|\s*\(data\.item\s*&&\s*data\.item\.id\)\s*\|\|\s*null/
+    )
+    // The item spread happens immediately after the id field; in
+    // ES5 mode it surfaces as `__assign({ id: ... }, (data.item || {}))`.
+    expect(src).toMatch(/\(data\.item\s*\|\|\s*\{\}\)/)
+  })
+
+  it('still forwards the anonymousUserId hint to the data-api', () => {
+    // Sanity: the previous-session fix that fed anonymousUserId
+    // through to coerceUuidColumnValue must not regress when
+    // tacking the email-notification block onto the same handler.
+    expect(src).toContain('reqBody.__anonymousUserId = __anonymousUserId')
+  })
+})

package/__tests__/runtime-absolutize-url.test.ts

@@ -0,0 +1,90 @@
+import { generateClientRuntimeCode } from '../src/executor-generator'
+
+// Regression guard for the server-side relative-URL fetch bug. The
+// generated client runtime is also loaded from Node in server-only
+// paths (e.g. Stripe / PayPal webhooks that trigger custom workflow
+// nodes with a server segment): undici's `fetch` rejects relative
+// URLs with "Failed to parse URL from /api/workflows/...".
+//
+// `absolutizeSegmentUrl` closes that gap using `context.__baseUrl`
+// (the live request origin recorded by the api-route generator).
+// This file locks the behaviour in with a battery of inputs so a
+// future refactor of the runtime can't silently reintroduce the
+// relative-URL fetch that used to crash payment webhooks.
+
+type Absolutize = (segmentUrl: unknown, context: unknown) => unknown
+
+function extractAbsolutizer(): Absolutize {
+  const src = generateClientRuntimeCode()
+  // Match from `function absolutizeSegmentUrl` up to the matching
+  // closing brace on its own line, then `eval` it to expose the
+  // function. The runtime is generated as a single string, so eval
+  // here is the cleanest way to exercise its internals without
+  // booting Next.js.
+  const match = src.match(/function absolutizeSegmentUrl[\s\S]*?\n\}/)
+  if (!match) {
+    throw new Error('absolutizeSegmentUrl not found in generated runtime')
+  }
+  // Node gives us access to `window` in test env via globalThis only
+  // when we set it — keep it undefined here so the function behaves
+  // as it would in a Node workflow segment.
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  return new Function(match[0] + '\nreturn absolutizeSegmentUrl;')() as Absolutize
+}
+
+describe('absolutizeSegmentUrl — server-side workflow fetch bridge', () => {
+  const abs = extractAbsolutizer()
+
+  it('absolutizes a relative /api URL using context.__baseUrl', () => {
+    expect(
+      abs('/api/workflows/process-payment-webhook-seg-server-1', {
+        __baseUrl: 'http://localhost:3000',
+      })
+    ).toBe('http://localhost:3000/api/workflows/process-payment-webhook-seg-server-1')
+  })
+
+  it('strips any trailing slashes from __baseUrl before concatenating', () => {
+    // Whether req.headers.host is "localhost:3000" or "example.com/"
+    // depends on deployment; both must produce the same URL.
+    expect(abs('/api/workflows/seg', { __baseUrl: 'http://localhost:3000/' })).toBe(
+      'http://localhost:3000/api/workflows/seg'
+    )
+    expect(abs('/api/workflows/seg', { __baseUrl: 'http://example.com///' })).toBe(
+      'http://example.com/api/workflows/seg'
+    )
+  })
+
+  it('leaves an already-absolute http(s) URL untouched', () => {
+    expect(abs('http://other.example/api', { __baseUrl: 'http://localhost:3000' })).toBe(
+      'http://other.example/api'
+    )
+    expect(abs('https://other.example/api', { __baseUrl: 'http://localhost:3000' })).toBe(
+      'https://other.example/api'
+    )
+  })
+
+  it('falls back to the original URL when __baseUrl is missing', () => {
+    // Server-side without __baseUrl means the api-route generator
+    // didn't run before this point — the fetch will still fail, but
+    // that's a generator bug, not this function's job. Keep the URL
+    // unchanged so the error message continues to point at the real
+    // cause.
+    expect(abs('/api/workflows/seg', {})).toBe('/api/workflows/seg')
+    expect(abs('/api/workflows/seg', null)).toBe('/api/workflows/seg')
+    expect(abs('/api/workflows/seg', undefined)).toBe('/api/workflows/seg')
+  })
+
+  it('prefixes a missing leading slash before concatenating', () => {
+    // Defensive: if a future codegen emits 'api/workflows/seg' without
+    // the leading '/', the concat must still produce a valid URL.
+    expect(abs('api/workflows/seg', { __baseUrl: 'http://localhost:3000' })).toBe(
+      'http://localhost:3000/api/workflows/seg'
+    )
+  })
+
+  it('passes through empty / null / non-string inputs untouched', () => {
+    expect(abs('', { __baseUrl: 'http://localhost:3000' })).toBe('')
+    expect(abs(null, { __baseUrl: 'http://localhost:3000' })).toBe(null)
+    expect(abs(undefined, { __baseUrl: 'http://localhost:3000' })).toBe(undefined)
+  })
+})

package/__tests__/security-runtime-shadow.test.ts

@@ -0,0 +1,195 @@
+import { loadHandler } from './_helpers/load-handler'
+import {
+  assertWorkflowsAreSecure,
+  CodegenSecurityError,
+  PROTECTED_ENV_NAMES,
+} from '../src/security-scanner'
+
+// Verifies the two security layers added on top of the general-custom-js
+// handler:
+//
+//   1. Codegen-time gate (`assertWorkflowsAreSecure`) refuses to even emit
+//      code for nodes whose user JS reads protected env vars or uses a
+//      sandbox-escape primitive.
+//
+//   2. Runtime preamble injected into the `new Function(...)` body shadows
+//      `process` so that `process.env.<protected>` resolves to `undefined`
+//      even when the user code is executed.
+
+describe('assertWorkflowsAreSecure (codegen gate)', () => {
+  it('throws CodegenSecurityError when custom-js reads a protected env', () => {
+    const uidlWorkflows = {
+      workflows: {
+        w1: {
+          id: 'w1',
+          name: 'wf',
+          nodes: [
+            {
+              id: 'n1',
+              type: 'general-custom-js',
+              config: {
+                code: 'function customHandler(){ return process.env.TELEPORT_DB_CONNECTION_STRING; }',
+              },
+            },
+          ],
+        },
+      },
+    }
+    expect(() => assertWorkflowsAreSecure(uidlWorkflows)).toThrowError(CodegenSecurityError)
+  })
+
+  it('throws for eval', () => {
+    const uidlWorkflows = {
+      workflows: {
+        w: {
+          nodes: [{ id: 'a', type: 'general-custom-js', config: { code: "eval('1+1')" } }],
+        },
+      },
+    }
+    expect(() => assertWorkflowsAreSecure(uidlWorkflows)).toThrowError(CodegenSecurityError)
+  })
+
+  it('throws for require("fs")', () => {
+    const uidlWorkflows = {
+      workflows: {
+        w: {
+          nodes: [
+            {
+              id: 'a',
+              type: 'general-custom-js',
+              config: { code: "const fs = require('fs');" },
+            },
+          ],
+        },
+      },
+    }
+    expect(() => assertWorkflowsAreSecure(uidlWorkflows)).toThrowError(CodegenSecurityError)
+  })
+
+  it('passes a clean workflow', () => {
+    const uidlWorkflows = {
+      workflows: {
+        w: {
+          nodes: [
+            {
+              id: 'a',
+              type: 'general-custom-js',
+              config: { code: 'function customHandler(p){ return p[0]; }' },
+            },
+          ],
+        },
+      },
+    }
+    expect(() => assertWorkflowsAreSecure(uidlWorkflows)).not.toThrow()
+  })
+
+  it('ignores non-custom-js nodes', () => {
+    const uidlWorkflows = {
+      workflows: {
+        w: {
+          nodes: [
+            {
+              id: 'a',
+              type: 'general-http-request',
+              config: { url: 'https://example.com' },
+            },
+          ],
+        },
+      },
+    }
+    expect(() => assertWorkflowsAreSecure(uidlWorkflows)).not.toThrow()
+  })
+
+  it('PROTECTED_ENV_NAMES contains exactly the 8 documented secrets', () => {
+    expect([...PROTECTED_ENV_NAMES].sort()).toEqual(
+      [
+        'PDF_SERVICE_API_KEY',
+        'PDF_SERVICE_URL',
+        'REALTIME_SERVER_API_KEY',
+        'REALTIME_SERVER_URL',
+        'RUNTIME_STORAGE_API_KEY',
+        'RUNTIME_STORAGE_PROJECT_ID',
+        'TELEPORT_DB_CONNECTION_STRING',
+        'TELEPORT_PROJECT_TOKEN',
+      ].sort()
+    )
+  })
+})
+
+describe('general-custom-js handler — runtime process shadow', () => {
+  const handler = loadHandler('general-custom-js')
+
+  const PROTECTED = process.env
+  beforeAll(() => {
+    // Inject sentinel values so we can confirm the shadow really hides them.
+    process.env.TELEPORT_DB_CONNECTION_STRING = 'secret-db-url'
+    process.env.RUNTIME_STORAGE_API_KEY = 'secret-storage'
+    process.env.TELEPORT_PROJECT_TOKEN = 'secret-token'
+    process.env.PUBLIC_FEATURE_FLAG = 'allowed'
+  })
+  afterAll(() => {
+    // Restore exactly what was there.
+    process.env = { ...PROTECTED }
+  })
+
+  it('hides protected env vars from user code', async () => {
+    const code = `function customHandler(){
+      return {
+        db: process.env.TELEPORT_DB_CONNECTION_STRING,
+        storage: process.env.RUNTIME_STORAGE_API_KEY,
+        token: process.env.TELEPORT_PROJECT_TOKEN,
+        allowed: process.env.PUBLIC_FEATURE_FLAG,
+      }
+    }`
+    const out = (await handler({ code, __nodeId: 'a' }, {})) as Record<string, unknown>
+    expect(out.db).toBeUndefined()
+    expect(out.storage).toBeUndefined()
+    expect(out.token).toBeUndefined()
+    expect(out.allowed).toBe('allowed')
+  })
+
+  it('hides protected vars from Object.keys(process.env)', async () => {
+    const code = `function customHandler(){
+      return Object.keys(process.env);
+    }`
+    const out = (await handler({ code, __nodeId: 'a' }, {})) as string[]
+    expect(out).not.toContain('TELEPORT_DB_CONNECTION_STRING')
+    expect(out).not.toContain('RUNTIME_STORAGE_API_KEY')
+    expect(out).not.toContain('TELEPORT_PROJECT_TOKEN')
+    expect(out).toContain('PUBLIC_FEATURE_FLAG')
+  })
+
+  it('hides protected vars from spread of process.env', async () => {
+    const code = `function customHandler(){
+      const all = { ...process.env };
+      return Object.keys(all);
+    }`
+    const out = (await handler({ code, __nodeId: 'a' }, {})) as string[]
+    expect(out).not.toContain('TELEPORT_DB_CONNECTION_STRING')
+    expect(out).toContain('PUBLIC_FEATURE_FLAG')
+  })
+
+  it('hides protected vars from globalThis.process', async () => {
+    const code = `function customHandler(){
+      return globalThis.process.env.TELEPORT_DB_CONNECTION_STRING;
+    }`
+    const out = await handler({ code, __nodeId: 'a' }, {})
+    expect(out).toBeUndefined()
+  })
+
+  it('returns undefined for protected vars via "in" check', async () => {
+    const code = `function customHandler(){
+      return 'TELEPORT_DB_CONNECTION_STRING' in process.env;
+    }`
+    const out = await handler({ code, __nodeId: 'a' }, {})
+    expect(out).toBe(false)
+  })
+
+  it('does not break access to non-process bindings', async () => {
+    const code = `function customHandler(){
+      return 1 + 2;
+    }`
+    const out = await handler({ code, __nodeId: 'a' }, {})
+    expect(out).toBe(3)
+  })
+})