fix: Do not use context explicitly for docs-change file

feat: Add docs change CI workflow to detect changes

.github/workflows/docs-change.yml

@@ -0,0 +1,32 @@
+name: Automatisch Docs Change
+on:
+  pull_request:
+    paths:
+      - 'packages/docs/**'
+jobs:
+  label:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+      - name: Label PR
+        uses: actions/github-script@v6
+        with:
+          script: |
+            const { pull_request } = context.payload;
+
+            const label = 'documentation-change';
+            const hasLabel = pull_request.labels.some(({ name }) => name === label);
+
+            if (!hasLabel) {
+              await github.rest.issues.addLabels({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: pull_request.number,
+                labels: [label],
+              });
+
+              console.log(`Label "${label}" added to PR #${pull_request.number}`);
+            } else {
+              console.log(`Label "${label}" already exists on PR #${pull_request.number}`);
+            }

packages/backend/src/apps/webhook/actions/index.js

@@ -0,0 +1,3 @@
+import respondWith from './respond-with/index.js';
+
+export default [respondWith];

packages/backend/src/apps/webhook/actions/respond-with/index.js

@@ -0,0 +1,38 @@
+import defineAction from '../../../../helpers/define-action.js';
+
+export default defineAction({
+  name: 'Respond with',
+  key: 'respondWith',
+  description: 'Respond with defined JSON body.',
+  arguments: [
+    {
+      label: 'Status code',
+      key: 'statusCode',
+      type: 'string',
+      required: true,
+      variables: true,
+      value: '200',
+    },
+    {
+      label: 'JSON body',
+      key: 'stringifiedJsonBody',
+      type: 'string',
+      required: true,
+      description: 'The content of the JSON body. It must be a valid JSON.',
+      variables: true,
+    },
+  ],
+
+  async run($) {
+    const parsedStatusCode = parseInt($.step.parameters.statusCode, 10);
+    const stringifiedJsonBody = $.step.parameters.stringifiedJsonBody;
+    const parsedJsonBody = JSON.parse(stringifiedJsonBody);
+
+    $.setActionItem({
+      raw: {
+        body: parsedJsonBody,
+        statusCode: parsedStatusCode,
+      },
+    });
+  },
+});

packages/backend/src/apps/webhook/index.js

@@ -1,4 +1,5 @@
 import defineApp from '../../helpers/define-app.js';
+import actions from './actions/index.js';
 import triggers from './triggers/index.js';
 
 export default defineApp({
@@ -10,5 +11,6 @@ export default defineApp({
   baseUrl: '',
   apiBaseUrl: '',
   primaryColor: '0059F7',
+  actions,
   triggers,
 });

packages/backend/src/apps/webhook/triggers/catch-raw-webhook/index.js

@@ -7,7 +7,20 @@ export default defineTrigger({
   key: 'catchRawWebhook',
   type: 'webhook',
   showWebhookUrl: true,
-  description: 'Triggers when the webhook receives a request.',
+  description:
+    'Triggers (immediately if configured) when the webhook receives a request.',
+  arguments: [
+    {
+      label: 'Wait until flow is done',
+      key: 'workSynchronously',
+      type: 'dropdown',
+      required: true,
+      options: [
+        { label: 'Yes', value: true },
+        { label: 'No', value: false },
+      ],
+    },
+  ],
 
   async run($) {
     const dataItem = {

packages/backend/src/controllers/api/v1/admin/saml-auth-providers/get-role-mappings.ee.js

@@ -0,0 +1,14 @@
+import { renderObject } from '../../../../../helpers/renderer.js';
+import SamlAuthProvider from '../../../../../models/saml-auth-provider.ee.js';
+
+export default async (request, response) => {
+  const samlAuthProvider = await SamlAuthProvider.query()
+    .findById(request.params.samlAuthProviderId)
+    .throwIfNotFound();
+
+  const roleMappings = await samlAuthProvider
+    .$relatedQuery('samlAuthProvidersRoleMappings')
+    .orderBy('remote_role_name', 'asc');
+
+  renderObject(response, roleMappings);
+};

packages/backend/src/controllers/api/v1/admin/saml-auth-providers/get-role-mappings.ee.test.js

@@ -0,0 +1,51 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import app from '../../../../../app.js';
+import createAuthTokenByUserId from '../../../../../helpers/create-auth-token-by-user-id.js';
+import { createRole } from '../../../../../../test/factories/role.js';
+import { createUser } from '../../../../../../test/factories/user.js';
+import { createSamlAuthProvider } from '../../../../../../test/factories/saml-auth-provider.ee.js';
+import { createRoleMapping } from '../../../../../../test/factories/role-mapping.js';
+import getRoleMappingsMock from '../../../../../../test/mocks/rest/api/v1/admin/saml-auth-providers/get-role-mappings.ee.js';
+import * as license from '../../../../../helpers/license.ee.js';
+
+describe('GET /api/v1/admin/saml-auth-providers/:samlAuthProviderId/role-mappings', () => {
+  let roleMappingOne, roleMappingTwo, samlAuthProvider, currentUser, token;
+
+  beforeEach(async () => {
+    const role = await createRole({ key: 'admin' });
+    currentUser = await createUser({ roleId: role.id });
+
+    samlAuthProvider = await createSamlAuthProvider();
+
+    roleMappingOne = await createRoleMapping({
+      samlAuthProviderId: samlAuthProvider.id,
+      remoteRoleName: 'Admin',
+    });
+
+    roleMappingTwo = await createRoleMapping({
+      samlAuthProviderId: samlAuthProvider.id,
+      remoteRoleName: 'User',
+    });
+
+    token = createAuthTokenByUserId(currentUser.id);
+  });
+
+  it('should return role mappings', async () => {
+    vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
+
+    const response = await request(app)
+      .get(
+        `/api/v1/admin/saml-auth-providers/${samlAuthProvider.id}/role-mappings`
+      )
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedPayload = await getRoleMappingsMock([
+      roleMappingOne,
+      roleMappingTwo,
+    ]);
+
+    expect(response.body).toEqual(expectedPayload);
+  });
+});

packages/backend/src/controllers/api/v1/admin/saml-auth-providers/get-saml-auth-provider.ee.js

@@ -6,5 +6,7 @@ export default async (request, response) => {
     .findById(request.params.samlAuthProviderId)
     .throwIfNotFound();
 
-  renderObject(response, samlAuthProvider);
+  renderObject(response, samlAuthProvider, {
+    serializer: 'AdminSamlAuthProvider',
+  });
 };

packages/backend/src/controllers/api/v1/admin/saml-auth-providers/get-saml-auth-providers.ee.js

@@ -7,5 +7,7 @@ export default async (request, response) => {
     'desc'
   );
 
-  renderObject(response, samlAuthProviders);
+  renderObject(response, samlAuthProviders, {
+    serializer: 'AdminSamlAuthProvider',
+  });
 };

packages/backend/src/controllers/api/v1/app-configs/get-app-config.ee.js

@@ -0,0 +1,12 @@
+import { renderObject } from '../../../../helpers/renderer.js';
+import AppConfig from '../../../../models/app-config.js';
+
+export default async (request, response) => {
+  const appConfig = await AppConfig.query()
+    .findOne({
+      key: request.params.appKey,
+    })
+    .throwIfNotFound();
+
+  renderObject(response, appConfig);
+};

packages/backend/src/controllers/api/v1/app-configs/get-app-config.ee.test.js

@@ -0,0 +1,44 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import app from '../../../../app.js';
+import createAuthTokenByUserId from '../../../../helpers/create-auth-token-by-user-id.js';
+import { createUser } from '../../../../../test/factories/user.js';
+import getAppConfigMock from '../../../../../test/mocks/rest/api/v1/app-configs/get-app-config.js';
+import { createAppConfig } from '../../../../../test/factories/app-config.js';
+import * as license from '../../../../helpers/license.ee.js';
+
+describe('GET /api/v1/app-configs/:appKey', () => {
+  let currentUser, appConfig, token;
+
+  beforeEach(async () => {
+    vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
+
+    currentUser = await createUser();
+
+    appConfig = await createAppConfig({
+      key: 'deepl',
+      allowCustomConnection: true,
+      shared: true,
+      disabled: false,
+    });
+
+    token = createAuthTokenByUserId(currentUser.id);
+  });
+
+  it('should return specified app config info', async () => {
+    const response = await request(app)
+      .get(`/api/v1/app-configs/${appConfig.key}`)
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedPayload = getAppConfigMock(appConfig);
+    expect(response.body).toEqual(expectedPayload);
+  });
+
+  it('should return not found response for not existing app key', async () => {
+    await request(app)
+      .get('/api/v1/app-configs/not-existing-app-key')
+      .set('Authorization', token)
+      .expect(404);
+  });
+});

packages/backend/src/controllers/api/v1/apps/get-flows.js

@@ -0,0 +1,23 @@
+import { renderObject } from '../../../../helpers/renderer.js';
+import App from '../../../../models/app.js';
+import paginateRest from '../../../../helpers/pagination-rest.js';
+
+export default async (request, response) => {
+  const app = await App.findOneByKey(request.params.appKey);
+
+  const flowsQuery = request.currentUser.authorizedFlows
+    .clone()
+    .joinRelated({
+      steps: true,
+    })
+    .withGraphFetched({
+      steps: true,
+    })
+    .where('steps.app_key', app.key)
+    .orderBy('active', 'desc')
+    .orderBy('updated_at', 'desc');
+
+  const flows = await paginateRest(flowsQuery, request.query.page);
+
+  renderObject(response, flows);
+};

packages/backend/src/controllers/api/v1/apps/get-flows.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import app from '../../../../app.js';
+import createAuthTokenByUserId from '../../../../helpers/create-auth-token-by-user-id.js';
+import { createUser } from '../../../../../test/factories/user.js';
+import { createFlow } from '../../../../../test/factories/flow.js';
+import { createStep } from '../../../../../test/factories/step.js';
+import { createPermission } from '../../../../../test/factories/permission.js';
+import getFlowsMock from '../../../../../test/mocks/rest/api/v1/flows/get-flows.js';
+
+describe('GET /api/v1/apps/:appKey/flows', () => {
+  let currentUser, currentUserRole, token;
+
+  beforeEach(async () => {
+    currentUser = await createUser();
+    currentUserRole = await currentUser.$relatedQuery('role');
+
+    token = createAuthTokenByUserId(currentUser.id);
+  });
+
+  it('should return the flows data of specified app for current user', async () => {
+    const currentUserFlowOne = await createFlow({ userId: currentUser.id });
+
+    const triggerStepFlowOne = await createStep({
+      flowId: currentUserFlowOne.id,
+      type: 'trigger',
+      appKey: 'webhook',
+    });
+
+    const actionStepFlowOne = await createStep({
+      flowId: currentUserFlowOne.id,
+      type: 'action',
+    });
+
+    const currentUserFlowTwo = await createFlow({ userId: currentUser.id });
+
+    await createStep({
+      flowId: currentUserFlowTwo.id,
+      type: 'trigger',
+      appKey: 'github',
+    });
+
+    await createStep({
+      flowId: currentUserFlowTwo.id,
+      type: 'action',
+    });
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: ['isCreator'],
+    });
+
+    const response = await request(app)
+      .get('/api/v1/apps/webhook/flows')
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedPayload = await getFlowsMock(
+      [currentUserFlowOne],
+      [triggerStepFlowOne, actionStepFlowOne]
+    );
+
+    expect(response.body).toEqual(expectedPayload);
+  });
+
+  it('should return the flows data of specified app for another user', async () => {
+    const anotherUser = await createUser();
+    const anotherUserFlowOne = await createFlow({ userId: anotherUser.id });
+
+    const triggerStepFlowOne = await createStep({
+      flowId: anotherUserFlowOne.id,
+      type: 'trigger',
+      appKey: 'webhook',
+    });
+
+    const actionStepFlowOne = await createStep({
+      flowId: anotherUserFlowOne.id,
+      type: 'action',
+    });
+
+    const anotherUserFlowTwo = await createFlow({ userId: anotherUser.id });
+
+    await createStep({
+      flowId: anotherUserFlowTwo.id,
+      type: 'trigger',
+      appKey: 'github',
+    });
+
+    await createStep({
+      flowId: anotherUserFlowTwo.id,
+      type: 'action',
+    });
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    const response = await request(app)
+      .get('/api/v1/apps/webhook/flows')
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedPayload = await getFlowsMock(
+      [anotherUserFlowOne],
+      [triggerStepFlowOne, actionStepFlowOne]
+    );
+
+    expect(response.body).toEqual(expectedPayload);
+  });
+
+  it('should return not found response for invalid app key', async () => {
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: ['isCreator'],
+    });
+
+    await request(app)
+      .get('/api/v1/apps/invalid-app-key/flows')
+      .set('Authorization', token)
+      .expect(404);
+  });
+});

packages/backend/src/controllers/api/v1/automatisch/config.ee.js

@@ -0,0 +1,24 @@
+import appConfig from '../../../../config/app.js';
+import Config from '../../../../models/config.js';
+import { renderObject } from '../../../../helpers/renderer.js';
+
+export default async (request, response) => {
+  const defaultConfig = {
+    disableNotificationsPage: appConfig.disableNotificationsPage,
+    disableFavicon: appConfig.disableFavicon,
+    additionalDrawerLink: appConfig.additionalDrawerLink,
+    additionalDrawerLinkText: appConfig.additionalDrawerLinkText,
+  };
+
+  let config = await Config.query().orderBy('key', 'asc');
+
+  config = config.reduce((computedConfig, configEntry) => {
+    const { key, value } = configEntry;
+
+    computedConfig[key] = value?.data;
+
+    return computedConfig;
+  }, defaultConfig);
+
+  renderObject(response, config);
+};

packages/backend/src/controllers/api/v1/automatisch/config.ee.test.js

@@ -0,0 +1,51 @@
+import { vi, expect, describe, it } from 'vitest';
+import request from 'supertest';
+import { createConfig } from '../../../../../test/factories/config.js';
+import app from '../../../../app.js';
+import configMock from '../../../../../test/mocks/rest/api/v1/automatisch/config.js';
+import * as license from '../../../../helpers/license.ee.js';
+
+describe('GET /api/v1/automatisch/config', () => {
+  it('should return Automatisch config', async () => {
+    vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
+
+    const logoConfig = await createConfig({
+      key: 'logo.svgData',
+      value: { data: '<svg>Sample</svg>' },
+    });
+
+    const primaryDarkConfig = await createConfig({
+      key: 'palette.primary.dark',
+      value: { data: '#001F52' },
+    });
+
+    const primaryLightConfig = await createConfig({
+      key: 'palette.primary.light',
+      value: { data: '#4286FF' },
+    });
+
+    const primaryMainConfig = await createConfig({
+      key: 'palette.primary.main',
+      value: { data: '#0059F7' },
+    });
+
+    const titleConfig = await createConfig({
+      key: 'title',
+      value: { data: 'Sample Title' },
+    });
+
+    const response = await request(app)
+      .get('/api/v1/automatisch/config')
+      .expect(200);
+
+    const expectedPayload = configMock(
+      logoConfig,
+      primaryDarkConfig,
+      primaryLightConfig,
+      primaryMainConfig,
+      titleConfig
+    );
+
+    expect(response.body).toEqual(expectedPayload);
+  });
+});

packages/backend/src/controllers/api/v1/connections/get-flows.js

@@ -0,0 +1,20 @@
+import { renderObject } from '../../../../helpers/renderer.js';
+import paginateRest from '../../../../helpers/pagination-rest.js';
+
+export default async (request, response) => {
+  const flowsQuery = request.currentUser.authorizedFlows
+    .clone()
+    .joinRelated({
+      steps: true,
+    })
+    .withGraphFetched({
+      steps: true,
+    })
+    .where('steps.connection_id', request.params.connectionId)
+    .orderBy('active', 'desc')
+    .orderBy('updated_at', 'desc');
+
+  const flows = await paginateRest(flowsQuery, request.query.page);
+
+  renderObject(response, flows);
+};

packages/backend/src/controllers/api/v1/connections/get-flows.test.js

@@ -0,0 +1,128 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import app from '../../../../app.js';
+import createAuthTokenByUserId from '../../../../helpers/create-auth-token-by-user-id.js';
+import { createUser } from '../../../../../test/factories/user.js';
+import { createConnection } from '../../../../../test/factories/connection.js';
+import { createFlow } from '../../../../../test/factories/flow.js';
+import { createStep } from '../../../../../test/factories/step.js';
+import { createPermission } from '../../../../../test/factories/permission.js';
+import getFlowsMock from '../../../../../test/mocks/rest/api/v1/flows/get-flows.js';
+
+describe('GET /api/v1/connections/:connectionId/flows', () => {
+  let currentUser, currentUserRole, token;
+
+  beforeEach(async () => {
+    currentUser = await createUser();
+    currentUserRole = await currentUser.$relatedQuery('role');
+
+    token = createAuthTokenByUserId(currentUser.id);
+  });
+
+  it('should return the flows data of specified connection for current user', async () => {
+    const currentUserFlowOne = await createFlow({ userId: currentUser.id });
+
+    const currentUserConnection = await createConnection({
+      userId: currentUser.id,
+      key: 'webhook',
+    });
+
+    const triggerStepFlowOne = await createStep({
+      flowId: currentUserFlowOne.id,
+      type: 'trigger',
+      appKey: 'webhook',
+      connectionId: currentUserConnection.id,
+    });
+
+    const actionStepFlowOne = await createStep({
+      flowId: currentUserFlowOne.id,
+      type: 'action',
+    });
+
+    const currentUserFlowTwo = await createFlow({ userId: currentUser.id });
+
+    await createStep({
+      flowId: currentUserFlowTwo.id,
+      type: 'trigger',
+      appKey: 'github',
+    });
+
+    await createStep({
+      flowId: currentUserFlowTwo.id,
+      type: 'action',
+    });
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: ['isCreator'],
+    });
+
+    const response = await request(app)
+      .get(`/api/v1/connections/${currentUserConnection.id}/flows`)
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedPayload = await getFlowsMock(
+      [currentUserFlowOne],
+      [triggerStepFlowOne, actionStepFlowOne]
+    );
+
+    expect(response.body).toEqual(expectedPayload);
+  });
+
+  it('should return the flows data of specified connection for another user', async () => {
+    const anotherUser = await createUser();
+    const anotherUserFlowOne = await createFlow({ userId: anotherUser.id });
+
+    const anotherUserConnection = await createConnection({
+      userId: anotherUser.id,
+      key: 'webhook',
+    });
+
+    const triggerStepFlowOne = await createStep({
+      flowId: anotherUserFlowOne.id,
+      type: 'trigger',
+      appKey: 'webhook',
+      connectionId: anotherUserConnection.id,
+    });
+
+    const actionStepFlowOne = await createStep({
+      flowId: anotherUserFlowOne.id,
+      type: 'action',
+    });
+
+    const anotherUserFlowTwo = await createFlow({ userId: anotherUser.id });
+
+    await createStep({
+      flowId: anotherUserFlowTwo.id,
+      type: 'trigger',
+      appKey: 'github',
+    });
+
+    await createStep({
+      flowId: anotherUserFlowTwo.id,
+      type: 'action',
+    });
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    const response = await request(app)
+      .get(`/api/v1/connections/${anotherUserConnection.id}/flows`)
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedPayload = await getFlowsMock(
+      [anotherUserFlowOne],
+      [triggerStepFlowOne, actionStepFlowOne]
+    );
+
+    expect(response.body).toEqual(expectedPayload);
+  });
+});

