chore(frontend): changed source code to src folder from root

frontend/src/pages/api/integrations/ChangeHerokuConfigVars.ts

@@ -0,0 +1,41 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+interface Props {
+  integrationId: string;
+  key: { encryptedKey: any; nonce: any };
+  secrets: {
+    ciphertextKey: any;
+    ivKey: any;
+    tagKey: any;
+    hashKey: any;
+    ciphertextValue: any;
+    ivValue: any;
+    tagValue: any;
+    hashValue: any;
+    type: string;
+  }[];
+}
+
+const changeHerokuConfigVars = ({ integrationId, key, secrets }: Props) => {
+  return SecurityClient.fetchCall(
+    '/api/v1/integration/' + integrationId + '/sync',
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        key,
+        secrets
+      })
+    }
+  ).then(async (res) => {
+    if (res && res.status == 200) {
+      return res;
+    } else {
+      console.log('Failed to sync secrets to Heroku');
+    }
+  });
+};
+
+export default changeHerokuConfigVars;

frontend/src/pages/api/integrations/DeleteIntegration.ts

@@ -0,0 +1,27 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+interface Props {
+  integrationId: string;
+}
+
+/**
+ * This route deletes an integration from a certain project
+ * @param {*} integrationId
+ * @returns
+ */
+const deleteIntegration = ({ integrationId }: Props) => {
+  return SecurityClient.fetchCall('/api/v1/integration/' + integrationId, {
+    method: 'DELETE',
+    headers: {
+      'Content-Type': 'application/json'
+    }
+  }).then(async (res) => {
+    if (res && res.status == 200) {
+      return (await res.json()).workspace;
+    } else {
+      console.log('Failed to delete an integration');
+    }
+  });
+};
+
+export default deleteIntegration;

frontend/src/pages/api/integrations/DeleteIntegrationAuth.ts

@@ -0,0 +1,30 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+interface Props {
+  integrationAuthId: string;
+}
+
+/**
+ * This route deletes an integration authorization from a certain project
+ * @param {*} integrationAuthId
+ * @returns
+ */
+const deleteIntegrationAuth = ({ integrationAuthId }: Props) => {
+  return SecurityClient.fetchCall(
+    '/api/v1/integration-auth/' + integrationAuthId,
+    {
+      method: 'DELETE',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }
+  ).then(async (res) => {
+    if (res && res.status == 200) {
+      return res;
+    } else {
+      console.log('Failed to delete an integration authorization');
+    }
+  });
+};
+
+export default deleteIntegrationAuth;

frontend/src/pages/api/integrations/GetIntegrationApps.ts

@@ -0,0 +1,25 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+interface Props {
+  integrationAuthId: string;
+}
+
+const getIntegrationApps = ({ integrationAuthId }: Props) => {
+  return SecurityClient.fetchCall(
+    '/api/v1/integration-auth/' + integrationAuthId + '/apps',
+    {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }
+  ).then(async (res) => {
+    if (res && res.status == 200) {
+      return (await res.json()).apps;
+    } else {
+      console.log('Failed to get available apps for an integration');
+    }
+  });
+};
+
+export default getIntegrationApps;

frontend/src/pages/api/integrations/GetIntegrationOptions.ts

@@ -0,0 +1,21 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+const getIntegrationOptions = () => {
+  return SecurityClient.fetchCall(
+    '/api/v1/integration-auth/integration-options',
+    {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }
+  ).then(async (res) => {
+    if (res && res.status == 200) {
+      return (await res.json()).integrationOptions;
+    } else {
+      console.log('Failed to get (cloud) integration options');
+    }
+  });
+};
+
+export default getIntegrationOptions;

frontend/src/pages/api/integrations/StartIntegration.ts

@@ -0,0 +1,36 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+interface Props {
+  integrationId: string;
+  appName: string;
+  environment: string;
+}
+
+/**
+ * This route starts the integration after teh default one if gonna set up.
+ * @param {*} integrationId
+ * @returns
+ */
+const startIntegration = ({ integrationId, appName, environment }: Props) => {
+  return SecurityClient.fetchCall('/api/v1/integration/' + integrationId, {
+    method: 'PATCH',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      update: {
+        app: appName,
+        environment,
+        isActive: true
+      }
+    })
+  }).then(async (res) => {
+    if (res && res.status == 200) {
+      return res;
+    } else {
+      console.log('Failed to start an integration');
+    }
+  });
+};
+
+export default startIntegration;

