circle-ci integration done

backend/src/controllers/v1/integrationAuthController.ts

@@ -130,7 +130,6 @@ export const getIntegrationAuthApps = async (req: Request, res: Response) => {
       accessToken: req.accessToken,
     });
   } catch (err) {
-    console.log(err); // testing
     Sentry.setUser({ email: req.user.email });
     Sentry.captureException(err);
     return res.status(400).send({

backend/src/controllers/v1/integrationController.ts

@@ -23,7 +23,6 @@ export const createIntegration = async (req: Request, res: Response) => {
       integrationAuth: req.integrationAuth._id,
     }).save();
   } catch (err) {
-    console.log(err);
     Sentry.setUser({ email: req.user.email });
     Sentry.captureException(err);
     return res.status(400).send({

backend/src/controllers/v1/workspaceController.ts

@@ -1,5 +1,5 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import * as Sentry from '@sentry/node';
+import * as Sentry from "@sentry/node";
 import {
   Workspace,
   Membership,
@@ -8,14 +8,14 @@ import {
   IntegrationAuth,
   IUser,
   ServiceToken,
-	ServiceTokenData
+  ServiceTokenData,
-} from '../../models';
+} from "../../models";
 import {
   createWorkspace as create,
-	deleteWorkspace as deleteWork
+  deleteWorkspace as deleteWork,
-} from '../../helpers/workspace';
+} from "../../helpers/workspace";
-import { addMemberships } from '../../helpers/membership';
+import { addMemberships } from "../../helpers/membership";
-import { ADMIN } from '../../variables';
+import { ADMIN } from "../../variables";
 
 /**
  * Return public keys of members of workspace with id [workspaceId]
@@ -30,25 +30,24 @@ export const getWorkspacePublicKeys = async (req: Request, res: Response) => {
 
     publicKeys = (
       await Membership.find({
-				workspace: workspaceId
+        workspace: workspaceId,
-			}).populate<{ user: IUser }>('user', 'publicKey')
+      }).populate<{ user: IUser }>("user", "publicKey")
-		)
+    ).map((member) => {
-		.map((member) => {
       return {
         publicKey: member.user.publicKey,
-				userId: member.user._id
+        userId: member.user._id,
       };
     });
   } catch (err) {
     Sentry.setUser({ email: req.user.email });
     Sentry.captureException(err);
     return res.status(400).send({
-			message: 'Failed to get workspace member public keys'
+      message: "Failed to get workspace member public keys",
     });
   }
 
   return res.status(200).send({
-		publicKeys
+    publicKeys,
   });
 };
 
@@ -64,18 +63,18 @@ export const getWorkspaceMemberships = async (req: Request, res: Response) => {
     const { workspaceId } = req.params;
 
     users = await Membership.find({
-			workspace: workspaceId
+      workspace: workspaceId,
-		}).populate('user', '+publicKey');
+    }).populate("user", "+publicKey");
   } catch (err) {
     Sentry.setUser({ email: req.user.email });
     Sentry.captureException(err);
     return res.status(400).send({
-			message: 'Failed to get workspace members'
+      message: "Failed to get workspace members",
     });
   }
 
   return res.status(200).send({
-		users
+    users,
   });
 };
 
@@ -90,19 +89,19 @@ export const getWorkspaces = async (req: Request, res: Response) => {
   try {
     workspaces = (
       await Membership.find({
-				user: req.user._id
+        user: req.user._id,
-			}).populate('workspace')
+      }).populate("workspace")
     ).map((m) => m.workspace);
   } catch (err) {
     Sentry.setUser({ email: req.user.email });
     Sentry.captureException(err);
     return res.status(400).send({
-			message: 'Failed to get workspaces'
+      message: "Failed to get workspaces",
     });
   }
 
   return res.status(200).send({
-		workspaces
+    workspaces,
   });
 };
 
@@ -118,18 +117,18 @@ export const getWorkspace = async (req: Request, res: Response) => {
     const { workspaceId } = req.params;
 
     workspace = await Workspace.findOne({
-			_id: workspaceId
+      _id: workspaceId,
     });
   } catch (err) {
     Sentry.setUser({ email: req.user.email });
     Sentry.captureException(err);
     return res.status(400).send({
-			message: 'Failed to get workspace'
+      message: "Failed to get workspace",
     });
   }
 
   return res.status(200).send({
-		workspace
+    workspace,
   });
 };
 
@@ -148,38 +147,38 @@ export const createWorkspace = async (req: Request, res: Response) => {
     // validate organization membership
     const membershipOrg = await MembershipOrg.findOne({
       user: req.user._id,
-			organization: organizationId
+      organization: organizationId,
     });
 
     if (!membershipOrg) {
-			throw new Error('Failed to validate organization membership');
+      throw new Error("Failed to validate organization membership");
     }
 
     if (workspaceName.length < 1) {
-			throw new Error('Workspace names must be at least 1-character long');
+      throw new Error("Workspace names must be at least 1-character long");
     }
 
     // create workspace and add user as member
     workspace = await create({
       name: workspaceName,
-			organizationId
+      organizationId,
     });
 
     await addMemberships({
       userIds: [req.user._id],
       workspaceId: workspace._id.toString(),
-			roles: [ADMIN]
+      roles: [ADMIN],
     });
   } catch (err) {
     Sentry.setUser({ email: req.user.email });
     Sentry.captureException(err);
     return res.status(400).send({
-			message: 'Failed to create workspace'
+      message: "Failed to create workspace",
     });
   }
 
   return res.status(200).send({
-		workspace
+    workspace,
   });
 };
 
@@ -195,18 +194,18 @@ export const deleteWorkspace = async (req: Request, res: Response) => {
 
     // delete workspace
     await deleteWork({
-			id: workspaceId
+      id: workspaceId,
     });
   } catch (err) {
     Sentry.setUser({ email: req.user.email });
     Sentry.captureException(err);
     return res.status(400).send({
-			message: 'Failed to delete workspace'
+      message: "Failed to delete workspace",
     });
   }
 
   return res.status(200).send({
-		message: 'Successfully deleted workspace'
+    message: "Successfully deleted workspace",
   });
 };
 
@@ -224,26 +223,26 @@ export const changeWorkspaceName = async (req: Request, res: Response) => {
 
     workspace = await Workspace.findOneAndUpdate(
       {
-				_id: workspaceId
+        _id: workspaceId,
       },
       {
-				name
+        name,
       },
       {
-				new: true
+        new: true,
       }
     );
   } catch (err) {
     Sentry.setUser({ email: req.user.email });
     Sentry.captureException(err);
     return res.status(400).send({
-			message: 'Failed to change workspace name'
+      message: "Failed to change workspace name",
     });
   }
 
   return res.status(200).send({
-		message: 'Successfully changed workspace name',
+    message: "Successfully changed workspace name",
-		workspace
+    workspace,
   });
 };
 
@@ -259,18 +258,18 @@ export const getWorkspaceIntegrations = async (req: Request, res: Response) => {
     const { workspaceId } = req.params;
 
     integrations = await Integration.find({
-			workspace: workspaceId
+      workspace: workspaceId,
     });
   } catch (err) {
     Sentry.setUser({ email: req.user.email });
     Sentry.captureException(err);
     return res.status(400).send({
-			message: 'Failed to get workspace integrations'
+      message: "Failed to get workspace integrations",
     });
   }
 
   return res.status(200).send({
-		integrations
+    integrations,
   });
 };
 
@@ -289,18 +288,18 @@ export const getWorkspaceIntegrationAuthorizations = async (
     const { workspaceId } = req.params;
 
     authorizations = await IntegrationAuth.find({
-			workspace: workspaceId
+      workspace: workspaceId,
     });
   } catch (err) {
     Sentry.setUser({ email: req.user.email });
     Sentry.captureException(err);
     return res.status(400).send({
-			message: 'Failed to get workspace integration authorizations'
+      message: "Failed to get workspace integration authorizations",
     });
   }
 
   return res.status(200).send({
-		authorizations
+    authorizations,
   });
 };
 
@@ -320,17 +319,17 @@ export const getWorkspaceServiceTokens = async (
     // ?? FIX.
     serviceTokens = await ServiceToken.find({
       user: req.user._id,
-			workspace: workspaceId
+      workspace: workspaceId,
     });
   } catch (err) {
     Sentry.setUser({ email: req.user.email });
     Sentry.captureException(err);
     return res.status(400).send({
-			message: 'Failed to get workspace service tokens'
+      message: "Failed to get workspace service tokens",
     });
   }
 
   return res.status(200).send({
-		serviceTokens
+    serviceTokens,
   });
-}
+};

backend/src/integrations/apps.ts

@@ -344,7 +344,6 @@ const getAppsCircleci = async ({ accessToken }: { accessToken: string }) => {
       name: a?.project_slug?.split("/")[2],
     }));
   } catch (err) {
-    console.log(err);
     Sentry.setUser(null);
     Sentry.captureException(err);
     throw new Error("Failed to get Render services");

backend/src/integrations/sync.ts

@@ -865,12 +865,7 @@ const syncSecretsCircleci = async ({
       )
     ).data?.items;
 
-    console.log(getSecretsRes);
+    // inject secrets to CircleCI (one by one)
-    console.log(secrets);
-
-    // inject secrets to CircleCI
-    // note: no relivent api end point was found in CircleCI to do entire secrets at a same time so
-    // it is done one by one
     Object.keys(secrets).forEach(
       async (key) =>
         await axios.post(
@@ -887,6 +882,19 @@ const syncSecretsCircleci = async ({
           }
         )
     );
+
+    getSecretsRes.forEach(async (sec: any) => {
+      if (!(sec.name in secrets)) {
+        await axios.delete(
+          `${INTEGRATION_CIRCLECI_API_URL}/v2/project/${slug}/${integration.app}/envvar/${sec.name}`,
+          {
+            headers: {
+              "Circle-Token": accessToken,
+            },
+          }
+        );
+      }
+    });
   } catch (err) {
     Sentry.setUser(null);
     Sentry.captureException(err);