Skip to content

🐸 Rybbit - open-source and privacy-friendly alternative to Google Analytics that is 10x more intuitive.

13.9 KB
Raw Blame
import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";

const mocks = vi.hoisted(() => ({
  invalidateSitesAccessCache: vi.fn(),
}));

vi.mock("../../db/postgres/postgres.js", async () => {
  const { PGlite } = await import("@electric-sql/pglite");
  const { drizzle } = await import("drizzle-orm/pglite");
  const schema = await import("../../db/postgres/schema.js");
  const client = new PGlite();
  return { db: drizzle(client, { schema }), sql: client };
});

vi.mock("../../lib/auth-utils.js", () => ({
  invalidateSitesAccessCache: mocks.invalidateSitesAccessCache,
}));

import { db, sql as pgClient } from "../../db/postgres/postgres.js";
import { updateMemberSiteAccess } from "./updateMemberSiteAccess.js";

const DDL = `
CREATE TABLE "organization" (
  "id" text PRIMARY KEY,
  "name" text NOT NULL,
  "slug" text NOT NULL,
  "createdAt" timestamp NOT NULL
);
CREATE TABLE "user" (
  "id" text PRIMARY KEY,
  "name" text NOT NULL,
  "email" text NOT NULL
);
CREATE TABLE "sites" (
  "site_id" serial PRIMARY KEY,
  "name" text NOT NULL,
  "domain" text NOT NULL,
  "organization_id" text REFERENCES "organization"("id")
);
CREATE TABLE "member" (
  "id" text PRIMARY KEY,
  "organizationId" text NOT NULL REFERENCES "organization"("id"),
  "userId" text NOT NULL REFERENCES "user"("id") ON DELETE CASCADE,
  "role" text NOT NULL,
  "createdAt" timestamp NOT NULL,
  "has_restricted_site_access" boolean NOT NULL DEFAULT false
);
CREATE TABLE "member_site_access" (
  "id" serial PRIMARY KEY,
  "member_id" text NOT NULL REFERENCES "member"("id") ON DELETE CASCADE,
  "site_id" integer NOT NULL REFERENCES "sites"("site_id") ON DELETE CASCADE,
  "role" text,
  "created_at" timestamp NOT NULL DEFAULT now(),
  "created_by" text REFERENCES "user"("id") ON DELETE SET NULL,
  UNIQUE ("member_id", "site_id")
);
`;

function replyStub() {
  const reply: any = { statusCode: 200 };
  reply.status = (code: number) => {
    reply.statusCode = code;
    return reply;
  };
  reply.send = (body: unknown) => {
    reply.body = body;
    return reply;
  };
  return reply;
}

function requestStub(overrides: Record<string, unknown> = {}) {
  return {
    params: { organizationId: "org_1", memberId: "membership_member" },
    body: { hasRestrictedSiteAccess: true, siteIds: [1] },
    user: { id: "admin" },
    log: { error: vi.fn() },
    ...overrides,
  } as any;
}

async function rows(query: string) {
  return (await (pgClient as any).query(query)).rows;
}

beforeAll(async () => {
  await (pgClient as any).exec(DDL);
});

afterAll(async () => {
  await (pgClient as any).close();
});