packages/backend/src/controllers/api/v1/executions/get-execution.js

@@ -2,6 +2,7 @@ import { renderObject } from '../../../../helpers/renderer.js';
 
 export default async (request, response) => {
   const execution = await request.currentUser.authorizedExecutions
+    .clone()
     .withGraphFetched({
       flow: {
         steps: true,

packages/backend/src/controllers/api/v1/executions/get-executions.js

@@ -3,6 +3,7 @@ import paginateRest from '../../../../helpers/pagination-rest.js';
 
 export default async (request, response) => {
   const executionsQuery = request.currentUser.authorizedExecutions
+    .clone()
     .withSoftDeleted()
     .orderBy('created_at', 'desc')
     .withGraphFetched({

packages/backend/src/controllers/api/v1/flows/get-flow.js

@@ -2,6 +2,7 @@ import { renderObject } from '../../../../helpers/renderer.js';
 
 export default async (request, response) => {
   const flow = await request.currentUser.authorizedFlows
+    .clone()
     .withGraphJoined({ steps: true })
     .orderBy('steps.position', 'asc')
     .findOne({ 'flows.id': request.params.flowId })

packages/backend/src/controllers/api/v1/flows/get-flows.js

@@ -0,0 +1,21 @@
+import { renderObject } from '../../../../helpers/renderer.js';
+import paginateRest from '../../../../helpers/pagination-rest.js';
+
+export default async (request, response) => {
+  const flowsQuery = request.currentUser.authorizedFlows
+    .clone()
+    .withGraphFetched({
+      steps: true,
+    })
+    .where((builder) => {
+      if (request.query.name) {
+        builder.where('flows.name', 'ilike', `%${request.query.name}%`);
+      }
+    })
+    .orderBy('active', 'desc')
+    .orderBy('updated_at', 'desc');
+
+  const flows = await paginateRest(flowsQuery, request.query.page);
+
+  renderObject(response, flows);
+};

packages/backend/src/controllers/api/v1/flows/get-flows.test.js

@@ -0,0 +1,118 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import app from '../../../../app.js';
+import createAuthTokenByUserId from '../../../../helpers/create-auth-token-by-user-id';
+import { createUser } from '../../../../../test/factories/user';
+import { createFlow } from '../../../../../test/factories/flow';
+import { createStep } from '../../../../../test/factories/step';
+import { createPermission } from '../../../../../test/factories/permission';
+import getFlowsMock from '../../../../../test/mocks/rest/api/v1/flows/get-flows.js';
+
+describe('GET /api/v1/flows', () => {
+  let currentUser, currentUserRole, token;
+
+  beforeEach(async () => {
+    currentUser = await createUser();
+    currentUserRole = await currentUser.$relatedQuery('role');
+
+    token = createAuthTokenByUserId(currentUser.id);
+  });
+
+  it('should return the flows data of current user', async () => {
+    const currentUserFlowOne = await createFlow({ userId: currentUser.id });
+
+    const triggerStepFlowOne = await createStep({
+      flowId: currentUserFlowOne.id,
+      type: 'trigger',
+    });
+    const actionStepFlowOne = await createStep({
+      flowId: currentUserFlowOne.id,
+      type: 'action',
+    });
+
+    const currentUserFlowTwo = await createFlow({ userId: currentUser.id });
+
+    const triggerStepFlowTwo = await createStep({
+      flowId: currentUserFlowTwo.id,
+      type: 'trigger',
+    });
+    const actionStepFlowTwo = await createStep({
+      flowId: currentUserFlowTwo.id,
+      type: 'action',
+    });
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: ['isCreator'],
+    });
+
+    const response = await request(app)
+      .get('/api/v1/flows')
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedPayload = await getFlowsMock(
+      [currentUserFlowTwo, currentUserFlowOne],
+      [
+        triggerStepFlowOne,
+        actionStepFlowOne,
+        triggerStepFlowTwo,
+        actionStepFlowTwo,
+      ]
+    );
+
+    expect(response.body).toEqual(expectedPayload);
+  });
+
+  it('should return the flows data of another user', async () => {
+    const anotherUser = await createUser();
+
+    const anotherUserFlowOne = await createFlow({ userId: anotherUser.id });
+
+    const triggerStepFlowOne = await createStep({
+      flowId: anotherUserFlowOne.id,
+      type: 'trigger',
+    });
+    const actionStepFlowOne = await createStep({
+      flowId: anotherUserFlowOne.id,
+      type: 'action',
+    });
+
+    const anotherUserFlowTwo = await createFlow({ userId: anotherUser.id });
+
+    const triggerStepFlowTwo = await createStep({
+      flowId: anotherUserFlowTwo.id,
+      type: 'trigger',
+    });
+    const actionStepFlowTwo = await createStep({
+      flowId: anotherUserFlowTwo.id,
+      type: 'action',
+    });
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    const response = await request(app)
+      .get('/api/v1/flows')
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedPayload = await getFlowsMock(
+      [anotherUserFlowTwo, anotherUserFlowOne],
+      [
+        triggerStepFlowOne,
+        actionStepFlowOne,
+        triggerStepFlowTwo,
+        actionStepFlowTwo,
+      ]
+    );
+
+    expect(response.body).toEqual(expectedPayload);
+  });
+});

packages/backend/src/controllers/api/v1/saml-auth-providers/get-saml-auth-providers.ee.js

@@ -0,0 +1,12 @@
+import { renderObject } from '../../../../helpers/renderer.js';
+import SamlAuthProvider from '../../../../models/saml-auth-provider.ee.js';
+
+export default async (request, response) => {
+  const samlAuthProviders = await SamlAuthProvider.query()
+    .where({
+      active: true,
+    })
+    .orderBy('created_at', 'desc');
+
+  renderObject(response, samlAuthProviders);
+};

packages/backend/src/controllers/api/v1/saml-auth-providers/get-saml-auth-providers.ee.test.js

@@ -0,0 +1,30 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import app from '../../../../app.js';
+import { createSamlAuthProvider } from '../../../../../test/factories/saml-auth-provider.ee.js';
+import getSamlAuthProvidersMock from '../../../../../test/mocks/rest/api/v1/saml-auth-providers/get-saml-auth-providers.js';
+import * as license from '../../../../helpers/license.ee.js';
+
+describe('GET /api/v1/saml-auth-providers', () => {
+  let samlAuthProviderOne, samlAuthProviderTwo;
+
+  beforeEach(async () => {
+    samlAuthProviderOne = await createSamlAuthProvider();
+    samlAuthProviderTwo = await createSamlAuthProvider();
+  });
+
+  it('should return saml auth providers', async () => {
+    vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
+
+    const response = await request(app)
+      .get('/api/v1/saml-auth-providers')
+      .expect(200);
+
+    const expectedPayload = await getSamlAuthProvidersMock([
+      samlAuthProviderTwo,
+      samlAuthProviderOne,
+    ]);
+
+    expect(response.body).toEqual(expectedPayload);
+  });
+});

packages/backend/src/controllers/api/v1/steps/get-connection.js

@@ -0,0 +1,11 @@
+import { renderObject } from '../../../../helpers/renderer.js';
+
+export default async (request, response) => {
+  const step = await request.currentUser.authorizedSteps
+    .findById(request.params.stepId)
+    .throwIfNotFound();
+
+  const connection = await step.$relatedQuery('connection').throwIfNotFound();
+
+  renderObject(response, connection);
+};

packages/backend/src/controllers/api/v1/steps/get-connection.test.js

@@ -0,0 +1,121 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import Crypto from 'crypto';
+import app from '../../../../app.js';
+import createAuthTokenByUserId from '../../../../helpers/create-auth-token-by-user-id';
+import { createUser } from '../../../../../test/factories/user';
+import { createConnection } from '../../../../../test/factories/connection';
+import { createFlow } from '../../../../../test/factories/flow';
+import { createStep } from '../../../../../test/factories/step';
+import { createPermission } from '../../../../../test/factories/permission';
+import getConnectionMock from '../../../../../test/mocks/rest/api/v1/steps/get-connection';
+
+describe('GET /api/v1/steps/:stepId/connection', () => {
+  let currentUser, currentUserRole, token;
+
+  beforeEach(async () => {
+    currentUser = await createUser();
+    currentUserRole = await currentUser.$relatedQuery('role');
+
+    token = createAuthTokenByUserId(currentUser.id);
+  });
+
+  it('should return the current user connection data of specified step', async () => {
+    const currentUserflow = await createFlow({ userId: currentUser.id });
+
+    const currentUserConnection = await createConnection();
+    const triggerStep = await createStep({
+      flowId: currentUserflow.id,
+      connectionId: currentUserConnection.id,
+    });
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: ['isCreator'],
+    });
+
+    const response = await request(app)
+      .get(`/api/v1/steps/${triggerStep.id}/connection`)
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedPayload = await getConnectionMock(currentUserConnection);
+
+    expect(response.body).toEqual(expectedPayload);
+  });
+
+  it('should return the current user connection data of specified step', async () => {
+    const anotherUser = await createUser();
+    const anotherUserFlow = await createFlow({ userId: anotherUser.id });
+
+    const anotherUserConnection = await createConnection();
+    const triggerStep = await createStep({
+      flowId: anotherUserFlow.id,
+      connectionId: anotherUserConnection.id,
+    });
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    const response = await request(app)
+      .get(`/api/v1/steps/${triggerStep.id}/connection`)
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedPayload = await getConnectionMock(anotherUserConnection);
+
+    expect(response.body).toEqual(expectedPayload);
+  });
+
+  it('should return not found response for not existing step without connection', async () => {
+    const stepWithoutConnection = await createStep();
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    await request(app)
+      .get(`/api/v1/steps/${stepWithoutConnection.id}/connection`)
+      .set('Authorization', token)
+      .expect(404);
+  });
+
+  it('should return not found response for not existing step UUID', async () => {
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    const notExistingFlowUUID = Crypto.randomUUID();
+
+    await request(app)
+      .get(`/api/v1/steps/${notExistingFlowUUID}/connection`)
+      .set('Authorization', token)
+      .expect(404);
+  });
+
+  it('should return bad request response for invalid UUID', async () => {
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    await request(app)
+      .get('/api/v1/steps/invalidFlowUUID/connection')
+      .set('Authorization', token)
+      .expect(400);
+  });
+});

packages/backend/src/controllers/api/v1/users/get-plan-and-usage.ee.js

@@ -0,0 +1,7 @@
+import { renderObject } from '../../../../helpers/renderer.js';
+
+export default async (request, response) => {
+  const planAndUsage = await request.currentUser.getPlanAndUsage();
+
+  renderObject(response, planAndUsage);
+};

packages/backend/src/controllers/api/v1/users/get-plan-and-usage.ee.test.js

@@ -0,0 +1,68 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import app from '../../../../app.js';
+import createAuthTokenByUserId from '../../../../helpers/create-auth-token-by-user-id.js';
+import { createUser } from '../../../../../test/factories/user.js';
+import { createSubscription } from '../../../../../test/factories/subscription.js';
+import { createUsageData } from '../../../../../test/factories/usage-data.js';
+import appConfig from '../../../../config/app.js';
+import { DateTime } from 'luxon';
+
+describe('GET /api/v1/users/:userId/plan-and-usage', () => {
+  let user, token;
+
+  beforeEach(async () => {
+    const trialExpiryDate = DateTime.now().plus({ days: 30 }).toISODate();
+    user = await createUser({ trialExpiryDate });
+    token = createAuthTokenByUserId(user.id);
+
+    vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(true);
+  });
+
+  it('should return free trial plan and usage data', async () => {
+    const response = await request(app)
+      .get(`/api/v1/users/${user.id}/plan-and-usage`)
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedResponseData = {
+      plan: {
+        id: null,
+        limit: null,
+        name: 'Free Trial',
+      },
+      usage: {
+        task: 0,
+      },
+    };
+
+    expect(response.body.data).toEqual(expectedResponseData);
+  });
+
+  it('should return current plan and usage data', async () => {
+    await createSubscription({ userId: user.id });
+
+    await createUsageData({
+      userId: user.id,
+      consumedTaskCount: 1234,
+    });
+
+    const response = await request(app)
+      .get(`/api/v1/users/${user.id}/plan-and-usage`)
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedResponseData = {
+      plan: {
+        id: '47384',
+        limit: '10,000',
+        name: '10k - monthly',
+      },
+      usage: {
+        task: 1234,
+      },
+    };
+
+    expect(response.body.data).toEqual(expectedResponseData);
+  });
+});

packages/backend/src/controllers/api/v1/users/get-subscription.ee.js

@@ -0,0 +1,9 @@
+import { renderObject } from '../../../../helpers/renderer.js';
+
+export default async (request, response) => {
+  const subscription = await request.currentUser
+    .$relatedQuery('currentSubscription')
+    .throwIfNotFound();
+
+  renderObject(response, subscription);
+};

packages/backend/src/controllers/api/v1/users/get-subscription.ee.test.js

@@ -0,0 +1,51 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import appConfig from '../../../../config/app.js';
+import app from '../../../../app.js';
+import createAuthTokenByUserId from '../../../../helpers/create-auth-token-by-user-id';
+import { createRole } from '../../../../../test/factories/role';
+import { createUser } from '../../../../../test/factories/user';
+import { createSubscription } from '../../../../../test/factories/subscription.js';
+import getSubscriptionMock from '../../../../../test/mocks/rest/api/v1/users/get-subscription.js';
+
+describe('GET /api/v1/users/:userId/subscription', () => {
+  let currentUser, role, subscription, token;
+
+  beforeEach(async () => {
+    vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(true);
+
+    role = await createRole();
+
+    currentUser = await createUser({
+      roleId: role.id,
+    });
+
+    subscription = await createSubscription({ userId: currentUser.id });
+
+    token = createAuthTokenByUserId(currentUser.id);
+  });
+
+  it('should return subscription info of the current user', async () => {
+    const response = await request(app)
+      .get(`/api/v1/users/${currentUser.id}/subscription`)
+      .set('Authorization', token)
+      .expect(200);
+
+    const expectedPayload = getSubscriptionMock(subscription);
+
+    expect(response.body).toEqual(expectedPayload);
+  });
+
+  it('should return not found response if there is no current subscription', async () => {
+    const userWithoutSubscription = await createUser({
+      roleId: role.id,
+    });
+
+    const token = createAuthTokenByUserId(userWithoutSubscription.id);
+
+    await request(app)
+      .get(`/api/v1/users/${userWithoutSubscription.id}/subscription`)
+      .set('Authorization', token)
+      .expect(404);
+  });
+});

packages/backend/src/controllers/webhooks/handler-sync-by-flow-id.js

@@ -0,0 +1,31 @@
+import Flow from '../../models/flow.js';
+import logger from '../../helpers/logger.js';
+import handlerSync from '../../helpers/webhook-handler-sync.js';
+
+export default async (request, response) => {
+  const computedRequestPayload = {
+    headers: request.headers,
+    body: request.body,
+    query: request.query,
+    params: request.params,
+  };
+
+  logger.debug(`Handling incoming webhook request at ${request.originalUrl}.`);
+  logger.debug(JSON.stringify(computedRequestPayload, null, 2));
+
+  const flowId = request.params.flowId;
+  const flow = await Flow.query().findById(flowId).throwIfNotFound();
+  const triggerStep = await flow.getTriggerStep();
+
+  if (triggerStep.appKey !== 'webhook') {
+    const connection = await triggerStep.$relatedQuery('connection');
+
+    if (!(await connection.verifyWebhook(request))) {
+      return response.sendStatus(401);
+    }
+  }
+
+  await handlerSync(flowId, request, response);
+
+  response.sendStatus(204);
+};

packages/backend/src/graphql/mutations/delete-step.js

@@ -1,4 +1,4 @@
-import Step from '../../models/flow.js';
+import Step from '../../models/step.js';
 
 const deleteStep = async (_parent, params, context) => {
   const conditions = context.currentUser.can('update', 'Flow');

packages/backend/src/graphql/queries/get-app-config.ee.js

@@ -1,17 +0,0 @@
-import AppConfig from '../../models/app-config.js';
-
-const getAppConfig = async (_parent, params, context) => {
-  context.currentUser.can('create', 'Connection');
-
-  const appConfig = await AppConfig.query()
-    .withGraphFetched({
-      appAuthClients: true,
-    })
-    .findOne({
-      key: params.key,
-    });
-
-  return appConfig;
-};
-
-export default getAppConfig;

packages/backend/src/graphql/queries/get-apps.js

@@ -1,17 +0,0 @@
-import App from '../../models/app.js';
-
-const getApps = async (_parent, params) => {
-  const apps = await App.findAll(params.name);
-
-  if (params.onlyWithTriggers) {
-    return apps.filter((app) => app.triggers?.length);
-  }
-
-  if (params.onlyWithActions) {
-    return apps.filter((app) => app.actions?.length);
-  }
-
-  return apps;
-};
-
-export default getApps;

packages/backend/src/graphql/queries/get-current-user.js

@@ -1,5 +0,0 @@
-const getCurrentUser = async (_parent, _params, context) => {
-  return context.currentUser;
-};
-
-export default getCurrentUser;

packages/backend/src/graphql/queries/get-current-user.test.js

@@ -1,79 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import request from 'supertest';
-import app from '../../app';
-import createAuthTokenByUserId from '../../helpers/create-auth-token-by-user-id';
-import { createRole } from '../../../test/factories/role';
-import { createUser } from '../../../test/factories/user';
-
-describe('graphQL getCurrentUser query', () => {
-  let role, currentUser, token, requestObject;
-
-  beforeEach(async () => {
-    role = await createRole({
-      key: 'sample',
-      name: 'sample',
-    });
-
-    currentUser = await createUser({
-      roleId: role.id,
-    });
-
-    token = createAuthTokenByUserId(currentUser.id);
-    requestObject = request(app).post('/graphql').set('Authorization', token);
-  });
-
-  it('should return user data', async () => {
-    const query = `
-      query {
-        getCurrentUser {
-          id
-          email
-          fullName
-          email
-          createdAt
-          updatedAt
-          role {
-            id
-            name
-          }
-        }
-      }
-    `;
-
-    const response = await requestObject.send({ query }).expect(200);
-
-    const expectedResponsePayload = {
-      data: {
-        getCurrentUser: {
-          createdAt: currentUser.createdAt.getTime().toString(),
-          email: currentUser.email,
-          fullName: currentUser.fullName,
-          id: currentUser.id,
-          role: { id: role.id, name: role.name },
-          updatedAt: currentUser.updatedAt.getTime().toString(),
-        },
-      },
-    };
-
-    expect(response.body).toEqual(expectedResponsePayload);
-  });
-
-  it('should not return user password', async () => {
-    const query = `
-      query {
-        getCurrentUser {
-          id
-          email
-          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-execution-steps.js

@@ -1,27 +0,0 @@
-import paginate from '../../helpers/pagination.js';
-import Execution from '../../models/execution.js';
-
-const getExecutionSteps = async (_parent, params, context) => {
-  const conditions = context.currentUser.can('read', 'Execution');
-  const userExecutions = context.currentUser.$relatedQuery('executions');
-  const allExecutions = Execution.query();
-  const executionBaseQuery = conditions.isCreator
-    ? userExecutions
-    : allExecutions;
-
-  const execution = await executionBaseQuery
-    .clone()
-    .withSoftDeleted()
-    .findById(params.executionId)
-    .throwIfNotFound();
-
-  const executionSteps = execution
-    .$relatedQuery('executionSteps')
-    .withSoftDeleted()
-    .withGraphFetched('step')
-    .orderBy('created_at', 'asc');
-
-  return paginate(executionSteps, params.limit, params.offset);
-};
-
-export default getExecutionSteps;

packages/backend/src/graphql/queries/get-execution.js

@@ -1,25 +0,0 @@
-import Execution from '../../models/execution.js';
-
-const getExecution = async (_parent, params, context) => {
-  const conditions = context.currentUser.can('read', 'Execution');
-  const userExecutions = context.currentUser.$relatedQuery('executions');
-  const allExecutions = Execution.query();
-  const executionBaseQuery = conditions.isCreator
-    ? userExecutions
-    : allExecutions;
-
-  const execution = await executionBaseQuery
-    .clone()
-    .withGraphFetched({
-      flow: {
-        steps: true,
-      },
-    })
-    .withSoftDeleted()
-    .findById(params.executionId)
-    .throwIfNotFound();
-
-  return execution;
-};
-
-export default getExecution;

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

@@ -1,70 +0,0 @@
-import { raw } from 'objection';
-import { DateTime } from 'luxon';
-import Execution from '../../models/execution.js';
-import paginate from '../../helpers/pagination.js';
-
-const getExecutions = async (_parent, params, context) => {
-  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 selectStatusStatement = `
-    case
-      when count(*) filter (where execution_steps.status = 'failure') > 0
-        then 'failure'
-      else 'success'
-    end
-    as status
-  `;
-
-  const executions = executionBaseQuery
-    .clone()
-    .joinRelated('executionSteps as execution_steps')
-    .select('executions.*', raw(selectStatusStatement))
-    .groupBy('executions.id')
-    .orderBy('created_at', 'desc');
-
-  const computedExecutions = Execution.query()
-    .with('executions', executions)
-    .withSoftDeleted()
-    .withGraphFetched({
-      flow: {
-        steps: true,
-      },
-    });
-
-  if (filters?.flowId) {
-    computedExecutions.where('executions.flow_id', filters.flowId);
-  }
-
-  if (filters?.status) {
-    computedExecutions.where('executions.status', filters.status);
-  }
-
-  if (filters?.createdAt) {
-    const createdAtFilter = filters.createdAt;
-    if (createdAtFilter.from) {
-      const isoFromDateTime = DateTime.fromMillis(
-        parseInt(createdAtFilter.from, 10)
-      ).toISO();
-      computedExecutions.where('executions.created_at', '>=', isoFromDateTime);
-    }
-
-    if (createdAtFilter.to) {
-      const isoToDateTime = DateTime.fromMillis(
-        parseInt(createdAtFilter.to, 10)
-      ).toISO();
-      computedExecutions.where('executions.created_at', '<=', isoToDateTime);
-    }
-  }
-
-  return paginate(computedExecutions, params.limit, params.offset);
-};
-
-export default getExecutions;

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

@@ -1,472 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import request 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';
-
-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
-              }
-            }
-          }
-        }
-      }
-    }
-  `;
-
-  describe('and without correct 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', () => {
-    let role,
-      currentUser,
-      anotherUser,
-      token,
-      flowOne,
-      stepOneForFlowOne,
-      stepTwoForFlowOne,
-      executionOne,
-      flowTwo,
-      stepOneForFlowTwo,
-      stepTwoForFlowTwo,
-      executionTwo,
-      flowThree,
-      stepOneForFlowThree,
-      stepTwoForFlowThree,
-      executionThree,
-      expectedResponseForExecutionOne,
-      expectedResponseForExecutionTwo,
-      expectedResponseForExecutionThree;
-
-    beforeEach(async () => {
-      role = await createRole({
-        key: 'sample',
-        name: 'sample',
-      });
-
-      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,
-      });
-
-      await createExecutionStep({
-        executionId: executionOne.id,
-        stepId: stepOneForFlowOne.id,
-        status: 'success',
-      });
-
-      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,
-      });
-
-      await createExecutionStep({
-        executionId: executionTwo.id,
-        stepId: stepOneForFlowTwo.id,
-        status: 'success',
-      });
-
-      await createExecutionStep({
-        executionId: executionTwo.id,
-        stepId: stepTwoForFlowTwo.id,
-        status: 'failure',
-      });
-
-      flowThree = await createFlow({
-        userId: anotherUser.id,
-      });
-
-      stepOneForFlowThree = await createStep({
-        flowId: flowThree.id,
-      });
-
-      stepTwoForFlowThree = await createStep({
-        flowId: flowThree.id,
-      });
-
-      executionThree = await createExecution({
-        flowId: flowThree.id,
-      });
-
-      await createExecutionStep({
-        executionId: executionThree.id,
-        stepId: stepOneForFlowThree.id,
-        status: 'success',
-      });
-
-      await createExecutionStep({
-        executionId: executionThree.id,
-        stepId: stepTwoForFlowThree.id,
-        status: 'failure',
-      });
-
-      expectedResponseForExecutionOne = {
-        node: {
-          createdAt: executionOne.createdAt.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.getTime().toString(),
-        },
-      };
-
-      expectedResponseForExecutionTwo = {
-        node: {
-          createdAt: executionTwo.createdAt.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.getTime().toString(),
-        },
-      };
-
-      expectedResponseForExecutionThree = {
-        node: {
-          createdAt: executionThree.createdAt.getTime().toString(),
-          flow: {
-            active: flowThree.active,
-            id: flowThree.id,
-            name: flowThree.name,
-            steps: [
-              {
-                iconUrl: `${appConfig.baseUrl}/apps/${stepOneForFlowThree.appKey}/assets/favicon.svg`,
-              },
-              {
-                iconUrl: `${appConfig.baseUrl}/apps/${stepTwoForFlowThree.appKey}/assets/favicon.svg`,
-              },
-            ],
-          },
-          id: executionThree.id,
-          status: 'failure',
-          testRun: executionThree.testRun,
-          updatedAt: executionThree.updatedAt.getTime().toString(),
-        },
-      };
-    });
-
-    describe('and with isCreator condition', () => {
-      beforeEach(async () => {
-        await createPermission({
-          action: 'read',
-          subject: 'Execution',
-          roleId: role.id,
-          conditions: ['isCreator'],
-        });
-      });
-
-      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: [
-                expectedResponseForExecutionTwo,
-                expectedResponseForExecutionOne,
-              ],
-              pageInfo: { currentPage: 1, totalPages: 1 },
-            },
-          },
-        };
-
-        expect(response.body).toEqual(expectedResponsePayload);
-      });
-    });
-
-    describe('and without isCreator condition', () => {
-      beforeEach(async () => {
-        await createPermission({
-          action: 'read',
-          subject: 'Execution',
-          roleId: role.id,
-          conditions: [],
-        });
-      });
-
-      it('should return executions data of all users', async () => {
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', token)
-          .send({ query })
-          .expect(200);
-
-        const expectedResponsePayload = {
-          data: {
-            getExecutions: {
-              edges: [
-                expectedResponseForExecutionThree,
-                expectedResponseForExecutionTwo,
-                expectedResponseForExecutionOne,
-              ],
-              pageInfo: { currentPage: 1, totalPages: 1 },
-            },
-          },
-        };
-
-        expect(response.body).toEqual(expectedResponsePayload);
-      });
-    });
-
-    describe('and with filters', () => {
-      beforeEach(async () => {
-        await createPermission({
-          action: 'read',
-          subject: 'Execution',
-          roleId: role.id,
-          conditions: [],
-        });
-      });
-
-      it('should return executions data for the specified flow', async () => {
-        const query = `
-            query {
-              getExecutions(limit: 10, offset: 0, filters: { flowId: "${flowOne.id}" }) {
-                pageInfo {
-                  currentPage
-                  totalPages
-                }
-                edges {
-                  node {
-                    id
-                    testRun
-                    createdAt
-                    updatedAt
-                    status
-                    flow {
-                      id
-                      name
-                      active
-                      steps {
-                        iconUrl
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          `;
-
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', token)
-          .send({ query })
-          .expect(200);
-
-        const expectedResponsePayload = {
-          data: {
-            getExecutions: {
-              edges: [expectedResponseForExecutionOne],
-              pageInfo: { currentPage: 1, totalPages: 1 },
-            },
-          },
-        };
-
-        expect(response.body).toEqual(expectedResponsePayload);
-      });
-
-      it('should return only executions data with success status', async () => {
-        const query = `
-            query {
-              getExecutions(limit: 10, offset: 0, filters: { status: "success" }) {
-                pageInfo {
-                  currentPage
-                  totalPages
-                }
-                edges {
-                  node {
-                    id
-                    testRun
-                    createdAt
-                    updatedAt
-                    status
-                    flow {
-                      id
-                      name
-                      active
-                      steps {
-                        iconUrl
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          `;
-
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', token)
-          .send({ query })
-          .expect(200);
-
-        const expectedResponsePayload = {
-          data: {
-            getExecutions: {
-              edges: [expectedResponseForExecutionOne],
-              pageInfo: { currentPage: 1, totalPages: 1 },
-            },
-          },
-        };
-
-        expect(response.body).toEqual(expectedResponsePayload);
-      });
-
-      it('should return only executions data within date range', async () => {
-        const createdAtFrom = executionOne.createdAt.getTime().toString();
-
-        const createdAtTo = executionOne.createdAt.getTime().toString();
-
-        const query = `
-            query {
-              getExecutions(limit: 10, offset: 0, filters: { createdAt: { from: "${createdAtFrom}", to: "${createdAtTo}" }}) {
-                pageInfo {
-                  currentPage
-                  totalPages
-                }
-                edges {
-                  node {
-                    id
-                    testRun
-                    createdAt
-                    updatedAt
-                    status
-                    flow {
-                      id
-                      name
-                      active
-                      steps {
-                        iconUrl
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          `;
-
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', token)
-          .send({ query })
-          .expect(200);
-
-        const expectedResponsePayload = {
-          data: {
-            getExecutions: {
-              edges: [expectedResponseForExecutionOne],
-              pageInfo: { currentPage: 1, totalPages: 1 },
-            },
-          },
-        };
-
-        expect(response.body).toEqual(expectedResponsePayload);
-      });
-    });
-  });
-});

