test: Implement getExecutions graphQL query tests

packages/backend/src/apps/trello/dynamic-data/index.ts

@@ -1,4 +0,0 @@
-import listBoardLists from './list-board-lists';
-import listBoards from './list-boards';
-
-export default [listBoardLists, listBoards];

packages/backend/src/apps/trello/dynamic-data/list-board-lists/index.ts

@@ -1,33 +0,0 @@
-import { IGlobalVariable, IJSONObject } from '@automatisch/types';
-
-export default {
-  name: 'List board lists',
-  key: 'listBoardLists',
-
-  async run($: IGlobalVariable) {
-    const boards: {
-      data: IJSONObject[];
-    } = {
-      data: [],
-    };
-
-    const boardId = $.step.parameters.boardId;
-
-    if (!boardId) {
-      return { data: [] };
-    }
-
-    const { data } = await $.http.get(`/1/boards/${boardId}/lists`);
-
-    if (data) {
-      for (const list of data) {
-        boards.data.push({
-          value: list.id,
-          name: list.name,
-        });
-      }
-    }
-
-    return boards;
-  },
-};

packages/backend/src/apps/trello/dynamic-data/list-boards/index.ts

@@ -1,29 +0,0 @@
-import { IGlobalVariable, IJSONObject } from '@automatisch/types';
-
-export default {
-  name: 'List boards',
-  key: 'listBoards',
-
-  async run($: IGlobalVariable) {
-    const boards: {
-      data: IJSONObject[];
-    } = {
-      data: [],
-    };
-
-    const { data } = await $.http.get(`/1/members/me/boards`);
-
-    if (data) {
-      for (const board of data) {
-        boards.data.push({
-          value: board.id,
-          name: board.name,
-        });
-      }
-    } else {
-      return { data: [] };
-    }
-
-    return boards;
-  },
-};

packages/backend/src/apps/trello/index.ts

@@ -1,8 +1,6 @@
 import defineApp from '../../helpers/define-app';
 import addAuthHeader from './common/add-auth-header';
 import auth from './auth';
