Skip to content

OpenPanel is an open-source web and product analytics platform, an open-source alternative to Mixpanel with optional self-hosting.

4.6 KB
Raw Blame
// The scope rule replaced "no rows means every project". Every verdict the
// old rule gave is re-derived here from the shape the migration writes, so a
// change to either side shows up as a diff rather than as a surprised member.

import { expect, test } from 'bun:test';
import type { Db } from '../context';
import {
  listProjectMemberEmails,
  resolveProjectAccess,
} from './access-lookups';

test('scope all follows the role: write for members and admins, read for viewers', () => {
  for (const role of ['admin', 'member', 'owner']) {
    expect(
      resolveProjectAccess({ role, projectScope: 'all', grant: null })
    ).toEqual({ level: 'write' });
  }
  expect(
    resolveProjectAccess({ role: 'viewer', projectScope: 'all', grant: null })
  ).toEqual({ level: 'read' });
});

test('scope selected without a row is no access, whatever the role', () => {
  for (const role of ['admin', 'owner', 'member', 'viewer']) {
    expect(
      resolveProjectAccess({ role, projectScope: 'selected', grant: null })
    ).toBeNull();
  }
});

test('a selected row derives write from the role unless it restricts to read', () => {
  expect(
    resolveProjectAccess({
      role: 'member',
      projectScope: 'selected',
      grant: { level: null },
    })
  ).toEqual({ level: 'write' });
  expect(
    resolveProjectAccess({
      role: 'member',
      projectScope: 'selected',
      grant: { level: 'read' },
    })
  ).toEqual({ level: 'read' });
});

test('a viewer never gets more than read from a row', () => {
  expect(
    resolveProjectAccess({
      role: 'viewer',
      projectScope: 'selected',
      grant: { level: 'write' },
    })
  ).toEqual({ level: 'read' });
});

// What the previous build answered, spelled out so the migration's mapping
// (no rows → all; rows → selected, read kept, write/admin → null) is checked
// against it rather than assumed.
function legacyProjectAccess(
  rows: { projectId: string; level: 'read' | 'write' | 'admin' }[],
  projectId: string
) {
  if (rows.length === 0) {
    return { level: 'write' as const };
  }
  const row = rows.find((item) => item.projectId === projectId);
  return row ? { level: row.level } : null;
}

function migrated(
  rows: { projectId: string; level: 'read' | 'write' | 'admin' }[],
  projectId: string
) {
  const grant = rows.find((item) => item.projectId === projectId);
  return resolveProjectAccess({
    role: 'member',
    projectScope: rows.length === 0 ? 'all' : 'selected',
    grant: grant ? { level: grant.level === 'read' ? 'read' : null } : null,
  });
}

test('the migrated shape gives the same verdict as the legacy rule for every row shape', () => {
  const fixtures: { projectId: string; level: 'read' | 'write' | 'admin' }[][] =
    [
      [],
      [{ projectId: 'a', level: 'write' }],
      [{ projectId: 'a', level: 'read' }],
      [{ projectId: 'a', level: 'admin' }],
      [
        { projectId: 'a', level: 'read' },
        { projectId: 'b', level: 'write' },
      ],
    ];
  for (const rows of fixtures) {
    for (const projectId of ['a', 'b', 'c']) {
      const legacy = legacyProjectAccess(rows, projectId);
      const current = migrated(rows, projectId);
      // `admin` collapses to write: the ladder already treats them alike.
      const expected =
        legacy?.level === 'admin' ? { level: 'write' as const } : legacy;
      expect(current).toEqual(expected);
    }
  }
});

test('listProjectMemberEmails mails all-scope members and selected members with a row, nobody else', async () => {
  const members = [
    {
      userId: 'u_all',
      role: 'member',
      projectScope: 'all',
      projects: [],
      user: { email: '[email protected]' },
    },
    {
      userId: 'u_this',
      role: 'viewer',
      projectScope: 'selected',
      projects: [{ projectId: 'p1', level: 'read' }],
      user: { email: '[email protected]' },
    },
    {
      userId: 'u_other',
      role: 'admin',
      projectScope: 'selected',
      projects: [{ projectId: 'p2', level: null }],
      user: { email: '[email protected]' },
    },
    {
      userId: 'u_dup',
      role: 'member',
      projectScope: 'all',
      projects: [],
      user: { email: '[email protected]' },
    },
  ];
  const memberWhere: unknown[] = [];
  const db = {
    member: {
      findMany: async ({ where }: { where: unknown }) => {
        memberWhere.push(where);
        return members;
      },
    },
  } as unknown as Db;

  const emails = await listProjectMemberEmails(db, {
    organizationId: 'org_1',
    projectId: 'p1',
  });

  expect(emails.sort()).toEqual(['[email protected]', '[email protected]']);
  expect(memberWhere).toEqual([
    { organizationId: 'org_1', user: { deletedAt: null } },
  ]);
});