[SalesForce] Aura vs Apex – Deserialization and Interface discrepancy (Major rewrite with git repo)

Question rewritten and complete example code provided

I am trying to write test methods for an aura implementation but am running into a roadblock where the JSON serialization/deserialization between Aura and Apex are producing different results.

I am curious to know if my aura implementation is wrong of if there is something else I am doing wrong.

The interface

public interface theInterface {
    void anImplementedMethod();
    String getName();
}

The Class that implements said interface

public with sharing class classThatImplements implements theInterface{
    @AuraEnabled public string getName(){
        return 'classThatImplements';
    }

    @AuraEnabled public String somethingPreset {get { return 'preset'; }set;}

    public static void anImplementedMethod(){
        System.debug('I am doing something');
    }

}

The Lightning Component

<aura:component description="testComponent" implements="force:hasRecordId" controller="auraController">

    <aura:handler name="init" value="{!this}" action="{!c.init}"/>
    <aura:attribute name="returnedObject" type="theInterface" description="the returned interface implementation"/>
    <aura:attribute name="result" type="String"/>


    <lightning:button variant="brand" label="Do it" onclick="{!c.callController}"/>

    {!v.result}
</aura:component>

The Lightning Controller

({
    init: function (component, event, helper) {

        var response = component.get("c.getClassThatImplements");

        response.setCallback(this, function (returnValue) {
            if (component.isValid() && returnValue.getState() === 'SUCCESS') {
                var returnedData = returnValue.getReturnValue();

                //This will show that the name property has been set
                console.log(JSON.stringify(returnedData));

                component.set("v.returnedObject", returnedData);


            } else if (component.isValid() && returnValue.getState() === 'ERROR') {
                alert(returnValue.getError()[0].message);
            }

        });
        $A.enqueueAction(response);

    },
    callController: function(component, event, helper){
        var doIt = component.get("c.consumeClassThatImplements");

        doIt.setParams({
            "objectJSON": JSON.stringify(component.get("v.returnedObject"))
        });

        //Do the initial update to the profile to ready for Chargent Use
        doIt.setCallback(this, function (rtn) {
            if (component.isValid() && rtn.getState() === 'SUCCESS') {
                component.set("v.result",rtn.getReturnValue());
            } else if (component.isValid() && rtn.getState() === 'ERROR') {
                alert(rtn.getError()[0].message);
            }

        });
        $A.enqueueAction(doIt);

    },

})

During init of the aura component I call to the controller and get the results. The results are output to the console and assigned to the attribute..

Console Output – NOTE: name is populated

{"name":"classThatImplements","somethingPreset":"preset"}

This is what I want, seems like it is using the aura enabled property to get the name and populate it as a property.

Now comes the apex part

Apex Controller

public class auraController {

    /**
     * This will return a class that implements the interface.
     * It is meant to determine which class to instantiate as there would be several classes that implement the interface
     * Which one is determined by the record type of an object that would be passed into this method
     *
     * @return Object A generic Object that can be return to Aura.
     */
    @AuraEnabled public static Object getClassThatImplements() {
        try {
            return (theInterface)New classThatImplements();
        }catch(Exception e){
            AuraHandledException aex = New AuraHandledException(e.getMessage());
            aex.setMessage(e.getMessage());
            throw aex;
        }

    }

    /**
     * Takes the JSON representation of the implemented Interface Class
     *
     * @param objectJSON
     *
     * @return
     */
    @AuraEnabled public static String consumeClassThatImplements(String objectJSON) {
        try {
            //Since we cannot use an interface for the Apex Type need to figure out the class name and deserialze casting to interface type
            theInterface controller = (theInterface) json.deserialize(objectJSON, Type.forName(getClassName(objectJSON)));
            controller.anImplementedMethod();
            return 'Look ma no errors';
        }catch(Exception e){
//            We Don't expect any aura errors for this demo
//            AuraHandledException aex = New AuraHandledException(e.getMessage());
//            aex.setMessage(e.getMessage());
//            throw aex;
            throw new auraController_Exception(e.getMessage()); //So we actually get a message in the apex demo
        }
    }

