@dependabit/github-client 0.1.14 → 0.1.16

package/src/auth/basic.ts

@@ -1,102 +0,0 @@
-/**
- * Basic authentication handler for GitHub API
- * Supports username/password or username/personal access token
- */
-
-export interface BasicAuth {
-  type: 'basic';
-  username: string;
-  password: string;
-}
-
-/**
- * Handler for HTTP Basic authentication
- */
-export class BasicAuthHandler {
-  private username: string;
-  private password: string;
-
-  constructor(username: string, password: string) {
-    if (!username || username.trim() === '') {
-      throw new Error('Username cannot be empty');
-    }
-    if (!password || password.trim() === '') {
-      throw new Error('Password cannot be empty');
-    }
-    this.username = username;
-    this.password = password;
-  }
-
-  /**
-   * Authenticate and return auth object
-   */
-  async authenticate(): Promise<BasicAuth> {
-    return {
-      type: 'basic',
-      username: this.username,
-      password: this.password
-    };
-  }
-
-  /**
-   * Get base64-encoded Basic auth header value
-   */
-  getAuthHeader(): string {
-    const credentials = `${this.username}:${this.password}`;
-    const encoded = Buffer.from(credentials).toString('base64');
-    return `Basic ${encoded}`;
-  }
-
-  /**
-   * Validate credentials format
-   */
-  validate(): boolean {
-    // Check for invalid characters (newlines, etc.)
-    if (this.username.includes('\n') || this.username.includes('\r')) {
-      return false;
-    }
-    if (this.password.includes('\n') || this.password.includes('\r')) {
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * Get authentication type
-   */
-  getType(): string {
-    return 'basic';
-  }
-
-  /**
-   * Update credentials (for rotation)
-   */
-  updateCredentials(username: string, password: string): void {
-    if (!username || username.trim() === '') {
-      throw new Error('Username cannot be empty');
-    }
-    if (!password || password.trim() === '') {
-      throw new Error('Password cannot be empty');
-    }
-    this.username = username;
-    this.password = password;
-  }
-
-  /**
-   * String representation (masks password)
-   */
-  toString(): string {
-    return `BasicAuth(username=${this.username}, password=***)`;
-  }
-
-  /**
-   * JSON representation (excludes password)
-   */
-  toJSON(): Record<string, unknown> {
-    return {
-      type: 'basic',
-      username: this.username
-      // password intentionally excluded
-    };
-  }
-}

package/src/auth/oauth.ts

@@ -1,183 +0,0 @@
-/**
- * OAuth 2.0 authentication handler for GitHub
- * Supports authorization code flow and token refresh
- */
-
-export interface OAuthConfig {
-  clientId: string;
-  clientSecret: string;
-  redirectUri: string;
-}
-
-export interface OAuthAuth {
-  type: 'oauth';
-  token: string;
-  tokenType: string;
-  scope?: string | undefined;
-  expiresIn?: number | undefined;
-  refreshToken?: string | undefined;
-}
-
-interface TokenResponse {
-  access_token: string;
-  token_type: string;
-  scope?: string;
-  expires_in?: number;
-  refresh_token?: string;
-}
-
-/**
- * Handler for OAuth 2.0 authentication
- */
-export class OAuthHandler {
-  private config: OAuthConfig;
-  private readonly GITHUB_OAUTH_URL = 'https://github.com/login/oauth';
-
-  constructor(config: OAuthConfig) {
-    if (!config.clientId || config.clientId.trim() === '') {
-      throw new Error('clientId is required');
-    }
-    if (!config.clientSecret || config.clientSecret.trim() === '') {
-      throw new Error('clientSecret is required');
-    }
-    this.config = config;
-  }
-
-  /**
-   * Exchange authorization code for access token
-   */
-  async authenticate(code: string): Promise<OAuthAuth> {
-    if (!code || code.trim() === '') {
-      throw new Error('Authorization code is required');
-    }
-
-    const tokenResponse = await this.exchangeCodeForToken(code);
-
-    return {
-      type: 'oauth',
-      token: tokenResponse.access_token,
-      tokenType: tokenResponse.token_type,
-      scope: tokenResponse.scope,
-      expiresIn: tokenResponse.expires_in,
-      refreshToken: tokenResponse.refresh_token
-    };
-  }
-
-  /**
-   * Generate authorization URL for OAuth flow
-   */
-  getAuthorizationUrl(scopes: string[], state?: string): string {
-    const params = new URLSearchParams({
-      client_id: this.config.clientId,
-      redirect_uri: this.config.redirectUri,
-      scope: scopes.join(' ')
-    });
-
-    if (state) {
-      params.append('state', state);
-    }
-
-    return `${this.GITHUB_OAUTH_URL}/authorize?${params.toString()}`;
-  }
-
-  /**
-   * Refresh an expired access token
-   */
-  async refreshToken(refreshToken: string): Promise<OAuthAuth> {
-    if (!refreshToken || refreshToken.trim() === '') {
-      throw new Error('Refresh token is required');
-    }
-
-    const tokenResponse = await this.performTokenRefresh(refreshToken);
-
-    return {
-      type: 'oauth',
-      token: tokenResponse.access_token,
-      tokenType: tokenResponse.token_type,
-      scope: tokenResponse.scope,
-      expiresIn: tokenResponse.expires_in
-    };
-  }
-
-  /**
-   * Validate OAuth configuration
-   */
-  validate(): boolean {
-    try {
-      // Validate redirect URI format
-      new URL(this.config.redirectUri);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Get authentication type
-   */
-  getType(): string {
-    return 'oauth';
-  }
-
-  /**
-   * Exchange authorization code for token (internal)
-   */
-  private async exchangeCodeForToken(code: string): Promise<TokenResponse> {
-    const response = await fetch(`${this.GITHUB_OAUTH_URL}/access_token`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Accept: 'application/json'
-      },
-      body: JSON.stringify({
-        client_id: this.config.clientId,
-        client_secret: this.config.clientSecret,
-        code: code,
-        redirect_uri: this.config.redirectUri
-      })
-    });
-
-    if (!response.ok) {
-      throw new Error(`Failed to exchange code for token: ${response.statusText}`);
-    }
-
-    const data = await response.json();
-
-    if (data.error) {
-      throw new Error(data.error_description || data.error);
-    }
-
-    return data;
-  }
-
-  /**
-   * Perform token refresh (internal)
-   */
-  private async performTokenRefresh(refreshToken: string): Promise<TokenResponse> {
-    const response = await fetch(`${this.GITHUB_OAUTH_URL}/access_token`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Accept: 'application/json'
-      },
-      body: JSON.stringify({
-        client_id: this.config.clientId,
-        client_secret: this.config.clientSecret,
-        grant_type: 'refresh_token',
-        refresh_token: refreshToken
-      })
-    });
-
-    if (!response.ok) {
-      throw new Error(`Failed to refresh token: ${response.statusText}`);
-    }
-
-    const data = await response.json();
-
-    if (data.error) {
-      throw new Error(data.error_description || data.error);
-    }
-
-    return data;
-  }
-}

