circle-ci integration on progress

backend/src/controllers/v1/integrationAuthController.ts

@@ -1,23 +1,16 @@
-import { Request, Response } from 'express';
-import { Types } from 'mongoose';
-import * as Sentry from '@sentry/node';
-import {
-	Integration, 
-	IntegrationAuth,
-	Bot 
-} from '../../models';
-import { INTEGRATION_SET, INTEGRATION_OPTIONS } from '../../variables';
-import { IntegrationService } from '../../services';
-import { getApps, revokeAccess } from '../../integrations';
+import { Request, Response } from "express";
+import { Types } from "mongoose";
+import * as Sentry from "@sentry/node";
+import { Integration, IntegrationAuth, Bot } from "../../models";
+import { INTEGRATION_SET, INTEGRATION_OPTIONS } from "../../variables";
+import { IntegrationService } from "../../services";
+import { getApps, revokeAccess } from "../../integrations";
 
-export const getIntegrationOptions = async (
-	req: Request,
-	res: Response
-) => {
-	return res.status(200).send({
-		integrationOptions: INTEGRATION_OPTIONS
-	});
-}
+export const getIntegrationOptions = async (req: Request, res: Response) => {
+  return res.status(200).send({
+    integrationOptions: INTEGRATION_OPTIONS,
+  });
+};
 
 /**
  * Perform OAuth2 code-token exchange as part of integration [integration] for workspace with id [workspaceId]
@@ -25,100 +18,103 @@ export const getIntegrationOptions = async (
  * @param res
  * @returns
  */
