How to Integrate Bolt.new with Teamwork

1// lib/teamwork.ts
2const getTeamworkBaseUrl = () => {
3  const subdomain = process.env.TEAMWORK_SUBDOMAIN;
4  if (!subdomain) throw new Error('TEAMWORK_SUBDOMAIN is not configured');
5  return `https://${subdomain}.teamwork.com`;
6};
7
8const getAuthHeader = () => {
9  const apiKey = process.env.TEAMWORK_API_KEY;
10  if (!apiKey) throw new Error('TEAMWORK_API_KEY is not configured');
11  // HTTP Basic auth: base64(apiKey:X)
12  const encoded = Buffer.from(`${apiKey}:X`).toString('base64');
13  return `Basic ${encoded}`;
14};
15
16interface TeamworkFetchOptions {
17  method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
18  params?: Record<string, string | number | boolean>;
19  body?: unknown;
20}
21
22export async function teamworkFetch<T = unknown>(
23  endpoint: string,
24  options: TeamworkFetchOptions = {}
25): Promise<T> {
26  const baseUrl = getTeamworkBaseUrl();
27  const url = new URL(`${baseUrl}/${endpoint}`);
28
29  if (options.params) {
30    Object.entries(options.params).forEach(([key, value]) => {
31      url.searchParams.set(key, String(value));
32    });
33  }
34
35  const response = await fetch(url.toString(), {
36    method: options.method || 'GET',
37    headers: {
38      Authorization: getAuthHeader(),
39      'Content-Type': 'application/json',
40    },
41    body: options.body ? JSON.stringify(options.body) : undefined,
42  });
43
44  if (!response.ok) {
45    const text = await response.text().catch(() => '');
46    throw new Error(`Teamwork API ${response.status}: ${text || response.statusText}`);
47  }
48
49  return response.json() as Promise<T>;
50}
51
52// Convenience types for common Teamwork resources
53export interface TeamworkProject {
54  id: string;
55  name: string;
56  description: string;
57  status: string;
58  'start-date': string;
59  'end-date': string;
60  'completed-count': number;
61  'uncompleted-count': number;
62  'is-project-admin': boolean;
63}
64
65export interface TeamworkTask {
66  id: string;
67  content: string;
68  status: string;
69  priority: string;
70  'due-date': string;
71  completed: boolean;
72  'project-id': string;
73  'project-name': string;
74  'responsible-party-names': string;
75  'estimated-minutes': number;
76}

1// app/api/teamwork/projects/route.ts
2import { NextResponse } from 'next/server';
3import { teamworkFetch, TeamworkProject } from '@/lib/teamwork';
4
5interface TeamworkProjectsResponse {
6  projects: TeamworkProject[];
7}
8
9export async function GET() {
10  try {
11    const data = await teamworkFetch<TeamworkProjectsResponse>('projects.json', {
12      params: { status: 'active', orderby: 'name', pageSize: 250 },
13    });
14
15    const projects = (data.projects || []).map((p) => {
16      const completed = p['completed-count'] || 0;
17      const open = p['uncompleted-count'] || 0;
18      const total = completed + open;
19      const completionPct = total > 0 ? Math.round((completed / total) * 100) : 0;
20
21      // Simple health heuristic
22      let healthStatus = 'On Track';
23      if (completionPct < 25 && total > 5) healthStatus = 'Early Stage';
24      if (p['end-date']) {
25        const daysLeft = Math.ceil(
26          (new Date(p['end-date']).getTime() - Date.now()) / (1000 * 60 * 60 * 24)
27        );
28        if (daysLeft < 0 && open > 0) healthStatus = 'Overdue';
29        else if (daysLeft < 7 && open > 0) healthStatus = 'At Risk';
30      }
31
32      return {
33        id: p.id,
34        name: p.name,
35        description: p.description || '',
36        status: p.status,
37        completedTasks: completed,
38        openTasks: open,
39        completionPct,
40        startDate: p['start-date'] || null,
41        endDate: p['end-date'] || null,
42        healthStatus,
43      };
44    });
45
46    return NextResponse.json({ projects, total: projects.length });
47  } catch (err) {
48    const message = err instanceof Error ? err.message : 'Failed to fetch projects';
49    return NextResponse.json({ error: message }, { status: 500 });
50  }
51}

