test: Implement getExecutions graphQL query tests

packages/backend/src/db/migrations/20231025101146_add_flow_id_index_in_executions.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.table('executions', (table) => {
+    table.index('flow_id');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.table('executions', (table) => {
+    table.dropIndex('flow_id');
+  });
+}

packages/backend/src/db/migrations/20231025101923_add_updated_at_index_in_executions.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.table('executions', (table) => {
+    table.index('updated_at');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.table('executions', (table) => {
+    table.dropIndex('updated_at');
+  });
+}

packages/backend/src/graphql/queries/get-executions.test.ts

@@ -0,0 +1,277 @@
+import request, { Test } from 'supertest';
+import app from '../../app';
+import appConfig from '../../config/app';
+import createAuthTokenByUserId from '../../helpers/create-auth-token-by-user-id';
+import { createRole } from '../../../test/factories/role';
+import { createPermission } from '../../../test/factories/permission';
+import { createUser } from '../../../test/factories/user';
+import { createFlow } from '../../../test/factories/flow';
+import { createStep } from '../../../test/factories/step';
+import { createExecution } from '../../../test/factories/execution';
+import { createExecutionStep } from '../../../test/factories/execution-step';
+import {
+  IRole,
+  IUser,
+  IExecution,
+  IFlow,
+  IExecutionStep,
+  IStep,
+} from '@automatisch/types';
+
+describe('graphQL getExecutions query', () => {
+  const query = `
+    query {
+      getExecutions(limit: 10, offset: 0) {
+        pageInfo {
+          currentPage
+          totalPages
+        }
+        edges {
+          node {
+            id
+            testRun
+            createdAt
+            updatedAt
+            status
+            flow {
+              id
+              name
+              active
+              steps {
+                iconUrl
+              }
+            }
+          }
+        }
+      }
+    }
+  `;
+
+  const invalidToken = 'invalid-token';
+
+  describe('with unauthenticated user', () => {
+    it('should throw not authorized error', async () => {
+      const response = await request(app)
+        .post('/graphql')
+        .set('Authorization', invalidToken)
+        .send({ query })
+        .expect(200);
+
+      expect(response.body.errors).toBeDefined();
+      expect(response.body.errors[0].message).toEqual('Not Authorised!');
+    });
+  });
+
+  describe('with authenticated user', () => {
+    describe('and without permissions', () => {
+      it('should throw not authorized error', async () => {
+        const userWithoutPermissions = await createUser();
+        const token = createAuthTokenByUserId(userWithoutPermissions.id);
+
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', token)
+          .send({ query })
+          .expect(200);
+
+        expect(response.body.errors).toBeDefined();
+        expect(response.body.errors[0].message).toEqual('Not authorized!');
+      });
+    });
+
+    describe('and with correct permission and isCreator condition', () => {
+      let role: IRole,
+        currentUser: IUser,
+        anotherUser: IUser,
+        token: string,
+        requestObject: Test,
+        flowOne: IFlow,
+        stepOneForFlowOne: IStep,
+        stepTwoForFlowOne: IStep,
+        executionOne: IExecution,
+        executionStepOneForExecutionOne: IExecutionStep,
+        executionStepTwoForExecutionOne: IExecutionStep,
+        flowTwo: IFlow,
+        stepOneForFlowTwo: IStep,
+        stepTwoForFlowTwo: IStep,
+        executionTwo: IExecution,
+        executionStepOneForExecutionTwo: IExecutionStep,
+        executionStepTwoForExecutionTwo: IExecutionStep;
+
+      beforeEach(async () => {
+        role = await createRole({
+          key: 'sample',
+          name: 'sample',
+        });
+
+        await createPermission({
+          action: 'read',
+          subject: 'Execution',
+          roleId: role.id,
+          conditions: ['isCreator'],
+        });
+
+        currentUser = await createUser({
+          roleId: role.id,
+          fullName: 'Current User',
+        });
+
+        anotherUser = await createUser();
+
+        token = createAuthTokenByUserId(currentUser.id);
+
+        flowOne = await createFlow({
+          userId: currentUser.id,
+        });
+
+        stepOneForFlowOne = await createStep({
+          flowId: flowOne.id,
+        });
+
+        stepTwoForFlowOne = await createStep({
+          flowId: flowOne.id,
+        });
+
+        executionOne = await createExecution({
+          flowId: flowOne.id,
+        });
+
+        executionStepOneForExecutionOne = await createExecutionStep({
+          executionId: executionOne.id,
+          stepId: stepOneForFlowOne.id,
+          status: 'success',
+        });
+
+        executionStepTwoForExecutionOne = await createExecutionStep({
+          executionId: executionOne.id,
+          stepId: stepTwoForFlowOne.id,
+          status: 'success',
+        });
+
+        flowTwo = await createFlow({
+          userId: currentUser.id,
+        });
+
+        stepOneForFlowTwo = await createStep({
+          flowId: flowTwo.id,
+        });
+
+        stepTwoForFlowTwo = await createStep({
+          flowId: flowTwo.id,
+        });
+
+        executionTwo = await createExecution({
+          flowId: flowTwo.id,
+        });
+
+        executionStepOneForExecutionTwo = await createExecutionStep({
+          executionId: executionTwo.id,
+          stepId: stepOneForFlowTwo.id,
+          status: 'success',
+        });
+
+        executionStepTwoForExecutionTwo = await createExecutionStep({
+          executionId: executionTwo.id,
+          stepId: stepTwoForFlowTwo.id,
+          status: 'failure',
+        });
+      });
+
+      it('should return executions data of the current user', async () => {
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', token)
+          .send({ query })
+          .expect(200);
+
+        const expectedResponsePayload = {
+          data: {
+            getExecutions: {
+              edges: [
+                {
+                  node: {
+                    createdAt: (flowTwo.createdAt as Date).getTime().toString(),
+                    flow: {
+                      active: flowTwo.active,
+                      id: flowTwo.id,
+                      name: flowTwo.name,
+                      steps: [
+                        {
+                          iconUrl: `${appConfig.baseUrl}/apps/${stepTwoForFlowTwo.appKey}/assets/favicon.svg`,
+                        },
+                        {
+                          iconUrl: `${appConfig.baseUrl}/apps/${stepTwoForFlowTwo.appKey}/assets/favicon.svg`,
+                        },
+                      ],
+                    },
+                    id: executionTwo.id,
+                    status: 'failure',
+                    testRun: executionTwo.testRun,
+                    updatedAt: (executionTwo.updatedAt as Date)
+                      .getTime()
+                      .toString(),
+                  },
+                },
+                {
+                  node: {
+                    createdAt: (flowOne.createdAt as Date).getTime().toString(),
+                    flow: {
+                      active: flowOne.active,
+                      id: flowOne.id,
+                      name: flowOne.name,
+                      steps: [
+                        {
+                          iconUrl: `${appConfig.baseUrl}/apps/${stepOneForFlowOne.appKey}/assets/favicon.svg`,
+                        },
+                        {
+                          iconUrl: `${appConfig.baseUrl}/apps/${stepTwoForFlowOne.appKey}/assets/favicon.svg`,
+                        },
+                      ],
+                    },
+                    id: executionOne.id,
+                    status: 'success',
+                    testRun: executionOne.testRun,
+                    updatedAt: (executionOne.updatedAt as Date)
+                      .getTime()
+                      .toString(),
+                  },
+                },
+              ],
+              pageInfo: { currentPage: 1, totalPages: 1 },
+            },
+          },
+        };
+
+        expect(response.body).toEqual(expectedResponsePayload);
+      });
+
+      // it('should not return users data with password', async () => {
+      //   const query = `
+      //     query {
+      //       getUsers(limit: 10, offset: 0) {
+      //         pageInfo {
+      //           currentPage
+      //           totalPages
+      //         }
+      //         totalCount
+      //         edges {
+      //           node {
+      //             id
+      //             fullName
+      //             password
+      //           }
+      //         }
+      //       }
+      //     }
+      //   `;
+
+      //   const response = await requestObject.send({ query }).expect(400);
+
+      //   expect(response.body.errors).toBeDefined();
+      //   expect(response.body.errors[0].message).toEqual(
+      //     'Cannot query field "password" on type "User".'
+      //   );
+      // });
+    });
+  });
+});

packages/backend/src/graphql/queries/get-executions.ts

@@ -1,11 +1,22 @@
 import { raw } from 'objection';
+import { DateTime } from 'luxon';
 import Context from '../../types/express/context';
 import Execution from '../../models/execution';
 import paginate from '../../helpers/pagination';
 
+type Filters = {
+  flowId?: string;
+  status?: string;
+  updatedAt?: {
+    from?: string;
+    to?: string;
+  };
+};
+
 type Params = {
   limit: number;
   offset: number;
+  filters?: Filters;
 };
 
 const getExecutions = async (
@@ -15,9 +26,13 @@ const getExecutions = async (
 ) => {
   const conditions = context.currentUser.can('read', 'Execution');
 
+  const filters = params.filters;
+
   const userExecutions = context.currentUser.$relatedQuery('executions');
   const allExecutions = Execution.query();
-  const executionBaseQuery = conditions.isCreator ? userExecutions : allExecutions;
+  const executionBaseQuery = conditions.isCreator
+    ? userExecutions
+    : allExecutions;
 
   const selectStatusStatement = `
     case
@@ -32,16 +47,44 @@ const getExecutions = async (
     .clone()
     .joinRelated('executionSteps as execution_steps')
     .select('executions.*', raw(selectStatusStatement))
+    .groupBy('executions.id')
+    .orderBy('updated_at', 'desc');
+
+  const computedExecutions = Execution.query()
+    .with('executions', executions)
     .withSoftDeleted()
     .withGraphFetched({
       flow: {
         steps: true,
       },
-    })
+    });
-    .groupBy('executions.id')
-    .orderBy('updated_at', 'desc');
 
-  return paginate(executions, params.limit, params.offset);
+  if (filters?.flowId) {
+    computedExecutions.where('executions.flow_id', filters.flowId);
+  }
+
+  if (filters?.status) {
+    computedExecutions.where('executions.status', filters.status);
+  }
+
+  if (filters?.updatedAt) {
+    const updatedAtFilter = filters.updatedAt;
+    if (updatedAtFilter.from) {
+      const isoFromDateTime = DateTime.fromMillis(
+        parseInt(updatedAtFilter.from, 10)
+      ).toISO();
+      computedExecutions.where('executions.updated_at', '>=', isoFromDateTime);
+    }
+
+    if (updatedAtFilter.to) {
+      const isoToDateTime = DateTime.fromMillis(
+        parseInt(updatedAtFilter.to, 10)
+      ).toISO();
+      computedExecutions.where('executions.updated_at', '<=', isoToDateTime);
+    }
+  }
+
+  return paginate(computedExecutions, params.limit, params.offset);
 };
 
 export default getExecutions;

packages/backend/src/graphql/schema.graphql

@@ -20,7 +20,11 @@ type Query {
   ): FlowConnection
   getStepWithTestExecutions(stepId: String!): [Step]
   getExecution(executionId: String!): Execution
-  getExecutions(limit: Int!, offset: Int!): ExecutionConnection
+  getExecutions(
+    limit: Int!
+    offset: Int!
+    filters: ExecutionFiltersInput
+  ): ExecutionConnection
   getExecutionSteps(
     executionId: String!
     limit: Int!
@@ -795,6 +799,17 @@ type Notification {
   description: String
 }
 
+input ExecutionUpdatedAtFilterInput {
+  from: String
+  to: String
+}
+
+input ExecutionFiltersInput {
+  flowId: String
+  updatedAt: ExecutionUpdatedAtFilterInput
+  status: String
+}
+
 schema {
   query: Query
   mutation: Mutation

packages/backend/test/factories/permission.ts

@@ -1,24 +1,15 @@
-import { IPermission } from '@automatisch/types';
+import Permission from '../../src/models/permission';
 import { createRole } from './role';
 
-type PermissionParams = {
+export const createPermission = async (params: Partial<Permission> = {}) => {
-  roleId?: string;
+  params.roleId = params?.roleId || (await createRole()).id;
-  action?: string;
+  params.action = params?.action || 'read';
-  subject?: string;
+  params.subject = params?.subject || 'User';
-};
+  params.conditions = params?.conditions || ['isCreator'];
-
-export const createPermission = async (
-  params: PermissionParams = {}
-): Promise<IPermission> => {
-  const permissionData = {
-    roleId: params?.roleId || (await createRole()).id,
-    action: params?.action || 'read',
-    subject: params?.subject || 'User',
-  };
 
   const [permission] = await global.knex
     .table('permissions')
-    .insert(permissionData)
+    .insert(params)
     .returning('*');
 
   return permission;

packages/backend/test/factories/step.ts

@@ -13,7 +13,9 @@ export const createStep = async (params: Partial<Step> = {}) => {
     .first();
 
   params.position = params?.position || (lastStep?.position || 0) + 1;
-  params.status = params?.status || 'incomplete';
+  params.status = params?.status || 'completed';
+  params.appKey =
+    params?.appKey || (params.type === 'action' ? 'webhook' : 'deepl');
 
   const [step] = await global.knex.table('steps').insert(params).returning('*');
 

packages/types/index.d.ts

@@ -51,8 +51,8 @@ export interface IExecution {
   testRun: boolean;
   status: 'success' | 'failure';
   executionSteps: IExecutionStep[];
-  updatedAt: string;
+  updatedAt: string | Date;
-  createdAt: string;
+  createdAt: string | Date;
 }
 
 export interface IStep {
@@ -83,8 +83,8 @@ export interface IFlow {
   active: boolean;
   status: 'paused' | 'published' | 'draft';
   steps: IStep[];
-  createdAt: string;
+  createdAt: string | Date;
-  updatedAt: string;
+  updatedAt: string | Date;
   remoteWebhookId: string;
   lastInternalId: () => Promise<string>;
 }