frontend/src/pages/api/integrations/authorizeIntegration.ts

@@ -0,0 +1,36 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+interface Props {
+  workspaceId: string;
+  code: string;
+  integration: string;
+}
+/**
+ * This is the first step of the change password process (pake)
+ * @param {object} obj
+ * @param {object} obj.workspaceId - project id for which we want to authorize the integration
+ * @param {object} obj.code
+ * @param {object} obj.integration - integration which a user is trying to turn on
+ * @returns
+ */
+const AuthorizeIntegration = ({ workspaceId, code, integration }: Props) => {
+  return SecurityClient.fetchCall('/api/v1/integration-auth/oauth-token', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      workspaceId,
+      code,
+      integration
+    })
+  }).then(async (res) => {
+    if (res && res.status == 200) {
+      return res;
+    } else {
+      console.log('Failed to authorize the integration');
+    }
+  });
+};
+
+export default AuthorizeIntegration;

frontend/src/pages/api/integrations/getWorkspaceAuthorizations.ts

@@ -0,0 +1,30 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+interface Props {
+  workspaceId: string;
+}
+
+/**
+ * This route gets authorizations of a certain project (Heroku, etc.)
+ * @param {*} workspaceId
+ * @returns
+ */
+const getWorkspaceAuthorizations = ({ workspaceId }: Props) => {
+  return SecurityClient.fetchCall(
+    '/api/v1/workspace/' + workspaceId + '/authorizations',
+    {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }
+  ).then(async (res) => {
+    if (res && res.status == 200) {
+      return (await res.json()).authorizations;
+    } else {
+      console.log('Failed to get project authorizations');
+    }
+  });
+};
+
+export default getWorkspaceAuthorizations;

frontend/src/pages/api/integrations/getWorkspaceIntegrations.ts

@@ -0,0 +1,30 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+interface Props {
+  workspaceId: string;
+}
+
+/**
+ * This route gets integrations of a certain project (Heroku, etc.)
+ * @param {*} workspaceId
+ * @returns
+ */
+const getWorkspaceIntegrations = ({ workspaceId }: Props) => {
+  return SecurityClient.fetchCall(
+    '/api/v1/workspace/' + workspaceId + '/integrations',
+    {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }
+  ).then(async (res) => {
+    if (res && res.status == 200) {
+      return (await res.json()).integrations;
+    } else {
+      console.log('Failed to get the project integrations');
+    }
+  });
+};
+
+export default getWorkspaceIntegrations;

frontend/src/pages/api/integrations/updateIntegration.ts

@@ -0,0 +1,60 @@
+import SecurityClient from "~/utilities/SecurityClient";
+
+/**
+ * This route starts the integration after teh default one if gonna set up.
+ * Update integration with id [integrationId] to sync envars from the project's
+ * [environment] to the integration [app] with active state [isActive]
+ * @param {Object} obj
+ * @param {String} obj.integrationId - id of integration
+ * @param {String} obj.app - name of app 
+ * @param {String} obj.environment - project environment to push secrets from
+ * @param {Boolean} obj.isActive - active state
+ * @param {String} obj.target - (optional) target (environment) for Vercel integration
+ * @param {String} obj.context - (optional) context (environment) for Netlify integration
+ * @param {String} obj.siteId - (optional) app (site_id) for Netlify integration
+ * @returns
+ */
+const updateIntegration = ({ 
+  integrationId, 
+  app, 
+  environment,
+  isActive,
+  target,
+  context,
+  siteId
+}: {
+  integrationId: string, 
+  app: string, 
+  environment: string,
+  isActive: boolean,
+  target: string | null,
+  context: string | null,
+  siteId: string | null
+
+}) => { 
+  return SecurityClient.fetchCall(
+    "/api/v1/integration/" + integrationId,
+    {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        app,
+        environment,
+        isActive,
+        target,
+        context,
+        siteId
+      }),
+    }
+  ).then(async (res) => {
+    if (res && res.status == 200) {
+      return res;
+    } else {
+      console.log("Failed to start an integration");
+    }
+  });
+};
+
+export default updateIntegration;