OAuth Integration Example

import type { RequestPayload, VerifiedPayload } from "@gitcoin/passport-types";
import { ProviderExternalVerificationError, type Provider, type ProviderOptions } from "../../types.js";
import axios from "axios";
import { handleProviderAxiosError } from "../../utils/handleProviderAxiosError.js";
 
interface DevCommunityTokenResponse {
  access_token: string;
  token_type: string;
  expires_in: number;
  scope: string;
}
 
interface DevCommunityUser {
  id: string;
  username: string;
  email: string;
  email_verified: boolean;
  reputation: number;
  account_created: string;
  last_active: string;
  status: 'active' | 'suspended' | 'banned';
  profile: {
    bio?: string;
    location?: string;
    website?: string;
  };
  stats: {
    posts_count: number;
    answers_count: number;
    helpful_votes: number;
  };
}
 
export class DevCommunityProvider implements Provider {
  type = "DevCommunityReputation";
 
  constructor(options: ProviderOptions = {}) {
    // Initialize provider if needed
  }
 
  async verify(payload: RequestPayload): Promise<VerifiedPayload> {
    const errors: string[] = [];
    let valid = false;
    let record = undefined;
 
    try {
      // 1. Exchange OAuth code for access token
      const accessToken = await this.getAccessToken(payload.proofs.code);
      
      // 2. Fetch user data from DevCommunity API
      const userData = await this.getUserData(accessToken);
      
      // 3. Validate user meets all requirements
      const validation = this.validateUser(userData);
      
      if (!validation.valid) {
        return {
          valid: false,
          errors: validation.errors,
        };
      }
 
      // 4. Build verification record (no PII)
      record = {
        id: userData.id,
        username: userData.username,
        reputation: userData.reputation,
        accountAge: this.calculateAccountAge(userData.account_created),
        verificationLevel: this.getVerificationLevel(userData.reputation),
        verifiedAt: Date.now(),
      };
 
      return {
        valid: true,
        record: record,
        errors: undefined,
      };
    } catch (error) {
      throw new ProviderExternalVerificationError(
        `DevCommunity verification error: ${error.message}`
      );
    }
  }
 
  private async getAccessToken(code: string): Promise<string> {
    const clientId = process.env.DEVCOMMUNITY_CLIENT_ID;
    const clientSecret = process.env.DEVCOMMUNITY_CLIENT_SECRET;
    const redirectUri = process.env.DEVCOMMUNITY_CALLBACK;
 
    if (!clientId || !clientSecret || !redirectUri) {
      throw new Error("Missing DevCommunity OAuth configuration");
    }
 
    try {
      const response = await axios.post(
        "https://api.devcommunity.example.com/oauth2/token",
        {
          grant_type: "authorization_code",
          code: code,
          client_id: clientId,
          client_secret: clientSecret,
          redirect_uri: redirectUri,
        },
        {
          headers: {
            'Content-Type': 'application/json',
            'Accept': 'application/json',
            'User-Agent': 'HumanPassport/1.0',
          },
          timeout: 10000, // 10 second timeout
        }
      );
 
      const tokenData = response.data as DevCommunityTokenResponse;
      
      if (!tokenData.access_token) {
        throw new Error("No access token received");
      }
 
      return tokenData.access_token;
    } catch (error) {
      handleProviderAxiosError(error, "error requesting DevCommunity access token", [code]);
      throw error;
    }
  }
 
  private async getUserData(accessToken: string): Promise<DevCommunityUser> {
    try {
      const response = await axios.get(
        "https://api.devcommunity.example.com/user/profile",
        {
          headers: {
            'Authorization': `Bearer ${accessToken}`,
            'Accept': 'application/json',
            'User-Agent': 'HumanPassport/1.0',
          },
          timeout: 10000,
        }
      );
 
      const userData = response.data as DevCommunityUser;
      
      // Validate response structure
      if (!this.isValidUserResponse(userData)) {
        throw new Error("Invalid user data structure received");
      }
 
      return userData;
    } catch (error) {
      handleProviderAxiosError(error, "error fetching DevCommunity user data", []);
      throw error;
    }
  }
 