-import triggers from './triggers';
-import dynamicData from './dynamic-data';
 
 export default defineApp({
   name: 'Trello',
@@ -15,6 +13,4 @@ export default defineApp({
   primaryColor: '0079bf',
   beforeRequest: [addAuthHeader],
   auth,
-  triggers,
-  dynamicData,
 });

packages/backend/src/apps/trello/triggers/index.ts

@@ -1,3 +0,0 @@
-import newCards from './new-cards';
-
-export default [newCards];

packages/backend/src/apps/trello/triggers/new-cards/index.ts

@@ -1,123 +0,0 @@
-import defineTrigger from '../../../../helpers/define-trigger';
-
-export default defineTrigger({
-  name: 'New cards',
-  key: 'newCards',
-  pollInterval: 15,
-  description: 'Triggers upon the addition of a new card.',
-  arguments: [
-    {
-      label: 'Board',
-      key: 'boardId',
-      type: 'dropdown' as const,
-      required: false,
-      description:
-        'Selecting a board initiates the trigger for newly added cards on that board.',
-      variables: true,
-      source: {
-        type: 'query',
-        name: 'getDynamicData',
-        arguments: [
-          {
-            name: 'key',
-            value: 'listBoards',
-          },
-        ],
-      },
-    },
-    {
-      label: 'List',
-      key: 'listId',
-      type: 'dropdown' as const,
-      required: false,
-      dependsOn: ['parameters.boardId'],
-      description: 'Requires to opt for a board.',
-      variables: true,
-      source: {
-        type: 'query',
-        name: 'getDynamicData',
-        arguments: [
-          {
-            name: 'key',
-            value: 'listBoardLists',
-          },
-          {
-            name: 'parameters.boardId',
-            value: '{parameters.boardId}',
-          },
-        ],
-      },
-    },
-    {
-      label: 'Filter',
-      key: 'filter',
-      type: 'dropdown' as const,
-      required: false,
-      description: 'Default is open.',
-      variables: true,
-      options: [
-        {
-          label: 'open',
-          value: 'open',
-        },
-        {
-          label: 'closed',
-          value: 'closed',
-        },
-        {
-          label: 'all',
-          value: 'all',
-        },
-      ],
-    },
-  ],
-
-  async run($) {
-    const { boardId, listId, filter } = $.step.parameters;
-
-    if (boardId && !listId) {
-      const cardFilter = filter || 'open';
-
-      const { data } = await $.http.get(
-        `/1/boards/${boardId}/cards/${cardFilter}`
-      );
-
-      if (data) {
-        for (const card of data) {
-          $.pushTriggerItem({
-            raw: card,
-            meta: {
-              internalId: card.id,
-            },
-          });
-        }
-      }
-    } else if (listId) {
-      const { data } = await $.http.get(`1/lists/${listId}/cards`);
-
-      if (data) {
-        for (const card of data) {
-          $.pushTriggerItem({
-            raw: card,
-            meta: {
-              internalId: card.id,
-            },
-          });
-        }
-      }
-    } else {
-      const { data } = await $.http.get(`/1/members/me/cards`);
-
-      if (data) {
-        for (const card of data) {
-          $.pushTriggerItem({
-            raw: card,
-            meta: {
-              internalId: card.id,
-            },
-          });
-        }
-      }
-    }
-  },
-});

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/src/models/user.ts

@@ -275,10 +275,7 @@ class User extends Base {
   async $beforeUpdate(opt: ModelOptions, queryContext: QueryContext) {
     await super.$beforeUpdate(opt, queryContext);
 
-    if (this.email) {
     this.email = this.email.toLowerCase();
-    }
-
     await this.generateHash();
   }
 

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 = {
-  roleId?: string;
-  action?: string;
-  subject?: string;
-};
-
-export const createPermission = async (
-  params: PermissionParams = {}
-): Promise<IPermission> => {
-  const permissionData = {
-    roleId: params?.roleId || (await createRole()).id,
-    action: params?.action || 'read',
-    subject: params?.subject || 'User',
-  };
+export const createPermission = async (params: Partial<Permission> = {}) => {
+  params.roleId = params?.roleId || (await createRole()).id;
+  params.action = params?.action || 'read';
+  params.subject = params?.subject || 'User';
+  params.conditions = params?.conditions || ['isCreator'];
 
   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/docs/pages/.vitepress/config.js

@@ -377,10 +377,7 @@ export default defineConfig({
           text: 'Trello',
           collapsible: true,
           collapsed: true,
-          items: [
-            { text: 'Triggers', link: '/apps/trello/triggers' },
-            { text: 'Connection', link: '/apps/trello/connection' },
-          ],
+          items: [{ text: 'Connection', link: '/apps/trello/connection' }],
         },
         {
           text: 'Twilio',

packages/docs/pages/apps/trello/triggers.md

@@ -1,12 +0,0 @@
----
-favicon: /favicons/trello.svg
-items:
-  - name: New cards
-    desc: Triggers upon the addition of a new card.
----
-
-<script setup>
-  import CustomListing from '../../components/CustomListing.vue'
-</script>
-
-<CustomListing />

packages/docs/pages/guide/available-apps.md

@@ -39,7 +39,6 @@ The following integrations are currently supported by Automatisch.
 - [Stripe](/apps/stripe/triggers)
 - [Telegram](/apps/telegram-bot/actions)
 - [Todoist](/apps/todoist/triggers)
-- [Trello](/apps/trello/triggers)
 - [Twilio](/apps/twilio/triggers)
 - [Twitter](/apps/twitter/triggers)
 - [Typeform](/apps/typeform/triggers)

packages/e2e-tests/fixtures/applications-modal.js

@@ -13,9 +13,9 @@ export class ApplicationsModal extends BasePage {
   constructor (page) {
     super(page);
     this.modal = page.getByTestId('add-app-connection-dialog');
-    this.searchInput = this.modal.getByTestId('search-for-app-text-field');
-    this.appListItem = this.modal.getByTestId('app-list-item');
-    this.appLoader = this.modal.getByTestId('search-for-app-loader');
+    this.searchInput = page.getByTestId('search-for-app-text-field');
+    this.appListItem = page.getByTestId('app-list-item');
+    this.appLoader = page.getByTestId('search-for-app-loader');
   }
 
   /**

packages/e2e-tests/tests/app-integrations/github.spec.js

@@ -9,7 +9,7 @@ test('Github OAuth integration', async ({ page, applicationsPage }) => {
         await page.waitForURL('/apps');
       }
       const connectionModal = await applicationsPage.openAddConnectionModal();
-      await expect(connectionModal.modal).toBeVisible();
+      expect(connectionModal.modal).toBeVisible();
       return await connectionModal.selectLink('github');
     }
   );
@@ -18,7 +18,7 @@ test('Github OAuth integration', async ({ page, applicationsPage }) => {
     'Ensure the github connection modal is visible',
     async () => {
       const connectionModal = githubConnectionPage.addConnectionModal;
-      await expect(connectionModal.modal).toBeVisible();
+      expect(connectionModal.modal).toBeVisible();
       return connectionModal;
     }
   );
@@ -35,9 +35,9 @@ test('Github OAuth integration', async ({ page, applicationsPage }) => {
   );
 
   await test.step('Ensure github popup is not a 404', async () => {
-    // await expect(githubPopup).toBeVisible();
+    // expect(githubPopup).toBeVisible();
     const title = await githubPopup.title();
-    await expect(title).not.toMatch(/^Page not found/);
+    expect(title).not.toMatch(/^Page not found/);
   });
 
   /* Skip these in CI

packages/types/index.d.ts

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

packages/web/src/components/AddNewAppConnection/index.tsx

@@ -74,12 +74,7 @@ export default function AddNewAppConnection(
   }, []);
 
   return (
-    <Dialog
-      open={true}
-      onClose={onClose}
-      maxWidth="sm"
-      fullWidth
-      data-test="add-app-connection-dialog">
+    <Dialog open={true} onClose={onClose} maxWidth="sm" fullWidth>
       <DialogTitle>{formatMessage('apps.addNewAppConnection')}</DialogTitle>
 
       <Box px={3}>