feat(orchestrator): support pagination for /instances and /overview

plugins/orchestrator-backend/src/helpers/queryBuilder.ts

@@ -0,0 +1,34 @@
+import { Pagination } from '../types/pagination';
+
+export function buildGraphQlQuery(args: {
+  type: 'ProcessDefinitions' | 'ProcessInstances' | 'Jobs';
+  queryBody: string;
+  whereClause?: string;
+  pagination?: Pagination;
+}): string {
+  let query = `{${args.type}`;
+
+  if (args.whereClause || args.pagination) {
+    query += ` (`;
+
+    if (args.whereClause) {
+      query += `where: {${args.whereClause}}`;
+      if (args.pagination) {
+        query += `, `;
+      }
+    }
+    if (args.pagination) {
+      if (args.pagination.sortField) {
+        query += `orderBy: {${
+          args.pagination.sortField
+        }: ${args.pagination.order?.toUpperCase()}}, `;
+      }
+      query += `pagination: {limit: ${args.pagination.limit} , offset: ${args.pagination.offset}}`;
+    }
+
+    query += `) `;
+  }
+  query += ` {${args.queryBody} } }`;
+
+  return query;
+}

plugins/orchestrator-backend/src/pagination.test.ts

@@ -0,0 +1,58 @@
+import { buildPagination } from './types/pagination';
+
+describe('buildPagination()', () => {
+  it('should build the correct pagination obj when no query parameters are passed', () => {
+    const mockRequest: any = {
+      query: {},
+    };
+    expect(buildPagination(mockRequest)).toEqual({
+      limit: 10,
+      offset: 0,
+      order: 'ASC',
+      sortField: undefined,
+    });
+  });
+  it('should build the correct pagination obj when partial query parameters are passed', () => {
+    const mockRequest: any = {
+      query: {
+        orderBy: 'lastUpdated',
+      },
+    };
+    expect(buildPagination(mockRequest)).toEqual({
+      limit: 10,
+      offset: 0,
+      order: 'ASC',
+      sortField: 'lastUpdated',
+    });
+  });
+  it('should build the correct pagination obj when all query parameters are passed', () => {
+    const mockRequest: any = {
+      query: {
+        page: 1,
+        pageSize: 50,
+        orderBy: 'lastUpdated',
+        orderDirection: 'DESC',
+      },
+    };
+    expect(buildPagination(mockRequest)).toEqual({
+      limit: 50,
+      offset: 1,
+      order: 'DESC',
+      sortField: 'lastUpdated',
+    });
+  });
+  it('should build the correct pagination obj when non numeric value passed to number fields', () => {
+    const mockRequest: any = {
+      query: {
+        page: 'abc',
+        pageSize: 'cde',
+      },
+    };
+    expect(buildPagination(mockRequest)).toEqual({
+      limit: 10,
+      offset: 0,
+      order: 'ASC',
+      sortField: undefined,
+    });
+  });
+});

plugins/orchestrator-backend/src/queryBuilder.test.ts

@@ -0,0 +1,49 @@
+import { buildGraphQlQuery } from './helpers/queryBuilder';
+import { Pagination } from './types/pagination';
+
+describe('GraphQL query builder', () => {
+  it('should return properly formatted graphQL query when where clause and pagination are present', () => {
+    const expectedQuery: string =
+      '{ProcessInstances (where: {processId: {isNull: false}}, orderBy: {lastUpdate: DESC}, pagination: {limit: 5 , offset: 2})  {id, processName, processId, state, start, lastUpdate, end, nodes { id }, variables, parentProcessInstance {id, processName, businessKey} } }';
+    const pagination: Pagination = {
+      offset: 2,
+      limit: 5,
+      order: 'DESC',
+      sortField: 'lastUpdate',
+    };
+    expect(
+      buildGraphQlQuery({
+        type: 'ProcessInstances',
+        queryBody:
+          'id, processName, processId, state, start, lastUpdate, end, nodes { id }, variables, parentProcessInstance {id, processName, businessKey}',
+        whereClause: 'processId: {isNull: false}',
+        pagination,
+      }),
+    ).toEqual(expectedQuery);
+  });
+
+  it('should return properly formatted graphQL query when where clause is present', () => {
+    const expectedQuery: string =
+      '{ProcessInstances (where: {processId: {isNull: false}})  {id, processName, processId, state, start, lastUpdate, end, nodes { id }, variables, parentProcessInstance {id, processName, businessKey} } }';
+    expect(
+      buildGraphQlQuery({
+        type: 'ProcessInstances',
+        queryBody:
+          'id, processName, processId, state, start, lastUpdate, end, nodes { id }, variables, parentProcessInstance {id, processName, businessKey}',
+        whereClause: 'processId: {isNull: false}',
+      }),
+    ).toEqual(expectedQuery);
+  });
+
+  it('should return properly formatted graphQL query when where clause is NOT present', () => {
+    const expectedQuery: string =
+      '{ProcessInstances {id, processName, processId, state, start, lastUpdate, end, nodes { id }, variables, parentProcessInstance {id, processName, businessKey} } }';
+    expect(
+      buildGraphQlQuery({
+        type: 'ProcessInstances',
+        queryBody:
+          'id, processName, processId, state, start, lastUpdate, end, nodes { id }, variables, parentProcessInstance {id, processName, businessKey}',
+      }),
+    ).toEqual(expectedQuery);
+  });
+});

plugins/orchestrator-backend/src/service/DataIndexService.ts

@@ -12,6 +12,9 @@ import {
 } from '@janus-idp/backstage-plugin-orchestrator-common';
 
 import { ErrorBuilder } from '../helpers/errorBuilder';
