Authentication

curl -X POST https://dev.api.baanx.com/v1/auth/login \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "[email protected]",
    "password": "SecurePassword123!"
  }'

curl -X POST https://dev.api.baanx.com/v1/auth/login/otp \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "userId": "b6b9168c-bb56-4c6a-9c0d-4650ea74f5f9"
  }'

curl -X POST https://dev.api.baanx.com/v1/auth/login \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "[email protected]",
    "password": "SecurePassword123!",
    "otpCode": "123456"
  }'

class AuthService {
  private apiBase = 'https://dev.api.baanx.com';
  private clientKey = 'YOUR_CLIENT_KEY';

  async login(email: string, password: string): Promise<LoginResponse> {
    const response = await fetch(`${this.apiBase}/v1/auth/login`, {
      method: 'POST',
      headers: {
        'x-client-key': this.clientKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ email, password })
    });

    if (!response.ok) {
      throw new Error(`Login failed: ${response.statusText}`);
    }

    return response.json();
  }

  async sendOtpCode(userId: string): Promise<void> {
    const response = await fetch(`${this.apiBase}/v1/auth/login/otp`, {
      method: 'POST',
      headers: {
        'x-client-key': this.clientKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ userId })
    });

    if (!response.ok) {
      throw new Error('Failed to send OTP code');
    }
  }

  async loginWithOtp(
    email: string,
    password: string,
    otpCode: string
  ): Promise<string> {
    const response = await fetch(`${this.apiBase}/v1/auth/login`, {
      method: 'POST',
      headers: {
        'x-client-key': this.clientKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ email, password, otpCode })
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.message || 'OTP login failed');
    }

    const data = await response.json();
    return data.accessToken;
  }

  async handleLogin(email: string, password: string): Promise<string> {
    const loginResult = await this.login(email, password);

    if (loginResult.isOtpRequired) {
      console.log('OTP required. Sending code to:', loginResult.phoneNumber);
      await this.sendOtpCode(loginResult.userId);

      const otpCode = await this.promptUserForOtpCode();

      return await this.loginWithOtp(email, password, otpCode);
    }

    return loginResult.accessToken;
  }

  private async promptUserForOtpCode(): Promise<string> {
    return new Promise((resolve) => {
      console.log('Please enter the OTP code:');
    });
  }
}

interface LoginResponse {
  accessToken: string;
  userId: string;
  isOtpRequired: boolean;
  phoneNumber?: string;
  verificationState: string;
}

const authService = new AuthService();

authService.handleLogin('[email protected]', 'SecurePassword123!')
  .then(accessToken => {
    console.log('Login successful! Token:', accessToken);
    localStorage.setItem('accessToken', accessToken);
  })
  .catch(error => {
    console.error('Login failed:', error);
  });

curl -X POST https://dev.api.baanx.com/v1/auth/logout \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Authorization: Bearer US_b6b9168a-bb56-4c6a-9c0d-4650ea74f5f9"

class AuthManager {
  private apiBase: string;
  private clientKey: string;
  private tokenKey = 'accessToken';
  private tokenTimeKey = 'tokenIssuedAt';

  constructor(apiBase: string, clientKey: string) {
    this.apiBase = apiBase;
    this.clientKey = clientKey;
  }

  private get headers() {
    return {
      'x-client-key': this.clientKey,
      'Content-Type': 'application/json'
    };
  }

  private get authHeaders() {
    const token = this.getToken();
    return {
      ...this.headers,
      'Authorization': `Bearer ${token}`
    };
  }

  async login(email: string, password: string): Promise<string> {
    try {
      const response = await fetch(`${this.apiBase}/v1/auth/login`, {
        method: 'POST',
        headers: this.headers,
        body: JSON.stringify({ email, password })
      });

      if (!response.ok) {
        throw new Error('Login failed');
      }

      const data = await response.json();

      if (data.isOtpRequired) {
        await this.sendOtpCode(data.userId);
        const otpCode = await this.getOtpFromUser();
        return await this.loginWithOtp(email, password, otpCode);
      }

      this.storeToken(data.accessToken);
      return data.accessToken;
    } catch (error) {
      console.error('Login error:', error);
      throw error;
    }
  }

  async sendOtpCode(userId: string): Promise<void> {
    const response = await fetch(`${this.apiBase}/v1/auth/login/otp`, {
      method: 'POST',
      headers: this.headers,
      body: JSON.stringify({ userId })
    });

    if (!response.ok) {
      throw new Error('Failed to send OTP');
    }
  }

  async loginWithOtp(
    email: string,
    password: string,
    otpCode: string
  ): Promise<string> {
    const response = await fetch(`${this.apiBase}/v1/auth/login`, {
      method: 'POST',
      headers: this.headers,
      body: JSON.stringify({ email, password, otpCode })
    });

    if (!response.ok) {
      throw new Error('OTP verification failed');
    }

    const data = await response.json();
    this.storeToken(data.accessToken);
    return data.accessToken;
  }

  async logout(): Promise<void> {
    try {
      await fetch(`${this.apiBase}/v1/auth/logout`, {
        method: 'POST',
        headers: this.authHeaders
      });
    } finally {
      this.clearToken();
    }
  }

  storeToken(token: string): void {
    localStorage.setItem(this.tokenKey, token);
    localStorage.setItem(this.tokenTimeKey, Date.now().toString());
  }

  getToken(): string | null {
    const token = localStorage.getItem(this.tokenKey);
    if (!token) return null;

    if (!this.isTokenValid()) {
      this.clearToken();
      return null;
    }

    return token;
  }

  clearToken(): void {
    localStorage.removeItem(this.tokenKey);
    localStorage.removeItem(this.tokenTimeKey);
  }

  isTokenValid(): boolean {
    const issuedAt = localStorage.getItem(this.tokenTimeKey);
    if (!issuedAt) return false;

    const SIX_HOURS_MS = 6 * 60 * 60 * 1000;
    const elapsed = Date.now() - parseInt(issuedAt);
    return elapsed < SIX_HOURS_MS;
  }

  isAuthenticated(): boolean {
    return this.getToken() !== null;
  }

  private async getOtpFromUser(): Promise<string> {
    return prompt('Enter OTP code:') || '';
  }
}

const authManager = new AuthManager(
  'https://dev.api.baanx.com',
  'YOUR_CLIENT_KEY'
);

authManager.login('[email protected]', 'SecurePassword123!')
  .then(() => console.log('Login successful'))
  .catch(error => console.error('Login failed:', error));