package/src/auth/token.ts

@@ -1,81 +0,0 @@
-/**
- * Token authentication handler for GitHub API
- * Supports GitHub PAT tokens, fine-grained tokens, and API keys
- */
-
-export interface TokenAuth {
-  type: 'token';
-  token: string;
-}
-
-/**
- * Handler for token-based authentication (GitHub PAT, API keys)
- */
-export class TokenAuthHandler {
-  private token: string;
-  private readonly GITHUB_TOKEN_PREFIXES = [
-    'ghp_', // Personal Access Token
-    'gho_', // OAuth Access Token
-    'ghu_', // User-to-Server Token
-    'ghs_', // Server-to-Server Token
-    'ghr_', // Refresh Token
-    'github_pat_' // Fine-grained PAT
-  ];
-
-  constructor(token: string) {
-    if (!token || token.trim() === '') {
-      throw new Error('Token cannot be empty');
-    }
-    this.token = token;
-  }
-
-  /**
-   * Authenticate and return auth object
-   */
-  async authenticate(): Promise<TokenAuth> {
-    return {
-      type: 'token',
-      token: this.token
-    };
-  }
-
-  /**
-   * Validate token format
-   */
-  validate(): boolean {
-    // Check if token starts with valid GitHub prefix or is an API key
-    const hasValidPrefix = this.GITHUB_TOKEN_PREFIXES.some((prefix) =>
-      this.token.startsWith(prefix)
-    );
-
-    // Allow any token format, but prefer GitHub token prefixes
-    return hasValidPrefix || this.token.length > 0;
-  }
-
-  /**
-   * Get authentication type
-   */
-  getType(): string {
-    return 'token';
-  }
-
-  /**
-   * Update token (for rotation)
-   */
-  updateToken(newToken: string): void {
-    if (!newToken || newToken.trim() === '') {
-      throw new Error('Token cannot be empty');
-    }
-    this.token = newToken;
-  }
-
-  /**
-   * Get current token
-   *
-   * @warning This method exposes the raw token value. Use with caution and avoid
-   * logging or displaying the token. Prefer using authenticate() for auth operations.
-   */
-  getToken(): string {
-    return this.token;
-  }
-}

package/src/auth.ts

