coding-with-the-force / salesforce-separation-of-concerns-and-the-apex-common-library Goto Github PK

If we need our query to include related record data we create an instance of our parent selector. In this case, Accounts and provide the query factory with the relationship.

 public List<Contact> selectWithAccountData(){
        fflib_QueryFactory contactQueryFactory = newQueryFactory();
        new AccountSelector().configureQueryFactoryFields(contactQueryFactory,
                Contact.AccountId.getDescribe().getRelationshipName());

        return Database.query(contactQueryFactory.toSOQL());
    }

Running this query will generate the following query string:
SELECT Account.AccountNumber, Account.Id,
Account.Industry, Account.Name, Account.NumberOfEmployees,
Account.Rating, AccountId,
Email, Id, Name, Phone, Title
FROM Contact
ORDER BY
Name ASC
NULLS FIRST

As of Dec 22nd the fflib_Selector was updated to use the Apex Data Access modes in its constructor.

Below is an example of a selector class that is set to run in usermode by default via the constructor. We must also provide a value for the use of field sets.

public inherited sharing class AccountSelector extends fflib_SObjectSelector {
 
    public AccountSelector(){
        super(false, DataAccess.USER_MODE);
    }
 
 
    public SObjectType getSObjectType() {
        //All selectors must implement
        return Account.SObjectType;
    }
 
    public List<SObjectField> getSObjectFieldList() {
        //All selectors must implement
        return new List<SObjectField>{
                Account.Id,
                Account.Name,
                Account.AccountNumber,
                Account.Industry,
                Account.Rating,
                Account.NumberOfEmployees
        };
 
    }   
}

If we want the selector to run in System mode, we configure that at the instance level.

AccountSelector accountSelector = new AccountSelector();
accountSelector.setDataAccess(fflib_SObjectSelector.DataAccess.SYSTEM_MODE);

An example query string would look like the following.
SELECT id, name, accountnumber,
industry, rating, numberofemployees, type, description
FROM Account
WITH SYSTEM_MODE
ORDER BY Name
ASC
NULLS FIRST
LIMIT 10

You said in one video that we should put dmls in the service layer.
Does this mean, that if we have a trigger that executes on afterInsert and creates a new record (different object), this logic should go into a service layer?

Hi ,
The code for the 1st video SOC introduction is missing i guess, I could not find it can u please help me the code

How do we handle for example record-type specific logic in the domain layer?
Imagine I have an object that calculates a currency field oninsert, but this logic differs for the record-type.

Would I make the domain class virtual? Or would I put the record-type specific logic into the service class for that object?

Was trying how to access Trigger.new, Trigger.old, etc... and was looking in section 11. Are they somewhere else? Or maybe info regarding this could be added somewhere?

It would be really helpful to also see sample test classes!

Most of the examples i've seen of the Service layer using enterprise design patterns are where the service layer is orchestrating one or more domain or selector objects. I haven't seen any examples of an enterprise layer orchestrating services.
I know an instance of a Service could easily be constructed which self populates its dependencies...but that violates IOC (inversion of control) principles. Seems like you would need some entity responsible for providing DI (dependency injection) which manages the dependency mappings. Because as it stands, the Application class doesn't appear to support this concept.

For example, suppose the Task_ServiceImpl.class depended on one or more other services...then the approach below would not support proper IOC.

public static final fflib_Application.ServiceFactory service = new fflib_Application.ServiceFactory(new Map<Type, Type>{
Task_Service_Interface.class => Task_Service_Impl.class
})

Are there plans for supporting this concept?