⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.
TypeScript honoissue-managementissue-trackerjira-alternativekanbanlinear-alternativemcpproject-managementreactself-hostedtypescript
import type { InferSelectModel } from "drizzle-orm";
import { and, eq } from "drizzle-orm";
import db from "../../../database";
import {
columnTable,
integrationTable,
taskTable,
} from "../../../database/schema";
import { type GitHubConfig, hasVerifiedGitHubBinding } from "../config";
import { extractTaskLinks } from "../utils/task-references";
import type { IntegrationDatabase } from "./integration-task-scope";
import { activeIntegrationCondition } from "../../active-integration-condition";
export type TaskRow = InferSelectModel<typeof taskTable>;
export type UpdateTaskStatusResult =
| { applied: false }
| { applied: true; before: TaskRow; after: TaskRow };
const NON_COLUMN_STATUSES = new Set(["planned", "archived"]);
export async function findTaskByNumber(
projectId: string,
taskNumber: number,
database: Pick<typeof db, "query"> = db,
) {
return database.query.taskTable.findFirst({
where: and(
eq(taskTable.projectId, projectId),
eq(taskTable.number, taskNumber),
),
});
}
export async function findTaskByLink(
projectId: string,
texts: (string | null | undefined)[],
database: Pick<typeof db, "query"> = db,
) {
const links = extractTaskLinks(...texts);
const link = links.length === 1 ? links[0] : undefined;
if (link?.projectId !== projectId) return;
return database.query.taskTable.findFirst({
where: and(
eq(taskTable.projectId, projectId),
eq(taskTable.id, link.taskId),
),
});
}
export async function findTaskById(
taskId: string,
database: Pick<typeof db, "query"> = db,
) {
return database.query.taskTable.findFirst({
where: eq(taskTable.id, taskId),
});
}
export async function updateTaskStatus(
taskId: string,
newStatus: string,
database: IntegrationDatabase = db,
): Promise<UpdateTaskStatusResult> {
const task = await database.query.taskTable.findFirst({
where: eq(taskTable.id, taskId),
});
if (!task) {
return { applied: false };
}
let columnId: string | null = null;
const column = await database.query.columnTable.findFirst({
where: and(
eq(columnTable.projectId, task.projectId),
eq(columnTable.slug, newStatus),
),
});
if (column) {
columnId = column.id;
} else if (!NON_COLUMN_STATUSES.has(newStatus)) {
console.warn(
`[GitHub] Skipping status update for task ${taskId}: column "${newStatus}" not found in project ${task.projectId}`,
);
return { applied: false };
}
const [after] = await database
.update(taskTable)
.set({ status: newStatus, columnId })
.where(
and(eq(taskTable.id, taskId), eq(taskTable.projectId, task.projectId)),
)
.returning();
if (!after) {
return { applied: false };
}
return { applied: true, before: task, after };
}
export async function isTaskInFinalState(
task: {
projectId: string;
status: string;
columnId: string | null;
},
database: Pick<typeof db, "query"> = db,
): Promise<boolean> {
if (task.columnId) {
const columnById = await database.query.columnTable.findFirst({
where: and(
eq(columnTable.id, task.columnId),
eq(columnTable.projectId, task.projectId),
),
});
if (columnById) {
return columnById.isFinal;
}
}
const columnByStatus = await database.query.columnTable.findFirst({
where: and(
eq(columnTable.projectId, task.projectId),
eq(columnTable.slug, task.status),
),
});
if (columnByStatus) {
return columnByStatus.isFinal;
}
return task.status === "done";
}
export async function getIntegrationWithProject(integrationId: string) {
return db.query.integrationTable.findFirst({
where: eq(integrationTable.id, integrationId),
with: {
project: true,
},
});
}
export type GitHubWebhookSource = {
installation?: { id: number };
repository: { id: number };
};
export async function findAllIntegrationsByRepo(source: GitHubWebhookSource) {
const installationId = source.installation?.id;
const repositoryId = source.repository.id;
if (
!Number.isSafeInteger(installationId) ||
!Number.isSafeInteger(repositoryId)
)
return [];
const integrations = await db.query.integrationTable.findMany({
where: and(
eq(integrationTable.type, "github"),
activeIntegrationCondition(),
),
with: { project: true },
});
return integrations.filter((integration) => {
try {
const config = JSON.parse(integration.config) as GitHubConfig;
return (
hasVerifiedGitHubBinding(config) &&
config.installationId === installationId &&
config.repositoryId === repositoryId
);
} catch {
return false;
}
});
}