Skip to content

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

let admins permanently delete a pending-deletion project

DimitrisStaratzisd0769717e40e
diff --git a/backend/e2e-test/routes/v1/project.spec.ts b/backend/e2e-test/routes/v1/project.spec.ts
index 63c4e793fd..813a794807 100644
--- a/backend/e2e-test/routes/v1/project.spec.ts
+++ b/backend/e2e-test/routes/v1/project.spec.ts
@@ -44,6 +44,16 @@ const restoreProject = async (projectId: string) => {
});
};
+const permanentlyDeleteProject = async (projectId: string) => {
+ return testServer.inject({
+ method: "DELETE",
+ url: `/api/v1/projects/deleted/${projectId}`,
+ headers: {
+ authorization: `Bearer ${jwtAuthToken}`
+ }
+ });
+};
+
const listDeletedProjects = async (): Promise<{ id: string; deleteAfter: string }[]> => {
const res = await testServer.inject({
method: "GET",
@@ -121,6 +131,31 @@ describe("Project deletion (soft-delete + async cleanup)", async () => {
await deleteProject(second.id, true);
});
+ test("keeps the slug reserved until the deleted project is permanently deleted", async () => {
+ const slug = "e2e-slug-reserved-test";
+ const first = await createProject("e2e-slug-reserved-1", slug);
+ expect((await deleteProject(first.id)).statusCode).toBe(200);
+
+ const blockedRes = await testServer.inject({
+ method: "POST",
+ url: "/api/v1/projects",
+ headers: {
+ authorization: `Bearer ${jwtAuthToken}`
+ },
+ body: { projectName: "e2e-slug-reserved-2", slug }
+ });
+ expect(blockedRes.statusCode).toBe(400);
+ expect(JSON.parse(blockedRes.payload).message).toContain("pending-deletion");
+
+ expect((await permanentlyDeleteProject(first.id)).statusCode).toBe(200);
+ expect((await listDeletedProjects()).some((p) => p.id === first.id)).toBe(false);
+
+ const second = await createProject("e2e-slug-reserved-2", slug);
+ expect(second.slug).toBe(slug);
+
+ await deleteProject(second.id, true);
+ });
+
test("cannot delete an already-deleted project", async () => {
const project = await createProject("e2e-double-delete");
expect((await deleteProject(project.id)).statusCode).toBe(200);
diff --git a/backend/src/lib/api-docs/constants.ts b/backend/src/lib/api-docs/constants.ts
index a9d702b41d..036c7aa42a 100644
--- a/backend/src/lib/api-docs/constants.ts
+++ b/backend/src/lib/api-docs/constants.ts
@@ -1073,6 +1073,9 @@ export const PROJECTS = {
RESTORE: {
projectId: "The ID of the soft-deleted project to restore."
},
+ PERMANENTLY_DELETE: {
+ projectId: "The ID of the soft-deleted project to permanently delete."
+ },
GET: {
projectId: "The ID of the project."
},
diff --git a/backend/src/server/routes/v1/project-router.ts b/backend/src/server/routes/v1/project-router.ts
index 1595f5c4a1..9248005a17 100644
--- a/backend/src/server/routes/v1/project-router.ts
+++ b/backend/src/server/routes/v1/project-router.ts
@@ -552,6 +552,60 @@ export const registerProjectRouter = async (server: FastifyZodProvider) => {
}
});
+ server.route({
+ method: "DELETE",
+ url: "/deleted/:projectId",
+ config: {
+ rateLimit: writeLimit
+ },
+ schema: {
+ hide: false,
+ operationId: "permanentlyDeleteProject",
+ tags: [ApiDocsTags.Projects],
+ description: "Permanently delete a soft-deleted project without waiting for its grace period to end",
+ security: [
+ {
+ bearerAuth: []
+ }
+ ],
+ params: z.object({
+ projectId: z.string().trim().describe(PROJECTS.PERMANENTLY_DELETE.projectId)
+ }),
+ response: {
+ 200: z.object({
+ project: SanitizedProjectSchema
+ })
+ }
+ },
+ onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]),
+ handler: async (req) => {
+ const project = await server.services.project.permanentlyDeleteProject({
+ actorId: req.permission.id,
+ actor: req.permission.type,
+ actorOrgId: req.permission.orgId,
+ actorAuthMethod: req.permission.authMethod,
+ projectId: req.params.projectId
+ });
+
+ await server.services.auditLog.createAuditLog({
+ ...req.auditLogInfo,
+ orgId: req.permission.orgId,
+ projectId: project.id,
+ event: {
+ type: EventType.DELETE_PROJECT,
+ metadata: {
+ id: project.id,
+ name: project.name,
+ softDelete: true,
+ deleteAfter: project.deleteAfter
+ }
+ }
+ });
+
+ return { project };
+ }
+ });
+
server.route({
method: "POST",
url: "/:projectId/restore",
diff --git a/backend/src/services/project/project-dal.ts b/backend/src/services/project/project-dal.ts
index 0ac1c8e029..378eeefcf1 100644
--- a/backend/src/services/project/project-dal.ts
+++ b/backend/src/services/project/project-dal.ts
@@ -131,6 +131,19 @@ export const projectDALFactory = (db: TDbClient) => {
}
};
+ const expireSoftDeletedById = async (id: string, slug: string, tx?: Knex) => {
+ try {
+ const [doc] = await (tx || db)(TableName.Project)
+ .where({ id })
+ .whereNotNull("deleteAfter")
+ .update({ deleteAfter: new Date(), slug })
+ .returning("*");
+ return doc as TProjects | undefined;
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Expire soft-deleted project" });
+ }
+ };
+
const restoreById = async (id: string, tx?: Knex) => {
try {
const [doc] = await (tx || db)(TableName.Project)
@@ -1159,6 +1172,7 @@ export const projectDALFactory = (db: TDbClient) => {
findByIdIncludingExpired,
findIncludingExpired,
softDeleteById,
+ expireSoftDeletedById,
restoreById,
findExpiredForHardDelete,
hardDeleteProjectSecretVersionsInBatches,
diff --git a/backend/src/services/project/project-service.ts b/backend/src/services/project/project-service.ts
index fcfe8e78ac..733ec77a6f 100644
--- a/backend/src/services/project/project-service.ts
+++ b/backend/src/services/project/project-service.ts
@@ -121,6 +121,7 @@ import {
TListProjectPkiSubscribersDTO,
TListProjectsDTO,
TLoadProjectKmsBackupDTO,
+ TPermanentlyDeleteProjectDTO,
TProjectAccessRequestDTO,
TRestoreProjectDTO,
TSearchProjectsDTO,
@@ -1015,6 +1016,55 @@ export const projectServiceFactory = ({
}
};
+ const permanentlyDeleteProject = async ({
+ actor,
+ actorId,
+ actorOrgId,
+ actorAuthMethod,
+ projectId
+ }: TPermanentlyDeleteProjectDTO) => {
+ const { permission } = await permissionService.getOrgPermission({
+ scope: OrganizationActionScope.Any,
+ actor,
+ actorId,
+ orgId: actorOrgId,
+ actorAuthMethod,
+ actorOrgId
+ });
+ ForbiddenError.from(permission).throwUnlessCan(
+ OrgPermissionAdminConsoleAction.AccessAllProjects,
+ OrgPermissionSubjects.AdminConsole
+ );
+
+ const project = await projectDAL.findByIdIncludingExpired(projectId);
+ if (!project || project.orgId !== actorOrgId || !project.deleteAfter) {
+ throw new NotFoundError({ message: `Deleted project with ID '${projectId}' not found` });
+ }
+
+ let lock: Awaited<ReturnType<typeof keyStore.acquireLock>> | undefined;
+ try {
+ lock = await keyStore.acquireLock([KeyStorePrefixes.ProjectDeleteLock(project.id)], 30_000, {
+ retryCount: 0
+ });
+ } catch {
+ throw new BadRequestError({
+ message: "Project is already being deleted."
+ });
+ }
+
+ try {
+ // Ends the grace period so the hard-delete worker picks it up, and frees the slug right away.
+ const expiredProject = await projectDAL.expireSoftDeletedById(project.id, `del-${alphaNumericNanoId(20)}`);
+ if (!expiredProject) {
+ throw new NotFoundError({ message: `Deleted project with ID '${projectId}' not found` });
+ }
+
+ return { ...expiredProject, slug: project.slug };
+ } finally {
+ await lock.release();
+ }
+ };
+
const getProjects = async ({ actorId, actor, includeRoles, actorAuthMethod, actorOrgId, type }: TListProjectsDTO) => {
const workspaces = (
actor === ActorType.IDENTITY
@@ -2514,6 +2564,7 @@ export const projectServiceFactory = ({
deleteProject,
listDeletedProjects,
restoreProject,
+ permanentlyDeleteProject,
getProjects,
getAccessibleProjectsWithSubOrgs,
updateProject,
diff --git a/backend/src/services/project/project-types.ts b/backend/src/services/project/project-types.ts
index 52f85a1277..56d9b7b68a 100644
--- a/backend/src/services/project/project-types.ts
+++ b/backend/src/services/project/project-types.ts
@@ -113,6 +113,8 @@ export type TDeleteProjectDTO = {
export type TRestoreProjectDTO = TProjectPermission;
+export type TPermanentlyDeleteProjectDTO = TProjectPermission;
+
export type TListDeletedProjectsDTO = {
type?: ProjectType;
} & Omit<TProjectPermission, "projectId">;
diff --git a/frontend/src/hooks/api/projects/index.tsx b/frontend/src/hooks/api/projects/index.tsx
index 9b9b7fe3db..299847fe20 100644
--- a/frontend/src/hooks/api/projects/index.tsx
+++ b/frontend/src/hooks/api/projects/index.tsx
@@ -34,6 +34,7 @@ export {
useListWorkspacePkiAlerts,
useListWorkspacePkiCollections,
useListWorkspacePkiSubscribers,
+ usePermanentlyDeleteProject,
useRestoreEnvironment,
useRestoreProject,
useSearchProjects,
diff --git a/frontend/src/hooks/api/projects/queries.tsx b/frontend/src/hooks/api/projects/queries.tsx
index f89aaede72..1c0b1fbb70 100644
--- a/frontend/src/hooks/api/projects/queries.tsx
+++ b/frontend/src/hooks/api/projects/queries.tsx
@@ -30,6 +30,7 @@ import {
DeletedProject,
DeleteEnvironmentDTO,
DeleteWorkspaceDTO,
+ PermanentlyDeleteProjectDTO,
Project,
ProjectEnv,
ProjectType,
@@ -336,6 +337,20 @@ export const useGetDeletedProjects = (type?: ProjectType, options?: { enabled?:
...options
});
+export const usePermanentlyDeleteProject = () => {
+ const queryClient = useQueryClient();
+
+ return useMutation<Project, object, PermanentlyDeleteProjectDTO>({
+ mutationFn: async ({ projectId }) => {
+ const { data } = await apiRequest.delete(`/api/v1/projects/deleted/${projectId}`);
+ return data.project;
+ },
+ onSuccess: () => {
+ queryClient.invalidateQueries({ queryKey: projectKeys.getAllUserProjects() });
+ }
+ });
+};
+
export const useRestoreProject = () => {
const queryClient = useQueryClient();
diff --git a/frontend/src/hooks/api/projects/types.ts b/frontend/src/hooks/api/projects/types.ts
index ad260d79a3..79b1fc4d2e 100644
--- a/frontend/src/hooks/api/projects/types.ts
+++ b/frontend/src/hooks/api/projects/types.ts
@@ -122,6 +122,8 @@ export type DeleteWorkspaceDTO = { projectID: string; hardDelete?: boolean };
export type RestoreProjectDTO = { projectId: string };
+export type PermanentlyDeleteProjectDTO = { projectId: string };
+
export type DeletedProject = {
id: string;
name: string;
diff --git a/frontend/src/pages/organization/ProjectsPage/components/DeletedProjectsTable.tsx b/frontend/src/pages/organization/ProjectsPage/components/DeletedProjectsTable.tsx
index 2abc797315..a519400dab 100644
--- a/frontend/src/pages/organization/ProjectsPage/components/DeletedProjectsTable.tsx
+++ b/frontend/src/pages/organization/ProjectsPage/components/DeletedProjectsTable.tsx
@@ -1,10 +1,14 @@
import { format } from "date-fns";
-import { Ellipsis, HourglassIcon, RotateCcwIcon } from "lucide-react";
+import { Ellipsis, HourglassIcon, RotateCcwIcon, Trash2Icon } from "lucide-react";
import { createNotification } from "@app/components/notifications";
import {
+ Alert,
+ AlertDescription,
AlertDialog,
+ AlertDialogAction,
AlertDialogCancel,
+ AlertDialogConfirmationField,
AlertDialogContent,
AlertDialogDescription,
AlertDialogFooter,
@@ -38,13 +42,19 @@ import {
import { OrgPermissionSubjects, useOrgPermission } from "@app/context";
import { OrgPermissionAdminConsoleAction } from "@app/context/OrgPermissionContext/types";
import { usePopUp } from "@app/hooks";
-import { useGetDeletedProjects, useRestoreProject } from "@app/hooks/api";
+import {
+ useGetDeletedProjects,
+ usePermanentlyDeleteProject,
+ useRestoreProject
+} from "@app/hooks/api";
import { ProjectType } from "@app/hooks/api/projects/types";
import {
formatRemainingDuration,
getActorLabel
} from "@app/pages/secret-manager/SettingsPage/components/EnvironmentSection/EnvironmentTable";
+const CONFIRM_KEYWORD = "confirm";
+
export const DeletedProjectsTable = ({ projectType }: { projectType: ProjectType }) => {
const { permission } = useOrgPermission();
const canAccessAllProjects = permission.can(
@@ -60,15 +70,22 @@ export const DeletedProjectsTable = ({ projectType }: { projectType: ProjectType
enabled: canAccessAllProjects
});
const restoreProject = useRestoreProject();
+ const permanentlyDeleteProject = usePermanentlyDeleteProject();
+ const isMutationPending = restoreProject.isPending || permanentlyDeleteProject.isPending;
const { popUp, handlePopUpOpen, handlePopUpClose, handlePopUpToggle } = usePopUp([
- "restoreProject"
+ "restoreProject",
+ "permanentlyDeleteProject"
] as const);
const restoreProjectData = popUp?.restoreProject?.data as
| { id: string; name: string }
| undefined;
+ const permanentlyDeleteProjectData = popUp?.permanentlyDeleteProject?.data as
+ | { id: string; name: string }
+ | undefined;
+
const onProjectRestoreSubmit = async () => {
if (!restoreProjectData?.id || restoreProject.isPending) return;
@@ -82,6 +99,19 @@ export const DeletedProjectsTable = ({ projectType }: { projectType: ProjectType
handlePopUpClose("restoreProject");
};
+ const onProjectPermanentlyDeleteSubmit = async () => {
+ if (!permanentlyDeleteProjectData?.id || permanentlyDeleteProject.isPending) return;
+
+ await permanentlyDeleteProject.mutateAsync({ projectId: permanentlyDeleteProjectData.id });
+
+ createNotification({
+ text: "Successfully deleted project",
+ type: "success"
+ });
+
+ handlePopUpClose("permanentlyDeleteProject");
+ };
+
if (!canAccessAllProjects || (!isError && !deletedProjects.length)) return null;
return (
@@ -146,11 +176,11 @@ export const DeletedProjectsTable = ({ projectType }: { projectType: ProjectType
</TooltipContent>
</Tooltip>
<DropdownMenu>
- <DropdownMenuTrigger asChild disabled={restoreProject.isPending}>
+ <DropdownMenuTrigger asChild disabled={isMutationPending}>
<IconButton
aria-label="Project options"
variant="ghost-muted"
- isDisabled={restoreProject.isPending}
+ isDisabled={isMutationPending}
>
<Ellipsis />
</IconButton>
@@ -162,6 +192,15 @@ export const DeletedProjectsTable = ({ projectType }: { projectType: ProjectType
<RotateCcwIcon />
Restore Project
</DropdownMenuItem>
+ <DropdownMenuItem
+ variant="danger"
+ onClick={() =>
+ handlePopUpOpen("permanentlyDeleteProject", { id, name })
+ }
+ >
+ <Trash2Icon />
+ Delete Now
+ </DropdownMenuItem>
</DropdownMenuContent>
</DropdownMenu>
</div>
@@ -201,6 +240,45 @@ export const DeletedProjectsTable = ({ projectType }: { projectType: ProjectType
</AlertDialogFooter>
</AlertDialogContent>
</AlertDialog>
+ <AlertDialog
+ isPending={permanentlyDeleteProject.isPending}
+ open={popUp.permanentlyDeleteProject.isOpen}
+ confirmationValue={CONFIRM_KEYWORD}
+ onOpenChange={(isOpen) => handlePopUpToggle("permanentlyDeleteProject", isOpen)}
+ >
+ <AlertDialogContent>
+ <AlertDialogHeader>
+ <AlertDialogTitle>
+ Permanently Delete {permanentlyDeleteProjectData?.name ?? "project"}?
+ </AlertDialogTitle>
+ <AlertDialogDescription asChild>
+ <Alert variant="danger" appearance="borderless">
+ <AlertDescription>
+ Skip the rest of the grace period and permanently delete{" "}
+ {permanentlyDeleteProjectData?.name} and all of its data. This action is not
+ reversible.
+ </AlertDescription>
+ </Alert>
+ </AlertDialogDescription>
+ </AlertDialogHeader>
+ <AlertDialogConfirmationField
+ inputProps={{ placeholder: `Type ${CONFIRM_KEYWORD} here` }}
+ onConfirm={() => onProjectPermanentlyDeleteSubmit().catch(() => undefined)}
+ />
+ <AlertDialogFooter>
+ <AlertDialogCancel>Cancel</AlertDialogCancel>
+ <AlertDialogAction
+ variant="danger"
+ onClick={(event) => {
+ event.preventDefault();
+ onProjectPermanentlyDeleteSubmit().catch(() => undefined);
+ }}
+ >
+ Delete Now
+ </AlertDialogAction>
+ </AlertDialogFooter>
+ </AlertDialogContent>
+ </AlertDialog>
</Card>
);
};