⚡ 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 { extractAssetIds } from "../../storage/cleanup-assets";
import { and, eq, inArray, isNull } from "drizzle-orm";
import { HTTPException } from "hono/http-exception";
import db from "../../database";
import {
assetTable,
columnTable,
customFieldDefinitionTable,
customFieldValueTable,
taskTable,
projectTable,
userTable,
} from "../../database/schema";
import {
findNewHiddenPicks,
isChoiceType,
readHiddenOptions,
readOptions,
} from "../../custom-field/choice-options";
import { publishEvent } from "../../events";
import {
assertAssignableUser,
getProjectWorkspaceId,
} from "../../utils/assert-assignable-user";
import type { TaskRecurrence } from "../recurrence/schema";
import {
assertRequiredCustomFields,
assertValidTaskStatus,
isCustomFieldValueEmpty,
} from "../validate-task-fields";
import { claimTaskNumber } from "./claim-task-numbers";
import { nextTaskPosition } from "./next-task-position";
type CustomFieldInput = {
fieldId: string;
value: string;
};
function deduplicateCustomFields(
customFields?: CustomFieldInput[],
): CustomFieldInput[] | undefined {
if (!customFields) {
return undefined;
}
const fieldsById = new Map<string, CustomFieldInput>();
for (const customField of customFields) {
fieldsById.set(customField.fieldId, customField);
}
return Array.from(fieldsById.values());
}
async function createTask({
projectId,
currentUserId,
userId,
title,
status,
startDate,
dueDate,
description,
priority,
recurrence,
customFields,
draftAssetIds,
}: {
projectId: string;
currentUserId: string;
userId?: string;
title: string;
status: string;
startDate?: Date;
dueDate?: Date;
description?: string;
priority?: string;
recurrence?: TaskRecurrence;
customFields?: CustomFieldInput[];
draftAssetIds?: string[];
}) {
const resolvedStatus = status || "to-do";
const resolvedPriority = priority || "no-priority";
const normalizedCustomFields = deduplicateCustomFields(customFields);
const normalizedUserId = userId?.trim() || undefined;
await assertValidTaskStatus(resolvedStatus, projectId);
const allFields = await db
.select()
.from(customFieldDefinitionTable)
.where(eq(customFieldDefinitionTable.projectId, projectId));
for (const input of normalizedCustomFields ?? []) {
const field = allFields.find((candidate) => candidate.id === input.fieldId);
if (!field || !isChoiceType(field.type)) continue;
const hidden = readHiddenOptions(
field.hiddenOptions,
readOptions(field.options),
);
if (findNewHiddenPicks(input.value, null, field.type, hidden).length > 0) {
throw new HTTPException(400, {
message: `Custom field "${field.name}" has a hidden option selected.`,
});
}
}
const mergedCustomFields: CustomFieldInput[] = normalizedCustomFields ?? [];
const providedFieldIds = new Set(mergedCustomFields.map((f) => f.fieldId));
for (const field of allFields) {
if (
!providedFieldIds.has(field.id) &&
field.required &&
field.defaultValue != null &&
!isCustomFieldValueEmpty(
field.defaultValue,
field.type as
| "number"
| "boolean"
| "date"
| "dropdown"
| "multiselect",
)
) {
mergedCustomFields.push({
fieldId: field.id,
value: field.defaultValue,
});
}
}
await assertRequiredCustomFields(projectId, mergedCustomFields);
let assignee: { name: string } | undefined;
if (normalizedUserId) {
await assertAssignableUser(
normalizedUserId,
await getProjectWorkspaceId(projectId),
projectId,
);
[assignee] = await db
.select({ name: userTable.name })
.from(userTable)
.where(eq(userTable.id, normalizedUserId));
}
const column = await db.query.columnTable.findFirst({
where: and(
eq(columnTable.projectId, projectId),
eq(columnTable.slug, resolvedStatus),
),
});
// A rule would never fire on a task that starts out completed.
if (recurrence && column?.isFinal)
throw new HTTPException(400, {
message: "Create the task in an open column to make it repeat",
});
const createdTask = await db.transaction(async (tx) => {
const taskNumber = await claimTaskNumber(projectId, tx);
const nextPosition = await nextTaskPosition(
tx,
projectId,
resolvedStatus,
column?.id ?? null,
);
const [task] = await tx
.insert(taskTable)
.values({
projectId,
userId: normalizedUserId ?? null,
title: title || "",
status: resolvedStatus,
columnId: column?.id ?? null,
startDate: startDate || null,
dueDate: dueDate || null,
description: description || "",
priority: resolvedPriority,
recurrence: recurrence ?? null,
number: taskNumber,
position: nextPosition,
})
.returning();
if (task && draftAssetIds?.length) {
const referenced = extractAssetIds(description);
const ids = [...new Set(draftAssetIds)].filter((id) =>
referenced.has(id),
);
if (ids.length) {
// claimTaskNumber already holds the project row lock in this transaction.
const project = await tx.query.projectTable.findFirst({
columns: { workspaceId: true },
where: eq(projectTable.id, projectId),
});
if (!project)
throw new HTTPException(404, { message: "Project not found" });
const claimed = await tx
.update(assetTable)
.set({
taskId: task.id,
surface: "description",
workspaceId: project.workspaceId,
})
.where(
and(
inArray(assetTable.id, ids),
eq(assetTable.projectId, projectId),
eq(assetTable.createdBy, currentUserId),
eq(assetTable.surface, "draft"),
isNull(assetTable.taskId),
),
)
.returning({ id: assetTable.id });
if (claimed.length !== ids.length)
throw new HTTPException(400, {
message:
"Some staged uploads are unavailable or belong to another owner/project",
});
}
}
if (task && mergedCustomFields.length) {
await tx.insert(customFieldValueTable).values(
mergedCustomFields.map(({ fieldId, value }) => ({
taskId: task.id,
fieldId,
value: value.trim(),
})),
);
}
return task;
});
if (!createdTask) {
throw new HTTPException(500, {
message: "Failed to create task",
});
}
await publishEvent("task.created", {
...createdTask,
taskId: createdTask.id,
userId: createdTask.userId ?? "",
currentUserId: currentUserId,
type: "created",
content: null,
});
return {
...createdTask,
assigneeName: assignee?.name,
};
}
export default createTask;