New in v0.3.0

import { TokenType } from '@snackbase/sdk';

enum TokenType {
  ACCESS = 'access',
  REFRESH = 'refresh',
  API_KEY = 'api_key',
}

interface User {
  id: string;
  email: string;
  // ... other fields
  token_type?: TokenType; // NEW: Type of token being used
}

const auth = client.auth;

// Check if current session is a superadmin
if (auth.isSuperadmin()) {
  console.log('Logged in as superadmin');
}

// Check if authenticated via API key
if (auth.isApiKeySession()) {
  console.log('Using API key authentication');
}

// Check if authenticated via access token
if (auth.isAccessTokenSession()) {
  console.log('Using access token authentication');
}

import { ApiKeyRestrictedError, EmailVerificationRequiredError } from '@snackbase/sdk';

try {
  await client.records.create('posts', data);
} catch (error) {
  if (error instanceof ApiKeyRestrictedError) {
    // API key doesn't have permission for this operation
    console.error('API key is restricted from this action');
  } else if (error instanceof EmailVerificationRequiredError) {
    // User must verify email before proceeding
    console.error('Please verify your email first');
  }
}

sb_ak_base64payload

sb_ak.payload.signature

// Before (v0.2.x)
if (client.user && client.apiKey) {
  // Has both user and API key
}

// After (v0.3.0) - More explicit
if (client.auth.isApiKeySession()) {
  // Definitely using API key auth
} else if (client.isAuthenticated) {
  // Using user authentication
}

try {
  await client.records.create('posts', data);
} catch (error) {
  if (error instanceof ApiKeyRestrictedError) {
    // Handle restricted API key
    alert('Your API key does not have permission to create posts');
  } else if (error instanceof EmailVerificationRequiredError) {
    // Handle unverified email
    await client.auth.sendVerificationEmail();
    alert('Please check your email for a verification link');
  } else {
    // Handle other errors as before
    throw error;
  }
}

const user = client.user;
if (user) {
  switch (user.token_type) {
    case TokenType.ACCESS:
      console.log('Authenticated with access token');
      break;
    case TokenType.REFRESH:
      console.log('Authenticated with refresh token');
      break;
    case TokenType.API_KEY:
      console.log('Authenticated with API key');
      break;
  }
}

const apiKey = await client.apiKeys.create({
  name: 'Production API Key',
});

console.log(apiKey.key); // sb_ak.payload.signature (new format)

// Show different UI based on authentication method
if (client.auth.isSuperadmin()) {
  // Show superadmin controls
  renderSuperAdminPanel();
} else if (client.auth.isApiKeySession()) {
  // API keys have limited permissions
  renderApiKeyWarning();
  renderLimitedControls();
} else {
  // Regular user session
  renderUserPanel();
}

import { EmailVerificationRequiredError } from '@snackbase/sdk';

async function createPost(data) {
  try {
    return await client.records.create('posts', data);
  } catch (error) {
    if (error instanceof EmailVerificationRequiredError) {
      // Send verification email
      await client.auth.sendVerificationEmail();

      // Show message to user
      showVerificationModal();
      return null;
    }
    throw error;
  }
}

import { ApiKeyRestrictedError } from '@snackbase/sdk';

async function adminOperation() {
  try {
    return await client.accounts.delete(accountId);
  } catch (error) {
    if (error instanceof ApiKeyRestrictedError) {
      console.error('This operation requires a user session or admin API key');
      return null;
    }
    throw error;
  }
}