feat: add Platform GraphQL client service for lead lookup and CRUD

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/platform/platform-graphql.service.ts

@@ -0,0 +1,132 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import axios from 'axios';
+import type { LeadNode, LeadActivityNode, CreateCallInput, CreateLeadActivityInput, UpdateLeadInput } from './platform.types';
+
+@Injectable()
+export class PlatformGraphqlService {
+    private readonly graphqlUrl: string;
+    private readonly apiKey: string;
+
+    constructor(private config: ConfigService) {
+        this.graphqlUrl = config.get<string>('platform.graphqlUrl')!;
+        this.apiKey = config.get<string>('platform.apiKey')!;
+    }
+
+    private async query<T>(query: string, variables?: Record<string, any>): Promise<T> {
+        const response = await axios.post(
+            this.graphqlUrl,
+            { query, variables },
+            {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+            },
+        );
+
+        if (response.data.errors) {
+            throw new Error(`GraphQL error: ${JSON.stringify(response.data.errors)}`);
+        }
+
+        return response.data.data;
+    }
+
+    async findLeadByPhone(phone: string): Promise<LeadNode | null> {
+        // Note: The exact filter syntax for PHONES fields depends on the platform
+        // This queries leads and filters client-side by phone number
+        const data = await this.query<{ leads: { edges: { node: LeadNode }[] } }>(
+            `query FindLeads($first: Int) {
+                leads(first: $first, orderBy: { createdAt: DescNullsLast }) {
+                    edges {
+                        node {
+                            id createdAt
+                            contactName { firstName lastName }
+                            contactPhone { number callingCode }
+                            contactEmail { address }
+                            leadSource leadStatus interestedService
+                            assignedAgent campaignId adId
+                            contactAttempts spamScore isSpam
+                            aiSummary aiSuggestedAction
+                        }
+                    }
+                }
+            }`,
+            { first: 100 },
+        );
+
+        // Client-side phone matching (strip non-digits for comparison)
+        const normalizedPhone = phone.replace(/\D/g, '');
+        return data.leads.edges.find(edge => {
+            const leadPhones = edge.node.contactPhone ?? [];
+            return leadPhones.some(p => p.number.replace(/\D/g, '').endsWith(normalizedPhone) || normalizedPhone.endsWith(p.number.replace(/\D/g, '')));
+        })?.node ?? null;
+    }
+
+    async findLeadById(id: string): Promise<LeadNode | null> {
+        const data = await this.query<{ lead: LeadNode }>(
+            `query FindLead($id: ID!) {
+                lead(id: $id) {
+                    id createdAt
+                    contactName { firstName lastName }
+                    contactPhone { number callingCode }
+                    contactEmail { address }
+                    leadSource leadStatus interestedService
+                    assignedAgent campaignId adId
+                    contactAttempts spamScore isSpam
+                    aiSummary aiSuggestedAction
+                }
+            }`,
+            { id },
+        );
+        return data.lead;
+    }
+
+    async updateLead(id: string, input: UpdateLeadInput): Promise<LeadNode> {
+        const data = await this.query<{ updateLead: LeadNode }>(
+            `mutation UpdateLead($id: ID!, $data: LeadUpdateInput!) {
+                updateLead(id: $id, data: $data) {
+                    id leadStatus aiSummary aiSuggestedAction
+                }
+            }`,
+            { id, data: input },
+        );
+        return data.updateLead;
+    }
+
+    async createCall(input: CreateCallInput): Promise<{ id: string }> {
+        const data = await this.query<{ createCall: { id: string } }>(
+            `mutation CreateCall($data: CallCreateInput!) {
+                createCall(data: $data) { id }
+            }`,
+            { data: input },
+        );
+        return data.createCall;
+    }
+
+    async createLeadActivity(input: CreateLeadActivityInput): Promise<{ id: string }> {
+        const data = await this.query<{ createLeadActivity: { id: string } }>(
+            `mutation CreateLeadActivity($data: LeadActivityCreateInput!) {
+                createLeadActivity(data: $data) { id }
+            }`,
+            { data: input },
+        );
+        return data.createLeadActivity;
+    }
+
+    async getLeadActivities(leadId: string, limit = 3): Promise<LeadActivityNode[]> {
+        const data = await this.query<{ leadActivities: { edges: { node: LeadActivityNode }[] } }>(
+            `query GetLeadActivities($filter: LeadActivityFilterInput, $first: Int) {
+                leadActivities(filter: $filter, first: $first, orderBy: { occurredAt: DescNullsLast }) {
+                    edges {
+                        node {
+                            id activityType summary occurredAt performedBy channel
+                        }
+                    }
+                }
+            }`,
+            { filter: { leadId: { eq: leadId } }, first: limit },
+        );
+        return data.leadActivities.edges.map(e => e.node);
+    }
+}