# For web applications
npm install @smarterservices/iam-client

# For React applications
npm install @smarterservices/iam-react

# For Node.js services
npm install @smarterservices/iam-node

import { IamClient } from '@smarterservices/iam-client';

const iam = new IamClient({
  apiUrl: 'https://iam.smarterservices.com',
  token: 'your-auth-token'
});

import { IamProvider } from '@smarterservices/iam-react';

function App() {
  return (
    <IamProvider
      apiUrl="https://iam.smarterservices.com"
      token={authToken}
    >
      <YourApp />
    </IamProvider>
  );
}

const { IamService } = require('@smarterservices/iam-node');

const iam = new IamService({
  apiUrl: 'https://iam.smarterservices.com',
  serviceKey: 'your-service-key'
});

const canDelete = await iam.authorize(
  'sp:DeleteSession',
  'ssrn:ss:sp::578:session/ES123456'
);

if (canDelete) {
  // User has permission to delete the session
  deleteSession();
} else {
  // Show access denied message
  showAccessDenied();
}

import { IamProtected } from '@smarterservices/iam-react';

function DeleteButton({ sessionId }) {
  return (
    <IamProtected 
      action="sp:DeleteSession" 
      resource={`ssrn:ss:sp::578:session/${sessionId}`}
    >
      <button onClick={handleDelete}>
        Delete Session
      </button>
    </IamProtected>
  );
}

const permissions = await iam.authorizeMultiple([
  { action: 'sp:ReadSession', resource: 'ssrn:ss:sp::578:session/ES123456' },
  { action: 'sp:UpdateSession', resource: 'ssrn:ss:sp::578:session/ES123456' },
  { action: 'sp:DeleteSession', resource: 'ssrn:ss:sp::578:session/ES123456' }
]);

const { canRead, canUpdate, canDelete } = permissions;

// Check if student can take an assessment
const canTakeAssessment = await iam.authorize(
  'sm:TakeAssessment',
  'ssrn:ss:sm::578:assessment/AS123456'
);

// Check if instructor can view student results
const canViewResults = await iam.authorize(
  'sm:ViewResults',
  'ssrn:ss:sm::578:user/student123/results'
);

// Check if proctor can monitor a session
const canMonitor = await iam.authorize(
  'sp:MonitorSession',
  'ssrn:ss:sp::578:session/ES123456'
);

// Check if user has admin privileges
const isAdmin = await iam.authorize(
  'platform:AdminAccess',
  'ssrn:ss:platform::578:admin'
);

try {
  const authorized = await iam.authorize(action, resource);
  
  if (authorized) {
    // Proceed with action
    performAction();
  } else {
    // Show user-friendly message
    showMessage('You do not have permission to perform this action');
  }
} catch (error) {
  if (error.code === 'NETWORK_ERROR') {
    showMessage('Unable to verify permissions. Please try again.');
  } else if (error.code === 'INVALID_TOKEN') {
    // Redirect to login
    redirectToLogin();
  } else {
    console.error('IAM error:', error);
    showMessage('Permission check failed');
  }
}

const iam = new IamClient({
  apiUrl: 'https://iam.smarterservices.com',
  token: 'your-auth-token',
  cache: {
    enabled: true,
    ttl: 300, // 5 minutes
    maxSize: 1000
  }
});

const iam = new IamClient({
  apiUrl: 'https://iam.smarterservices.com',
  token: 'your-auth-token',
  timeout: 5000, // 5 seconds
  retries: 3
});

// Helper function for building resource strings
const buildSessionResource = (accountId, sessionId) => {
  return `ssrn:ss:sp::${accountId}:session/${sessionId}`;
};

// Usage
const resource = buildSessionResource('578', 'ES123456');
const canRead = await iam.authorize('sp:ReadSession', resource);

// Cache permissions for better performance
const permissionCache = new Map();

async function checkCachedPermission(action, resource) {
  const key = `${action}:${resource}`;
  
  if (permissionCache.has(key)) {
    return permissionCache.get(key);
  }
  
  const result = await iam.authorize(action, resource);
  permissionCache.set(key, result);
  
  // Clear cache after 5 minutes
  setTimeout(() => permissionCache.delete(key), 300000);
  
  return result;
}

// Load all permissions for a user session at once
async function loadUserPermissions(userId, accountId) {
  const permissions = await iam.authorizeMultiple([
    { action: 'sm:ReadUser', resource: `ssrn:ss:sm::${accountId}:user/${userId}` },
    { action: 'sm:UpdateUser', resource: `ssrn:ss:sm::${accountId}:user/${userId}` },
    { action: 'sm:TakeAssessment', resource: `ssrn:ss:sm::${accountId}:assessment/*` },
    { action: 'sp:ViewSessions', resource: `ssrn:ss:sp::${accountId}:session/*` }
  ]);
  
  return permissions;
}

const iam = new IamClient({
  apiUrl: 'https://iam.smarterservices.com',
  token: 'your-auth-token',
  debug: true // Enable debug logging
});

// Verify IAM service is available
const isHealthy = await iam.healthCheck();
if (!isHealthy) {
  console.warn('IAM service is unavailable');
}