How to Integrate Bolt.new with Meetup

1# .env — add to project root in Bolt
2# From: meetup.com/api/oauth/list/ → Register new OAuth Consumer
3MEETUP_CONSUMER_KEY=your_consumer_key
4MEETUP_CONSUMER_SECRET=your_consumer_secret
5# Access token for server-to-server / public API queries
6# Obtain via client credentials grant (see step 2)
7MEETUP_ACCESS_TOKEN=your_access_token
8# For user OAuth flow (update after deployment)
9MEETUP_REDIRECT_URI=https://your-app.netlify.app/api/meetup/callback

1// lib/meetup-client.ts
2export interface MeetupEvent {
3  id: string;
4  title: string;
5  dateTime: string;
6  endTime?: string;
7  eventUrl: string;
8  going: number;
9  description?: string;
10  venue?: {
11    name: string;
12    address?: string;
13    city?: string;
14    state?: string;
15  };
16  group: {
17    id: string;
18    name: string;
19    urlname: string;
20    city: string;
21  };
22}
23
24export async function meetupQuery<T>(
25  query: string,
26  variables: Record<string, unknown> = {}
27): Promise<T> {
28  const token = process.env.MEETUP_ACCESS_TOKEN;
29  if (!token) {
30    throw new Error('MEETUP_ACCESS_TOKEN not configured');
31  }
32
33  const res = await fetch('https://api.meetup.com/gql', {
34    method: 'POST',
35    headers: {
36      Authorization: `Bearer ${token}`,
37      'Content-Type': 'application/json',
38    },
39    body: JSON.stringify({ query, variables }),
40  });
41
42  if (!res.ok) {
43    throw new Error(`Meetup API error: ${res.status} ${res.statusText}`);
44  }
45
46  const { data, errors } = await res.json();
47
48  if (errors?.length) {
49    throw new Error(`Meetup GraphQL error: ${errors[0].message}`);
50  }
51
52  return data;
53}
54
55// Meetup GraphQL queries
56export const EVENT_SEARCH_QUERY = `
57  query SearchEvents($input: SearchConnectionInput!, $first: Int) {
58    keywordSearch(input: $input, filter: { upcoming: true }) {
59      pageInfo {
60        hasNextPage
61        endCursor
62      }
63      edges {
64        node {
65          id
66          result {
67            ... on Event {
68              id
69              title
70              dateTime
71              endTime
72              eventUrl
73              going
74              description
75              venue {
76                name
77                address
78                city
79                state
80              }
81              group {
82                id
83                name
84                urlname
85                city
86              }
87            }
88          }
89        }
90      }
91    }
92  }
93`;
94
95export const GROUP_EVENTS_QUERY = `
96  query GroupEvents($urlname: String!) {
97    groupByUrlname(urlname: $urlname) {
98      id
99      name
100      description
101      city
102      memberships {
103        count
104      }
105      upcomingEvents(input: { first: 10 }) {
106        edges {
107          node {
108            id
109            title
110            dateTime
111            duration
112            going
113            eventUrl
114            description
115            venue {
116              name
117              address
118              city
119            }
120          }
121        }
122      }
123    }
124  }
125`;

1// app/api/meetup/events/route.ts
2import { NextResponse } from 'next/server';
3import { meetupQuery, EVENT_SEARCH_QUERY } from '@/lib/meetup-client';
4
5interface SearchEdge {
6  node: {
7    id: string;
8    result: {
9      id?: string;
10      title?: string;
11      dateTime?: string;
12      eventUrl?: string;
13      going?: number;
14      description?: string;
15      venue?: { name: string; city: string };
16      group?: { name: string; urlname: string; city: string };
17    };
18  };
19}
20
21export async function GET(request: Request) {
22  try {
23    const { searchParams } = new URL(request.url);
24    const lat = parseFloat(searchParams.get('lat') || '37.7749');
25    const lon = parseFloat(searchParams.get('lon') || '-122.4194');
26    const keyword = searchParams.get('keyword') || 'tech';
27    const radius = parseFloat(searchParams.get('radius') || '25');
28
29    const data = await meetupQuery<{
30      keywordSearch: { edges: SearchEdge[] };
31    }>(EVENT_SEARCH_QUERY, {
32      input: {
33        query: keyword,
34        lat,
35        lon,
36        radius,
37        source: 'EVENTS',
38      },
39    });
40
41    const events = data.keywordSearch.edges
42      .map(edge => edge.node.result)
43      .filter(r => r.title && r.dateTime); // Filter to Event type results
44
45    return NextResponse.json({ events });
46  } catch (error) {
47    const message = error instanceof Error ? error.message : 'Search failed';
48    return NextResponse.json({ error: message }, { status: 500 });
49  }
50}

1// app/api/meetup/callback/route.ts
2import { NextResponse } from 'next/server';
3import { cookies } from 'next/headers';
4
5export async function GET(request: Request) {
6  const { searchParams } = new URL(request.url);
7  const code = searchParams.get('code');
8  const state = searchParams.get('state');
9  const storedState = cookies().get('meetup_oauth_state')?.value;
10
11  if (!code) {
12    return NextResponse.json({ error: 'No authorization code' }, { status: 400 });
13  }
14
15  if (state !== storedState) {
16    return NextResponse.json({ error: 'Invalid state parameter' }, { status: 400 });
17  }
18
19  const tokenRes = await fetch('https://secure.meetup.com/oauth2/access', {
20    method: 'POST',
21    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
22    body: new URLSearchParams({
23      client_id: process.env.MEETUP_CONSUMER_KEY!,
24      client_secret: process.env.MEETUP_CONSUMER_SECRET!,
25      grant_type: 'authorization_code',
26      redirect_uri: process.env.MEETUP_REDIRECT_URI!,
27      code: code!,
28    }),
29  });
30
31  if (!tokenRes.ok) {
32    const error = await tokenRes.text();
33    return NextResponse.json({ error: `Token exchange failed: ${error}` }, { status: 500 });
34  }
35
36  const { access_token, refresh_token, expires_in } = await tokenRes.json();
37
38  const response = NextResponse.redirect(new URL('/events', request.url));
39
40  response.cookies.set('meetup_token', access_token, {
41    httpOnly: true,
42    secure: process.env.NODE_ENV === 'production',
43    maxAge: expires_in || 86400,
44  });
45
46  // Store refresh token more persistently (consider Supabase for long-term storage)
47  if (refresh_token) {
48    response.cookies.set('meetup_refresh', refresh_token, {
49      httpOnly: true,
50      secure: process.env.NODE_ENV === 'production',
51      maxAge: 60 * 60 * 24 * 30, // 30 days
52    });
53  }
54
55  return response;
56}