packages/backend/src/graphql/queries/get-invoices.ee.js

@@ -1,19 +0,0 @@
-import Billing from '../../helpers/billing/index.ee.js';
-
-const getInvoices = async (_parent, _params, context) => {
-  const subscription = await context.currentUser.$relatedQuery(
-    'currentSubscription'
-  );
-
-  if (!subscription) {
-    return;
-  }
-
-  const invoices = await Billing.paddleClient.getInvoices(
-    Number(subscription.paddleSubscriptionId)
-  );
-
-  return invoices;
-};
-
-export default getInvoices;

packages/backend/src/graphql/queries/get-paddle-info.ee.js

@@ -1,10 +0,0 @@
-import appConfig from '../../config/app.js';
-import Billing from '../../helpers/billing/index.ee.js';
-
-const getPaddleInfo = async () => {
-  if (!appConfig.isCloud) return;
-
-  return Billing.paddleInfo;
-};
-
-export default getPaddleInfo;

packages/backend/src/graphql/queries/get-payment-plans.ee.js

@@ -1,10 +0,0 @@
-import appConfig from '../../config/app.js';
-import Billing from '../../helpers/billing/index.ee.js';
-
-const getPaymentPlans = async () => {
-  if (!appConfig.isCloud) return;
-
-  return Billing.paddlePlans;
-};
-
-export default getPaymentPlans;