@@ -1,100 +0,0 @@
-/**
- * Authentication support for GitHub API client
- * Provides token, OAuth, and basic authentication methods
- */
-
-import { TokenAuthHandler, type TokenAuth } from './auth/token.js';
-import { OAuthHandler, type OAuthAuth, type OAuthConfig } from './auth/oauth.js';
-import { BasicAuthHandler, type BasicAuth } from './auth/basic.js';
-
-export type AuthType = 'token' | 'oauth' | 'basic';
-export type AuthResult = TokenAuth | OAuthAuth | BasicAuth;
-
-export interface AuthConfig {
-  type: AuthType;
-  token?: string;
-  oauth?: OAuthConfig;
-  username?: string;
-  password?: string;
-}
-
-/**
- * Authentication manager that supports multiple auth methods
- */
-export class AuthManager {
-  private handler: TokenAuthHandler | OAuthHandler | BasicAuthHandler;
-
-  constructor(config: AuthConfig) {
-    switch (config.type) {
-      case 'token':
-        if (!config.token) {
-          throw new Error('Token is required for token authentication');
-        }
-        this.handler = new TokenAuthHandler(config.token);
-        break;
-
-      case 'oauth':
-        if (!config.oauth) {
-          throw new Error('OAuth config is required for OAuth authentication');
-        }
-        this.handler = new OAuthHandler(config.oauth);
-        break;
-
-      case 'basic':
-        if (!config.username || !config.password) {
-          throw new Error('Username and password are required for basic authentication');
-        }
-        this.handler = new BasicAuthHandler(config.username, config.password);
-        break;
-
-      default:
-        throw new Error(`Unsupported authentication type: ${config.type}`);
-    }
-  }
-
-  /**
-   * Perform authentication
-   */
-  async authenticate(code?: string): Promise<AuthResult> {
-    if (this.handler instanceof OAuthHandler && code) {
-      return this.handler.authenticate(code);
-    }
-    if (this.handler instanceof TokenAuthHandler || this.handler instanceof BasicAuthHandler) {
-      return this.handler.authenticate();
-    }
-    throw new Error('Invalid authentication flow');
-  }
-
-  /**
-   * Validate authentication configuration
-   */
-  validate(): boolean {
-    return this.handler.validate();
-  }
-
-  /**
-   * Get authentication type
-   */
-  getType(): string {
-    return this.handler.getType();
-  }
-
-  /**
-   * Get underlying handler
-   */
-  getHandler(): TokenAuthHandler | OAuthHandler | BasicAuthHandler {
-    return this.handler;
-  }
-}
-
-/**
- * Create authentication manager from config
- */
-export function createAuth(config: AuthConfig): AuthManager {
-  return new AuthManager(config);
-}
-
-// Re-export handler classes and types
-export { TokenAuthHandler, type TokenAuth } from './auth/token.js';
-export { OAuthHandler, type OAuthAuth, type OAuthConfig } from './auth/oauth.js';
-export { BasicAuthHandler, type BasicAuth } from './auth/basic.js';

package/src/client.test.ts

@@ -1,115 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { GitHubClient, createGitHubClient } from '../src/client.js';
-
-// Mock the octokit module
-vi.mock('octokit', () => {
-  const mockRateLimitGet = vi.fn().mockResolvedValue({
-    data: {
-      rate: {
-        limit: 5000,
-        remaining: 4900,
-        reset: Math.floor(Date.now() / 1000) + 3600,
-        used: 100
-      }
-    }
-  });
-
-  class MockOctokit {
-    rest = {
-      rateLimit: {
-        get: mockRateLimitGet
-      }
-    };
-  }
-
-  return {
-    Octokit: MockOctokit
-  };
-});
-
-describe('GitHubClient Tests', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('GitHubClient', () => {
-    it('should create client with default configuration', () => {
-      const client = new GitHubClient();
-      expect(client).toBeDefined();
-      expect(client.getOctokit()).toBeDefined();
-    });
-
-    it('should create client with authentication', () => {
-      const client = new GitHubClient({ auth: 'test-token' });
-      expect(client).toBeDefined();
-    });
-
-    it('should get rate limit information', async () => {
-      const client = new GitHubClient();
-      const rateLimit = await client.getRateLimit();
-
-      expect(rateLimit).toHaveProperty('limit');
-      expect(rateLimit).toHaveProperty('remaining');
-      expect(rateLimit).toHaveProperty('reset');
-      expect(rateLimit).toHaveProperty('used');
-      expect(rateLimit.limit).toBe(5000);
-      expect(rateLimit.remaining).toBe(4900);
-    });
-
-    it('should cache last rate limit check', async () => {
-      const client = new GitHubClient();
-      await client.getRateLimit();
-
-      const cached = client.getLastRateLimitCheck();
-      expect(cached).toBeDefined();
-      expect(cached?.limit).toBe(5000);
-    });
-
-    it('should check rate limit before requests', async () => {
-      const client = new GitHubClient();
-      await expect(client.checkRateLimit()).resolves.not.toThrow();
-    });
-
-    it('should throw error when rate limit is exceeded', async () => {
-      const client = new GitHubClient({ rateLimitMinRemaining: 10 });
-
-      // This test is tricky with mocks, so we'll test the behavior when remaining is low
-      // In a real scenario, this would wait or throw
-      const checkResult = client.checkRateLimit();
-
-      // Since our mock has 4900 remaining, this should not throw
-      await expect(checkResult).resolves.not.toThrow();
-    });
-
-    it('should execute function with rate limit checking', async () => {
-      const client = new GitHubClient();
-      const mockFn = vi.fn(async () => 'result');
-
-      const result = await client.withRateLimit(mockFn);
-
-      expect(result).toBe('result');
-      expect(mockFn).toHaveBeenCalled();
-    });
-
-    it('should respect custom rate limit thresholds', () => {
-      const client = new GitHubClient({
-        rateLimitWarningThreshold: 200,
-        rateLimitMinRemaining: 50
-      });
-
-      expect(client).toBeDefined();
-    });
-  });
-
-  describe('createGitHubClient', () => {
-    it('should create a client instance', () => {
-      const client = createGitHubClient();
-      expect(client).toBeInstanceOf(GitHubClient);
-    });
-
-    it('should accept configuration', () => {
-      const client = createGitHubClient({ auth: 'test-token' });
-      expect(client).toBeInstanceOf(GitHubClient);
-    });
-  });
-});

