Resolve benchmark workflows for seed (#2006)

Fixes OPS-3751.

## Additional Notes

This PR adds a helper method to return paths for benchmark workflows
from the catalog for a given provider and user chosen workflow ids.

The next step would be to import the flows using these paths.

---------

Co-authored-by: Cezar <cezar@openops.com>

Author: ravikiranvm

packages/server/api/project.json

@@ -20,7 +20,14 @@
         "outputPath": "dist/packages/server/api",
         "main": "packages/server/api/src/main.ts",
         "tsConfig": "packages/server/api/tsconfig.app.json",
-        "assets": ["packages/server/api/src/assets"],
+        "assets": [
+          "packages/server/api/src/assets",
+          {
+            "input": "packages/server/api/src/app/benchmark",
+            "glob": "workflows-catalog/**/*",
+            "output": "."
+          }
+        ],
         "webpackConfig": "packages/server/api/webpack.config.js",
         "generatePackageJson": false,
         "babelUpwardRootMode": true,

packages/server/api/src/app/benchmark/catalog-manifests.ts

@@ -0,0 +1,11 @@
+export type LifecycleWorkflow = {
+  orchestratorWorkflowId: string;
+  cleanupWorkflowId: string;
+};
+
+export const PROVIDER_LIFECYCLE_WORKFLOWS: Record<string, LifecycleWorkflow> = {
+  aws: {
+    orchestratorWorkflowId: 'Run AWS Benchmark - orchestrator',
+    cleanupWorkflowId: 'Clean-up AWS Benchmark data',
+  },
+};

packages/server/api/src/app/benchmark/catalog-resolver.ts

@@ -0,0 +1,65 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  type LifecycleWorkflow,
+  PROVIDER_LIFECYCLE_WORKFLOWS,
+} from './catalog-manifests';
+import { throwValidationError } from './errors';
+
+const WORKFLOWS_CATALOG_DIR = 'workflows-catalog';
+
+function getCatalogDir(provider: string): string {
+  return path.join(__dirname, WORKFLOWS_CATALOG_DIR, provider.toLowerCase());
+}
+
+function getLifecycleWorkflow(provider: string): LifecycleWorkflow {
+  const normalized = provider.toLowerCase();
+  const lifecycleWorkflow = PROVIDER_LIFECYCLE_WORKFLOWS[normalized];
+  if (!lifecycleWorkflow) {
+    throwValidationError(`Unsupported benchmark provider: ${provider}`);
+  }
+  return lifecycleWorkflow;
+}
+
+function getOrchestratorId(provider: string): string {
+  return getLifecycleWorkflow(provider).orchestratorWorkflowId;
+}
+
+function getCleanupWorkflowId(provider: string): string {
+  return getLifecycleWorkflow(provider).cleanupWorkflowId;
+}
+
+export type ResolvedWorkflowPath = {
+  id: string;
+  filePath: string;
+};
+
+function resolveWorkflowPaths(
+  provider: string,
+  workflowIds: string[],
+): ResolvedWorkflowPath[] {
+  const catalogDir = getCatalogDir(provider);
+  const result: ResolvedWorkflowPath[] = [];
+  for (const id of workflowIds) {
+    const filePath = path.join(catalogDir, `${id}.json`);
+    if (!fs.existsSync(filePath)) {
+      throwValidationError(`Workflow catalog file not found: ${id}`);
+    }
+    result.push({ id, filePath });
+  }
+  return result;
+}
+
+export function resolveWorkflowPathsForSeed(
+  provider: string,
+  subWorkflowIds: string[],
+): ResolvedWorkflowPath[] {
+  if (subWorkflowIds.length === 0) {
+    getLifecycleWorkflow(provider);
+    return [];
+  }
+  const orchestratorId = getOrchestratorId(provider);
+  const cleanupId = getCleanupWorkflowId(provider);
+  const allIds = [orchestratorId, cleanupId, ...subWorkflowIds];
+  return resolveWorkflowPaths(provider, allIds);
+}

