Integrations and Deprecations 0.1.0 #

This topic includes integrations and deprecations for Pragma Version 0.1.0.

Integrations #

Multiplayer #

[Multiplayer] Update references to relocated Friend and Presence classes in the SDK #

Description: For better project organization, we moved the FPragmaFriend, FPragmaFriendOverview, and FPragmaPresence classes in the Unreal SDK from the Pragma/Api/Player folder to Pragma/Api/Common/Friend folder

Integration steps:

• sdk | If you are importing the FPragmaFriend, FPragmaFriendOverview, or FPragmaPresence class, update the import path according to the new structure.

[Multiplayer] Update client code to work with restructured Unreal Presence objects. #

Description: In an effort to decouple our data types from the Unreal type system, we’ve converted the Unreal struct FPragmaPresence to a simple C++ class. Blueprint access to the class has been removed and new functions exist to access the data that was previously publicly accessible as properties on the struct. Unreal SDK users who interact with the Presence portions of the SDK will need to update their client code to continue to compile and function.

Integration steps:

• sdk | Update any access to data on FPragmaPresence objects to invoke a function that returns the data instead of directly accessing the data (e.g., change Presence->PlayerId to Presence->GetPlayerId()).

[Multiplayer] Initialize Presence service in SDK #

Description: To use the Presence service with the Unreal and Unity SDK, you must first call the new Initialize() function. This ensures that the locally cached state is in sync with the Pragma platform.

Integration steps:

• sdk | Locate SDK code that creates Pragma player sessions.
• sdk | If that player session intends to interact with the Presence API, it should invoke UPragmaPresenceApi::Initialize(const FOnCompleteDelegate& OnComplete).
• sdk | After initialization, the Presence API GetPresenceCache() will return a populated TSharedPtr<const IPragmaPresenceCache>.

[Multiplayer] Adjust code imports for HostConnectionDetails relocation #

Description: To resolve dependencies, the HostConnectionDetails payload was relocated from GameInstanceRpc to GameInstanceCommon.

Integration steps:

• platform | Update any code that imports GameInstanceRpc.HostConnectionDetails to instead import GameInstanceCommon.HostConnectionDetails.

[Multiplayer] Rename GameInstanceTestFactory files #

Description: The GameInstanceTestFactory and GameInstanceGameTestFactory files were renamed to better conform to our naming patterns and to better reflect what module the test factory resides in.

Integration steps:

• platform | If you were using one of the two GameInstance test factories, update your code to reference them by their new names:

[Multiplayer] Adjust the stale party expiration default if necessary #

Description: Version 0.1.0 enables the Party service’s stale party expiration feature by default. The default configuration automatically removes parties older than 7 days. The goal of this feature is to catch parties that did not shutdown properly.

Integration steps:

• platform | If the default values are appropriate for your game, no action is required.
• platform | To disable the stale party expiration feature, change the PartyConfig.enableStalePartyExpiration config value to false.
• platform | To change the expiration time, adjust the PartyConfig.stalePartyExpirationMinutes config value.

Accounts #

[Accounts] sdk | Update UPragmaPartnerBansAPI in the Unreal SDK to use the rich SDK delegate types for returning information. #

Description: The following are the affected SDK methods:

• UPragmaPartnerBansApi::BanAccountFromGameShard
• UPragmaPartnerBansApi::BanAccount
• UPragmaPartnerBansApi::RevokeBan

Integration steps:

• sdk | Update references to old delegate types to use the new delegate types.

  • UPragmaPartnerBansApi Delegate Types:

    Before:

    // For BanAccount and BanAccountFromGameShard
    DECLARE_DELEGATE_TwoParams(
        FBanAccountPartnerV1Delegate,
        TPragmaResult<FPragma_Account_BanAccountPartnerV1Response> /* Result */,
        const FPragmaMessageMetadata& /* Metadata */
    );
    
    // For RevokeBan
    DECLARE_DELEGATE_TwoParams(
        FRevokeBanAccountPartnerV1Delegate,
        TPragmaResult<FPragma_Account_RevokeBanAccountPartnerV1Response> /* Result */,
        const FPragmaMessageMetadata& /* Metadata */
    );
    

    After:

    // For BanAccount and BanAccountFromGameShard
    DECLARE_DELEGATE_OneParam(
        FBanAccountPartnerDelegate,
        TPragmaResult<FPragmaBanRecord> /* Result */
    );
    
    // For RevokeBan
    DECLARE_DELEGATE_OneParam(
        FOnCompleteDelegate,
        TPragmaResult<> /* Result */
    );
    

  • UPragmaPartnerBansApi Delegate Type References

    Before:

    // For BanAccount and BanAccountFromGameShard
    UPragmaAccountPartnerServiceRaw::FBanAccountPartnerV1Delegate
    
    // For RevokeBan
    UPragmaAccountPartnerServiceRaw::FRevokeBanAccountPartnerV1Delegate
    

    After:

    // For BanAccount and BanAccountFromGameShard
    UPragmaPartnerBansApi::FBanAccountPartnerDelegate
    
    // For RevokeBan
    UPragmaPartnerBansApi::FOnCompleteDelegate
    