-export const oAuthExchange = async (
-	req: Request,
-	res: Response
-) => {
-	try {
-		const { workspaceId, code, integration } = req.body;
+export const oAuthExchange = async (req: Request, res: Response) => {
+  try {
+    const { workspaceId, code, integration } = req.body;
 
-		if (!INTEGRATION_SET.has(integration))
-			throw new Error('Failed to validate integration');
-		
-		const environments = req.membership.workspace?.environments || [];
-		if(environments.length === 0){
-			throw new Error("Failed to get environments")
-		}
-	
-		await IntegrationService.handleOAuthExchange({
-			workspaceId,
-			integration,
-			code,
-			environment: environments[0].slug,
-		});
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to get OAuth2 code-token exchange'
-		});
-	}
+    if (!INTEGRATION_SET.has(integration))
+      throw new Error("Failed to validate integration");
 
-	return res.status(200).send({
-		message: 'Successfully enabled integration authorization'
-	});
+    const environments = req.membership.workspace?.environments || [];
+    if (environments.length === 0) {
+      throw new Error("Failed to get environments");
+    }
+
+    await IntegrationService.handleOAuthExchange({
+      workspaceId,
+      integration,
+      code,
+      environment: environments[0].slug,
+    });
+  } catch (err) {
+    Sentry.setUser({ email: req.user.email });
+    Sentry.captureException(err);
+    return res.status(400).send({
+      message: "Failed to get OAuth2 code-token exchange",
+    });
+  }
+
+  return res.status(200).send({
+    message: "Successfully enabled integration authorization",
+  });
 };
 
 /**
  * Save integration access token as part of integration [integration] for workspace with id [workspaceId]
- * @param req 
- * @param res 
+ * @param req
+ * @param res
  */
 export const saveIntegrationAccessToken = async (
-	req: Request,
-	res: Response
+  req: Request,
+  res: Response
 ) => {
-	// TODO: refactor
-	let integrationAuth;
-	try {
-		const {
-			workspaceId,
-			accessToken,
-			integration
-		}: {
-			workspaceId: string;
-			accessToken: string;
-			integration: string;
-		} = req.body;
+  // TODO: refactor
+  let integrationAuth;
+  try {
+    const {
+      workspaceId,
+      accessToken,
+      integration,
+    }: {
+      workspaceId: string;
+      accessToken: string;
+      integration: string;
+    } = req.body;
 
-		integrationAuth = await IntegrationAuth.findOneAndUpdate({
-            workspace: new Types.ObjectId(workspaceId),
-            integration
-        }, {
-            workspace: new Types.ObjectId(workspaceId),
-            integration
-		}, {
-            new: true,
-            upsert: true
-        });
+    integrationAuth = await IntegrationAuth.findOneAndUpdate(
+      {
+        workspace: new Types.ObjectId(workspaceId),
+        integration,
+      },
+      {
+        workspace: new Types.ObjectId(workspaceId),
+        integration,
+      },
+      {
+        new: true,
+        upsert: true,
+      }
+    );
 
-		const bot = await Bot.findOne({
-            workspace: new Types.ObjectId(workspaceId),
-            isActive: true
-        });
-        
-        if (!bot) throw new Error('Bot must be enabled to save integration access token');
-		
-		// encrypt and save integration access token
-		integrationAuth = await IntegrationService.setIntegrationAuthAccess({
-			integrationAuthId: integrationAuth._id.toString(),
-			accessToken,
-			accessExpiresAt: undefined
-		});
-		
-		if (!integrationAuth) throw new Error('Failed to save integration access token');
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to save access token for integration'
-		});
-	}
-	
-	return res.status(200).send({
-		integrationAuth
-	});
-}
+    const bot = await Bot.findOne({
+      workspace: new Types.ObjectId(workspaceId),
+      isActive: true,
+    });
+
+    if (!bot)
+      throw new Error("Bot must be enabled to save integration access token");
+
+    // encrypt and save integration access token
+    integrationAuth = await IntegrationService.setIntegrationAuthAccess({
+      integrationAuthId: integrationAuth._id.toString(),
+      accessToken,
+      accessExpiresAt: undefined,
+    });
+
+    if (!integrationAuth)
+      throw new Error("Failed to save integration access token");
+  } catch (err) {
+    Sentry.setUser({ email: req.user.email });
+    Sentry.captureException(err);
+    return res.status(400).send({
+      message: "Failed to save access token for integration",
+    });
+  }
+
+  return res.status(200).send({
+    integrationAuth,
+  });
+};
 
 /**
  * Return list of applications allowed for integration with integration authorization id [integrationAuthId]
@@ -127,23 +123,24 @@ export const saveIntegrationAccessToken = async (
  * @returns
  */
 export const getIntegrationAuthApps = async (req: Request, res: Response) => {
-	let apps;
-	try {
-		apps = await getApps({
-			integrationAuth: req.integrationAuth,
-			accessToken: req.accessToken
-		});
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-        Sentry.captureException(err);	
-		return res.status(400).send({
-			message: 'Failed to get integration authorization applications'
-		});
-	}
+  let apps;
+  try {
+    apps = await getApps({
+      integrationAuth: req.integrationAuth,
+      accessToken: req.accessToken,
+    });
+  } catch (err) {
+    console.log(err); // testing
+    Sentry.setUser({ email: req.user.email });
+    Sentry.captureException(err);
+    return res.status(400).send({
+      message: "Failed to get integration authorization applications",
+    });
+  }
 
-	return res.status(200).send({
-		apps
-	});
+  return res.status(200).send({
+    apps,
+  });
 };
 
 /**
@@ -153,21 +150,21 @@ export const getIntegrationAuthApps = async (req: Request, res: Response) => {
  * @returns
  */
 export const deleteIntegrationAuth = async (req: Request, res: Response) => {
-	let integrationAuth;
-	try {
-		integrationAuth = await revokeAccess({
-			integrationAuth: req.integrationAuth,
-			accessToken: req.accessToken
-		});
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-        Sentry.captureException(err);	
-		return res.status(400).send({
-			message: 'Failed to delete integration authorization'
-		});
-	}
-	
-	return res.status(200).send({
-		integrationAuth
-	});
-}
+  let integrationAuth;
+  try {
+    integrationAuth = await revokeAccess({
+      integrationAuth: req.integrationAuth,
+      accessToken: req.accessToken,
+    });
+  } catch (err) {
+    Sentry.setUser({ email: req.user.email });
+    Sentry.captureException(err);
+    return res.status(400).send({
+      message: "Failed to delete integration authorization",
+    });
+  }
+
+  return res.status(200).send({
+    integrationAuth,
+  });
+};

backend/src/controllers/v1/integrationController.ts

@@ -1,44 +1,40 @@
-import { Request, Response } from 'express';
-import * as Sentry from '@sentry/node';
-import { 
-	Integration, 
-	Workspace,
-	Bot, 
-	BotKey 
-} from '../../models';
-import { EventService } from '../../services';
-import { eventPushSecrets } from '../../events';
+import { Request, Response } from "express";
+import * as Sentry from "@sentry/node";
+import { Integration, Workspace, Bot, BotKey } from "../../models";
+import { EventService } from "../../services";
+import { eventPushSecrets } from "../../events";
 
 /**
  * Create/initialize an (empty) integration for integration authorization
- * @param req 
- * @param res 
- * @returns 
+ * @param req
+ * @param res
+ * @returns
  */
 export const createIntegration = async (req: Request, res: Response) => {
-	let integration;
-	try {
-		// initialize new integration after saving integration access token
-        integration = await new Integration({
-            workspace: req.integrationAuth.workspace._id,
-            isActive: false,
-            app: null,
-            environment: req.integrationAuth.workspace?.environments[0].slug,
-            integration: req.integrationAuth.integration,
-            integrationAuth: req.integrationAuth._id
-        }).save();
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to create integration'
-		});
-	}
+  let integration;
+  try {
+    // initialize new integration after saving integration access token
+    integration = await new Integration({
+      workspace: req.integrationAuth.workspace._id,
+      isActive: false,
+      app: null,
+      environment: req.integrationAuth.workspace?.environments[0].slug,
+      integration: req.integrationAuth.integration,
+      integrationAuth: req.integrationAuth._id,
+    }).save();
+  } catch (err) {
+    console.log(err);
+    Sentry.setUser({ email: req.user.email });
+    Sentry.captureException(err);
+    return res.status(400).send({
+      message: "Failed to create integration",
+    });
+  }
 
