feat: add call javascript action MDL pipeline and association retrieve fix

Full pipeline for `call javascript action` syntax:
- Grammar rule, AST node, visitor, builder, validator, BSON serializer
- JavaScript actions allowed in nanoflows (client-side), disallowed check
  skips them correctly
- Separate JS action reference validation from Java action validation

Association retrieve roundtrip fix:
- Preserve AssociationRetrieveSource on roundtrip instead of converting
  to DatabaseRetrieveSource with XPath for reverse traversals

Author: retran

mdl/ast/ast_microflow.go

@@ -367,6 +367,17 @@ type CallJavaActionStmt struct {
 
 func (s *CallJavaActionStmt) isMicroflowStatement() {}
 
+// CallJavaScriptActionStmt represents: CALL JAVASCRIPT ACTION Name (args) [ON ERROR ...]
+type CallJavaScriptActionStmt struct {
+	OutputVariable string               // Optional output variable
+	ActionName     QualifiedName        // JavaScript action name
+	Arguments      []CallArgument       // Arguments
+	ErrorHandling  *ErrorHandlingClause // Optional ON ERROR clause
+	Annotations    *ActivityAnnotations // Optional @position, @caption, @color, @annotation
+}
+
+func (s *CallJavaScriptActionStmt) isMicroflowStatement() {}
+
 // ExecuteDatabaseQueryStmt represents: EXECUTE DATABASE QUERY Module.Connection.QueryName ...
 type ExecuteDatabaseQueryStmt struct {
 	OutputVariable      string               // Optional output variable

mdl/executor/cmd_microflows_builder_actions.go

@@ -286,51 +286,29 @@ func (fb *flowBuilder) addRetrieveAction(s *ast.RetrieveStmt) model.ID {
 
 	if s.StartVariable != "" {
 		// Association retrieve: RETRIEVE $List FROM $Parent/Module.AssocName
+		// Always use AssociationRetrieveSource to preserve the original syntax.
+		// The runtime resolves traversal direction from association metadata.
 		assocQN := s.Source.Module + "." + s.Source.Name
 
-		// Look up association to determine type and direction.
-		// For Reference associations, AssociationRetrieveSource always returns a single
-		// object (the entity on the other end). When the user navigates from the child
-		// (non-owner) side, the intent is to get a list of parent entities — we must use
-		// a DatabaseRetrieveSource with XPath constraint instead.
-		assocInfo := fb.lookupAssociation(s.Source.Module, s.Source.Name)
-		startVarType := ""
-		if fb.varTypes != nil {
-			startVarType = fb.varTypes[s.StartVariable]
+		source = &microflows.AssociationRetrieveSource{
+			BaseElement:              model.BaseElement{ID: model.ID(types.GenerateID())},
+			StartVariable:            s.StartVariable,
+			AssociationQualifiedName: assocQN,
 		}
 
-		if assocInfo != nil && assocInfo.Type == domainmodel.AssociationTypeReference &&
-			assocInfo.childEntityQN != "" && startVarType == assocInfo.childEntityQN {
-			// Reverse traversal on Reference: child → parent (one-to-many)
-			// Use DatabaseRetrieveSource with XPath to get a list of parent entities
-			dbSource := &microflows.DatabaseRetrieveSource{
-				BaseElement:         model.BaseElement{ID: model.ID(types.GenerateID())},
-				EntityQualifiedName: assocInfo.parentEntityQN,
-				XPathConstraint:     "[" + assocQN + " = $" + s.StartVariable + "]",
-			}
-			source = dbSource
-			if fb.varTypes != nil {
-				fb.varTypes[s.Variable] = "List of " + assocInfo.parentEntityQN
-			}
-		} else {
-			// Forward traversal or ReferenceSet: use AssociationRetrieveSource
-			source = &microflows.AssociationRetrieveSource{
-				BaseElement:              model.BaseElement{ID: model.ID(types.GenerateID())},
-				StartVariable:            s.StartVariable,
-				AssociationQualifiedName: assocQN,
-			}
-			if fb.varTypes != nil {
-				if assocInfo != nil && assocInfo.Type == domainmodel.AssociationTypeReference {
-					// Reference forward traversal: returns single object
-					otherEntity := assocInfo.childEntityQN
-					if startVarType == assocInfo.childEntityQN {
-						otherEntity = assocInfo.parentEntityQN
-					}
-					fb.varTypes[s.Variable] = otherEntity
-				} else {
-					// ReferenceSet or unknown: returns a list
-					fb.varTypes[s.Variable] = "List of " + assocQN
+		// Infer variable type for downstream validation
+		if fb.varTypes != nil {
+			assocInfo := fb.lookupAssociation(s.Source.Module, s.Source.Name)
+			startVarType := fb.varTypes[s.StartVariable]
+			if assocInfo != nil && assocInfo.Type == domainmodel.AssociationTypeReference {
+				otherEntity := assocInfo.childEntityQN
+				if startVarType == assocInfo.childEntityQN {
+					otherEntity = assocInfo.parentEntityQN
 				}
+				fb.varTypes[s.Variable] = otherEntity
+			} else {
+				// ReferenceSet or unknown: returns a list
+				fb.varTypes[s.Variable] = "List of " + assocQN
 			}
 		}
 	} else {

mdl/executor/cmd_microflows_builder_annotations.go

@@ -47,6 +47,8 @@ func getStatementAnnotations(stmt ast.MicroflowStatement) *ast.ActivityAnnotatio
 		return s.Annotations
 	case *ast.CallJavaActionStmt:
 		return s.Annotations
+	case *ast.CallJavaScriptActionStmt:
+		return s.Annotations
 	case *ast.ExecuteDatabaseQueryStmt:
 		return s.Annotations
 	case *ast.CallExternalActionStmt:

mdl/executor/cmd_microflows_builder_calls.go

@@ -328,6 +328,66 @@ func (fb *flowBuilder) addCallJavaActionAction(s *ast.CallJavaActionStmt) model.
 	return activity.ID
 }
 
+// addCallJavaScriptActionAction creates a CALL JAVASCRIPT ACTION statement.
+func (fb *flowBuilder) addCallJavaScriptActionAction(s *ast.CallJavaScriptActionStmt) model.ID {
+	actionQN := s.ActionName.Module + "." + s.ActionName.Name
+
+	// Build parameter mappings with Value structure
+	var mappings []*microflows.JavaScriptActionParameterMapping
+	for _, arg := range s.Arguments {
+		// Parameter qualified name format: Module.JavaScriptAction.ParameterName
+		paramQN := actionQN + "." + arg.Name
+
+		// JavaScript actions use BasicCodeActionParameterValue for all parameters
+		valueExpr := fb.exprToString(arg.Value)
+		value := &microflows.BasicCodeActionParameterValue{
+			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+			Argument:    valueExpr,
+		}
+
+		mapping := &microflows.JavaScriptActionParameterMapping{
+			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+			Parameter:   paramQN,
+			Value:       value,
+		}
+		mappings = append(mappings, mapping)
+	}
+
+	action := &microflows.JavaScriptActionCallAction{
+		BaseElement:        model.BaseElement{ID: model.ID(types.GenerateID())},
+		ErrorHandlingType:  convertErrorHandlingType(s.ErrorHandling),
+		JavaScriptAction:   actionQN,
+		ParameterMappings:  mappings,
+		OutputVariableName: s.OutputVariable,
+		UseReturnVariable:  s.OutputVariable != "",
+	}
+
+	activityX := fb.posX
+	activity := &microflows.ActionActivity{
+		BaseActivity: microflows.BaseActivity{
+			BaseMicroflowObject: microflows.BaseMicroflowObject{
+				BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+				Position:    model.Point{X: fb.posX, Y: fb.posY},
+				Size:        model.Size{Width: ActivityWidth, Height: ActivityHeight},
+			},
+			AutoGenerateCaption: true,
+		},
+		Action: action,
+	}
+
+	fb.objects = append(fb.objects, activity)
+	fb.posX += fb.spacing
+
+	// Build custom error handler flow if present
+	if s.ErrorHandling != nil && len(s.ErrorHandling.Body) > 0 {
+		errorY := fb.posY + VerticalSpacing
+		mergeID := fb.addErrorHandlerFlow(activity.ID, activityX, s.ErrorHandling.Body)
+		fb.handleErrorHandlerMerge(mergeID, activity.ID, errorY)
+	}
+
+	return activity.ID
+}
+
 // addCallExternalActionAction creates a CALL EXTERNAL ACTION statement.
 func (fb *flowBuilder) addCallExternalActionAction(s *ast.CallExternalActionStmt) model.ID {
 	serviceQN := s.ServiceName.Module + "." + s.ServiceName.Name

mdl/executor/cmd_microflows_builder_graph.go

@@ -224,6 +224,8 @@ func (fb *flowBuilder) addStatement(stmt ast.MicroflowStatement) model.ID {
 		return fb.addCallNanoflowAction(s)
 	case *ast.CallJavaActionStmt:
 		return fb.addCallJavaActionAction(s)
+	case *ast.CallJavaScriptActionStmt:
+		return fb.addCallJavaScriptActionAction(s)
 	case *ast.ExecuteDatabaseQueryStmt:
 		return fb.addExecuteDatabaseQueryAction(s)
 	case *ast.CallExternalActionStmt:

mdl/executor/cmd_microflows_builder_validate.go

@@ -163,6 +163,16 @@ func (fb *flowBuilder) validateStatement(stmt ast.MicroflowStatement) {
 			fb.validateStatements(s.ErrorHandling.Body)
 		}
 
+	case *ast.CallJavaScriptActionStmt:
+		// Register result variable if assigned
+		if s.OutputVariable != "" {
+			fb.declaredVars[s.OutputVariable] = "Unknown"
+		}
+		// Validate error handler body if present
+		if s.ErrorHandling != nil && len(s.ErrorHandling.Body) > 0 {
+			fb.validateStatements(s.ErrorHandling.Body)
+		}
+
 	case *ast.ExecuteDatabaseQueryStmt:
 		if s.OutputVariable != "" {
 			fb.declaredVars[s.OutputVariable] = "Unknown"

mdl/executor/nanoflow_validation.go

@@ -113,6 +113,8 @@ func getErrorHandling(stmt ast.MicroflowStatement) *ast.ErrorHandlingClause {
 		return s.ErrorHandling
 	case *ast.CallJavaActionStmt:
 		return s.ErrorHandling
+	case *ast.CallJavaScriptActionStmt:
+		return s.ErrorHandling
 	case *ast.CallExternalActionStmt:
 		return s.ErrorHandling
 	case *ast.RestCallStmt:

mdl/executor/validate.go

@@ -519,6 +519,10 @@ func (c *flowRefCollector) collectFromStatements(stmts []ast.MicroflowStatement)
 			if s.ActionName.Module != "" {
 				c.javaActions = append(c.javaActions, s.ActionName.String())
 			}
+		case *ast.CallJavaScriptActionStmt:
+			if s.ActionName.Module != "" {
+				c.javaActions = append(c.javaActions, s.ActionName.String())
+			}
 		case *ast.CreateObjectStmt:
 			if s.EntityType.Module != "" {
 				c.entities = append(c.entities, entityRef{name: s.EntityType.String(), source: "create"})
@@ -569,6 +573,10 @@ func getErrorHandlerBody(stmt ast.MicroflowStatement) []ast.MicroflowStatement {
 		if s.ErrorHandling != nil && s.ErrorHandling.Body != nil {
 			return s.ErrorHandling.Body
 		}
+	case *ast.CallJavaScriptActionStmt:
+		if s.ErrorHandling != nil && s.ErrorHandling.Body != nil {
+			return s.ErrorHandling.Body
+		}
 	case *ast.ExecuteDatabaseQueryStmt:
 		if s.ErrorHandling != nil && s.ErrorHandling.Body != nil {
 			return s.ErrorHandling.Body

mdl/executor/validate_microflow.go

@@ -165,6 +165,8 @@ func stmtActivityName(stmt ast.MicroflowStatement) string {
 		return "call nanoflow"
 	case *ast.CallJavaActionStmt:
 		return "call java action"
+	case *ast.CallJavaScriptActionStmt:
+		return "call javascript action"
 	case *ast.ExecuteDatabaseQueryStmt:
 		return "execute database query"
 	default:
@@ -362,6 +364,10 @@ func collectDeclaredVars(body []ast.MicroflowStatement) map[string]bool {
 			if stmt.OutputVariable != "" {
 				vars[stmt.OutputVariable] = true
 			}
+		case *ast.CallJavaScriptActionStmt:
+			if stmt.OutputVariable != "" {
+				vars[stmt.OutputVariable] = true
+			}
 		case *ast.ExecuteDatabaseQueryStmt:
 			if stmt.OutputVariable != "" {
 				vars[stmt.OutputVariable] = true
@@ -464,6 +470,8 @@ func stmtErrorHandling(stmt ast.MicroflowStatement) *ast.ErrorHandlingClause {
 		return s.ErrorHandling
 	case *ast.CallJavaActionStmt:
 		return s.ErrorHandling
+	case *ast.CallJavaScriptActionStmt:
+		return s.ErrorHandling
 	case *ast.ExecuteDatabaseQueryStmt:
 		return s.ErrorHandling
 	}

mdl/grammar/MDLParser.g4

@@ -1310,6 +1310,7 @@ microflowStatement
     | annotation* callMicroflowStatement SEMICOLON?
     | annotation* callNanoflowStatement SEMICOLON?
     | annotation* callJavaActionStatement SEMICOLON?
+    | annotation* callJavaScriptActionStatement SEMICOLON?
     | annotation* executeDatabaseQueryStatement SEMICOLON?
     | annotation* callExternalActionStatement SEMICOLON?
     | annotation* showPageStatement SEMICOLON?
@@ -1482,6 +1483,11 @@ callJavaActionStatement
     : (VARIABLE EQUALS)? CALL JAVA ACTION qualifiedName LPAREN callArgumentList? RPAREN onErrorClause?
     ;
 
+// $Result = CALL JAVASCRIPT ACTION Module.JSAction(Param = 'value');
+callJavaScriptActionStatement
+    : (VARIABLE EQUALS)? CALL JAVASCRIPT ACTION qualifiedName LPAREN callArgumentList? RPAREN onErrorClause?
+    ;
+
 // $Result = EXECUTE DATABASE QUERY Module.Connection.QueryName (param = 'value');
 // $Result = EXECUTE DATABASE QUERY Module.Connection.QueryName DYNAMIC 'SELECT ...';
 // $Result = EXECUTE DATABASE QUERY Module.Connection.QueryName CONNECTION (DBSource = $Url, DBUsername = $User, DBPassword = $Pass);