How to Integrate Bolt.new with Hootsuite

1// lib/social-apis.ts
2export interface SocialPost {
3  content: string;
4  mediaUrls?: string[];
5  scheduledAt?: Date;
6}
7
8export interface PublishResult {
9  platform: string;
10  success: boolean;
11  postId?: string;
12  error?: string;
13}
14
15// Twitter/X API v2
16export async function publishToTwitter(content: string): Promise<PublishResult> {
17  const token = process.env.TWITTER_BEARER_TOKEN;
18  if (!token) return { platform: 'twitter', success: false, error: 'Missing TWITTER_BEARER_TOKEN' };
19
20  try {
21    const response = await fetch('https://api.twitter.com/2/tweets', {
22      method: 'POST',
23      headers: {
24        'Authorization': `Bearer ${token}`,
25        'Content-Type': 'application/json',
26      },
27      body: JSON.stringify({ text: content }),
28    });
29    const data = await response.json();
30    if (!response.ok) throw new Error(data.detail || 'Twitter API error');
31    return { platform: 'twitter', success: true, postId: data.data?.id };
32  } catch (error) {
33    return { platform: 'twitter', success: false, error: (error as Error).message };
34  }
35}
36
37// LinkedIn API
38export async function publishToLinkedIn(content: string, authorUrn: string): Promise<PublishResult> {
39  const token = process.env.LINKEDIN_ACCESS_TOKEN;
40  if (!token) return { platform: 'linkedin', success: false, error: 'Missing LINKEDIN_ACCESS_TOKEN' };
41
42  try {
43    const response = await fetch('https://api.linkedin.com/v2/ugcPosts', {
44      method: 'POST',
45      headers: {
46        'Authorization': `Bearer ${token}`,
47        'Content-Type': 'application/json',
48        'X-Restli-Protocol-Version': '2.0.0',
49      },
50      body: JSON.stringify({
51        author: authorUrn,
52        lifecycleState: 'PUBLISHED',
53        specificContent: {
54          'com.linkedin.ugc.ShareContent': {
55            shareCommentary: { text: content },
56            shareMediaCategory: 'NONE',
57          },
58        },
59        visibility: { 'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC' },
60      }),
61    });
62    const data = await response.json();
63    if (!response.ok) throw new Error(JSON.stringify(data));
64    return { platform: 'linkedin', success: true, postId: data.id };
65  } catch (error) {
66    return { platform: 'linkedin', success: false, error: (error as Error).message };
67  }
68}
69
70// Facebook Graph API
71export async function publishToFacebook(content: string): Promise<PublishResult> {
72  const token = process.env.FACEBOOK_PAGE_TOKEN;
73  const pageId = process.env.FACEBOOK_PAGE_ID;
74  if (!token || !pageId) return { platform: 'facebook', success: false, error: 'Missing Facebook credentials' };
75
76  try {
77    const response = await fetch(
78      `https://graph.facebook.com/v18.0/${pageId}/feed`,
79      {
80        method: 'POST',
81        headers: { 'Content-Type': 'application/json' },
82        body: JSON.stringify({ message: content, access_token: token }),
83      }
84    );
85    const data = await response.json();
86    if (data.error) throw new Error(data.error.message);
87    return { platform: 'facebook', success: true, postId: data.id };
88  } catch (error) {
89    return { platform: 'facebook', success: false, error: (error as Error).message };
90  }
91}

1// app/api/social/publish/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { publishToTwitter, publishToLinkedIn, publishToFacebook } from '@/lib/social-apis';
4
5type Platform = 'twitter' | 'linkedin' | 'facebook';
6
7interface PublishRequest {
8  content: string;
9  platforms: Platform[];
10  linkedinAuthorUrn?: string;
11}
12
13export async function POST(request: NextRequest) {
14  const body: PublishRequest = await request.json();
15  const { content, platforms, linkedinAuthorUrn } = body;
16
17  if (!content?.trim()) {
18    return NextResponse.json({ error: 'Content is required' }, { status: 400 });
19  }
20
21  if (!platforms?.length) {
22    return NextResponse.json({ error: 'At least one platform is required' }, { status: 400 });
23  }
24
25  if (platforms.includes('twitter') && content.length > 280) {
26    return NextResponse.json(
27      { error: 'Content exceeds Twitter 280 character limit' },
28      { status: 400 }
29    );
30  }
31
32  const publishPromises = platforms.map((platform) => {
33    switch (platform) {
34      case 'twitter':
35        return publishToTwitter(content);
36      case 'linkedin':
37        return publishToLinkedIn(content, linkedinAuthorUrn || process.env.LINKEDIN_PERSON_URN || '');
38      case 'facebook':
39        return publishToFacebook(content);
40      default:
41        return Promise.resolve({ platform, success: false, error: 'Unknown platform' });
42    }
43  });
44
45  const results = await Promise.allSettled(publishPromises);
46
47  const formattedResults = results.map((result, index) => {
48    if (result.status === 'fulfilled') return result.value;
49    return { platform: platforms[index], success: false, error: result.reason?.message || 'Unknown error' };
50  });
51
52  const hasSuccess = formattedResults.some((r) => r.success);
53  const statusCode = hasSuccess ? 200 : 500;
54
55  return NextResponse.json({ results: formattedResults }, { status: statusCode });
56}

