Points and wallet

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

const orgApiKey = process.env.EXPYS_ORG_API_KEY;
if (!orgApiKey) {
  throw new Error(
    "Set EXPYS_ORG_API_KEY (your secret Org-API-Key, e.g. expys_live_...). " +
      "Run this on a backend only, never in a client app.",
  );
}

// Construct the client with the machine credential as the token. Server-mode
// methods are guarded against member tokens client-side.
const expys = initialize({
  baseUrl: process.env.EXPYS_BASE_URL,
  environment: "sandbox",
  token: orgApiKey,
});

const externalUserID = process.env.EXPYS_EXTERNAL_USER_ID ?? "user_42";

async function main(): Promise<void> {
  // Mint a short-lived member token for your app to use (return this to the app,
  // never the Org-API-Key). Idempotent POST: a retry replays rather than re-mints.
  const grant = await expys.exchangeToken({ externalUserID });
  console.log(`minted member token expiring at ${grant.expiresAt}`);

  // Upsert the member's profile. PUT is idempotent by HTTP semantics (no key).
  const member = await expys.setMember(externalUserID, {
    displayName: "Ada Lovelace",
    tier: "gold",
  });
  console.log(`member ${member.externalUserID} is now tier=${member.tier}`);

  // Credit points to the member's wallet. Idempotent POST sends an Idempotency-Key.
  const credited = await expys.creditPoints({
    amount: 100,
    externalUserID,
    reason: "welcome bonus",
  });
  console.log(`new balance: ${credited.balance} ${credited.currency.symbol}`);

  // Register a webhook. The signingSecret is shown ONLY on creation - store it now.
  const webhook = await expys.createWebhook({
    events: ["redemption.created"],
    url: "https://example.com/expys/webhooks",
  });
  console.log(`webhook ${webhook.id} secret: ${webhook.signingSecret}`);

  // Org-wide analytics rollups.
  const summary = await expys.analyticsSummary();
  console.log(
    `members: ${summary.memberCount}, minted: ${summary.pointsMinted}`,
  );
}

import ExpysSDK
import Foundation

@main
struct ServerModeExample {
  static func main() async throws {
    let environment = ProcessInfo.processInfo.environment
    guard let orgApiKey = environment["EXPYS_ORG_API_KEY"] else {
      fatalError(
        "Set EXPYS_ORG_API_KEY (your secret Org-API-Key, e.g. expys_live_...). "
          + "Run this on a backend only, never in a client app.")
    }
    let baseURL =
      environment["EXPYS_BASE_URL"].flatMap(URL.init(string:))
      ?? ExpysConfiguration.defaultBaseURL
    let externalUserID = environment["EXPYS_EXTERNAL_USER_ID"] ?? "user_42"

    // Configure the client with the machine credential as the token. Server-mode
    // methods are guarded against member tokens client-side.
    let client = ExpysClient(
      configuration: ExpysConfiguration(token: orgApiKey, environment: .sandbox, baseURL: baseURL)
    )

    // Mint a short-lived member token for your app to use (return this to the app,
    // never the Org-API-Key). Idempotent POST: a retry replays rather than re-mints.
    let grant = try await client.exchangeToken(TokenExchangeRequest(externalUserID: externalUserID))
    print("minted member token expiring at \(grant.expiresAt)")

    // Upsert the member's profile. PUT is idempotent by HTTP semantics (no key).
    let member = try await client.setMember(
      externalUserID: externalUserID,
      SetMemberRequest(displayName: "Ada Lovelace", tier: "gold"))
    print("member \(member.externalUserID) is now tier=\(member.tier)")

    // Credit points to the member's wallet. Idempotent POST sends an Idempotency-Key.
    let credited = try await client.creditPoints(
      CreditWalletRequest(amount: 100, externalUserID: externalUserID, reason: "welcome bonus"))
    print("new balance: \(credited.balance) \(credited.currency.symbol)")

    // Register a webhook. The signingSecret is shown ONLY on creation - store it now.
    let webhook = try await client.createWebhook(
      CreateWebhookRequest(
        events: ["redemption.created"], url: "https://example.com/expys/webhooks"))
    print("webhook \(webhook.id) secret: \(webhook.signingSecret)")

    // Org-wide analytics rollups.
    let summary = try await client.analyticsSummary()
    print("members: \(summary.memberCount), minted: \(summary.pointsMinted)")
  }
}

package com.expys.sdk.examples.servermode

