How to Integrate FedEx API with V0

1// lib/fedex-auth.ts
2interface CachedToken {
3  accessToken: string;
4  expiresAt: number; // Unix timestamp in ms
5}
6
7let tokenCache: CachedToken | null = null;
8
9function getFedexBaseUrl(): string {
10  return process.env.FEDEX_SANDBOX === 'true'
11    ? 'https://apis-sandbox.fedex.com'
12    : 'https://apis.fedex.com';
13}
14
15export async function getFedexAccessToken(): Promise<string> {
16  const now = Date.now();
17  const bufferMs = 60 * 1000; // 60 second safety margin
18
19  // Return cached token if still valid
20  if (tokenCache && tokenCache.expiresAt > now + bufferMs) {
21    return tokenCache.accessToken;
22  }
23
24  const clientId = process.env.FEDEX_CLIENT_ID;
25  const clientSecret = process.env.FEDEX_CLIENT_SECRET;
26
27  if (!clientId || !clientSecret) {
28    throw new Error('FedEx credentials not configured');
29  }
30
31  const body = new URLSearchParams({
32    grant_type: 'client_credentials',
33    client_id: clientId,
34    client_secret: clientSecret,
35  });
36
37  const response = await fetch(`${getFedexBaseUrl()}/oauth/token`, {
38    method: 'POST',
39    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
40    body: body.toString(),
41    cache: 'no-store',
42  });
43
44  if (!response.ok) {
45    const error = await response.text();
46    throw new Error(`FedEx token request failed: ${response.status} ${error}`);
47  }
48
49  const data = await response.json();
50  tokenCache = {
51    accessToken: data.access_token,
52    expiresAt: now + (data.expires_in * 1000),
53  };
54
55  return tokenCache.accessToken;
56}
57
58export async function fedexFetch(path: string, options: RequestInit = {}): Promise<Response> {
59  const token = await getFedexAccessToken();
60  const baseUrl = getFedexBaseUrl();
61
62  return fetch(`${baseUrl}${path}`, {
63    ...options,
64    headers: {
65      ...options.headers,
66      Authorization: `Bearer ${token}`,
67      'Content-Type': 'application/json',
68      'X-locale': 'en_US',
69    },
70  });
71}

1// app/api/fedex/rates/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { fedexFetch } from '@/lib/fedex-auth';
4
5const SERVICE_LABELS: Record<string, string> = {
6  FEDEX_GROUND: 'FedEx Ground',
7  FEDEX_2_DAY: 'FedEx 2Day',
8  FEDEX_2_DAY_AM: 'FedEx 2Day AM',
9  STANDARD_OVERNIGHT: 'FedEx Standard Overnight',
10  PRIORITY_OVERNIGHT: 'FedEx Priority Overnight',
11  FIRST_OVERNIGHT: 'FedEx First Overnight',
12  FEDEX_EXPRESS_SAVER: 'FedEx Express Saver',
13};
14
15export async function POST(request: NextRequest) {
16  try {
17    const { originZip, destinationZip, weight, length, width, height } =
18      await request.json();
19
20    const accountNumber = process.env.FEDEX_ACCOUNT_NUMBER;
21    if (!accountNumber) {
22      return NextResponse.json({ error: 'FedEx account not configured' }, { status: 500 });
23    }
24
25    const rateRequest = {
26      accountNumber: { value: accountNumber },
27      requestedShipment: {
28        shipper: { address: { postalCode: originZip, countryCode: 'US' } },
29        recipient: { address: { postalCode: destinationZip, countryCode: 'US' } },
30        pickupType: 'DROPOFF_AT_FEDEX_LOCATION',
31        rateRequestType: ['ACCOUNT', 'LIST'],
32        requestedPackageLineItems: [{
33          weight: { units: 'LB', value: weight },
34          dimensions: { length, width, height, units: 'IN' },
35        }],
36      },
37    };
38
39    const response = await fedexFetch('/rate/v1/rates/quotes', {
40      method: 'POST',
41      body: JSON.stringify(rateRequest),
42    });
43
44    if (!response.ok) {
45      const error = await response.json();
46      console.error('FedEx rate error:', error);
47      return NextResponse.json({ error: 'Rate quote failed' }, { status: response.status });
48    }
49
50    const data = await response.json();
51    const rateDetails = data.output?.rateReplyDetails || [];
52
53    const rates = rateDetails.map((detail: Record<string, unknown>) => {
54      const shipmentDetail = (detail.ratedShipmentDetails as Record<string, unknown>[])?.[0];
55      const totalCharge = (shipmentDetail?.totalNetChargeWithDutiesAndTaxes as Record<string, unknown>)
56        || (shipmentDetail?.totalNetCharge as Record<string, unknown>);
57
58      return {
59        serviceType: detail.serviceType,
60        serviceName: SERVICE_LABELS[detail.serviceType as string] || detail.serviceType,
61        deliveryDate: detail.commit?.dateDetail?.dayFormat || 'N/A',
62        transitDays: detail.commit?.transitDays?.description || '',
63        rate: parseFloat((totalCharge?.amount as string) || '0'),
64        currency: totalCharge?.currency || 'USD',
65      };
66    }).sort((a: { rate: number }, b: { rate: number }) => a.rate - b.rate);
67
68    return NextResponse.json({ rates });
69  } catch (error) {
70    console.error('FedEx rates error:', error);
71    return NextResponse.json({ error: 'Failed to get rates' }, { status: 500 });
72  }
73}
74
75// app/api/fedex/track/route.ts
76import { NextRequest, NextResponse } from 'next/server';
77import { fedexFetch } from '@/lib/fedex-auth';
78
79export async function GET(request: NextRequest) {
80  const { searchParams } = new URL(request.url);
81  const trackingNumber = searchParams.get('trackingNumber');
82
83  if (!trackingNumber) {
84    return NextResponse.json({ error: 'trackingNumber is required' }, { status: 400 });
85  }
86
87  try {
88    const response = await fedexFetch('/track/v1/trackingnumbers', {
89      method: 'POST',
90      body: JSON.stringify({
91        includeDetailedScans: true,
92        trackingInfo: [{ trackingNumberInfo: { trackingNumber } }],
93      }),
94    });
95
96    if (!response.ok) {
97      return NextResponse.json({ error: 'Tracking request failed' }, { status: response.status });
98    }
99
100    const data = await response.json();
101    const trackResult = data.output?.completeTrackResults?.[0]?.trackResults?.[0];
102
103    if (!trackResult) {
104      return NextResponse.json({ error: 'No tracking data found' }, { status: 404 });
105    }
106
107    const scanEvents = (trackResult.scanEvents || []).map((event: Record<string, unknown>) => ({
108      timestamp: event.date,
109      eventType: event.eventType,
110      description: event.eventDescription,
111      location: [event.scanLocation?.city, event.scanLocation?.stateOrProvinceCode]
112        .filter(Boolean).join(', '),
113    }));
114
115    return NextResponse.json({
116      trackingNumber,
117      status: trackResult.latestStatusDetail?.description,
118      estimatedDelivery: trackResult.estimatedDeliveryTimeWindow?.window?.ends,
119      events: scanEvents,
120    });
121  } catch (error) {
122    console.error('FedEx tracking error:', error);
123    return NextResponse.json({ error: 'Tracking failed' }, { status: 500 });
124  }
125}