Add a separate view for Pseudo-accounts. Focus on space membership. Testing.

Author: maparent

apps/website/app/utils/supabase/account.ts

@@ -1,44 +1,5 @@
-import type { Database } from "@repo/database/dbTypes";
 import type { DGSupabaseClient } from "@repo/database/lib/client";
 
-type AgentType = Database["public"]["Enums"]["AgentType"] | "group";
-
-export const getGroupMemberList = async (
-  client: DGSupabaseClient,
-  groupId: string,
-): Promise<
-  {
-    id: string;
-    name: string;
-    agentType: AgentType; // eslint-disable-line @typescript-eslint/naming-convention
-    admin: boolean;
-  }[]
-> => {
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  const results = await client.rpc("group_members", { p_group_id: groupId });
-  if (results.error) throw results.error;
-  if (!results.data) return [];
-  return (
-    results.data
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      .map(({ id, name, agent_type, admin }) => ({
-        id,
-        name,
-        agentType: agent_type,
-        admin,
-      }))
-      .filter(
-        ({ id, name, agentType, admin }) =>
-          admin !== null && id !== null && name !== null && agentType !== null,
-      ) as unknown as {
-      admin: boolean;
-      id: string;
-      name: string;
-      agentType: AgentType;
-    }[]
-  );
-};
-
 export const createGroup = async (
   client: DGSupabaseClient,
   name: string,

apps/website/test/integration/list-group-members.test.ts

@@ -0,0 +1,183 @@
+import assert from "assert";
+import { describe, it, beforeAll, afterAll } from "vitest";
+import { createClient } from "@supabase/supabase-js";
+import type { Database } from "@repo/database/dbTypes";
+import type { DGSupabaseClient } from "@repo/database/lib/client";
+import {
+  fetchOrCreateSpaceDirect,
+  spaceAnonUserEmail,
+} from "@repo/database/lib/contextFunctions";
+import { createGroup } from "../../app/utils/supabase/account";
+
+const SUPABASE_URL = process.env.SUPABASE_URL!;
+const ANON_KEY = process.env.SUPABASE_PUBLISHABLE_KEY!;
+const SERVICE_KEY = process.env.SUPABASE_SECRET_KEY!;
+const PASSWORD = "abcdefgh";
+
+const freshClient = (): DGSupabaseClient =>
+  createClient<Database, "public">(SUPABASE_URL, ANON_KEY);
+
+const serviceClient = () =>
+  createClient<Database, "public">(SUPABASE_URL, SERVICE_KEY);
+
+const signedInClient = async (spaceId: number): Promise<DGSupabaseClient> => {
+  const client = freshClient();
+  const { error } = await client.auth.signInWithPassword({
+    email: spaceAnonUserEmail("Roam", spaceId),
+    password: PASSWORD,
+  });
+  if (error) throw new Error(`Sign-in failed: ${error.message}`);
+  return client;
+};
+
+describe("list group members flow", { tags: ["database"] }, () => {
+  let spaceId1: number;
+  let spaceId2: number;
+  let spaceAccountId1: number;
+  let spaceAccountUuid1: string;
+  let spaceAccountId2: number;
+  let spaceAccountUuid2: string;
+  let client1: DGSupabaseClient;
+  let client2: DGSupabaseClient;
+  let createdGroupId: string | null = null;
+
+  beforeAll(async () => {
+    const s1 = await fetchOrCreateSpaceDirect({
+      name: "vitest-s1",
+      url: "https://roamresearch.com/#/app/vitest-s1",
+      platform: "Roam",
+      password: PASSWORD,
+    });
+    if (!s1.data)
+      throw new Error(`Failed to create space 1: ${s1.error?.message}`);
+    spaceId1 = s1.data.id;
+    client1 = await signedInClient(spaceId1);
+    assert(client1);
+    const accountReq1 = await client1
+      .from("PlatformAccount")
+      .select("id,dg_account")
+      .eq(
+        "account_local_id",
+        `roam-${spaceId1}-anon@database.discoursegraphs.com`,
+      )
+      .maybeSingle();
+    assert(!accountReq1.error);
+    assert(accountReq1.data);
+    assert(accountReq1.data.dg_account);
+    spaceAccountId1 = accountReq1.data.id;
+    spaceAccountUuid1 = accountReq1.data.dg_account;
+    const s2 = await fetchOrCreateSpaceDirect({
+      name: "vitest-s2",
+      url: "https://roamresearch.com/#/app/vitest-s2",
+      platform: "Roam",
+      password: PASSWORD,
+    });
+    if (!s2.data)
+      throw new Error(`Failed to create space 2: ${s2.error?.message}`);
+    spaceId2 = s2.data.id;
+    client2 = await signedInClient(spaceId2);
+    assert(client2);
+    const accountReq2 = await client2
+      .from("PlatformAccount")
+      .select("id,dg_account")
+      .eq(
+        "account_local_id",
+        `roam-${spaceId2}-anon@database.discoursegraphs.com`,
+      )
+      .maybeSingle();
+    assert(!accountReq2.error);
+    assert(accountReq2.data);
+    assert(accountReq2.data.dg_account);
+    spaceAccountId2 = accountReq2.data.id;
+    spaceAccountUuid2 = accountReq2.data.dg_account;
+  });
+
+  afterAll(async () => {
+    if (createdGroupId)
+      await serviceClient().auth.admin.deleteUser(createdGroupId);
+    if (spaceAccountUuid1)
+      await serviceClient().auth.admin.deleteUser(spaceAccountUuid1);
+    if (spaceAccountUuid2)
+      await serviceClient().auth.admin.deleteUser(spaceAccountUuid2);
+    if (spaceId1)
+      await serviceClient().from("Space").delete().eq("id", spaceId1);
+    if (spaceId2)
+      await serviceClient().from("Space").delete().eq("id", spaceId2);
+  });
+
+  it("lists group members", async () => {
+    // Step 1: user1 creates a group
+    const groupId = await createGroup(client1, "vitest-invite-group");
+    assert(groupId !== null, "createGroup should return a group ID");
+    createdGroupId = groupId!;
+
+    // Step 2: Add another member
+    const { error: errorAddMember } = await client1
+      .from("group_membership")
+      .insert({
+        member_id: spaceAccountUuid2,
+        group_id: groupId,
+        admin: false,
+      });
+    assert(!errorAddMember);
+
+    // Step 3: Mutual publish setup
+    const { error: errorPublishSpace1 } = await client1
+      .from("SpaceAccess")
+      .insert({
+        space_id: spaceId1,
+        account_uid: groupId,
+        permissions: "partial",
+      });
+    assert(!errorPublishSpace1);
+
+    const { error: errorPublishSpace2 } = await client2
+      .from("SpaceAccess")
+      .insert({
+        space_id: spaceId2,
+        account_uid: groupId,
+        permissions: "partial",
+      });
+    assert(!errorPublishSpace2);
+
+    const expectedSpaceIds = [spaceId1, spaceId2];
+    // Step 4: user1 lists group members
+    const { data: data1, error: error1 } = await client1.rpc(
+      "spaces_in_group",
+      {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        p_group_id: createdGroupId,
+      },
+    );
+    assert(error1 === null, error1 ? error1.message : "");
+    assert(data1 !== null, "group spaces should not be empty");
+    assert(data1.length === 2, "There should be two spaces");
+    const spacesSeenBy1 = new Set(
+      data1.map((gm) => gm.id).filter((id) => id !== null),
+    );
+    assert(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      expectedSpaceIds.every((id) => spacesSeenBy1.has(id)),
+      "Wrong membership information",
+    );
+    // Step 5: user2 lists group members
+    const { data: data2, error: error2 } = await client2.rpc(
+      "spaces_in_group",
+      {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        p_group_id: createdGroupId,
+      },
+    );
+    assert(error2 === null, error2 ? error2.message : "");
+    assert(data2 !== null, "group spaces should not be empty");
+    assert(data2.length === 2, "There should be two spaces");
+    const spacesSeenBy2 = new Set(
+      data2.map((gm) => gm.id).filter((id) => id !== null),
+    );
+    assert(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      expectedSpaceIds.every((id) => spacesSeenBy2.has(id)),
+      "Wrong membership information",
+    );
+  });
+});