DB Classes

Rather than scattering inline SOQL through the codebase, each package wraps its queries in per-object DB classes, kept in a db/ folder (for example UserDB, AccountDB). A DB class declares the fields it loads in one place and delegates to FCORE_BASE.CacheService, so every consumer in a transaction shares one cached query. Query through the DB class for an object whenever one exists. The conventional method shapes are getById, getByIds, and getBy[Field].

A Full DB Class (`UserDB`)

This is the actual UserDB class from the Platform package (fusioncore-platform/force-app/main/default/classes/db/UserDB.cls). It is declared public inherited sharing, declares the fields it queries in one private method, and delegates to FCORE_BASE.CacheServiceWithoutSharing:

/**
 * @description Retrieves User records from Salesforce DB
 */
public inherited sharing class UserDB {

    /**
     * @description Retrieves User record by provided Id
     *
     * @param id Id of the User record
     *
     * @return User record or NULL
     */
    public static User getById(Id id) {
        List<User> users = (List<User>) FCORE_BASE.CacheServiceWithoutSharing.getInstance().getByIds(
                User.SObjectType,
                new Set<Id>{id},
                getFieldsToQuery()
        );

        return users.isEmpty() ? null : users[0];
    }

    private static List<SObjectField> getFieldsToQuery() {
        return new List<SObjectField>{
                User.Id,
                User.Email
        };
    }
}

This is the canonical pattern:

The fields are declared once in getFieldsToQuery() as a List<SObjectField>. To load another field, you add it here and every consumer picks it up.
getById delegates to the cache’s getByIds with a single-element Set<Id> and returns the first match, or null when nothing is found.
Consumers never write inline SOQL for User — they call UserDB.getById(...), and the cache ensures the query runs at most once per transaction.

Singleton DB Classes for Small Tables

For small, frequently-read reference tables, the DB class is instead a singleton that loads every row once on construction and serves lookups from in-memory maps. This is the actual CurrencyTypeDB class (fusioncore-platform/force-app/main/default/classes/db/CurrencyTypeDB.cls). Note that it is public inherited sharing (not global), it caches all rows in its private constructor via queryAndCacheAll(), and it guards on UserInfo.isMultiCurrencyOrganization():

/**
 * @description Helper class for Currency Types
 */
public inherited sharing class CurrencyTypeDB {

    // Singleton
    private static CurrencyTypeDB instance;

    // Cache
    private final Map<String, SObject> currencyIsoCodeToCurrencyType = new Map<String, SObject>();
    private SObject corporateCurrencyType;

    /**
     * @description Constructor
     */
    private CurrencyTypeDB() {
        queryAndCacheAll();
    }

    /**
     * @description Returns singleton instance
     *
     * @return CurrencyTypeDB instance
     */
    public static CurrencyTypeDB getInstance() {
        if(instance == null) {
            instance = new CurrencyTypeDB();
        }

        return instance;
    }

    /**
    * @description Retrieve All Currency Types and puts them into cache
    */
    private void queryAndCacheAll() {
        for(SObject currencyType : queryAll()) {
            currencyIsoCodeToCurrencyType.put(CurrencyTypeUtils.getIsoCode(currencyType), currencyType);

            if(CurrencyTypeUtils.isCorporate(currencyType)) {
                corporateCurrencyType = currencyType;
            }
        }
    }

    /**
    * @description Retrieve All Currency Types
    *
    * @return List of Currency Type records
    */
    private static List<SObject> queryAll() {
        if(!UserInfo.isMultiCurrencyOrganization()){
            return new List<SObject>();
        }

        return Database.query('SELECT Id, ConversionRate, IsoCode, IsCorporate FROM CurrencyType', AccessLevel.SYSTEM_MODE);
    }

    /**
    * @description Retrieve Currency Type record by Iso Code
    *
    * @param isoCode ISO Code value
    *
    * @return Currency Type record or NULL if not found
    */
    public SObject getByIsoCode(String isoCode) {
        List<SObject> currencyTypes = getByIsoCodes(new Set<String>{isoCode});
        return currencyTypes.isEmpty() ? null : currencyTypes[0];
    }

    /**
     * @description Retrieve records of currency types by ISO Codes
     *
     * @param isoCodes Iso Codes of currency types
     *
     * @return Currency Type records
     */
    public List<SObject> getByIsoCodes(Set<String> isoCodes) {
        List<SObject> currencyTypes = new List<SObject>();

        if(isoCodes == null || isoCodes.isEmpty()) {
            return currencyTypes;
        }

        for(String isoCode : isoCodes) {
            SObject currencyType = currencyIsoCodeToCurrencyType.get(isoCode);

            if(currencyType != null) {
                currencyTypes.add(currencyType);
            }
        }

        return currencyTypes;
    }

    /**
     * @description Returns corporate Currency Type
     *
     * @return CurrencyType
     */
    public SObject getCorporate() {
        return corporateCurrencyType;
    }
}

This is the singleton pattern:

A private constructor plus getInstance() gives a lazy singleton — the first caller constructs the instance, and everyone after reuses it.
All rows are loaded once into currencyIsoCodeToCurrencyType (keyed by ISO code) when the instance is constructed.
Lookups — getByIsoCode, getByIsoCodes, and getCorporate — are served from memory with zero further SOQL.
The multi-currency guard in queryAll() returns an empty list in single-currency orgs, where CurrencyType is not queryable.

Call sites get the instance and read straight from memory:

SObject usd = CurrencyTypeDB.getInstance().getByIsoCode('USD');
SObject corporate = CurrencyTypeDB.getInstance().getCorporate();

Which Pattern to Use

Use a per-object DB class that delegates to the cache (like UserDB) for general records queried by Id.
Use a singleton that loads all rows (like CurrencyTypeDB) for small reference tables read repeatedly across a transaction.

Developer Guide

fusionCore Infrastructure

A Full DB Class (`UserDB`)

Singleton DB Classes for Small Tables

Which Pattern to Use

​A Full DB Class (UserDB)

​Singleton DB Classes for Small Tables

​Which Pattern to Use

A Full DB Class (`UserDB`)

Singleton DB Classes for Small Tables

Which Pattern to Use