Clean up Jira Cloud instance

This template helps you keep your Jira Cloud instance clean automatically so when a company-managed project is deleted, all the associated schemes, workflows and screens go with it as well if not tied to any other company-managed projects. Get started to learn more.

What is ScriptRunner Connect?

ScriptRunner Connect is an AI assisted code-first (JavaScript/TypeScript) integration platform (iPaaS) for building complex integrations and automations.

Can I try it out for free?

Yes. ScriptRunner Connect comes with a forever free tier.

Can I customize the integration logic?

Absolutely. The main value proposition of ScriptRunner Connect is that you'll get full access to the code that is powering the integration, which means you can make any changes to the the integration logic yourself.

Can I change the integration to communicate with additional apps?

Yes. Since ScriptRunner Connect specializes in enabling complex integrations, you can easily change the integration logic to connect to as many additional apps as you need, no limitations.

What if I don't feel comfortable making changes to the code?

First you can try out our AI assistant which can help you understand what the code does, and also help you make changes to the code. Alternatively you can hire our professionals to make the changes you need or build new integrations from scratch.

Do I have to host it myself?

No. ScriptRunner Connect is a fully managed SaaS (Software-as-a-Service) product.

What about security?

ScriptRunner Connect is ISO 27001 and SOC 2 certified. Learn more about our security.

📋 Overview

This workspace will help you keep your Jira Cloud instance clean automatically so that when a company-managed project is deleted, all the associated schemes, workflows and screens go with it as well if not tied to any other company-managed projects.

The cleanup process after a project gets deleted goes as follows:

• The Issue Type Screen Scheme with the given deleted project key gets deleted.
• The Issue Type Scheme with the given deleted project key gets deleted.
• The Screen Scheme with the given deleted project key gets deleted.
• The Workflow Scheme with the given deleted project key gets deleted.
• The workflows tied to the workflow scheme above are deleted.
• The screens tied to the Screen Scheme from step 3 and the screens tied to the workflows in step 5 are deleted.
• The Permission Scheme with the given deleted project key gets deleted.
• To retain any needed schemes regardless of inactivity, you can add the names of the schemes, workflows, or screens to the EXCLUSION_LIST parameter to exclude them from the deletion process.

🖊️ Setup

• Configure API connections and event listeners

Set up the API connection and event listener for Jira Cloud. You can either create new connectors or use existing ones.

• Adjust parameters

Go to the Parameters section and add various scheme, screen and workflow names to the EXCLUSION_LIST which you would like to keep.

🚀 Usage

• After setup is complete, whenever a project is deleted, all related oprhaned resources will be deleted.
• To run the cleanup process ad-hoc, run the BulkCleanUp script manually.

import { BadRequestError } from '@managed-api/commons-core';
import JiraCloud from './api/jira/cloud';
import { jsonToMap, Params } from './Utils';