    /**
     * Gets the Name property from a class
     *
     * @param objectJSON
     *
     * @return
     */
    @TestVisible private static String getClassName(String objectJSON){
        Map<String,Object> tmp = (Map<String, Object>) JSON.deserializeUntyped(objectJSON);
        //Just for debugging purposes
        for(String key : tmp.keySet()){
            System.debug('Key: ' + key + ' - Value: ' + tmp.get(key));
        }

        String typeName = (String) ( (Map<String, Object>) JSON.deserializeUntyped(objectJSON) ).get('name');

        System.debug('Type Name:' + typeName);

        if(String.isBlank(typeName)){
            throw new auraController_Exception('Well, this did not work as the name property was blank');
        }

        return typeName;


    }

    public class auraController_Exception extends Exception{}

}

From the Aura component I pass the JSON of the attribute to the method consumeClassThatImplements which then deserializes it. In order to do so we need to know the concrete class name, not the interface so the helper method getClassName is called to get the name (remember in aura is was set and output so we know we have it in the JSON)

Doing this during the Aura lifecycle works just fine

Apex Failure

Running the same code path in Apex during tests always returns NULL for the name when I try to get it. Here is the code to use to show that doing the same thing (minus the Apex <=> Aura communication)

String tmp = json.serialize(auraController.getClassThatImplements());
System.debug(auraController.consumeClassThatImplements(tmp));

The above results in:

Error on line 41, column 1: auraController.auraController_Exception: Well, this did not work as the name property was blank

So my question is:

Why does the Name property get populated in Aura during deserialization from Apex and assignment to the attribute – I am glad it does
Why during apex outside of Aura does the Name property always return null?

Is one a bug, are they both working as expected?

I took inspiration from here: Cannot deserialize JSON as abstract type?

But the fact that during Apex tests it does not behave as it does in aura concerns me.

I have shared the project on GitHub so all you need to do to test is:

Create a scratch org
Clone the repo and push to scratch org
Open scratch org
hit /apex/vfTestPage
look at the console and verify that name is present
Click "Do It" to call the Apex Controller method
Observe that "Look ma no errors" is presented (successfully ran)

Then

In dev console execute

String tmp = json.serialize(auraController.getClassThatImplements());
System.debug(auraController.consumeClassThatImplements(tmp));

An you will get an error thrown which will show that in apex only JSON serialization.deserialization the name property is not available

Best Answer

There are four different things that work different and should not be mixed up:

Attributes visible to Apex (System.debug(object))
Attributes visible to JSON.serialize
Attributes visible to Aura
Attributes visible to VisualForce

At the end of this post, you will find the class with different types of attributes (public; getter; getMethod; auraEnabled; transient). But first I want to point out the differences between these four possible outputs.

1) Apex Debug: Only declared attributes are printed. getAttribute methods aren't visible if we debug the object itself, not even {get{return x;}} is executed (null). They only get executed, when we access them directly.

Thing:[auraEnable=x, getter=null, publc=x, transi=x]

2) JSON: JSON.serialize uses the same information, so it only sees declared attributes, but also knows how to call their getters get{return x;}, so we are one step further. (You can use transient to hide it from JSON).

{"publc":"x","getter":"x","auraEnable":"x"}

3) Aura: Aura sees everything, that is @auraEnabled and knows how to call the getters to get its information. It is not using JSON.serialize()!

Object { method: "x", auraEnable: "x", getter: "x" }

