sync-status-across-projects.yml

name: Sync Status, Labels, and State Across Projects

on:
  issues:
    types: [edited, labeled, unlabeled, closed, reopened]

jobs:
  sync-status-labels-state:
    runs-on: ubuntu-latest
    steps:
      - name: Sync Issue Fields
        uses: actions/github-script@v6
        with:
          github-token: ${{ secrets.GH_TOKEN }}
          script: |
            const orgName = process.env.GITHUB_REPOSITORY_OWNER;
            const sourceProjectNumber = 1314; 
            const sourceProjectId = 'PVT_kwDOAFK5-84Ak8oz';
            const targetProjectNumber = 1514; 
            const targetProjectId = 'PVT_kwDOAFK5-84Ar1s4'; 

            // Function to fetch fields for a project
            const fetchProjectFields = async (projectNumber, orgName) => {
              const query = `
                query($orgName: String!, $projectNumber: Int!) {
                  organization(login: $orgName) {
                    projectV2(number: $projectNumber) {
                      id
                      fields(first: 20) {
                        nodes {
                          ... on ProjectV2SingleSelectField {
                            id
                            name
                            options {
                              id
                              name
                            }
                          }
                        }
                      }
                    }
                  }
                }
              `;
              console.log("Running GraphQL Query with orgName:", orgName, "and projectNumber:", projectNumber);
              try {
                const response = await github.graphql(query, {
                  orgName: orgName,
                  projectNumber: projectNumber
                });

                console.log("GraphQL Response:", response);

                if (!response) {
                  console.log("No response received from GitHub GraphQL API.");
                  return null;
                }

                return response;

              } catch (error) {
                console.error("Error executing GraphQL query:", error);
                return null;
              }
            };

            // Fetch fields for the source project
            const sourceProjectData = await fetchProjectFields(sourceProjectNumber, orgName);
            console.log("Source Project Fields:", sourceProjectData);

            // Fetch fields for the target project
            const targetProjectData = await fetchProjectFields(targetProjectNumber, orgName);
            console.log("Target Project Fields:", targetProjectData);

            // Find the 'Status' field ID from the source project
            const statusField = sourceProjectData.organization.projectV2.fields.nodes.find(field => field.name === 'Status');
            if (!statusField) {
              console.log("No 'Status' field found in source project.");
              return;
            }
            const statusFieldId = statusField.id;

            console.log(`Found 'Status' field ID in source project: ${statusFieldId}`);

            // Fetch the current issue data (including labels, status, and state)
            const issueNodeId = context.payload.issue.node_id;
            const labels = context.payload.issue.labels.map(label => label.name);
            const issueState = context.payload.issue.state;

            // Fetch the status field value for the current issue in the source project
                const data = await github.graphql(`
                query($issueId: ID!) {
                    node(id: $issueId) {
                    ... on Issue {
                        projectItems(first: 10) {
                        nodes {
                            project {
                            id
                            fields(first: 10) {
                                nodes {
                                ... on ProjectV2SingleSelectField {
                                    id
                                    name
                                    options {
                                    id
                                    name
                                    }
                                }
                                }
                            }
                            }
                            fieldValues(first: 10) {
                            nodes {
                                ... on ProjectV2ItemFieldSingleSelectValue {
                                id
                                name
                                }
                            }
                            }
                        }
                        }
                    }
                    }
                }
                `, {
                issueId: issueNodeId
                });

            console.log("Issue data", data)

            const projectItems = data.node.projectItems.nodes;

            // Find the "Status" field and its options
             const statusFieldOptions = projectItems
             .map(item => item.project.fields.nodes.find(field => field.name === 'Status'))  // Find "Status" field in each project
             .find(Boolean);

            if (statusFieldOptions) {
            // Find the corresponding field value for "Status"
            const currentStatus = projectItems
                .flatMap(item => item.fieldValues.nodes) 
                .find(fieldValue => statusFieldOptions.options.some(option => option.name === fieldValue.name))?.name;  // Find matching option by name

            if (currentStatus) {
                console.log(`Current status for the issue: ${currentStatus}`);
            } else {
                console.log("No matching status found for the issue.");
            }
            } else {
            console.log("No 'Status' field found in the project.");
            }

            // Now sync the status field, labels, and state in the target project

            // Sync Status Field
            await github.graphql(`
              mutation($projectId: ID!, $contentId: ID!, $status: String!, $statusFieldId: ID!) {
                updateProjectV2ItemFieldValue(input: {
                  projectId: $projectId,
                  itemId: $contentId,
                  fieldId: $statusFieldId,
                  value: $status
                }) {
                  projectV2Item {
                    id
                  }
                }
              }
            `, {
              projectId: targetProjectId,
              contentId: issueNodeId,
              status: currentStatus,
              statusFieldId: statusFieldId
            });

            console.log(`Status synced successfully to target project for issue ID: ${issueNodeId}`);

            // Sync Labels
            await github.issues.addLabels({
              owner: orgName,
              repo: context.payload.repository.name,
              issue_number: context.payload.issue.number,
              labels: labels
            });

            console.log(`Labels synced successfully to target project for issue ID: ${issueNodeId}`);

            // Sync Issue State (Closed/Reopened)
            if (issueState === 'closed') {
              await github.issues.update({
                owner: orgName,
                repo: context.payload.repository.name,
                issue_number: context.payload.issue.number,
                state: 'closed'
              });

              console.log(`Issue state updated to 'closed' for issue ID: ${issueNodeId}`);
            } else if (issueState === 'reopened') {
              await github.issues.update({
                owner: orgName,
                repo: context.payload.repository.name,
                issue_number: context.payload.issue.number,
                state: 'open'
              });

              console.log(`Issue state updated to 'open' for issue ID: ${issueNodeId}`);
            }

            console.log(`Issue state synced successfully to target project for issue ID: ${issueNodeId}`);