packages/backend/src/graphql/queries/get-permission-catalog.ee.js

@@ -1,7 +0,0 @@
-import permissionCatalog from '../../helpers/permission-catalog.ee.js';
-
-const getPermissionCatalog = async () => {
-  return permissionCatalog;
-};
-
-export default getPermissionCatalog;

packages/backend/src/graphql/queries/get-role.ee.js

@@ -1,17 +0,0 @@
-import Role from '../../models/role.js';
-
-const getRole = async (_parent, params, context) => {
-  context.currentUser.can('read', 'Role');
-
-  return await Role.query()
-    .leftJoinRelated({
-      permissions: true,
-    })
-    .withGraphFetched({
-      permissions: true,
-    })
-    .findById(params.id)
-    .throwIfNotFound();
-};
-
-export default getRole;

packages/backend/src/graphql/queries/get-role.ee.test.js

@@ -1,164 +0,0 @@
-import { vi, describe, it, expect, beforeEach } from 'vitest';
-import request from 'supertest';
-import app from '../../app';
-import createAuthTokenByUserId from '../../helpers/create-auth-token-by-user-id';
-import Crypto from 'crypto';
-import { createRole } from '../../../test/factories/role';
-import { createPermission } from '../../../test/factories/permission';
-import { createUser } from '../../../test/factories/user';
-import * as license from '../../helpers/license.ee';
-
-describe('graphQL getRole query', () => {
-  let validRole,
-    invalidRoleId,
-    queryWithValidRole,
-    queryWithInvalidRole,
-    userWithPermissions,
-    userWithoutPermissions,
-    tokenWithPermissions,
-    tokenWithoutPermissions,
-    permissionOne,
-    permissionTwo;
-
-  beforeEach(async () => {
-    validRole = await createRole();
-    invalidRoleId = Crypto.randomUUID();
-
-    queryWithValidRole = `
-      query {
-        getRole(id: "${validRole.id}") {
-          id
-          name
-          key
-          description
-          isAdmin
-          permissions {
-            id
-            action
-            subject
-            conditions
-          }
-        }
-      }
-    `;
-
-    queryWithInvalidRole = `
-      query {
-        getRole(id: "${invalidRoleId}") {
-          id
-          name
-        }
-      }
-    `;
-
-    permissionOne = await createPermission({
-      action: 'read',
-      subject: 'Role',
-      roleId: validRole.id,
-    });
-
-    permissionTwo = await createPermission({
-      action: 'read',
-      subject: 'User',
-      roleId: validRole.id,
-    });
-
-    userWithPermissions = await createUser({
-      roleId: validRole.id,
-    });
-
-    userWithoutPermissions = await createUser();
-
-    tokenWithPermissions = createAuthTokenByUserId(userWithPermissions.id);
-    tokenWithoutPermissions = createAuthTokenByUserId(
-      userWithoutPermissions.id
-    );
-  });
-
-  describe('and with valid license', () => {
-    beforeEach(async () => {
-      vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
-    });
-
-    describe('and without permissions', () => {
-      it('should throw not authorized error', async () => {
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', tokenWithoutPermissions)
-          .send({ query: queryWithValidRole })
-          .expect(200);
-
-        expect(response.body.errors).toBeDefined();
-        expect(response.body.errors[0].message).toEqual('Not authorized!');
-      });
-    });
-
-    describe('and correct permissions', () => {
-      it('should return role data for a valid role id', async () => {
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', tokenWithPermissions)
-          .send({ query: queryWithValidRole })
-          .expect(200);
-
-        const expectedResponsePayload = {
-          data: {
-            getRole: {
-              description: validRole.description,
-              id: validRole.id,
-              isAdmin: validRole.key === 'admin',
-              key: validRole.key,
-              name: validRole.name,
-              permissions: [
-                {
-                  action: permissionOne.action,
-                  conditions: permissionOne.conditions,
-                  id: permissionOne.id,
-                  subject: permissionOne.subject,
-                },
-                {
-                  action: permissionTwo.action,
-                  conditions: permissionTwo.conditions,
-                  id: permissionTwo.id,
-                  subject: permissionTwo.subject,
-                },
-              ],
-            },
-          },
-        };
-
-        expect(response.body).toEqual(expectedResponsePayload);
-      });
-
-      it('should return not found for invalid role id', async () => {
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', tokenWithPermissions)
-          .send({ query: queryWithInvalidRole })
-          .expect(200);
-
-        expect(response.body.errors).toBeDefined();
-        expect(response.body.errors[0].message).toEqual('NotFoundError');
-      });
-    });
-  });
-
-  describe('and without valid license', () => {
-    beforeEach(async () => {
-      vi.spyOn(license, 'hasValidLicense').mockResolvedValue(false);
-    });
-
-    describe('and correct permissions', () => {
-      it('should throw not authorized error', async () => {
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', tokenWithPermissions)
-          .send({ query: queryWithInvalidRole })
-          .expect(200);
-
-        expect(response.body.errors).toBeDefined();
-        expect(response.body.errors[0].message).toEqual('Not authorized!');
-      });
-    });
-  });
-});

packages/backend/src/graphql/queries/get-roles.ee.js

@@ -1,9 +0,0 @@
-import Role from '../../models/role.js';
-
-const getRoles = async (_parent, params, context) => {
-  context.currentUser.can('read', 'Role');
-
-  return await Role.query().orderBy('name');
-};
-
-export default getRoles;

packages/backend/src/graphql/queries/get-roles.ee.test.js

