Merge pull request #241 from OpenPathfinder/ulises/v1-run-workflow

UlisesGascon · web-flow · commit 5012b928edc8 · 2025-06-15T19:26:38.000+02:00
diff --git a/__tests__/httpServer/apiV1.test.js b/__tests__/httpServer/apiV1.test.js
@@ -1,3 +1,24 @@
+// Mocks
+jest.mock('../../src/reports', () => ({
+  generateStaticReports: jest.fn()
+}))
+
+const mockWorkflowFn = jest.fn()
+jest.mock('../../src/cli/workflows', () => ({
+  getWorkflowsDetails: jest.fn(() => ({
+    workflows: {
+      'test-workflow': {
+        name: 'test-workflow',
+        description: 'Test workflow',
+        workflow: mockWorkflowFn
+      }
+    },
+    workflowsList: [
+      { id: 'test-workflow', description: 'Test workflow' }
+    ]
+  }))
+}))
+
 const request = require('supertest')
 const { generateStaticReports } = require('../../src/reports')
 const knexInit = require('knex')
@@ -6,18 +27,15 @@ const { resetDatabase, initializeStore } = require('../../__utils__')
 const pkg = require('../../package.json')
 const serverModule = require('../../src/httpServer')
 const { dbSettings } = getConfig('test')
-const { getAllWorkflows } = require('../../src/cli/workflows')
+const { getWorkflowsDetails } = require('../../src/cli/workflows')
+const { workflowsList } = getWorkflowsDetails()
+
 let server
 let serverStop
 let app
 let knex
 let getAllProjects
 
-// Mocks
-jest.mock('../../src/reports', () => ({
-  generateStaticReports: jest.fn()
-}))
-
 beforeAll(async () => {
   // Initialize server asynchronously
   const serverInstance = serverModule()
@@ -121,12 +139,89 @@ describe('HTTP Server API V1', () => {
       const response = await app.get('/api/v1/workflow')
 
       expect(response.status).toBe(200)
-      expect(response.body).toStrictEqual(getAllWorkflows())
+      expect(response.body).toStrictEqual(workflowsList)
     })
 
     test.todo('should return 500 for internal server error')
   })
 