4) Visualforce: sees all attributes including transient and (oddly) also auraEnabled (but doesn't know how to execute getters without direct calls.) In fact VF sees everything that is also outputted in debug(thing);

Thing:[auraEnable=x, getter=null, publc=x, transi=x]

The Answer:

Aura seems to be the smartest of all these possibilities to output an object. It is the only one that executed both getter methods. JSON.serialize only executed the public get{}.

So in your case, I would suggest replacing your interface with an abstract class using the template method pattern:

public abstract class theInterface{
    public String className { public get{ return getClassName(); } set; }

    public abstract String getClassName();
}

public class ImplementingThing extends theInterface{
    @auraEnabled
    public override String getClassName() {
        return ImplementingThing.class.getName();
    }
}

This would work in Aura and in your Test. Be aware that there are some issues about abstract classes and their properties in Lightning. Here are some more ways to get the classes name.

This is the code to verify all this:

public class ObjectCtrl {

    @auraEnabled
    public static Thing getThing() {
        Thing result = new Thing();

        System.debug(result);
        System.debug(JSON.serialize(result));

        return result;
    }

    public class Thing {
        public String publc = 'x';

        @auraEnabled
        public String getter { public get{ return 'x'; } set; }

        @auraEnabled
        public String getMethod() {
            return 'x';
        }

        @auraEnabled
        public String auraEnable = 'x';

        transient
        public String transi = 'x';
    }
}

Visual Force:

<apex:page controller="ObjectCtrl">
    {!thing}
</apex:page>

Lightning App (Aura):

<aura:application controller="ObjectCtrl">
    <aura:handler name="init" value="{!this}" action="{!c.onInit}"/>
</aura:application>

({
    onInit: function(cmp, evt, helper) {
        var action = cmp.get("c.getThing");

        action.setCallback(this, function(response) {
            console.log(response.getReturnValue());
        });

        $A.enqueueAction(action);
    },
})

Related Solutions

[SalesForce] Returning a string as part of an Apex class in an AuraEnabled Method

You can try doing what Peter Knolle mentioned in the post you referenced, to just return a JSON string that contains the data in your class, instead of returning 'Classic'. Basically you would just have to serialize your class instance

@AuraEnabled
public static String returnClassic(){
    return JSON.serialize(new Classic('one',2));
}

And then in the controller just parse the string into a Javascript object.

({
    handlePress : function(component, event, helper) {
        var action = component.get("c.returnClassic");
        action.setCallback(this,function(response){
                if (response.getState() === "SUCCESS"){
                    console.log(JSON.parse(response.getReturnValue()));
                }
            });
        $A.enqueueAction(action);
    }
})

[SalesForce] How to deserialize into interface type when concrete type is unknown

I think you should revisit the idea of using an abstract class rather than an interface. You can use the former to enforce a contract.

public class Demo
{
    final String typeName;
    public String getSomeProperty() { return typeName; }
    public abstract List<User> doStuff();
}

Granted, this definition cannot be constructed either, but deserialization into this type is allowed.

Demo instance = (Demo)JSON.deserialize('{}', Demo.class);
system.debug(instance.getSomeProperty());

And the contract gets enforced, for if you try to save a class which doesn't implement the method:

class Foo extends Demo { }

You get a compile-time error:

Class Foo must implement the abstract method: List<User> Demo.doStuff()

As a benefit, properties like typeName can be preserved throughout the serialization round-trip.

Here's a simple demonstration of that process. First define this extension:

public class Foo extends Demo
{
    final String profileName;
    public override List<User> doStuff()
    {
        return [
            SELECT Username FROM User
            WHERE Profile.Name = :profileName
        ];
    }
}

Now run this script:

String payload = '{"typeName": "Foo", "profileName": "System Administrator"}';
Map<String, Object> controllerData = (Map<String, Object>)JSON.deserializeUntyped(payload);
String controllerType = (String)controllerData.get('typeName');

Demo controller;
if (controllerType != null)
{
    controller = (Demo)JSON.deserialize(payload, Type.forName(controllerType));
    system.debug(controller.doStuff());
}

As far as why your repo works in aura but not in a pure Apex context, it looks like the system acts similarly to Visualforce, treating methods prefixed with get as properties and adding them to the serialization (since the end result is indecipherable from { get; set; } notation). If you had named your method retrieveName instead of getName, I suspect it would not have worked in aura either. You can hack around it with mimicry along the lines of:

public class MyClass
{
    final String name = getName();
    public String getName() { return 'MyClass'; }
}

But I suspect that's not a tenable long-term solution.

Best Answer

The Answer:

Related Solutions

[SalesForce] Returning a string as part of an Apex class in an AuraEnabled Method

[SalesForce] How to deserialize into interface type when concrete type is unknown

Related Topic