Getting SDK Connection Details

ditto = Ditto(
  identity: DittoIdentity.onlinePlayground(
    appID: "REPLACE_ME_WITH_YOUR_APP_ID",
    token: "REPLACE_ME_WITH_YOUR_PLAYGROUND_TOKEN",
    enableDittoCloudSync: false, // This is required to be set to false to use the correct URLs
    customAuthURL: URL(string: "REPLACE_ME_WITH_YOUR_AUTH_URL")
  )
)

ditto.updateTransportConfig { transportConfig in
  // Set the Ditto Websocket URL
  transportConfig.connect.webSocketURLs.insert("wss://REPLACE_ME_WITH_YOUR_WEBSOCKET_URL")
}

// Disable DQL strict mode so that collection definitions are not required in DQL queries
try await ditto.store.execute("ALTER SYSTEM SET DQL_STRICT_MODE = false")

do {
  try ditto.startSync()
} catch {
  print(error.localizedDescription)
}

try {
    val androidDependencies = DefaultAndroidDittoDependencies(applicationContext)
    val identity =
        DittoIdentity.OnlinePlayground(
            dependencies = androidDependencies,
            appId = "REPLACE_ME_WITH_YOUR_APP_ID",
            token = "REPLACE_ME_WITH_YOUR_PLAYGROUND_TOKEN",
            customAuthUrl = "REPLACE_ME_WITH_YOUR_AUTH_URL",
            enableDittoCloudSync = false  // This is required to be set to false to use the correct URLs
        )

    ditto = Ditto(androidDependencies, identity)

    ditto?.updateTransportConfig { config ->
        config.connect.websocketUrls.add("REPLACE_ME_WITH_YOUR_WEBSOCKET_URL")
    }

    // Disable DQL strict mode so that collection definitions are not required in DQL queries
    ditto.store.execute("ALTER SYSTEM SET DQL_STRICT_MODE = false")
    
    ditto.startSync()
} catch (e: DittoError) {
    Log.e("Ditto error", e.message!!)
}

await Ditto.init();

final identity = OnlinePlaygroundIdentity(
    appId: "REPLACE_ME_WITH_YOUR_APP_ID",
    token: "REPLACE_ME_WITH_YOUR_PLAYGROUND_TOKEN",
    customAuthUrl: "REPLACE_ME_WITH_YOUR_AUTH_URL",
    enableDittoCloudSync: false // This is required to be set to false to use the correct URLs
);
final ditto = await Ditto.open(identity);

ditto.updateTransportConfig((config) {
  // Set the Ditto Websocket URL
  config.connect.webSocketUrls.add("wss://REPLACE_ME_WITH_YOUR_WEBSOCKET_URL");
});

// Disable DQL strict mode so that collection definitions are not required in DQL queries
await ditto.store.execute("ALTER SYSTEM SET DQL_STRICT_MODE = false");

ditto.startSync();

import { init, Ditto, TransportConfig } from '@dittolive/ditto'

await init()

const ditto = new Ditto({
  type: "onlinePlayground",
  appID: "REPLACE_ME_WITH_YOUR_APP_ID",
  token: "REPLACE_ME_WITH_YOUR_PLAYGROUND_TOKEN",
  customAuthURL: "REPLACE_ME_WITH_YOUR_AUTH_URL",
  enableDittoCloudSync: false, // This is required to be set to false to use the correct URLs
})

ditto.updateTransportConfig((config: TransportConfig): void => {
  config.connect.websocketURLs.push(
    'wss://REPLACE_ME_WITH_YOUR_WEBSOCKET_URL'
  )
})

// Disable DQL strict mode so that collection definitions are not required in DQL queries
await ditto.store.execute("ALTER SYSTEM SET DQL_STRICT_MODE = false")

ditto.startSync()

import com.ditto.java.Ditto;
import com.ditto.java.DittoFactory;
import com.ditto.java.DittoConfig;
import com.ditto.java.DittoAuthenticationProvider;