@@ -1,134 +0,0 @@
-import { vi, describe, it, expect, beforeEach } from 'vitest';
-import request from 'supertest';
-import app from '../../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 * as license from '../../helpers/license.ee';
-
-describe('graphQL getRoles query', () => {
-  let currentUserRole,
-    roleOne,
-    roleSecond,
-    query,
-    userWithPermissions,
-    userWithoutPermissions,
-    tokenWithPermissions,
-    tokenWithoutPermissions;
-
-  beforeEach(async () => {
-    currentUserRole = await createRole({ name: 'Current user role' });
-    roleOne = await createRole({ name: 'Role one' });
-    roleSecond = await createRole({ name: 'Role second' });
-
-    query = `
-      query {
-        getRoles {
-          id
-          key
-          name
-          description
-          isAdmin
-        }
-      }
-    `;
-
-    await createPermission({
-      action: 'read',
-      subject: 'Role',
-      roleId: currentUserRole.id,
-    });
-
-    userWithPermissions = await createUser({
-      roleId: currentUserRole.id,
-    });
-
-    userWithoutPermissions = await createUser({
-      roleId: roleOne.id,
-    });
-
-    tokenWithPermissions = createAuthTokenByUserId(userWithPermissions.id);
-    tokenWithoutPermissions = createAuthTokenByUserId(
-      userWithoutPermissions.id
-    );
-  });
-
-  describe('and with valid license', () => {
-    beforeEach(async () => {
-      vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
-    });
-
-    describe('and without permissions', () => {
-      it('should throw not authorized error', async () => {
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', tokenWithoutPermissions)
-          .send({ query })
-          .expect(200);
-
-        expect(response.body.errors).toBeDefined();
-        expect(response.body.errors[0].message).toEqual('Not authorized!');
-      });
-    });
-
-    describe('and correct permissions', () => {
-      it('should return roles data', async () => {
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', tokenWithPermissions)
-          .send({ query })
-          .expect(200);
-
-        const expectedResponsePayload = {
-          data: {
-            getRoles: [
-              {
-                description: currentUserRole.description,
-                id: currentUserRole.id,
-                isAdmin: currentUserRole.key === 'admin',
-                key: currentUserRole.key,
-                name: currentUserRole.name,
-              },
-              {
-                description: roleOne.description,
-                id: roleOne.id,
-                isAdmin: roleOne.key === 'admin',
-                key: roleOne.key,
-                name: roleOne.name,
-              },
-              {
-                description: roleSecond.description,
-                id: roleSecond.id,
-                isAdmin: roleSecond.key === 'admin',
-                key: roleSecond.key,
-                name: roleSecond.name,
-              },
-            ],
-          },
-        };
-
-        expect(response.body).toEqual(expectedResponsePayload);
-      });
-    });
-  });
-
-  describe('and without valid license', () => {
-    beforeEach(async () => {
-      vi.spyOn(license, 'hasValidLicense').mockResolvedValue(false);
-    });
-
-    describe('and correct permissions', () => {
-      it('should throw not authorized error', async () => {
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', tokenWithPermissions)
-          .send({ query })
-          .expect(200);
-
-        expect(response.body.errors).toBeDefined();
-        expect(response.body.errors[0].message).toEqual('Not authorized!');
-      });
-    });
-  });
-});

packages/backend/src/graphql/queries/get-saml-auth-provider-role-mappings.ee.js

@@ -1,17 +0,0 @@
-import SamlAuthProvider from '../../models/saml-auth-provider.ee.js';
-
-const getSamlAuthProviderRoleMappings = async (_parent, params, context) => {
-  context.currentUser.can('read', 'SamlAuthProvider');
-
-  const samlAuthProvider = await SamlAuthProvider.query()
-    .findById(params.id)
-    .throwIfNotFound();
-
-  const roleMappings = await samlAuthProvider
-    .$relatedQuery('samlAuthProvidersRoleMappings')
-    .orderBy('remote_role_name', 'asc');
-
-  return roleMappings;
-};
-
-export default getSamlAuthProviderRoleMappings;

packages/backend/src/graphql/queries/get-saml-auth-provider.ee.js

@@ -1,14 +0,0 @@
-import SamlAuthProvider from '../../models/saml-auth-provider.ee.js';
-
-const getSamlAuthProvider = async (_parent, params, context) => {
-  context.currentUser.can('read', 'SamlAuthProvider');
-
-  const samlAuthProvider = await SamlAuthProvider.query()
-    .limit(1)
-    .first()
-    .throwIfNotFound();
-
-  return samlAuthProvider;
-};
-
-export default getSamlAuthProvider;

packages/backend/src/graphql/queries/get-subscription-status.ee.js

@@ -1,17 +0,0 @@
-import appConfig from '../../config/app.js';
-
-const getSubscriptionStatus = async (_parent, _params, context) => {
-  if (!appConfig.isCloud) return;
-
-  const currentSubscription = await context.currentUser.$relatedQuery(
-    'currentSubscription'
-  );
-
-  if (!currentSubscription?.cancellationEffectiveDate) return;
-
-  return {
-    cancellationEffectiveDate: currentSubscription.cancellationEffectiveDate,
-  };
-};
-
-export default getSubscriptionStatus;

packages/backend/src/graphql/queries/get-trial-status.ee.js

@@ -1,17 +0,0 @@
-import appConfig from '../../config/app.js';
-
-const getTrialStatus = async (_parent, _params, context) => {
-  if (!appConfig.isCloud) return;
-
-  const inTrial = await context.currentUser.inTrial();
-  const hasActiveSubscription =
-    await context.currentUser.hasActiveSubscription();
-
-  if (!inTrial && hasActiveSubscription) return;
-
-  return {
-    expireAt: context.currentUser.trialExpiryDate,
-  };
-};
-
-export default getTrialStatus;

packages/backend/src/graphql/queries/get-trial-status.ee.test.js

@@ -1,100 +0,0 @@
-import { vi, describe, it, expect, beforeEach } from 'vitest';
-import request from 'supertest';
-import app from '../../app';
-import User from '../../models/user';
-import { createUser } from '../../../test/factories/user';
-import createAuthTokenByUserId from '../../helpers/create-auth-token-by-user-id';
-import { DateTime } from 'luxon';
-import appConfig from '../../config/app';
-
-describe('graphQL getTrialStatus query', () => {
-  const query = `
-    query GetTrialStatus {
-      getTrialStatus {
-        expireAt
-      }
-    }
-  `;
-
-  let user, userToken;
-
-  beforeEach(async () => {
-    const trialExpiryDate = DateTime.now().plus({ days: 30 }).toISODate();
-
-    user = await createUser({ trialExpiryDate });
-    userToken = createAuthTokenByUserId(user.id);
-  });
-
-  describe('and with cloud flag disabled', () => {
-    beforeEach(async () => {
-      vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(false);
-    });
-
-    it('should return null', async () => {
-      const response = await request(app)
-        .post('/graphql')
-        .set('Authorization', userToken)
-        .send({ query })
-        .expect(200);
-
-      const expectedResponsePayload = {
-        data: { getTrialStatus: null },
-      };
-
-      expect(response.body).toEqual(expectedResponsePayload);
-    });
-  });
-
-  describe('and with cloud flag enabled', () => {
-    beforeEach(async () => {
-      vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(true);
-    });
-
-    describe('and not in trial and has active subscription', () => {
-      beforeEach(async () => {
-        vi.spyOn(User.prototype, 'inTrial').mockResolvedValue(false);
-        vi.spyOn(User.prototype, 'hasActiveSubscription').mockResolvedValue(
-          true
-        );
-      });
-
-      it('should return null', async () => {
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', userToken)
-          .send({ query })
-          .expect(200);
-
-        const expectedResponsePayload = {
-          data: { getTrialStatus: null },
-        };
-
-        expect(response.body).toEqual(expectedResponsePayload);
-      });
-    });
-
-    describe('and in trial period', () => {
-      beforeEach(async () => {
-        vi.spyOn(User.prototype, 'inTrial').mockResolvedValue(true);
-      });
-
-      it('should return null', async () => {
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', userToken)
-          .send({ query })
-          .expect(200);
-
-        const expectedResponsePayload = {
-          data: {
-            getTrialStatus: {
-              expireAt: new Date(user.trialExpiryDate).getTime().toString(),
-            },
-          },
-        };
-
-        expect(response.body).toEqual(expectedResponsePayload);
-      });
-    });
-  });
-});

packages/backend/src/graphql/queries/get-user.js

@@ -1,17 +0,0 @@
-import User from '../../models/user.js';
-
-const getUser = async (_parent, params, context) => {
-  context.currentUser.can('read', 'User');
-
-  return await User.query()
-    .leftJoinRelated({
-      role: true,
-    })
-    .withGraphFetched({
-      role: true,
-    })
-    .findById(params.id)
-    .throwIfNotFound();
-};
-
-export default getUser;

packages/backend/src/graphql/queries/get-user.test.js

