Income verification

import { GraphQLClient, gql } from 'graphql-request';

const CREATE_TRUV_BRIDGE_TOKEN = gql`
  mutation CreateTruvBridgeToken($input: CreateInitializationTokenInput!) {
    verify {
      createInitializationToken(input: $input) {
        ... on TruvBridgeToken {
          bridgeToken
        }
      }
    }
  }
`;

const EXCHANGE_TRUV_TOKEN = gql`
  mutation ExchangeTruvToken($input: ExchangePublicTokenInput!) {
    verify {
      exchangePublicToken(input: $input) {
        ... on TruvLinkAccess {
          linkId
        }
      }
    }
  }
`;

const client = new GraphQLClient('https://api.pylon.mortgage/graphql', {
  headers: {
    Authorization: `Bearer ${process.env.PYLON_API_KEY}`,
  },
});

/**
 * Step 1: request a Truv bridge token for a borrower.
 * Hand the returned bridgeToken to the Truv Bridge widget in your frontend.
 */
async function createTruvBridgeToken(borrowerId: string): Promise<string> {
  const data = await client.request<{
    verify: { createInitializationToken: { bridgeToken: string } };
  }>(CREATE_TRUV_BRIDGE_TOKEN, {
    input: { vendor: 'TRUV', borrowerId },
  });

  return data.verify.createInitializationToken.bridgeToken;
}

/**
 * Step 4: exchange the public token returned by the Truv Bridge onSuccess callback.
 * The taskId comes from the onSuccess metadata; employerName is optional.
 */
async function exchangeTruvToken(params: {
  borrowerId: string;
  publicToken: string;
  taskId: string;
  employerName?: string;
}): Promise<string> {
  const data = await client.request<{
    verify: { exchangePublicToken: { linkId: string } };
  }>(EXCHANGE_TRUV_TOKEN, {
    input: {
      vendor: 'TRUV',
      publicToken: params.publicToken,
      borrowerId: params.borrowerId,
      truvMetadata: {
        taskId: params.taskId,
        employerName: params.employerName,
      },
    },
  });

  return data.verify.exchangePublicToken.linkId;
}

// Example usage
// 1. Server: mint a bridge token and send it to the browser
const bridgeToken = await createTruvBridgeToken('borrower-123');

// 2. Frontend: initialize Truv Bridge with `bridgeToken`. On success the widget
//    returns a public token and metadata containing a task_id.

// 3. Server: finalize the connection. Pylon then pulls the VOIE report and maps
//    income entities asynchronously; poll for `verifiedAmount` afterward.
const linkId = await exchangeTruvToken({
  borrowerId: 'borrower-123',
  publicToken: '<public_token from onSuccess>',
  taskId: '<task_id from onSuccess metadata>',
  employerName: 'Acme Corp',
});

query GetVerifiedIncomes($loanId: ID!) {
  loan(id: $loanId) {
    borrowers(first: 10) {
      edges {
        node {
          id
          firstName
          lastName
          incomes(first: 100) {
            edges {
              node {
                id
                __typename
                statedMonthlyAmount
                verifiedAmount
                voieReportId
                ... on StandardEmploymentIncome {
                  employment {
                    ... on StandardEmployment {
                      employer {
                        name
                      }
                    }
                  }
                }
              }
            }
            pageInfo {
              hasNextPage
              endCursor
            }
          }
        }
      }
    }
  }
}

import { GraphQLClient } from 'graphql-request';

const GET_VERIFIED_INCOMES = `
  query GetVerifiedIncomes($loanId: ID!) {
    loan(id: $loanId) {
      borrowers(first: 10) {
        edges {
          node {
            id
            firstName
            lastName
            incomes(first: 100) {
              edges {
                node {
                  id
                  __typename
                  statedMonthlyAmount
                  verifiedAmount
                  ... on StandardEmploymentIncome {
                    employment {
                      ... on StandardEmployment {
                        employer {
                          name
                        }
                      }
                    }
                  }
                }
              }
              pageInfo {
                hasNextPage
                endCursor
              }
            }
          }
        }
      }
    }
  }
`;

interface IncomeNode {
  id: string;
  __typename: string;
  statedMonthlyAmount: number | null;
  verifiedAmount: number | null;
  employment?: {
    employer?: {
      name: string;
    };
  };
}

interface BorrowerNode {
  id: string;
  firstName: string;
  lastName: string;
  incomes: {
    edges: Array<{
      node: IncomeNode;
    }>;
    pageInfo: {
      hasNextPage: boolean;
      endCursor: string | null;
    };
  };
}

interface LoanData {
  loan: {
    borrowers: {
      edges: Array<{
        node: BorrowerNode;
      }>;
    };
  };
}

/**
 * Polls for verified income values for a given loan
 * @param client - GraphQL client configured with your Pylon API endpoint and auth
 * @param loanId - The ID of the loan to check
 * @param maxAttempts - Maximum number of polling attempts (default: 30)
 * @param intervalMs - Polling interval in milliseconds (default: 2000)
 * @returns Promise resolving to verified incomes or null if verification not available
 */
async function pollForVerifiedIncomes(
  client: GraphQLClient,
  loanId: string,
  maxAttempts: number = 30,
  intervalMs: number = 2000
): Promise<IncomeNode[] | null> {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const data = await client.request<LoanData>(GET_VERIFIED_INCOMES, {
      loanId,
    });

    const allIncomes: IncomeNode[] = [];
    
    // Collect all incomes from all borrowers
    for (const borrowerEdge of data.loan.borrowers.edges) {
      const borrower = borrowerEdge.node;
      
      for (const incomeEdge of borrower.incomes.edges) {
        const income = incomeEdge.node;
        allIncomes.push(income);
        
        // Check if this income has been verified
        if (income.verifiedAmount !== null && income.verifiedAmount > 0) {
          console.log(
            `✓ Income verified for ${borrower.firstName} ${borrower.lastName}: ` +
            `$${income.verifiedAmount}/month (${income.__typename})`
          );
        }
      }
    }

    // Check if any incomes have been verified
    const verifiedIncomes = allIncomes.filter(
      (income) => income.verifiedAmount !== null && income.verifiedAmount > 0
    );

    if (verifiedIncomes.length > 0) {
      return verifiedIncomes;
    }

    // If no verified incomes yet, wait before next attempt
    if (attempt < maxAttempts - 1) {
      console.log(
        `No verified incomes yet (attempt ${attempt + 1}/${maxAttempts}). ` +
        `Polling again in ${intervalMs}ms...`
      );
      await new Promise((resolve) => setTimeout(resolve, intervalMs));
    }
  }

  console.log('Income verification not available after maximum attempts');
  return null;
}

// Example usage
const client = new GraphQLClient('https://api.pylon.mortgage/graphql', {
  headers: {
    Authorization: `Bearer ${process.env.PYLON_API_KEY}`,
  },
});

// Poll for verified incomes
pollForVerifiedIncomes(client, 'loan-123')
  .then((verifiedIncomes) => {
    if (verifiedIncomes) {
      console.log(`Found ${verifiedIncomes.length} verified income(s)`);
      // Use verified income data for your application logic
    } else {
      console.log('Income verification not available - fallback to traditional methods');
      // Fallback to requesting pay stubs, W-2s, etc.
    }
  })
  .catch((error) => {
    console.error('Error polling for verified incomes:', error);
  });