refactor(server): move the team runtime into a postponed package (P1.1)

Team mode stays in the repository but is not built or shipped (ADR-0003).

- The team server (index.ts, config, db, daemons, plugins, proactive,
  routes, scheduler, services, ws, drizzle migrations) and its tests move
  from @waggle/server to packages/team-server (@waggle/team-server,
  private). It keeps its own copies of the logger and the agent-group
  executor, so it does not import @waggle/server. @clerk/fastify, bullmq,
  ioredis, postgres, drizzle-orm, drizzle-kit, cron-parser and
  @waggle/waggle-dance leave @waggle/server; the launcher drops the same
  team-only dependencies.
- build:packages no longer builds waggle-dance or the worker: nothing in
  the community edition imports them, and the worker's project reference
  would otherwise build the team server. The worker now imports from
  team-server; the team Dockerfile builds both explicitly.
- The sidecar no longer starts the team server when DATABASE_URL is set,
  and loses the team routes (/api/team/*, /api/teams), the WaggleDance
  routes and bridge (/api/waggle-dance/*), the Team server binding and
  egress guard, the WebSocket team client, the TeamSync cache and pushes,
  team audit forwarding, team workspace registration and the team
  capability-policy lookup in chat. The in-process room signal bus stays:
  agent groups, fleet runs and external tool runs use it.
  middleware/audit.ts was dead and is deleted.
- @waggle/core loses TeamSync and the teamServer part of WaggleConfig. A
  teamServer key in config.json is ignored and kept on save, as P0.1 does
  for the tier keys. Workspaces lose teamServerUrl and teamUserId; teamId
  and teamRole stay because workspaces from a shared data directory still
  carry them and the viewer write guards read them. POST /api/workspaces
  ignores team fields.
- The sidecar bundle no longer marks the team packages as external.

The agent still references the TeamSync type in orchestrator.ts and
pattern-write-back.ts; those files are being rewritten in P1.5 and drop
it there.

Logs UF-030 and UF-031 (team sync and team policy defects found while
removing the code).
This commit is contained in:
shumeiko.it
2026-10-24 11:53:23 +02:00
parent 0cbde468a9
commit c25efe6c44
136 changed files with 450 additions and 4990 deletions

View File

@@ -0,0 +1,581 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, agents, agentGroups, agentGroupMembers, agentJobs, teams, teamMembers } from '../../src/db/schema.js';
import { sql, eq } from 'drizzle-orm';
describe('Agent API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let user1Id: string;
let user2Id: string;
let teamId: string;
let team2Id: string;
let agent1Id: string;
let agent2Id: string;
let foreignAgentId: string;
let group1Id: string;
beforeAll(async () => {
server = await buildServer();
// Clean up leftover test data
await server.db.execute(sql`DELETE FROM agent_group_members WHERE group_id IN (SELECT id FROM agent_groups WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%'))`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
await server.db.execute(sql`DELETE FROM agent_groups WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
await server.db.execute(sql`DELETE FROM agents WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'agtest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'agtest_%'`);
// Create test users
const [u1] = await server.db.insert(users).values({
clerkId: 'agtest_user1',
displayName: 'Agent User 1',
email: 'agentuser1@test.com',
}).returning();
user1Id = u1.id;
const [u2] = await server.db.insert(users).values({
clerkId: 'agtest_user2',
displayName: 'Agent User 2',
email: 'agentuser2@test.com',
}).returning();
user2Id = u2.id;
// Create a team for job tests
const [team] = await server.db.insert(teams).values({
name: 'Agent Test Team',
slug: 'agtest-team',
ownerId: user1Id,
}).returning();
teamId = team.id;
await server.db.insert(teamMembers).values({ teamId, userId: user1Id, role: 'owner' });
const [team2] = await server.db.insert(teams).values({
name: 'Agent Test Team 2',
slug: 'agtest-team-2',
ownerId: user2Id,
}).returning();
team2Id = team2.id;
await server.db.insert(teamMembers).values({ teamId: team2Id, userId: user2Id, role: 'owner' });
// Override auth handler for tests
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM agent_group_members WHERE group_id IN (SELECT id FROM agent_groups WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%'))`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
await server.db.execute(sql`DELETE FROM agent_groups WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
await server.db.execute(sql`DELETE FROM agents WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'agtest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'agtest_%'`);
await server.close();
});
it('creates an agent with custom model, tools, and system prompt', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/agents',
headers: { 'x-test-user-id': user1Id },
payload: {
name: 'Research Agent',
role: 'researcher',
systemPrompt: 'You are a research agent.',
model: 'claude-sonnet-4-20250514',
tools: ['web_search', 'read_file'],
config: { maxTokens: 4096 },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.name).toBe('Research Agent');
expect(body.role).toBe('researcher');
expect(body.systemPrompt).toBe('You are a research agent.');
expect(body.model).toBe('claude-sonnet-4-20250514');
expect(body.tools).toEqual(['web_search', 'read_file']);
expect(body.config).toEqual({ maxTokens: 4096 });
expect(body.userId).toBe(user1Id);
agent1Id = body.id;
});
it('creates a second agent for user1', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/agents',
headers: { 'x-test-user-id': user1Id },
payload: {
name: 'Coding Agent',
model: 'claude-haiku-4-5',
tools: ['execute_code'],
},
});
expect(response.statusCode).toBe(201);
agent2Id = JSON.parse(response.body).id;
});
it('lists agents returns only the user\'s agents', async () => {
// Create an agent for user2
const foreignAgentResponse = await server.inject({
method: 'POST',
url: '/api/agents',
headers: { 'x-test-user-id': user2Id },
payload: { name: 'User2 Agent' },
});
expect(foreignAgentResponse.statusCode).toBe(201);
foreignAgentId = JSON.parse(foreignAgentResponse.body).id;
const response = await server.inject({
method: 'GET',
url: '/api/agents',
headers: { 'x-test-user-id': user1Id },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBe(2);
expect(body.every((a: { userId: string }) => a.userId === user1Id)).toBe(true);
});
it('updates agent model and config', async () => {
const response = await server.inject({
method: 'PATCH',
url: `/api/agents/${agent1Id}`,
headers: { 'x-test-user-id': user1Id },
payload: {
model: 'claude-haiku-4-5',
config: { maxTokens: 2048, temperature: 0.7 },
},
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.model).toBe('claude-haiku-4-5');
expect(body.config).toEqual({ maxTokens: 2048, temperature: 0.7 });
});
it('user cannot update another user\'s agent', async () => {
const response = await server.inject({
method: 'PATCH',
url: `/api/agents/${agent1Id}`,
headers: { 'x-test-user-id': user2Id },
payload: { model: 'hacked-model' },
});
expect(response.statusCode).toBe(403);
});
it('user cannot delete another user\'s agent', async () => {
const response = await server.inject({
method: 'DELETE',
url: `/api/agents/${agent1Id}`,
headers: { 'x-test-user-id': user2Id },
});
expect(response.statusCode).toBe(403);
});
it('creates an agent group with parallel strategy and 2 members', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/agent-groups',
headers: { 'x-test-user-id': user1Id },
payload: {
name: 'Research Squad',
description: 'Parallel research team',
strategy: 'parallel',
members: [
{ agentId: agent1Id, roleInGroup: 'worker', executionOrder: 0 },
{ agentId: agent2Id, roleInGroup: 'worker', executionOrder: 0 },
],
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.name).toBe('Research Squad');
expect(body.strategy).toBe('parallel');
expect(body.members).toHaveLength(2);
group1Id = body.id;
});
it('rejects foreign and missing agents identically when creating a group', async () => {
const payload = {
name: 'Cross-tenant group',
strategy: 'parallel',
members: [
{ agentId: agent1Id, roleInGroup: 'worker', executionOrder: 0 },
{ agentId: foreignAgentId, roleInGroup: 'worker', executionOrder: 1 },
],
};
const foreignResponse = await server.inject({
method: 'POST',
url: '/api/agent-groups',
headers: { 'x-test-user-id': user1Id },
payload,
});
const missingResponse = await server.inject({
method: 'POST',
url: '/api/agent-groups',
headers: { 'x-test-user-id': user1Id },
payload: {
...payload,
members: [
payload.members[0],
{ ...payload.members[1], agentId: '00000000-0000-4000-8000-000000000001' },
],
},
});
expect(foreignResponse.statusCode).toBe(404);
expect(missingResponse.statusCode).toBe(404);
expect(JSON.parse(foreignResponse.body)).toEqual({ error: 'Agent not found' });
expect(missingResponse.body).toBe(foreignResponse.body);
const groups = await server.db
.select()
.from(agentGroups)
.where(eq(agentGroups.userId, user1Id));
expect(groups.some((group) => group.name === payload.name)).toBe(false);
});
it('rejects foreign replacement members without altering the owned group', async () => {
const foreignResponse = await server.inject({
method: 'PATCH',
url: `/api/agent-groups/${group1Id}`,
headers: { 'x-test-user-id': user1Id },
payload: {
members: [
{ agentId: agent1Id, roleInGroup: 'worker', executionOrder: 0 },
{ agentId: foreignAgentId, roleInGroup: 'worker', executionOrder: 1 },
],
},
});
const missingResponse = await server.inject({
method: 'PATCH',
url: `/api/agent-groups/${group1Id}`,
headers: { 'x-test-user-id': user1Id },
payload: {
members: [
{ agentId: agent1Id, roleInGroup: 'worker', executionOrder: 0 },
{
agentId: '00000000-0000-4000-8000-000000000001',
roleInGroup: 'worker',
executionOrder: 1,
},
],
},
});
expect(foreignResponse.statusCode).toBe(404);
expect(missingResponse.statusCode).toBe(404);
expect(JSON.parse(foreignResponse.body)).toEqual({ error: 'Agent not found' });
expect(missingResponse.body).toBe(foreignResponse.body);
const groupResponse = await server.inject({
method: 'GET',
url: `/api/agent-groups/${group1Id}`,
headers: { 'x-test-user-id': user1Id },
});
expect(groupResponse.statusCode).toBe(200);
const group = JSON.parse(groupResponse.body);
expect(group.members.map((member: { agentId: string }) => member.agentId).sort())
.toEqual([agent1Id, agent2Id].sort());
});
it('replaces group membership when every agent belongs to the caller', async () => {
const response = await server.inject({
method: 'PATCH',
url: `/api/agent-groups/${group1Id}`,
headers: { 'x-test-user-id': user1Id },
payload: {
members: [
{ agentId: agent1Id, roleInGroup: 'lead', executionOrder: 0 },
{ agentId: agent2Id, roleInGroup: 'worker', executionOrder: 1 },
],
},
});
expect(response.statusCode).toBe(200);
const group = JSON.parse(response.body);
expect(group.members.map((member: { agentId: string }) => member.agentId).sort())
.toEqual([agent1Id, agent2Id].sort());
});
it('creates a group with coordinator strategy and a lead agent', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/agent-groups',
headers: { 'x-test-user-id': user1Id },
payload: {
name: 'Coordinated Team',
strategy: 'coordinator',
members: [
{ agentId: agent1Id, roleInGroup: 'lead', executionOrder: 0 },
{ agentId: agent2Id, roleInGroup: 'worker', executionOrder: 1 },
],
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.strategy).toBe('coordinator');
const lead = body.members.find((m: { roleInGroup: string; agentId: string }) => m.roleInGroup === 'lead');
expect(lead).toBeDefined();
expect(lead.agentId).toBe(agent1Id);
});
it('gets group with members', async () => {
// List groups to get an ID
const listResponse = await server.inject({
method: 'GET',
url: '/api/agent-groups',
headers: { 'x-test-user-id': user1Id },
});
expect(listResponse.statusCode).toBe(200);
const groups = JSON.parse(listResponse.body);
expect(groups.length).toBeGreaterThanOrEqual(2);
const groupId = groups[0].id;
const response = await server.inject({
method: 'GET',
url: `/api/agent-groups/${groupId}`,
headers: { 'x-test-user-id': user1Id },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.id).toBe(groupId);
expect(body.members).toBeDefined();
expect(Array.isArray(body.members)).toBe(true);
});
it('executes group run — queues a job and returns 202 with jobId', async () => {
const listResponse = await server.inject({
method: 'GET',
url: '/api/agent-groups',
headers: { 'x-test-user-id': user1Id },
});
const groups = JSON.parse(listResponse.body);
const groupId = groups[0].id;
const response = await server.inject({
method: 'POST',
url: `/api/agent-groups/${groupId}/run`,
headers: { 'x-test-user-id': user1Id },
payload: {
task: 'Research the latest AI papers',
teamId,
},
});
expect(response.statusCode).toBe(202);
const body = JSON.parse(response.body);
expect(body.jobId).toBeDefined();
expect(typeof body.jobId).toBe('string');
// Verify the job was created in the database
const [job] = await server.db
.select()
.from(agentJobs)
.where(eq(agentJobs.id, body.jobId))
.limit(1);
expect(job).toBeDefined();
expect(job.status).toBe('queued');
expect(job.jobType).toBe('group');
expect(job.userId).toBe(user1Id);
});
it('rejects an owned group run attributed to a foreign team', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/agent-groups/${group1Id}/run`,
headers: { 'x-test-user-id': user1Id },
payload: { task: 'Cross-tenant run', teamId: team2Id },
});
expect(response.statusCode).toBe(404);
expect(JSON.parse(response.body)).toEqual({ error: 'Team not found' });
});
it('rejects generic job submission for a foreign team', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/jobs',
headers: { 'x-test-user-id': user1Id },
payload: { jobType: 'chat', teamId: team2Id, input: { message: 'Cross-tenant job' } },
});
expect(response.statusCode).toBe(404);
expect(JSON.parse(response.body)).toEqual({ error: 'Team not found' });
});
it('rejects a generic group job that references another user\'s group', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/jobs',
headers: { 'x-test-user-id': user2Id },
payload: {
jobType: 'group',
teamId: team2Id,
input: { groupId: group1Id, taskInput: { task: 'Run foreign group' } },
},
});
expect(response.statusCode).toBe(404);
expect(JSON.parse(response.body)).toEqual({ error: 'Agent group not found' });
});
it('hides job status from users outside the job team while preserving member access', async () => {
const createResponse = await server.inject({
method: 'POST',
url: '/api/jobs',
headers: { 'x-test-user-id': user1Id },
payload: { jobType: 'chat', teamId, input: { message: 'Private job' } },
});
expect(createResponse.statusCode).toBe(202);
const { jobId } = JSON.parse(createResponse.body);
const foreignResponse = await server.inject({
method: 'GET',
url: `/api/jobs/${jobId}`,
headers: { 'x-test-user-id': user2Id },
});
expect(foreignResponse.statusCode).toBe(404);
expect(JSON.parse(foreignResponse.body)).toEqual({ error: 'Job not found' });
const memberResponse = await server.inject({
method: 'GET',
url: `/api/jobs/${jobId}`,
headers: { 'x-test-user-id': user1Id },
});
expect(memberResponse.statusCode).toBe(200);
expect(JSON.parse(memberResponse.body).id).toBe(jobId);
});
it('prevents users outside the job team from cancelling it', async () => {
const createResponse = await server.inject({
method: 'POST',
url: '/api/jobs',
headers: { 'x-test-user-id': user1Id },
payload: { jobType: 'chat', teamId, input: { message: 'Do not cancel' } },
});
expect(createResponse.statusCode).toBe(202);
const { jobId } = JSON.parse(createResponse.body);
const foreignResponse = await server.inject({
method: 'POST',
url: `/api/jobs/${jobId}/cancel`,
headers: { 'x-test-user-id': user2Id },
});
expect(foreignResponse.statusCode).toBe(404);
expect(JSON.parse(foreignResponse.body)).toEqual({ error: 'Job not found' });
const [unchanged] = await server.db
.select()
.from(agentJobs)
.where(eq(agentJobs.id, jobId))
.limit(1);
expect(unchanged.status).toBe('queued');
const memberResponse = await server.inject({
method: 'POST',
url: `/api/jobs/${jobId}/cancel`,
headers: { 'x-test-user-id': user1Id },
});
expect(memberResponse.statusCode).toBe(200);
});
it('fails closed when a legacy group contains a foreign-owned agent', async () => {
const [legacyGroup] = await server.db.insert(agentGroups).values({
userId: user1Id,
name: 'Legacy compromised group',
strategy: 'parallel',
}).returning();
await server.db.insert(agentGroupMembers).values({
groupId: legacyGroup.id,
agentId: foreignAgentId,
roleInGroup: 'worker',
executionOrder: 0,
});
const getResponse = await server.inject({
method: 'GET',
url: `/api/agent-groups/${legacyGroup.id}`,
headers: { 'x-test-user-id': user1Id },
});
const patchResponse = await server.inject({
method: 'PATCH',
url: `/api/agent-groups/${legacyGroup.id}`,
headers: { 'x-test-user-id': user1Id },
payload: { name: 'Preserved compromise' },
});
const runResponse = await server.inject({
method: 'POST',
url: `/api/agent-groups/${legacyGroup.id}/run`,
headers: { 'x-test-user-id': user1Id },
payload: { task: 'Run foreign configuration', teamId },
});
const jobResponse = await server.inject({
method: 'POST',
url: '/api/jobs',
headers: { 'x-test-user-id': user1Id },
payload: {
jobType: 'group',
teamId,
input: { groupId: legacyGroup.id, taskInput: { task: 'Run foreign configuration' } },
},
});
for (const response of [getResponse, patchResponse, runResponse, jobResponse]) {
expect(response.statusCode).toBe(404);
expect(JSON.parse(response.body)).toEqual({ error: 'Agent group not found' });
}
const [unchanged] = await server.db
.select()
.from(agentGroups)
.where(eq(agentGroups.id, legacyGroup.id))
.limit(1);
expect(unchanged.name).toBe('Legacy compromised group');
});
it('deletes an agent', async () => {
const response = await server.inject({
method: 'DELETE',
url: `/api/agents/${agent2Id}`,
headers: { 'x-test-user-id': user1Id },
});
expect(response.statusCode).toBe(204);
// Verify it's gone
const listResponse = await server.inject({
method: 'GET',
url: '/api/agents',
headers: { 'x-test-user-id': user1Id },
});
const remaining = JSON.parse(listResponse.body);
const ids = remaining.map((a: { id: string }) => a.id);
expect(ids).not.toContain(agent2Id);
});
});

View File

@@ -0,0 +1,261 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, agentAuditLog, agentJobs, teamCapabilityRequests } from '../../src/db/schema.js';
import { sql } from 'drizzle-orm';
describe('Analytics API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let teamId: string;
beforeAll(async () => {
server = await buildServer();
// Clean up any leftover test data
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE agent_name = 'analytics-test'`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE job_type = 'analytics-test'`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE justification = 'analytics-test'`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug = 'test-analytics')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug = 'test-analytics')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug = 'test-analytics'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'antest_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'antest_owner',
displayName: 'Analytics Owner',
email: 'analytics-owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'antest_member',
displayName: 'Analytics Member',
email: 'analytics-member@test.com',
}).returning();
memberId = member.id;
// Create team
const [team] = await server.db.insert(teams).values({
name: 'Analytics Test Team',
slug: 'test-analytics',
ownerId,
}).returning();
teamId = team.id;
// Add members
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
]);
// Override auth handler for tests
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE agent_name = 'analytics-test'`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE job_type = 'analytics-test'`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE justification = 'analytics-test'`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug = 'test-analytics')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug = 'test-analytics')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug = 'test-analytics'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'antest_%'`);
await server.close();
});
it('GET /api/admin/teams/:slug/analytics returns correct shape with zeroes for empty data', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/test-analytics/analytics',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
// Verify top-level shape
expect(body).toHaveProperty('activeUsers');
expect(body).toHaveProperty('tokenUsage');
expect(body).toHaveProperty('topTools');
expect(body).toHaveProperty('topCommands');
expect(body).toHaveProperty('capabilityGaps');
expect(body).toHaveProperty('performanceTrends');
// activeUsers shape
expect(body.activeUsers).toHaveProperty('daily');
expect(body.activeUsers).toHaveProperty('weekly');
expect(body.activeUsers).toHaveProperty('monthly');
expect(typeof body.activeUsers.daily).toBe('number');
expect(typeof body.activeUsers.weekly).toBe('number');
expect(typeof body.activeUsers.monthly).toBe('number');
// tokenUsage shape
expect(typeof body.tokenUsage.total).toBe('number');
expect(Array.isArray(body.tokenUsage.byUser)).toBe(true);
// topTools and topCommands are arrays
expect(Array.isArray(body.topTools)).toBe(true);
expect(Array.isArray(body.topCommands)).toBe(true);
expect(Array.isArray(body.capabilityGaps)).toBe(true);
// performanceTrends shape
expect(typeof body.performanceTrends.correctionRate).toBe('number');
expect(typeof body.performanceTrends.correctionTrend).toBe('number');
expect(typeof body.performanceTrends.avgResponseTime).toBe('number');
// With no activity, everything should be zeroes
expect(body.activeUsers.daily).toBe(0);
expect(body.activeUsers.weekly).toBe(0);
expect(body.activeUsers.monthly).toBe(0);
expect(body.tokenUsage.total).toBe(0);
expect(body.topTools).toHaveLength(0);
expect(body.topCommands).toHaveLength(0);
expect(body.capabilityGaps).toHaveLength(0);
expect(body.performanceTrends.correctionRate).toBe(0);
expect(body.performanceTrends.avgResponseTime).toBe(0);
});
it('returns 401 without auth header', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/test-analytics/analytics',
});
expect(response.statusCode).toBe(401);
});
it('returns 403 for non-admin member', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/test-analytics/analytics',
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(403);
});
it('returns 404 for non-existent team', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/nonexistent-team/analytics',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(404);
});
it('returns data when audit log entries exist', async () => {
// Insert some audit log entries
await server.db.insert(agentAuditLog).values([
{
userId: ownerId,
teamId,
agentName: 'analytics-test',
actionType: 'web_search',
description: 'test search 1',
},
{
userId: ownerId,
teamId,
agentName: 'analytics-test',
actionType: 'web_search',
description: 'test search 2',
},
{
userId: ownerId,
teamId,
agentName: 'analytics-test',
actionType: 'save_memory',
description: 'test memory save',
},
{
userId: ownerId,
teamId,
agentName: 'analytics-test',
actionType: 'command:/research',
description: 'test command',
},
]);
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/test-analytics/analytics',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
// Should detect the active user
expect(body.activeUsers.daily).toBeGreaterThanOrEqual(1);
expect(body.activeUsers.weekly).toBeGreaterThanOrEqual(1);
expect(body.activeUsers.monthly).toBeGreaterThanOrEqual(1);
// Should show top tools
expect(body.topTools.length).toBeGreaterThanOrEqual(1);
const webSearch = body.topTools.find((t: { name: string }) => t.name === 'web_search');
expect(webSearch).toBeDefined();
expect(webSearch.invocations).toBeGreaterThanOrEqual(2);
// Should show top commands
expect(body.topCommands.length).toBeGreaterThanOrEqual(1);
const research = body.topCommands.find((c: { name: string }) => c.name === '/research');
expect(research).toBeDefined();
expect(research.count).toBeGreaterThanOrEqual(1);
});
it('returns capability gaps from pending requests', async () => {
// Insert a pending capability request
await server.db.insert(teamCapabilityRequests).values({
teamId,
requestedBy: memberId,
capabilityName: 'email_send',
capabilityType: 'tool',
justification: 'analytics-test',
status: 'pending',
});
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/test-analytics/analytics',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.capabilityGaps.length).toBeGreaterThanOrEqual(1);
const emailGap = body.capabilityGaps.find((g: { tool: string }) => g.tool === 'email_send');
expect(emailGap).toBeDefined();
expect(emailGap.requestCount).toBeGreaterThanOrEqual(1);
expect(emailGap.suggestion).toContain('email_send');
});
it('includes byUser token estimates in tokenUsage', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/test-analytics/analytics',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
// byUser should include team members
expect(body.tokenUsage.byUser.length).toBeGreaterThanOrEqual(1);
const ownerEntry = body.tokenUsage.byUser.find((u: { userId: string }) => u.userId === ownerId);
expect(ownerEntry).toBeDefined();
expect(ownerEntry.name).toBe('Analytics Owner');
expect(typeof ownerEntry.tokens).toBe('number');
expect(typeof ownerEntry.cost).toBe('number');
});
});

View File

@@ -0,0 +1,191 @@
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import { and, eq, sql } from 'drizzle-orm';
import { buildServer } from '../../src/index.js';
import {
messages,
teamCapabilityOverrides,
teamCapabilityRequests,
teamMembers,
teams,
users,
} from '../../src/db/schema.js';
const SLUG_PREFIX = 'cap-bind-';
const MISSING_ID = '00000000-0000-4000-8000-000000000000';
describe('Capability Governance Routes', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let attackerAdminId: string;
let victimOwnerId: string;
let attackerTeamId: string;
let victimTeamId: string;
beforeAll(async () => {
server = await buildServer();
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'}`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'cap_bind_%'`);
const [attackerAdmin, victimOwner] = await server.db.insert(users).values([
{
clerkId: 'cap_bind_attacker_admin',
displayName: 'Capability Attacker Admin',
email: 'cap-bind-attacker@test.invalid',
},
{
clerkId: 'cap_bind_victim_owner',
displayName: 'Capability Victim Owner',
email: 'cap-bind-victim@test.invalid',
},
]).returning();
attackerAdminId = attackerAdmin.id;
victimOwnerId = victimOwner.id;
const [attackerTeam, victimTeam] = await server.db.insert(teams).values([
{ name: 'Capability Attacker Team', slug: `${SLUG_PREFIX}attacker`, ownerId: attackerAdminId },
{ name: 'Capability Victim Team', slug: `${SLUG_PREFIX}victim`, ownerId: victimOwnerId },
]).returning();
attackerTeamId = attackerTeam.id;
victimTeamId = victimTeam.id;
await server.db.insert(teamMembers).values([
{ teamId: attackerTeamId, userId: attackerAdminId, role: 'admin' },
{ teamId: victimTeamId, userId: victimOwnerId, role: 'owner' },
]);
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'}`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'cap_bind_%'`);
await server.close();
});
it('does not let an authorized admin delete another team\'s override by ID', async () => {
const [victimOverride] = await server.db.insert(teamCapabilityOverrides).values({
teamId: victimTeamId,
capabilityName: 'victim-secret-tool',
capabilityType: 'mcp',
decision: 'blocked',
decidedBy: victimOwnerId,
}).returning();
const foreign = await server.inject({
method: 'DELETE',
url: `/api/teams/${SLUG_PREFIX}attacker/capability-overrides/${victimOverride.id}`,
headers: { 'x-test-user-id': attackerAdminId },
});
const missing = await server.inject({
method: 'DELETE',
url: `/api/teams/${SLUG_PREFIX}attacker/capability-overrides/${MISSING_ID}`,
headers: { 'x-test-user-id': attackerAdminId },
});
expect({ statusCode: foreign.statusCode, body: foreign.body }).toEqual({
statusCode: missing.statusCode,
body: missing.body,
});
const [stored] = await server.db.select().from(teamCapabilityOverrides).where(and(
eq(teamCapabilityOverrides.id, victimOverride.id),
eq(teamCapabilityOverrides.teamId, victimTeamId),
));
expect(stored).toBeDefined();
});
it('still lets a same-team admin delete an override', async () => {
const [ownOverride] = await server.db.insert(teamCapabilityOverrides).values({
teamId: attackerTeamId,
capabilityName: 'attacker-team-tool',
capabilityType: 'mcp',
decision: 'blocked',
decidedBy: attackerAdminId,
}).returning();
const response = await server.inject({
method: 'DELETE',
url: `/api/teams/${SLUG_PREFIX}attacker/capability-overrides/${ownOverride.id}`,
headers: { 'x-test-user-id': attackerAdminId },
});
expect(response.statusCode).toBe(204);
const [stored] = await server.db.select().from(teamCapabilityOverrides).where(eq(teamCapabilityOverrides.id, ownOverride.id));
expect(stored).toBeUndefined();
});
it('does not let an authorized admin decide another team\'s request by ID', async () => {
const [victimRequest] = await server.db.insert(teamCapabilityRequests).values({
teamId: victimTeamId,
requestedBy: victimOwnerId,
capabilityName: 'victim-requested-tool',
capabilityType: 'mcp',
justification: 'Victim-only request',
}).returning();
const foreign = await server.inject({
method: 'PATCH',
url: `/api/teams/${SLUG_PREFIX}attacker/capability-requests/${victimRequest.id}`,
headers: { 'x-test-user-id': attackerAdminId },
payload: { status: 'rejected', reason: 'cross-team decision attempt' },
});
const missing = await server.inject({
method: 'PATCH',
url: `/api/teams/${SLUG_PREFIX}attacker/capability-requests/${MISSING_ID}`,
headers: { 'x-test-user-id': attackerAdminId },
payload: { status: 'rejected', reason: 'missing request' },
});
expect({ statusCode: foreign.statusCode, body: foreign.body }).toEqual({
statusCode: missing.statusCode,
body: missing.body,
});
const [stored] = await server.db.select().from(teamCapabilityRequests).where(and(
eq(teamCapabilityRequests.id, victimRequest.id),
eq(teamCapabilityRequests.teamId, victimTeamId),
));
expect(stored?.status).toBe('pending');
expect(stored?.decidedBy).toBeNull();
});
it('still lets a same-team admin decide a pending request', async () => {
const [ownRequest] = await server.db.insert(teamCapabilityRequests).values({
teamId: attackerTeamId,
requestedBy: attackerAdminId,
capabilityName: 'attacker-requested-tool',
capabilityType: 'mcp',
justification: 'Same-team request',
}).returning();
const response = await server.inject({
method: 'PATCH',
url: `/api/teams/${SLUG_PREFIX}attacker/capability-requests/${ownRequest.id}`,
headers: { 'x-test-user-id': attackerAdminId },
payload: { status: 'rejected', reason: 'same-team decision' },
});
expect(response.statusCode).toBe(200);
expect(response.json()).toMatchObject({
id: ownRequest.id,
teamId: attackerTeamId,
status: 'rejected',
decidedBy: attackerAdminId,
});
});
});

View File

@@ -0,0 +1,366 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, teamEntities, teamRelations } from '../../src/db/schema.js';
import { eq, or, sql } from 'drizzle-orm';
describe('Team Knowledge Graph API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let outsiderId: string;
let teamSlug: string;
let teamId: string;
let foreignEntityId: string;
beforeAll(async () => {
server = await buildServer();
// Clean up any leftover test data
await server.db.execute(sql`DELETE FROM team_relations WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'kgtest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'kgtest_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'kgtest_owner',
displayName: 'KG Owner',
email: 'kgtest_owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'kgtest_member',
displayName: 'KG Member',
email: 'kgtest_member@test.com',
}).returning();
memberId = member.id;
const [outsider] = await server.db.insert(users).values({
clerkId: 'kgtest_outsider',
displayName: 'KG Outsider',
email: 'kgtest_outsider@test.com',
}).returning();
outsiderId = outsider.id;
// Create a team with owner + member
const [team] = await server.db.insert(teams).values({
name: 'KG Test Team',
slug: 'kgtest-knowledge',
ownerId,
}).returning();
teamId = team.id;
teamSlug = team.slug;
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
]);
const [foreignTeam] = await server.db.insert(teams).values({
name: 'Foreign KG Team',
slug: 'kgtest-foreign-knowledge',
ownerId: outsiderId,
}).returning();
await server.db.insert(teamMembers).values({
teamId: foreignTeam.id,
userId: outsiderId,
role: 'owner',
});
const [foreignEntity] = await server.db.insert(teamEntities).values({
teamId: foreignTeam.id,
entityType: 'secret',
name: 'Foreign Entity',
properties: { confidential: true },
sharedBy: outsiderId,
}).returning();
foreignEntityId = foreignEntity.id;
// Override auth handler
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM team_relations WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'kgtest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'kgtest_%'`);
await server.close();
});
it('creates an entity with properties and valid_from/valid_to', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: {
entityType: 'concept',
name: 'Machine Learning',
properties: { domain: 'AI', level: 'advanced' },
validFrom: '2026-01-01T00:00:00.000Z',
validTo: '2027-01-01T00:00:00.000Z',
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.entityType).toBe('concept');
expect(body.name).toBe('Machine Learning');
expect(body.properties).toEqual({ domain: 'AI', level: 'advanced' });
expect(body.sharedBy).toBe(ownerId);
expect(body.teamId).toBe(teamId);
expect(body.validFrom).toBeTruthy();
expect(body.validTo).toBeTruthy();
});
it('searches entities by type', async () => {
// Create entities of different types
await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'person', name: 'Alice' },
});
await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'person', name: 'Bob' },
});
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/entities?type=person`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(2);
expect(body.every((e: { entityType: string }) => e.entityType === 'person')).toBe(true);
});
it('searches entities by name (ILIKE)', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/entities?search=machine`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.length).toBeGreaterThanOrEqual(1);
expect(body.some((e: { name: string }) => e.name === 'Machine Learning')).toBe(true);
});
it('creates a relation with confidence score', async () => {
// Create two entities to relate
const res1 = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'tool', name: 'TensorFlow' },
});
const entity1 = JSON.parse(res1.body);
const res2 = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'concept', name: 'Deep Learning' },
});
const entity2 = JSON.parse(res2.body);
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/relations`,
headers: { 'x-test-user-id': ownerId },
payload: {
sourceId: entity1.id,
targetId: entity2.id,
relationType: 'implements',
confidence: 0.95,
properties: { since: '2015' },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.sourceId).toBe(entity1.id);
expect(body.targetId).toBe(entity2.id);
expect(body.relationType).toBe('implements');
expect(body.confidence).toBeCloseTo(0.95);
expect(body.teamId).toBe(teamId);
});
it('rejects relations when either endpoint belongs to another team', async () => {
const localRes = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'concept', name: 'Local Endpoint' },
});
const localEntity = localRes.json();
const foreignSource = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/relations`,
headers: { 'x-test-user-id': ownerId },
payload: {
sourceId: foreignEntityId,
targetId: localEntity.id,
relationType: 'references',
},
});
const foreignTarget = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/relations`,
headers: { 'x-test-user-id': ownerId },
payload: {
sourceId: localEntity.id,
targetId: foreignEntityId,
relationType: 'references',
},
});
expect(foreignSource.statusCode).toBe(404);
expect(foreignSource.json()).toEqual({ error: 'Entity not found' });
expect(foreignTarget.statusCode).toBe(404);
expect(foreignTarget.json()).toEqual({ error: 'Entity not found' });
const leaked = await server.db.select().from(teamRelations).where(or(
eq(teamRelations.sourceId, foreignEntityId),
eq(teamRelations.targetId, foreignEntityId),
));
expect(leaked).toEqual([]);
});
it('graph traversal returns connected entities up to depth N', async () => {
// Create a chain: A -> B -> C
const resA = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'node', name: 'Node-A' },
});
const nodeA = JSON.parse(resA.body);
const resB = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'node', name: 'Node-B' },
});
const nodeB = JSON.parse(resB.body);
const resC = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'node', name: 'Node-C' },
});
const nodeC = JSON.parse(resC.body);
// A -> B
await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/relations`,
headers: { 'x-test-user-id': ownerId },
payload: { sourceId: nodeA.id, targetId: nodeB.id, relationType: 'links_to' },
});
// B -> C
await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/relations`,
headers: { 'x-test-user-id': ownerId },
payload: { sourceId: nodeB.id, targetId: nodeC.id, relationType: 'links_to' },
});
// Depth 1: should find A and B only
const res1 = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/graph?startId=${nodeA.id}&depth=1`,
headers: { 'x-test-user-id': ownerId },
});
expect(res1.statusCode).toBe(200);
const graph1 = JSON.parse(res1.body);
const entityIds1 = graph1.entities.map((e: { id: string }) => e.id);
expect(entityIds1).toContain(nodeA.id);
expect(entityIds1).toContain(nodeB.id);
expect(entityIds1).not.toContain(nodeC.id);
// Depth 2: should find A, B, and C
const res2 = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/graph?startId=${nodeA.id}&depth=2`,
headers: { 'x-test-user-id': ownerId },
});
expect(res2.statusCode).toBe(200);
const graph2 = JSON.parse(res2.body);
const entityIds2 = graph2.entities.map((e: { id: string }) => e.id);
expect(entityIds2).toContain(nodeA.id);
expect(entityIds2).toContain(nodeB.id);
expect(entityIds2).toContain(nodeC.id);
expect(graph2.relations.length).toBeGreaterThanOrEqual(2);
});
it('does not return a foreign-team graph start entity', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/graph?startId=${foreignEntityId}&depth=1`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(404);
expect(response.json()).toEqual({ error: 'Entity not found' });
expect(response.body).not.toContain('Foreign Entity');
expect(response.body).not.toContain('confidential');
});
it('shared_by tracks who contributed', async () => {
// Owner creates entity
const res1 = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'doc', name: 'Owner Doc' },
});
expect(JSON.parse(res1.body).sharedBy).toBe(ownerId);
// Member creates entity
const res2 = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': memberId },
payload: { entityType: 'doc', name: 'Member Doc' },
});
expect(JSON.parse(res2.body).sharedBy).toBe(memberId);
});
it('non-member gets 403', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': outsiderId },
});
expect(response.statusCode).toBe(403);
});
});

View File

@@ -0,0 +1,392 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, teamEntities, tasks, messages } from '../../src/db/schema.js';
import { sql } from 'drizzle-orm';
describe('Waggle Dance Messages API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let outsiderId: string;
let teamSlug: string;
let teamId: string;
const SLUG_PREFIX = 'msgtest-';
beforeAll(async () => {
server = await buildServer();
// Clean up any leftover test data (order matters for FK constraints)
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'}`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'msgtest_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'msgtest_owner',
displayName: 'Msg Owner',
email: 'msgtest_owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'msgtest_member',
displayName: 'Msg Member',
email: 'msgtest_member@test.com',
}).returning();
memberId = member.id;
const [outsider] = await server.db.insert(users).values({
clerkId: 'msgtest_outsider',
displayName: 'Msg Outsider',
email: 'msgtest_outsider@test.com',
}).returning();
outsiderId = outsider.id;
// Create a team with owner + member
const [team] = await server.db.insert(teams).values({
name: 'Msg Test Team',
slug: `${SLUG_PREFIX}waggle`,
ownerId,
}).returning();
teamId = team.id;
teamSlug = team.slug;
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
]);
// Seed some team_entities and tasks for hive-check tests
await server.db.insert(teamEntities).values([
{ teamId, entityType: 'concept', name: 'Machine Learning', properties: { domain: 'AI' }, sharedBy: ownerId },
{ teamId, entityType: 'tool', name: 'TensorFlow', properties: { lang: 'python' }, sharedBy: memberId },
{ teamId, entityType: 'concept', name: 'Database Design', properties: { domain: 'engineering' }, sharedBy: ownerId },
]);
await server.db.insert(tasks).values([
{ teamId, title: 'Implement ML pipeline', description: 'Build a machine learning pipeline', status: 'open', createdBy: ownerId },
{ teamId, title: 'Fix login bug', description: 'Login page crashes on mobile', status: 'done', createdBy: memberId },
]);
// Override auth handler
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'}`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'msgtest_%'`);
await server.close();
});
it('sends a broadcast message and returns 201', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': ownerId },
payload: {
type: 'broadcast',
subtype: 'discovery',
content: { topic: 'New skill available', details: 'web-scraper v2' },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.type).toBe('broadcast');
expect(body.subtype).toBe('discovery');
expect(body.content).toEqual({ topic: 'New skill available', details: 'web-scraper v2' });
expect(body.senderId).toBe(ownerId);
expect(body.teamId).toBe(teamId);
expect(body.id).toBeDefined();
});
it('sends a request message with valid type-subtype combo', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': memberId },
payload: {
type: 'request',
subtype: 'knowledge_check',
content: { query: 'Who knows about React?' },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.type).toBe('request');
expect(body.subtype).toBe('knowledge_check');
});
it('rejects invalid type-subtype combination with 400', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': ownerId },
payload: {
type: 'request',
subtype: 'discovery', // discovery is a broadcast subtype, not request
content: { query: 'test' },
},
});
expect(response.statusCode).toBe(400);
const body = JSON.parse(response.body);
expect(body.error).toContain('Invalid type-subtype combination');
});
it('stores routing field when provided', async () => {
const routing = [
{ userId: memberId, reason: 'Expert in ML' },
];
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': ownerId },
payload: {
type: 'broadcast',
subtype: 'routed_share',
content: { data: 'ML model results' },
routing,
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.routing).toEqual(routing);
});
it('stores referenceId when provided', async () => {
// First create a message to reference
const firstRes = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': memberId },
payload: {
type: 'request',
subtype: 'task_delegation',
content: { task: 'Review PR #42' },
},
});
const firstMsg = JSON.parse(firstRes.body);
// Send a response referencing the first message
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': ownerId },
payload: {
type: 'response',
subtype: 'task_claim',
content: { accepted: true },
referenceId: firstMsg.id,
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.referenceId).toBe(firstMsg.id);
});
it('lists messages for the team', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(1);
});
it('filters messages by type', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/messages?type=broadcast`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.every((m: { type: string }) => m.type === 'broadcast')).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(1);
});
it('filters messages by subtype', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/messages?subtype=discovery`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.every((m: { subtype: string }) => m.subtype === 'discovery')).toBe(true);
});
it('publishes message to Redis channel on send', async () => {
// Subscribe to the team channel before sending
const receivedMessages: string[] = [];
await server.redisSub.subscribe(`team:${teamId}:waggle`);
server.redisSub.on('message', (_channel: string, message: string) => {
receivedMessages.push(message);
});
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': ownerId },
payload: {
type: 'broadcast',
subtype: 'skill_share',
content: { skill: 'data-analysis', version: '1.0' },
},
});
expect(response.statusCode).toBe(201);
// Give Redis a moment to deliver
await new Promise((resolve) => setTimeout(resolve, 200));
expect(receivedMessages.length).toBeGreaterThanOrEqual(1);
const published = JSON.parse(receivedMessages[receivedMessages.length - 1]);
expect(published.subtype).toBe('skill_share');
expect(published.content).toEqual({ skill: 'data-analysis', version: '1.0' });
// Cleanup subscription
await server.redisSub.unsubscribe(`team:${teamId}:waggle`);
server.redisSub.removeAllListeners('message');
});
it('non-member gets 403 when sending messages', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': outsiderId },
payload: {
type: 'broadcast',
subtype: 'discovery',
content: { test: true },
},
});
expect(response.statusCode).toBe(403);
});
it('non-member gets 403 when listing messages', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': outsiderId },
});
expect(response.statusCode).toBe(403);
});
describe('hive-check', () => {
it('finds matching entities by topic', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages/hive-check`,
headers: { 'x-test-user-id': ownerId },
payload: { topic: 'Machine Learning' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.entities.length).toBeGreaterThanOrEqual(1);
expect(body.entities.some((e: { name: string }) => e.name === 'Machine Learning')).toBe(true);
});
it('finds matching tasks by topic', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages/hive-check`,
headers: { 'x-test-user-id': memberId },
payload: { topic: 'ML pipeline' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.relatedTasks.length).toBeGreaterThanOrEqual(1);
expect(body.relatedTasks.some((t: { title: string }) => t.title.includes('ML pipeline'))).toBe(true);
});
it('finds matching broadcast messages', async () => {
// We already sent broadcast messages earlier in the test suite
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages/hive-check`,
headers: { 'x-test-user-id': ownerId },
payload: { topic: 'anything' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.relatedMessages).toBeDefined();
expect(Array.isArray(body.relatedMessages)).toBe(true);
});
it('returns empty results for non-matching topic', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages/hive-check`,
headers: { 'x-test-user-id': ownerId },
payload: { topic: 'xyzzy_nonexistent_topic_12345' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.entities).toHaveLength(0);
expect(body.relatedTasks).toHaveLength(0);
});
it('non-member gets 403 on hive-check', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages/hive-check`,
headers: { 'x-test-user-id': outsiderId },
payload: { topic: 'test' },
});
expect(response.statusCode).toBe(403);
});
it('validates hive-check input', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages/hive-check`,
headers: { 'x-test-user-id': ownerId },
payload: {}, // missing topic
});
expect(response.statusCode).toBe(400);
});
});
});

View File

@@ -0,0 +1,263 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, teamResources } from '../../src/db/schema.js';
import { eq, sql } from 'drizzle-orm';
describe('Team Resources API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let outsiderId: string;
let teamSlug: string;
let teamId: string;
beforeAll(async () => {
server = await buildServer();
// Clean up any leftover test data
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'restest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'restest_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'restest_owner',
displayName: 'Res Owner',
email: 'restest_owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'restest_member',
displayName: 'Res Member',
email: 'restest_member@test.com',
}).returning();
memberId = member.id;
const [outsider] = await server.db.insert(users).values({
clerkId: 'restest_outsider',
displayName: 'Res Outsider',
email: 'restest_outsider@test.com',
}).returning();
outsiderId = outsider.id;
// Create a team with owner + member
const [team] = await server.db.insert(teams).values({
name: 'Res Test Team',
slug: 'restest-resources',
ownerId,
}).returning();
teamId = team.id;
teamSlug = team.slug;
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
]);
// Override auth handler
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'restest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'restest_%'`);
await server.close();
});
it('shares a model_recipe resource', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/resources`,
headers: { 'x-test-user-id': ownerId },
payload: {
resourceType: 'model_recipe',
name: 'GPT-4 Coding Recipe',
description: 'Optimized for code generation',
config: { model: 'gpt-4', temperature: 0.2 },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.resourceType).toBe('model_recipe');
expect(body.name).toBe('GPT-4 Coding Recipe');
expect(body.description).toBe('Optimized for code generation');
expect(body.config).toEqual({ model: 'gpt-4', temperature: 0.2 });
expect(body.sharedBy).toBe(ownerId);
expect(body.rating).toBe(0);
expect(body.useCount).toBe(0);
});
it('shares a skill resource', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/resources`,
headers: { 'x-test-user-id': memberId },
payload: {
resourceType: 'skill',
name: 'Code Review Skill',
description: 'Automated code review with best practices',
config: { language: 'typescript', rules: ['no-any', 'strict-null'] },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.resourceType).toBe('skill');
expect(body.name).toBe('Code Review Skill');
expect(body.sharedBy).toBe(memberId);
});
it('rates a resource and updates running average', async () => {
// Create a resource first
const createRes = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/resources`,
headers: { 'x-test-user-id': ownerId },
payload: {
resourceType: 'prompt_template',
name: 'Summarizer Prompt',
config: { template: 'Summarize: {{input}}' },
},
});
const resource = JSON.parse(createRes.body);
// First rating: should be the rating itself (useCount was 0)
const rate1 = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/resources/${resource.id}`,
headers: { 'x-test-user-id': ownerId },
payload: { rating: 4 },
});
expect(rate1.statusCode).toBe(200);
const body1 = JSON.parse(rate1.body);
// After first rate: rating was set to 4 (useCount was 0), then useCount incremented to 1
expect(body1.useCount).toBe(1);
// Second rating: running average = (4 * 1 + 2) / 2 = 3
const rate2 = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/resources/${resource.id}`,
headers: { 'x-test-user-id': memberId },
payload: { rating: 2 },
});
expect(rate2.statusCode).toBe(200);
const body2 = JSON.parse(rate2.body);
expect(body2.useCount).toBe(2);
// rating = (4 * 1 + 2) / 2 = 3
expect(body2.rating).toBeCloseTo(3, 1);
});
it('increments use_count on rate', async () => {
const createRes = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/resources`,
headers: { 'x-test-user-id': ownerId },
payload: {
resourceType: 'tool_config',
name: 'Linter Config',
config: { tool: 'eslint', extends: 'recommended' },
},
});
const resource = JSON.parse(createRes.body);
expect(resource.useCount).toBe(0);
// Rate it
const rateRes = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/resources/${resource.id}`,
headers: { 'x-test-user-id': memberId },
payload: { rating: 5 },
});
const rated = JSON.parse(rateRes.body);
expect(rated.useCount).toBe(1);
// Rate again
const rateRes2 = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/resources/${resource.id}`,
headers: { 'x-test-user-id': ownerId },
payload: { rating: 3 },
});
const rated2 = JSON.parse(rateRes2.body);
expect(rated2.useCount).toBe(2);
});
it('does not rate a resource owned by another team through this team route', async () => {
const [foreignTeam] = await server.db.insert(teams).values({
name: 'Foreign Resource Team',
slug: 'restest-foreign-resources',
ownerId: outsiderId,
}).returning();
await server.db.insert(teamMembers).values({
teamId: foreignTeam.id,
userId: outsiderId,
role: 'owner',
});
const [foreignResource] = await server.db.insert(teamResources).values({
teamId: foreignTeam.id,
resourceType: 'model_recipe',
name: 'Foreign Recipe',
config: { model: 'private-model' },
sharedBy: outsiderId,
rating: 1,
useCount: 1,
}).returning();
const response = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/resources/${foreignResource.id}`,
headers: { 'x-test-user-id': ownerId },
payload: { rating: 5 },
});
expect(response.statusCode).toBe(404);
expect(response.json()).toEqual({ error: 'Resource not found' });
const [unchanged] = await server.db.select().from(teamResources)
.where(eq(teamResources.id, foreignResource.id));
expect(unchanged.rating).toBe(1);
expect(unchanged.useCount).toBe(1);
});
it('filters resources by resource_type', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/resources?type=skill`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(1);
expect(body.every((r: { resourceType: string }) => r.resourceType === 'skill')).toBe(true);
});
it('non-member gets 403', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/resources`,
headers: { 'x-test-user-id': outsiderId },
});
expect(response.statusCode).toBe(403);
});
});

View File

@@ -0,0 +1,210 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, tasks } from '../../src/db/schema.js';
import { sql } from 'drizzle-orm';
describe('Task Board API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let outsiderId: string;
let teamSlug: string;
let teamId: string;
let createdTaskId: string;
beforeAll(async () => {
server = await buildServer();
// Clean up any leftover test data
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'tstest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'tstest_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'tstest_owner',
displayName: 'Task Owner',
email: 'tstest_owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'tstest_member',
displayName: 'Task Member',
email: 'tstest_member@test.com',
}).returning();
memberId = member.id;
const [outsider] = await server.db.insert(users).values({
clerkId: 'tstest_outsider',
displayName: 'Task Outsider',
email: 'tstest_outsider@test.com',
}).returning();
outsiderId = outsider.id;
// Create a team with owner + member
const [team] = await server.db.insert(teams).values({
name: 'Task Test Team',
slug: 'tstest-tasks',
ownerId,
}).returning();
teamId = team.id;
teamSlug = team.slug;
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
]);
// Override auth handler
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'tstest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'tstest_%'`);
await server.close();
});
it('creates a task on team board', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/tasks`,
headers: { 'x-test-user-id': ownerId },
payload: { title: 'Research competitors', description: 'Analyze top 5 competitors', priority: 'high' },
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.title).toBe('Research competitors');
expect(body.description).toBe('Analyze top 5 competitors');
expect(body.priority).toBe('high');
expect(body.status).toBe('open');
expect(body.createdBy).toBe(ownerId);
expect(body.teamId).toBe(teamId);
createdTaskId = body.id;
});
it('lists tasks on team board', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/tasks`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(1);
expect(body.some((t: { id: string }) => t.id === createdTaskId)).toBe(true);
});
it('lists tasks with status filter', async () => {
// Create a second task and mark it done
const createRes = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/tasks`,
headers: { 'x-test-user-id': ownerId },
payload: { title: 'Done task' },
});
const doneTask = JSON.parse(createRes.body);
await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/tasks/${doneTask.id}`,
headers: { 'x-test-user-id': ownerId },
payload: { status: 'done' },
});
// Filter by status=open
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/tasks?status=open`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.every((t: { status: string }) => t.status === 'open')).toBe(true);
expect(body.some((t: { id: string }) => t.id === doneTask.id)).toBe(false);
});
it('claims a task — sets assignedTo and status to claimed', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/tasks/${createdTaskId}/claim`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.assignedTo).toBe(memberId);
expect(body.status).toBe('claimed');
});
it('completes a task — status changes to done', async () => {
const response = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/tasks/${createdTaskId}`,
headers: { 'x-test-user-id': memberId },
payload: { status: 'done' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.status).toBe('done');
});
it('creates a subtask with parentTaskId', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/tasks`,
headers: { 'x-test-user-id': ownerId },
payload: { title: 'Sub-research item', parentTaskId: createdTaskId },
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.parentTaskId).toBe(createdTaskId);
expect(body.priority).toBe('normal');
});
it('non-team-member gets 403', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/tasks`,
headers: { 'x-test-user-id': outsiderId },
});
expect(response.statusCode).toBe(403);
});
it('gets a single task by id', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/tasks/${createdTaskId}`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.id).toBe(createdTaskId);
expect(body.title).toBe('Research competitors');
});
});

View File

@@ -0,0 +1,304 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers } from '../../src/db/schema.js';
import { sql } from 'drizzle-orm';
describe('Team API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let adminId: string;
beforeAll(async () => {
server = await buildServer();
// Clean up any leftover test data (use unique prefix to avoid collision with auth tests)
// Narrow to 'test-team%' — previously 'test-%' collided with analytics.test.ts's
// 'test-analytics' slug when files ran in parallel and wiped it mid-run, causing
// spurious 403s because the analytics team's owner was no longer a member.
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'test-team%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'tmtest_%'`);
// Create test users directly in DB (clerk IDs use 'tmtest_' prefix to avoid auth test cleanup)
const [owner] = await server.db.insert(users).values({
clerkId: 'tmtest_owner',
displayName: 'Team Owner',
email: 'teamowner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'tmtest_member',
displayName: 'Team Member',
email: 'teammember@test.com',
}).returning();
memberId = member.id;
const [admin] = await server.db.insert(users).values({
clerkId: 'tmtest_admin',
displayName: 'Team Admin',
email: 'teamadmin@test.com',
}).returning();
adminId = admin.id;
// Override auth handler to use x-test-user-id header (via indirection object)
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
// Narrow to 'test-team%' — previously 'test-%' collided with analytics.test.ts's
// 'test-analytics' slug when files ran in parallel and wiped it mid-run, causing
// spurious 403s because the analytics team's owner was no longer a member.
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'test-team%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'tmtest_%'`);
await server.close();
});
it('creates a team and auto-adds owner as member with role owner', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/teams',
headers: { 'x-test-user-id': ownerId },
payload: { name: 'Test Team', slug: 'test-team-crud' },
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.name).toBe('Test Team');
expect(body.slug).toBe('test-team-crud');
expect(body.ownerId).toBe(ownerId);
// Verify owner membership
const [membership] = await server.db
.select()
.from(teamMembers)
.where(sql`team_id = ${body.id} AND user_id = ${ownerId}`);
expect(membership).toBeDefined();
expect(membership.role).toBe('owner');
});
it('returns 409 on duplicate slug', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/teams',
headers: { 'x-test-user-id': ownerId },
payload: { name: 'Another Team', slug: 'test-team-crud' },
});
expect(response.statusCode).toBe(409);
});
it('lists only teams the user belongs to', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/teams',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
const slugs = body.map((t: { slug: string }) => t.slug);
expect(slugs).toContain('test-team-crud');
});
it('non-member gets empty list', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/teams',
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
// memberId is not a member of any team with test- slug yet
const testTeams = body.filter((t: { slug: string }) => t.slug.startsWith('test-'));
expect(testTeams).toHaveLength(0);
});
it('gets team by slug with members', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/teams/test-team-crud',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.slug).toBe('test-team-crud');
expect(body.members).toBeDefined();
expect(body.members.length).toBeGreaterThanOrEqual(1);
expect(body.members[0].displayName).toBe('Team Owner');
});
it('non-member gets 403 when accessing team', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/teams/test-team-crud',
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(403);
});
it('adds a member via invite (admin+)', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/teams/test-team-crud/members',
headers: { 'x-test-user-id': ownerId },
payload: { email: 'teammember@test.com', role: 'member' },
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.userId).toBe(memberId);
expect(body.role).toBe('member');
});
it('returns 409 when inviting existing member', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/teams/test-team-crud/members',
headers: { 'x-test-user-id': ownerId },
payload: { email: 'teammember@test.com', role: 'member' },
});
expect(response.statusCode).toBe(409);
});
it('adds an admin member', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/teams/test-team-crud/members',
headers: { 'x-test-user-id': ownerId },
payload: { email: 'teamadmin@test.com', role: 'admin' },
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.role).toBe('admin');
});
it('member can update own roleDescription and interests', async () => {
const response = await server.inject({
method: 'PATCH',
url: `/api/teams/test-team-crud/members/${memberId}`,
headers: { 'x-test-user-id': memberId },
payload: {
roleDescription: 'Frontend developer',
interests: ['React', 'TypeScript'],
},
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.roleDescription).toBe('Frontend developer');
expect(body.interests).toEqual(['React', 'TypeScript']);
});
it('member cannot change own role', async () => {
// Attempting to change role requires admin, but member is only 'member'
const response = await server.inject({
method: 'PATCH',
url: `/api/teams/test-team-crud/members/${memberId}`,
headers: { 'x-test-user-id': memberId },
payload: { role: 'admin' },
});
expect(response.statusCode).toBe(403);
});
it('admin can update team name', async () => {
const response = await server.inject({
method: 'PATCH',
url: '/api/teams/test-team-crud',
headers: { 'x-test-user-id': adminId },
payload: { name: 'Updated Team Name' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.name).toBe('Updated Team Name');
});
it('member cannot update team name', async () => {
const response = await server.inject({
method: 'PATCH',
url: '/api/teams/test-team-crud',
headers: { 'x-test-user-id': memberId },
payload: { name: 'Should Fail' },
});
expect(response.statusCode).toBe(403);
});
it('cannot remove the team owner', async () => {
const response = await server.inject({
method: 'DELETE',
url: `/api/teams/test-team-crud/members/${ownerId}`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(403);
});
it('admin can remove a member', async () => {
const response = await server.inject({
method: 'DELETE',
url: `/api/teams/test-team-crud/members/${memberId}`,
headers: { 'x-test-user-id': adminId },
});
expect(response.statusCode).toBe(204);
// Verify member is gone
const checkResponse = await server.inject({
method: 'GET',
url: '/api/teams/test-team-crud',
headers: { 'x-test-user-id': ownerId },
});
const body = JSON.parse(checkResponse.body);
const memberIds = body.members.map((m: { userId: string }) => m.userId);
expect(memberIds).not.toContain(memberId);
});
it('does not let an admin demote the team owner', async () => {
const response = await server.inject({
method: 'PATCH',
url: `/api/teams/test-team-crud/members/${ownerId}`,
headers: { 'x-test-user-id': adminId },
payload: { role: 'member' },
});
expect(response.statusCode).toBe(403);
expect(response.json()).toEqual({ error: 'Cannot change the team owner role' });
const [membership] = await server.db.select().from(teamMembers)
.where(sql`team_id = (SELECT id FROM teams WHERE slug = 'test-team-crud') AND user_id = ${ownerId}`);
expect(membership.role).toBe('owner');
});
it('returns 401 without auth header', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/teams',
});
expect(response.statusCode).toBe(401);
});
});

View File

@@ -0,0 +1,173 @@
import { createHmac } from 'node:crypto';
import Fastify, { type FastifyInstance } from 'fastify';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { webhookRoutes } from '../../src/routes/webhooks.js';
const SIGNING_KEY = Buffer.from('waggle-clerk-webhook-test-secret');
const SIGNING_SECRET = `whsec_${SIGNING_KEY.toString('base64')}`;
const createEvent = {
type: 'user.created',
data: {
id: 'clerk_webhook_user',
first_name: 'Ada',
last_name: 'Lovelace',
email_addresses: [{ email_address: 'ada@example.com' }],
image_url: 'https://example.com/ada.png',
},
};
function signedHeaders(payload: object, timestamp = Math.floor(Date.now() / 1000)) {
const id = 'msg_waggle_clerk_test';
const body = JSON.stringify(payload);
const signature = createHmac('sha256', SIGNING_KEY)
.update(`${id}.${timestamp}.${body}`)
.digest('base64');
return {
'svix-id': id,
'svix-timestamp': String(timestamp),
'svix-signature': `v1,${signature}`,
};
}
function createDbDouble() {
const onConflictDoNothing = vi.fn().mockResolvedValue(undefined);
const values = vi.fn(() => ({ onConflictDoNothing }));
const insert = vi.fn(() => ({ values }));
const updateWhere = vi.fn().mockResolvedValue(undefined);
const set = vi.fn(() => ({ where: updateWhere }));
const update = vi.fn(() => ({ set }));
const deleteWhere = vi.fn().mockResolvedValue(undefined);
const deleteFrom = vi.fn(() => ({ where: deleteWhere }));
return {
db: { insert, update, delete: deleteFrom },
mutations: { insert, values, update, deleteFrom },
};
}
describe('Clerk webhook authenticity', () => {
let app: FastifyInstance;
let mutations: ReturnType<typeof createDbDouble>['mutations'];
let originalSigningSecret: string | undefined;
beforeEach(async () => {
originalSigningSecret = process.env.CLERK_WEBHOOK_SIGNING_SECRET;
process.env.CLERK_WEBHOOK_SIGNING_SECRET = SIGNING_SECRET;
const dbDouble = createDbDouble();
mutations = dbDouble.mutations;
app = Fastify();
app.decorate('db', dbDouble.db as never);
await app.register(webhookRoutes);
});
afterEach(async () => {
await app.close();
if (originalSigningSecret === undefined) {
delete process.env.CLERK_WEBHOOK_SIGNING_SECRET;
} else {
process.env.CLERK_WEBHOOK_SIGNING_SECRET = originalSigningSecret;
}
});
it.each([
['user.created', createEvent.data],
['user.updated', createEvent.data],
['user.deleted', { id: createEvent.data.id }],
])('rejects an unsigned %s event before any database mutation', async (type, data) => {
const response = await app.inject({
method: 'POST',
url: '/api/webhooks/clerk',
payload: { type, data },
});
expect(response.statusCode).toBe(400);
expect(response.json()).toEqual({ error: 'Invalid webhook signature' });
expect(mutations.insert).not.toHaveBeenCalled();
expect(mutations.update).not.toHaveBeenCalled();
expect(mutations.deleteFrom).not.toHaveBeenCalled();
});
it('rejects an otherwise signed event when its timestamp is stale', async () => {
const staleTimestamp = Math.floor(Date.now() / 1000) - 301;
const response = await app.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(createEvent, staleTimestamp),
payload: createEvent,
});
expect(response.statusCode).toBe(400);
expect(mutations.insert).not.toHaveBeenCalled();
});
it('rejects a signature that was generated for a different body', async () => {
const tamperedEvent = {
...createEvent,
data: { ...createEvent.data, email_addresses: [{ email_address: 'attacker@example.com' }] },
};
const response = await app.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(createEvent),
payload: tamperedEvent,
});
expect(response.statusCode).toBe(400);
expect(mutations.insert).not.toHaveBeenCalled();
});
it('fails closed when the Clerk webhook signing secret is not configured', async () => {
delete process.env.CLERK_WEBHOOK_SIGNING_SECRET;
const response = await app.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(createEvent),
payload: createEvent,
});
expect(response.statusCode).toBe(400);
expect(mutations.insert).not.toHaveBeenCalled();
});
it('preserves a correctly signed user.created event and its field mapping', async () => {
const response = await app.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(createEvent),
payload: createEvent,
});
expect(response.statusCode).toBe(200);
expect(response.json()).toEqual({ received: true });
expect(mutations.values).toHaveBeenCalledWith({
clerkId: 'clerk_webhook_user',
displayName: 'Ada Lovelace',
email: 'ada@example.com',
avatarUrl: 'https://example.com/ada.png',
});
});
it('preserves correctly signed user.updated and user.deleted events', async () => {
const updateEvent = { ...createEvent, type: 'user.updated' };
const deleteEvent = { type: 'user.deleted', data: { id: createEvent.data.id } };
for (const event of [updateEvent, deleteEvent]) {
const response = await app.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(event),
payload: event,
});
expect(response.statusCode).toBe(200);
}
expect(mutations.update).toHaveBeenCalledOnce();
expect(mutations.deleteFrom).toHaveBeenCalledOnce();
});
});