Apply SWC transformation on step functions returned from factory function (#360)

Added support for transforming step functions that are returned from factory functions.

### What changed?

Enhanced the SWC plugin to detect and transform step functions that are defined within object literals returned by factory functions. The transformation now properly identifies arrow functions with object literal bodies and processes their step functions accordingly.

Added test fixtures to verify the functionality:
- Created test cases for a factory function that returns an object with a step method
- Added corresponding output files for client, step, and workflow modes

### How to test?

1. Create a factory function that returns an object with methods marked as steps:
```javascript
const myFactory = () => ({
  myStep: async () => {
    'use step';
    await fs.mkdir('test');
  },
});
```

2. Verify that the step function is properly transformed and registered when used in a workflow.

### Why make this change?

This enhancement supports a common pattern where developers create factory functions that return objects containing step methods. Without this change, step functions defined in this pattern weren't being properly transformed, which limited the flexibility of the workflow system.

Author: TooTallNate

.changeset/metal-cycles-slide.md

@@ -0,0 +1,5 @@
+---
+"@workflow/swc-plugin": patch
+---
+
+Apply SWC transformation on step functions returned from factory function

packages/swc-plugin-workflow/transform/src/lib.rs

@@ -864,7 +864,40 @@ impl StepTransform {
                     stmt.visit_mut_children_with(self);
                 }
             }
-            Stmt::Decl(Decl::Var(_)) => {
+            Stmt::Decl(Decl::Var(var_decl)) => {
+                // Check if any declarators contain arrow functions with object literal bodies
+                for declarator in &mut var_decl.decls {
+                    if let Some(init) = &mut declarator.init {
+                        if let Pat::Ident(binding) = &declarator.name {
+                            let name = binding.id.sym.to_string();
+                            
+                            // Check if the initializer is an arrow function with object literal body
+                            if let Expr::Arrow(arrow_expr) = &mut **init {
+                                match &mut *arrow_expr.body {
+                                    BlockStmtOrExpr::Expr(expr) => {
+                                        // Handle both direct object literals and parenthesized ones
+                                        let obj_lit_mut = match &mut **expr {
+                                            Expr::Object(obj) => Some(obj),
+                                            Expr::Paren(paren) => {
+                                                if let Expr::Object(obj) = &mut *paren.expr {
+                                                    Some(obj)
+                                                } else {
+                                                    None
+                                                }
+                                            }
+                                            _ => None,
+                                        };
+                                        
+                                        if let Some(obj_lit) = obj_lit_mut {
+                                            self.process_object_properties_for_step_functions(obj_lit, &name);
+                                        }
+                                    }
+                                    _ => {}
+                                }
+                            }
+                        }
+                    }
+                }
                 stmt.visit_mut_children_with(self);
             }
             _ => {

packages/swc-plugin-workflow/transform/tests/fixture/factory-with-step-method/input.js

@@ -0,0 +1,11 @@
+import fs from 'fs/promises';
+
+const myFactory = () => ({
+  myStep: async () => {
+    'use step';
+    await fs.mkdir('test');
+  },
+});
+
+export default myFactory;
+

packages/swc-plugin-workflow/transform/tests/fixture/factory-with-step-method/output-client.js

@@ -0,0 +1,7 @@
+import fs from 'fs/promises';
+const myFactory = ()=>({
+        myStep: async ()=>{
+            await fs.mkdir('test');
+        }
+    });
+export default myFactory;

packages/swc-plugin-workflow/transform/tests/fixture/factory-with-step-method/output-step.js

@@ -0,0 +1,11 @@
+import { registerStepFunction } from "workflow/internal/private";
+import fs from 'fs/promises';
+/**__internal_workflows{"steps":{"input.js":{"myFactory/myStep":{"stepId":"step//input.js//myFactory/myStep"}}}}*/;
+var myFactory$myStep = async ()=>{
+    await fs.mkdir('test');
+};
+const myFactory = ()=>({
+        myStep: myFactory$myStep
+    });
+export default myFactory;
+registerStepFunction("step//input.js//myFactory/myStep", myFactory$myStep);

packages/swc-plugin-workflow/transform/tests/fixture/factory-with-step-method/output-workflow.js

@@ -0,0 +1,5 @@
+/**__internal_workflows{"steps":{"input.js":{"myFactory/myStep":{"stepId":"step//input.js//myFactory/myStep"}}}}*/;
+const myFactory = ()=>({
+        myStep: globalThis[Symbol.for("WORKFLOW_USE_STEP")]("step//input.js//myFactory/myStep")
+    });
+export default myFactory;