@teleporthq/teleport-plugin-next-workflows 0.43.36 → 0.43.38

package/src/workflow-project-plugin.ts

@@ -29,6 +29,7 @@ import {
   collectUsedRealtimeActionTypes,
 } from './graph-utils'
 import { nodeRegistry } from './nodes'
+import { resolveHandlerEntryName } from './nodes/types'
 import {
   generateClientRuntimeCode,
   generateServerRuntimeCode,
@@ -915,10 +916,26 @@ export class NextWorkflowProjectPlugin implements ProjectPlugin {
     // contract (`handlerToString(fn)` preserves `fn.name`, and every handler
     // names its entry `nodeType.replace(/-/g, '_')`) is enforced by
     // node-handler-file-inline-map.test.ts across the whole node registry.
+    //
+    // That contract holds for the handler's OWN source (checked below via
+    // resolveHandlerEntryName), but not necessarily for the RUNTIME name a
+    // caller's bundler assigns it. Handlers built from `handlerToString(fn)`
+    // embed `fn.toString()` — a snapshot of whatever `fn` was actually named
+    // at the moment it's read. When this package is bundled and minified by a
+    // consumer (e.g. teleport-gui's browser packer worker, built with
+    // Next.js/Terser), the minifier freely renames `fn`'s declaration: nothing
+    // in the bundle calls it by name, only `.toString()` reads it at runtime,
+    // which is invisible to the minifier. The naive
+    // `nodeType.replace(/-/g, '_')` name would then reference an identifier
+    // that no longer exists in the embedded source — a Vercel-only
+    // "Collecting page data" ReferenceError, since local dev never runs a
+    // minifier. resolveHandlerEntryName reads the name the source text
+    // ACTUALLY declares instead of assuming it matches the convention.
     const entries = exportNames
       .map((t, index) => {
-        const entryFn = t.replace(/-/g, '_')
-        return `  '${t}': (function () {\n${handlers[index].trim()}\nreturn ${entryFn};\n})()`
+        const source = handlers[index].trim()
+        const entryFn = resolveHandlerEntryName(source, t)
+        return `  '${t}': (function () {\n${source}\nreturn ${entryFn};\n})()`
       })
       .join(',\n')
 
@@ -1530,8 +1547,31 @@ module.exports = __customNodeRegistry;
       }
     })
 
+    // See resolveHandlerEntryName: handlers built from `handlerToString(fn)`
+    // on a real function (e.g. general-if-statement) can have `fn` renamed by
+    // a consumer's own minifier (nothing in the bundle calls it by name, only
+    // this runtime `.toString()` read does) — so the reference below must
+    // match whatever `handlers[index]` actually declares, not the
+    // `t.replace(/-/g, '_')` convention name.
+    //
+    // Each entry is ALSO isolated in its own IIFE, rather than declaring every
+    // handler as a bare sibling statement inside `useGlobalWorkflows()`. Two
+    // DIFFERENT node types are minified independently (each in its own
+    // source file), so their real declared names can coincidentally collide —
+    // e.g. state-update-local-state and payment-cancel-plan can both
+    // legitimately mangle down to the same short name. Declared as siblings
+    // in one shared function body, the second declaration would silently
+    // shadow the first, so BOTH map entries end up pointing at the SAME
+    // (wrong-for-one-of-them) function — a silent wrong-handler-executes bug,
+    // not even a crash. An IIFE per entry gives every handler its own scope,
+    // exactly like generateNodeHandlerFile already does, so a same-named
+    // collision between two unrelated handlers can never shadow each other.
     const handlerEntries = emittedHandlerTypes
-      .map((t) => `    '${t}': ${t.replace(/-/g, '_')}`)
+      .map((t, index) => {
+        const source = handlers[index].trim()
+        const entryFn = resolveHandlerEntryName(source, t)
+        return `    '${t}': (function () {\n${source}\nreturn ${entryFn};\n})()`
+      })
       .join(',\n')
 
     // NOTE: this module is pulled into the GLOBAL client bundle (every page,
@@ -1549,8 +1589,6 @@ import workflowRuntime from './runtime';
 const executeWorkflowWithSegments = workflowRuntime.executeWorkflowWithSegments;
 
 export function useGlobalWorkflows() {
-${handlers.join('\n')}
-
   const clientNodeHandlers = {
 ${handlerEntries}
   };