beforeEach(async () => {
  vi.restoreAllMocks();
  vi.clearAllMocks();

  await (pgClient as any).exec(`
    TRUNCATE "member_site_access", "member", "sites", "user", "organization" RESTART IDENTITY;
    INSERT INTO "organization" ("id", "name", "slug", "createdAt") VALUES
      ('org_1', 'One', 'one', '2026-01-01'),
      ('org_2', 'Two', 'two', '2026-01-01');
    INSERT INTO "user" ("id", "name", "email") VALUES
      ('admin', 'Admin', '[email protected]'),
      ('member_user', 'Member', '[email protected]'),
      ('admin_user', 'Another Admin', '[email protected]'),
      ('owner_user', 'Owner', '[email protected]'),
      ('other_user', 'Other Member', '[email protected]');
    INSERT INTO "member" ("id", "organizationId", "userId", "role", "createdAt", "has_restricted_site_access") VALUES
      ('membership_admin_actor', 'org_1', 'admin', 'admin', '2026-01-01', false),
      ('membership_member', 'org_1', 'member_user', 'member', '2026-01-01', true),
      ('membership_admin', 'org_1', 'admin_user', 'admin', '2026-01-01', false),
      ('membership_owner', 'org_1', 'owner_user', 'owner', '2026-01-01', false),
      ('membership_other', 'org_2', 'other_user', 'member', '2026-01-01', false);
    INSERT INTO "sites" ("name", "domain", "organization_id") VALUES
      ('One A', 'a.example.com', 'org_1'),
      ('One B', 'b.example.com', 'org_1'),
      ('Other', 'other.example.com', 'org_2');
    INSERT INTO "member_site_access" ("member_id", "site_id", "created_by")
      VALUES ('membership_member', 1, 'admin');
  `);
});