1// app/api/teamwork/tasks/route.ts
2import { NextResponse } from 'next/server';
3import { teamworkFetch } from '@/lib/teamwork';
4
5interface TeamworkTasksResponse {
6  'todo-items': Array<{
7    id: string;
8    content: string;
9    status: string;
10    priority: string;
11    'due-date': string;
12    completed: boolean;
13    'project-id': string;
14    'project-name': string;
15    'responsible-party-names': string;
16    'estimated-minutes': number;
17    description: string;
18  }>;
19}
20
21export async function GET(request: Request) {
22  const { searchParams } = new URL(request.url);
23  const projectId = searchParams.get('projectId');
24  const filter = searchParams.get('filter') || 'active';
25  const responsiblePartyIds = searchParams.get('responsiblePartyIds');
26  const page = searchParams.get('page') || '1';
27
28  const endpoint = projectId
29    ? `projects/${projectId}/tasks.json`
30    : 'tasks.json';
31
32  const params: Record<string, string> = {
33    filter,
34    page,
35    pageSize: '100',
36    'sort': 'duedate',
37    'sort-order': 'asc',
38  };
39
40  if (responsiblePartyIds) params['responsible-party-ids'] = responsiblePartyIds;
41
42  try {
43    const data = await teamworkFetch<TeamworkTasksResponse>(endpoint, { params });
44    const tasks = (data['todo-items'] || []).map((t) => ({
45      id: t.id,
46      content: t.content,
47      priority: t.priority || 'none',
48      dueDate: t['due-date'] || null,
49      completed: t.completed,
50      projectId: t['project-id'],
51      projectName: t['project-name'],
52      assignees: t['responsible-party-names'] || '',
53      estimatedMinutes: t['estimated-minutes'] || 0,
54    }));
55
56    return NextResponse.json({ tasks, total: tasks.length });
57  } catch (err) {
58    const message = err instanceof Error ? err.message : 'Failed to fetch tasks';
59    return NextResponse.json({ error: message }, { status: 500 });
60  }
61}

1// app/api/teamwork/time-entries/route.ts
2import { NextResponse } from 'next/server';
3import { teamworkFetch } from '@/lib/teamwork';
4
5interface TimeEntry {
6  id: string;
7  description: string;
8  hours: number;
9  minutes: number;
10  date: string;
11  'person-first-name': string;
12  'person-last-name': string;
13  'project-name': string;
14  'todo-item-name': string;
15  billable: boolean;
16}
17
18interface TimeEntriesResponse {
19  'time-entries': TimeEntry[];
20}
21
22export async function GET(request: Request) {
23  const { searchParams } = new URL(request.url);
24  const personId = searchParams.get('personId');
25  const date = searchParams.get('date') || new Date().toISOString().split('T')[0];
26
27  try {
28    const data = await teamworkFetch<TimeEntriesResponse>('time_entries.json', {
29      params: {
30        'fromdate': date,
31        'todate': date,
32        ...(personId ? { 'userId': personId } : {}),
33      },
34    });
35
36    const entries = data['time-entries'] || [];
37    const totalMinutes = entries.reduce(
38      (sum, e) => sum + (e.hours || 0) * 60 + (e.minutes || 0),
39      0
40    );
41
42    return NextResponse.json({
43      entries,
44      totalHours: Math.floor(totalMinutes / 60),
45      totalMinutes: totalMinutes % 60,
46    });
47  } catch (err) {
48    const message = err instanceof Error ? err.message : 'Failed to fetch time entries';
49    return NextResponse.json({ error: message }, { status: 500 });
50  }
51}
52
53export async function POST(request: Request) {
54  const { taskId, hours, minutes, date, description, billable = true } = await request.json();
55
56  if (!taskId || (!hours && !minutes)) {
57    return NextResponse.json({ error: 'taskId and hours or minutes are required' }, { status: 400 });
58  }
59
60  try {
61    const result = await teamworkFetch(`tasks/${taskId}/time_entries.json`, {
62      method: 'POST',
63      body: {
64        'time-entry': {
65          description: description || '',
66          hours: hours || 0,
67          minutes: minutes || 0,
68          date: date || new Date().toISOString().split('T')[0],
69          billable,
70        },
71      },
72    }) as { STATUS?: string; timeLogId?: string };
73
74    if (result.STATUS !== 'OK') {
75      throw new Error('Time entry creation failed');
76    }
77
78    return NextResponse.json({ success: true, timeLogId: result.timeLogId });
79  } catch (err) {
80    const message = err instanceof Error ? err.message : 'Failed to log time';
81    return NextResponse.json({ error: message }, { status: 500 });
82  }
83}