feat(api): sync GitHub issues into tasks

apps/api/src/app/api/github/callback/route.ts

@@ -1,5 +1,10 @@
 import { db } from "@superset/db/client";
-import { githubInstallations, members } from "@superset/db/schema";
+import type { GithubConfig } from "@superset/db/schema";
+import {
+	githubInstallations,
+	integrationConnections,
+	members,
+} from "@superset/db/schema";
 import { Client } from "@upstash/qstash";
 import { and, eq } from "drizzle-orm";
 
@@ -120,6 +125,34 @@ export async function GET(request: Request) {
 			);
 		}
 
+		await db
+			.insert(integrationConnections)
+			.values({
+				organizationId,
+				connectedByUserId: userId,
+				provider: "github",
+				accessToken: `ghi_${installation.id}`, // Installation-based auth, not OAuth
+				externalOrgId: accountLogin,
+				externalOrgName: accountLogin,
+				config: {
+					provider: "github",
+					syncIssues: true,
+				} satisfies GithubConfig,
+			})
+			.onConflictDoUpdate({
+				target: [
+					integrationConnections.organizationId,
+					integrationConnections.provider,
+				],
+				set: {
+					connectedByUserId: userId,
+					accessToken: `ghi_${installation.id}`,
+					externalOrgId: accountLogin,
+					externalOrgName: accountLogin,
+					updatedAt: new Date(),
+				},
+			});
+
 		// Queue initial sync job
 		try {
 			await qstash.publishJSON({

apps/api/src/app/api/github/jobs/initial-sync/route.ts

@@ -1,14 +1,21 @@
 import { db } from "@superset/db/client";
+import type { GithubConfig } from "@superset/db/schema";
 import {
 	githubInstallations,
 	githubPullRequests,
 	githubRepositories,
+	integrationConnections,
+	tasks,
 } from "@superset/db/schema";
 import { Receiver } from "@upstash/qstash";
-import { eq } from "drizzle-orm";
+import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { env } from "@/env";
+import {
+	mapGithubIssueToTask,
+	resolveTaskStatusIds,
+} from "../../lib/map-issue-to-task";
 import { githubApp } from "../../octokit";
 
 const receiver = new Receiver({
@@ -228,6 +235,97 @@ export async function POST(request: Request) {
 			}
 		}
 
+		const { organizationId } = parsed.data;
+		const connection = await db.query.integrationConnections.findFirst({
+			where: and(
+				eq(integrationConnections.organizationId, organizationId),
+				eq(integrationConnections.provider, "github"),
+			),
+			columns: { config: true },
+		});
+
+		const config = connection?.config as GithubConfig | null;
+		const syncIssues = config?.syncIssues !== false;
+
+		if (syncIssues) {
+			const statusIds = await resolveTaskStatusIds({ organizationId });
+
+			if (!statusIds) {
+				console.warn(
+					"[github/initial-sync] Missing unstarted/completed status types, skipping issue sync",
+				);
+			} else {
+				for (const repo of repos) {
+					const issues = await octokit.paginate(
+						octokit.rest.issues.listForRepo,
+						{
+							owner: repo.owner.login,
+							repo: repo.name,
+							state: "open",
+							per_page: 100,
+						},
+					);
+
+					// Filter out pull requests (GitHub issues API includes PRs)
+					const realIssues = issues.filter(
+						(issue) => !("pull_request" in issue && issue.pull_request),
+					);
+
+					console.log(
+						`[github/initial-sync] Found ${realIssues.length} issues for ${repo.full_name}`,
+					);
+
+					for (const issue of realIssues) {
+						const statusId =
+							issue.state === "closed"
+								? statusIds.completedStatusId
+								: statusIds.unstartedStatusId;
+
+						const taskData = mapGithubIssueToTask({
+							issue: {
+								id: issue.id,
+								number: issue.number,
+								title: issue.title,
+								body: issue.body,
+								html_url: issue.html_url,
+								state: issue.state,
+								assignee: issue.assignee
+									? {
+											login: issue.assignee.login,
+											email:
+												"email" in issue.assignee
+													? (issue.assignee.email as string | null)
+													: null,
+										}
+									: null,
+								labels: issue.labels,
+							},
+							repoName: repo.name,
+							statusId,
+							assigneeId: null,
+						});
+
+						await db
+							.insert(tasks)
+							.values({
+								...taskData,
+								organizationId,
+								creatorId: installation.connectedByUserId,
+								priority: "none",
+							})
+							.onConflictDoUpdate({
+								target: [
+									tasks.organizationId,
+									tasks.externalProvider,
+									tasks.externalId,
+								],
+								set: { ...taskData, syncError: null },
+							});
+					}
+				}
+			}
+		}
+
 		// Update installation lastSyncedAt
 		await db
 			.update(githubInstallations)

apps/api/src/app/api/github/lib/map-issue-to-task.ts

@@ -0,0 +1,160 @@
+import { db } from "@superset/db/client";
+import { taskStatuses, tasks, users } from "@superset/db/schema";
+import { and, eq } from "drizzle-orm";
+
+interface GithubIssue {
+	id: number;
+	number: number;
+	title: string;
+	body?: string | null;
+	html_url: string;
+	state: string;
+	assignee?: { login: string; email?: string | null } | null;
+	labels: Array<{ name?: string } | string>;
+}
+
+interface ResolvedStatusIds {
+	unstartedStatusId: string;
+	completedStatusId: string;
+}
+
+export async function resolveTaskStatusIds({
+	organizationId,
+}: {
+	organizationId: string;
+}): Promise<ResolvedStatusIds | null> {
+	const statuses = await db
+		.select({ id: taskStatuses.id, type: taskStatuses.type })
+		.from(taskStatuses)
+		.where(eq(taskStatuses.organizationId, organizationId));
+
+	const unstartedStatus = statuses.find((s) => s.type === "unstarted");
+	const completedStatus = statuses.find((s) => s.type === "completed");
+
+	if (!unstartedStatus || !completedStatus) {
+		return null;
+	}
+
+	return {
+		unstartedStatusId: unstartedStatus.id,
+		completedStatusId: completedStatus.id,
+	};
+}
+
+async function resolveAssigneeId({
+	assignee,
+}: {
+	assignee?: GithubIssue["assignee"];
+}): Promise<string | null> {
+	if (!assignee?.email) {
+		return null;
+	}
+
+	const matchedUser = await db.query.users.findFirst({
+		where: eq(users.email, assignee.email),
+		columns: { id: true },
+	});
+
+	return matchedUser?.id ?? null;
+}
+
+export function mapGithubIssueToTask({
+	issue,
+	repoName,
+	statusId,
+	assigneeId,
+}: {
+	issue: GithubIssue;
+	repoName: string;
+	statusId: string;
+	assigneeId: string | null;
+}) {
+	return {
+		slug: `${repoName}#${issue.number}`,
+		title: issue.title,
+		description: issue.body ?? null,
+		statusId,
+		assigneeId,
+		labels: issue.labels
+			.map((l) => (typeof l === "string" ? l : l.name))
+			.filter((name): name is string => !!name),
+		externalProvider: "github" as const,
+		externalId: String(issue.id),
+		externalKey: `#${issue.number}`,
+		externalUrl: issue.html_url,
+		lastSyncedAt: new Date(),
+	};
+}
+
+export async function processGithubIssueEvent({
+	issue,
+	repoName,
+	organizationId,
+	creatorId,
+	action,
+}: {
+	issue: GithubIssue;
+	repoName: string;
+	organizationId: string;
+	creatorId: string;
+	action:
+		| "opened"
+		| "edited"
+		| "closed"
+		| "reopened"
+		| "assigned"
+		| "unassigned"
+		| "labeled"
+		| "unlabeled"
+		| "deleted";
+}) {
+	if (action === "deleted") {
+		await db
+			.update(tasks)
+			.set({ deletedAt: new Date() })
+			.where(
+				and(
+					eq(tasks.organizationId, organizationId),
+					eq(tasks.externalProvider, "github"),
+					eq(tasks.externalId, String(issue.id)),
+				),
+			);
+		return;
+	}
+
+	const statusIds = await resolveTaskStatusIds({ organizationId });
+	if (!statusIds) {
+		console.warn(
+			"[github/issues] Missing unstarted/completed status types for org:",
+			organizationId,
+		);
+		return;
+	}
+
+	const statusId =
+		issue.state === "closed"
+			? statusIds.completedStatusId
+			: statusIds.unstartedStatusId;
+
+	const assigneeId = await resolveAssigneeId({ assignee: issue.assignee });
+
+	const taskData = mapGithubIssueToTask({
+		issue,
+		repoName,
+		statusId,
+		assigneeId,
+	});
+
+	await db
+		.insert(tasks)
+		.values({
+			...taskData,
+			organizationId,
+			creatorId,
+			priority: "none",
+		})
+		.onConflictDoUpdate({
+			target: [tasks.organizationId, tasks.externalProvider, tasks.externalId],
+			set: { ...taskData, syncError: null },
+		});
+}