package/src/client.ts

@@ -1,109 +0,0 @@
-import { Octokit } from 'octokit';
-
-/**
- * Rate limit information
- */
-export interface RateLimitInfo {
-  limit: number;
-  remaining: number;
-  reset: number;
-  used: number;
-}
-
-/**
- * GitHub client configuration
- */
-export interface GitHubClientConfig {
-  auth?: string;
-  rateLimitWarningThreshold?: number; // Warn when remaining falls below this
-  rateLimitMinRemaining?: number; // Wait when remaining falls below this
-}
-
-/**
- * GitHub API client wrapper with rate limit handling
- */
-export class GitHubClient {
-  private octokit: Octokit;
-  private rateLimitWarningThreshold: number;
-  private rateLimitMinRemaining: number;
-  private lastRateLimitCheck?: RateLimitInfo;
-
-  constructor(config: GitHubClientConfig = {}) {
-    this.octokit = new Octokit({
-      auth: config.auth
-    });
-    this.rateLimitWarningThreshold = config.rateLimitWarningThreshold ?? 100;
-    this.rateLimitMinRemaining = config.rateLimitMinRemaining ?? 10;
-  }
-
-  /**
-   * Get current rate limit status
-   */
-  async getRateLimit(): Promise<RateLimitInfo> {
-    const response = await this.octokit.rest.rateLimit.get();
-    const core = response.data.rate;
-
-    const info: RateLimitInfo = {
-      limit: core.limit,
-      remaining: core.remaining,
-      reset: core.reset,
-      used: core.used
-    };
-
-    this.lastRateLimitCheck = info;
-    return info;
-  }
-
-  /**
-   * Check rate limit and throw if exceeded; log a warning when remaining is low.
-   */
-  async checkRateLimit(): Promise<void> {
-    const rateLimit = await this.getRateLimit();
-
-    if (rateLimit.remaining <= this.rateLimitMinRemaining) {
-      const resetTime = new Date(rateLimit.reset * 1000);
-      const waitMs = resetTime.getTime() - Date.now();
-
-      if (waitMs > 0) {
-        throw new Error(
-          `Rate limit exceeded. ${rateLimit.remaining} requests remaining. Reset at ${resetTime.toISOString()}`
-        );
-      }
-    }
-
-    if (rateLimit.remaining <= this.rateLimitWarningThreshold) {
-      console.warn(
-        `Rate limit warning: ${rateLimit.remaining}/${rateLimit.limit} requests remaining`
-      );
-    }
-  }
-
-  /**
-   * Execute a request with rate limit checking
-   */
-  async withRateLimit<T>(fn: () => Promise<T>): Promise<T> {
-    await this.checkRateLimit();
-    return fn();
-  }
-
-  /**
-   * Get the underlying Octokit instance
-   */
-  getOctokit(): Octokit {
-    return this.octokit;
-  }
-
-  /**
-   * Get last known rate limit info (cached)
-   */
-  getLastRateLimitCheck(): RateLimitInfo | undefined {
-    return this.lastRateLimitCheck;
-  }
-}
-
-/**
- * Create a GitHub client instance
- */
-export function createGitHubClient(config?: GitHubClientConfig): GitHubClient {
-  return new GitHubClient(config);
-}