packages/server/api/test/unit/benchmark/catalog-resolver.test.ts

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import { resolveWorkflowPathsForSeed } from '../../../src/app/benchmark/catalog-resolver';
+
+const ORCHESTRATOR_WORKFLOW_ID = 'Orchestrator Workflow';
+const CLEANUP_WORKFLOW_ID = 'Cleanup Workflow';
+const SUB_WORKFLOW_ID = 'Sub Workflow A';
+
+const TEST_PROVIDER = 'provider_a';
+
+jest.mock('../../../src/app/benchmark/catalog-manifests', () => ({
+  PROVIDER_LIFECYCLE_WORKFLOWS: {
+    provider_a: {
+      orchestratorWorkflowId: 'Orchestrator Workflow',
+      cleanupWorkflowId: 'Cleanup Workflow',
+    },
+  },
+}));
+
+jest.mock('node:fs', () => ({
+  ...jest.requireActual('node:fs'),
+  existsSync: jest.fn(),
+}));
+
+const existsSyncMock = fs.existsSync as jest.MockedFunction<
+  typeof fs.existsSync
+>;
+
+function setCatalogExists(workflowFilesExist: (path: string) => boolean): void {
+  existsSyncMock.mockImplementation((filePath: fs.PathLike) => {
+    const str = String(filePath);
+    return workflowFilesExist(str);
+  });
+}
+
+describe('catalog-resolver', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('resolveWorkflowPathsForSeed throws when provider is not in catalog', () => {
+    expect(() => resolveWorkflowPathsForSeed('gcp', [])).toThrow(
+      'Unsupported benchmark provider: gcp',
+    );
+  });
+
+  it('resolveWorkflowPathsForSeed returns empty array when no sub-workflows', () => {
+    const result = resolveWorkflowPathsForSeed(TEST_PROVIDER, []);
+    expect(result).toEqual([]);
+  });
+
+  it('resolveWorkflowPathsForSeed throws when workflow file does not exist', () => {
+    setCatalogExists((filePath) => {
+      return (
+        filePath.endsWith(`${ORCHESTRATOR_WORKFLOW_ID}.json`) ||
+        filePath.endsWith(`${CLEANUP_WORKFLOW_ID}.json`)
+      );
+    });
+
+    expect(() =>
+      resolveWorkflowPathsForSeed(TEST_PROVIDER, [SUB_WORKFLOW_ID]),
+    ).toThrow(`Workflow catalog file not found: ${SUB_WORKFLOW_ID}`);
+  });
+
+  it('resolveWorkflowPathsForSeed returns orchestrator, cleanup, then sub-workflows when all exist', () => {
+    setCatalogExists((filePath) => {
+      return (
+        filePath.endsWith(`${ORCHESTRATOR_WORKFLOW_ID}.json`) ||
+        filePath.endsWith(`${CLEANUP_WORKFLOW_ID}.json`) ||
+        filePath.endsWith(`${SUB_WORKFLOW_ID}.json`)
+      );
+    });
+
+    const result = resolveWorkflowPathsForSeed(TEST_PROVIDER, [
+      SUB_WORKFLOW_ID,
+    ]);
+
+    expect(result).toHaveLength(3);
+    expect(result[0].id).toBe(ORCHESTRATOR_WORKFLOW_ID);
+    expect(result[0].filePath).toContain(ORCHESTRATOR_WORKFLOW_ID);
+    expect(result[1].id).toBe(CLEANUP_WORKFLOW_ID);
+    expect(result[1].filePath).toContain(CLEANUP_WORKFLOW_ID);
+    expect(result[2].id).toBe(SUB_WORKFLOW_ID);
+    expect(result[2].filePath.endsWith(`${SUB_WORKFLOW_ID}.json`)).toBe(true);
+  });
+});