describe("updateMemberSiteAccess", () => {
  it("replaces grants, records the acting user, and returns site metadata", async () => {
    const reply = replyStub();

    await updateMemberSiteAccess(requestStub({ body: { hasRestrictedSiteAccess: true, siteIds: [2] } }), reply);

    expect(reply.statusCode).toBe(200);
    expect(reply.body).toEqual({
      memberId: "membership_member",
      hasRestrictedSiteAccess: true,
      siteAccess: [{ siteId: 2, role: null, name: "One B", domain: "b.example.com" }],
    });
    expect(await rows(`SELECT has_restricted_site_access FROM member WHERE id = 'membership_member'`)).toEqual([
      { has_restricted_site_access: true },
    ]);
    expect(await rows(`SELECT site_id, created_by FROM member_site_access`)).toEqual([
      { site_id: 2, created_by: "admin" },
    ]);
    expect(mocks.invalidateSitesAccessCache).toHaveBeenCalledOnce();
    expect(mocks.invalidateSitesAccessCache).toHaveBeenCalledWith("member_user");
  });

  it("supports multiple same-organization grants", async () => {
    const reply = replyStub();

    await updateMemberSiteAccess(requestStub({ body: { hasRestrictedSiteAccess: true, siteIds: [1, 2] } }), reply);

    expect(reply.body.siteAccess).toEqual([
      { siteId: 1, role: null, name: "One A", domain: "a.example.com" },
      { siteId: 2, role: null, name: "One B", domain: "b.example.com" },
    ]);
    expect(await rows(`SELECT site_id FROM member_site_access ORDER BY site_id`)).toEqual([
      { site_id: 1 },
      { site_id: 2 },
    ]);
  });

  it("stores the role the grants carry", async () => {
    const reply = replyStub();

    await updateMemberSiteAccess(
      requestStub({ body: { hasRestrictedSiteAccess: true, siteIds: [2], siteRole: "editor" } }),
      reply
    );

    expect(reply.statusCode).toBe(200);
    expect(reply.body.siteAccess).toEqual([{ siteId: 2, role: "editor", name: "One B", domain: "b.example.com" }]);
    expect(await rows(`SELECT site_id, role FROM member_site_access`)).toEqual([{ site_id: 2, role: "editor" }]);
  });

  it("keeps the role the grants carry when the request doesn't mention it", async () => {
    await (pgClient as any).exec(`UPDATE member_site_access SET role = 'editor' WHERE member_id = 'membership_member'`);
    const reply = replyStub();

    // Site 1 stays, site 2 is new: both carry the member's existing site role.
    await updateMemberSiteAccess(requestStub({ body: { hasRestrictedSiteAccess: true, siteIds: [1, 2] } }), reply);

    expect(reply.statusCode).toBe(200);
    expect(await rows(`SELECT site_id, role FROM member_site_access ORDER BY site_id`)).toEqual([
      { site_id: 1, role: "editor" },
      { site_id: 2, role: "editor" },
    ]);
  });

  it("clears the site role when the request sends null", async () => {
    await (pgClient as any).exec(`UPDATE member_site_access SET role = 'editor' WHERE member_id = 'membership_member'`);
    const reply = replyStub();

    await updateMemberSiteAccess(
      requestStub({ body: { hasRestrictedSiteAccess: true, siteIds: [1], siteRole: null } }),
      reply
    );

    expect(await rows(`SELECT site_id, role FROM member_site_access`)).toEqual([{ site_id: 1, role: null }]);
  });

  it("refuses a grant role above editor", async () => {
    const reply = replyStub();

    await updateMemberSiteAccess(
      requestStub({ body: { hasRestrictedSiteAccess: true, siteIds: [2], siteRole: "admin" } }),
      reply
    );

    expect(reply.statusCode).toBe(400);
    // The existing grant is untouched.
    expect(await rows(`SELECT site_id, role FROM member_site_access`)).toEqual([{ site_id: 1, role: null }]);
  });

  it("can restrict a member to no sites", async () => {
    const reply = replyStub();

    await updateMemberSiteAccess(requestStub({ body: { hasRestrictedSiteAccess: true, siteIds: [] } }), reply);

    expect(reply.statusCode).toBe(200);
    expect(reply.body).toEqual({
      memberId: "membership_member",
      hasRestrictedSiteAccess: true,
      siteAccess: [],
    });
    expect(await rows(`SELECT * FROM member_site_access`)).toEqual([]);
    expect(mocks.invalidateSitesAccessCache).toHaveBeenCalledWith("member_user");
  });

  it("unrestricts a member and clears every prior explicit grant", async () => {
    const reply = replyStub();

    await updateMemberSiteAccess(requestStub({ body: { hasRestrictedSiteAccess: false, siteIds: [] } }), reply);

    expect(reply.statusCode).toBe(200);
    expect(reply.body.siteAccess).toEqual([]);
    expect(await rows(`SELECT has_restricted_site_access FROM member WHERE id = 'membership_member'`)).toEqual([
      { has_restricted_site_access: false },
    ]);
    expect(await rows(`SELECT * FROM member_site_access`)).toEqual([]);
  });

  it("stores null audit attribution when authentication did not populate request.user", async () => {
    const reply = replyStub();

    await updateMemberSiteAccess(
      requestStub({ user: undefined, body: { hasRestrictedSiteAccess: true, siteIds: [2] } }),
      reply
    );

    expect(reply.statusCode).toBe(200);
    expect(await rows(`SELECT site_id, created_by FROM member_site_access`)).toEqual([
      { site_id: 2, created_by: null },
    ]);
  });

  it("returns 404 for an unknown member or a member in another organization", async () => {
    for (const params of [
      { organizationId: "org_1", memberId: "missing" },
      { organizationId: "org_1", memberId: "membership_other" },
      { organizationId: "org_2", memberId: "membership_member" },
    ]) {
      const reply = replyStub();
      await updateMemberSiteAccess(requestStub({ params }), reply);

      expect(reply.statusCode).toBe(404);
      expect(reply.body).toEqual({ error: "Member not found" });
    }
    expect(mocks.invalidateSitesAccessCache).not.toHaveBeenCalled();
  });

  it("rejects restricting admins and owners without changing their records", async () => {
    for (const memberId of ["membership_admin", "membership_owner"]) {
      const reply = replyStub();
      await updateMemberSiteAccess(requestStub({ params: { organizationId: "org_1", memberId } }), reply);

      expect(reply.statusCode).toBe(400);
      expect(reply.body).toEqual({ error: "Cannot restrict site access for admin or owner roles" });
    }
    expect(
      await rows(`SELECT id, has_restricted_site_access FROM member WHERE role IN ('admin', 'owner') ORDER BY id`)
    ).toEqual([
      { id: "membership_admin", has_restricted_site_access: false },
      { id: "membership_admin_actor", has_restricted_site_access: false },
      { id: "membership_owner", has_restricted_site_access: false },
    ]);
    expect(mocks.invalidateSitesAccessCache).not.toHaveBeenCalled();
  });

  it("clears a restriction left over from before a promotion", async () => {
    await (pgClient as any).exec(`
      UPDATE member SET role = 'admin' WHERE id = 'membership_member';
    `);
    const reply = replyStub();

    await updateMemberSiteAccess(requestStub({ body: { hasRestrictedSiteAccess: false, siteIds: [] } }), reply);

    expect(reply.statusCode).toBe(200);
    expect(await rows(`SELECT has_restricted_site_access FROM member WHERE id = 'membership_member'`)).toEqual([
      { has_restricted_site_access: false },
    ]);
    expect(await rows(`SELECT * FROM member_site_access`)).toEqual([]);
  });

  it("rejects foreign and nonexistent site IDs without changing existing access", async () => {
    const reply = replyStub();
    await (pgClient as any).exec(`UPDATE member SET has_restricted_site_access = false WHERE id = 'membership_member'`);

    await updateMemberSiteAccess(requestStub({ body: { hasRestrictedSiteAccess: true, siteIds: [1, 3, 99] } }), reply);

    expect(reply.statusCode).toBe(400);
    expect(reply.body).toEqual({
      error: "Invalid site IDs: 3, 99. Sites must belong to this organization.",
    });
    expect(await rows(`SELECT has_restricted_site_access FROM member WHERE id = 'membership_member'`)).toEqual([
      { has_restricted_site_access: false },
    ]);
    expect(await rows(`SELECT site_id FROM member_site_access`)).toEqual([{ site_id: 1 }]);
    expect(mocks.invalidateSitesAccessCache).not.toHaveBeenCalled();
  });

  it("rolls back the flag and grants when replacement insertion fails", async () => {
    const request = requestStub({
      user: { id: "missing-actor" },
      body: { hasRestrictedSiteAccess: true, siteIds: [2] },
    });
    const reply = replyStub();
    await (pgClient as any).exec(`UPDATE member SET has_restricted_site_access = false WHERE id = 'membership_member'`);

    await updateMemberSiteAccess(request, reply);

    expect(reply.statusCode).toBe(500);
    expect(await rows(`SELECT has_restricted_site_access FROM member WHERE id = 'membership_member'`)).toEqual([
      { has_restricted_site_access: false },
    ]);
    expect(await rows(`SELECT site_id, created_by FROM member_site_access`)).toEqual([
      { site_id: 1, created_by: "admin" },
    ]);
    expect(mocks.invalidateSitesAccessCache).not.toHaveBeenCalled();
  });

  it("does not retain submitted site IDs when switching to unrestricted access", async () => {
    const reply = replyStub();

    await updateMemberSiteAccess(requestStub({ body: { hasRestrictedSiteAccess: false, siteIds: [1] } }), reply);

    expect(reply.statusCode).toBe(200);
    expect(reply.body.siteAccess).toEqual([]);
    expect(await rows(`SELECT * FROM member_site_access`)).toEqual([]);
  });

  it("returns 500 and logs database failures", async () => {
    const request = requestStub();
    const reply = replyStub();
    vi.spyOn(db, "select").mockImplementationOnce(() => {
      throw new Error("database offline");
    });

    await updateMemberSiteAccess(request, reply);

    expect(reply.statusCode).toBe(500);
    expect(reply.body).toEqual({ error: "Failed to update member site access" });
    expect(request.log.error).toHaveBeenCalledWith({ err: expect.any(Error) }, "Error updating member site access");
    expect(mocks.invalidateSitesAccessCache).not.toHaveBeenCalled();
  });
});