[Accounts] platform | Update usages of getBanHistory. #

Description: getBanHistory now has two parameters: includeExpiredBans and includeRevokedBans. These parameters are defaulted to false. Previously getBanHistory would return the full history, which included both expired and revoked bans.

Set both fields to true to maintain previous behavior.

Integration steps:

• platform | Update use of getBanHistory to take in its new parameters.

  getBanHistory(includeExpiredBans: Boolean = false, includeRevokedBans: Boolean = false): List<BanRecord> = emptyList()
  

[Accounts] platform | Update Unreal and Unity SDKs that are used by a player session to access other players’ account information. #

Description: Several delegates in both the Unreal and Unity SDK have been renamed for clarity.

Integration steps:

• sdk | Update the following delegates.

  • Unreal:

  Original	Replacement
  FGetPlayerIdentitiesDelegate	FGetPlayerIdentitiesPartnerDelegate
  GetPragmaPlayerIdsForProviderIds	GetPlayerIdentitiesByProviderAccountIds

  • Unity:

  Original	Replacement
  GetPragmaPlayerIdsForProviderIds	GetPlayerIdentitiesByProviderAccountIds

[Accounts] sdk | Update usages of EnumToString and typedef AccountIdProvider. #

Description: To avoid name collisions the EnumToString utility in the Unreal SDK has been namespaced to the Pragma namespace. We’ve also removed an unused typedef AccountIdProvider.

Integration steps:

• sdk | Update usages of EnumToString.

• sdk | Update usages of AccountIdProvider.

[Accounts] config | If you are using PublicSocialIdentity::idProviderAccounts and PlayerIdentity:idProviderAccounts, you may need to update your identity provider configs. #

Description: Identity providers will be returned to the endpoints based on the config value visibleToOtherPlayers. See

Customize which identity providers are visible to other players to avoid exposing personal information for details. Player session type endpoints that return social and player identities will now have a filtered list of identity provider accounts. Filtering is done based on the new visibleToOtherPlayers identity provider config.

Integration steps:

• config | Update your identity provider configs to ensure the correct identity provider accounts will be visible. The affected endpoints include:
  • GetSocialIdentitiesV1
  • GetPlayerIdentitiesV1
  • GetSocialIdentitiesByProviderAccountIdsV1
  • GetPlayerIdentitiesByProviderAccountIdsV1

[Accounts] platform | Detect the banned error case and perform a social only login if you would still like to retrieve a social token. #

Description: The /v1/account/authenticateorcreatev2 endpoint now responds with a 403 and an AccountApplicationError when a player attempts to authenticate with active bans.

We no longer return a social token if a player has an active game ban. Since the social token is no longer provided, you may need to detect the banned error case and perform a social only login if you would still like to retrieve a social token.

Players without an active ban will still be able to perform a social only authentication through /v1/account/authenticatev1 or /v1/account/authenticateorcreatev2 without passing in a game shard.

Integration steps:

• platform | Add error handling for players attempting to perform a game login with active bans.

[Accounts] config |If you are using the previous Xbox identity provider plugin, update your config. #

Description: We’ve made improvements that require your Xbox identity provider config to be updated.

Integration steps: Reach out to your Pragma customer success representative for more details.

Inventory #

[Inventory] platform | If you are using the Inventory service, update your configs so Inventory Content loads on engine startup. #

Description: Pragma Engine’s startup no longer requires that Inventory service content is loaded and valid. To continue using Inventory service content, you’ll need to change your configs to load Inventory content on engine startup. Note that if you enable Inventory service content to be required on engine startup, any missing content files from Inventory service content will still result in runtime errors for unfound content.

Integration steps:

• platform | Update InventoryServiceConfig with a new property to ensure content is loaded on startup for game nodes running Inventory service.

  serviceConfigs:
  InventoryServiceConfig:
      loadInventoryContentOnStart: true
  