  private validateUser(userData: DevCommunityUser): { valid: boolean; errors?: string[] } {
    const errors: string[] = [];
 
    // 1. Email verification requirement
    if (!userData.email_verified) {
      errors.push("Email address must be verified on DevCommunity");
    }
 
    // 2. Reputation requirement
    const minReputation = 100;
    if (userData.reputation < minReputation) {
      errors.push(`Must have at least ${minReputation} reputation points (current: ${userData.reputation})`);
    }
 
    // 3. Account age requirement (30 days)
    const accountAge = this.calculateAccountAge(userData.account_created);
    const minAge = 30; // days
    if (accountAge < minAge) {
      errors.push(`Account must be at least ${minAge} days old (current: ${accountAge} days)`);
    }
 
    // 4. Account status requirement
    if (userData.status !== 'active') {
      errors.push("Account must be active and in good standing");
    }
 
    // 5. Minimum activity requirement
    const totalActivity = userData.stats.posts_count + userData.stats.answers_count;
    if (totalActivity < 10) {
      errors.push("Must have at least 10 posts or answers showing community participation");
    }
 
    // 6. Recent activity requirement (must be active within last 90 days)
    const lastActiveDate = new Date(userData.last_active);
    const daysSinceActive = Math.floor((Date.now() - lastActiveDate.getTime()) / (24 * 60 * 60 * 1000));
    if (daysSinceActive > 90) {
      errors.push("Account must have been active within the last 90 days");
    }
 
    return {
      valid: errors.length === 0,
      errors: errors.length > 0 ? errors : undefined,
    };
  }
 
  private calculateAccountAge(accountCreated: string): number {
    const createdDate = new Date(accountCreated);
    const now = new Date();
    const diffTime = now.getTime() - createdDate.getTime();
    return Math.floor(diffTime / (24 * 60 * 60 * 1000)); // Convert to days
  }
 
  private getVerificationLevel(reputation: number): string {
    if (reputation >= 1000) return 'expert';
    if (reputation >= 500) return 'advanced';
    if (reputation >= 100) return 'intermediate';
    return 'beginner';
  }
 
  private isValidUserResponse(data: any): data is DevCommunityUser {
    return (
      data &&
      typeof data.id === 'string' &&
      typeof data.username === 'string' &&
      typeof data.email_verified === 'boolean' &&
      typeof data.reputation === 'number' &&
      typeof data.account_created === 'string' &&
      typeof data.status === 'string' &&
      data.stats &&
      typeof data.stats.posts_count === 'number'
    );
  }
}

import { DevCommunityProvider } from "../Providers/devCommunity.js";
import { RequestPayload } from "@gitcoin/passport-types";
import axios from "axios";
 
jest.mock("axios");
const mockedAxios = axios as jest.Mocked<typeof axios>;
 
describe("DevCommunityProvider", () => {
  let provider: DevCommunityProvider;
 
  beforeEach(() => {
    provider = new DevCommunityProvider();
    jest.clearAllMocks();
    
    // Set environment variables for tests
    process.env.DEVCOMMUNITY_CLIENT_ID = "test_client_id";
    process.env.DEVCOMMUNITY_CLIENT_SECRET = "test_client_secret";
    process.env.DEVCOMMUNITY_CALLBACK = "http://localhost:3000/callback";
  });
 
  afterEach(() => {
    // Clean up environment variables
    delete process.env.DEVCOMMUNITY_CLIENT_ID;
    delete process.env.DEVCOMMUNITY_CLIENT_SECRET;
    delete process.env.DEVCOMMUNITY_CALLBACK;
  });
 
  const validPayload: RequestPayload = {
    address: "0x1234567890123456789012345678901234567890",
    proofs: { code: "valid_oauth_code" },
    type: "DevCommunityReputation",
    version: "0.0.0",
  };
 
  const mockValidUser = {
    id: "user123",
    username: "testdeveloper",
    email: "test@example.com",
    email_verified: true,
    reputation: 250,
    account_created: "2023-01-01T00:00:00Z",
    last_active: new Date().toISOString(),
    status: "active" as const,
    profile: {
      bio: "Full-stack developer",
      location: "San Francisco",
    },
    stats: {
      posts_count: 15,
      answers_count: 8,
      helpful_votes: 42,
    },
  };