+  describe('POST /api/v1/workflow/:id/run', () => {
+    let workflowSpy
+    let mockWorkflowFn
+
+    beforeEach(() => {
+      mockWorkflowFn = jest.fn()
+      workflowSpy = jest.spyOn(require('../../src/cli/workflows'), 'getWorkflowsDetails').mockReturnValue({
+        workflows: {
+          'test-workflow': {
+            name: 'test-workflow',
+            description: 'Test workflow',
+            workflow: mockWorkflowFn
+          }
+        },
+        workflowsList: [
+          { id: 'test-workflow', description: 'Test workflow' }
+        ]
+      })
+    })
+
+    afterEach(() => {
+      workflowSpy.mockRestore()
+      jest.clearAllMocks()
+    })
+
+    test('should return 202 and run the specified workflow', async () => {
+      mockWorkflowFn.mockResolvedValueOnce()
+      const response = await app
+        .post('/api/v1/workflow/test-workflow/run')
+        .set('Content-Type', 'application/json')
+        .send({ some: 'data' })
+
+      expect(response.status).toBe(202)
+      expect(response.body).toHaveProperty('status', 'completed')
+      expect(response.body.workflow).toMatchObject({
+        id: 'test-workflow',
+        description: 'Test workflow'
+      })
+      expect(mockWorkflowFn).toHaveBeenCalledWith({ some: 'data' })
+    })
+
+    test('should return 404 for invalid workflow ID', async () => {
+    // Overwrite the spy to return no workflows
+      workflowSpy.mockReturnValueOnce({
+        workflows: {},
+        workflowsList: []
+      })
+      const response = await app
+        .post('/api/v1/workflow/invalid-workflow/run')
+        .set('Content-Type', 'application/json')
+        .send({})
+
+      expect(response.status).toBe(404)
+      expect(response.body).toStrictEqual({ errors: [{ message: 'Workflow not found' }] })
+    })
+
+    test('should return 500 for internal server error', async () => {
+      mockWorkflowFn.mockRejectedValueOnce(new Error('Something went wrong'))
+
+      const response = await app
+        .post('/api/v1/workflow/test-workflow/run')
+        .set('Content-Type', 'application/json')
+        .send({ some: 'data' })
+
+      expect(response.status).toBe(500)
+      expect(response.body.status).toBe('failed')
+      expect(response.body.workflow).toMatchObject({
+        id: 'test-workflow',
+        description: 'Test workflow'
+      })
+      expect(response.body.errors[0].message).toMatch(/Failed to run workflow: Something went wrong/)
+      expect(mockWorkflowFn).toHaveBeenCalledWith({ some: 'data' })
+    })
+
+    test.todo('should return 500 when workflow execution times out')
+  })
+
   describe('POST /api/v1/generate-reports', () => {
     test('should return status completed when report generation succeeds', async () => {
       generateStaticReports.mockResolvedValueOnce()
diff --git a/src/cli/workflows.js b/src/cli/workflows.js
@@ -1,4 +1,5 @@
 const inquirer = require('inquirer').default
+const _ = require('lodash')
 const debug = require('debug')('cli:workflows')
 const { updateGithubOrgs, upsertGithubRepositories, runAllTheComplianceChecks, upsertOSSFScorecardAnalysis } = require('../workflows')
 const { generateStaticReports } = require('../reports')
@@ -31,10 +32,24 @@ const commandList = [{
   workflow: bulkImport
 }]
 
-const workflows = commandList.map(({ name, description }) => ({ id: name, description }))
-
 const validCommandNames = commandList.map(({ name }) => name)
 
+const getWorkflowsDetails = () => {
+  const workflows = {}
+  const workflowsList = []
+
+  commandList.forEach((workflow) => {
+    const workflowName = _.kebabCase(workflow.name)
+    workflowsList.push({ id: workflowName, description: workflow.description })
+    workflows[workflowName] = {
+      description: workflow.description,
+      workflow: workflow.workflow
+    }
+  })
+
+  return { workflows, workflowsList }
+}
+
 function listWorkflowCommand (options = {}) {
   logger.info('Available workflows:')
   commandList.forEach(({ name, description }) => logger.info(`- ${name}: ${description}`))
@@ -72,6 +87,6 @@ async function runWorkflowCommand (knex, options = {}) {
 
 module.exports = {
   listWorkflowCommand,
-  getAllWorkflows: () => workflows,
+  getWorkflowsDetails,
   runWorkflowCommand
 }
diff --git a/src/httpServer/routers/apiV1.js b/src/httpServer/routers/apiV1.js
@@ -4,7 +4,28 @@ const { logger } = require('../../utils')
 const { initializeStore } = require('../../store')
 const _ = require('lodash')
 const { isSlug } = require('validator')
-const { getAllWorkflows } = require('../../cli/workflows')
+const { getWorkflowsDetails } = require('../../cli/workflows')
+
+const HTTP_DEFAULT_TIMEOUT = 30 * 1000 // 30 seconds
+
+const runWorkflow = (workflowName, data) => new Promise((resolve, reject) => {
+  const { workflows } = getWorkflowsDetails()
+  const workflow = workflows[workflowName]
+  if (!workflow || typeof workflow.workflow !== 'function') {
+    return reject(new Error('Invalid Workflow'))
+  }
+  // @TODO: This is temporary and ideally we should move this to a queue system
+  // to avoid blocking the HTTP server and allow long-running workflows
+  const timeout = setTimeout(() => {
+    reject(new Error('Workflow default timeout reached'))
+  }, HTTP_DEFAULT_TIMEOUT)
+
+  Promise.resolve()
+    .then(() => workflow.workflow(data))
+    .then(() => resolve(workflow))
+    .catch(err => reject(new Error(`Failed to run workflow: ${err.message}`)))
+    .finally(() => clearTimeout(timeout))
+})
 
 function createApiRouter (knex, express) {
   const { addProject, getProjectByName } = initializeStore(knex)
@@ -45,14 +66,45 @@ function createApiRouter (knex, express) {
 
   router.get('/workflow', (req, res) => {
     try {
-      const workflows = getAllWorkflows()
-      res.json(workflows)
+      const { workflowsList } = getWorkflowsDetails()
+      res.json(workflowsList)
     } catch (error) {
       logger.error(error)
       res.status(500).json({ errors: [{ message: 'Failed to retrieve workflows' }] })
     }
   })
 
+  router.post('/workflow/:id/run', async (req, res) => {
+    const { id } = req.params
+    const data = req.body
+    const { workflows } = getWorkflowsDetails()
+
+    if (!id || !isSlug(id)) {
+      return res.status(400).json({ errors: [{ message: 'Invalid workflow ID' }] })
+    }
+    const workflow = workflows[id]
+
+    if (!workflow) {
+      return res.status(404).json({ errors: [{ message: 'Workflow not found' }] })
+    }
+    try {
+      // @TODO: We need to delegate the workflow execution to a worker and provide and endpoint to check the status
+      // This is a temporary solution to run the workflow within the HTTP timeout
+      // data validation is done in the workflow itself
+      const wf = await runWorkflow(id, data)
+      res.status(202).json({ status: 'completed', workflow: { id, description: wf.description } })
+    } catch (error) {
+      logger.error(error)
+      res.status(500).json({
+        status: 'failed',
+        workflow: workflow
+          ? { id, description: workflow.description }
+          : undefined,
+        errors: [{ message: `Failed to run workflow: ${error.message}` }]
+      })
+    }
+  })
+
   router.post('/generate-reports', async (req, res) => {
     const startTs = new Date().toISOString()
     try {
diff --git a/src/httpServer/swagger/api-v1.yml b/src/httpServer/swagger/api-v1.yml
@@ -70,6 +70,82 @@ paths:
               schema:
                 $ref: '#/components/schemas/ErrorResponse'
 
+  /api/v1/workflow/{workflowId}/run:
+    post:
+      summary: Execute a workflow
+      description: Executes the specified workflow with the provided input data
+      operationId: executeWorkflow
+      tags:
+        - Workflows
+      parameters:
+        - name: workflowId
+          in: path
+          required: true
+          description: The ID of the workflow to execute
+          schema:
+            type: string
+            example: example-workflow
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              # @TODO: Improve this schema to be more specific about the expected input
+              properties:
+                data:
+                  oneOf:
+                    - type: object
+                    - type: array
+                      items:
+                        oneOf:
+                          - type: object
+                          - type: string
+      responses:
+        '202':
+          description: Workflow executed successfully
+          content:
+            application/json:
+              schema:
+                type: object
+                additionalProperties: false
+                properties:
+                  status:
+                    type: string
+                    example: completed
+                  workflow:
+                    type: object
+                    properties:
+                      id:
+                        type: string
+                        example: example-workflow
+                      description:
+                        type: string
+                        example: This is an example workflow
+                    required:
+                      - id
+                      - description
+                required:
+                  - status
+                  - workflow
+        '400':
+          description: Bad request, invalid input data
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ErrorResponse'
+        '404':
+          description: Workflow not found
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ErrorResponse'
+        '500':
+          description: Internal server error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ErrorResponse'
   /api/v1/project:
     post:
       summary: Create a new project
diff --git a/src/importers/index.js b/src/importers/index.js
