Hartmut/CapaKraken
1
0
Fork 0
Code Issues 10 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

perf(db): add missing indexes, fix N+1 batch delete, add pagination limits

Browse Source 
- Add indexes on Resource(blueprintId, roleId), DemandRequirement(roleId),
  Assignment(roleId) — commonly filtered FK columns that were missing indexes
- Replace N+1 batch delete pattern (2N queries) with findAllocationEntries()
  that does 2 total queries via findMany({ id: { in: ids } })
- Add take/skip pagination with default limit of 500 to listDemands and
  listAssignments to prevent unbounded result sets

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Hartmut Nörenberg
2026-04-11 08:09:39 +02:00
parent 110e4ff1aa
commit c098cedf06
7 changed files with 264 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/api/src/__tests__/allocation-router.test.ts
+83 -39
View File
@@ -1,7 +1,11 @@
import { AllocationStatus, PermissionKey, SystemRole } from "@capakraken/shared";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { allocationRouter } from "../router/allocation/index.js";
import { emitAllocationCreated, emitAllocationDeleted, emitNotificationCreated } from "../sse/event-bus.js";
import {
emitAllocationCreated,
emitAllocationDeleted,
emitNotificationCreated,
} from "../sse/event-bus.js";
import { checkBudgetThresholds } from "../lib/budget-alerts.js";
import { generateAutoSuggestions } from "../lib/auto-staffing.js";
import { invalidateDashboardCache } from "../lib/cache.js";
@@ -155,6 +159,8 @@ describe("allocation router authorization", () => {
where: {},
include: expect.any(Object),
orderBy: { startDate: "asc" },
take: 500,
skip: 0,
});
});
@@ -196,9 +202,12 @@ describe("allocation router authorization", () => {
});
it("does not treat viewCosts as a substitute for viewPlanning on planning reads", async () => {
const caller = createProtectedCallerWithOverrides({}, {
granted: [PermissionKey.VIEW_COSTS],
});
const caller = createProtectedCallerWithOverrides(
{},
{
granted: [PermissionKey.VIEW_COSTS],
},
);
await expect(caller.listAssignments({})).rejects.toMatchObject({
code: "FORBIDDEN",
@@ -208,32 +217,47 @@ describe("allocation router authorization", () => {
it.each([
{ name: "list", invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.list({}) },
{ name: "listView", invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.listView({}) },
{ name: "listDemands", invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.listDemands({}) },
{ name: "listAssignments", invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.listAssignments({}) },
{
name: "listView",
invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.listView({}),
},
{
name: "listDemands",
invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.listDemands({}),
},
{
name: "listAssignments",
invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.listAssignments({}),
},
{
name: "getAssignmentById",
invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.getAssignmentById({ id: "assignment_1" }),
invoke: (caller: ReturnType<typeof createProtectedCaller>) =>
caller.getAssignmentById({ id: "assignment_1" }),
},
{
name: "resolveAssignment",
invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.resolveAssignment({ assignmentId: "assignment_1" }),
invoke: (caller: ReturnType<typeof createProtectedCaller>) =>
caller.resolveAssignment({ assignmentId: "assignment_1" }),
},
{
name: "getDemandRequirementById",
invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.getDemandRequirementById({ id: "demand_1" }),
invoke: (caller: ReturnType<typeof createProtectedCaller>) =>
caller.getDemandRequirementById({ id: "demand_1" }),
},
{
name: "checkResourceAvailability",
invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.checkResourceAvailability(planningWindow),
invoke: (caller: ReturnType<typeof createProtectedCaller>) =>
caller.checkResourceAvailability(planningWindow),
},
{
name: "getResourceAvailabilityView",
invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.getResourceAvailabilityView(planningWindow),
invoke: (caller: ReturnType<typeof createProtectedCaller>) =>
caller.getResourceAvailabilityView(planningWindow),
},
{
name: "getResourceAvailabilitySummary",
invoke: (caller: ReturnType<typeof createProtectedCaller>) => caller.getResourceAvailabilitySummary(planningWindow),
invoke: (caller: ReturnType<typeof createProtectedCaller>) =>
caller.getResourceAvailabilitySummary(planningWindow),
},
])("requires planning read access for $name", async ({ invoke }) => {
const caller = createProtectedCaller({});
@@ -708,7 +732,9 @@ describe("allocation entry resolution router", () => {
it("logs and swallows background side-effect failures during demand creation", async () => {
vi.mocked(invalidateDashboardCache).mockRejectedValueOnce(new Error("redis unavailable"));
vi.mocked(checkBudgetThresholds).mockRejectedValueOnce(new Error("budget alerts unavailable"));
vi.mocked(generateAutoSuggestions).mockRejectedValueOnce(new Error("auto suggestions unavailable"));
vi.mocked(generateAutoSuggestions).mockRejectedValueOnce(
new Error("auto suggestions unavailable"),
);
const createdDemandRequirement = {
id: "demand_safe_1",
@@ -761,7 +787,10 @@ describe("allocation entry resolution router", () => {
"Allocation background side effect failed",
);
expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
expect.objectContaining({ effectName: "generateAutoSuggestions", demandRequirementId: "demand_safe_1" }),
expect.objectContaining({
effectName: "generateAutoSuggestions",
demandRequirementId: "demand_safe_1",
}),
"Allocation background side effect failed",
);
});
@@ -1017,7 +1046,8 @@ describe("allocation entry resolution router", () => {
}),
},
demandRequirement: {
findUnique: vi.fn()
findUnique: vi
.fn()
.mockResolvedValueOnce({
id: "demand_1",
projectId: "project_1",
@@ -1182,7 +1212,11 @@ describe("allocation entry resolution router", () => {
expect(db.assignment.delete).toHaveBeenCalledWith({
where: { id: "assignment_explicit_1" },
});
expect(emitAllocationDeleted).toHaveBeenCalledWith("assignment_explicit_1", "project_1", "resource_1");
expect(emitAllocationDeleted).toHaveBeenCalledWith(
"assignment_explicit_1",
"project_1",
"resource_1",
);
});
it("updates an explicit demand row through allocation.update", async () => {
@@ -1276,15 +1310,13 @@ describe("allocation entry resolution router", () => {
const db = {
demandRequirement: {
findUnique: vi.fn().mockImplementation(
({ where }: { where: { id?: string } }) => {
if (where.id === "demand_stale") {
return existingDemand;
}
findUnique: vi.fn().mockImplementation(({ where }: { where: { id?: string } }) => {
if (where.id === "demand_stale") {
return existingDemand;
}
return null;
},
),
return null;
}),
update: vi.fn().mockResolvedValue(updatedDemand),
},
assignment: {
@@ -1360,15 +1392,29 @@ describe("allocation entry resolution router", () => {
findUnique: vi.fn().mockResolvedValue(null),
},
demandRequirement: {
findUnique: vi.fn().mockImplementation(({ where }: { where: { id: string } }) =>
where.id === "demand_1" ? explicitDemand : null,
),
findUnique: vi
.fn()
.mockImplementation(({ where }: { where: { id: string } }) =>
where.id === "demand_1" ? explicitDemand : null,
),
findMany: vi
.fn()
.mockImplementation(({ where }: { where: { id: { in: string[] } } }) =>
[explicitDemand].filter((d) => where.id.in.includes(d.id)),
),
delete: vi.fn().mockResolvedValue({}),
},
assignment: {
findUnique: vi.fn().mockImplementation(({ where }: { where: { id: string } }) =>
where.id === "assignment_1" ? explicitAssignment : null,
),
findUnique: vi
.fn()
.mockImplementation(({ where }: { where: { id: string } }) =>
where.id === "assignment_1" ? explicitAssignment : null,
),
findMany: vi
.fn()
.mockImplementation(({ where }: { where: { id: { in: string[] } } }) =>
[explicitAssignment].filter((a) => where.id.in.includes(a.id)),
),
updateMany: vi.fn().mockResolvedValue({ count: 0 }),
delete: vi.fn().mockResolvedValue({}),
},
@@ -1424,15 +1470,13 @@ describe("allocation entry resolution router", () => {
findUnique: vi.fn().mockResolvedValue(null),
},
assignment: {
findUnique: vi.fn().mockImplementation(
({ where }: { where: { id?: string } }) => {
if (where.id === "assignment_stale") {
return existingAssignment;
}
findUnique: vi.fn().mockImplementation(({ where }: { where: { id?: string } }) => {
if (where.id === "assignment_stale") {
return existingAssignment;
}
return null;
},
),
return null;
}),
delete: vi.fn().mockResolvedValue({}),
},
auditLog: {
packages/api/src/router/allocation/assignment-mutations.ts
+57 -77
View File
@@ -4,6 +4,7 @@ import {
createDemandRequirement,
deleteAllocationEntry,
deleteAssignment,
findAllocationEntries,
loadAllocationEntry,
updateAllocationEntry,
updateAssignment,
@@ -68,21 +69,18 @@ export async function createAllocationReadModelEntry(
}).allocations[0]!;
}
const assignment = await createAssignment(
tx,
{
resourceId: input.resourceId,
projectId: input.projectId,
startDate: input.startDate,
endDate: input.endDate,
hoursPerDay: input.hoursPerDay,
percentage: input.percentage,
role: input.role,
roleId: input.roleId,
status: input.status,
metadata: input.metadata,
},
);
const assignment = await createAssignment(tx, {
resourceId: input.resourceId,
projectId: input.projectId,
startDate: input.startDate,
endDate: input.endDate,
hoursPerDay: input.hoursPerDay,
percentage: input.percentage,
role: input.role,
roleId: input.roleId,
status: input.status,
metadata: input.metadata,
});
return buildSplitAllocationReadModel({
demandRequirements: [],
@@ -94,17 +92,20 @@ export async function ensureAssignmentRecord(
db: Pick<PrismaClient, "$transaction" | "assignment" | "resource">,
input: EnsureAssignmentInput,
) {
const existing = (await db.assignment.findMany({
where: {
resourceId: input.resourceId,
projectId: input.projectId,
},
include: ASSIGNMENT_INCLUDE,
orderBy: { startDate: "asc" },
})).find((assignment) => (
toIsoDate(assignment.startDate) === toIsoDate(input.startDate)
&& toIsoDate(assignment.endDate) === toIsoDate(input.endDate)
));
const existing = (
await db.assignment.findMany({
where: {
resourceId: input.resourceId,
projectId: input.projectId,
},
include: ASSIGNMENT_INCLUDE,
orderBy: { startDate: "asc" },
})
).find(
(assignment) =>
toIsoDate(assignment.startDate) === toIsoDate(input.startDate) &&
toIsoDate(assignment.endDate) === toIsoDate(input.endDate),
);
if (existing) {
if (existing.status !== AllocationStatus.CANCELLED) {
@@ -122,24 +123,21 @@ export async function ensureAssignmentRecord(
throw new TRPCError({ code: "NOT_FOUND", message: "Resource not found" });
}
const updated = await db.$transaction(async (tx) => updateAssignment(
tx as Parameters<typeof updateAssignment>[0],
existing.id,
{
const updated = await db.$transaction(async (tx) =>
updateAssignment(tx as Parameters<typeof updateAssignment>[0], existing.id, {
status: AllocationStatus.PROPOSED,
hoursPerDay: input.hoursPerDay,
percentage: (input.hoursPerDay / 8) * 100,
dailyCostCents: Math.round(resource.lcrCents * input.hoursPerDay),
...(input.role ? { role: input.role } : {}),
},
));
}),
);
return { assignment: updated, action: "reactivated" as const };
}
const assignment = await db.$transaction(async (tx) => createAssignment(
tx as Parameters<typeof createAssignment>[0],
{
const assignment = await db.$transaction(async (tx) =>
createAssignment(tx as Parameters<typeof createAssignment>[0], {
resourceId: input.resourceId,
projectId: input.projectId,
startDate: input.startDate,
@@ -149,8 +147,8 @@ export async function ensureAssignmentRecord(
status: AllocationStatus.PROPOSED,
metadata: {},
...(input.role ? { role: input.role } : {}),
},
));
}),
);
return { assignment, action: "created" as const };
}
@@ -168,8 +166,7 @@ export async function updateAllocationWithAudit(
id,
demandRequirementUpdate:
existing.kind === "assignment" ? {} : toDemandRequirementUpdateInput(data),
assignmentUpdate:
existing.kind === "demand" ? {} : toAssignmentUpdateInput(data),
assignmentUpdate: existing.kind === "demand" ? {} : toAssignmentUpdateInput(data),
},
);
@@ -191,10 +188,7 @@ export async function updateAllocationWithAudit(
return { existing, updated };
}
export async function deleteAssignmentWithAudit(
db: AllocationMutationDb,
id: string,
) {
export async function deleteAssignmentWithAudit(db: AllocationMutationDb, id: string) {
const existing = await findUniqueOrThrow(
db.assignment.findUnique({
where: { id },
@@ -204,10 +198,7 @@ export async function deleteAssignmentWithAudit(
);
await db.$transaction(async (tx) => {
await deleteAssignment(
tx as Parameters<typeof deleteAssignment>[0],
id,
);
await deleteAssignment(tx as Parameters<typeof deleteAssignment>[0], id);
await tx.auditLog.create({
data: {
@@ -222,24 +213,20 @@ export async function deleteAssignmentWithAudit(
return existing;
}
export async function deleteAllocationWithAudit(
db: AllocationMutationDb,
id: string,
) {
export async function deleteAllocationWithAudit(db: AllocationMutationDb, id: string) {
const existing = await loadAllocationEntry(db, id);
await db.$transaction(async (tx) => {
await deleteAllocationEntry(
tx as Parameters<typeof deleteAllocationEntry>[0],
existing,
);
await deleteAllocationEntry(tx as Parameters<typeof deleteAllocationEntry>[0], existing);
await tx.auditLog.create({
data: {
entityType: "Allocation",
entityId: id,
action: "DELETE",
changes: { before: existing.entry } as unknown as import("@capakraken/db").Prisma.InputJsonValue,
changes: {
before: existing.entry,
} as unknown as import("@capakraken/db").Prisma.InputJsonValue,
},
});
});
@@ -247,20 +234,13 @@ export async function deleteAllocationWithAudit(
return existing;
}
export async function batchDeleteAllocationsWithAudit(
db: AllocationMutationDb,
ids: string[],
) {
const existing = (
await Promise.all(ids.map(async (id) => findAllocationEntryOrNull(db, id)))
).filter((entry): entry is NonNullable<typeof entry> => Boolean(entry));
export async function batchDeleteAllocationsWithAudit(db: AllocationMutationDb, ids: string[]) {
// Batch-load in 2 queries (demand + assignment) instead of 2N individual lookups
const existing = await findAllocationEntries(db, ids);
await db.$transaction(async (tx) => {
for (const allocation of existing) {
await deleteAllocationEntry(
tx as Parameters<typeof deleteAllocationEntry>[0],
allocation,
);
await deleteAllocationEntry(tx as Parameters<typeof deleteAllocationEntry>[0], allocation);
}
await tx.auditLog.create({
@@ -290,16 +270,16 @@ export async function batchUpdateAllocationStatusWithAudit(
) {
const updated = await db.$transaction(async (tx) => {
const updatedAllocations = await Promise.all(
input.ids.map(async (id) => (
await updateAllocationEntry(
tx as Parameters<typeof updateAllocationEntry>[0],
{
id,
demandRequirementUpdate: { status: input.status },
assignmentUpdate: { status: input.status },
},
)
).allocation),
input.ids.map(
async (id) =>
(
await updateAllocationEntry(tx as Parameters<typeof updateAllocationEntry>[0], {
id,
demandRequirementUpdate: { status: input.status },
assignmentUpdate: { status: input.status },
})
).allocation,
),
);
await tx.auditLog.create({
packages/api/src/router/allocation/read.ts
+58 -35
View File
@@ -5,7 +5,11 @@ import { anonymizeResource, getAnonymizationDirectory } from "../../lib/anonymiz
import { planningReadProcedure } from "../../trpc.js";
import { buildResourceAvailabilitySummary, buildResourceAvailabilityView } from "./availability.js";
import { ASSIGNMENT_INCLUDE, DEMAND_INCLUDE } from "./shared.js";
import { getDemandRequirementByIdOrThrow, loadAllocationReadModel, resolveAssignmentBySelection } from "./support.js";
import {
getDemandRequirementByIdOrThrow,
loadAllocationReadModel,
resolveAssignmentBySelection,
} from "./support.js";
export const allocationReadProcedures = {
list: planningReadProcedure
@@ -37,6 +41,8 @@ export const allocationReadProcedures = {
projectId: z.string().optional(),
status: z.nativeEnum(AllocationStatus).optional(),
roleId: z.string().optional(),
take: z.number().int().min(1).max(1000).default(500),
skip: z.number().int().min(0).default(0),
}),
)
.query(async ({ ctx, input }) => {
@@ -48,6 +54,8 @@ export const allocationReadProcedures = {
},
include: DEMAND_INCLUDE,
orderBy: { startDate: "asc" },
take: input.take,
skip: input.skip,
});
const directory = await getAnonymizationDirectory(ctx.db);
if (!directory) {
@@ -55,11 +63,11 @@ export const allocationReadProcedures = {
}
return demands.map((demand) => ({
...demand,
assignments: demand.assignments.map((assignment) => (
assignments: demand.assignments.map((assignment) =>
assignment.resource
? { ...assignment, resource: anonymizeResource(assignment.resource, directory) }
: assignment
)),
: assignment,
),
}));
}),
@@ -70,6 +78,8 @@ export const allocationReadProcedures = {
resourceId: z.string().optional(),
status: z.nativeEnum(AllocationStatus).optional(),
demandRequirementId: z.string().optional(),
take: z.number().int().min(1).max(1000).default(500),
skip: z.number().int().min(0).default(0),
}),
)
.query(async ({ ctx, input }) => {
@@ -82,16 +92,18 @@ export const allocationReadProcedures = {
},
include: ASSIGNMENT_INCLUDE,
orderBy: { startDate: "asc" },
take: input.take,
skip: input.skip,
});
const directory = await getAnonymizationDirectory(ctx.db);
if (!directory) {
return assignments;
}
return assignments.map((assignment) => (
return assignments.map((assignment) =>
assignment.resource
? { ...assignment, resource: anonymizeResource(assignment.resource, directory) }
: assignment
));
: assignment,
);
}),
getAssignmentById: planningReadProcedure
@@ -115,15 +127,17 @@ export const allocationReadProcedures = {
}),
resolveAssignment: planningReadProcedure
.input(z.object({
assignmentId: z.string().optional(),
resourceId: z.string().optional(),
projectId: z.string().optional(),
startDate: z.coerce.date().optional(),
endDate: z.coerce.date().optional(),
selectionMode: z.enum(["WINDOW", "EXACT_START"]).default("EXACT_START"),
excludeCancelled: z.boolean().default(false),
}))
.input(
z.object({
assignmentId: z.string().optional(),
resourceId: z.string().optional(),
projectId: z.string().optional(),
startDate: z.coerce.date().optional(),
endDate: z.coerce.date().optional(),
selectionMode: z.enum(["WINDOW", "EXACT_START"]).default("EXACT_START"),
excludeCancelled: z.boolean().default(false),
}),
)
.query(async ({ ctx, input }) => resolveAssignmentBySelection(ctx.db, input)),
getDemandRequirementById: planningReadProcedure
@@ -131,33 +145,42 @@ export const allocationReadProcedures = {
.query(async ({ ctx, input }) => getDemandRequirementByIdOrThrow(ctx.db, input.id)),
checkResourceAvailability: planningReadProcedure
.input(z.object({
resourceId: z.string(),
startDate: z.coerce.date(),
endDate: z.coerce.date(),
hoursPerDay: z.number().min(0.5).max(24).default(8),
}))
.input(
z.object({
resourceId: z.string(),
startDate: z.coerce.date(),
endDate: z.coerce.date(),
hoursPerDay: z.number().min(0.5).max(24).default(8),
}),
)
.query(async ({ ctx, input }) => {
const { vacations: _vacations, ...availability } = await buildResourceAvailabilityView(ctx.db, input);
const { vacations: _vacations, ...availability } = await buildResourceAvailabilityView(
ctx.db,
input,
);
return availability;
}),
getResourceAvailabilityView: planningReadProcedure
.input(z.object({
resourceId: z.string(),
startDate: z.coerce.date(),
endDate: z.coerce.date(),
hoursPerDay: z.number().min(0.5).max(24).default(8),
}))
.input(
z.object({
resourceId: z.string(),
startDate: z.coerce.date(),
endDate: z.coerce.date(),
hoursPerDay: z.number().min(0.5).max(24).default(8),
}),
)
.query(async ({ ctx, input }) => buildResourceAvailabilityView(ctx.db, input)),
getResourceAvailabilitySummary: planningReadProcedure
.input(z.object({
resourceId: z.string(),
startDate: z.coerce.date(),
endDate: z.coerce.date(),
hoursPerDay: z.number().min(0.5).max(24).default(8),
}))
.input(
z.object({
resourceId: z.string(),
startDate: z.coerce.date(),
endDate: z.coerce.date(),
hoursPerDay: z.number().min(0.5).max(24).default(8),
}),
)
.query(async ({ ctx, input }) => {
const availability = await buildResourceAvailabilityView(ctx.db, input);
return buildResourceAvailabilitySummary(availability, input);