export default async function (event: any, context: Context): Promise<void> {
    const params = context.environment.vars as Params;

    // Find and delete orphaned issue type screen schemes
    let issueTypeScreenSchemesResponse = await JiraCloud.All.getIssueTypeScreenSchemes({
        expand: 'projects'
    });
    let issueTypeScreenSchemes = issueTypeScreenSchemesResponse.values ?? [];

    let iterations = 1;
    if (issueTypeScreenSchemesResponse.nextPage) {
        iterations = Math.ceil(issueTypeScreenSchemesResponse.total ?? 0 / (issueTypeScreenSchemesResponse.maxResults ?? 0))
    }
    for (let i = 0; i < iterations; i++) {
        for (const issueTypeScreenScheme of issueTypeScreenSchemes) {
            if (issueTypeScreenScheme.id !== '1' && (issueTypeScreenScheme as any)?.['projects']?.total === 0 && !params.EXCLUSION_LIST.includes(issueTypeScreenScheme.name)) {
                await JiraCloud.All.deleteIssueTypeScreenScheme({
                    issueTypeScreenSchemeId: issueTypeScreenScheme.id
                });
                console.log(`${issueTypeScreenScheme.name} issue type screen scheme has been deleted.`);
            }
        }

        if (issueTypeScreenSchemesResponse.nextPage) {
            const startAt = (Math.trunc((issueTypeScreenSchemesResponse.startAt ?? 0 + (issueTypeScreenSchemesResponse.maxResults ?? 0)) / 10) * 10) + 1
            issueTypeScreenSchemesResponse = await JiraCloud.All.getIssueTypeScreenSchemes({
                expand: 'projects',
                startAt
            });
            issueTypeScreenSchemes = issueTypeScreenSchemesResponse.values ?? [];
        }
    }

    // Find and delete orphaned issue type schemes
    let issueTypeSchemesResponse = await JiraCloud.All.getIssueTypeSchemes({
        expand: 'projects'
    })
    let issueTypeSchemes = issueTypeSchemesResponse.values ?? [];

    iterations = 1
    if (issueTypeSchemesResponse.nextPage) {
        iterations = Math.ceil(issueTypeSchemesResponse.total ?? 0 / (issueTypeSchemesResponse.maxResults ?? 0))
    }
    for (let i = 0; i < iterations; i++) {
        for (const issueTypeScheme of issueTypeSchemes) {
            if (issueTypeScheme.id !== '10000' && (issueTypeScheme as any)?.['projects']?.total == 0 && !params.EXCLUSION_LIST.includes(issueTypeScheme.name)) {
                await JiraCloud.All.deleteIssueTypeScheme({
                    issueTypeSchemeId: parseInt(issueTypeScheme.id)
                });
                console.log(`${issueTypeScheme.name} issue type scheme has been deleted.`);
            }
        }
        if (issueTypeSchemesResponse.nextPage) {
            const startAt = (Math.trunc((issueTypeSchemesResponse.startAt ?? 0 + (issueTypeSchemesResponse.maxResults ?? 0)) / 10) * 10) + 1
            issueTypeSchemesResponse = await JiraCloud.All.getIssueTypeSchemes({
                expand: 'projects',
                startAt
            });
            issueTypeSchemes = issueTypeSchemesResponse.values ?? [];
        }
    }

    // Find and delete orphaned screens schemes
    let screensToDelete: string[] = [];

    let screenSchemesRequest = await JiraCloud.All.getScreenSchemes({
        expand: 'issueTypeScreenSchemes',
        maxResults: 100,
    })
    let screenSchemes = screenSchemesRequest.values ?? [];

    iterations = 1
    if (screenSchemesRequest.nextPage) {
        iterations = Math.ceil(screenSchemesRequest.total ?? 0 / (screenSchemesRequest.maxResults ?? 0))
    }
    for (let i = 0; i < iterations; i++) {
        for (const screenScheme of screenSchemes) {
            if (screenScheme['issueTypeScreenSchemes']?.total === 0 && !params.EXCLUSION_LIST.includes(screenScheme.name ?? '')) {
                const screenSchemeScreens = jsonToMap<string>(JSON.parse(JSON.stringify(screenScheme['screens'])))
                for (const screenSchemeScreen of screenSchemeScreens.values()) {
                    if (!screensToDelete.includes(screenSchemeScreen)) {
                        screensToDelete.push(screenSchemeScreen);
                    }

                }
                await JiraCloud.All.deleteScreenScheme({
                    screenSchemeId: `${screenScheme.id}`
                });
                console.log(`${screenScheme.name} screen scheme has been deleted.`);
            }
        }

        if (screenSchemesRequest.nextPage) {
            const startAt = (Math.trunc((screenSchemesRequest.startAt ?? 0 + (screenSchemesRequest.maxResults ?? 0)) / 10) * 10) + 1
            screenSchemesRequest = await JiraCloud.All.getScreenSchemes({
                expand: 'issueTypeScreenSchemes',
                maxResults: 100,
                startAt
            });
            screenSchemes = screenSchemesRequest.values ?? [];
        }
    }

    // Find and delete orphaned workflow schemes
    let workflowSchemesResponse = await JiraCloud.All.getWorkflowSchemes();
    let workflowSchemes = workflowSchemesResponse.values ?? [];
    let workflowsToDelete: string[] = [];

    iterations = 1
    if (workflowSchemesResponse.nextPage) {
        iterations = Math.ceil(workflowSchemesResponse.total ?? 0 / (workflowSchemesResponse.maxResults ?? 0))
    }
    for (let i = 0; i < iterations; i++) {
        for (const workflowScheme of workflowSchemes) {
            if (workflowScheme.id !== 10000 && !params.EXCLUSION_LIST.includes(workflowScheme.name ?? '')) {
                const workflowSchemeWorkflows = jsonToMap<string>(JSON.parse(JSON.stringify(workflowScheme.issueTypeMappings)))
                for (const workflow of workflowSchemeWorkflows.values()) {
                    if (!workflowsToDelete.includes(workflow)) {
                        workflowsToDelete.push(workflow);
                    }
                }

                try {
                    await JiraCloud.All.deleteWorkflowScheme({
                        id: workflowScheme.id ?? 0
                    });
                    console.log(`${workflowScheme.name} workflow scheme has been deleted.`);
                } catch (e) {
                    if (e instanceof BadRequestError) {
                        console.error(`Error while deleting workflow scheme ${workflowScheme.name} - Error: ${(e as Error).message}`);
                    } else {
                        throw e;
                    }
                }
            }
        }

        if (workflowSchemesResponse.nextPage) {
            const startAt = (Math.trunc((workflowSchemesResponse.startAt ?? 0 + (workflowSchemesResponse.maxResults ?? 0)) / 10) * 10) + 1
            workflowSchemesResponse = await JiraCloud.All.getWorkflowSchemes({
                startAt
            });
            workflowSchemes = workflowSchemesResponse.values ?? [];
        }
    }

    // Find and delete orphaned workflows
    let workflowsResponse = await JiraCloud.All.getWorkflows({
        workflowName: workflowsToDelete,
        expand: 'projects,transitions,schemes',
        maxResults: workflowsToDelete.length,
        isActive: false
    });
    let workflows = workflowsResponse.values ?? [];

    for (const workflow of workflows) {
        if (workflow.id.entityId?.match(/([0-9a-f]+-?){5}/) && !workflow['projects'] && workflow.schemes?.length == 0 && !params.EXCLUSION_LIST.includes(workflow.id.name) && workflow.id.name.indexOf(event.project.key) > -1) {
            for (const transition of workflow.transitions ?? []) {
                if (!screensToDelete.includes(transition.screen?.id ?? '')) {
                    screensToDelete.push(transition.screen?.id ?? '')
                }
            }
            try {
                await JiraCloud.All.deleteWorkflow({
                    entityId: workflow.id.entityId
                });
                console.log(`${workflow.id.name} workflow has been deleted.`)
            } catch (e) {
                if (e instanceof BadRequestError) {
                    console.error(`Error while deleting workflow ${workflow.id.name} - Error: ${(e as Error).message}`);
                } else {
                    throw e;
                }
            }
        }
    }

    workflowsResponse = await JiraCloud.All.getWorkflows({
        expand: 'projects,transitions,schemes',
        isActive: false
    });
    workflows = workflowsResponse.values ?? [];

    iterations = 1;
    if (workflowsResponse.nextPage) {
        iterations = Math.ceil(workflowsResponse.total ?? 0 / (workflowsResponse.maxResults ?? 0));
    }
    for (let i = 0; i < iterations; i++) {
        for (const workflow of workflows) {
            if (workflow.id.entityId?.match(/([0-9a-f]+-?){5}/) && !workflow['projects'] && workflow.schemes?.length == 0 && !params.EXCLUSION_LIST.includes(workflow.id.name)) {

                for (const transition of workflow.transitions ?? []) {
                    if (transition.screen) {
                        if (!screensToDelete.includes(transition.screen.id)) {
                            screensToDelete.push(transition.screen.id);
                        }
                    }
                }
                try {
                    await JiraCloud.All.deleteWorkflow({
                        entityId: workflow.id.entityId
                    });
                    console.log(`${workflow.id.name} workflow has been deleted.`);
                } catch (e) {
                    if (e instanceof BadRequestError) {
                        console.error(`Error while deleting workflow ${workflow.id.name} - Error: ${(e as Error).message}`);
                    } else {
                        throw e;
                    }
                }
            }
        }
        if (workflowsResponse.nextPage) {
            const startAt = (Math.trunc((workflowsResponse.startAt ?? 0 + (workflowsResponse.maxResults ?? 0)) / 10) * 10) + 1;
            workflowsResponse = await JiraCloud.All.getWorkflows({
                expand: 'projects,transitions,schemes',
                startAt,
                isActive: false
            });
            workflows = workflowsResponse.values ?? [];
        }
    }

    // Delete orphaned screens
    for (const screen of screensToDelete) {
        const screenResponse = await JiraCloud.All.getScreens({
            id: [+screen],
            scope: ["GLOBAL"]
        })
        const screenName = screenResponse.values?.[0].name ?? '';
        if (!params.EXCLUSION_LIST.includes(screenName)) {
            await JiraCloud.All.deleteScreen({
                screenId: +screen
            });
            console.log(`${screenName} screen has been deleted.`);
        }
    }

    let screensRequest = await JiraCloud.All.getScreens({
        scope: ["GLOBAL"]
    });
    let screens = screensRequest.values ?? [];

    iterations = 1;
    if (screensRequest.nextPage) {
        iterations = Math.ceil(screensRequest.total ?? 0 / (screensRequest.maxResults ?? 0));
    }
    for (let i = 0; i < iterations; i++) {
        for (const screen of screens) {
            const screenResponse = await JiraCloud.All.getScreens({
                id: [screen.id ?? 0],
                scope: ["GLOBAL"]
            })
            const screenName = screenResponse.values?.[0].name ?? '';
            if (!params.EXCLUSION_LIST.includes(screenName)) {
                try {
                    await JiraCloud.All.deleteScreen({
                        screenId: screen.id ?? 0
                    });
                    console.log(`${screenResponse.values?.[0].name} screen has been deleted.`);
                } catch (e) {
                    if (e instanceof BadRequestError) {
                        console.error(`Error while deleting screen ${screenName} - Error: ${(e as Error).message}`);
                    } else {
                        throw e;
                    }
                }
            }
        }

        if (screensRequest.nextPage) {
            const startAt = (Math.trunc((screensRequest.startAt ?? 0 + (screensRequest.maxResults ?? 0)) / 10) * 10) + 1
            screensRequest = await JiraCloud.All.getScreens({
                scope: ["GLOBAL"],
                startAt
            });
            screens = screensRequest.values ?? [];
        }
    }
}