[Inventory] platform | If you are using the Inventory service with the Party service, update your Party Plugin code to fetch inventory data. #

As part of the transition from Inventory service to Player Data service, the Party service no longer sets or updates the inventory field on Party.PartyPlayer as part of the onAddPlayer(), returnFromMatchmaking(), and returnFromGameInstance() operations. Instead, the inventory field has been changed to a nullable type and is stored as a settable value.

Integration steps: To continue to use the Inventory service with the Party service, make the following changes:

• platform | Update any use of Party.PartyPlayer.Inventory to handle a potential null value.

• platform | Populate the inventory:

  • Add an InventoryClient to your Party Plugin, and invoke inventoryClient.init(service) with the service provided to the plugin constructor.
  • In the onAddPlayer(), returnFromMatchmaking(), and returnFromGameInstance() functions, invoke inventoryClient.getInventoryDataV3 for each player with the inventoryTagsToInclude values from the PartyConfig provided to the plugin function.
  • Wrap the result of the inventoryClient call with a ServiceInventoryData and assign it to the player’s inventory.

For example:

class ExamplePartyPlugin(
   val service: Service,
   val contentDataNodeService: ContentDataNodeService,
   private val inventoryClient: InventoryClient,
) : PartyPlugin {

    constructor(
       service: Service,
       contentDataNodeService: ContentDataNodeService,
   ) : this(
       service,
       contentDataNodeService,
       InventoryClient()
   )

   init {
       inventoryClient.init(service)
   }

    override suspend fun onAddPlayer(
        requestExt: ExtPlayerJoinRequest, 
        playerToAdd: Party.PartyPlayer, 
        party: Party.Party, 
        partyConfig: PartyConfig,
   ) {
       val inventoryResponse = inventoryClient.getInventoryDataV3(
            playerToAdd.playerId, 
            partyConfig.inventoryTagsToInclude.values)
        
        playerToAdd.inventory = ServiceInventoryData(
            inventoryResponse.inventory, 
            playerToAdd.playerId)
         
       // do stuff with player's inventory as before
   }
}

[Inventory] platform |If you are using the DefaultPragmaLoginDataPlugin to return Inventory content and trigger Limited Grants, you’ll need to implement your own instance of this plugin. #

Description: Due to recent deprecations deprecations of the Inventory service, the DefaultPragmaLoginDataPlugin no longer includes any default dependent jobs, including InventoryGetLoginDataV2DependentJob as a default job.

Integration steps:

• platform | Copy the existing DefaultPragmaLoginDataPlugin into your 5-ext, give the plugin a custom name, and add the InventoryGetLoginDataV2DependentJob to your LoginDataJobs.

  // Example of plugin with the `InventoryGetLoginDataV2DependentJob`
  class <CUSTOM PLUGIN NAME>(val service: Service, val contentDataNodeService: ContentDataNodeService) : LoginDataPlugin {
  override fun getLoginDataJobsV2(playerId: PlayerId): List<DependentJob<LoginDataBuilder>> {
  return listOf(
  InventoryGetLoginDataV2DependentJob(playerId, service)
  )
  }
  }
  

Engine #

[Engine] Parse error data for typed failures #

For SDK methods that return a raw service result, for example MatchApi.ConnectPlayers, a null pointer exception will be thrown if you try to access error code properties that do not exist. You need to check if the error is a typed failure and, if so, parse the error data because it is not guaranteed to have the Error() and ErrorCode() properties. For example:

if (Result.IsTypedFailure() && Result.GetErrorType() == FPragma_GameInstance_GameInstanceApplicationError::StaticStruct())
{
    auto GameInstanceApplicationError = Result.template ReadError<FPragma_GameInstance_GameInstanceApplicationError>();
    auto error = FPragmaError(GameInstanceApplicationError.Error);
    auto message = GameInstanceApplicationError.Message;
    ...
}

[Engine] platform | Update any usages of service-to-service APIs with the changed API parameter. #

Description: Service to service calls in Pragma Engine have been modified with a changed API parameter. Instead of responseKClass: KClass<out Response> as the API’s type, these APIs now use ParseFromFunction<Response>. This function is defined as typealias ParseFromFunction<T> = (ByteString) -> T and will be used as a protos parseFrom function.

Integration steps:

• platform | Update any service to service calls in your Pragma Engine so the API’s parameters use the proto’s parseFrom function instead of KClass.

  • Before:

  val result = service.requestRpc(request, DataRightsRpc.GetPersonalDataPackageServiceV1Response::class)
  

  • After:

  val result = service.requestRpc(request, DataRightsRpc.GetPersonalDataPackageServiceV1Response::parseFrom)
  

SDK #

[SDK] Update usage of TFuture functions to use function callbacks #

Description: The TFuture functions that were deprecated in version 0.0.101 have been removed from the Unreal SDK. Relevant files:

• PragmaFriendApi
• PragmaGameLoopApi
• PragmaPresenceApi
• PragmaMatchApi
• PragmaAccountPartnerService

Integration steps:

• sdk| If you use an Unreal function that returns a TFuture, instead use the analogous function that returns void and takes a callback. For example:

  • Before:

  auto Future = PragmaPlayer->FriendApi.AcceptFriendInvite(InviterSocialId);
  

  • After:

  auto Delegate = UFriendApi::FOnCompleteDelegate::CreateWeakLambda();
      PragmaPlayer->FriendApi().AcceptFriendInvite(
          InviterSocialId, Delegate);
  

Infra & Tooling #

[Infra & Tooling] Remove deprecated services from Docker #

Description: The docker-compose.yml file has been updated to remove unused fields.

Integration steps: Restart your local Docker and remove orphaned dependencies:

$ cd platform/devenv/docker-compose-devenv
$ docker compose down --remove-orphans
$ docker compose up -d

GameLoopApi Migration for Unreal #

This guide explains the changes to the Game Loop API for Unreal in Pragma Engine version 0.1.0.

Summary of changes #

• The Game Loop API has been deprecated, with its functions being relocated into the new Party API and Game Instance API.

  • Party API: Includes player client actions and events relating to parties and matchmaking
  • Game Instance API: Includes player client actions and events relating to game instance functionality

  These new dedicated APIs offer better management and reduce bloat. Each new API also includes an improved interface and a cache that can easily synchronize player client data with the platform.

• We improved the process of reconnecting to a game server using the new Game Instance API

Relocated and removed functions #

The following party-related functions are now available in the PartyApi:

• Initialize (specific to the PartyApi)
• ForceSync (specific to the party data cache)
• CreateParty
• SendPartyInvite
• RespondToPartyInvite
• JoinPartyWithInviteCode
• JoinPartyWithId
• LeaveParty
• AssignPartyLeader
• KickPlayerFromParty
• UpdatePartyPlayer
• UpdateParty
• SetPartyPreferredGameServerZones
• SetPartyPlayerGameServerZoneToPing
• SetPartyPlayerReady
• EnterMatchmaking
• LeaveMatchmaking
• GetMatchmakingInfo
• GetPartyCache (replaces GetPartyState)
• GetPendingPartyInvites
• GetPartyInviteByInviteId

The following player client game instance functions are now available in the GameInstanceApi:

• Initialize (specific to the GameInstanceApi)
• ForceSync (specific to the game instance data cache)
• DeclineReconnect
• GetGameInstanceCache (replaces GetGameInstanceId)

The following functions have been removed:

• GetHostConnectionDetails (details available via GetGameInstanceCache())
• CanCreateParty
• CanSendPartyInvite
• CanAcceptPartyInvite
• CanJoinParty
• CanLeaveParty
• CanAssignPartyLeader
• CanKickPlayerFromParty
• CanUpdatePartyPlayer
• CanUpdateParty
• CanSetPartyPreferredGameServerZones
• CanSetPartyPlayerGameServerZoneToPing
• CanSetPartyPlayerReady
• CanEnterMatchmaking
• CanLeaveMatchmaking
• CanDeclineReconnect
• CanGetMatchConnectionDetails

Relocated and removed events #

The following party-related events are now available in the PartyApiI:

• OnPartyUpdated (see also: Changed events)
• OnPartyInviteCodeChanged
• OnExtBroadcastPartyChanged
• OnPartyPreferredGameServerZonesChanged
• OnRemovedFromParty
• OnPartyPlayersChanged
• OnPlayerJoinedParty
• OnPartyPlayerDataChanged
• OnPlayerLeftParty
• OnExtPrivatePlayerChanged
• OnPartyInvitesChanged
• OnPartyInviteReceived
• OnPartyInviteRevoked
• OnPartyInviteAccepted
• OnPartyInviteDeclined
• OnGameClientVersionUpdateRequired
• OnPartyClientVersionMismatch
• OnEnteredMatchmaking
• OnLeftMatchmaking
• OnMatchmakingFailed

