⭐️⭐️⭐️ Open-source, self-hosted alternative to Linear and Plane. Project management and issue tracking where teams and AI agents work side by side to plan and ship products.
TypeScript agenticagileai-agentsbug-reportingbug-trackerganttissue-trackerjirajira-alternativekanbanlinearlinear-alternativeopen-sourceproduct-managementproject-managementroadmapself-hostedsprint-planningteam-collaborationtrello-alternative
import { db, gitManagedRepository, gitProviderConnection, project } from '@repo/db';
import { decryptSecret, encryptSecret } from '@repo/crypto';
import { and, asc, eq, inArray } from 'drizzle-orm';
import { HttpError, iso } from '#shared/lib';
import {
createProviderPullRequest,
deleteProviderWebhook,
createPullRequestComment,
getProviderAccount,
getProviderPullRequest,
getProviderRepository,
installProviderWebhook,
listProviderBranches,
listProviderPullRequests,
listProviderRepositories,
normalizeProviderBaseUrl,
type CreateProviderPullRequestInput,
type GitProvider,
type ProviderBranchPage,
type ProviderConnectionInput,
type ProviderPullRequestDetails,
type ProviderPullRequestPage,
type ProviderRepository,
} from './connections-provider';
import { getOrCreateGitSettings, type GitSettings } from './service';
export interface GitProviderConnectionDto {
id: number;
provider: GitProvider;
baseUrl: string;
accountLogin: string;
repositories: GitManagedRepositoryDto[];
createdAt: string;
updatedAt: string;
}
export interface GitManagedRepositoryDto {
id: number;
externalId: string;
fullName: string;
webUrl: string;
status: 'connected' | 'error';
lastError: string | null;
}
export interface DevelopmentRepositoryDto {
id: number;
provider: 'github' | 'gitlab';
fullName: string;
webUrl: string;
}
interface ConnectionSecret {
provider: GitProvider;
baseUrl: string;
token: string;
}
const repositoryColumns = {
id: gitManagedRepository.id,
externalId: gitManagedRepository.externalId,
fullName: gitManagedRepository.fullName,
webUrl: gitManagedRepository.webUrl,
status: gitManagedRepository.status,
lastError: gitManagedRepository.lastError,
};
function mapRepository(row: {
id: number;
externalId: string;
fullName: string;
webUrl: string;
status: string;
lastError: string | null;
}): GitManagedRepositoryDto {
return { ...row, status: row.status === 'error' ? 'error' : 'connected' };
}
interface ManagedDevelopmentRepository {
input: ProviderConnectionInput & { provider: 'github' | 'gitlab' };
repository: ProviderRepository;
}
async function managedDevelopmentRepository(
projectId: number,
repositoryId: number,
): Promise<ManagedDevelopmentRepository> {
const [row] = await db
.select({
provider: gitProviderConnection.provider,
baseUrl: gitProviderConnection.baseUrl,
ciphertext: gitProviderConnection.ciphertext,
iv: gitProviderConnection.iv,
authTag: gitProviderConnection.authTag,
externalId: gitManagedRepository.externalId,
fullName: gitManagedRepository.fullName,
webUrl: gitManagedRepository.webUrl,
})
.from(gitManagedRepository)
.innerJoin(
gitProviderConnection,
eq(gitManagedRepository.connectionId, gitProviderConnection.id),
)
.where(
and(
eq(gitManagedRepository.id, repositoryId),
eq(gitManagedRepository.projectId, projectId),
eq(gitManagedRepository.status, 'connected'),
),
)
.limit(1);
if (!row) throw new HttpError(404, 'Managed repository not found');
if (row.provider !== 'github' && row.provider !== 'gitlab')
throw new HttpError(400, 'Creating and linking pull requests supports GitHub and GitLab');
return {
input: { provider: row.provider, baseUrl: row.baseUrl, token: decryptSecret(row) },
repository: {
externalId: row.externalId,
fullName: row.fullName,
webUrl: row.webUrl,
private: false,
},
};
}
export async function listDevelopmentRepositories(
projectId: number,
): Promise<DevelopmentRepositoryDto[]> {
const rows = await db
.select({
id: gitManagedRepository.id,
provider: gitProviderConnection.provider,
fullName: gitManagedRepository.fullName,
webUrl: gitManagedRepository.webUrl,
})
.from(gitManagedRepository)
.innerJoin(
gitProviderConnection,
eq(gitManagedRepository.connectionId, gitProviderConnection.id),
)
.where(
and(
eq(gitManagedRepository.projectId, projectId),
eq(gitManagedRepository.status, 'connected'),
inArray(gitProviderConnection.provider, ['github', 'gitlab']),
),
)
.orderBy(asc(gitProviderConnection.provider), asc(gitManagedRepository.fullName));
return rows.map((row) => ({ ...row, provider: row.provider as 'github' | 'gitlab' }));
}
export async function listManagedPullRequests(
projectId: number,
repositoryId: number,
state: 'open' | 'all',
page: number,
): Promise<{ provider: 'github' | 'gitlab'; repository: string; page: ProviderPullRequestPage }> {
const managed = await managedDevelopmentRepository(projectId, repositoryId);
return {
provider: managed.input.provider,
repository: managed.repository.fullName,
page: await listProviderPullRequests(managed.input, managed.repository, state, page),
};
}
export async function getManagedPullRequest(
projectId: number,
repositoryId: number,
number: number,
): Promise<{ provider: 'github' | 'gitlab'; details: ProviderPullRequestDetails }> {
const managed = await managedDevelopmentRepository(projectId, repositoryId);
return {
provider: managed.input.provider,
details: await getProviderPullRequest(managed.input, managed.repository, number),
};
}
export async function listManagedBranches(
projectId: number,
repositoryId: number,
page: number,
): Promise<ProviderBranchPage> {
const managed = await managedDevelopmentRepository(projectId, repositoryId);
return listProviderBranches(managed.input, managed.repository, page);
}
export async function createManagedPullRequest(
projectId: number,
repositoryId: number,
input: CreateProviderPullRequestInput,
): Promise<{ provider: 'github' | 'gitlab'; details: ProviderPullRequestDetails }> {
const managed = await managedDevelopmentRepository(projectId, repositoryId);
return {
provider: managed.input.provider,
details: await createProviderPullRequest(managed.input, managed.repository, input),
};
}
async function repositoriesByConnection(
projectId: number | undefined,
connectionIds: number[],
): Promise<Map<number, GitManagedRepositoryDto[]>> {
if (connectionIds.length === 0) return new Map();
const rows = await db
.select({ connectionId: gitManagedRepository.connectionId, ...repositoryColumns })
.from(gitManagedRepository)
.where(
projectId === undefined
? inArray(gitManagedRepository.connectionId, connectionIds)
: and(
eq(gitManagedRepository.projectId, projectId),
inArray(gitManagedRepository.connectionId, connectionIds),
),
)
.orderBy(asc(gitManagedRepository.fullName));
const grouped = new Map<number, GitManagedRepositoryDto[]>();
for (const row of rows) {
const repositories = grouped.get(row.connectionId) ?? [];
repositories.push(mapRepository(row));
grouped.set(row.connectionId, repositories);
}
return grouped;
}
export async function listGitProviderConnections(
projectId: number,
): Promise<GitProviderConnectionDto[]> {
const teamId = await projectTeamId(projectId);
return listTeamGitProviderConnections(teamId, projectId);
}
async function projectTeamId(projectId: number): Promise<number> {
const [row] = await db
.select({ teamId: project.teamId })
.from(project)
.where(eq(project.id, projectId))
.limit(1);
if (!row) throw new HttpError(404, 'Project not found');
return row.teamId;
}
export async function listTeamGitProviderConnections(
teamId: number,
projectId?: number,
): Promise<GitProviderConnectionDto[]> {
const rows = await db
.select({
id: gitProviderConnection.id,
provider: gitProviderConnection.provider,
baseUrl: gitProviderConnection.baseUrl,
accountLogin: gitProviderConnection.accountLogin,
createdAt: gitProviderConnection.createdAt,
updatedAt: gitProviderConnection.updatedAt,
})
.from(gitProviderConnection)
.where(eq(gitProviderConnection.teamId, teamId))
.orderBy(asc(gitProviderConnection.provider), asc(gitProviderConnection.baseUrl));
const repositories = await repositoriesByConnection(
projectId,
rows.map((row) => row.id),
);
return rows.map((row) => ({
id: row.id,
provider: row.provider as GitProvider,
baseUrl: row.baseUrl,
accountLogin: row.accountLogin,
repositories: repositories.get(row.id) ?? [],
createdAt: iso(row.createdAt),
updatedAt: iso(row.updatedAt),
}));
}
async function connectionSecret(id: number, projectId: number): Promise<ConnectionSecret> {
return teamConnectionSecret(id, await projectTeamId(projectId));
}
async function teamConnectionSecret(id: number, teamId: number): Promise<ConnectionSecret> {
const rows = await db
.select()
.from(gitProviderConnection)
.where(and(eq(gitProviderConnection.id, id), eq(gitProviderConnection.teamId, teamId)))
.limit(1);
const row = rows[0];
if (!row) throw new HttpError(404, 'Provider connection not found');
if (!['github', 'gitlab', 'gitea', 'forgejo', 'bitbucket'].includes(row.provider)) {
throw new HttpError(400, 'Unknown Git provider');
}
return {
provider: row.provider as GitProvider,
baseUrl: row.baseUrl,
token: decryptSecret(row),
};
}
function providerInput(connection: ConnectionSecret): ProviderConnectionInput {
return {
provider: connection.provider,
baseUrl: connection.baseUrl,
token: connection.token,
};
}
export async function connectGitProvider(
teamId: number,
input: { provider: GitProvider; baseUrl?: string; token: string },
): Promise<GitProviderConnectionDto> {
const token = input.token.trim();
if (!token) throw new HttpError(400, 'token is required');
const baseUrl = await normalizeProviderBaseUrl(input.provider, input.baseUrl);
const accountLogin = await getProviderAccount({ provider: input.provider, baseUrl, token });
const encrypted = encryptSecret(token);
// A team can hold several connections of one account: the migration from
// project-owned connections keeps each project's token. Saving the account
// rotates all of them.
let rows = await db
.update(gitProviderConnection)
.set({ ...encrypted, updatedAt: new Date() })
.where(
and(
eq(gitProviderConnection.teamId, teamId),
eq(gitProviderConnection.provider, input.provider),
eq(gitProviderConnection.baseUrl, baseUrl),
eq(gitProviderConnection.accountLogin, accountLogin),
),
)
.returning({ id: gitProviderConnection.id });
if (rows.length === 0) {
rows = await db
.insert(gitProviderConnection)
.values({ teamId, provider: input.provider, baseUrl, accountLogin, ...encrypted })
.returning({ id: gitProviderConnection.id });
}
const connectionId = rows[0]?.id;
if (!connectionId) throw new HttpError(500, 'Provider connection was not stored');
for (const row of rows) {
await reconcileConnectionWebhooks(row.id, { provider: input.provider, baseUrl, token });
}
const connections = await listTeamGitProviderConnections(teamId);
const connection = connections.find((item) => item.id === connectionId);
if (!connection) throw new HttpError(500, 'Provider connection was not stored');
return connection;
}
async function reconcileConnectionWebhooks(
connectionId: number,
input: ProviderConnectionInput,
): Promise<void> {
const repositories = await db
.select()
.from(gitManagedRepository)
.where(eq(gitManagedRepository.connectionId, connectionId));
const settingsByProject = new Map<number, GitSettings>();
for (const repository of repositories) {
let settings = settingsByProject.get(repository.projectId);
if (!settings) {
settings = await getOrCreateGitSettings(repository.projectId);
settingsByProject.set(repository.projectId, settings);
}
await reconcileRepositoryWebhook(input, repository, settings);
}
}
async function reconcileRepositoryWebhook(
input: ProviderConnectionInput,
repository: typeof gitManagedRepository.$inferSelect,
settings: GitSettings,
): Promise<void> {
try {
const webhookExternalId = await installProviderWebhook(
input,
{
externalId: repository.externalId,
fullName: repository.fullName,
webUrl: repository.webUrl,
private: false,
},
settings.payloadUrl,
settings.secret,
repository.webhookExternalId,
);
await db
.update(gitManagedRepository)
.set({ webhookExternalId, status: 'connected', lastError: null, updatedAt: new Date() })
.where(eq(gitManagedRepository.id, repository.id));
} catch (error) {
await db
.update(gitManagedRepository)
.set({
status: 'error',
lastError: error instanceof Error ? error.message : 'Webhook update failed',
updatedAt: new Date(),
})
.where(eq(gitManagedRepository.id, repository.id));
}
}
export async function listAvailableRepositories(
projectId: number,
connectionId: number,
page: number,
search: string,
) {
const connection = await connectionSecret(connectionId, projectId);
const result = await listProviderRepositories(providerInput(connection), page, search.trim());
const managed = await db
.select({ id: gitManagedRepository.id, externalId: gitManagedRepository.externalId })
.from(gitManagedRepository)
.where(
and(
eq(gitManagedRepository.projectId, projectId),
eq(gitManagedRepository.connectionId, connectionId),
),
);
const managedByExternalId = new Map(managed.map((repo) => [repo.externalId, repo.id]));
return {
repositories: result.repositories.map((repo) => ({
...repo,
managedRepositoryId: managedByExternalId.get(repo.externalId) ?? null,
})),
nextPage: result.nextPage,
};
}
export async function connectRepositories(
projectId: number,
connectionId: number,
externalIds: string[],
): Promise<GitProviderConnectionDto> {
const ids = [...new Set(externalIds.map((id) => id.trim()).filter(Boolean))];
if (ids.length === 0) throw new HttpError(400, 'Select at least one repository');
if (ids.length > 50) throw new HttpError(400, 'Select at most 50 repositories');
const connection = await connectionSecret(connectionId, projectId);
const existing = await db
.select({ externalId: gitManagedRepository.externalId })
.from(gitManagedRepository)
.where(
and(
eq(gitManagedRepository.connectionId, connectionId),
eq(gitManagedRepository.projectId, projectId),
inArray(gitManagedRepository.externalId, ids),
),
);
const existingIds = new Set(existing.map((repo) => repo.externalId));
const settings = await getOrCreateGitSettings(projectId);
for (const externalId of ids) {
if (existingIds.has(externalId)) continue;
const repository = await getProviderRepository(providerInput(connection), externalId);
const webhookExternalId = await installProviderWebhook(
providerInput(connection),
repository,
settings.payloadUrl,
settings.secret,
null,
);
await db.insert(gitManagedRepository).values({
projectId,
connectionId,
externalId: repository.externalId,
fullName: repository.fullName,
webUrl: repository.webUrl,
webhookExternalId,
});
}
return connectionDto(projectId, connectionId);
}
async function connectionDto(projectId: number, connectionId: number) {
const connections = await listGitProviderConnections(projectId);
const connection = connections.find((item) => item.id === connectionId);
if (!connection) throw new HttpError(404, 'Provider connection not found');
return connection;
}
export async function disconnectRepository(
projectId: number,
connectionId: number,
repositoryId: number,
): Promise<void> {
const connection = await connectionSecret(connectionId, projectId);
const rows = await db
.select()
.from(gitManagedRepository)
.where(
and(
eq(gitManagedRepository.id, repositoryId),
eq(gitManagedRepository.connectionId, connectionId),
eq(gitManagedRepository.projectId, projectId),
),
)
.limit(1);
const row = rows[0];
if (!row) throw new HttpError(404, 'Managed repository not found');
await deleteProviderWebhook(
providerInput(connection),
{ externalId: row.externalId, fullName: row.fullName, webUrl: row.webUrl, private: false },
row.webhookExternalId,
);
await db.delete(gitManagedRepository).where(eq(gitManagedRepository.id, repositoryId));
}
export async function disconnectGitProvider(teamId: number, connectionId: number): Promise<void> {
const connection = await teamConnectionSecret(connectionId, teamId);
const repositories = await db
.select()
.from(gitManagedRepository)
.where(eq(gitManagedRepository.connectionId, connectionId));
for (const repository of repositories) {
await deleteProviderWebhook(
providerInput(connection),
{
externalId: repository.externalId,
fullName: repository.fullName,
webUrl: repository.webUrl,
private: false,
},
repository.webhookExternalId,
);
}
await db
.delete(gitProviderConnection)
.where(
and(eq(gitProviderConnection.id, connectionId), eq(gitProviderConnection.teamId, teamId)),
);
}
export async function reconcileManagedWebhooks(
projectId: number,
settings: GitSettings,
): Promise<void> {
const connections = await listGitProviderConnections(projectId);
for (const item of connections) {
const input = providerInput(await connectionSecret(item.id, projectId));
const repositories = await db
.select()
.from(gitManagedRepository)
.where(
and(
eq(gitManagedRepository.projectId, projectId),
eq(gitManagedRepository.connectionId, item.id),
),
);
for (const repository of repositories) {
await reconcileRepositoryWebhook(input, repository, settings);
}
}
}
export async function postPullRequestLinkback(
projectId: number,
provider: GitProvider,
repository: string,
number: number,
body: string,
): Promise<boolean> {
const [row] = await db
.select({
provider: gitProviderConnection.provider,
baseUrl: gitProviderConnection.baseUrl,
ciphertext: gitProviderConnection.ciphertext,
iv: gitProviderConnection.iv,
authTag: gitProviderConnection.authTag,
externalId: gitManagedRepository.externalId,
fullName: gitManagedRepository.fullName,
webUrl: gitManagedRepository.webUrl,
})
.from(gitManagedRepository)
.innerJoin(
gitProviderConnection,
eq(gitManagedRepository.connectionId, gitProviderConnection.id),
)
.where(
and(
eq(gitManagedRepository.projectId, projectId),
eq(gitProviderConnection.provider, provider),
eq(gitManagedRepository.fullName, repository),
),
)
.limit(1);
if (!row) return false;
await createPullRequestComment(
{
provider,
baseUrl: row.baseUrl,
token: decryptSecret(row),
},
{
externalId: row.externalId,
fullName: row.fullName,
webUrl: row.webUrl,
private: false,
},
number,
body,
);
return true;
}