-	return res.status(200).send({
-		integration
-	});
-}
+  return res.status(200).send({
+    integration,
+  });
+};
 
 /**
  * Change environment or name of integration with id [integrationId]
@@ -47,57 +43,57 @@ export const createIntegration = async (req: Request, res: Response) => {
  * @returns
  */
 export const updateIntegration = async (req: Request, res: Response) => {
-	let integration;
-	
-	// TODO: add integration-specific validation to ensure that each
-	// integration has the correct fields populated in [Integration]
-	
-	try {
-		const { 
-			environment, 
-			isActive, 
-			app, 
-			appId,
-			targetEnvironment,
-			owner, // github-specific integration param
-		} = req.body;
-		
-		integration = await Integration.findOneAndUpdate(
-			{
-				_id: req.integration._id
-			},
-			{
-				environment,
-				isActive,
-				app,
-				appId,
-				targetEnvironment,
-				owner
-			},
-			{
-				new: true
-			}
-		);
-		
-		if (integration) {
-			// trigger event - push secrets
-			EventService.handleEvent({
-				event: eventPushSecrets({
-					workspaceId: integration.workspace.toString()
-				})
-			});
-		}
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to update integration'
-		});
-	}
+  let integration;
 
-	return res.status(200).send({
-		integration
-	});
+  // TODO: add integration-specific validation to ensure that each
+  // integration has the correct fields populated in [Integration]
+
+  try {
+    const {
+      environment,
+      isActive,
+      app,
+      appId,
+      targetEnvironment,
+      owner, // github-specific integration param
+    } = req.body;
+
+    integration = await Integration.findOneAndUpdate(
+      {
+        _id: req.integration._id,
+      },
+      {
+        environment,
+        isActive,
+        app,
+        appId,
+        targetEnvironment,
+        owner,
+      },
+      {
+        new: true,
+      }
+    );
+
+    if (integration) {
+      // trigger event - push secrets
+      EventService.handleEvent({
+        event: eventPushSecrets({
+          workspaceId: integration.workspace.toString(),
+        }),
+      });
+    }
+  } catch (err) {
+    Sentry.setUser({ email: req.user.email });
+    Sentry.captureException(err);
+    return res.status(400).send({
+      message: "Failed to update integration",
+    });
+  }
+
+  return res.status(200).send({
+    integration,
+  });
 };
 
 /**
@@ -108,24 +104,24 @@ export const updateIntegration = async (req: Request, res: Response) => {
  * @returns
  */
 export const deleteIntegration = async (req: Request, res: Response) => {
-	let integration;
-	try {
-		const { integrationId } = req.params;
+  let integration;
+  try {
+    const { integrationId } = req.params;
 
-		integration = await Integration.findOneAndDelete({
-			_id: integrationId
-		});
-		
-		if (!integration) throw new Error('Failed to find integration');
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to delete integration'
-		});
-	}
-	
-	return res.status(200).send({
-		integration
-	});
+    integration = await Integration.findOneAndDelete({
+      _id: integrationId,
+    });
+
+    if (!integration) throw new Error("Failed to find integration");
+  } catch (err) {
+    Sentry.setUser({ email: req.user.email });
+    Sentry.captureException(err);
+    return res.status(400).send({
+      message: "Failed to delete integration",
+    });
+  }
+
+  return res.status(200).send({
+    integration,
+  });
 };

backend/src/integrations/apps.ts

@@ -321,9 +321,10 @@ const getAppsCircleci = async ({ accessToken }: { accessToken: string }) => {
       await axios.get(`${INTEGRATION_CIRCLECI_API_URL}/v2/me/collaborations`, {
         headers: {
           "Circle-Token": accessToken,
+          "Accept-Encoding": "application/json",
         },
       })
-    ).data;
+    ).data[0];
 
     const { slug } = circleciOrganizationDetail;
 
@@ -333,15 +334,17 @@ const getAppsCircleci = async ({ accessToken }: { accessToken: string }) => {
         {
           headers: {
             "Circle-Token": accessToken,
+            "Accept-Encoding": "application/json",
           },
         }
       )