The following game instance-related events are now available in the GameInstanceApi:

• OnAddedToGameInstance (see also: Changed events)
• OnFailedToAllocateGameInstance
• OnHostConnectionDetailsReceived (see also: Changed events)
• OnRemovedFromGameInstance (see also: Changed events)
• OnGameInstanceEnded (see also: Changed events)
• OnGameInstanceTerminated (see also: Changed events)

The following game instance-related events have been removed:

• OnGameInstanceReconnect (see also: New reconnect flow)

Changed events #

Several events exposed by the API have been slightly renamed and now offer improved parameter lists, often including a full reference to a const FPragmaGameInstance so that any event handler has access to complete context on the player’s game instance state when fired. The data types returned from the party events have been modified where appropriate to ensure access protection on the underlying data caches.

OnPartyChanged/OnPartyUpdated #

// GameLoopApi (deprecated)
DECLARE_EVENT_OneParam(
UPragmaGameLoopApi, 
FPartyEvent, 
const UPragmaParty* /* Party */);
FPartyEvent OnPartyChanged;

//PartyApi
DECLARE_EVENT_OneParam(
UPragmaPartyApi, 
FPartyEvent, 
const FPragmaParty& /* Party */);
FPartyEvent OnPartyUpdated;

OnAddedToGame/OnAddedToGameInstance #

// GameLoopApi (deprecated)
DECLARE_EVENT_TwoParams(
UPragmaGameLoopApi, 
FAddedToGameEvent, 
FString /* GameInstanceId */, 
FPragma_GameInstance_ExtAddedToGame /* Ext */);
FAddedToGameEvent OnAddedToGame;

//GameInstanceApi
DECLARE_EVENT_OneParam(
UPragmaGameInstanceApi, 
FGameInstanceEvent, 
const FPragmaGameInstance& /* GameInstance */);
FGameInstanceEvent OnAddedToGameInstance;

OnHostConnectionDetailsReceived #

//GameLoopApi (deprecated)	
DECLARE_EVENT_OneParam(
UPragmaGameLoopApi, 
FHostConnectionDetailsEvent,
	FPragma_GameInstance_HostConnectionDetails /* HostConnectionDetails */);
FHostConnectionDetailsEvent OnHostConnectionDetailsReceived;


//GameInstanceApi
DECLARE_EVENT_OneParam(
UPragmaGameInstanceApi, 
FGameInstanceEvent, 
const FPragmaGameInstance& /* GameInstance */);
FGameInstanceEvent OnHostConnectionDetailsReceived;

OnRemovedFromGame/OnRemovedFromGameInstance #

//GameLoopApi (deprecated)	
DECLARE_EVENT_TwoParams(
UPragmaGameLoopApi, 
FRemovedFromGameEvent, 
FString /* GameInstanceId */,
	FPragma_GameInstance_ExtRemovedFromGame /* ExtRemovedFromGame */);
FRemovedFromGameEvent OnRemovedFromGame;

//GameInstanceApi
DECLARE_EVENT_TwoParams(
UPragmaGameInstanceApi, 
FRemovedFromGameEvent, 
const FString& /* GameInstanceId */,
	const FPragma_GameInstance_ExtRemovedFromGame& /* ExtRemovedFromGame */);
FRemovedFromGameEvent OnRemovedFromGameInstance;

OnGameEnded/OnGameInstanceEnded #

//GameLoopApi (deprecated)	
DECLARE_EVENT_TwoParams(
UPragmaGameLoopApi, 
FGameEndedEvent, 
FString /* GameInstanceId */,
	FPragma_GameInstance_ExtGameEnded /* Ext */);
FGameEndedEvent OnGameEnded;

//GameInstanceApi
DECLARE_EVENT_TwoParams(
UPragmaGameInstanceApi, 
FGameEndedEvent, 
const FString& /* GameInstanceId */,
	const FPragma_GameInstance_ExtGameEnded& /* Ext */);
FGameEndedEvent OnGameInstanceEnded;

OnGameInstanceTerminated #

//GameLoopApi (deprecated)	
DECLARE_EVENT_TwoParams(
UPragmaGameLoopApi, 
FGameInstanceTerminatedEvent, 
FString /* GameInstanceId */,
EPragma_GameInstance_GameInstanceTerminationReason /* TerminationReason 
*/);
FGameInstanceTerminatedEvent OnGameInstanceTerminated;

