Skip to content

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

add grace period and restore for deleted secret manager projects

DimitrisStaratziscaae8a5aca8c
diff --git a/backend-go/internal/services/permission/permission.go b/backend-go/internal/services/permission/permission.go
index feae3c26bd..6a463334b2 100644
--- a/backend-go/internal/services/permission/permission.go
+++ b/backend-go/internal/services/permission/permission.go
@@ -733,7 +733,7 @@ func (s *Service) findProjectByID(ctx context.Context, projectID string) (*proje
query := `
SELECT id, name, slug, "orgId", type, "enforceEncryptedSecretManagerSecretMetadata"
FROM projects
- WHERE id = @projectID
+ WHERE id = @projectID AND "deleteAfter" IS NULL
`
args := pgx.NamedArgs{"projectID": projectID}
diff --git a/backend/src/ee/services/audit-log/audit-log-types.ts b/backend/src/ee/services/audit-log/audit-log-types.ts
index efe59a39fa..b452ed4544 100644
--- a/backend/src/ee/services/audit-log/audit-log-types.ts
+++ b/backend/src/ee/services/audit-log/audit-log-types.ts
@@ -727,6 +727,7 @@ export enum EventType {
CREATE_PROJECT = "create-project",
UPDATE_PROJECT = "update-project",
DELETE_PROJECT = "delete-project",
+ RESTORE_PROJECT = "restore-project",
CREATE_PROJECT_ROLE = "create-project-role",
UPDATE_PROJECT_ROLE = "update-project-role",
@@ -5944,6 +5945,16 @@ interface ProjectDeleteEvent {
// true: actor soft-deleted the project (marked for deletion).
// false: the async cleanup worker hard-deleted an expired soft-deleted project.
softDelete?: boolean;
+ hardDelete?: boolean;
+ };
+}
+
+interface ProjectRestoreEvent {
+ type: EventType.RESTORE_PROJECT;
+ metadata: {
+ id: string;
+ name: string;
+ slug: string;
};
}
@@ -8660,6 +8671,7 @@ export type Event =
| ProjectCreateEvent
| ProjectUpdateEvent
| ProjectDeleteEvent
+ | ProjectRestoreEvent
| SecretReminderCreateEvent
| SecretReminderGetEvent
| SecretReminderDeleteEvent
diff --git a/backend/src/lib/api-docs/constants.ts b/backend/src/lib/api-docs/constants.ts
index ed68a5cbbb..6def5c03fd 100644
--- a/backend/src/lib/api-docs/constants.ts
+++ b/backend/src/lib/api-docs/constants.ts
@@ -1063,7 +1063,15 @@ export const PROJECTS = {
template: "The name of the project template, if specified, to apply to this project."
},
DELETE: {
- projectId: "The ID of the project to delete."
+ projectId: "The ID of the project to delete.",
+ hardDelete:
+ "When true, the project is permanently deleted shortly after the request. When false or omitted, a secret manager project is soft-deleted (preserved and scheduled for permanent deletion after a grace period) and hidden from subsequent reads."
+ },
+ LIST_DELETED: {
+ type: "The type of soft-deleted projects to list."
+ },
+ RESTORE: {
+ projectId: "The ID of the soft-deleted project to restore."
},
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 b1cd61e148..7376b6569c 100644
--- a/backend/src/server/routes/v1/project-router.ts
+++ b/backend/src/server/routes/v1/project-router.ts
@@ -49,6 +49,24 @@ import {
import { sanitizedServiceTokenSchema } from "../v2/service-token-router";
import { ProjectAccessRequestCommentSchema } from "./project-access-request-schema";
+const deletedBySchema = z
+ .discriminatedUnion("type", [
+ z.object({
+ type: z.literal("user"),
+ id: z.string(),
+ email: z.string().nullable(),
+ username: z.string().nullable(),
+ firstName: z.string().nullable(),
+ lastName: z.string().nullable()
+ }),
+ z.object({
+ type: z.literal("identity"),
+ id: z.string(),
+ name: z.string()
+ })
+ ])
+ .nullable();
+
const projectWithEnv = SanitizedProjectSchema.merge(
z.object({
_id: z.string(),
@@ -60,23 +78,7 @@ const projectWithEnv = SanitizedProjectSchema.merge(
slug: z.string(),
deleteAfter: z.date(),
softDeletedAt: z.date(),
- deletedBy: z
- .discriminatedUnion("type", [
- z.object({
- type: z.literal("user"),
- id: z.string(),
- email: z.string().nullable(),
- username: z.string().nullable(),
- firstName: z.string().nullable(),
- lastName: z.string().nullable()
- }),
- z.object({
- type: z.literal("identity"),
- id: z.string(),
- name: z.string()
- })
- ])
- .nullable()
+ deletedBy: deletedBySchema
})
.array()
})
@@ -453,6 +455,13 @@ export const registerProjectRouter = async (server: FastifyZodProvider) => {
params: z.object({
projectId: z.string().trim().describe(PROJECTS.DELETE.projectId)
}),
+ querystring: z.object({
+ hardDelete: z
+ .enum(["true", "false"])
+ .default("false")
+ .transform((value) => value === "true")
+ .describe(PROJECTS.DELETE.hardDelete)
+ }),
response: {
200: z.object({
project: SanitizedProjectSchema.optional()
@@ -471,7 +480,8 @@ export const registerProjectRouter = async (server: FastifyZodProvider) => {
filter: {
type: ProjectFilterType.ID,
projectId: req.params.projectId
- }
+ },
+ hardDelete: req.query.hardDelete
});
await server.services.auditLog.createAuditLog({
@@ -483,7 +493,108 @@ export const registerProjectRouter = async (server: FastifyZodProvider) => {
metadata: {
id: project.id,
name: project.name,
- softDelete: true
+ softDelete: true,
+ hardDelete: req.query.hardDelete
+ }
+ }
+ });
+
+ return { project };
+ }
+ });
+
+ server.route({
+ method: "GET",
+ url: "/deleted",
+ config: {
+ rateLimit: readLimit
+ },
+ schema: {
+ hide: false,
+ operationId: "listDeletedProjects",
+ tags: [ApiDocsTags.Projects],
+ description: "List soft-deleted projects that can still be restored",
+ security: [
+ {
+ bearerAuth: []
+ }
+ ],
+ querystring: z.object({
+ type: z.nativeEnum(ProjectType).optional().describe(PROJECTS.LIST_DELETED.type)
+ }),
+ response: {
+ 200: z.object({
+ projects: z
+ .object({
+ id: z.string(),
+ name: z.string(),
+ type: z.string(),
+ deleteAfter: z.date(),
+ softDeletedAt: z.date(),
+ deletedBy: deletedBySchema
+ })
+ .array()
+ })
+ }
+ },
+ onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]),
+ handler: async (req) => {
+ const projects = await server.services.project.listDeletedProjects({
+ actorId: req.permission.id,
+ actor: req.permission.type,
+ actorOrgId: req.permission.orgId,
+ actorAuthMethod: req.permission.authMethod,
+ type: req.query.type
+ });
+ return { projects };
+ }
+ });
+
+ server.route({
+ method: "POST",
+ url: "/:projectId/restore",
+ config: {
+ rateLimit: writeLimit
+ },
+ schema: {
+ hide: false,
+ operationId: "restoreProject",
+ tags: [ApiDocsTags.Projects],
+ description: "Restore a soft-deleted project",
+ security: [
+ {
+ bearerAuth: []
+ }
+ ],
+ params: z.object({
+ projectId: z.string().trim().describe(PROJECTS.RESTORE.projectId)
+ }),
+ response: {
+ 200: z.object({
+ project: SanitizedProjectSchema
+ })
+ }
+ },
+ onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]),
+ handler: async (req) => {
+ const project = await server.services.project.restoreProject({
+ 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.RESTORE_PROJECT,
+ metadata: {
+ id: project.id,
+ name: project.name,
+ slug: project.slug
}
}
});
diff --git a/backend/src/services/project/project-dal.ts b/backend/src/services/project/project-dal.ts
index 35e2fc8437..e0e62f8ccc 100644
--- a/backend/src/services/project/project-dal.ts
+++ b/backend/src/services/project/project-dal.ts
@@ -131,6 +131,26 @@ export const projectDALFactory = (db: TDbClient) => {
}
};
+ const restoreById = async (id: string, slug: string, tx?: Knex) => {
+ try {
+ const [doc] = await (tx || db)(TableName.Project)
+ .where({ id })
+ .whereNotNull("deleteAfter")
+ .andWhere("deleteAfter", ">", new Date())
+ .update({
+ deleteAfter: null,
+ softDeletedAt: null,
+ deletedByActorType: null,
+ deletedByActorId: null,
+ slug
+ })
+ .returning("*");
+ return doc as TProjects | undefined;
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Restore project" });
+ }
+ };
+
const findExpiredForHardDelete = async (limit: number, tx?: Knex) => {
try {
const rows = await (tx || db.replicaNode())(TableName.Project)
@@ -1018,6 +1038,92 @@ export const projectDALFactory = (db: TDbClient) => {
}
};
+ const findDeletedProjects = async (orgId: string, type?: ProjectType, tx?: Knex) => {
+ try {
+ type DeletedProjectRow = {
+ id: string;
+ name: string;
+ type: string;
+ deleteAfter: Date;
+ softDeletedAt: Date;
+ deletedByActorType: string | null;
+ deletedByActorId: string | null;
+ deletedByUserEmail: string | null;
+ deletedByUserUsername: string | null;
+ deletedByUserFirstName: string | null;
+ deletedByUserLastName: string | null;
+ deletedByIdentityName: string | null;
+ };
+
+ const query = (tx || db.replicaNode())(TableName.Project)
+ .leftJoin(TableName.Users, `${TableName.Project}.deletedByActorId`, `${TableName.Users}.id`)
+ .leftJoin(TableName.Identity, `${TableName.Project}.deletedByActorId`, `${TableName.Identity}.id`)
+ .where(`${TableName.Project}.orgId`, orgId)
+ .whereNotNull(`${TableName.Project}.deleteAfter`)
+ .whereNotNull(`${TableName.Project}.softDeletedAt`)
+ .select(
+ `${TableName.Project}.id`,
+ `${TableName.Project}.name`,
+ `${TableName.Project}.type`,
+ `${TableName.Project}.deleteAfter`,
+ `${TableName.Project}.softDeletedAt`,
+ `${TableName.Project}.deletedByActorType`,
+ `${TableName.Project}.deletedByActorId`,
+ db.ref("email").withSchema(TableName.Users).as("deletedByUserEmail"),
+ db.ref("username").withSchema(TableName.Users).as("deletedByUserUsername"),
+ db.ref("firstName").withSchema(TableName.Users).as("deletedByUserFirstName"),
+ db.ref("lastName").withSchema(TableName.Users).as("deletedByUserLastName"),
+ db.ref("name").withSchema(TableName.Identity).as("deletedByIdentityName")
+ )
+ .orderBy(`${TableName.Project}.deleteAfter`, "asc");
+ if (type) void query.where(`${TableName.Project}.type`, type);
+
+ const rows = (await query) as DeletedProjectRow[];
+
+ return rows.map((row) => {
+ let deletedBy:
+ | {
+ type: "user";
+ id: string;
+ email: string | null;
+ username: string | null;
+ firstName: string | null;
+ lastName: string | null;
+ }
+ | { type: "identity"; id: string; name: string }
+ | null = null;
+
+ if (row.deletedByActorId && row.deletedByActorType === ActorType.USER) {
+ deletedBy = {
+ type: "user",
+ id: row.deletedByActorId,
+ email: row.deletedByUserEmail,
+ username: row.deletedByUserUsername,
+ firstName: row.deletedByUserFirstName,
+ lastName: row.deletedByUserLastName
+ };
+ } else if (row.deletedByActorId && row.deletedByActorType === ActorType.IDENTITY) {
+ deletedBy = {
+ type: "identity",
+ id: row.deletedByActorId,
+ name: row.deletedByIdentityName ?? ""
+ };
+ }
+
+ return {
+ id: row.id,
+ name: row.name,
+ type: row.type,
+ deleteAfter: row.deleteAfter,
+ softDeletedAt: row.softDeletedAt,
+ deletedBy
+ };
+ });
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find deleted projects" });
+ }
+ };
+
const countOfBillableOrgProjects = async (orgId: string | null, tx?: Knex) => {
try {
const subOrgProjects = db.replicaNode()(TableName.Organization).where({ rootOrgId: orgId }).select("id");
@@ -1054,6 +1160,7 @@ export const projectDALFactory = (db: TDbClient) => {
findByIdIncludingExpired,
findIncludingExpired,
softDeleteById,
+ restoreById,
findExpiredForHardDelete,
hardDeleteProjectSecretVersionsInBatches,
hardDeleteProjectSecretReferencesInBatches,
@@ -1079,6 +1186,7 @@ export const projectDALFactory = (db: TDbClient) => {
searchProjects,
findProjectByEnvId,
findProjectDeletedEnvironments,
+ findDeletedProjects,
countOfBillableOrgProjects
};
};
diff --git a/backend/src/services/project/project-service.ts b/backend/src/services/project/project-service.ts
index bccf3e83b6..71e2617448 100644
--- a/backend/src/services/project/project-service.ts
+++ b/backend/src/services/project/project-service.ts
@@ -20,6 +20,7 @@ import { isWithinPlanAuditLogRetention } from "@app/ee/services/audit-log/audit-
import { TLicenseServiceFactory } from "@app/ee/services/license/license-service";
import {
OrgPermissionActions,
+ OrgPermissionAdminConsoleAction,
OrgPermissionMemberActions,
OrgPermissionProjectActions,
OrgPermissionSubjects
@@ -84,6 +85,7 @@ import { TOrgDALFactory } from "../org/org-dal";
import { TPkiAlertDALFactory } from "../pki-alert/pki-alert-dal";
import { TPkiCollectionDALFactory } from "../pki-collection/pki-collection-dal";
import { TProjectEnvDALFactory } from "../project-env/project-env-dal";
+import { SOFT_DELETE_GRACE_MS } from "../project-env/project-env-queue";
import { TProjectMembershipDALFactory } from "../project-membership/project-membership-dal";
import { getPredefinedRoles } from "../project-role/project-role-fns";
import { TRoleDALFactory } from "../role/role-dal";
@@ -109,6 +111,7 @@ import {
TGetProjectDTO,
TGetProjectKmsKey,
TGetProjectWorkflowIntegrationConfig,
+ TListDeletedProjectsDTO,
TListProjectAlertsDTO,
TListProjectCasDTO,
TListProjectCertificateTemplatesDTO,
@@ -117,6 +120,7 @@ import {
TListProjectsDTO,
TLoadProjectKmsBackupDTO,
TProjectAccessRequestDTO,
+ TRestoreProjectDTO,
TSearchProjectsDTO,
TToggleProjectAutoCapitalizationDTO,
TToggleProjectDeleteProtectionDTO,
@@ -790,7 +794,14 @@ export const projectServiceFactory = ({
return results;
};
- const deleteProject = async ({ actor, actorId, actorOrgId, actorAuthMethod, filter }: TDeleteProjectDTO) => {
+ const deleteProject = async ({
+ actor,
+ actorId,
+ actorOrgId,
+ actorAuthMethod,
+ filter,
+ hardDelete = false
+ }: TDeleteProjectDTO) => {
const project = await projectDAL.findProjectByFilter(filter);
const { permission } = await permissionService.getProjectPermission({
@@ -854,13 +865,14 @@ export const projectServiceFactory = ({
}
try {
- // "Real delete" from the caller's perspective: this returns immediately (one UPDATE) and the
- // project disappears from every read, but the expensive cascade runs asynchronously in the
- // hard-delete worker. deleteAfter = now marks it immediately eligible for the next worker tick
- // (no grace period). The slug is freed so a same-named project can be recreated right away.
+ // This returns immediately (one UPDATE) and the project disappears from every read, but the
+ // expensive cascade runs asynchronously in the hard-delete worker once deleteAfter passes. Only
+ // secret manager projects get a restore grace period; the rest (and hard deletes) are eligible on
+ // the next worker tick. The slug is freed so a same-named project can be recreated right away.
const now = new Date();
+ const hasGracePeriod = !hardDelete && project.type === ProjectType.SecretManager;
const softDeletedProject = await projectDAL.softDeleteById(project.id, {
- deleteAfter: now,
+ deleteAfter: hasGracePeriod ? new Date(now.getTime() + SOFT_DELETE_GRACE_MS) : now,
softDeletedAt: now,
deletedByActorType: actor,
deletedByActorId: actorId,
@@ -884,6 +896,103 @@ export const projectServiceFactory = ({
}
};
+ const listDeletedProjects = async ({
+ actor,
+ actorId,
+ actorOrgId,
+ actorAuthMethod,
+ type
+ }: TListDeletedProjectsDTO) => {
+ const { permission } = await permissionService.getOrgPermission({
+ scope: OrganizationActionScope.Any,
+ actor,
+ actorId,
+ orgId: actorOrgId,
+ actorAuthMethod,
+ actorOrgId
+ });
+ ForbiddenError.from(permission).throwUnlessCan(
+ OrgPermissionAdminConsoleAction.AccessAllProjects,
+ OrgPermissionSubjects.AdminConsole
+ );
+
+ return projectDAL.findDeletedProjects(actorOrgId, type);
+ };
+
+ const restoreProject = async ({ actor, actorId, actorOrgId, actorAuthMethod, projectId }: TRestoreProjectDTO) => {
+ 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` });
+ }
+
+ if (new Date(project.deleteAfter).getTime() <= Date.now()) {
+ throw new BadRequestError({
+ message: "Cannot restore project: its deletion grace period has already elapsed."
+ });
+ }
+
+ // The hard-delete worker holds this lock while it purges, so a restore can't land mid-purge.
+ 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: "Cannot restore project: it is being permanently deleted."
+ });
+ }
+
+ try {
+ // Read before the transaction: a plan cache miss queries on its own connection.
+ const plan = await licenseService.getPlan(project.orgId);
+
+ const restoredProject = await projectDAL.transaction(async (tx) => {
+ await tx.raw("SELECT pg_advisory_xact_lock(?)", [PgSqlLock.CreateProject(project.orgId)]);
+
+ if (plan.workspaceLimit !== null && project.type === ProjectType.SecretManager) {
+ const currentProjectCount = await projectDAL.countOfBillableOrgProjects(project.orgId, tx);
+ if (currentProjectCount >= plan.workspaceLimit) {
+ throw new BadRequestError({
+ message:
+ "Failed to restore project due to project limit reached. Upgrade plan or remove an existing project."
+ });
+ }
+ }
+
+ // The original slug was freed on delete and may have been reused since.
+ return projectDAL.restoreById(project.id, slugify(`${project.name}-${alphaNumericNanoId(4)}`), tx);
+ });
+
+ if (!restoredProject) {
+ throw new BadRequestError({
+ message: "Cannot restore project: its deletion grace period has already elapsed."
+ });
+ }
+
+ await keyStore.deleteItem(KeyStorePrefixes.LicenseCloudPlan(project.orgId));
+ usageMeteringService.emit(project.orgId, SecretIdentities.key);
+ usageMeteringService.emit(project.orgId, PamIdentities.key);
+ usageMeteringService.emit(project.orgId, AgentVaultIdentities.key);
+ return restoredProject;
+ } finally {
+ await lock.release();
+ }
+ };
+
const getProjects = async ({ actorId, actor, includeRoles, actorAuthMethod, actorOrgId, type }: TListProjectsDTO) => {
const workspaces = (
actor === ActorType.IDENTITY
@@ -2372,6 +2481,8 @@ export const projectServiceFactory = ({
return {
createProject,
deleteProject,
+ listDeletedProjects,
+ restoreProject,
getProjects,
getAccessibleProjectsWithSubOrgs,
updateProject,
diff --git a/backend/src/services/project/project-types.ts b/backend/src/services/project/project-types.ts
index 7aed061308..52f85a1277 100644
--- a/backend/src/services/project/project-types.ts
+++ b/backend/src/services/project/project-types.ts
@@ -108,6 +108,13 @@ export type TDeleteProjectDTO = {
actor: ActorType;
actorId: string;
actorOrgId: string | undefined;
+ hardDelete?: boolean;
+} & Omit<TProjectPermission, "projectId">;
+
+export type TRestoreProjectDTO = TProjectPermission;
+
+export type TListDeletedProjectsDTO = {
+ type?: ProjectType;
} & Omit<TProjectPermission, "projectId">;
export type TListProjectsDTO = {
diff --git a/frontend/src/hooks/api/projects/index.tsx b/frontend/src/hooks/api/projects/index.tsx
index 23673ec38f..9b9b7fe3db 100644
--- a/frontend/src/hooks/api/projects/index.tsx
+++ b/frontend/src/hooks/api/projects/index.tsx
@@ -14,6 +14,7 @@ export {
useDeleteWorkspace,
useDeleteWsEnvironment,
useGetAvailableProjectUsers,
+ useGetDeletedProjects,
useGetMembershipPermissionAudit,
useGetMyPendingProjectAccessRequests,
useGetUpgradeProjectStatus,
@@ -34,6 +35,7 @@ export {
useListWorkspacePkiCollections,
useListWorkspacePkiSubscribers,
useRestoreEnvironment,
+ useRestoreProject,
useSearchProjects,
useUpdateProject,
useUpdateUserWorkspaceRole,
diff --git a/frontend/src/hooks/api/projects/queries.tsx b/frontend/src/hooks/api/projects/queries.tsx
index 448b54d702..f89aaede72 100644
--- a/frontend/src/hooks/api/projects/queries.tsx
+++ b/frontend/src/hooks/api/projects/queries.tsx
@@ -27,12 +27,14 @@ import { projectKeys } from "./query-keys";
import {
CreateEnvironmentDTO,
CreateWorkspaceDTO,
+ DeletedProject,
DeleteEnvironmentDTO,
DeleteWorkspaceDTO,
Project,
ProjectEnv,
ProjectType,
RestoreEnvironmentDTO,
+ RestoreProjectDTO,
TGetIdentityPermissionAuditResponse,
TGetMembershipPermissionAuditResponse,
TGetUpgradeProjectStatusDTO,
@@ -306,8 +308,40 @@ export const useDeleteWorkspace = () => {
const queryClient = useQueryClient();
return useMutation<Project, object, DeleteWorkspaceDTO>({
- mutationFn: async ({ projectID }) => {
- const { data } = await apiRequest.delete(`/api/v1/projects/${projectID}`);
+ mutationFn: async ({ projectID, hardDelete }) => {
+ const { data } = await apiRequest.delete(`/api/v1/projects/${projectID}`, {
+ params: hardDelete ? { hardDelete: true } : undefined
+ });
+ return data.project;
+ },
+ onSuccess: () => {
+ queryClient.invalidateQueries({ queryKey: projectKeys.getAllUserProjects() });
+ queryClient.invalidateQueries({
+ queryKey: ["org-admin-projects"]
+ });
+ }
+ });
+};
+
+export const useGetDeletedProjects = (type?: ProjectType, options?: { enabled?: boolean }) =>
+ useQuery({
+ queryKey: projectKeys.getDeletedProjects(type),
+ queryFn: async () => {
+ const { data } = await apiRequest.get<{ projects: DeletedProject[] }>(
+ "/api/v1/projects/deleted",
+ { params: { type } }
+ );
+ return data.projects;
+ },
+ ...options
+ });
+
+export const useRestoreProject = () => {
+ const queryClient = useQueryClient();
+
+ return useMutation<Project, object, RestoreProjectDTO>({
+ mutationFn: async ({ projectId }) => {
+ const { data } = await apiRequest.post(`/api/v1/projects/${projectId}/restore`);
return data.project;
},
onSuccess: () => {
diff --git a/frontend/src/hooks/api/projects/query-keys.tsx b/frontend/src/hooks/api/projects/query-keys.tsx
index 5af59c4583..47efce2147 100644
--- a/frontend/src/hooks/api/projects/query-keys.tsx
+++ b/frontend/src/hooks/api/projects/query-keys.tsx
@@ -1,6 +1,6 @@
import type { CaStatus } from "../ca";
import { WorkflowIntegrationPlatform } from "../workflowIntegrations/types";
-import { TListProjectIdentitiesDTO, TSearchProjectsDTO } from "./types";
+import { ProjectType, TListProjectIdentitiesDTO, TSearchProjectsDTO } from "./types";
export const projectKeys = {
allProjectQueries: () => ["projects"] as const,
@@ -17,6 +17,8 @@ export const projectKeys = {
[...projectKeys.getAllUserProjects(), "with-sub-orgs", { orgId }] as const,
getMyPendingProjectAccessRequests: () =>
[...projectKeys.allProjectQueries(), "my-pending-access-requests"] as const,
+ getDeletedProjects: (type?: ProjectType) =>
+ [...projectKeys.allProjectQueries(), "deleted", { type }] as const,
getProjectAuditLogs: (projectId: string) => [{ projectId }, "project-audit-logs"] as const,
getProjectUsers: (
projectId: string,
diff --git a/frontend/src/hooks/api/projects/types.ts b/frontend/src/hooks/api/projects/types.ts
index 7a06693138..ad260d79a3 100644
--- a/frontend/src/hooks/api/projects/types.ts
+++ b/frontend/src/hooks/api/projects/types.ts
@@ -118,7 +118,18 @@ export type UpdateAuditLogsRetentionDTO = { projectId: string; auditLogsRetentio
export type ToggleAutoCapitalizationDTO = { projectID: string; state: boolean };
export type ToggleDeleteProjectProtectionDTO = { projectID: string; state: boolean };
-export type DeleteWorkspaceDTO = { projectID: string };
+export type DeleteWorkspaceDTO = { projectID: string; hardDelete?: boolean };
+
+export type RestoreProjectDTO = { projectId: string };
+
+export type DeletedProject = {
+ id: string;
+ name: string;
+ type: ProjectType;
+ deleteAfter: string;
+ softDeletedAt: string;
+ deletedBy: ProjectDeletedEnvActor | null;
+};
export type CreateEnvironmentDTO = {
projectId: string;
diff --git a/frontend/src/pages/organization/ProjectsPage/ProjectTypePage/ProjectTypePage.tsx b/frontend/src/pages/organization/ProjectsPage/ProjectTypePage/ProjectTypePage.tsx
index 3cd02bcc48..90bfc8f1a4 100644
--- a/frontend/src/pages/organization/ProjectsPage/ProjectTypePage/ProjectTypePage.tsx
+++ b/frontend/src/pages/organization/ProjectsPage/ProjectTypePage/ProjectTypePage.tsx
@@ -112,6 +112,7 @@ import {
import { useGetSecretScanningProjectId } from "@app/hooks/api/secretScanningV2";
import { useUpdateUserProjectFavorites } from "@app/hooks/api/users/mutation";
import { useGetUserProjectFavorites } from "@app/hooks/api/users/queries";
+import { DeletedProjectsTable } from "@app/pages/organization/ProjectsPage/components/DeletedProjectsTable";
import {
ProjectListToggle,
ProjectListView
@@ -411,6 +412,9 @@ const ProjectTypeContent = ({
hideProjectListToggle={!canRequestAccess}
/>
)}
+ {projectType === ProjectType.SecretManager && (
+ <DeletedProjectsTable projectType={projectType} />
+ )}
<NewProjectModal
isOpen={popUp.addNewWs.isOpen}
onOpenChange={(isOpen) => handlePopUpToggle("addNewWs", isOpen)}
diff --git a/frontend/src/pages/organization/ProjectsPage/components/DeletedProjectsTable.tsx b/frontend/src/pages/organization/ProjectsPage/components/DeletedProjectsTable.tsx
new file mode 100644
index 0000000000..f22f9bba53
--- /dev/null
+++ b/frontend/src/pages/organization/ProjectsPage/components/DeletedProjectsTable.tsx
@@ -0,0 +1,181 @@
+import { format } from "date-fns";
+import { Ellipsis, HourglassIcon, RotateCcwIcon } from "lucide-react";
+
+import { createNotification } from "@app/components/notifications";
+import {
+ AlertDialog,
+ AlertDialogCancel,
+ AlertDialogContent,
+ AlertDialogDescription,
+ AlertDialogFooter,
+ AlertDialogHeader,
+ AlertDialogTitle,
+ Badge,
+ Button,
+ Card,
+ CardContent,
+ CardDescription,
+ CardHeader,
+ CardTitle,
+ DropdownMenu,
+ DropdownMenuContent,
+ DropdownMenuItem,
+ DropdownMenuTrigger,
+ IconButton,
+ Table,
+ TableBody,
+ TableCell,
+ TableRow,
+ Tooltip,
+ TooltipContent,
+ TooltipTrigger
+} from "@app/components/v3";
+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 { ProjectType } from "@app/hooks/api/projects/types";
+import {
+ formatRemainingDuration,
+ getActorLabel
+} from "@app/pages/secret-manager/SettingsPage/components/EnvironmentSection/EnvironmentTable";
+
+export const DeletedProjectsTable = ({ projectType }: { projectType: ProjectType }) => {
+ const { permission } = useOrgPermission();
+ const canAccessAllProjects = permission.can(
+ OrgPermissionAdminConsoleAction.AccessAllProjects,
+ OrgPermissionSubjects.AdminConsole
+ );
+
+ const { data: deletedProjects = [] } = useGetDeletedProjects(projectType, {
+ enabled: canAccessAllProjects
+ });
+ const restoreProject = useRestoreProject();
+
+ const { popUp, handlePopUpOpen, handlePopUpClose, handlePopUpToggle } = usePopUp([
+ "restoreProject"
+ ] as const);
+
+ const restoreProjectData = popUp?.restoreProject?.data as
+ | { id: string; name: string }
+ | undefined;
+
+ const onProjectRestoreSubmit = async () => {
+ if (!restoreProjectData?.id || restoreProject.isPending) return;
+
+ await restoreProject.mutateAsync({ projectId: restoreProjectData.id });
+
+ createNotification({
+ text: "Successfully restored project",
+ type: "success"
+ });
+
+ handlePopUpClose("restoreProject");
+ };
+
+ if (!canAccessAllProjects || !deletedProjects.length) return null;
+
+ return (
+ <Card className="mt-6">
+ <CardHeader>
+ <CardTitle>Recently Deleted</CardTitle>
+ <CardDescription>
+ Deleted projects can be restored until they are permanently deleted.
+ </CardDescription>
+ </CardHeader>
+ <CardContent>
+ <Table>
+ <TableBody>
+ {deletedProjects.map(({ id, name, deleteAfter, softDeletedAt, deletedBy }) => {
+ const deleteAfterDate = new Date(deleteAfter);
+ const remaining = formatRemainingDuration(deleteAfterDate);
+
+ return (
+ <TableRow key={id} className="bg-warning/[0.025]">
+ <TableCell className="text-warning/80 line-through">{name}</TableCell>
+ <TableCell>
+ <div className="flex items-center justify-end gap-2">
+ <Tooltip>
+ <TooltipTrigger asChild>
+ <Badge variant="warning">
+ <HourglassIcon />
+ Pending deletion
+ </Badge>
+ </TooltipTrigger>
+ <TooltipContent className="max-w-xs">
+ <div className="flex flex-col gap-1">
+ <span className="text-sm font-semibold text-foreground">
+ {remaining
+ ? `${remaining} until permanent deletion`
+ : "Will be permanently deleted soon"}
+ </span>
+ <span className="text-xs text-accent">
+ {remaining
+ ? `Scheduled for ${format(deleteAfterDate, "MMM d, yyyy, h:mm a")}`
+ : "Awaiting the next cleanup sweep"}
+ </span>
+ <span className="text-xs text-accent">
+ Soft-deleted by {getActorLabel(deletedBy)} ·{" "}
+ {format(new Date(softDeletedAt), "MMM d, yyyy")}
+ </span>
+ </div>
+ </TooltipContent>
+ </Tooltip>
+ <DropdownMenu>
+ <DropdownMenuTrigger asChild disabled={restoreProject.isPending}>
+ <IconButton
+ aria-label="Project options"
+ variant="ghost-muted"
+ isDisabled={restoreProject.isPending}
+ >
+ <Ellipsis />
+ </IconButton>
+ </DropdownMenuTrigger>
+ <DropdownMenuContent align="end">
+ <DropdownMenuItem
+ onClick={() => handlePopUpOpen("restoreProject", { id, name })}
+ >
+ <RotateCcwIcon />
+ Restore project
+ </DropdownMenuItem>
+ </DropdownMenuContent>
+ </DropdownMenu>
+ </div>
+ </TableCell>
+ </TableRow>
+ );
+ })}
+ </TableBody>
+ </Table>
+ </CardContent>
+ <AlertDialog
+ open={popUp.restoreProject.isOpen}
+ onOpenChange={(isOpen) => {
+ if (!isOpen && restoreProject.isPending) return;
+ handlePopUpToggle("restoreProject", isOpen);
+ }}
+ >
+ <AlertDialogContent>
+ <AlertDialogHeader>
+ <AlertDialogTitle>Restore {restoreProjectData?.name ?? "project"}?</AlertDialogTitle>
+ <AlertDialogDescription>
+ The project will become accessible again with its secrets, environments, and history
+ preserved. Its slug was released on deletion, so it gets a new one.
+ </AlertDialogDescription>
+ </AlertDialogHeader>
+ <AlertDialogFooter>
+ <AlertDialogCancel isDisabled={restoreProject.isPending}>Cancel</AlertDialogCancel>
+ <Button
+ variant="project"
+ size="sm"
+ onClick={() => onProjectRestoreSubmit().catch(() => undefined)}
+ isPending={restoreProject.isPending}
+ >
+ Restore Project
+ </Button>
+ </AlertDialogFooter>
+ </AlertDialogContent>
+ </AlertDialog>
+ </Card>
+ );
+};
diff --git a/frontend/src/pages/project/SettingsPage/components/DeleteProjectSection/DeleteProjectSection.tsx b/frontend/src/pages/project/SettingsPage/components/DeleteProjectSection/DeleteProjectSection.tsx
index 9ce5f06933..62e77c005a 100644
--- a/frontend/src/pages/project/SettingsPage/components/DeleteProjectSection/DeleteProjectSection.tsx
+++ b/frontend/src/pages/project/SettingsPage/components/DeleteProjectSection/DeleteProjectSection.tsx
@@ -1,4 +1,5 @@
import { useNavigate } from "@tanstack/react-router";
+import { addDays, format } from "date-fns";
import { Trash2Icon } from "lucide-react";
import { createNotification } from "@app/components/notifications";
@@ -36,6 +37,7 @@ import {
} from "@app/context";
import { useToggle } from "@app/hooks";
import { useDeleteWorkspace, useLeaveProject, useUpdateProject } from "@app/hooks/api";
+import { ProjectType } from "@app/hooks/api/projects/types";
import { usePopUp } from "@app/hooks/usePopUp";
const CONFIRM_KEYWORD = "confirm";
@@ -44,6 +46,7 @@ export const DeleteProjectSection = () => {
const navigate = useNavigate();
const { popUp, handlePopUpOpen, handlePopUpClose, handlePopUpToggle } = usePopUp([
+ "scheduleDeleteWorkspace",
"deleteWorkspace",
"leaveWorkspace"
] as const);
@@ -58,14 +61,16 @@ export const DeleteProjectSection = () => {
const leaveProject = useLeaveProject();
const { mutateAsync: updateProject, isPending: isUpdatingDeleteProtection } = useUpdateProject();
const hasDeleteProtection = currentProject?.hasDeleteProtection ?? false;
+ const isRestorable = currentProject?.type === ProjectType.SecretManager;
- const handleDeleteWorkspaceSubmit = async () => {
+ const handleDeleteWorkspaceSubmit = async (hardDelete: boolean) => {
setIsDeleting.on();
try {
if (!currentProject?.id) return;
await deleteWorkspace.mutateAsync({
- projectID: currentProject?.id
+ projectID: currentProject?.id,
+ hardDelete
});
createNotification({
@@ -77,6 +82,7 @@ export const DeleteProjectSection = () => {
to: "/organizations/$orgId/projects",
params: { orgId: currentOrg.id }
});
+ handlePopUpClose("scheduleDeleteWorkspace");
handlePopUpClose("deleteWorkspace");
} finally {
setIsDeleting.off();
@@ -138,7 +144,9 @@ export const DeleteProjectSection = () => {
isPending={isDeleting}
isDisabled={isDisabled}
variant="danger"
- onClick={() => handlePopUpOpen("deleteWorkspace")}
+ onClick={() =>
+ handlePopUpOpen(isRestorable ? "scheduleDeleteWorkspace" : "deleteWorkspace")
+ }
>
<Trash2Icon />
{`Delete ${currentProject?.name}`}
@@ -232,6 +240,57 @@ export const DeleteProjectSection = () => {
</CardFooter>
</Card>
+ <AlertDialog
+ isPending={isDeleting}
+ open={popUp.scheduleDeleteWorkspace.isOpen}
+ onOpenChange={(isOpen) => handlePopUpToggle("scheduleDeleteWorkspace", isOpen)}
+ >
+ <AlertDialogContent className="sm:max-w-xl!">
+ <AlertDialogHeader>
+ <AlertDialogTitle>Schedule deletion of {currentProject?.name}?</AlertDialogTitle>
+ <AlertDialogDescription>
+ {currentProject?.name} will be inaccessible immediately, then permanently deleted on{" "}
+ <span className="font-medium text-foreground">
+ {format(addDays(new Date(), 14), "MMM d, yyyy")}
+ </span>
+ .
+ </AlertDialogDescription>
+ </AlertDialogHeader>
+ <ul className="list-disc pl-4 text-sm text-label">
+ <li>
+ Organization admins can restore it within 14 days. Secrets, environments, and history
+ are preserved.
+ </li>
+ <li>After 14 days, all project data is wiped and cannot be recovered.</li>
+ </ul>
+ <AlertDialogFooter className="sm:justify-between">
+ <Button
+ variant="danger"
+ size="sm"
+ onClick={() => {
+ handlePopUpClose("scheduleDeleteWorkspace");
+ handlePopUpOpen("deleteWorkspace");
+ }}
+ isDisabled={isDeleting}
+ >
+ Delete Now
+ </Button>
+ <div className="flex gap-2">
+ <AlertDialogCancel>Cancel</AlertDialogCancel>
+ <AlertDialogAction
+ variant="project"
+ onClick={(event) => {
+ event.preventDefault();
+ handleDeleteWorkspaceSubmit(false);
+ }}
+ >
+ Confirm
+ </AlertDialogAction>
+ </div>
+ </AlertDialogFooter>
+ </AlertDialogContent>
+ </AlertDialog>
+
<AlertDialog
isPending={isDeleting}
open={popUp.deleteWorkspace.isOpen}
@@ -253,7 +312,7 @@ export const DeleteProjectSection = () => {
<AlertDialogConfirmationField
inputProps={{ placeholder: `Type ${CONFIRM_KEYWORD} here` }}
onConfirm={() => {
- handleDeleteWorkspaceSubmit();
+ handleDeleteWorkspaceSubmit(isRestorable);
}}
/>
<AlertDialogFooter>
@@ -262,7 +321,7 @@ export const DeleteProjectSection = () => {
variant="danger"
onClick={(event) => {
event.preventDefault();
- handleDeleteWorkspaceSubmit();
+ handleDeleteWorkspaceSubmit(isRestorable);
}}
>
Delete Project
diff --git a/frontend/src/pages/secret-manager/SettingsPage/components/EnvironmentSection/EnvironmentTable.tsx b/frontend/src/pages/secret-manager/SettingsPage/components/EnvironmentSection/EnvironmentTable.tsx
index 9faadedd10..7f7cf5b145 100644
--- a/frontend/src/pages/secret-manager/SettingsPage/components/EnvironmentSection/EnvironmentTable.tsx
+++ b/frontend/src/pages/secret-manager/SettingsPage/components/EnvironmentSection/EnvironmentTable.tsx
@@ -53,14 +53,14 @@ type Props = {
onMutationPendingChange: (isPending: boolean) => void;
};
-const getActorLabel = (actor: ProjectDeletedEnvActor | null): string => {
+export const getActorLabel = (actor: ProjectDeletedEnvActor | null): string => {
if (!actor) return "Someone";
if (actor.type === "identity") return actor.name || "An identity";
return actor.firstName || actor.username || actor.email || "A user";
};
-const formatRemainingDuration = (target: Date): string | null => {
+export const formatRemainingDuration = (target: Date): string | null => {
const now = new Date();
if (target.getTime() <= now.getTime()) return null;