OpenPanel is an open-source web and product analytics platform, an open-source alternative to Mixpanel with optional self-hosting.
// 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 } },
]);
});