Add OAuth2 token management and storage implementation

workers/main/src/services/OAuth2/FileTokenStorage.ts

@@ -0,0 +1,72 @@
+import { promises as fs } from 'fs';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+import { TokenStorageProvider } from './IOAuth2TokenManager';
+import { TokenData } from './types';
+
+export class FileTokenStorage implements TokenStorageProvider {
+  private readonly tokenFilePath: string;
+  private readonly serviceName: string;
+
+  constructor(serviceName: string = 'qbo', tokenFilePath?: string) {
+    this.serviceName = serviceName;
+    this.tokenFilePath =
+      tokenFilePath ||
+      join(process.cwd(), 'data', 'oauth2_tokens', `${serviceName}.json`);
+  }
+
+  async save(tokenData: TokenData): Promise<void> {
+    try {
+      const dir = join(this.tokenFilePath, '..');
+
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(
+        this.tokenFilePath,
+        JSON.stringify(tokenData, null, 2),
+      );
+    } catch {
+      throw new Error('Failed to save token data to file');
+    }
+  }
+
+  load(): TokenData | null {
+    try {
+      const data = readFileSync(this.tokenFilePath, 'utf8');
+      const tokenData = JSON.parse(data) as TokenData;
+
+      if (!this.isValidTokenData(tokenData)) {
+        return null;
+      }
+
+      return tokenData;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        return null;
+      }
+
+      return null;
+    }
+  }
+
+  async clear(): Promise<void> {
+    try {
+      await fs.unlink(this.tokenFilePath);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw new Error('Failed to clear token data from file');
+      }
+    }
+  }
+
+  private isValidTokenData(data: unknown): data is TokenData {
+    return (
+      typeof data === 'object' &&
+      data !== null &&
+      typeof (data as TokenData).access_token === 'string' &&
+      typeof (data as TokenData).refresh_token === 'string' &&
+      typeof (data as TokenData).expires_at === 'number' &&
+      typeof (data as TokenData).token_type === 'string'
+    );
+  }
+}

workers/main/src/services/OAuth2/IOAuth2TokenManager.ts

@@ -0,0 +1,61 @@
+import { TokenData } from './types';
+
+/**
+ * Interface for token storage providers
+ * Handles saving and loading token data to/from persistent storage
+ */
+export interface TokenStorageProvider {
+  /**
+   * Save token data to storage
+   * @param tokenData - The token data to save
+   */
+  save(tokenData: TokenData): Promise<void>;
+
+  /**
+   * Load token data from storage
+   * @returns TokenData if available, null otherwise
+   */
+  load(): TokenData | null;
+
+  /**
+   * Clear stored token data
+   */
+  clear(): Promise<void>;
+}
+
+/**
+ * Interface for token refresh providers
+ * Handles refreshing access tokens using refresh tokens
+ */
+export interface TokenRefreshProvider {
+  /**
+   * Refresh access token using refresh token
+   * @param refreshToken - The refresh token to use
+   * @returns Promise resolving to new TokenData
+   */
+  refreshToken(refreshToken: string): Promise<TokenData>;
+}
+
+/**
+ * Interface for OAuth2 token manager
+ * Main interface for token management operations
+ */
+export interface IOAuth2TokenManager {
+  /**
+   * Get a valid access token, refreshing if necessary
+   * @returns Promise resolving to access token string
+   */
+  getAccessToken(): Promise<string>;
+
+  /**
+   * Get the current refresh token
+   * @returns refresh token string
+   */
+  getCurrentRefreshToken(): string;
+
+  /**
+   * Check if current token is valid
+   * @returns boolean indicating if token is valid
+   */
+  isTokenValid(): boolean;
+}

workers/main/src/services/OAuth2/OAuth2TokenManager.test.ts

@@ -0,0 +1,108 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { OAuth2TokenManager } from './OAuth2TokenManager';
+import { TokenData } from './types';
+
+vi.mock('./FileTokenStorage', () => ({
+  FileTokenStorage: vi.fn().mockImplementation(() => ({
+    save: vi.fn().mockResolvedValue(undefined),
+    load: vi.fn().mockReturnValue(null),
+    clear: vi.fn().mockResolvedValue(undefined),
+  })),
+}));
+
+vi.mock('./OAuth2TokenRefreshProvider', () => ({
+  OAuth2TokenRefreshProvider: vi.fn().mockImplementation(() => ({
+    refreshToken: vi.fn().mockResolvedValue({
+      access_token: 'new-access-token',
+      refresh_token: 'new-refresh-token',
+      expires_at: Date.now() + 3600000,
+      token_type: 'Bearer',
+    }),
+  })),
+}));
+
+vi.mock('../../configs/qbo', () => ({
+  qboConfig: {
+    clientId: 'test-client-id',
+    clientSecret: 'test-client-secret',
+    refreshToken: 'test-refresh-token',
+    tokenUrl: 'https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer',
+  },
+}));
+
+describe('OAuth2TokenManager', () => {
+  let tokenManager: OAuth2TokenManager;
+
+  beforeEach(() => {
+    tokenManager = new OAuth2TokenManager('qbo', 'test-refresh-token');
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create OAuth2TokenManager instance', () => {
+      expect(tokenManager).toBeInstanceOf(OAuth2TokenManager);
+    });
+
+    it('should create OAuth2TokenManager with custom service name', () => {
+      const customTokenManager = new OAuth2TokenManager(
+        'custom-service',
+        'custom-refresh-token',
+      );
+
+      expect(customTokenManager).toBeInstanceOf(OAuth2TokenManager);
+    });
+  });
+
+  describe('isTokenValid', () => {
+    it('should return false when no token is set', () => {
+      expect(tokenManager.isTokenValid()).toBe(false);
+    });
+
+    it('should return false when token is expired', () => {
+      const expiredTokenData: TokenData = {
+        access_token: 'expired-token',
+        refresh_token: 'refresh-token',
+        expires_at: Date.now() - 3600000,
+        token_type: 'Bearer',
+      };
+
+      const setTokenData = (
+        tokenManager as unknown as { setTokenData: (data: TokenData) => void }
+      ).setTokenData.bind(tokenManager);
+
+      setTokenData(expiredTokenData);
+
+      expect(tokenManager.isTokenValid()).toBe(false);
+    });
+
+    it('should return true when token is valid', () => {
+      const validTokenData: TokenData = {
+        access_token: 'valid-token',
+        refresh_token: 'refresh-token',
+        expires_at: Date.now() + 3600000,
+        token_type: 'Bearer',
+      };
+
+      const setTokenData = (
+        tokenManager as unknown as { setTokenData: (data: TokenData) => void }
+      ).setTokenData.bind(tokenManager);
+
+      setTokenData(validTokenData);
+
+      expect(tokenManager.isTokenValid()).toBe(true);
+    });
+  });
+
+  describe('getCurrentRefreshToken', () => {
+    it('should return refresh token from config when no cached token', async () => {
+      const refreshToken = tokenManager.getCurrentRefreshToken();
+
+      expect(refreshToken).toBe('test-refresh-token');
+    });
+  });
+});