@@ -1,146 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import request from 'supertest';
-import app from '../../app';
-import createAuthTokenByUserId from '../../helpers/create-auth-token-by-user-id';
-import Crypto from 'crypto';
-import { createRole } from '../../../test/factories/role';
-import { createPermission } from '../../../test/factories/permission';
-import { createUser } from '../../../test/factories/user';
-
-describe('graphQL getUser query', () => {
-  describe('and without permissions', () => {
-    it('should throw not authorized error', async () => {
-      const userWithoutPermissions = await createUser();
-      const anotherUser = await createUser();
-
-      const query = `
-          query {
-            getUser(id: "${anotherUser.id}") {
-              id
-              email
-            }
-          }
-        `;
-
-      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 correct permissions', () => {
-    let role, currentUser, anotherUser, token, requestObject;
-
-    beforeEach(async () => {
-      role = await createRole({
-        key: 'sample',
-        name: 'sample',
-      });
-
-      await createPermission({
-        action: 'read',
-        subject: 'User',
-        roleId: role.id,
-      });
-
-      currentUser = await createUser({
-        roleId: role.id,
-      });
-
-      anotherUser = await createUser({
-        roleId: role.id,
-      });
-
-      token = createAuthTokenByUserId(currentUser.id);
-      requestObject = request(app).post('/graphql').set('Authorization', token);
-    });
-
-    it('should return user data for a valid user id', async () => {
-      const query = `
-          query {
-            getUser(id: "${anotherUser.id}") {
-              id
-              email
-              fullName
-              email
-              createdAt
-              updatedAt
-              role {
-                id
-                name
-              }
-            }
-          }
-        `;
-
-      const response = await requestObject.send({ query }).expect(200);
-
-      const expectedResponsePayload = {
-        data: {
-          getUser: {
-            createdAt: anotherUser.createdAt.getTime().toString(),
-            email: anotherUser.email,
-            fullName: anotherUser.fullName,
-            id: anotherUser.id,
-            role: { id: role.id, name: role.name },
-            updatedAt: anotherUser.updatedAt.getTime().toString(),
-          },
-        },
-      };
-
-      expect(response.body).toEqual(expectedResponsePayload);
-    });
-
-    it('should not return user password for a valid user id', async () => {
-      const query = `
-          query {
-            getUser(id: "${anotherUser.id}") {
-              id
-              email
-              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".'
-      );
-    });
-
-    it('should return not found for invalid user id', async () => {
-      const invalidUserId = Crypto.randomUUID();
-
-      const query = `
-          query {
-            getUser(id: "${invalidUserId}") {
-              id
-              email
-              fullName
-              email
-              createdAt
-              updatedAt
-              role {
-                id
-                name
-              }
-            }
-          }
-        `;
-
-      const response = await requestObject.send({ query }).expect(200);
-
-      expect(response.body.errors).toBeDefined();
-      expect(response.body.errors[0].message).toEqual('NotFoundError');
-    });
-  });
-});

packages/backend/src/graphql/queries/healthcheck.js

@@ -1,9 +0,0 @@
-import appConfig from '../../config/app.js';
-
-const healthcheck = () => {
-  return {
-    version: appConfig.version,
-  };
-};
-
-export default healthcheck;

packages/backend/src/graphql/queries/healthcheck.test.js

@@ -1,27 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import request from 'supertest';
-import app from '../../app';
-import appConfig from '../../config/app';
-
-describe('graphQL healthcheck query', () => {
-  it('should return application version', async () => {
-    const query = `
-      query {
-        healthcheck {
-          version
-        }
-      }
-    `;
-
-    const response = await request(app)
-      .post('/graphql')
-      .send({ query })
-      .expect(200);
-
-    const expectedResponsePayload = {
-      data: { healthcheck: { version: appConfig.version } },
-    };
-
-    expect(response.body).toEqual(expectedResponsePayload);
-  });
-});

packages/backend/src/graphql/queries/list-saml-auth-providers.ee.js

@@ -1,9 +0,0 @@
-import SamlAuthProvider from '../../models/saml-auth-provider.ee.js';
-
-const listSamlAuthProviders = async () => {
-  const providers = await SamlAuthProvider.query().where({ active: true });
-
-  return providers;
-};
-
-export default listSamlAuthProviders;

packages/backend/src/graphql/query-resolvers.js

@@ -1,70 +1,32 @@
 import getApp from './queries/get-app.js';
 import getAppAuthClient from './queries/get-app-auth-client.ee.js';
 import getAppAuthClients from './queries/get-app-auth-clients.ee.js';
-import getAppConfig from './queries/get-app-config.ee.js';
-import getApps from './queries/get-apps.js';
 import getBillingAndUsage from './queries/get-billing-and-usage.ee.js';
 import getConfig from './queries/get-config.ee.js';
 import getConnectedApps from './queries/get-connected-apps.js';
-import getCurrentUser from './queries/get-current-user.js';
 import getDynamicData from './queries/get-dynamic-data.js';
 import getDynamicFields from './queries/get-dynamic-fields.js';
-import getExecution from './queries/get-execution.js';
-import getExecutionSteps from './queries/get-execution-steps.js';
-import getExecutions from './queries/get-executions.js';
 import getFlow from './queries/get-flow.js';
 import getFlows from './queries/get-flows.js';
-import getInvoices from './queries/get-invoices.ee.js';
 import getNotifications from './queries/get-notifications.js';
-import getPaddleInfo from './queries/get-paddle-info.ee.js';
-import getPaymentPlans from './queries/get-payment-plans.ee.js';
-import getPermissionCatalog from './queries/get-permission-catalog.ee.js';
-import getRole from './queries/get-role.ee.js';
-import getRoles from './queries/get-roles.ee.js';
-import getSamlAuthProviderRoleMappings from './queries/get-saml-auth-provider-role-mappings.ee.js';
-import getSamlAuthProvider from './queries/get-saml-auth-provider.ee.js';
 import getStepWithTestExecutions from './queries/get-step-with-test-executions.js';
-import getSubscriptionStatus from './queries/get-subscription-status.ee.js';
-import getTrialStatus from './queries/get-trial-status.ee.js';
-import getUser from './queries/get-user.js';
 import getUsers from './queries/get-users.js';
-import healthcheck from './queries/healthcheck.js';
-import listSamlAuthProviders from './queries/list-saml-auth-providers.ee.js';
 import testConnection from './queries/test-connection.js';
 
 const queryResolvers = {
   getApp,
   getAppAuthClient,
   getAppAuthClients,
-  getAppConfig,
-  getApps,
   getBillingAndUsage,
   getConfig,
   getConnectedApps,
-  getCurrentUser,
   getDynamicData,
   getDynamicFields,
-  getExecution,
-  getExecutions,
-  getExecutionSteps,
   getFlow,
   getFlows,
-  getInvoices,
   getNotifications,
-  getPaddleInfo,
-  getPaymentPlans,
-  getPermissionCatalog,
-  getRole,
-  getRoles,
-  getSamlAuthProvider,
-  getSamlAuthProviderRoleMappings,
   getStepWithTestExecutions,
-  getSubscriptionStatus,
-  getTrialStatus,
-  getUser,
   getUsers,
-  healthcheck,
-  listSamlAuthProviders,
   testConnection,
 };
 

packages/backend/src/graphql/schema.graphql

@@ -1,11 +1,5 @@
 type Query {
-  getApps(
-    name: String
-    onlyWithTriggers: Boolean
-    onlyWithActions: Boolean
-  ): [App]
   getApp(key: String!): App
-  getAppConfig(key: String!): AppConfig
   getAppAuthClient(id: String!): AppAuthClient
   getAppAuthClients(appKey: String!, active: Boolean): [AppAuthClient]
   getConnectedApps(name: String): [App]
@@ -19,17 +13,6 @@ type Query {
     name: String
   ): FlowConnection
   getStepWithTestExecutions(stepId: String!): [Step]
-  getExecution(executionId: String!): Execution
-  getExecutions(
-    limit: Int!
-    offset: Int!
-    filters: ExecutionFiltersInput
-  ): ExecutionConnection
-  getExecutionSteps(
-    executionId: String!
-    limit: Int!
-    offset: Int!
-  ): ExecutionStepConnection
   getDynamicData(
     stepId: String!
     key: String!
@@ -41,23 +24,9 @@ type Query {
     parameters: JSONObject
   ): [SubstepArgument]
   getBillingAndUsage: GetBillingAndUsage
-  getCurrentUser: User
   getConfig(keys: [String]): JSONObject
-  getInvoices: [Invoice]
-  getPaddleInfo: GetPaddleInfo
-  getPaymentPlans: [PaymentPlan]
-  getPermissionCatalog: PermissionCatalog
-  getRole(id: String!): Role
-  getRoles: [Role]
   getNotifications: [Notification]
-  getSamlAuthProvider: SamlAuthProvider
-  getSamlAuthProviderRoleMappings(id: String!): [SamlAuthProvidersRoleMapping]
-  getSubscriptionStatus: GetSubscriptionStatus
-  getTrialStatus: GetTrialStatus
-  getUser(id: String!): User
   getUsers(limit: Int!, offset: Int!): UserConnection
-  healthcheck: AppHealth
-  listSamlAuthProviders: [ListSamlAuthProvider]
 }
 
 type Mutation {
@@ -313,15 +282,6 @@ type Flow {
   status: FlowStatus
 }
 
-type Execution {
-  id: String
-  testRun: Boolean
-  createdAt: String
-  updatedAt: String
-  status: String
-  flow: Flow
-}
-
 type SamlAuthProvider {
   id: String
   name: String
@@ -621,28 +581,15 @@ type PageInfo {
   totalPages: Int!
 }
 
-type ExecutionEdge {
-  node: Execution
-}
-
 type ExecutionStepEdge {
   node: ExecutionStep
 }
 
-type ExecutionConnection {
-  edges: [ExecutionEdge]
-  pageInfo: PageInfo
-}
-
 type ExecutionStepConnection {
   edges: [ExecutionStepEdge]
   pageInfo: PageInfo
 }
 
-type AppHealth {
-  version: String
-}
-
 type License {
   id: String
   name: String
@@ -650,14 +597,6 @@ type License {
   verified: Boolean
 }
 
-type GetTrialStatus {
-  expireAt: String
-}
-
-type GetSubscriptionStatus {
-  cancellationEffectiveDate: String
-}
-
 type GetBillingAndUsage {
   subscription: Subscription
   usage: Usage
@@ -695,33 +634,6 @@ type Usage {
   task: Int
 }
 
-type GetPaddleInfo {
-  sandbox: Boolean
-  vendorId: Int
-}
-
-type Invoice {
-  id: Int
-  amount: Float
-  currency: String
-  payout_date: String
-  receipt_url: String
-}
-
-type PaymentPlan {
-  name: String
-  limit: String
-  price: String
-  productId: String
-}
-
-type ListSamlAuthProvider {
-  id: String
-  name: String
-  issuer: String
-  loginUrl: String
-}
-
 type Permission {
   id: String
   action: String
@@ -729,12 +641,6 @@ type Permission {
   conditions: [String]
 }
 
-type PermissionCatalog {
-  actions: [Action]
-  subjects: [Subject]
-  conditions: [Condition]
-}
-
 type Action {
   label: String
   key: String
@@ -793,17 +699,6 @@ type Notification {
   description: String
 }
 
-input ExecutionCreatedAtFilterInput {
-  from: String
-  to: String
-}
-
-input ExecutionFiltersInput {
-  flowId: String
-  createdAt: ExecutionCreatedAtFilterInput
-  status: String
-}
-
 schema {
   query: Query
   mutation: Mutation

packages/backend/src/helpers/authentication.js

@@ -44,8 +44,6 @@ export const authenticationRules = {
     '*': isAuthenticatedRule,
     getConfig: allow,
     getNotifications: allow,
-    healthcheck: allow,
-    listSamlAuthProviders: allow,
   },
   Mutation: {
     '*': isAuthenticatedRule,

packages/backend/src/helpers/authorization.js

@@ -11,6 +11,22 @@ const authorizationList = {
     action: 'read',
     subject: 'Flow',
   },
+  'GET /api/v1/flows/': {
+    action: 'read',
+    subject: 'Flow',
+  },
+  'GET /api/v1/steps/:stepId/connection': {
+    action: 'read',
+    subject: 'Flow',
+  },
+  'GET /api/v1/connections/:connectionId/flows': {
+    action: 'read',
+    subject: 'Flow',
+  },
+  'GET /api/v1/apps/:appKey/flows': {
+    action: 'read',
+    subject: 'Flow',
+  },
   'GET /api/v1/executions/:executionId': {
     action: 'read',
     subject: 'Execution',

packages/backend/src/helpers/renderer.js

@@ -15,7 +15,7 @@ const renderObject = (response, object, options) => {
   let data = isPaginated(object) ? object.records : object;
 
   const type = isPaginated(object)
-    ? object.records[0].constructor.name
+    ? object.records[0]?.constructor?.name || 'Object'
     : Array.isArray(object)
     ? object?.[0]?.constructor?.name || 'Object'
     : object.constructor.name;

packages/backend/src/helpers/webhook-handler-sync.js

@@ -0,0 +1,86 @@
+import isEmpty from 'lodash/isEmpty.js';
+
+import Flow from '../models/flow.js';
+import { processTrigger } from '../services/trigger.js';
+import { processAction } from '../services/action.js';
+import globalVariable from './global-variable.js';
+import QuotaExceededError from '../errors/quote-exceeded.js';
+
+export default async (flowId, request, response) => {
+  const flow = await Flow.query().findById(flowId).throwIfNotFound();
+  const user = await flow.$relatedQuery('user');
+
+  const testRun = !flow.active;
+  const quotaExceeded = !testRun && !(await user.isAllowedToRunFlows());
+
+  if (quotaExceeded) {
+    throw new QuotaExceededError();
+  }
+
+  const [triggerStep, ...actionSteps] = await flow
+    .$relatedQuery('steps')
+    .withGraphFetched('connection')
+    .orderBy('position', 'asc');
+  const app = await triggerStep.getApp();
+  const isWebhookApp = app.key === 'webhook';
+
+  if (testRun && !isWebhookApp) {
+    return response.status(404);
+  }
+
+  const connection = await triggerStep.$relatedQuery('connection');
+
+  const $ = await globalVariable({
+    flow,
+    connection,
+    app,
+    step: triggerStep,
+    testRun,
+    request,
+  });
+
+  const triggerCommand = await triggerStep.getTriggerCommand();
+  await triggerCommand.run($);
+
+  const reversedTriggerItems = $.triggerOutput.data.reverse();
+
+  // This is the case when we filter out the incoming data
+  // in the run method of the webhook trigger.
+  // In this case, we don't want to process anything.
+  if (isEmpty(reversedTriggerItems)) {
+    return response.status(204);
+  }
+
+  // set default status, but do not send it yet!
+  response.status(204);
+
+  for (const triggerItem of reversedTriggerItems) {
+    const { executionId } = await processTrigger({
+      flowId,
+      stepId: triggerStep.id,
+      triggerItem,
+      testRun,
+    });
+
+    if (testRun) {
+      // in case of testing, we do not process the whole process.
+      continue;
+    }
+
+    for (const actionStep of actionSteps) {
+      const { executionStep: actionExecutionStep } = await processAction({
+        flowId: flow.id,
+        stepId: actionStep.id,
+        executionId,
+      });
+
+      if (actionStep.key === 'respondWith' && !response.headersSent) {
+        // we send the response only if it's not sent yet. This allows us to early respond from the flow.
+        response.status(actionExecutionStep.dataOut.statusCode);
+        response.send(actionExecutionStep.dataOut.body);
+      }
+    }
+  }
+
+  return response;
+};

packages/backend/src/models/step.js

@@ -103,6 +103,10 @@ class Step extends Base {
       return `/webhooks/connections/${this.connectionId}`;
     }
 
+    if (this.parameters.workSynchronously) {
+      return `/webhooks/flows/${this.flowId}/sync`;
+    }
+
     return `/webhooks/flows/${this.flowId}`;
   }
 
@@ -161,7 +165,7 @@ class Step extends Base {
     if (!isTrigger || !appKey || !key) return null;
 
     const app = await App.findOneByKey(appKey);
-    const command = app.triggers.find((trigger) => trigger.key === key);
+    const command = app.triggers?.find((trigger) => trigger.key === key);
 
     return command;
   }
@@ -171,7 +175,7 @@ class Step extends Base {
     if (!isAction || !appKey || !key) return null;
 
     const app = await App.findOneByKey(appKey);
-    const command = app.actions.find((action) => action.key === key);
+    const command = app.actions?.find((action) => action.key === key);
 
     return command;
   }

packages/backend/src/models/user.js

@@ -149,6 +149,11 @@ class User extends Base {
     return conditions.isCreator ? this.$relatedQuery('flows') : Flow.query();
   }
 
+  get authorizedSteps() {
+    const conditions = this.can('read', 'Flow');
+    return conditions.isCreator ? this.$relatedQuery('steps') : Step.query();
+  }
+
   get authorizedExecutions() {
     const conditions = this.can('read', 'Execution');
     return conditions.isCreator
@@ -250,6 +255,31 @@ class User extends Base {
     return currentUsageData.consumedTaskCount < plan.quota;
   }
 
+  async getPlanAndUsage() {
+    const usageData = await this.$relatedQuery(
+      'currentUsageData'
+    ).throwIfNotFound();
+
+    const subscription = await this.$relatedQuery('currentSubscription');
+
+    const currentPlan = Billing.paddlePlans.find(
+      (plan) => plan.productId === subscription?.paddlePlanId
+    );
+
+    const planAndUsage = {
+      usage: {
+        task: usageData.consumedTaskCount,
+      },
+      plan: {
+        id: subscription?.paddlePlanId || null,
+        name: subscription ? currentPlan.name : 'Free Trial',
+        limit: currentPlan?.limit || null,
+      },
+    };
+
+    return planAndUsage;
+  }
+
   async getInvoices() {
     const subscription = await this.$relatedQuery('currentSubscription');
 

packages/backend/src/routes/api/v1/admin/saml-auth-providers.ee.js

@@ -5,6 +5,7 @@ import { authorizeAdmin } from '../../../../helpers/authorization.js';
 import { checkIsEnterprise } from '../../../../helpers/check-is-enterprise.js';
 import getSamlAuthProvidersAction from '../../../../controllers/api/v1/admin/saml-auth-providers/get-saml-auth-providers.ee.js';
 import getSamlAuthProviderAction from '../../../../controllers/api/v1/admin/saml-auth-providers/get-saml-auth-provider.ee.js';
+import getRoleMappingsAction from '../../../../controllers/api/v1/admin/saml-auth-providers/get-role-mappings.ee.js';
 
 const router = Router();
 
@@ -24,4 +25,12 @@ router.get(
   asyncHandler(getSamlAuthProviderAction)
 );
 
+router.get(
+  '/:samlAuthProviderId/role-mappings',
+  authenticateUser,
+  authorizeAdmin,
+  checkIsEnterprise,
+  asyncHandler(getRoleMappingsAction)
+);
+
 export default router;

packages/backend/src/routes/api/v1/app-configs.ee.js

@@ -0,0 +1,16 @@
+import { Router } from 'express';
+import asyncHandler from 'express-async-handler';
+import { authenticateUser } from '../../../helpers/authentication.js';
+import { checkIsEnterprise } from '../../../helpers/check-is-enterprise.js';
+import getAppConfigAction from '../../../controllers/api/v1/app-configs/get-app-config.ee.js';
+
+const router = Router();
+
+router.get(
+  '/:appKey',
+  authenticateUser,
+  checkIsEnterprise,
+  asyncHandler(getAppConfigAction)
+);
+
+export default router;

packages/backend/src/routes/api/v1/apps.js

@@ -1,6 +1,7 @@
 import { Router } from 'express';
 import asyncHandler from 'express-async-handler';
 import { authenticateUser } from '../../../helpers/authentication.js';
+import { authorizeUser } from '../../../helpers/authorization.js';
 import getAppAction from '../../../controllers/api/v1/apps/get-app.js';
 import getAppsAction from '../../../controllers/api/v1/apps/get-apps.js';
 import getAuthAction from '../../../controllers/api/v1/apps/get-auth.js';
@@ -8,6 +9,7 @@ import getTriggersAction from '../../../controllers/api/v1/apps/get-triggers.js'
 import getTriggerSubstepsAction from '../../../controllers/api/v1/apps/get-trigger-substeps.js';
 import getActionsAction from '../../../controllers/api/v1/apps/get-actions.js';
 import getActionSubstepsAction from '../../../controllers/api/v1/apps/get-action-substeps.js';
+import getFlowsAction from '../../../controllers/api/v1/apps/get-flows.js';
 
 const router = Router();
 
@@ -39,4 +41,11 @@ router.get(
   asyncHandler(getActionSubstepsAction)
 );
 
+router.get(
+  '/:appKey/flows',
+  authenticateUser,
+  authorizeUser,
+  asyncHandler(getFlowsAction)
+);
+
 export default router;

packages/backend/src/routes/api/v1/automatisch.js

@@ -1,9 +1,11 @@
 import { Router } from 'express';
 import asyncHandler from 'express-async-handler';
+import { checkIsEnterprise } from '../../../helpers/check-is-enterprise.js';
 import versionAction from '../../../controllers/api/v1/automatisch/version.js';
 import notificationsAction from '../../../controllers/api/v1/automatisch/notifications.js';
 import infoAction from '../../../controllers/api/v1/automatisch/info.js';
 import licenseAction from '../../../controllers/api/v1/automatisch/license.js';
+import configAction from '../../../controllers/api/v1/automatisch/config.ee.js';
 
 const router = Router();
 
@@ -11,5 +13,6 @@ router.get('/version', asyncHandler(versionAction));
 router.get('/notifications', asyncHandler(notificationsAction));
 router.get('/info', asyncHandler(infoAction));
 router.get('/license', asyncHandler(licenseAction));
+router.get('/config', checkIsEnterprise, asyncHandler(configAction));
 
 export default router;

packages/backend/src/routes/api/v1/connections.js

@@ -0,0 +1,16 @@
+import { Router } from 'express';
+import asyncHandler from 'express-async-handler';
+import { authenticateUser } from '../../../helpers/authentication.js';
+import { authorizeUser } from '../../../helpers/authorization.js';
+import getFlowsAction from '../../../controllers/api/v1/connections/get-flows.js';
+
+const router = Router();
+
+router.get(
+  '/:connectionId/flows',
+  authenticateUser,
+  authorizeUser,
+  asyncHandler(getFlowsAction)
+);
+
+export default router;

packages/backend/src/routes/api/v1/flows.js

@@ -2,10 +2,13 @@ import { Router } from 'express';
 import asyncHandler from 'express-async-handler';
 import { authenticateUser } from '../../../helpers/authentication.js';
 import { authorizeUser } from '../../../helpers/authorization.js';
+import getFlowsAction from '../../../controllers/api/v1/flows/get-flows.js';
 import getFlowAction from '../../../controllers/api/v1/flows/get-flow.js';
 
 const router = Router();
 
+router.get('/', authenticateUser, authorizeUser, asyncHandler(getFlowsAction));
+
 router.get(
   '/:flowId',
   authenticateUser,

packages/backend/src/routes/api/v1/saml-auth-providers.ee.js

@@ -0,0 +1,10 @@
+import { Router } from 'express';
+import asyncHandler from 'express-async-handler';
+import { checkIsEnterprise } from '../../../helpers/check-is-enterprise.js';
+import getSamlAuthProvidersAction from '../../../controllers/api/v1/saml-auth-providers/get-saml-auth-providers.ee.js';
+
+const router = Router();
+
+router.get('/', checkIsEnterprise, asyncHandler(getSamlAuthProvidersAction));
+
+export default router;

packages/backend/src/routes/api/v1/steps.js

@@ -0,0 +1,16 @@
+import { Router } from 'express';
+import asyncHandler from 'express-async-handler';
+import { authenticateUser } from '../../../helpers/authentication.js';
+import { authorizeUser } from '../../../helpers/authorization.js';
+import getConnectionAction from '../../../controllers/api/v1/steps/get-connection.js';
+
+const router = Router();
+
+router.get(
+  '/:stepId/connection',
+  authenticateUser,
+  authorizeUser,
+  asyncHandler(getConnectionAction)
+);
+
+export default router;

packages/backend/src/routes/api/v1/users.js

@@ -5,6 +5,8 @@ import checkIsCloud from '../../../helpers/check-is-cloud.js';
 import getCurrentUserAction from '../../../controllers/api/v1/users/get-current-user.js';
 import getUserTrialAction from '../../../controllers/api/v1/users/get-user-trial.ee.js';
 import getInvoicesAction from '../../../controllers/api/v1/users/get-invoices.ee.js';
+import getSubscriptionAction from '../../../controllers/api/v1/users/get-subscription.ee.js';
+import getPlanAndUsageAction from '../../../controllers/api/v1/users/get-plan-and-usage.ee.js';
 
 const router = Router();
 
@@ -23,4 +25,18 @@ router.get(
   asyncHandler(getUserTrialAction)
 );
 
+router.get(
+  '/:userId/subscription',
+  authenticateUser,
+  checkIsCloud,
+  asyncHandler(getSubscriptionAction)
+);
+
+router.get(
+  '/:userId/plan-and-usage',
+  authenticateUser,
+  checkIsCloud,
+  asyncHandler(getPlanAndUsageAction)
+);
+
 export default router;

packages/backend/src/routes/index.js

@@ -7,10 +7,14 @@ import automatischRouter from './api/v1/automatisch.js';
 import usersRouter from './api/v1/users.js';
 import paymentRouter from './api/v1/payment.ee.js';
 import appAuthClientsRouter from './api/v1/app-auth-clients.js';
+import appConfigsRouter from './api/v1/app-configs.ee.js';
 import flowsRouter from './api/v1/flows.js';
+import stepsRouter from './api/v1/steps.js';
 import appsRouter from './api/v1/apps.js';
+import connectionsRouter from './api/v1/connections.js';
 import executionsRouter from './api/v1/executions.js';
-import samlAuthProvidersRouter from './api/v1/admin/saml-auth-providers.ee.js';
+import samlAuthProvidersRouter from './api/v1/saml-auth-providers.ee.js';
+import adminSamlAuthProvidersRouter from './api/v1/admin/saml-auth-providers.ee.js';
 import rolesRouter from './api/v1/admin/roles.ee.js';
 import permissionsRouter from './api/v1/admin/permissions.ee.js';
 import adminUsersRouter from './api/v1/admin/users.ee.js';
@@ -26,10 +30,14 @@ router.use('/api/v1/automatisch', automatischRouter);
 router.use('/api/v1/users', usersRouter);
 router.use('/api/v1/payment', paymentRouter);
 router.use('/api/v1/app-auth-clients', appAuthClientsRouter);
+router.use('/api/v1/app-configs', appConfigsRouter);
 router.use('/api/v1/flows', flowsRouter);
+router.use('/api/v1/steps', stepsRouter);
 router.use('/api/v1/apps', appsRouter);
+router.use('/api/v1/connections', connectionsRouter);
 router.use('/api/v1/executions', executionsRouter);
-router.use('/api/v1/admin/saml-auth-providers', samlAuthProvidersRouter);
+router.use('/api/v1/saml-auth-providers', samlAuthProvidersRouter);
+router.use('/api/v1/admin/saml-auth-providers', adminSamlAuthProvidersRouter);
 router.use('/api/v1/admin/roles', rolesRouter);
 router.use('/api/v1/admin/permissions', permissionsRouter);
 router.use('/api/v1/admin/users', adminUsersRouter);

packages/backend/src/routes/webhooks.js

@@ -3,6 +3,7 @@ import multer from 'multer';
 
 import appConfig from '../config/app.js';
 import webhookHandlerByFlowId from '../controllers/webhooks/handler-by-flow-id.js';
+import webhookHandlerSyncByFlowId from '../controllers/webhooks/handler-sync-by-flow-id.js';
 import webhookHandlerByConnectionIdAndRefValue from '../controllers/webhooks/handler-by-connection-id-and-ref-value.js';
 
 const router = Router();
@@ -46,6 +47,7 @@ createRouteHandler(
   '/connections/:connectionId',
   webhookHandlerByConnectionIdAndRefValue
 );
+createRouteHandler('/flows/:flowId/sync', webhookHandlerSyncByFlowId);
 createRouteHandler('/flows/:flowId', webhookHandlerByFlowId);
 createRouteHandler('/:flowId', webhookHandlerByFlowId);
 

packages/backend/src/serializers/admin-saml-auth-provider.ee.js

@@ -0,0 +1,18 @@
+const adminSamlAuthProviderSerializer = (samlAuthProvider) => {
+  return {
+    id: samlAuthProvider.id,
+    name: samlAuthProvider.name,
+    certificate: samlAuthProvider.certificate,
+    signatureAlgorithm: samlAuthProvider.signatureAlgorithm,
+    issuer: samlAuthProvider.issuer,
+    entryPoint: samlAuthProvider.entryPoint,
+    firstnameAttributeName: samlAuthProvider.firstnameAttributeName,
+    surnameAttributeName: samlAuthProvider.surnameAttributeName,
+    emailAttributeName: samlAuthProvider.emailAttributeName,
+    roleAttributeName: samlAuthProvider.roleAttributeName,
+    active: samlAuthProvider.active,
+    defaultRoleId: samlAuthProvider.defaultRoleId,
+  };
+};
+
+export default adminSamlAuthProviderSerializer;

packages/backend/src/serializers/admin-saml-auth-provider.ee.test.js

@@ -0,0 +1,32 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createSamlAuthProvider } from '../../test/factories/saml-auth-provider.ee.js';
+import adminSamlAuthProviderSerializer from './admin-saml-auth-provider.ee.js';
+
+describe('adminSamlAuthProviderSerializer', () => {
+  let samlAuthProvider;
+
+  beforeEach(async () => {
+    samlAuthProvider = await createSamlAuthProvider();
+  });
+
+  it('should return saml auth provider data', async () => {
+    const expectedPayload = {
+      id: samlAuthProvider.id,
+      name: samlAuthProvider.name,
+      certificate: samlAuthProvider.certificate,
+      signatureAlgorithm: samlAuthProvider.signatureAlgorithm,
+      issuer: samlAuthProvider.issuer,
+      entryPoint: samlAuthProvider.entryPoint,
+      firstnameAttributeName: samlAuthProvider.firstnameAttributeName,
+      surnameAttributeName: samlAuthProvider.surnameAttributeName,
+      emailAttributeName: samlAuthProvider.emailAttributeName,
+      roleAttributeName: samlAuthProvider.roleAttributeName,
+      active: samlAuthProvider.active,
+      defaultRoleId: samlAuthProvider.defaultRoleId,
+    };
+
+    expect(adminSamlAuthProviderSerializer(samlAuthProvider)).toEqual(
+      expectedPayload
+    );
+  });
+});

packages/backend/src/serializers/app-config.js

@@ -0,0 +1,15 @@
+const appConfigSerializer = (appConfig) => {
+  return {
+    id: appConfig.id,
+    key: appConfig.key,
+    allowCustomConnection: appConfig.allowCustomConnection,
+    shared: appConfig.shared,
+    disabled: appConfig.disabled,
+    canConnect: appConfig.canConnect,
+    canCustomConnect: appConfig.canCustomConnect,
+    createdAt: appConfig.createdAt.getTime(),
+    updatedAt: appConfig.updatedAt.getTime(),
+  };
+};
+
+export default appConfigSerializer;

packages/backend/src/serializers/app-config.test.js

@@ -0,0 +1,27 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createAppConfig } from '../../test/factories/app-config';
+import appConfigSerializer from './app-config';
+
+describe('appConfig serializer', () => {
+  let appConfig;
+
+  beforeEach(async () => {
+    appConfig = await createAppConfig();
+  });
+
+  it('should return app config data', async () => {
+    const expectedPayload = {
+      id: appConfig.id,
+      key: appConfig.key,
+      allowCustomConnection: appConfig.allowCustomConnection,
+      shared: appConfig.shared,
+      disabled: appConfig.disabled,
+      canConnect: appConfig.canConnect,
+      canCustomConnect: appConfig.canCustomConnect,
+      createdAt: appConfig.createdAt.getTime(),
+      updatedAt: appConfig.updatedAt.getTime(),
+    };
+
+    expect(appConfigSerializer(appConfig)).toEqual(expectedPayload);
+  });
+});

packages/backend/src/serializers/connection.js

@@ -0,0 +1,16 @@
+const connectionSerializer = (connection) => {
+  return {
+    id: connection.id,
+    key: connection.key,
+    reconnectable: connection.reconnectable,
+    appAuthClientId: connection.appAuthClientId,
+    formattedData: {
+      screenName: connection.formattedData.screenName,
+    },
+    verified: connection.verified,
+    createdAt: connection.createdAt.getTime(),
+    updatedAt: connection.updatedAt.getTime(),
+  };
+};
+
+export default connectionSerializer;

packages/backend/src/serializers/connection.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createConnection } from '../../test/factories/connection';
+import connectionSerializer from './connection';
+
+describe('connectionSerializer', () => {
+  let connection;
+
+  beforeEach(async () => {
+    connection = await createConnection();
+  });
+
+  it('should return connection data', async () => {
+    const expectedPayload = {
+      id: connection.id,
+      key: connection.key,
+      reconnectable: connection.reconnectable,
+      appAuthClientId: connection.appAuthClientId,
+      formattedData: {
+        screenName: connection.formattedData.screenName,
+      },
+      verified: connection.verified,
+      createdAt: connection.createdAt.getTime(),
+      updatedAt: connection.updatedAt.getTime(),
+    };
+
+    expect(connectionSerializer(connection)).toEqual(expectedPayload);
+  });
+});

packages/backend/src/serializers/index.js

@@ -1,31 +1,41 @@
 import userSerializer from './user.js';
 import roleSerializer from './role.js';
 import permissionSerializer from './permission.js';
+import adminSamlAuthProviderSerializer from './admin-saml-auth-provider.ee.js';
 import samlAuthProviderSerializer from './saml-auth-provider.ee.js';
+import samlAuthProviderRoleMappingSerializer from './role-mapping.ee.js';
 import appAuthClientSerializer from './app-auth-client.js';
+import appConfigSerializer from './app-config.js';
 import flowSerializer from './flow.js';
 import stepSerializer from './step.js';
+import connectionSerializer from './connection.js';
 import appSerializer from './app.js';
 import authSerializer from './auth.js';
 import triggerSerializer from './trigger.js';
 import actionSerializer from './action.js';
 import executionSerializer from './execution.js';
 import executionStepSerializer from './execution-step.js';
+import subscriptionSerializer from './subscription.ee.js';
 
 const serializers = {
   User: userSerializer,
   Role: roleSerializer,
   Permission: permissionSerializer,
+  AdminSamlAuthProvider: adminSamlAuthProviderSerializer,
   SamlAuthProvider: samlAuthProviderSerializer,
+  SamlAuthProvidersRoleMapping: samlAuthProviderRoleMappingSerializer,
   AppAuthClient: appAuthClientSerializer,
+  AppConfig: appConfigSerializer,
   Flow: flowSerializer,
   Step: stepSerializer,
+  Connection: connectionSerializer,
   App: appSerializer,
   Auth: authSerializer,
   Trigger: triggerSerializer,
   Action: actionSerializer,
   Execution: executionSerializer,
   ExecutionStep: executionStepSerializer,
+  Subscription: subscriptionSerializer,
 };
 
 export default serializers;

packages/backend/src/serializers/role-mapping.ee.js

@@ -0,0 +1,10 @@
+const roleMappingSerializer = (roleMapping) => {
+  return {
+    id: roleMapping.id,
+    samlAuthProviderId: roleMapping.samlAuthProviderId,
+    roleId: roleMapping.roleId,
+    remoteRoleName: roleMapping.remoteRoleName,
+  };
+};
+
+export default roleMappingSerializer;

packages/backend/src/serializers/saml-auth-provider.ee.js

@@ -2,16 +2,8 @@ const samlAuthProviderSerializer = (samlAuthProvider) => {
   return {
     id: samlAuthProvider.id,
     name: samlAuthProvider.name,
-    certificate: samlAuthProvider.certificate,
-    signatureAlgorithm: samlAuthProvider.signatureAlgorithm,
+    loginUrl: samlAuthProvider.loginUrl,
     issuer: samlAuthProvider.issuer,
-    entryPoint: samlAuthProvider.entryPoint,
-    firstnameAttributeName: samlAuthProvider.firstnameAttributeName,
-    surnameAttributeName: samlAuthProvider.surnameAttributeName,
-    emailAttributeName: samlAuthProvider.emailAttributeName,
-    roleAttributeName: samlAuthProvider.roleAttributeName,
-    active: samlAuthProvider.active,
-    defaultRoleId: samlAuthProvider.defaultRoleId,
   };
 };
 

packages/backend/src/serializers/saml-auth-provider.ee.test.js

@@ -13,16 +13,8 @@ describe('samlAuthProviderSerializer', () => {
     const expectedPayload = {
       id: samlAuthProvider.id,
       name: samlAuthProvider.name,
-      certificate: samlAuthProvider.certificate,
-      signatureAlgorithm: samlAuthProvider.signatureAlgorithm,
+      loginUrl: samlAuthProvider.loginUrl,
       issuer: samlAuthProvider.issuer,
-      entryPoint: samlAuthProvider.entryPoint,
-      firstnameAttributeName: samlAuthProvider.firstnameAttributeName,
-      surnameAttributeName: samlAuthProvider.surnameAttributeName,
-      emailAttributeName: samlAuthProvider.emailAttributeName,
-      roleAttributeName: samlAuthProvider.roleAttributeName,
-      active: samlAuthProvider.active,
-      defaultRoleId: samlAuthProvider.defaultRoleId,
     };
 
     expect(samlAuthProviderSerializer(samlAuthProvider)).toEqual(

packages/backend/src/serializers/subscription.ee.js

@@ -0,0 +1,20 @@
+const subscriptinSerializer = (subscription) => {
+  let userData = {
+    id: subscription.id,
+    paddleSubscriptionId: subscription.paddleSubscriptionId,
+    paddlePlanId: subscription.paddlePlanId,
+    updateUrl: subscription.updateUrl,
+    cancelUrl: subscription.cancelUrl,
+    status: subscription.status,
+    nextBillAmount: subscription.nextBillAmount,
+    nextBillDate: subscription.nextBillDate,
+    lastBillDate: subscription.lastBillDate,
+    createdAt: subscription.createdAt.getTime(),
+    updatedAt: subscription.updatedAt.getTime(),
+    cancellationEffectiveDate: subscription.cancellationEffectiveDate,
+  };
+
+  return userData;
+};
+
+export default subscriptinSerializer;

packages/backend/src/serializers/subscription.ee.test.js

@@ -0,0 +1,35 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import appConfig from '../config/app';
+import { createUser } from '../../test/factories/user';
+import { createSubscription } from '../../test/factories/subscription';
+import subscriptionSerializer from './subscription.ee.js';
+
+describe('subscriptionSerializer', () => {
+  let user, subscription;
+
+  beforeEach(async () => {
+    user = await createUser();
+    subscription = await createSubscription({ userId: user.id });
+  });
+
+  it('should return subscription data', async () => {
+    vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(true);
+
+    const expectedPayload = {
+      id: subscription.id,
+      paddleSubscriptionId: subscription.paddleSubscriptionId,
+      paddlePlanId: subscription.paddlePlanId,
+      updateUrl: subscription.updateUrl,
+      cancelUrl: subscription.cancelUrl,
+      status: subscription.status,
+      nextBillAmount: subscription.nextBillAmount,
+      nextBillDate: subscription.nextBillDate,
+      lastBillDate: subscription.lastBillDate,
+      createdAt: subscription.createdAt.getTime(),
+      updatedAt: subscription.updatedAt.getTime(),
+      cancellationEffectiveDate: subscription.cancellationEffectiveDate,
+    };
+
+    expect(subscriptionSerializer(subscription)).toEqual(expectedPayload);
+  });
+});

packages/backend/test/factories/app-config.js

@@ -1,13 +1,9 @@
 import AppConfig from '../../src/models/app-config.js';
 
 export const createAppConfig = async (params = {}) => {
-  const appConfigData = {
-    key: params?.key || 'gitlab',
-  };
+  params.key = params?.key || 'gitlab';
 
-  const appConfig = await AppConfig.query()
-    .insert(appConfigData)
-    .returning('*');
+  const appConfig = await AppConfig.query().insert(params).returning('*');
 
   return appConfig;
 };

packages/backend/test/factories/connection.js

@@ -17,7 +17,7 @@ export const createConnection = async (params = {}) => {
     appConfig.encryptionKey
   ).toString();
 
-  const connection = await Connection.query().insert(params).returning('*');
+  const connection = await Connection.query().insertAndFetch(params);
 
   return connection;
 };

packages/backend/test/factories/role-mapping.js

@@ -0,0 +1,16 @@
+import { createRole } from './role.js';
+import { createSamlAuthProvider } from './saml-auth-provider.ee.js';
+import SamlAuthProviderRoleMapping from '../../src/models/saml-auth-providers-role-mapping.ee.js';
+
+export const createRoleMapping = async (params = {}) => {
+  params.roleId = params?.roleId || (await createRole()).id;
+  params.samlAuthProviderId =
+    params?.samlAuthProviderId || (await createSamlAuthProvider()).id;
+
+  params.remoteRoleName = params?.remoteRoleName || 'User';
+
+  const samlAuthProviderRoleMapping =
+    await SamlAuthProviderRoleMapping.query().insertAndFetch(params);
+
+  return samlAuthProviderRoleMapping;
+};

packages/backend/test/factories/subscription.js

@@ -0,0 +1,21 @@
+import { DateTime } from 'luxon';
+import { createUser } from './user';
+import Subscription from '../../src/models/subscription.ee.js';
+
+export const createSubscription = async (params = {}) => {
+  params.userId = params?.userId || (await createUser()).id;
+  params.paddleSubscriptionId =
+    params?.paddleSubscriptionId || 'paddleSubscriptionId';
+
+  params.paddlePlanId = params?.paddlePlanId || '47384';
+  params.updateUrl = params?.updateUrl || 'https://example.com/update-url';
+  params.cancelUrl = params?.cancelUrl || 'https://example.com/cancel-url';
+  params.status = params?.status || 'active';
+  params.nextBillAmount = params?.nextBillAmount || '20';
+  params.nextBillDate =
+    params?.nextBillDate || DateTime.now().plus({ days: 30 }).toISODate();
+
+  const subscription = await Subscription.query().insert(params).returning('*');
+
+  return subscription;
+};

packages/backend/test/factories/usage-data.js

@@ -0,0 +1,15 @@
+import { DateTime } from 'luxon';
+import { createUser } from './user';
+import UsageData from '../../src/models/usage-data.ee.js';
+
+export const createUsageData = async (params = {}) => {
+  params.userId = params?.userId || (await createUser()).id;
+  params.nextResetAt =
+    params?.nextResetAt || DateTime.now().plus({ days: 30 }).toISODate();
+
+  params.consumedTaskCount = params?.consumedTaskCount || 0;
+
+  const usageData = await UsageData.query().insertAndFetch(params);
+
+  return usageData;
+};

packages/backend/test/mocks/rest/api/v1/admin/saml-auth-providers/get-role-mappings.ee.js

@@ -0,0 +1,23 @@
+const getRoleMappingsMock = async (roleMappings) => {
+  const data = roleMappings.map((roleMapping) => {
+    return {
+      id: roleMapping.id,
+      samlAuthProviderId: roleMapping.samlAuthProviderId,
+      roleId: roleMapping.roleId,
+      remoteRoleName: roleMapping.remoteRoleName,
+    };
+  });
+
+  return {
+    data: data,
+    meta: {
+      count: data.length,
+      currentPage: null,
+      isArray: true,
+      totalPages: null,
+      type: 'SamlAuthProvidersRoleMapping',
+    },
+  };
+};
+
+export default getRoleMappingsMock;

packages/backend/test/mocks/rest/api/v1/app-configs/get-app-config.js

@@ -0,0 +1,24 @@
+const getAppConfigMock = (appConfig) => {
+  return {
+    data: {
+      id: appConfig.id,
+      key: appConfig.key,
+      allowCustomConnection: appConfig.allowCustomConnection,
+      shared: appConfig.shared,
+      disabled: appConfig.disabled,
+      canConnect: appConfig.canConnect,
+      canCustomConnect: appConfig.canCustomConnect,
+      createdAt: appConfig.createdAt.getTime(),
+      updatedAt: appConfig.updatedAt.getTime(),
+    },
+    meta: {
+      count: 1,
+      currentPage: null,
+      isArray: false,
+      totalPages: null,
+      type: 'AppConfig',
+    },
+  };
+};
+
+export default getAppConfigMock;

packages/backend/test/mocks/rest/api/v1/automatisch/config.js

@@ -0,0 +1,28 @@
+const infoMock = (
+  logoConfig,
+  primaryDarkConfig,
+  primaryLightConfig,
+  primaryMainConfig,
+  titleConfig
+) => {
+  return {
+    data: {
+      disableFavicon: false,
+      disableNotificationsPage: false,
+      'logo.svgData': logoConfig.value.data,
+      'palette.primary.dark': primaryDarkConfig.value.data,
+      'palette.primary.light': primaryLightConfig.value.data,
+      'palette.primary.main': primaryMainConfig.value.data,
+      title: titleConfig.value.data,
+    },
+    meta: {
+      count: 1,
+      currentPage: null,
+      isArray: false,
+      totalPages: null,
+      type: 'Object',
+    },
+  };
+};
+
+export default infoMock;

packages/backend/test/mocks/rest/api/v1/flows/get-flows.js

@@ -0,0 +1,36 @@
+const getFlowsMock = async (flows, steps) => {
+  const data = flows.map((flow) => {
+    const flowSteps = steps.filter((step) => step.flowId === flow.id);
+
+    return {
+      active: flow.active,
+      id: flow.id,
+      name: flow.name,
+      status: flow.active ? 'published' : 'draft',
+      steps: flowSteps.map((step) => ({
+        appKey: step.appKey,
+        iconUrl: step.iconUrl,
+        id: step.id,
+        key: step.key,
+        parameters: step.parameters,
+        position: step.position,
+        status: step.status,
+        type: step.type,
+        webhookUrl: step.webhookUrl,
+      })),
+    };
+  });
+
+  return {
+    data: data,
+    meta: {
+      count: data.length,
+      currentPage: 1,
+      isArray: true,
+      totalPages: 1,
+      type: 'Flow',
+    },
+  };
+};
+
+export default getFlowsMock;

packages/backend/test/mocks/rest/api/v1/saml-auth-providers/get-saml-auth-providers.js

@@ -0,0 +1,23 @@
+const getSamlAuthProvidersMock = async (samlAuthProviders) => {
+  const data = samlAuthProviders.map((samlAuthProvider) => {
+    return {
+      id: samlAuthProvider.id,
+      name: samlAuthProvider.name,
+      loginUrl: samlAuthProvider.loginUrl,
+      issuer: samlAuthProvider.issuer,
+    };
+  });
+
+  return {
+    data: data,
+    meta: {
+      count: data.length,
+      currentPage: null,
+      isArray: true,
+      totalPages: null,
+      type: 'SamlAuthProvider',
+    },
+  };
+};
+
+export default getSamlAuthProvidersMock;

packages/backend/test/mocks/rest/api/v1/steps/get-connection.js

@@ -0,0 +1,27 @@
+const getConnectionMock = async (connection) => {
+  const data = {
+    id: connection.id,
+    key: connection.key,
+    verified: connection.verified,
+    reconnectable: connection.reconnectable,
+    appAuthClientId: connection.appAuthClientId,
+    formattedData: {
+      screenName: connection.formattedData.screenName,
+    },
+    createdAt: connection.createdAt.getTime(),
+    updatedAt: connection.updatedAt.getTime(),
+  };
+
+  return {
+    data: data,
+    meta: {
+      count: 1,
+      currentPage: null,
+      isArray: false,
+      totalPages: null,
+      type: 'Connection',
+    },
+  };
+};
+
+export default getConnectionMock;