Best Linear Phone Validation API & Email Verification Integration 2025

import { LinearClient } from '@linear/sdk';
import { ApolloClient, InMemoryCache, createHttpLink } from '@apollo/client';
import { setContext } from '@apollo/client/link/context';

// Linear client setup
const linearClient = new LinearClient({
  apiKey: process.env.LINEAR_API_KEY
});

// Apollo client for custom GraphQL operations
const httpLink = createHttpLink({
  uri: 'https://api.linear.app/graphql',
});

const authLink = setContext((_, { headers }) => {
  return {
    headers: {
      ...headers,
      authorization: `Bearer ${process.env.LINEAR_API_KEY}`,
    }
  }
});

const client = new ApolloClient({
  link: authLink.concat(httpLink),
  cache: new InMemoryCache()
});

class LinearValidationService {
  private lookupClient: LookupClient;
  private linearClient: LinearClient;

  constructor() {
    this.lookupClient = new LookupClient({
      apiKey: process.env.LOOKUP_API_KEY
    });
    this.linearClient = new LinearClient({
      apiKey: process.env.LINEAR_API_KEY
    });
  }

  async validateIssueContact(issueId: string, contact: ContactInfo) {
    const validation = await this.lookupClient.validate(contact);
    await this.updateIssueCustomFields(issueId, validation);
    return validation;
  }
}

mutation CreateValidationFields($teamId: String!) {
  phoneValidationField: customFieldCreate(input: {
    name: "Phone Validation"
    type: Select
    selectOptions: [
      { name: "Valid", color: "#10b981" }
      { name: "Invalid", color: "#ef4444" }
      { name: "Risky", color: "#f59e0b" }
      { name: "Pending", color: "#3b82f6" }
    ]
    teamId: $teamId
  }) {
    customField {
      id
      name
    }
  }
  
  riskScoreField: customFieldCreate(input: {
    name: "Contact Risk Score"
    type: Number
    teamId: $teamId
  }) {
    customField {
      id
      name
    }
  }
}

interface ValidationCustomFields {
  phoneValidation: string;
  emailValidation: string;
  riskScore: number;
  validatedAt: string;
}

interface ContactValidationResult {
  phone: {
    status: 'valid' | 'invalid' | 'risky';
    carrier?: string;
    type?: 'mobile' | 'landline';
  };
  email: {
    status: 'valid' | 'invalid' | 'disposable';
    deliverable: boolean;
  };
  riskScore: number;
  validatedAt: Date;
}

app.post('/linear-webhook', async (req, res) => {
  const { type, data } = req.body;
  
  if (type === 'Issue' && ['create', 'update'].includes(data.action)) {
    const issue = data.issue;
    
    // Extract contact information from issue
    const contactInfo = extractContactFromIssue(issue);
    
    if (contactInfo.phone || contactInfo.email) {
      // Validate contact asynchronously
      validateContactAsync(issue.id, contactInfo);
    }
  }
  
  res.status(200).send('OK');
});

async function validateContactAsync(issueId: string, contact: ContactInfo) {
  try {
    const validation = await lookupClient.validate({
      phone_number: contact.phone,
      email: contact.email
    });
    
    await updateIssueWithValidation(issueId, validation);
    
    // Send notification for high-risk contacts
    if (validation.riskScore > 70) {
      await sendSlackAlert(issueId, validation);
    }
    
  } catch (error) {
    console.error('Validation failed:', error);
  }
}

const UPDATE_ISSUE_VALIDATION = gql`
  mutation UpdateIssueValidation(
    $issueId: String!
    $phoneFieldId: String!
    $riskFieldId: String!
    $phoneStatus: String!
    $riskScore: Float!
  ) {
    issueUpdate(
      id: $issueId
      input: {
        customFields: [
          { customFieldId: $phoneFieldId, value: $phoneStatus }
          { customFieldId: $riskFieldId, value: $riskScore }
        ]
      }
    ) {
      issue {
        id
        title
        customFields {
          customField {
            name
          }
          value
        }
      }
    }
  }
`;

async function updateIssueWithValidation(issueId: string, validation: ValidationResult) {
  await client.mutate({
    mutation: UPDATE_ISSUE_VALIDATION,
    variables: {
      issueId,
      phoneFieldId: 'phone_validation_field_id',
      riskFieldId: 'risk_score_field_id',
      phoneStatus: validation.phone.status,
      riskScore: validation.riskScore
    }
  });
  
  // Add validation comment
  await linearClient.commentCreate({
    issueId,
    body: `🔍 Contact validated:\n- Phone: ${validation.phone.status}\n- Risk Score: ${validation.riskScore}`
  });
}