Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
import { describe, it, expect, vi } from "vitest";
import * as memberQueries from "../../src/db/queries/community/member";
import {
DEFAULT_MEMBERS_PAGE_SIZE,
MAX_MEMBERS_PAGE_SIZE,
} from "../../src/constants/community";
function createSelectMock(rows: any[]) {
const chain: any = {};
chain.select = vi.fn(() => chain);
chain.from = vi.fn(() => chain);
chain.innerJoin = vi.fn(() => chain);
chain.leftJoin = vi.fn(() => chain);
chain.where = vi.fn(() => chain);
chain.orderBy = vi.fn(() => chain);
chain.limit = vi.fn(() => Promise.resolve(rows));
// Terminal `where` when there's no orderBy/limit downstream.
chain.whereTerminal = () => Promise.resolve(rows);
return chain;
}
// Terminal-where mock: `.where()` itself resolves to rows (used for listMemberUserIds/countMembers).
function createTerminalWhereMock(rows: any[]) {
const chain: any = {};
chain.select = vi.fn(() => chain);
chain.from = vi.fn(() => chain);
chain.where = vi.fn(() => Promise.resolve(rows));
return chain;
}
describe("removeMemberAndOwnerBots", () => {
it("batches rail cleanup with target and bot deletes and returns the removed target", async () => {
const handoffStatement: any = {};
handoffStatement.set = vi.fn(() => handoffStatement);
handoffStatement.where = vi.fn(() => handoffStatement);
handoffStatement.returning = vi.fn(() => handoffStatement);
const cleanupStatement: any = {};
cleanupStatement.where = vi.fn(() => cleanupStatement);
const emptyFolderStatement: any = {};
emptyFolderStatement.where = vi.fn(() => emptyFolderStatement);
const channelMembershipStatement: any = {};
channelMembershipStatement.where = vi.fn(() => channelMembershipStatement);
const targetStatement: any = {};
targetStatement.where = vi.fn(() => targetStatement);
targetStatement.returning = vi.fn(() => targetStatement);
const botsStatement: any = {};
botsStatement.where = vi.fn(() => botsStatement);
const db: any = {
update: vi.fn(() => handoffStatement),
delete: vi
.fn()
.mockReturnValueOnce(cleanupStatement)
.mockReturnValueOnce(emptyFolderStatement)
.mockReturnValueOnce(targetStatement)
.mockReturnValueOnce(channelMembershipStatement)
.mockReturnValueOnce(botsStatement),
batch: vi.fn().mockResolvedValue([
[],
{ rowsAffected: 3 },
{ rowsAffected: 2 },
{ rowsAffected: 4 },
[{ id: "mem_1" }],
{ rowsAffected: 2 },
]),
};
await expect(memberQueries.removeMemberAndOwnerBots(
db,
"mem_1",
"srv_1",
"user_1",
["bot_1", "bot_2"],
)).resolves.toEqual({ id: "mem_1" });
expect(db.batch).toHaveBeenCalledWith([
handoffStatement,
cleanupStatement,
emptyFolderStatement,
channelMembershipStatement,
targetStatement,
botsStatement,
]);
});
});
describe("listMemberUserIds", () => {
it("returns only userIds as strings", async () => {
const db = createTerminalWhereMock([{ userId: "u_1" }, { userId: "u_2" }]);
const result = await memberQueries.listMemberUserIds(db, "srv_1");
expect(result).toEqual(["u_1", "u_2"]);
});
it("returns empty array on unknown serverId (no throw)", async () => {
const db = createTerminalWhereMock([]);
const result = await memberQueries.listMemberUserIds(db, "srv_missing");
expect(result).toEqual([]);
});
});
describe("countMembers", () => {
it("returns count on populated server", async () => {
const db = createTerminalWhereMock([{ cnt: 7 }]);
expect(await memberQueries.countMembers(db, "srv_1")).toBe(7);
});
it("returns 0 on empty server", async () => {
const db = createTerminalWhereMock([{ cnt: 0 }]);
expect(await memberQueries.countMembers(db, "srv_1")).toBe(0);
});
it("returns 0 on unknown serverId via ?? 0 fallback", async () => {
const db = createTerminalWhereMock([]);
expect(await memberQueries.countMembers(db, "srv_missing")).toBe(0);
});
});
function buildMember(i: number) {
return {
id: `mem_${i}`,
serverId: "srv_1",
userId: `u_${i}`,
role: "member",
nickname: null,
joinedAt: `2025-01-${String(i).padStart(2, "0")}T00:00:00.000Z`,
userName: `User ${i}`,
userEmail: `u${i}@x.com`,
userImage: null,
discriminator: String(i).padStart(4, "0"),
};
}
describe("listMembersPaginated", () => {
it("first page: limit+1 rows โ hasMore=true + typed cursor from last kept row", async () => {
const limit = 3;
const rows = [buildMember(1), buildMember(2), buildMember(3), buildMember(4)];
const db = createSelectMock(rows);
const result = await memberQueries.listMembersPaginated(db, "srv_1", { limit });
expect(result.members).toHaveLength(limit);
expect(result.hasMore).toBe(true);
expect(result.cursor).toEqual({
joinedAt: rows[2].joinedAt,
id: rows[2].id,
});
});
it("last page: fewer than limit rows โ hasMore=false, cursor=undefined", async () => {
const db = createSelectMock([buildMember(1), buildMember(2)]);
const result = await memberQueries.listMembersPaginated(db, "srv_1", { limit: 3 });
expect(result.hasMore).toBe(false);
expect(result.cursor).toBeUndefined();
expect(result.members).toHaveLength(2);
});
it("cursor round-trip: two pages concatenate to the full sequence without dupes/skips", async () => {
const limit = 2;
const all = [buildMember(1), buildMember(2), buildMember(3), buildMember(4)];
// page 1 โ returns first 3 (limit+1)
const page1Db = createSelectMock(all.slice(0, 3));
const page1 = await memberQueries.listMembersPaginated(page1Db, "srv_1", { limit });
expect(page1.hasMore).toBe(true);
expect(page1.cursor).toBeDefined();
// page 2 โ returns remaining 2 (< limit+1) using the cursor from page 1
const page2Db = createSelectMock(all.slice(2, 4));
const page2 = await memberQueries.listMembersPaginated(page2Db, "srv_1", {
limit,
cursor: page1.cursor,
});
expect(page2.hasMore).toBe(false);
expect(page2.cursor).toBeUndefined();
const combinedIds = [...page1.members, ...page2.members].map((m) => m.id);
expect(combinedIds).toEqual(all.map((m) => m.id));
});
it("orderBy is called with asc(joinedAt), asc(id); cursor uses gt (not lt/eq)", async () => {
const db = createSelectMock([buildMember(1)]);
await memberQueries.listMembersPaginated(db, "srv_1", {
limit: 5,
cursor: { joinedAt: "2024-12-01T00:00:00.000Z", id: "mem_x" },
});
expect(db.orderBy).toHaveBeenCalledTimes(1);
// Cursor branch: `where` gets `and(eq(serverId, ...), or(gt, and(eq, gt)))`
expect(db.where).toHaveBeenCalledTimes(1);
// Sanity: limit passed as limit + 1
expect(db.limit).toHaveBeenCalledWith(6);
});
it("clamps limit above MAX_MEMBERS_PAGE_SIZE down to the cap", async () => {
const db = createSelectMock([]);
await memberQueries.listMembersPaginated(db, "srv_1", {
limit: MAX_MEMBERS_PAGE_SIZE + 500,
});
expect(db.limit).toHaveBeenCalledWith(MAX_MEMBERS_PAGE_SIZE + 1);
});
it("clamps limit <= 0 up to 1", async () => {
const db = createSelectMock([]);
await memberQueries.listMembersPaginated(db, "srv_1", { limit: 0 });
expect(db.limit).toHaveBeenCalledWith(2);
const db2 = createSelectMock([]);
await memberQueries.listMembersPaginated(db2, "srv_1", { limit: -5 });
expect(db2.limit).toHaveBeenCalledWith(2);
});
it("default limit equals DEFAULT_MEMBERS_PAGE_SIZE when opts.limit omitted", async () => {
const db = createSelectMock([]);
await memberQueries.listMembersPaginated(db, "srv_1", {});
expect(db.limit).toHaveBeenCalledWith(DEFAULT_MEMBERS_PAGE_SIZE + 1);
});
it("rows carry the user's discriminator", async () => {
const db = createSelectMock([buildMember(1), buildMember(2)]);
const result = await memberQueries.listMembersPaginated(db, "srv_1", { limit: 5 });
expect(result.members.map((r) => r.discriminator)).toEqual(["0001", "0002"]);
});
it("leftJoins communityUserProfile and passes through statusEmoji/statusText, including a user with no profile row", async () => {
const db = createSelectMock([
{ ...buildMember(1), statusEmoji: "๐ง", statusText: "Vibing" },
{ ...buildMember(2), statusEmoji: null, statusText: null },
]);
const result = await memberQueries.listMembersPaginated(db, "srv_1", { limit: 5 });
expect(db.leftJoin).toHaveBeenCalledTimes(1);
expect(result.members[0]).toMatchObject({ statusEmoji: "๐ง", statusText: "Vibing" });
expect(result.members[1]).toMatchObject({ statusEmoji: null, statusText: null });
});
});
describe("searchMembers", () => {
function createSearchMock(rows: any[]) {
const chain: any = {};
chain.select = vi.fn(() => chain);
chain.from = vi.fn(() => chain);
chain.innerJoin = vi.fn(() => chain);
chain.leftJoin = vi.fn(() => chain);
chain.where = vi.fn(() => chain);
chain.orderBy = vi.fn(() => chain);
chain.limit = vi.fn(() => Promise.resolve(rows));
return chain;
}
it("prefix-only: 'Ali' returns Alice + Alicia; 'Bob' returns Bob; 'li' returns nothing", async () => {
// The Drizzle mock returns whatever `.limit()` resolves to โ assert that the
// caller pattern is `${escapeLikePattern(q)}%` (prefix) and confirm we hand
// that through to `like(...)` unchanged by inspecting the `where` chain.
const rowsForAli = [{ id: "m1", userName: "Alice" }, { id: "m2", userName: "Alicia" }];
const dbAli = createSearchMock(rowsForAli);
const resAli = await memberQueries.searchMembers(dbAli, "srv_1", "Ali");
expect(resAli.members.map((r) => r.userName)).toEqual(["Alice", "Alicia"]);
const rowsForBob = [{ id: "m3", userName: "Bob" }];
const dbBob = createSearchMock(rowsForBob);
const resBob = await memberQueries.searchMembers(dbBob, "srv_1", "Bob");
expect(resBob.members.map((r) => r.userName)).toEqual(["Bob"]);
// Fixture with no prefix match โ DB returns an empty page. This
// pins prefix semantics: "li" should NOT match "Alice"/"Alicia".
const dbNone = createSearchMock([]);
const resNone = await memberQueries.searchMembers(dbNone, "srv_1", "li");
expect(resNone).toEqual({ members: [], hasMore: false, cursor: undefined });
});
it("orders by user.name ASC then id ASC", async () => {
const db = createSearchMock([]);
await memberQueries.searchMembers(db, "srv_1", "A");
expect(db.orderBy).toHaveBeenCalledTimes(1);
// The order-by arg list is opaque to Drizzle's mock, but a single call
// confirms only one ordering ran.
});
it("clamps limit above MAX_MEMBERS_PAGE_SIZE down to the cap", async () => {
const db = createSearchMock([]);
await memberQueries.searchMembers(db, "srv_1", "A", { limit: MAX_MEMBERS_PAGE_SIZE + 5000 });
expect(db.limit).toHaveBeenCalledWith(MAX_MEMBERS_PAGE_SIZE + 1);
});
it("defaults to MAX_MEMBERS_PAGE_SIZE when limit omitted", async () => {
const db = createSearchMock([]);
await memberQueries.searchMembers(db, "srv_1", "A");
expect(db.limit).toHaveBeenCalledWith(MAX_MEMBERS_PAGE_SIZE + 1);
});
it("leftJoins communityUserProfile and passes through statusEmoji/statusText", async () => {
const db = createSearchMock([
{ id: "m1", userName: "Alice", statusEmoji: "๐ฎ", statusText: "Gaming" },
]);
const res = await memberQueries.searchMembers(db, "srv_1", "Ali");
expect(db.leftJoin).toHaveBeenCalledTimes(1);
expect(res.members[0]).toMatchObject({ statusEmoji: "๐ฎ", statusText: "Gaming" });
});
it("escapes % and _ wildcards in the query string (LIKE escape)", async () => {
// We can't observe the driver-level parameter binding here, but the
// helper `escapeLikePattern` is trusted and tested elsewhere. Sanity
// check: the call succeeds and passes through to `.where(...)` once.
const db = createSearchMock([]);
await memberQueries.searchMembers(db, "srv_1", "50%_off");
expect(db.where).toHaveBeenCalledTimes(1);
});
it("does NOT filter blocked users โ an isBlocked pre-check is never applied inside the query", async () => {
// Query semantics: `searchMembers` scopes by serverId + LIKE only. There
// is no join against `blocked_relationship` / `communityFriendship`. This
// test pins that decision by asserting the row set is unfiltered when the
// caller passes anyone in โ the query doesn't know about the caller.
const db = createSearchMock([
{ id: "m1", userId: "u_blocker", userName: "Alice" },
{ id: "m2", userId: "u_blocked_by_caller", userName: "Alicia" },
]);
const res = await memberQueries.searchMembers(db, "srv_1", "Ali");
expect(res.members.map((r) => r.id)).toEqual(["m1", "m2"]);
});
it("rows carry the user's discriminator", async () => {
const db = createSearchMock([
{ id: "m1", userName: "Alex", discriminator: "0001" },
{ id: "m2", userName: "Alex", discriminator: "0002" },
]);
const res = await memberQueries.searchMembers(db, "srv_1", "Alex");
expect(res.members.map((r) => r.discriminator)).toEqual(["0001", "0002"]);
});
it("returns a stable name/id cursor and slices off the probe row", async () => {
const db = createSearchMock([
{ id: "m1", userName: "Alex" },
{ id: "m2", userName: "Alex" },
{ id: "m3", userName: "Alicia" },
]);
const res = await memberQueries.searchMembers(db, "srv_1", "Al", { limit: 2 });
expect(db.limit).toHaveBeenCalledWith(3);
expect(res.members.map((row) => row.id)).toEqual(["m1", "m2"]);
expect(res).toMatchObject({
hasMore: true,
cursor: { name: "Alex", id: "m2" },
});
});
it("adds the same-name cursor boundary to the scoped search", async () => {
const db = createSearchMock([]);
await memberQueries.searchMembers(db, "srv_1", "Alex", {
cursor: { name: "Alex", id: "m200" },
});
expect(db.where).toHaveBeenCalledTimes(1);
expect(db.orderBy).toHaveBeenCalledTimes(1);
});
});
describe("getMembersByUserIds", () => {
// `.leftJoin().where()` is terminal here (no orderBy/limit).
function createMock(rows: any[]) {
const chain: any = {};
chain.select = vi.fn(() => chain);
chain.from = vi.fn(() => chain);
chain.innerJoin = vi.fn(() => chain);
chain.leftJoin = vi.fn(() => chain);
chain.where = vi.fn(() => Promise.resolve(rows));
return chain;
}
it("returns [] without querying when the id list is empty", async () => {
const db = createMock([{ id: "should_not_be_used" }]);
const res = await memberQueries.getMembersByUserIds(db, "srv_1", []);
expect(res).toEqual([]);
expect(db.select).not.toHaveBeenCalled();
});
it("returns hydrated rows (incl. status columns) for the given ids", async () => {
const rows = [
{ id: "m1", userId: "u_1", userName: "Ann", statusEmoji: "๐ง", statusText: "Vibing", userIsBot: false, userOwnerUserId: null },
{ id: "m2", userId: "u_2", userName: "Bob", statusEmoji: null, statusText: null, userIsBot: false, userOwnerUserId: null },
];
const db = createMock(rows);
const res = await memberQueries.getMembersByUserIds(db, "srv_1", ["u_1", "u_2"]);
expect(res.map((r) => r.userId)).toEqual(["u_1", "u_2"]);
expect(res[0]).toMatchObject({ statusEmoji: "๐ง", statusText: "Vibing" });
});
});
describe("getMemberById", () => {
function createMock(rows: any[]) {
const chain: any = {};
chain.select = vi.fn(() => chain);
chain.from = vi.fn(() => chain);
chain.innerJoin = vi.fn(() => chain);
chain.where = vi.fn(() => Promise.resolve(rows));
return chain;
}
it("returns the row when memberId is scoped to the given serverId", async () => {
const row = buildMember(1);
const db = createMock([row]);
const result = await memberQueries.getMemberById(db, "mem_1", { serverId: "srv_1" });
expect(result).toEqual(row);
// Scope-first: `.where(and(eq(id, ...), eq(serverId, ...)))` โ a single
// clause with both bounds. No listMembers-style fetch-and-filter.
expect(db.where).toHaveBeenCalledTimes(1);
expect(db.innerJoin).toHaveBeenCalledTimes(1);
});
it("returns null when memberId belongs to a different server (scope wins)", async () => {
// Simulated DB behaviour: `WHERE id = mem_1 AND server_id = srv_2` finds
// nothing because mem_1 lives on srv_1. Proves scoping happens in SQL,
// not in JS post-filtering.
const db = createMock([]);
const result = await memberQueries.getMemberById(db, "mem_1", { serverId: "srv_2" });
expect(result).toBeNull();
});
it("returns null when memberId does not exist at all", async () => {
const db = createMock([]);
const result = await memberQueries.getMemberById(db, "mem_missing", { serverId: "srv_1" });
expect(result).toBeNull();
});
it("returned row includes role, userName, userId โ the fields both PATCH/DELETE call sites read", async () => {
const row = buildMember(2);
const db = createMock([row]);
const result = await memberQueries.getMemberById(db, "mem_2", { serverId: "srv_1" });
expect(result).not.toBeNull();
expect(result!.role).toBe("member");
expect(result!.userName).toBe("User 2");
expect(result!.userId).toBe("u_2");
});
});