Session Management

const oneSDKInstance = await OneSdk({
  mode: 'production',
  session: { token: 'your-token' }
});

// Access session methods
const sessionId = oneSDKInstance.session.getSessionId();

getSessionId(): string

const sessionId = oneSDKInstance.session.getSessionId();
console.log('Session ID:', sessionId);

// Use in support requests or logs
console.log('Support ID:', sessionId);

getEntityId(): string | null

const entityId = oneSDKInstance.session.getEntityId();
if (entityId) {
  console.log('Entity ID:', entityId);
  // Fetch data from your backend API using entityId
  const userData = await fetch(`/api/users/${entityId}`).then(r => r.json());
} else {
  console.log('No entity associated yet');
}

getReference(): string | null

const reference = oneSDKInstance.session.getReference();
if (reference) {
  console.log('Application Reference:', reference);
  // Look up application in your system
  const application = await getApplicationByReference(reference);
} else {
  console.log('No reference set');
}

isPersisted(): boolean

if (oneSDKInstance.session.isPersisted()) {
  console.log('Welcome back! Resuming your verification...');
  // Skip onboarding, go directly to where they left off
  resumeVerification();
} else {
  console.log('Starting new verification session');
  // Show onboarding/instructions
  showWelcomeScreen();
}

unpersist(): void

function handleLogout() {
  // Clear persisted session from browser storage
  oneSDKInstance.session.unpersist();
  console.log('Session cleared from storage');

  // Also invalidate on backend (optional but recommended)
  await revokeSessionOnBackend(sessionId);

  // Redirect to login
  window.location.href = '/login';
}

getFrankie2customer(): boolean | undefined

const isFrankie2customer = oneSDKInstance.session.getFrankie2customer();
if (isFrankie2customer) {
  console.log('Using Frankie v2 API');
} else {
  console.log('Standard API integration');
}

getExtraData(): {
  linkExpiry?: string;
  [key: string]: any;
}

const extraData = oneSDKInstance.session.getExtraData();

if (extraData.linkExpiry) {
  console.log('Session expires:', extraData.linkExpiry);
  // Parse and show expiration warning
  const expiryDate = new Date(extraData.linkExpiry);
  if (expiryDate < new Date()) {
    showExpiryWarning();
  }
}

// Access custom metadata if you set any
if (extraData.customField) {
  console.log('Custom data:', extraData.customField);
}

getExpirationEpoch(): number

const expirationEpoch = oneSDKInstance.session.getExpirationEpoch();

// Convert to JavaScript Date (note: multiply by 1000)
const expirationDate = new Date(expirationEpoch * 1000);
console.log('Session expires at:', expirationDate.toLocaleString());

// Check if session is expired
const now = Date.now();
const isExpired = now > (expirationEpoch * 1000);

if (isExpired) {
  console.warn('Session has expired!');
  handleExpiredSession();
} else {
  // Calculate time remaining
  const timeRemaining = (expirationEpoch * 1000) - now;
  const minutesRemaining = Math.floor(timeRemaining / 60000);

  console.log(`Session expires in ${minutesRemaining} minutes`);

  // Warn if less than 5 minutes remaining
  if (minutesRemaining < 5) {
    showExpirationWarning(`Your session will expire in ${minutesRemaining} minutes`);
  }
}

// First initialization - token is stored
const oneSDKInstance = await OneSdk({
  mode: 'production',
  session: {
    token: 'your-token',  // Required - will be stored
    persist: true
  }
});

// Subsequent initialization - stored token is used if valid
const oneSDKInstance = await OneSdk({
  mode: 'production',
  session: {
    token: 'new-token',  // Required but may not be used if stored token is valid
    persist: true
  }
});

// Check if current session is persisted
if (oneSDKInstance.session.isPersisted()) {
  console.log('This session was restored from storage');

  // Clear it when done (e.g., on logout)
  oneSDKInstance.session.unpersist();
}

import OneSdk from '@frankieone/one-sdk';

async function initializeVerification() {
  try {
    // Initialize SDK
    const sdk = await OneSdk({
      mode: 'production',
      session: {
        token: await fetchTokenFromBackend(),
        persist: true,
        appReference: 'my-app-v1.0.0'
      }
    });

    // Log session information
    console.log('Session initialized:', {
      sessionId: sdk.session.getSessionId(),
      entityId: sdk.session.getEntityId(),
      reference: sdk.session.getReference(),
      isPersisted: sdk.session.isPersisted(),
      expiresAt: new Date(sdk.session.getExpirationEpoch() * 1000)
    });

    // Check extra data for custom metadata
    const extraData = sdk.session.getExtraData();
    if (extraData.linkExpiry) {
      console.log('Session link expires:', extraData.linkExpiry);
    }

    // Monitor session expiration
    const expirationEpoch = sdk.session.getExpirationEpoch();
    const timeUntilExpiry = (expirationEpoch * 1000) - Date.now();

    if (timeUntilExpiry < 5 * 60 * 1000) {
      console.warn('Session expires in less than 5 minutes');
    }

    // Set up expiration warning
    setTimeout(() => {
      alert('Your session is about to expire. Please complete verification soon.');
    }, timeUntilExpiry - (2 * 60 * 1000)); // Warn 2 minutes before expiry

    return sdk;

  } catch (error) {
    console.error('Failed to initialize:', error);
    throw error;
  }
}

function logout(sdk) {
  // Clear persisted session on logout
  sdk.session.unpersist();
  console.log('Session cleared');
}

// Initialize
const sdk = await initializeVerification();

// Later, on logout
logout(sdk);

const expirationEpoch = sdk.session.getExpirationEpoch();
const timeLeft = (expirationEpoch * 1000) - Date.now();
const fiveMinutes = 5 * 60 * 1000;

if (timeLeft < 0) {
  // Already expired — the user must start over
  showMessage('Your session has expired. Please start the verification process again.');
  redirectToStart();
} else if (timeLeft < fiveMinutes) {
  // Expiring soon — warn the user
  showWarning(`Your session will expire in ${Math.floor(timeLeft / 60000)} minutes.`);
}

try {
  const sdk = await OneSdk({
    session: { token: 'token', persist: true }
  });
} catch (error) {
  if (error.message.includes('storage')) {
    console.warn('Session persistence not available');
    // Fall back to non-persistent mode
  }
}