Quickstart

npm install @akin-travel/partner-sdk

// app/layout.tsx — wrap once
import { AkinProvider, resolveConfig } from '@akin-travel/partner-sdk';
 
export default function RootLayout({ children }) {
  return (
    <AkinProvider
      config={resolveConfig({
        partnerId: process.env.NEXT_PUBLIC_AKIN_PARTNER_ID!,
        // Use a PUBLISHABLE (browser-safe) key here — this ships to the browser.
        // pk_test_* → sandbox, pk_live_* → production.
        apiKey: process.env.NEXT_PUBLIC_AKIN_API_KEY!,
      })}
    >
      {children}
    </AkinProvider>
  );
}

// Sign a member in, then read their loyalty state
import { MagicLinkForm, useAkinAuth, useAkinLoyalty } from '@akin-travel/partner-sdk';
 
export function Account() {
  const { member } = useAkinAuth();
  const { points, tier } = useAkinLoyalty();
 
  if (!member) {
    return (
      <MagicLinkForm onSuccess={(m) => console.log('Signed in:', m.id)}>
        {({ email, setEmail, handleSubmit, isPending }) => (
          <form onSubmit={handleSubmit}>
            <input value={email} onChange={(e) => setEmail(e.target.value)} placeholder="you@example.com" />
            <button type="submit" disabled={isPending}>{isPending ? 'Sending…' : 'Send magic link'}</button>
          </form>
        )}
      </MagicLinkForm>
    );
  }
  return <span>{member.firstName} • {points} pts • {tier}</span>;
}

npm install graphql-request firebase

// akin.ts — a tiny client, no SDK required
import { GraphQLClient } from 'graphql-request';
import { initializeApp } from 'firebase/app';
import { getAuth, signInWithCustomToken } from 'firebase/auth';
 
const ENDPOINT = 'https://staging-api.akintravel.com/graphql';
const firebase = initializeApp(/* Firebase/GIP config from onboarding */);
 
// Step 1 — send the magic link (unauthenticated; API key identifies the partner)
export async function sendMagicLink(email: string) {
  const client = new GraphQLClient(ENDPOINT, { headers: { 'x-partner-api-key': 'pk_test_…' } });
  await client.request(
    `mutation ($email: String!, $userType: String!, $partnerId: ID, $redirectUrl: String) {
      requestMagicLink(email: $email, userType: $userType, partnerId: $partnerId, redirectUrl: $redirectUrl) { success error }
    }`,
    { email, userType: 'MEMBER', partnerId: 'your-partner-id', redirectUrl: 'https://yourapp.com/auth/verify' },
  );
}
 
// Step 2 + 3 — on your /auth/verify page, exchange the one-time token for an ID token
export async function completeSignIn(token: string) {
  const client = new GraphQLClient(ENDPOINT, { headers: { 'x-partner-api-key': 'pk_test_…' } });
  const { verifyAuthToken } = await client.request(
    `mutation ($token: String!) { verifyAuthToken(token: $token) { customToken userId error } }`,
    { token },
  );
  const cred = await signInWithCustomToken(getAuth(firebase), verifyAuthToken.customToken);
  return cred.user; // Firebase manages the ID token + refresh from here
}
 
// Authenticated request — send the Firebase ID token as a bearer
export async function getPoints(memberId: string) {
  const idToken = await getAuth(firebase).currentUser!.getIdToken();
  const client = new GraphQLClient(ENDPOINT, { headers: { authorization: `Bearer ${idToken}` } });
  const { memberProfile } = await client.request(
    `query ($id: ID!) { memberProfile(id: $id) { membershipYearStats { akinPoints totalStays } } }`,
    { id: memberId },
  );
  return memberProfile.membershipYearStats.akinPoints;
}

import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.auth.ktx.auth
import com.google.firebase.ktx.Firebase
import kotlinx.coroutines.tasks.await
 
const val ENDPOINT = "https://staging-api.akintravel.com/graphql"
 
// Step 2 + 3 — after the magic-link redirect hands your app the one-time `token`
suspend fun completeSignIn(token: String) {
    val customToken = graphql(
        query = """mutation(${'$'}t: String!){ verifyAuthToken(token: ${'$'}t){ customToken error } }""",
        variables = mapOf("t" to token),
        apiKey = "pk_test_…",
    ).getJSONObject("verifyAuthToken").getString("customToken")
 
    Firebase.auth.signInWithCustomToken(customToken).await() // ID token now managed by Firebase
}
 
// Authenticated request — attach the Firebase ID token
suspend fun points(memberId: String): Int {
    val idToken = Firebase.auth.currentUser!!.getIdToken(false).await().token!!
    val data = graphql(
        query = """query(${'$'}id: ID!){ memberProfile(id: ${'$'}id){ membershipYearStats{ akinPoints } } }""",
        variables = mapOf("id" to memberId),
        bearer = idToken,
    )
    return data.getJSONObject("memberProfile").getJSONObject("membershipYearStats").getInt("akinPoints")
}

import FirebaseAuth
 
let endpoint = URL(string: "https://staging-api.akintravel.com/graphql")!
 
// Step 2 + 3 — after the magic-link redirect delivers the one-time `token`
func completeSignIn(token: String) async throws {
    let customToken = try await graphQL(
        query: "mutation($t:String!){ verifyAuthToken(token:$t){ customToken error } }",
        variables: ["t": token],
        apiKey: "pk_test_…"
    ).value(for: ["verifyAuthToken", "customToken"]) as String
 
    try await Auth.auth().signIn(withCustomToken: customToken) // Firebase manages the ID token
}
 
// Authenticated request — attach the Firebase ID token
func points(memberId: String) async throws -> Int {
    let idToken = try await Auth.auth().currentUser!.getIDToken()
    let data = try await graphQL(
        query: "query($id:ID!){ memberProfile(id:$id){ membershipYearStats{ akinPoints } } }",
        variables: ["id": memberId],
        bearer: idToken
    )
    return data.value(for: ["memberProfile", "membershipYearStats", "akinPoints"]) as Int
}

# Step 1 — send a magic link (partner identified by the API key, no user token yet)
curl https://staging-api.akintravel.com/graphql \
  -H 'content-type: application/json' \
  -H 'x-partner-api-key: pk_test_…' \
  -d '{"query":"mutation($e:String!,$u:String!,$p:ID,$r:String){requestMagicLink(email:$e,userType:$u,partnerId:$p,redirectUrl:$r){success error}}","variables":{"e":"member@example.com","u":"MEMBER","p":"your-partner-id","r":"https://yourapp.com/auth/verify"}}'
 
# Step 2 — exchange the one-time token (from the email link) for a Firebase custom token
curl https://staging-api.akintravel.com/graphql \
  -H 'content-type: application/json' -H 'x-partner-api-key: pk_test_…' \
  -d '{"query":"mutation($t:String!){verifyAuthToken(token:$t){customToken userId error}}","variables":{"t":"ONE_TIME_TOKEN"}}'
 
# Step 3 happens in a Firebase client SDK (web/Android/iOS): signInWithCustomToken(customToken) → ID token.
 
# Authenticated query — send the Firebase ID token as a bearer
curl https://staging-api.akintravel.com/graphql \
  -H 'content-type: application/json' \
  -H 'authorization: Bearer <FIREBASE_ID_TOKEN>' \
  -d '{"query":"query($id:ID!){memberProfile(id:$id){membershipYearStats{akinPoints totalStays}}}","variables":{"id":"MEMBER_ID"}}'