1// app/api/social/analytics/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3
4interface NormalizedAnalytics {
5  platform: string;
6  period: string;
7  totalImpressions: number;
8  totalEngagements: number;
9  posts: Array<{
10    id: string;
11    content: string;
12    publishedAt: string;
13    impressions: number;
14    engagements: number;
15  }>;
16}
17
18async function fetchTwitterAnalytics(period: string): Promise<NormalizedAnalytics> {
19  const userId = process.env.TWITTER_USER_ID!;
20  const token = process.env.TWITTER_BEARER_TOKEN!;
21  const maxResults = period === '7d' ? 10 : period === '30d' ? 50 : 100;
22
23  const url = `https://api.twitter.com/2/users/${userId}/tweets?max_results=${maxResults}&tweet.fields=public_metrics,created_at&expansions=attachments.media_keys`;
24  const response = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
25  const data = await response.json();
26
27  if (!response.ok) throw new Error(data.detail || 'Twitter API error');
28
29  const posts = (data.data || []).map((tweet: { id: string; text: string; created_at: string; public_metrics: { impression_count: number; like_count: number; retweet_count: number; reply_count: number } }) => ({
30    id: tweet.id,
31    content: tweet.text,
32    publishedAt: tweet.created_at,
33    impressions: tweet.public_metrics?.impression_count || 0,
34    engagements: (tweet.public_metrics?.like_count || 0) +
35      (tweet.public_metrics?.retweet_count || 0) +
36      (tweet.public_metrics?.reply_count || 0),
37  }));
38
39  return {
40    platform: 'twitter',
41    period,
42    totalImpressions: posts.reduce((sum: number, p: { impressions: number }) => sum + p.impressions, 0),
43    totalEngagements: posts.reduce((sum: number, p: { engagements: number }) => sum + p.engagements, 0),
44    posts,
45  };
46}
47
48async function fetchFacebookAnalytics(period: string): Promise<NormalizedAnalytics> {
49  const pageId = process.env.FACEBOOK_PAGE_ID!;
50  const token = process.env.FACEBOOK_PAGE_TOKEN!;
51  const periodParam = period === '7d' ? 'week' : 'month';
52
53  const url = `https://graph.facebook.com/v18.0/${pageId}/insights?metric=page_impressions,page_post_engagements&period=${periodParam}&access_token=${token}`;
54  const response = await fetch(url);
55  const data = await response.json();
56
57  if (data.error) throw new Error(data.error.message);
58
59  const impressionsData = data.data?.find((m: { name: string }) => m.name === 'page_impressions');
60  const engagementsData = data.data?.find((m: { name: string }) => m.name === 'page_post_engagements');
61
62  const totalImpressions = impressionsData?.values?.reduce((sum: number, v: { value: number }) => sum + (v.value || 0), 0) || 0;
63  const totalEngagements = engagementsData?.values?.reduce((sum: number, v: { value: number }) => sum + (v.value || 0), 0) || 0;
64
65  return { platform: 'facebook', period, totalImpressions, totalEngagements, posts: [] };
66}
67
68export async function GET(request: NextRequest) {
69  const { searchParams } = new URL(request.url);
70  const platform = searchParams.get('platform') || 'twitter';
71  const period = searchParams.get('period') || '7d';
72
73  try {
74    let analytics: NormalizedAnalytics;
75    if (platform === 'twitter') {
76      analytics = await fetchTwitterAnalytics(period);
77    } else if (platform === 'facebook') {
78      analytics = await fetchFacebookAnalytics(period);
79    } else {
80      return NextResponse.json({ error: 'Platform not supported' }, { status: 400 });
81    }
82    return NextResponse.json(analytics);
83  } catch (error) {
84    return NextResponse.json(
85      { error: (error as Error).message },
86      { status: 500 }
87    );
88  }
89}

1# netlify.toml
2[build]
3  command = "npm run build"
4  publish = ".next"
5
6[[plugins]]
7  package = "@netlify/plugin-nextjs"
8
9[build.environment]
10  NODE_VERSION = "20"
11  NEXT_TELEMETRY_DISABLED = "1"
12
13[[redirects]]
14  from = "/api/*"
15  to = "/api/:splat"
16  status = 200