Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

fix(membership): retain Certificate Manager and PAM project admins (#8456)

Andrew Huang329d860abf6d
diff --git a/backend/src/ee/services/agent-vault-member/agent-vault-membership-service.test.ts b/backend/src/ee/services/agent-vault-member/agent-vault-membership-service.test.ts
index 22b3e50f8b..1f4bccebdc 100644
--- a/backend/src/ee/services/agent-vault-member/agent-vault-membership-service.test.ts
+++ b/backend/src/ee/services/agent-vault-member/agent-vault-membership-service.test.ts
@@ -32,7 +32,10 @@ const buildTx = (adminCount: number) => {
return chain;
});
});
- chain.first = vi.fn().mockResolvedValue({ count: String(adminCount) });
+ chain.first = vi
+ .fn()
+ .mockResolvedValueOnce({ count: String(adminCount) })
+ .mockResolvedValue({ count: "1" });
const tx = vi.fn(() => chain) as unknown as { raw: ReturnType<typeof vi.fn> };
tx.raw = vi.fn();
diff --git a/backend/src/ee/services/pam-membership/pam-membership-service.test.ts b/backend/src/ee/services/pam-membership/pam-membership-service.test.ts
index acc8fcb0ac..fc759d0e2b 100644
--- a/backend/src/ee/services/pam-membership/pam-membership-service.test.ts
+++ b/backend/src/ee/services/pam-membership/pam-membership-service.test.ts
@@ -1,3 +1,4 @@
+import knex, { Knex } from "knex";
import { describe, expect, test, vi } from "vitest";
import { AccessScope } from "@app/db/schemas";
@@ -20,6 +21,75 @@ const ctx = {
const user = (id: string, username: string) => ({ id, username, isGhost: false });
+describe("pamMembership product admin retention", () => {
+ const buildRemovalService = (adminCount: number) => {
+ const query = knex({ client: "pg" }).queryBuilder();
+ vi.spyOn(query, "first")
+ .mockResolvedValueOnce({ count: String(adminCount) })
+ .mockResolvedValue({ count: "1" });
+ const tx = Object.assign(
+ vi.fn(() => query),
+ { raw: vi.fn().mockResolvedValue(undefined) }
+ ) as unknown as Knex;
+ const deps = {
+ permissionService: { getProjectPermission: vi.fn().mockResolvedValue({ hasRole: () => true }) },
+ membershipDAL: {
+ find: vi.fn().mockResolvedValue([{ id: "membership-1" }]),
+ transaction: vi.fn((cb: (trx: Knex) => unknown) => cb(tx)),
+ deleteById: vi.fn()
+ },
+ membershipRoleDAL: {
+ find: vi.fn().mockResolvedValue([{ role: PamProductRole.Admin }]),
+ update: vi.fn(),
+ delete: vi.fn()
+ }
+ };
+ return {
+ service: pamMembershipServiceFactory(deps as unknown as Parameters<typeof pamMembershipServiceFactory>[0]),
+ deps,
+ tx
+ };
+ };
+
+ test("refuses last-admin removal before deleting any roles or membership", async () => {
+ const { service, deps } = buildRemovalService(0);
+ await expect(service.removeProductMember({ ...ctx, projectId: PROJECT_ID, userId: "other-user" })).rejects.toThrow(
+ "Privileged Access Manager must keep at least one admin"
+ );
+ expect(deps.membershipRoleDAL.delete).not.toHaveBeenCalled();
+ expect(deps.membershipDAL.deleteById).not.toHaveBeenCalled();
+ });
+
+ test("refuses last-admin demotion before changing the role", async () => {
+ const { service, deps } = buildRemovalService(0);
+ await expect(
+ service.updateProductMemberRole({
+ ...ctx,
+ projectId: PROJECT_ID,
+ userId: "other-user",
+ role: PamProductRole.Member
+ })
+ ).rejects.toThrow("Privileged Access Manager must keep at least one admin");
+ expect(deps.membershipRoleDAL.update).not.toHaveBeenCalled();
+ });
+
+ test("allows demotion when another admin remains, in the guard transaction", async () => {
+ const { service, deps, tx } = buildRemovalService(1);
+ await service.updateProductMemberRole({
+ ...ctx,
+ projectId: PROJECT_ID,
+ userId: "other-user",
+ role: PamProductRole.Member
+ });
+ expect(deps.membershipRoleDAL.update).toHaveBeenCalledWith(
+ { membershipId: "membership-1" },
+ { role: PamProductRole.Member },
+ tx
+ );
+ expect(tx.raw).toHaveBeenCalled();
+ });
+});
+
// Only the collaborators addProductUserMembers touches on the add path; everything else is left
// undefined so an unexpected reach shows up as a crash rather than a silent pass.
const buildService = ({
diff --git a/backend/src/ee/services/pam-membership/pam-membership-service.ts b/backend/src/ee/services/pam-membership/pam-membership-service.ts
index c6af0af130..cd9a7fb193 100644
--- a/backend/src/ee/services/pam-membership/pam-membership-service.ts
+++ b/backend/src/ee/services/pam-membership/pam-membership-service.ts
@@ -20,6 +20,7 @@ import { TIdentityDALFactory } from "@app/services/identity/identity-dal";
import { PamIdentities } from "@app/services/license-client";
import { TUsageMeteringServiceFactory } from "@app/services/license-client/usage";
import { TMembershipDALFactory } from "@app/services/membership/membership-dal";
+import { assertWillRetainProjectAdmin } from "@app/services/membership/membership-fns";
import { TMembershipRoleDALFactory } from "@app/services/membership/membership-role-dal";
import { TOrgDALFactory } from "@app/services/org/org-dal";
import { TProjectAccessRequestDALFactory } from "@app/services/project/project-access-request-dal";
@@ -566,22 +567,6 @@ export const pamMembershipServiceFactory = ({
return { memberships, skipped };
};
- const assertNotLastAdmin = async (projectId: string, membershipId: string, tx?: Knex) => {
- const allProductMemberships = await membershipDAL.find(
- { scope: AccessScope.Project, scopeProjectId: projectId },
- { tx }
- );
- const otherMemberships = allProductMemberships.filter((m) => m.id !== membershipId);
-
- const otherRoles = await Promise.all(
- otherMemberships.map((m) => membershipRoleDAL.find({ membershipId: m.id }, { tx }))
- );
- const hasOtherAdmin = otherRoles.some((roles) => roles.some((r) => r.role === PamProductRole.Admin));
- if (!hasOtherAdmin) {
- throw new BadRequestError({ message: "Cannot remove or demote the last product admin" });
- }
- };
-
const updateProductMemberRole = async ({ projectId, role, ...dto }: TUpdatePamProductMemberDTO & TActorContext) => {
await checkProductAdmin(projectId, dto);
@@ -612,10 +597,13 @@ export const pamMembershipServiceFactory = ({
});
}
- const existingRoles = await membershipRoleDAL.find({ membershipId: membership.id }, { tx });
- const wasAdmin = existingRoles.some((r) => r.role === PamProductRole.Admin);
- if (wasAdmin && role !== PamProductRole.Admin) {
- await assertNotLastAdmin(projectId, membership.id, tx);
+ if (role !== PamProductRole.Admin) {
+ await assertWillRetainProjectAdmin({
+ scopeProjectId: projectId,
+ excludeMembershipIds: [membership.id],
+ productLabel: "Privileged Access Manager",
+ tx
+ });
}
await upsertRole(membership.id, role, tx);
@@ -667,10 +655,12 @@ export const pamMembershipServiceFactory = ({
});
}
- const roles = await membershipRoleDAL.find({ membershipId: membership.id }, { tx });
- if (roles.some((r) => r.role === PamProductRole.Admin)) {
- await assertNotLastAdmin(projectId, membership.id, tx);
- }
+ await assertWillRetainProjectAdmin({
+ scopeProjectId: projectId,
+ excludeMembershipIds: [membership.id],
+ productLabel: "Privileged Access Manager",
+ tx
+ });
await membershipRoleDAL.delete({ membershipId: membership.id }, tx);
diff --git a/backend/src/services/identity-v2/identity-service.test.ts b/backend/src/services/identity-v2/identity-service.test.ts
index 0a95ef21e2..eab8ea41ab 100644
--- a/backend/src/services/identity-v2/identity-service.test.ts
+++ b/backend/src/services/identity-v2/identity-service.test.ts
@@ -1,8 +1,8 @@
import { createMongoAbility } from "@casl/ability";
-import { Knex } from "knex";
+import knex, { Knex } from "knex";
import { beforeEach, describe, expect, test, vi } from "vitest";
-import { AccessScope } from "@app/db/schemas";
+import { AccessScope, ProjectType } from "@app/db/schemas";
import { identityV2ServiceFactory } from "./identity-service";
import { TDeleteIdentityV2DTO } from "./identity-types";
@@ -40,13 +40,15 @@ const buildDto = (): TDeleteIdentityV2DTO =>
}) as unknown as TDeleteIdentityV2DTO;
const createService = ({
- existingIdentity = { id: IDENTITY_ID, name: "ident", hasDeleteProtection: false }
-}: { existingIdentity?: Record<string, unknown> | null } = {}) => {
+ existingIdentity = { id: IDENTITY_ID, name: "ident", hasDeleteProtection: false },
+ projectType,
+ tx = TX
+}: { existingIdentity?: Record<string, unknown> | null; projectType?: ProjectType; tx?: Knex } = {}) => {
const deleteAlertsForDeletedResource = vi.fn().mockResolvedValue(0);
const identityDAL = {
findOne: vi.fn().mockResolvedValue(existingIdentity),
- transaction: vi.fn(async (cb: (tx: Knex) => Promise<unknown>) => cb(TX)),
+ transaction: vi.fn(async (cb: (tx: Knex) => Promise<unknown>) => cb(tx)),
deleteById: vi.fn().mockResolvedValue({ id: IDENTITY_ID, name: "ident" }),
updateById: vi.fn().mockResolvedValue({ id: IDENTITY_ID, name: "renamed" })
};
@@ -66,7 +68,10 @@ const createService = ({
} as never,
licenseService: { getPlan: vi.fn(), updateSubscriptionOrgMemberCount: vi.fn() } as never,
// The delete guards bound the removal against the roles the target identity holds.
- membershipIdentityDAL: { getIdentityById: vi.fn().mockResolvedValue({ roles: [] }) } as never,
+ membershipIdentityDAL: {
+ getIdentityById: vi.fn().mockResolvedValue({ roles: [] }),
+ find: vi.fn().mockResolvedValue([{ id: "identity-membership" }])
+ } as never,
membershipRoleDAL: {} as never,
identityMetadataDAL: { delete: vi.fn(), insertMany: vi.fn() } as never,
identityAccessTokenService: {
@@ -77,7 +82,7 @@ const createService = ({
projectDAL: {
findActorAccessibleProjectIds: vi.fn(),
findOrgProjectIds: vi.fn(),
- findById: vi.fn()
+ findById: vi.fn().mockResolvedValue(projectType ? { id: PROJECT_ID, type: projectType } : undefined)
} as never,
orgDAL: { findById: vi.fn().mockResolvedValue({ id: ORG_ID, shouldUseNewPrivilegeSystem: true }) } as never,
roleDAL: { find: vi.fn() } as never,
@@ -124,6 +129,28 @@ describe("deleteIdentity alert cleanup", () => {
);
});
+ test.each([ProjectType.CertificateManager, ProjectType.PAM, ProjectType.AgentVault])(
+ "refuses deleting the last project admin identity in %s",
+ async (projectType) => {
+ const query = knex({ client: "pg" }).queryBuilder();
+ vi.spyOn(query, "first").mockResolvedValueOnce({ count: "0" }).mockResolvedValue({ count: "1" });
+ const tx = Object.assign(
+ vi.fn(() => query),
+ { raw: vi.fn().mockResolvedValue(undefined) }
+ ) as unknown as Knex;
+ const { service, identityDAL, deleteAlertsForDeletedResource } = createService({ projectType, tx });
+ await expect(
+ service.deleteIdentity({
+ ...buildDto(),
+ scopeData: { scope: AccessScope.Project, orgId: ORG_ID, projectId: PROJECT_ID }
+ })
+ ).rejects.toThrow("must keep at least one admin");
+ expect(identityDAL.deleteById).not.toHaveBeenCalled();
+ expect(deleteAlertsForDeletedResource).not.toHaveBeenCalled();
+ expect(query.toSQL().bindings).toContain("identity-membership");
+ }
+ );
+
test("delete protection stops the delete before anything is reaped", async () => {
const { service, deleteAlertsForDeletedResource } = createService({
existingIdentity: { id: IDENTITY_ID, name: "ident", hasDeleteProtection: true }
diff --git a/backend/src/services/identity-v2/identity-service.ts b/backend/src/services/identity-v2/identity-service.ts
index 7d72ff4c45..05fc0025b2 100644
--- a/backend/src/services/identity-v2/identity-service.ts
+++ b/backend/src/services/identity-v2/identity-service.ts
@@ -45,7 +45,7 @@ import { ActorType } from "../auth/auth-type";
import { getIdentityActiveLockoutAuthMethods } from "../identity/identity-fns";
import { TIdentityMetadataDALFactory } from "../identity/identity-metadata-dal";
import { TIdentityAccessTokenServiceFactory } from "../identity-access-token/identity-access-token-service";
-import { filterRolesNeedingPrivilegeBoundary } from "../membership/membership-fns";
+import { assertProductWillRetainAdmin, filterRolesNeedingPrivilegeBoundary } from "../membership/membership-fns";
import { TMembershipRoleDALFactory } from "../membership/membership-role-dal";
import { TMembershipIdentityDALFactory } from "../membership-identity/membership-identity-dal";
import { TIdentityV2DALFactory } from "./identity-dal";
@@ -410,6 +410,24 @@ export const identityV2ServiceFactory = ({
// Set the identity-wide PG revocation epoch atomically with the row delete
// so any JWT issued for this identity (with iat < now) is rejected.
const deletedIdentity = await identityDAL.transaction(async (tx) => {
+ if (scopeData.scope === AccessScope.Project) {
+ const project = await projectDAL.findById(scopeData.projectId, tx);
+ if (getAdminMemberOnlyProductLabel(project?.type)) {
+ const memberships = await membershipIdentityDAL.find(
+ {
+ scope: AccessScope.Project,
+ scopeProjectId: scopeData.projectId,
+ actorIdentityId: dto.selector.identityId
+ },
+ { tx }
+ );
+ await assertProductWillRetainAdmin({
+ project,
+ excludeMembershipIds: memberships.map(({ id }) => id),
+ tx
+ });
+ }
+ }
await identityAccessTokenService.insertIdentityWideRevocationMarker({ identityId: dto.selector.identityId, tx });
await alertService.deleteAlertsForDeletedResource(
diff --git a/backend/src/services/membership-group/membership-group-service.ts b/backend/src/services/membership-group/membership-group-service.ts
index 7d4b1f53e3..e8751f6bb0 100644
--- a/backend/src/services/membership-group/membership-group-service.ts
+++ b/backend/src/services/membership-group/membership-group-service.ts
@@ -306,9 +306,9 @@ export const membershipGroupServiceFactory = ({
const customRolesGroupBySlug = groupBy(customRoles, ({ slug }) => slug);
const membershipDoc = await membershipGroupDAL.transaction(async (tx) => {
- const newRolesHavePermanentAdmin = data.roles.some(
- (r) => r.role === ProjectMembershipRole.Admin && !r.isTemporary
- );
+ const newIsActive = data.isActive ?? existingMembership.isActive;
+ const newRolesHavePermanentAdmin =
+ newIsActive && data.roles.some((r) => r.role === ProjectMembershipRole.Admin && !r.isTemporary);
if (!newRolesHavePermanentAdmin && scopeData.scope === AccessScope.Project) {
await assertProductWillRetainAdmin({
project: await projectDAL.findById(scopeData.projectId, tx),
diff --git a/backend/src/services/membership-identity/membership-identity-service.test.ts b/backend/src/services/membership-identity/membership-identity-service.test.ts
index 83c7be4238..cbdd0aede9 100644
--- a/backend/src/services/membership-identity/membership-identity-service.test.ts
+++ b/backend/src/services/membership-identity/membership-identity-service.test.ts
@@ -1,8 +1,8 @@
import { createMongoAbility } from "@casl/ability";
-import { Knex } from "knex";
+import knex, { Knex } from "knex";
import { beforeEach, describe, expect, test, vi } from "vitest";
-import { AccessScope } from "@app/db/schemas";
+import { AccessScope, ProjectType } from "@app/db/schemas";
import { membershipIdentityServiceFactory } from "./membership-identity-service";
import {
@@ -40,8 +40,10 @@ const buildDto = (): TDeleteMembershipIdentityDTO => ({
});
const createService = ({
- existingMembership = { id: MEMBERSHIP_ID, actorIdentityId: IDENTITY_ID }
-}: { existingMembership?: Record<string, unknown> | null } = {}) => {
+ existingMembership = { id: MEMBERSHIP_ID, actorIdentityId: IDENTITY_ID },
+ projectType,
+ tx = {} as Knex
+}: { existingMembership?: Record<string, unknown> | null; projectType?: ProjectType; tx?: Knex } = {}) => {
const bumpIdentityRevocationVersion = vi.fn().mockResolvedValue(undefined);
const insertOrgMembershipRevocationMarker = vi.fn().mockResolvedValue(undefined);
const removeOrgMembershipRevocationMarkers = vi.fn().mockResolvedValue(undefined);
@@ -57,7 +59,7 @@ const createService = ({
create: vi.fn().mockResolvedValue({ id: MEMBERSHIP_ID, actorIdentityId: IDENTITY_ID }),
updateById: vi.fn().mockImplementation(async (id: string, data: Record<string, unknown>) => ({ id, ...data })),
deleteById: vi.fn().mockResolvedValue({ id: MEMBERSHIP_ID }),
- transaction: vi.fn(async (cb: (tx: Knex) => Promise<unknown>) => cb({} as Knex))
+ transaction: vi.fn(async (cb: (tx: Knex) => Promise<unknown>) => cb(tx))
};
const service = membershipIdentityServiceFactory({
@@ -90,7 +92,9 @@ const createService = ({
} as never,
licenseService: { getPlan: vi.fn() } as never,
applicationMembershipCleanupService: { cleanupActorApplicationMemberships: vi.fn() } as never,
- projectDAL: { findById: vi.fn() } as never,
+ projectDAL: {
+ findById: vi.fn().mockResolvedValue(projectType ? { id: "project-1", type: projectType } : undefined)
+ } as never,
keyStore: { sortedSetRangeByScore: vi.fn().mockResolvedValue([]) } as never,
usageMeteringService: { emit: vi.fn(), emitForProject: vi.fn() } as never,
alertService: { deleteAlertsForResource } as never,
@@ -144,6 +148,35 @@ describe("deleteMembership org revocation bump ordering", () => {
const PROJECT_ID = "project-1";
+describe("project admin identity deactivation", () => {
+ test.each([ProjectType.CertificateManager, ProjectType.PAM, ProjectType.AgentVault])(
+ "refuses disabling the last admin while retaining its Admin role in %s",
+ async (projectType) => {
+ const query = knex({ client: "pg" }).queryBuilder();
+ vi.spyOn(query, "first").mockResolvedValueOnce({ count: "0" }).mockResolvedValue({ count: "1" });
+ const tx = Object.assign(
+ vi.fn(() => query),
+ { raw: vi.fn().mockResolvedValue(undefined) }
+ ) as unknown as Knex;
+ const { service, membershipIdentityDAL } = createService({
+ projectType,
+ tx,
+ existingMembership: { id: MEMBERSHIP_ID, actorIdentityId: IDENTITY_ID, isActive: true }
+ });
+ await expect(
+ service.updateMembership({
+ ...buildDto(),
+ scopeData: { scope: AccessScope.Project, orgId: SUB_ORG_ID, projectId: PROJECT_ID },
+ data: { roles: [{ role: "admin", isTemporary: false }], isActive: false }
+ })
+ ).rejects.toThrow("must keep at least one admin");
+ expect(membershipIdentityDAL.updateById).not.toHaveBeenCalled();
+ expect(membershipIdentityDAL.findByIdForUpdate).not.toHaveBeenCalled();
+ expect(query.toSQL().bindings).toContain(MEMBERSHIP_ID);
+ }
+ );
+});
+
describe("deleteMembership alert cleanup", () => {
beforeEach(() => vi.clearAllMocks());
diff --git a/backend/src/services/membership-identity/membership-identity-service.ts b/backend/src/services/membership-identity/membership-identity-service.ts
index 882177b1c6..4466758582 100644
--- a/backend/src/services/membership-identity/membership-identity-service.ts
+++ b/backend/src/services/membership-identity/membership-identity-service.ts
@@ -312,9 +312,9 @@ export const membershipIdentityServiceFactory = ({
const membershipDoc = await membershipIdentityDAL.transaction(async (tx) => {
// The project advisory lock before the row lock, the order every other caller takes: a product-route
// change holding the advisory lock needs KEY SHARE on this row, so the reverse order deadlocks.
- const newRolesHavePermanentAdmin = data.roles.some(
- (r) => r.role === ProjectMembershipRole.Admin && !r.isTemporary
- );
+ const newIsActive = data.isActive ?? existingMembership.isActive;
+ const newRolesHavePermanentAdmin =
+ newIsActive && data.roles.some((r) => r.role === ProjectMembershipRole.Admin && !r.isTemporary);
if (!newRolesHavePermanentAdmin && scopeData.scope === AccessScope.Project) {
await assertProductWillRetainAdmin({
project: await projectDAL.findById(scopeData.projectId, tx),
diff --git a/backend/src/services/membership/membership-fns.test.ts b/backend/src/services/membership/membership-fns.test.ts
index 361135584d..f8038c45e9 100644
--- a/backend/src/services/membership/membership-fns.test.ts
+++ b/backend/src/services/membership/membership-fns.test.ts
@@ -1,4 +1,74 @@
-import { resolveMembershipRoleSlugs } from "./membership-fns";
+import knex, { Knex } from "knex";
+import { vi } from "vitest";
+
+import { ProjectType } from "@app/db/schemas";
+import { PgSqlLock } from "@app/keystore/keystore";
+
+import { assertProductWillRetainAdmin, resolveMembershipRoleSlugs } from "./membership-fns";
+
+describe("product admin retention", () => {
+ const buildTx = (adminCount: number, removingAdmins = 1) => {
+ const db = knex({ client: "pg" });
+ const query = db.queryBuilder();
+ const first = vi
+ .spyOn(query, "first")
+ .mockResolvedValueOnce({ count: String(adminCount) })
+ .mockResolvedValue({ count: String(removingAdmins) });
+ const tx = Object.assign(
+ vi.fn(() => query),
+ { raw: vi.fn().mockResolvedValue(undefined) }
+ );
+ return { tx: tx as unknown as Knex, raw: tx.raw, query, first };
+ };
+
+ test.each([ProjectType.CertificateManager, ProjectType.PAM, ProjectType.AgentVault])(
+ "blocks removing the last admin in %s",
+ async (type) => {
+ const { tx, raw, first } = buildTx(0);
+ await expect(
+ assertProductWillRetainAdmin({ project: { id: "project-1", type }, excludeMembershipIds: ["admin-1"], tx })
+ ).rejects.toThrow("must keep at least one admin");
+ expect(raw).toHaveBeenCalledWith("SELECT pg_advisory_xact_lock(?)", [
+ PgSqlLock.LastAdminGuard("project", "project-1")
+ ]);
+ expect(raw.mock.invocationCallOrder[0]).toBeLessThan(first.mock.invocationCallOrder[0]);
+ }
+ );
+
+ test("allows another active built-in admin of any actor kind using the transaction", async () => {
+ const { tx, query } = buildTx(1);
+ await assertProductWillRetainAdmin({
+ project: { id: "project-1", type: ProjectType.CertificateManager },
+ excludeMembershipIds: ["admin-1"],
+ tx
+ });
+ const { sql, bindings } = query.toSQL();
+ expect(sql).toContain('"isActive" = ?');
+ expect(sql).toContain('"isTemporary" = ? or "membership_roles"."temporaryAccessEndTime" > ?');
+ expect(sql).toContain('"id" not in (?)');
+ expect(bindings).toContain("admin");
+ expect(bindings).toContain("admin-1");
+ expect(sql).not.toMatch(/actorUserId|actorGroupId|actorIdentityId|customRoleId/);
+ });
+
+ test("allows changing a non-admin in an already adminless project", async () => {
+ const { tx } = buildTx(0, 0);
+ await assertProductWillRetainAdmin({
+ project: { id: "project-1", type: ProjectType.CertificateManager },
+ excludeMembershipIds: ["member-1"],
+ tx
+ });
+ });
+
+ test.each([ProjectType.SecretManager, ProjectType.KMS, ProjectType.SecretScanning, null])(
+ "does not change retention policy for %s",
+ async (type) => {
+ const { tx, raw } = buildTx(0);
+ await assertProductWillRetainAdmin({ project: { id: "project-1", type }, excludeMembershipIds: [], tx });
+ expect(raw).not.toHaveBeenCalled();
+ }
+ );
+});
describe("resolveMembershipRoleSlugs", () => {
test("prefers the custom role slug over the built-in role column", () => {
diff --git a/backend/src/services/membership/membership-fns.ts b/backend/src/services/membership/membership-fns.ts
index e05c98708c..a6d05b3562 100644
--- a/backend/src/services/membership/membership-fns.ts
+++ b/backend/src/services/membership/membership-fns.ts
@@ -88,7 +88,8 @@ type TAssertWillRetainProjectAdminArg = {
// Must run inside the same transaction as the membership mutation, like assertWillRetainOrgAdmin: the
// advisory lock serializes admin mutations per project so two concurrent demotions cannot both pass the
// count and leave none. Every actor kind counts, since a group or machine identity holding the admin role
-// can still administer the product, and a lapsed temporary role confers nothing so it is not counted.
+// can still administer the product, and a lapsed temporary role confers nothing so it is not counted. A
+// change that touches no live admin cannot lower the count, so it passes even in an already adminless project.
export const assertWillRetainProjectAdmin = async ({
scopeProjectId,
excludeMembershipIds,
@@ -97,23 +98,32 @@ export const assertWillRetainProjectAdmin = async ({
}: TAssertWillRetainProjectAdminArg) => {
await tx.raw("SELECT pg_advisory_xact_lock(?)", [PgSqlLock.LastAdminGuard("project", scopeProjectId)]);
- const query = tx(TableName.Membership)
- .join(TableName.MembershipRole, `${TableName.Membership}.id`, `${TableName.MembershipRole}.membershipId`)
- .where(`${TableName.Membership}.scope`, AccessScope.Project)
- .where(`${TableName.Membership}.scopeProjectId`, scopeProjectId)
- .where(`${TableName.Membership}.isActive`, true)
- .where(`${TableName.MembershipRole}.role`, ProjectMembershipRole.Admin)
- .where((qb) => {
- void qb
- .where(`${TableName.MembershipRole}.isTemporary`, false)
- .orWhere(`${TableName.MembershipRole}.temporaryAccessEndTime`, ">", new Date());
- });
- if (excludeMembershipIds.length) {
- void query.whereNotIn(`${TableName.Membership}.id`, excludeMembershipIds);
- }
+ const countLiveAdmins = async (filter: (qb: Knex.QueryBuilder) => void) => {
+ const query = tx(TableName.Membership)
+ .join(TableName.MembershipRole, `${TableName.Membership}.id`, `${TableName.MembershipRole}.membershipId`)
+ .where(`${TableName.Membership}.scope`, AccessScope.Project)
+ .where(`${TableName.Membership}.scopeProjectId`, scopeProjectId)
+ .where(`${TableName.Membership}.isActive`, true)
+ .where(`${TableName.MembershipRole}.role`, ProjectMembershipRole.Admin)
+ .where((qb) => {
+ void qb
+ .where(`${TableName.MembershipRole}.isTemporary`, false)
+ .orWhere(`${TableName.MembershipRole}.temporaryAccessEndTime`, ">", new Date());
+ });
+ filter(query);
+ const result = await query.countDistinct<{ count: string }[]>(`${TableName.Membership}.id as count`).first();
+ return Number(result?.count ?? 0);
+ };
+
+ const remaining = await countLiveAdmins((qb) => {
+ if (excludeMembershipIds.length) void qb.whereNotIn(`${TableName.Membership}.id`, excludeMembershipIds);
+ });
+ if (remaining > 0) return;
- const result = await query.countDistinct<{ count: string }[]>(`${TableName.Membership}.id as count`).first();
- if (Number(result?.count ?? 0) < 1) {
+ const removing = await countLiveAdmins((qb) => {
+ void qb.whereIn(`${TableName.Membership}.id`, excludeMembershipIds);
+ });
+ if (removing > 0) {
throw new BadRequestError({ message: `${productLabel} must keep at least one admin` });
}
};
@@ -129,7 +139,7 @@ export const assertProductWillRetainAdmin = async ({
excludeMembershipIds: string[];
tx: Knex;
}) => {
- if (project?.type !== ProjectType.AgentVault) return;
+ if (!project) return;
const productLabel = getAdminMemberOnlyProductLabel(project.type);
if (!productLabel) return;
await assertWillRetainProjectAdmin({ scopeProjectId: project.id, excludeMembershipIds, productLabel, tx });