import JiraCloud from './api/jira/cloud';
import { ProjectDeletedEvent } from '@sr-connect/jira-cloud/events';
import { BadRequestError } from '@managed-api/commons-core';
import { jsonToMap, Params } from './Utils';

/**
 * When triggered, this script deletes all schemes, workflows, and screens of an associated project
 * after the project gets deleted from a Jira Cloud instance and the configurations become inactive
 *
 * @param event Object that holds Project Deleted event data
 * @param context Object that holds function invocation context data
 */
export default async function (event: ProjectDeletedEvent, context: Context): Promise<void> {
    const params = context.environment.vars as Params;

    // Get issue type screen schemes
    const issueTypeScreenSchemes = await JiraCloud.All.getIssueTypeScreenSchemes({
        expand: 'projects',
        queryString: `${event.project.key}:`
    });

    // Delete orphaned issue type screen schemes
    for (const issueTypeScreenScheme of issueTypeScreenSchemes.values ?? []) {
        if (issueTypeScreenScheme.id !== '1' && (issueTypeScreenScheme as any)['projects']?.total === 0 && !params.EXCLUSION_LIST.includes(issueTypeScreenScheme.name)) {
            await JiraCloud.All.deleteIssueTypeScreenScheme({
                issueTypeScreenSchemeId: issueTypeScreenScheme.id
            });
            console.log(`${issueTypeScreenScheme.name} issue type screen scheme has been deleted.`);
        }
    }

    // Get issue type screen schemes
    const issueTypeSchemes = await JiraCloud.All.getIssueTypeSchemes({
        expand: 'projects',
        queryString: `${event.project.key}:`
    });

    // Delete orphaned issue type schemes
    for (const issueTypeScheme of issueTypeSchemes.values ?? []) {
        if (issueTypeScheme.id !== '10000' && (issueTypeScheme as any)['projects']?.total === 0 && !params.EXCLUSION_LIST.includes(issueTypeScheme.name)) {
            await JiraCloud.All.deleteIssueTypeScheme({
                issueTypeSchemeId: parseInt(issueTypeScheme.id)
            });
            console.log(`${issueTypeScheme.name} issue type scheme has been deleted.`);
        }
    }

    // Find and delete orphaned screen schemes
    const screensToDelete: string[] = [];

    let screenSchemesResponse = await JiraCloud.All.getScreenSchemes({
        expand: 'issueTypeScreenSchemes',
        queryString: `${event.project.key}:`
    })
    let screenSchemes = screenSchemesResponse.values ?? [];

    let iterations = 1
    if (screenSchemesResponse.nextPage) {
        iterations = Math.ceil(screenSchemesResponse.total ?? 0 / (screenSchemesResponse.maxResults ?? 0));
    }
    for (let i = 0; i < iterations; i++) {
        for (const screenScheme of screenSchemes) {
            if (screenScheme['issueTypeScreenSchemes']?.total === 0 && (screenScheme.name?.indexOf(event.project.key) ?? 0) > -1 && !params.EXCLUSION_LIST.includes(screenScheme.name ?? '')) {
                const screenSchemeScreens = jsonToMap<string>(JSON.parse(JSON.stringify(screenScheme['screens'])))
                for (const screenSchemeScreen of screenSchemeScreens.values()) {
                    if (!screensToDelete.includes(screenSchemeScreen)) {
                        screensToDelete.push(screenSchemeScreen);
                    }

                }

                await JiraCloud.All.deleteScreenScheme({
                    screenSchemeId: `${screenScheme.id}`
                });
                console.log(`${screenScheme.name} screen scheme has been deleted.`);
            }
        }

        if (screenSchemesResponse.nextPage) {
            const startAt = (Math.trunc((screenSchemesResponse.startAt ?? 0 + (screenSchemesResponse.maxResults ?? 0)) / 10) * 10) + 1
            screenSchemesResponse = await JiraCloud.All.getScreenSchemes({
                expand: 'issueTypeScreenSchemes',
                startAt,
                queryString: `${event.project.key}:`
            });
            screenSchemes = screenSchemesResponse.values ?? [];
        }
    }

    // Find and delete orphaned workflow schemes
    let workflowSchemesResponse = await JiraCloud.All.getWorkflowSchemes();

    let workflowSchemes = workflowSchemesResponse.values ?? [];
    let workflowsToDelete: string[] = [];

    iterations = 1
    if (workflowSchemesResponse.nextPage) {
        iterations = Math.ceil(workflowSchemesResponse.total ?? 0 / (workflowSchemesResponse.maxResults ?? 0));
    }
    for (let i = 0; i < iterations; i++) {
        for (let workflowScheme of workflowSchemes) {
            if (workflowScheme.id != 10000 && (workflowScheme.name?.indexOf(event.project.key) ?? 0) > -1 && !params.EXCLUSION_LIST.includes(workflowScheme.name ?? '')) {
                const workflowSchemeWorkflows = jsonToMap<string>(JSON.parse(JSON.stringify(workflowScheme.issueTypeMappings)))
                for (const workflow of workflowSchemeWorkflows.values()) {
                    if (!workflowsToDelete.includes(workflow)) {
                        workflowsToDelete.push(workflow);
                    }
                }
                try {
                    await JiraCloud.All.deleteWorkflowScheme({
                        id: workflowScheme.id ?? 0
                    });
                    console.log(`${workflowScheme.name} workflow scheme has been deleted.`);
                } catch (e) {
                    if (e instanceof BadRequestError) {
                        console.error(`Error while deleting workflow scheme ${workflowScheme.name} - Error: ${(e as Error).message}`);
                    } else {
                        throw e;
                    }
                }
            }
        }

        if (workflowSchemesResponse.nextPage) {
            const startAt = (Math.trunc((workflowSchemesResponse.startAt ?? 0 + (workflowSchemesResponse.maxResults ?? 0)) / 10) * 10) + 1
            workflowSchemesResponse = await JiraCloud.All.getWorkflowSchemes({
                startAt
            });
            workflowSchemes = workflowSchemesResponse.values ?? [];
        }
    }

    // Find and delete oprhaned workflows
    const workflows = await JiraCloud.All.getWorkflows({
        workflowName: workflowsToDelete,
        expand: 'projects,transitions,schemes',
        queryString: `${event.project.key}`,
        maxResults: workflowsToDelete.length,
        isActive: false
    });

    for (const workflow of workflows.values ?? []) {
        if (workflow.id.entityId?.match(/([0-9a-f]+-?){5}/) && !workflow['projects'] && workflow.schemes?.length == 0 && !params.EXCLUSION_LIST.includes(workflow.id.name) && workflow.id.name.indexOf(event.project.key) > -1) {
            for (const transition of workflow.transitions ?? []) {
                if (transition.screen) {
                    if (screensToDelete.indexOf(transition.screen.id) == -1) {
                        screensToDelete.push(transition.screen.id);
                    }
                }
            }

            await JiraCloud.All.deleteWorkflow({
                entityId: workflow.id.entityId
            });
            console.log(`${workflow.id.name} workflow has been deleted.`);
        }
    }

    // Delete orphaned screens
    for (const screen of screensToDelete) {
        const screenResponse = await JiraCloud.All.getScreens({
            id: [+screen],
            scope: ["GLOBAL"]
        })
        if (!params.EXCLUSION_LIST.includes(screenResponse.values?.[0]?.name ?? '')) {
            await JiraCloud.All.deleteScreen({
                screenId: parseInt(screen)
            });
            console.log(`${screenResponse.values?.[0].name} screen has been deleted.`);
        }
    }

    // Get permission schemes
    const permissionSchemes = await JiraCloud.All.getPermissionSchemes()

    // Delete oprhaned permission schemes
    for (const permissionScheme of permissionSchemes.permissionSchemes ?? []) {
        if ((permissionScheme.id ?? 0) > 10001 && permissionScheme.name.indexOf(event.project.key) > -1 && !params.EXCLUSION_LIST.includes(permissionScheme.name)) {
            try {
                await JiraCloud.All.deletePermissionScheme({
                    schemeId: permissionScheme.id ?? 0
                });
                console.log(`${permissionScheme.name} permission scheme has been deleted.`)
            } catch (e) {
                if (e instanceof BadRequestError) {
                    console.error(`Error while deleting permission scheme ${permissionScheme.name} - Error: ${(e as Error).message}`);
                } else {
                    throw e;
                }
            }
        }
    }
}

export interface Params {
    readonly EXCLUSION_LIST: string[];
}

export function jsonToMap<T>(obj: Record<string, T>): Map<string, T> {
    const map = new Map<string, T>();
    for (const [key, value] of Object.entries(obj)) {
        map.set(key, value);
    }
    return map;
}