Fix return formatter option binding

Author: elpete

models/Query/Formatters/StructFormatter.cfc

@@ -8,21 +8,7 @@ component accessors="true" {
     }
 
     public function toFormatter( struct options = {} ) {
-        var formatterOptions = arguments.options;
-        return function( q ) {
-            if (
-                !formatterOptions.keyExists( "columnKey" ) || isNull( formatterOptions.columnKey ) || !len(
-                    formatterOptions.columnKey
-                )
-            ) {
-                throw(
-                    type = "MissingColumnKey",
-                    message = "A columnKey option is required for the [struct] return formatter."
-                );
-            }
-
-            return variables.utils.queryToStructOfStructs( q, formatterOptions.columnKey );
-        };
+        return new qb.models.Query.Formatters.StructReturnFormatter( variables.utils, arguments.options );
     }
 
 }

models/Query/Formatters/StructReturnFormatter.cfc

@@ -0,0 +1,27 @@
+component accessors="true" {
+
+    property name="utils";
+    property name="options";
+
+    public StructReturnFormatter function init( any utils = new qb.models.Query.QueryUtils(), struct options = {} ) {
+        variables.utils = arguments.utils;
+        variables.options = arguments.options;
+        return this;
+    }
+
+    public struct function format( required any q ) {
+        if (
+            !variables.options.keyExists( "columnKey" ) || isNull( variables.options.columnKey ) || !len(
+                variables.options.columnKey
+            )
+        ) {
+            throw(
+                type = "MissingColumnKey",
+                message = "A columnKey option is required for the [struct] return formatter."
+            );
+        }
+
+        return variables.utils.queryToStructOfStructs( arguments.q, variables.options.columnKey );
+    }
+
+}

models/Query/QueryBuilder.cfc

@@ -4337,18 +4337,35 @@ component displayname="QueryBuilder" accessors="true" {
         }
 
         if ( isQuery( q ) ) {
-            return returnFormat( q );
+            return applyReturnFormat( q );
         }
 
         if ( isArray( q ) ) {
-            return returnFormat( q );
+            return applyReturnFormat( q );
         }
 
         if ( !q.keyExists( "result" ) || !q.keyExists( "query" ) ) {
-            return returnFormat( q );
+            return applyReturnFormat( q );
         }
 
-        return { result: q.result, query: returnFormat( q.query ) };
+        return { result: q.result, query: applyReturnFormat( q.query ) };
+    }
+
+    private any function applyReturnFormat( required any q ) {
+        var formatter = getReturnFormat();
+
+        if ( isClosure( formatter ) || isCustomFunction( formatter ) ) {
+            return formatter( arguments.q );
+        }
+
+        if ( structKeyExists( formatter, "format" ) ) {
+            return formatter.format( arguments.q );
+        }
+
+        throw(
+            type = "InvalidFormat",
+            message = "The configured return formatter must be a closure or a component with a format method."
+        );
     }
 
     /**

models/Query/ReturnFormatterRegistry.cfc

@@ -67,7 +67,13 @@ component accessors="true" singleton {
         var formatterOptions = duplicate( definition.options );
         structAppend( formatterOptions, arguments.options, true );
 
-        return resolveFactory( definition.factory, definition.properties )( formatterOptions );
+        var factory = resolveFactory( definition.factory, definition.properties );
+
+        if ( isClosure( factory ) || isCustomFunction( factory ) ) {
+            return factory( formatterOptions );
+        }
+
+        return factory.toFormatter( formatterOptions );
     }
 
     public boolean function hasReturnFormatter( required string name ) {
@@ -140,13 +146,10 @@ component accessors="true" singleton {
                 );
             }
 
-            var wireboxFactory = variables.wirebox.getInstance(
+            return variables.wirebox.getInstance(
                 name = arguments.factory,
                 initArguments = { "properties": arguments.properties }
             );
-            return function( options ) {
-                return wireboxFactory.toFormatter( arguments.options );
-            };
         }
 
         if ( !structKeyExists( arguments.factory, "toFormatter" ) ) {
@@ -156,10 +159,7 @@ component accessors="true" singleton {
             );
         }
 
-        var componentFactory = arguments.factory;
-        return function( options ) {
-            return componentFactory.toFormatter( arguments.options );
-        };
+        return arguments.factory;
     }
 
 }