Conversations

// The permanent thread
const { conversations } = await expys.listConversations();
const general = conversations.find((c) => c.type === "GENERAL");

// A booking's thread, straight off the redemption
const redemption = await expys.createRedemption({ offer: "off_123" });
redemption.conversationId;

let conversations = try await client.listConversations()
let general = conversations.conversations.first { $0.type == "GENERAL" }

let redemption = try await client.createRedemption(.init(offer: "off_123"))
redemption.conversationId

val conversations = client.listConversations()
val general = conversations.conversations.firstOrNull { it.type == "GENERAL" }

val redemption = client.createRedemption(CreateRedemptionRequest(offer = "off_123"))
redemption.conversationId

import { initialize } from "@expys/sdk";

const token = process.env.EXPYS_MEMBER_TOKEN;
if (!token) {
  throw new Error(
    "Set EXPYS_MEMBER_TOKEN (a member token from your backend's /v1/auth/exchange)",
  );
}

const expys = initialize({
  baseUrl: process.env.EXPYS_BASE_URL,
  environment: "sandbox",
  token,
});

const externalUserID = process.env.EXPYS_EXTERNAL_USER_ID;

async function main(): Promise<void> {
  const { conversations } = await expys.listConversations({ externalUserID });
  console.log(`found ${conversations.length} conversations`);

  const conversation = conversations[0];
  if (!conversation) {
    return;
  }
  console.log(`reading: ${conversation.title ?? conversation.id}`);

  const { messages } = await expys.listMessages(conversation.id, {
    externalUserID,
    limit: 50,
  });
  for (const message of messages) {
    console.log(`[${message.authorID}] ${message.body ?? "(no body)"}`);
  }

  // Writes auto-send an Idempotency-Key so a retry replays rather than double-posts.
  const result = await expys.sendMessage(conversation.id, "Hello from the SDK");
  console.log(`message sent: ok=${result.ok}`);
}

import ExpysSDK
import Foundation

@main
struct ConversationsExample {
  static func main() async throws {
    let environment = ProcessInfo.processInfo.environment
    guard let token = environment["EXPYS_MEMBER_TOKEN"] else {
      fatalError("Set EXPYS_MEMBER_TOKEN (a member token from your backend's /v1/auth/exchange)")
    }
    let baseURL =
      environment["EXPYS_BASE_URL"].flatMap(URL.init(string:))
      ?? ExpysConfiguration.defaultBaseURL
    let externalUserID = environment["EXPYS_EXTERNAL_USER_ID"]

    let client = ExpysClient(
      configuration: ExpysConfiguration(token: token, environment: .sandbox, baseURL: baseURL)
    )

    let conversations = try await client.listConversations(externalUserID: externalUserID)
    print("found \(conversations.conversations.count) conversations")

    guard let conversation = conversations.conversations.first else { return }
    print("reading: \(conversation.title ?? conversation.id)")

    let messages = try await client.listMessages(
      id: conversation.id, limit: 50, externalUserID: externalUserID)
    for message in messages.messages {
      print("[\(message.authorID)] \(message.body ?? "(no body)")")
    }

    // Writes auto-send an Idempotency-Key so a retry replays rather than double-posts.
    let result = try await client.sendMessage(id: conversation.id, message: "Hello from the SDK")
    print("message sent: ok=\(result.ok)")
  }
}

package com.expys.sdk.examples.conversations

import com.expys.sdk.ExpysClient
import com.expys.sdk.ExpysConfiguration
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
  val token = System.getenv("EXPYS_MEMBER_TOKEN")
    ?: error("Set EXPYS_MEMBER_TOKEN (a member token from your backend's /v1/auth/exchange)")
  val externalUserID = System.getenv("EXPYS_EXTERNAL_USER_ID")

  val client = ExpysClient.create(
    ExpysConfiguration(
      token = token,
      baseUrl = System.getenv("EXPYS_BASE_URL") ?: ExpysConfiguration.DEFAULT_BASE_URL,
    ),
  )

  val conversations = client.listConversations(externalUserID = externalUserID)
  println("found ${conversations.conversations.size} conversations")

  val conversation = conversations.conversations.firstOrNull() ?: return@runBlocking
  println("reading: ${conversation.title ?: conversation.id}")

  val messages = client.listMessages(conversation.id, limit = 50, externalUserID = externalUserID)
  for (message in messages.messages) {
    println("[${message.authorID}] ${message.body ?: "(no body)"}")
  }

  // Writes auto-send an Idempotency-Key so a retry replays rather than double-posts.
  val result = client.sendMessage(conversation.id, "Hello from the SDK")
  println("message sent: ok=${result.ok}")
}