+import { buildGraphQlQuery } from '../helpers/queryBuilder';
+import { Pagination } from '../types/pagination';
+import { FETCH_PROCESS_INSTANCES_SORT_FIELD } from './constants';
 
 export class DataIndexService {
   private client: Client;
@@ -89,23 +92,18 @@ export class DataIndexService {
     return processDefinitions[0];
   }
 
-  public async getWorkflowInfos(): Promise<WorkflowInfo[]> {
-    const QUERY = `
-        query ProcessDefinitions {
-            ProcessDefinitions {
-                id
-                name
-                version
-                type
-                endpoint
-                serviceUrl
-                source
-            }
-        }
-      `;
-
+  public async getWorkflowInfos(
+    pagination: Pagination,
+  ): Promise<WorkflowInfo[]> {
     this.logger.info(`getWorkflowInfos() called: ${this.dataIndexUrl}`);
-    const result = await this.client.query(QUERY, {});
+
+    const graphQlQuery = buildGraphQlQuery({
+      type: 'ProcessDefinitions',
+      queryBody: 'id, name, version, type, endpoint, serviceUrl, source',
+      pagination,
+    });
+    this.logger.debug(`GraphQL query: ${graphQlQuery}`);
+    const result = await this.client.query(graphQlQuery, {});
 
     this.logger.debug(
       `Get workflow definitions result: ${JSON.stringify(result)}`,
@@ -121,10 +119,19 @@ export class DataIndexService {
     return result.data.ProcessDefinitions;
   }
 
-  public async fetchProcessInstances(): Promise<ProcessInstance[] | undefined> {
-    const graphQlQuery =
-      '{ ProcessInstances ( orderBy: { start: ASC }, where: {processId: {isNull: false} } ) { id, processName, processId, businessKey, state, start, end, nodes { id }, variables, parentProcessInstance {id, processName, businessKey} } }';
-
+  public async fetchProcessInstances(
+    pagination: Pagination,
+  ): Promise<ProcessInstance[] | undefined> {
+    pagination.sortField ??= FETCH_PROCESS_INSTANCES_SORT_FIELD;
+
+    const graphQlQuery = buildGraphQlQuery({
+      type: 'ProcessInstances',
+      queryBody:
+        'id, processName, processId, businessKey, state, start, end, nodes { id }, variables, parentProcessInstance {id, processName, businessKey}',
+      whereClause: 'processId: {isNull: false}',
+      pagination,
+    });
+    this.logger.debug(`GraphQL query: ${graphQlQuery}`);
     const result = await this.client.query(graphQlQuery, {});
 
     this.logger.debug(
@@ -147,6 +154,24 @@ export class DataIndexService {
     return processInstances;
   }
 
+  public async getProcessInstancesTotalCount(): Promise<number> {
+    const graphQlQuery = buildGraphQlQuery({
+      type: 'ProcessInstances',
+      queryBody: 'id',
+    });
+    this.logger.debug(`GraphQL query: ${graphQlQuery}`);
+    const result = await this.client.query(graphQlQuery, {});
+
+    if (result.error) {
+      this.logger.error(`Error when fetching instances: ${result.error}`);
+      throw result.error;
+    }
+
+    const idArr = result.data.ProcessInstances as ProcessInstance[];
+
+    return Promise.resolve(idArr.length);
+  }
+
   private async getWorkflowDefinitionFromInstance(instance: ProcessInstance) {
     const workflowInfo = await this.getWorkflowDefinition(instance.processId);
     if (!workflowInfo?.source) {

plugins/orchestrator-backend/src/service/SonataFlowService.ts

@@ -21,6 +21,7 @@ import {
 import { spawn } from 'child_process';
 import { join, resolve } from 'path';
 
+import { Pagination } from '../types/pagination';
 import { DataIndexService } from './DataIndexService';
 import { executeWithRetry } from './Helper';
 
@@ -143,11 +144,11 @@ export class SonataFlowService {
     return undefined;
   }
 
-  public async fetchWorkflowOverviews(): Promise<
-    WorkflowOverview[] | undefined
-  > {
+  public async fetchWorkflowOverviews(
+    pagination: Pagination,
+  ): Promise<WorkflowOverview[] | undefined> {
     try {
-      const workflowInfos = await this.dataIndex.getWorkflowInfos();
+      const workflowInfos = await this.dataIndex.getWorkflowInfos(pagination);
       if (!workflowInfos?.length) {
         return [];
       }

plugins/orchestrator-backend/src/service/api/v1.ts

@@ -10,6 +10,7 @@ import {
   WorkflowOverviewListResult,
 } from '@janus-idp/backstage-plugin-orchestrator-common';
 
+import { Pagination } from '../../types/pagination';
 import { DataIndexService } from '../DataIndexService';
 import { retryAsyncFunction } from '../Helper';
 import { SonataFlowService } from '../SonataFlowService';
@@ -20,8 +21,10 @@ const FETCH_INSTANCE_RETRY_DELAY_MS = 1000;
 export namespace V1 {
   export async function getWorkflowsOverview(
     sonataFlowService: SonataFlowService,
+    pagination: Pagination,
   ): Promise<WorkflowOverviewListResult> {
-    const overviews = await sonataFlowService.fetchWorkflowOverviews();
+    const overviews =
+      await sonataFlowService.fetchWorkflowOverviews(pagination);
     if (!overviews) {
       throw new Error("Couldn't fetch workflow overviews");
     }
@@ -76,8 +79,9 @@ export namespace V1 {
 
   export async function getInstances(
     dataIndexService: DataIndexService,
+    pagination: Pagination,
   ): Promise<ProcessInstance[]> {
-    const instances = await dataIndexService.fetchProcessInstances();
+    const instances = await dataIndexService.fetchProcessInstances(pagination);
 
     if (!instances) {
       throw new Error("Couldn't fetch process instances");