import com.expys.sdk.ExpysClient
import com.expys.sdk.ExpysConfiguration
import com.expys.sdk.ExpysEnvironment
import com.expys.sdk.models.CreateWebhookRequest
import com.expys.sdk.models.CreditWalletRequest
import com.expys.sdk.models.SetMemberRequest
import com.expys.sdk.models.TokenExchangeRequest
import kotlinx.coroutines.runBlocking
import java.net.URI

fun main() = runBlocking {
  val orgApiKey = System.getenv("EXPYS_ORG_API_KEY")
    ?: error(
      "Set EXPYS_ORG_API_KEY (your secret Org-API-Key, e.g. expys_live_...). " +
        "Run this on a backend only, never in a client app.",
    )
  val externalUserID = System.getenv("EXPYS_EXTERNAL_USER_ID") ?: "user_42"

  // Configure the client with the machine credential as the token. Server-mode
  // methods are guarded against member tokens client-side.
  val client = ExpysClient.create(
    ExpysConfiguration(
      token = orgApiKey,
      environment = ExpysEnvironment.SANDBOX,
      baseUrl = System.getenv("EXPYS_BASE_URL") ?: ExpysConfiguration.DEFAULT_BASE_URL,
    ),
  )

  // Mint a short-lived member token for your app to use (return this to the app,
  // never the Org-API-Key). Idempotent POST: a retry replays rather than re-mints.
  val grant = client.exchangeToken(TokenExchangeRequest(externalUserID = externalUserID))
  println("minted member token expiring at ${grant.expiresAt}")

  // Upsert the member's profile. PUT is idempotent by HTTP semantics (no key).
  val member = client.setMember(externalUserID, SetMemberRequest(displayName = "Ada Lovelace", tier = "gold"))
  println("member ${member.externalUserID} is now tier=${member.tier}")

  // Credit points to the member's wallet. Idempotent POST sends an Idempotency-Key.
  val credited = client.creditPoints(
    CreditWalletRequest(amount = 100, externalUserID = externalUserID, reason = "welcome bonus"),
  )
  println("new balance: ${credited.balance} ${credited.currency.symbol}")

  // Register a webhook. The signingSecret is shown ONLY on creation - store it now.
  val webhook = client.createWebhook(
    CreateWebhookRequest(events = listOf("redemption.created"), url = URI("https://example.com/expys/webhooks")),
  )
  println("webhook ${webhook.id} secret: ${webhook.signingSecret}")

  // Org-wide analytics rollups.
  val summary = client.analyticsSummary()
  println("members: ${summary.memberCount}, minted: ${summary.pointsMinted}")
}

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,
});

async function main(): Promise<void> {
  // externalUserID names the member when a machine token calls on their behalf.
  const eligibility = await expys.eligibility({
    externalUserID: process.env.EXPYS_EXTERNAL_USER_ID,
  });
  console.log(`tier: ${eligibility.tier}`);
  console.log(`wallet (from eligibility): ${eligibility.wallet.balance}`);

  const wallet = await expys.wallet();
  console.log(
    `wallet: balance=${wallet.balance} received=${wallet.amountReceived} ` +
      `spent=${wallet.amountSpent} ${wallet.currency.symbol} (${wallet.currency.name})`,
  );
}

import ExpysSDK
import Foundation

@main
struct EligibilityWalletExample {
  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 client = ExpysClient(
      configuration: ExpysConfiguration(token: token, environment: .sandbox, baseURL: baseURL)
    )

    // externalUserID names the member when a machine token calls on their behalf.
    let eligibility = try await client.eligibility(
      externalUserID: environment["EXPYS_EXTERNAL_USER_ID"]
    )
    print("tier: \(eligibility.tier)")
    print("wallet (from eligibility): \(eligibility.wallet.balance)")

    let wallet = try await client.wallet()
    print(
      "wallet: balance=\(wallet.balance) received=\(wallet.amountReceived) "
        + "spent=\(wallet.amountSpent) \(wallet.currency.symbol) (\(wallet.currency.name))"
    )
  }
}

package com.expys.sdk.examples.eligibilitywallet

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 client = ExpysClient.create(
    ExpysConfiguration(
      token = token,
      baseUrl = System.getenv("EXPYS_BASE_URL") ?: ExpysConfiguration.DEFAULT_BASE_URL,
    ),
  )

  // externalUserID names the member when a machine token calls on their behalf.
  val eligibility = client.eligibility(externalUserID = System.getenv("EXPYS_EXTERNAL_USER_ID"))
  println("tier: ${eligibility.tier}")

  val wallet = client.wallet()
  println("balance: ${wallet.balance} ${wallet.currency.symbol}")
  println("received: ${wallet.amountReceived}, spent: ${wallet.amountSpent}")
}