//GameInstanceApi
DECLARE_EVENT_TwoParams(
UPragmaGameInstanceApi, 
FGameInstanceTerminatedEvent, 
const FString& /* GameInstanceId */,
	const EPragma_GameInstance_GameInstanceTerminationReason& /* 
TerminationReason */);
FGameInstanceTerminatedEvent OnGameInstanceTerminated;

Integration steps #

Initialization and caching #

Both new APIs have an Initialize() function that must be called prior to using the API. We recommend you initialize the APIs immediately after logging the player in. Initialization automatically synchronizes the player’s party/game instance state with the backend. Backend data is available through the new GetPartyCache() and GetGameInstanceCache() functions.

While the Pragma SDK constantly attempts to stay in sync with the Pragma Engine backend, there may be instances where you want to explicitly force the SDK party cache to sync with the backend data. To forcibly synchronize the client’s state with the platform, call the PartyApi/GameInstanceApi ForceSync() function.

New reconnect flow #

To check if a reconnected player is still in a game instance, use the GameInstanceApi.GetGameInstanceCache() SDK method. This method will also return host connection details so the player client can connect to the appropriate game server.

If the player is reconnecting to the engine due to logging out, call GetGameInstanceCache() immediately after GameInstanceApi.Initialize() to check if the player is still in a game instance.

Using new functions and events #

Most changes will be as simple as changing references:

• Replace Player()->GameLoopApi() with Player()->PartyApi()
• Replace Player()->GameLoopApi() with Player()->GameInstanceApi()
• Account for any new function names or event return types

Replacing can functions #

Previously, the SDK can functions were Pragma-authored functions that checked the party or game instance cache to determine if the action was allowed. For example, verifying that a player was in a party. To allow for more flexibility and customization, the can functions have been removed. You can perform the same checks, as well as any additional checks you want, by looking at the data in GetPartyCache() and GetGameInstanceCache(). For example, you can check if a player is in a party using GetPartyCache()->IsInParty() and make decisions accordingly.

Deprecations #

[Multiplayer] sdk | GetPresence() has been deprecated in favor of GetPresenceCache->GetPresence(). #

GetPresence() has been deprecated in favor of exposing the user’s presence information within the IPragmaPresenceCache. To prepare for this deprecation, replace calls to PresenceApi->GetPresence() with calls to the Presence cache’s GetPresence() function, as shown in the following table:

The deprecated function is scheduled to be removed in Pragma Engine version 0.2.0.

[Multiplayer] sdk | Unreal GameLoopApi deprecated in favor of a dedicated Party API and Game Instance API. #

Actions and events related to parties and game instances have been organized into separate APIs to separate concerns and reduce bloat. All methods and events on the PragmaGameLoopApi have been deprecated and their replacements have been added to the PragmaPartyApi and PragmaGameInstanceApi.

The GameLoopApi is scheduled to be removed in Pragma Engine version 0.3.0.

[Engine] config | The use of hosting credentials within the database configuration is being deprecated in favor of identifier schemas. #

The following table lists the deprecated configuration and the recommended replacement. Database configuration can be self-defined or auto-generated for managed service customers.

• Original:

  [Service]DaoConfig:
      databaseConfig:
          driver: "MYSQLDB"
          username: "superuser"
          password: "[encrypted-password]"
              hostPortSchemas:
              1: "database.test.[studio].pragmaengine.com:3306/local_[service]_[table]"
  

• Replacement option 1 - Self-defined: Move the database hosting credentials to the SharedDatabaseConfigServiceConfig and then reference the database by its identifier field.

  serviceConfigs:
      SharedDatabaseConfigServiceConfig:
          databaseConfigsByIdentifier:
          defaultDb:
              username: "superuser"
              password: "[encrypted-password]"
              host: "database.test.[studio].pragmaengine.com"
  
      [Service]DaoConfig:
          databaseConfig:
              identifierSchemas:
              1:
                  identifier: "defaultDb"
                  schema: "local_[service]_[table]"
  

• Replacement option 2 - Auto-generated by managed services: contact your customer service representative to enable this feature, and then update your database configuration to reference the auto-generated defaultIdentifier field.

  serviceConfigs:
      [Service]DaoConfig:
          databaseConfig:
              identifierSchemas:
              1:
                  identifier: "defaultIdentifier"
                  schema: "local_[service]_[table]"
  

The deprecated configuration format is scheduled to be removed in Pragma Engine version 0.2.0.