-    ).data.items;
+    ).data?.items;
 
     apps = res.map((a: any) => ({
       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

@@ -87,12 +87,12 @@ const syncSecrets = async ({
           accessToken,
         });
         break;
-      // case INTEGRATION_CIRCLECI:
-      //   await syncSecretsCircleci({
-      //     integration,
-      //     secrets,
-      //     accessToken,
-      //   });
+      case INTEGRATION_CIRCLECI:
+        await syncSecretsCircleci({
+          integration,
+          secrets,
+          accessToken,
+        });
     }
   } catch (err) {
     Sentry.setUser(null);
@@ -831,14 +831,67 @@ const syncSecretsFlyio = async ({
   }
 };
 
-// const syncSecretsCircleci = async ({
-//   integration,
-//   secrets,
-//   accessToken,
-// }: {
-//   integration: IIntegration;
-//   secrets: any;
-//   accessToken: string;
-// }) => {};
+const syncSecretsCircleci = async ({
+  integration,
+  secrets,
+  accessToken,
+}: {
+  integration: IIntegration;
+  secrets: any;
+  accessToken: string;
+}) => {
+  try {
+    const circleciOrganizationDetail = (
+      await axios.get(`${INTEGRATION_CIRCLECI_API_URL}/v2/me/collaborations`, {
+        headers: {
+          "Circle-Token": accessToken,
+          "Accept-Encoding": "application/json",
+        },
+      })
+    ).data[0];
+
+    const { slug } = circleciOrganizationDetail;
+
+    // get secrets from CircleCI
+    const getSecretsRes = (
+      await axios.get(
+        `${INTEGRATION_CIRCLECI_API_URL}/v2/project/${slug}/${integration.app}/envvar`,
+        {
+          headers: {
+            "Circle-Token": accessToken,
+            "Accept-Encoding": "application/json",
+          },
+        }
+      )
+    ).data?.items;
+
+    console.log(getSecretsRes);
+    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(
+          `${INTEGRATION_CIRCLECI_API_URL}/v2/project/${slug}/${integration.app}/envvar`,
+          {
+            name: key,
+            value: secrets[key],
+          },
+          {
+            headers: {
+              "Circle-Token": accessToken,
+              "Content-Type": "application/json",
+            },
+          }
+        )
+    );
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error("Failed to sync secrets to CircleCI");
+  }
+};
 
 export { syncSecrets };

backend/src/models/integration.ts

@@ -6,6 +6,7 @@ import {
   INTEGRATION_GITHUB,
   INTEGRATION_RENDER,
   INTEGRATION_FLYIO,
+  INTEGRATION_CIRCLECI,
 } from "../variables";
 
 export interface IIntegration {
@@ -74,6 +75,7 @@ const integrationSchema = new Schema<IIntegration>(
         INTEGRATION_GITHUB,
         INTEGRATION_RENDER,
         INTEGRATION_FLYIO,
+        INTEGRATION_CIRCLECI,
       ],
       required: true,
     },

backend/src/models/integrationAuth.ts

@@ -4,6 +4,7 @@ import {
   INTEGRATION_VERCEL,
   INTEGRATION_NETLIFY,
   INTEGRATION_GITHUB,
+  INTEGRATION_CIRCLECI,
 } from "../variables";
 
 export interface IIntegrationAuth {
@@ -42,6 +43,7 @@ const integrationAuthSchema = new Schema<IIntegrationAuth>(
         INTEGRATION_VERCEL,
         INTEGRATION_NETLIFY,
         INTEGRATION_GITHUB,
+        INTEGRATION_CIRCLECI,
       ],
       required: true,
     },

backend/src/variables/integration.ts

@@ -138,8 +138,8 @@ const INTEGRATION_OPTIONS = [
     name: "Circle CI",
     slug: "circleci",
     image: "Circle CI.png",
-    isAvailable: false,
-    type: "",
+    isAvailable: true,
+    type: "pat",
     clientId: "",
     docsLink: "",
   },

backend/src/variables/organization.ts

@@ -1,24 +1,16 @@
 // membership roles
-const OWNER = 'owner';
-const ADMIN = 'admin';
-const MEMBER = 'member';
+const OWNER = "owner";
+const ADMIN = "admin";
+const MEMBER = "member";
 
 // membership statuses
-const INVITED = 'invited';
+const INVITED = "invited";
 
 // membership permissions ability
-const ABILITY_READ = 'read';
-const ABILITY_WRITE = 'write';
+const ABILITY_READ = "read";
+const ABILITY_WRITE = "write";
 
 // -- organization
-const ACCEPTED = 'accepted';
+const ACCEPTED = "accepted";
 
-export {
-    OWNER,
-    ADMIN,
-    MEMBER,
-    INVITED,
-    ACCEPTED,
-    ABILITY_READ,
-    ABILITY_WRITE
-}
+export { OWNER, ADMIN, MEMBER, INVITED, ACCEPTED, ABILITY_READ, ABILITY_WRITE };