try {
    // Configure Ditto with playground settings
    DittoConfig config = new DittoConfig.Builder("REPLACE_ME_WITH_YOUR_APP_ID")
        .connect(new DittoConfig.Connect.Server("wss://REPLACE_ME_WITH_YOUR_WEBSOCKET_URL"))
        .build();

    Ditto ditto = DittoFactory.create(config);

    // Set up authentication with playground token
    ditto.getAuth().login(
        "REPLACE_ME_WITH_YOUR_PLAYGROUND_TOKEN",
        DittoAuthenticationProvider.playground()
    ).thenAccept(clientInfo -> {
        // Disable DQL strict mode so that collection definitions are not required in DQL queries
        ditto.getStore().execute("ALTER SYSTEM SET DQL_STRICT_MODE = false");

        ditto.startSync();
    }).exceptionally(error -> {
        // Handle authentication error
        return null;
    });
} catch (DittoError e) {
    // Handle error in Ditto initialization
}

var identity = DittoIdentity.OnlinePlayground(
    appId, 
    playgroundToken, 
    false, // This is required to be set to false to use the correct URLs
    authUrl);

ditto = new Ditto(identity, tempDir);

ditto.UpdateTransportConfig(config =>
{
    // Set the Ditto Websocket URL
    config.Connect.WebSocketUrls.Add("wss://REPLACE_ME_WITH_YOUR_WEBSOCKET_URL");
});

// Disable DQL strict mode so that collection definitions are not required in DQL queries
await ditto.Store.ExecuteAsync("ALTER SYSTEM SET DQL_STRICT_MODE = false");

ditto.StartSync();

const auto identity = ditto::Identity::OnlinePlayground(
    std::move(app_id),
    std::move(online_playground_token),
    enable_cloud_sync,                  // This is required to be set to false to use the correct URLs
    std::move(custom_url)
);

ditto->update_transport_config([&](ditto::TransportConfig &config) {
    config.enable_all_peer_to_peer();
    config.connect.websocket_urls.insert(websocket_url);
});
// Required for compatibility with DQL.
ditto->disable_sync_with_v3();

// Disable DQL strict mode so that collection definitions are not required in DQL queries
ditto->get_store().execute("ALTER SYSTEM SET DQL_STRICT_MODE = false");

ditto->start_sync();

use dittolive_ditto::prelude::*;
use std::time::Duration;

// Initialize with DittoConfig using database_id (was app_id in v4).
// Copy the "URL" and "Database ID" from the Ditto Portal (Connect via SDK).
let database_id = DatabaseId::from_str("REPLACE_ME_WITH_YOUR_DATABASE_ID")?;
let config = DittoConfig::new(
    database_id.clone(),
    DittoConnect::Server {
        url: "REPLACE_ME_WITH_YOUR_URL".to_string()
    }
);

let ditto = Ditto::open(config)?;

// Set up authentication expiration handler
ditto.auth().set_expiration_handler(|ditto, seconds_remaining| {
    ditto.auth().login(
        "REPLACE_ME_WITH_YOUR_PLAYGROUND_TOKEN",
        Authenticator::development_provider(),
        |result| {
            if let Err(e) = result {
                eprintln!("Auth error: {}", e);
            }
        }
    );
});

// Configure transport (optional)
ditto.set_transport_config({
    let mut config = TransportConfig::new();
    config
        .connect
        .websocket_urls
        // Your Portal URL with the scheme changed from https:// to wss:// (host only)
        .insert("wss://REPLACE_ME_WITH_YOUR_URL_HOST".to_string());
    config
});

// Start sync (was ditto.start_sync() in v4)
ditto.sync().start()?;

const endpoint = "REPLACE_ME_WITH_YOUR_URL"
const id       = "REPLACE_ME_WITH_YOUR_DATABASE_ID"
const token    = "REPLACE_ME_WITH_YOUR_DEVELOPMENT_TOKEN"

config := ditto.DefaultDittoConfig().
    WithDatabaseID(id).
    WithConnect(&ditto.DittoConfigConnectServer{URL: endpoint})

dit, err := ditto.Open(config)
if err != nil {
    log.Fatalf("error: failed to open Ditto: %v", err)
}
defer dit.Close()

// Set up authentication expiration handler (required for server connections)
dit.Auth().SetExpirationHandler(
    func(d *ditto.Ditto, timeUntilExpiration time.Duration) {
        _, err := d.Auth().Login(token, ditto.DevelopmentAuthenticationProvider())
        if err != nil {
            log.Errorf("Authentication failed: %v", err)
        } else {
            log.Printf("Authentication succeeded")
        }
    })

if err := dit.Sync().Start(); err != nil {
    log.Errorf("error: failed to start sync: %v", err)
}