Merge branch 'main' into feat/error-handling

backend/src/integrations/apps.ts

@@ -1,17 +1,22 @@
 import axios from 'axios';
 import * as Sentry from '@sentry/node';
+import { Octokit } from '@octokit/rest';
+import { IIntegrationAuth } from '../models';
 import {
-    IIntegrationAuth
-} from '../models';
-import {
-    INTEGRATION_HEROKU,
-    INTEGRATION_VERCEL,
-    INTEGRATION_NETLIFY,
-    INTEGRATION_HEROKU_API_URL,
-    INTEGRATION_VERCEL_API_URL,
-    INTEGRATION_NETLIFY_API_URL
+  INTEGRATION_HEROKU,
+  INTEGRATION_VERCEL,
+  INTEGRATION_NETLIFY,
+  INTEGRATION_GITHUB,
+  INTEGRATION_HEROKU_API_URL,
+  INTEGRATION_VERCEL_API_URL,
+  INTEGRATION_NETLIFY_API_URL,
+  INTEGRATION_GITHUB_API_URL
 } from '../variables';
 
+interface GitHubApp {
+  name: string;
+}
+
 /**
  * Return list of names of apps for integration named [integration]
  * @param {Object} obj
@@ -21,47 +26,51 @@ import {
  * @returns {String} apps.name - name of integration app
  */
 const getApps = async ({
-    integrationAuth,
-    accessToken
+  integrationAuth,
+  accessToken
 }: {
-    integrationAuth: IIntegrationAuth;
-    accessToken: string;
+  integrationAuth: IIntegrationAuth;
+  accessToken: string;
 }) => {
-    
-    interface App {
-        name: string;
-        siteId?: string;
-    }
+  interface App {
+    name: string;
+    siteId?: string;
+  }
 
-    let apps: App[]; // TODO: add type and define payloads for apps
-    try {
-        switch (integrationAuth.integration) {
-            case INTEGRATION_HEROKU:
-                apps = await getAppsHeroku({
-                    accessToken
-                });
-                break;
-            case INTEGRATION_VERCEL:
-                apps = await getAppsVercel({
-                    accessToken
-                });
-                break;
-            case INTEGRATION_NETLIFY:
-                apps = await getAppsNetlify({
-                    integrationAuth,
-                    accessToken
-                });
-                break;
-        }
-
-    } catch (err) {
-        Sentry.setUser(null);
-        Sentry.captureException(err);
-        throw new Error('Failed to get integration apps');
+  let apps: App[]; // TODO: add type and define payloads for apps
+  try {
+    switch (integrationAuth.integration) {
+      case INTEGRATION_HEROKU:
+        apps = await getAppsHeroku({
+          accessToken
+        });
+        break;
+      case INTEGRATION_VERCEL:
+        apps = await getAppsVercel({
+          accessToken
+        });
+        break;
+      case INTEGRATION_NETLIFY:
+        apps = await getAppsNetlify({
+          integrationAuth,
+          accessToken
+        });
+        break;
+      case INTEGRATION_GITHUB:
+        apps = await getAppsGithub({
+          integrationAuth,
+          accessToken
+        });
+        break;
     }
-    
-    return apps;
-}
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed to get integration apps');
+  }
+
+  return apps;
+};
 
 /**
  * Return list of names of apps for Heroku integration
@@ -70,31 +79,29 @@ const getApps = async ({
  * @returns {Object[]} apps - names of Heroku apps
  * @returns {String} apps.name - name of Heroku app
  */
-const getAppsHeroku = async ({
-    accessToken
-}: {
-    accessToken: string;
-}) => {
-    let apps;
-    try {
-        const res = (await axios.get(`${INTEGRATION_HEROKU_API_URL}/apps`, {
-            headers: {
-                Accept: 'application/vnd.heroku+json; version=3',
-                Authorization: `Bearer ${accessToken}`
-            }
-        })).data;
-        
-        apps = res.map((a: any) => ({
-			name: a.name
-		}));
-    } catch (err) {
-        Sentry.setUser(null);
-        Sentry.captureException(err);
-        throw new Error('Failed to get Heroku integration apps');
-    }
-    
-    return apps;
-}
+const getAppsHeroku = async ({ accessToken }: { accessToken: string }) => {
+  let apps;
+  try {
+    const res = (
+      await axios.get(`${INTEGRATION_HEROKU_API_URL}/apps`, {
+        headers: {
+          Accept: 'application/vnd.heroku+json; version=3',
+          Authorization: `Bearer ${accessToken}`
+        }
+      })
+    ).data;
+
+    apps = res.map((a: any) => ({
+      name: a.name
+    }));
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed to get Heroku integration apps');
+  }
+
+  return apps;
+};
 
 /**
  * Return list of names of apps for Vercel integration
@@ -103,30 +110,28 @@ const getAppsHeroku = async ({
  * @returns {Object[]} apps - names of Vercel apps
  * @returns {String} apps.name - name of Vercel app
  */
-const getAppsVercel = async ({
-    accessToken
-}: {
-    accessToken: string;
-}) => {
-    let apps;
-    try {
-        const res = (await axios.get(`${INTEGRATION_VERCEL_API_URL}/v9/projects`, {
-            headers: {
-                Authorization: `Bearer ${accessToken}`
-            }
-        })).data;
-        
-        apps = res.projects.map((a: any) => ({
-			name: a.name
-		}));
-    } catch (err) {
-        Sentry.setUser(null);
-        Sentry.captureException(err);
-        throw new Error('Failed to get Vercel integration apps');
-    }
-    
-    return apps;
-}
+const getAppsVercel = async ({ accessToken }: { accessToken: string }) => {
+  let apps;
+  try {
+    const res = (
+      await axios.get(`${INTEGRATION_VERCEL_API_URL}/v9/projects`, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`
+        }
+      })
+    ).data;
+
+    apps = res.projects.map((a: any) => ({
+      name: a.name
+    }));
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed to get Vercel integration apps');
+  }
+
+  return apps;
+};
 
 /**
  * Return list of names of sites for Netlify integration
@@ -136,34 +141,73 @@ const getAppsVercel = async ({
  * @returns {String} apps.name - name of Netlify site
  */
 const getAppsNetlify = async ({
-    integrationAuth,
-    accessToken
+  integrationAuth,
+  accessToken
 }: {
-    integrationAuth: IIntegrationAuth;
-    accessToken: string;
+  integrationAuth: IIntegrationAuth;
+  accessToken: string;
 }) => {
-    let apps;
-    try {
-        const res = (await axios.get(`${INTEGRATION_NETLIFY_API_URL}/api/v1/sites`, {
-            headers: {
-                Authorization: `Bearer ${accessToken}`
-            }
-        })).data;
-        
-        apps = res.map((a: any) => ({
-			name: a.name,
-            siteId: a.site_id
-		}));
-        
-    } catch (err) {
-        Sentry.setUser(null);
-        Sentry.captureException(err);
-        throw new Error('Failed to get Netlify integration apps');
-    }
-    
-    return apps;
-}
+  let apps;
+  try {
+    const res = (
+      await axios.get(`${INTEGRATION_NETLIFY_API_URL}/api/v1/sites`, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`
+        }
+      })
+    ).data;
 
-export {
-    getApps
-}
+    apps = res.map((a: any) => ({
+      name: a.name,
+      siteId: a.site_id
+    }));
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed to get Netlify integration apps');
+  }
+
+  return apps;
+};
+
+/**
+ * Return list of names of repositories for Github integration
+ * @param {Object} obj
+ * @param {String} obj.accessToken - access token for Netlify API
+ * @returns {Object[]} apps - names of Netlify sites
+ * @returns {String} apps.name - name of Netlify site
+ */
+const getAppsGithub = async ({
+  integrationAuth,
+  accessToken
+}: {
+  integrationAuth: IIntegrationAuth;
+  accessToken: string;
+}) => {
+  let apps;
+  try {
+    const octokit = new Octokit({
+      auth: accessToken
+    });
+
+    const repos = (await octokit.request(
+      'GET /user/repos{?visibility,affiliation,type,sort,direction,per_page,page,since,before}',
+      {}
+    )).data;
+
+    apps = repos
+      .filter((a:any) => a.permissions.admin === true)
+      .map((a: any) => ({
+          name: a.name
+        })
+      );
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed to get Github repos');
+  }
+
+  return apps;
+};
+
+export { getApps };

backend/src/integrations/exchange.ts

@@ -1,46 +1,57 @@
 import axios from 'axios';
 import * as Sentry from '@sentry/node';
 import {
-    INTEGRATION_HEROKU,
-    INTEGRATION_VERCEL,
-    INTEGRATION_NETLIFY,
-    INTEGRATION_HEROKU_TOKEN_URL,
-    INTEGRATION_VERCEL_TOKEN_URL,
-    INTEGRATION_NETLIFY_TOKEN_URL,
-    ACTION_PUSH_TO_HEROKU
+  INTEGRATION_HEROKU,
+  INTEGRATION_VERCEL,
+  INTEGRATION_NETLIFY,
+  INTEGRATION_GITHUB,
+  INTEGRATION_HEROKU_TOKEN_URL,
+  INTEGRATION_VERCEL_TOKEN_URL,
+  INTEGRATION_NETLIFY_TOKEN_URL,
+  INTEGRATION_GITHUB_TOKEN_URL,
+  INTEGRATION_GITHUB_API_URL
 } from '../variables';
-import { 
-    SITE_URL,
-    CLIENT_SECRET_HEROKU,
-    CLIENT_ID_VERCEL,
-    CLIENT_ID_NETLIFY,
-    CLIENT_SECRET_VERCEL,
-    CLIENT_SECRET_NETLIFY
+import {
+  SITE_URL,
+  CLIENT_ID_VERCEL,
+  CLIENT_ID_NETLIFY,
+  CLIENT_ID_GITHUB,
+  CLIENT_SECRET_HEROKU,
+  CLIENT_SECRET_VERCEL,
+  CLIENT_SECRET_NETLIFY,
+  CLIENT_SECRET_GITHUB
 } from '../config';
+import { user } from '../routes';
 
 interface ExchangeCodeHerokuResponse {
-    token_type: string;
-    access_token: string;
-    expires_in: number;
-    refresh_token: string;
-    user_id: string;
-    session_nonce?: string;
+  token_type: string;
+  access_token: string;
+  expires_in: number;
+  refresh_token: string;
+  user_id: string;
+  session_nonce?: string;
 }
 
 interface ExchangeCodeVercelResponse {
-    token_type: string;
-    access_token: string;
-    installation_id: string;
-    user_id: string;
-    team_id?: string;
+  token_type: string;
+  access_token: string;
+  installation_id: string;
+  user_id: string;
+  team_id?: string;
 }
 
 interface ExchangeCodeNetlifyResponse {
-    access_token: string;
-    token_type: string;
-    refresh_token: string;
-    scope: string;
-    created_at: number;
+  access_token: string;
+  token_type: string;
+  refresh_token: string;
+  scope: string;
+  created_at: number;
+}
+
+interface ExchangeCodeGithubResponse {
+  access_token: string;
+  scope: string;
+  token_type: string;
 }
 
 /**
@@ -56,40 +67,45 @@ interface ExchangeCodeNetlifyResponse {
  * @returns {String} obj.action - integration action for bot sequence
  */
 const exchangeCode = async ({
-    integration,
-    code
-}: { 
-    integration: string;
-    code: string;
+  integration,
+  code
+}: {
+  integration: string;
+  code: string;
 }) => {
-    let obj = {} as any;
-                
-    try {
-        switch (integration) {
-            case INTEGRATION_HEROKU:
-                obj = await exchangeCodeHeroku({
-                    code
-                });
-                break;
-            case INTEGRATION_VERCEL:
-                obj = await exchangeCodeVercel({
-                    code
-                });
-                break;
-            case INTEGRATION_NETLIFY:
-                obj = await exchangeCodeNetlify({
-                    code
-                });
-                break;
-        } 
-    } catch (err) {
-        Sentry.setUser(null);
-        Sentry.captureException(err);
-        throw new Error('Failed OAuth2 code-token exchange');
+  let obj = {} as any;
+
+  try {
+    switch (integration) {
+      case INTEGRATION_HEROKU:
+        obj = await exchangeCodeHeroku({
+          code
+        });
+        break;
+      case INTEGRATION_VERCEL:
+        obj = await exchangeCodeVercel({
+          code
+        });
+        break;
+      case INTEGRATION_NETLIFY:
+        obj = await exchangeCodeNetlify({
+          code
+        });
+        break;
+      case INTEGRATION_GITHUB:
+        obj = await exchangeCodeGithub({
+          code
+        });
+        break;
     }
-    
-    return obj;
-}
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed OAuth2 code-token exchange');
+  }
+
+  return obj;
+};
 
 /**
  * Return [accessToken], [accessExpiresAt], and [refreshToken] for Heroku
@@ -144,35 +160,33 @@ const exchangeCodeHeroku = async ({
  * @returns {String} obj2.refreshToken - refresh token for Heroku API
  * @returns {Date} obj2.accessExpiresAt - date of expiration for access token
  */
-const exchangeCodeVercel = async ({
-    code
-}: {
-    code: string;
-}) => {
-    let res: ExchangeCodeVercelResponse;
-    try {
-        res = (await axios.post(
-            INTEGRATION_VERCEL_TOKEN_URL,
-            new URLSearchParams({
-				code: code,
-                client_id: CLIENT_ID_VERCEL,
-				client_secret: CLIENT_SECRET_VERCEL,
-                redirect_uri: `${SITE_URL}/vercel`
-			} as any)
-        )).data;
-    } catch (err) {
-        Sentry.setUser(null);
-        Sentry.captureException(err);
-        throw new Error('Failed OAuth2 code-token exchange with Vercel');
-    }
-    
-    return ({
-        accessToken: res.access_token,
-        refreshToken: null,
-        accessExpiresAt: null,
-        teamId: res.team_id
-    });
-}
+const exchangeCodeVercel = async ({ code }: { code: string }) => {
+  let res: ExchangeCodeVercelResponse;
+  try {
+    res = (
+      await axios.post(
+        INTEGRATION_VERCEL_TOKEN_URL,
+        new URLSearchParams({
+          code: code,
+          client_id: CLIENT_ID_VERCEL,
+          client_secret: CLIENT_SECRET_VERCEL,
+          redirect_uri: `${SITE_URL}/vercel`
+        } as any)
+      )
+    ).data;
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed OAuth2 code-token exchange with Vercel');
+  }
+
+  return {
+    accessToken: res.access_token,
+    refreshToken: null,
+    accessExpiresAt: null,
+    teamId: res.team_id
+  };
+};
 
 /**
  * Return [accessToken], [accessExpiresAt], and [refreshToken] for Vercel
@@ -184,58 +198,89 @@ const exchangeCodeVercel = async ({
  * @returns {String} obj2.refreshToken - refresh token for Heroku API
  * @returns {Date} obj2.accessExpiresAt - date of expiration for access token
  */
-const exchangeCodeNetlify = async ({
-    code
-}: {
-    code: string;
-}) => {
-    let res: ExchangeCodeNetlifyResponse;
-    let accountId;
-    try {
-        res = (await axios.post(
-            INTEGRATION_NETLIFY_TOKEN_URL,
-            new URLSearchParams({
-                grant_type: 'authorization_code',
-				code: code,
-                client_id: CLIENT_ID_NETLIFY,
-				client_secret: CLIENT_SECRET_NETLIFY,
-                redirect_uri: `${SITE_URL}/netlify`
-			} as any)
-        )).data;
+const exchangeCodeNetlify = async ({ code }: { code: string }) => {
+  let res: ExchangeCodeNetlifyResponse;
+  let accountId;
+  try {
+    res = (
+      await axios.post(
+        INTEGRATION_NETLIFY_TOKEN_URL,
+        new URLSearchParams({
+          grant_type: 'authorization_code',
+          code: code,
+          client_id: CLIENT_ID_NETLIFY,
+          client_secret: CLIENT_SECRET_NETLIFY,
+          redirect_uri: `${SITE_URL}/netlify`
+        } as any)
+      )
+    ).data;
 
-        const res2 = await axios.get(
-            'https://api.netlify.com/api/v1/sites',
-            {
-                headers: {
-                    Authorization: `Bearer ${res.access_token}`
-                }
-            }
-        );
-        
-        const res3 = (await axios.get(
-            'https://api.netlify.com/api/v1/accounts',
-            {
-                headers: {
-                    Authorization: `Bearer ${res.access_token}`
-                }
-            }
-        )).data;
-        
-        accountId = res3[0].id;
-
-    } catch (err) {
-        Sentry.setUser(null);
-        Sentry.captureException(err);
-        throw new Error('Failed OAuth2 code-token exchange with Netlify');
-    }
-    
-    return ({
-        accessToken: res.access_token,
-        refreshToken: res.refresh_token,
-        accountId
+    const res2 = await axios.get('https://api.netlify.com/api/v1/sites', {
+      headers: {
+        Authorization: `Bearer ${res.access_token}`
+      }
     });
-}
 
-export {
-    exchangeCode
-}
+    const res3 = (
+      await axios.get('https://api.netlify.com/api/v1/accounts', {
+        headers: {
+          Authorization: `Bearer ${res.access_token}`
+        }
+      })
+    ).data;
+
+    accountId = res3[0].id;
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed OAuth2 code-token exchange with Netlify');
+  }
+
+  return {
+    accessToken: res.access_token,
+    refreshToken: res.refresh_token,
+    accountId
+  };
+};
+
+/**
+ * Return [accessToken], [accessExpiresAt], and [refreshToken] for Github
+ * code-token exchange
+ * @param {Object} obj1
+ * @param {Object} obj1.code - code for code-token exchange
+ * @returns {Object} obj2
+ * @returns {String} obj2.accessToken - access token for Github API
+ * @returns {String} obj2.refreshToken - refresh token for Github API
+ * @returns {Date} obj2.accessExpiresAt - date of expiration for access token
+ */
+const exchangeCodeGithub = async ({ code }: { code: string }) => {
+  let res: ExchangeCodeGithubResponse;
+  try {
+    res = (
+      await axios.get(INTEGRATION_GITHUB_TOKEN_URL, {
+        params: {
+          client_id: CLIENT_ID_GITHUB,
+          client_secret: CLIENT_SECRET_GITHUB,
+          code: code,
+          redirect_uri: `${SITE_URL}/github`
+        },
+        headers: {
+          Accept: 'application/json'
+        }
+      })
+    ).data;
+
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed OAuth2 code-token exchange with Github');
+  }
+
+  return {
+    accessToken: res.access_token,
+    refreshToken: null,
+    accessExpiresAt: null
+  };
+};
+
+export { exchangeCode };

backend/src/integrations/refresh.ts

@@ -13,44 +13,44 @@ import {
  * named [integration]
  * @param {Object} obj
  * @param {String} obj.integration - name of integration
- * @param {String} obj.refreshToken - refresh token to use to get new access token for Heroku 
+ * @param {String} obj.refreshToken - refresh token to use to get new access token for Heroku
  */
 const exchangeRefresh = async ({
-    integration,
-    refreshToken
+  integration,
+  refreshToken
 }: {
-    integration: string;
-    refreshToken: string;
+  integration: string;
+  refreshToken: string;
 }) => {
-    let accessToken;
-    try {
-        switch (integration) {
-            case INTEGRATION_HEROKU:
-                accessToken = await exchangeRefreshHeroku({
-                    refreshToken
-                });
-                break;
-        }
-    } catch (err) {
-        Sentry.setUser(null);
-        Sentry.captureException(err);
-        throw new Error('Failed to get new OAuth2 access token'); 
+  let accessToken;
+  try {
+    switch (integration) {
+      case INTEGRATION_HEROKU:
+        accessToken = await exchangeRefreshHeroku({
+          refreshToken
+        });
+        break;
     }
-    
-    return accessToken;
-}
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed to get new OAuth2 access token');
+  }
+
+  return accessToken;
+};
 
 /**
  * Return new access token by exchanging refresh token [refreshToken] for the
  * Heroku integration
  * @param {Object} obj
  * @param {String} obj.refreshToken - refresh token to use to get new access token for Heroku
- * @returns 
+ * @returns
  */
 const exchangeRefreshHeroku = async ({
-    refreshToken
+  refreshToken
 }: {
-    refreshToken: string;
+  refreshToken: string;
 }) => {
     let accessToken;
 	//TODO: Refactor code to take advantage of using RequestError. It's possible to create new types of errors for more detailed errors
@@ -64,16 +64,14 @@ const exchangeRefreshHeroku = async ({
             } as any)
         );
 
-        accessToken = res.data.access_token;
-    } catch (err) {
-        Sentry.setUser(null);
-        Sentry.captureException(err);
-        throw new Error('Failed to get new OAuth2 access token for Heroku');
-    }
-    
-    return accessToken;
-}
+    accessToken = res.data.access_token;
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed to get new OAuth2 access token for Heroku');
+  }
 
-export {
-    exchangeRefresh
-}
+  return accessToken;
+};
+
+export { exchangeRefresh };

backend/src/integrations/revoke.ts

@@ -1,50 +1,47 @@
 import axios from 'axios';
 import * as Sentry from '@sentry/node';
+import { IIntegrationAuth, IntegrationAuth, Integration } from '../models';
 import {
-    IIntegrationAuth,
-    IntegrationAuth,
-    Integration
-} from '../models';
-import {
-    INTEGRATION_HEROKU,
-    INTEGRATION_VERCEL,
-    INTEGRATION_NETLIFY
+  INTEGRATION_HEROKU,
+  INTEGRATION_VERCEL,
+  INTEGRATION_NETLIFY,
+  INTEGRATION_GITHUB
 } from '../variables';
 
 const revokeAccess = async ({
-    integrationAuth,
-    accessToken
+  integrationAuth,
+  accessToken
 }: {
-    integrationAuth: IIntegrationAuth,
-    accessToken: string
+  integrationAuth: IIntegrationAuth;
+  accessToken: string;
 }) => {
-    try {
-        // add any integration-specific revocation logic 
-        switch (integrationAuth.integration) {
-            case INTEGRATION_HEROKU:
-                break;
-            case INTEGRATION_VERCEL:
-                break;
-            case INTEGRATION_NETLIFY:
-                break;
-        }
-        
-        const deletedIntegrationAuth = await IntegrationAuth.findOneAndDelete({
-            _id: integrationAuth._id
-        });
-
-        if (deletedIntegrationAuth) {
-			await Integration.deleteMany({
-				integrationAuth: deletedIntegrationAuth._id
-			});
-		}
-    } catch (err) {
-        Sentry.setUser(null);
-        Sentry.captureException(err);
-        throw new Error('Failed to delete integration authorization');
+  try {
+    // add any integration-specific revocation logic
+    switch (integrationAuth.integration) {
+      case INTEGRATION_HEROKU:
+        break;
+      case INTEGRATION_VERCEL:
+        break;
+      case INTEGRATION_NETLIFY:
+        break;
+      case INTEGRATION_GITHUB:
+        break;
     }
-}
 
-export {
-    revokeAccess
-}
+    const deletedIntegrationAuth = await IntegrationAuth.findOneAndDelete({
+      _id: integrationAuth._id
+    });
+
+    if (deletedIntegrationAuth) {
+      await Integration.deleteMany({
+        integrationAuth: deletedIntegrationAuth._id
+      });
+    }
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed to delete integration authorization');
+  }
+};
+
+export { revokeAccess };

backend/src/integrations/sync.ts

@@ -1,16 +1,21 @@
 import axios from 'axios';
 import * as Sentry from '@sentry/node';
+import { Octokit } from '@octokit/rest';
+// import * as sodium from 'libsodium-wrappers';
+import sodium from 'libsodium-wrappers';
+// const sodium = require('libsodium-wrappers');
+import { IIntegration, IIntegrationAuth } from '../models';
 import {
-    IIntegration, IIntegrationAuth
-} from '../models';
-import { 
-    INTEGRATION_HEROKU,
-    INTEGRATION_VERCEL,
-    INTEGRATION_NETLIFY,
-    INTEGRATION_HEROKU_API_URL,
-    INTEGRATION_VERCEL_API_URL,
-    INTEGRATION_NETLIFY_API_URL
+  INTEGRATION_HEROKU,
+  INTEGRATION_VERCEL,
+  INTEGRATION_NETLIFY,
+  INTEGRATION_GITHUB,
+  INTEGRATION_HEROKU_API_URL,
+  INTEGRATION_VERCEL_API_URL,
+  INTEGRATION_NETLIFY_API_URL,
+  INTEGRATION_GITHUB_API_URL
 } from '../variables';
+import { access, appendFile } from 'fs';
 
 // TODO: need a helper function in the future to handle integration
 // envar priorities (i.e. prioritize secrets within integration or those on Infisical)
@@ -26,49 +31,54 @@ import {
  * @param {String} obj.accessToken - access token for integration
  */
 const syncSecrets = async ({
-    integration,
-    integrationAuth,
-    secrets,
-    accessToken,
+  integration,
+  integrationAuth,
+  secrets,
+  accessToken
 }: {
-    integration: IIntegration;
-    integrationAuth: IIntegrationAuth;
-    secrets: any;
-    accessToken: string;
+  integration: IIntegration;
+  integrationAuth: IIntegrationAuth;
+  secrets: any;
+  accessToken: string;
 }) => {
-    try {
-        switch (integration.integration) {
-            case INTEGRATION_HEROKU:
-                await syncSecretsHeroku({
-                    integration,
-                    secrets,
-                    accessToken
-                });
-                break;
-            case INTEGRATION_VERCEL:
-                await syncSecretsVercel({
-                    integration,
-                    secrets,
-                    accessToken
-                });
-                break;
-            case INTEGRATION_NETLIFY:
-                await syncSecretsNetlify({
-                    integration,
-                    integrationAuth,
-                    secrets,
-                    accessToken
-                });
-                break;
-        }
-        
-        // TODO: set integration to inactive if it was not synced correctly (send alert?)
-    } catch (err) {
-        Sentry.setUser(null);
-        Sentry.captureException(err);
-        throw new Error('Failed to sync secrets to integration');
+  try {
+    switch (integration.integration) {
+      case INTEGRATION_HEROKU:
+        await syncSecretsHeroku({
+          integration,
+          secrets,
+          accessToken
+        });
+        break;
+      case INTEGRATION_VERCEL:
+        await syncSecretsVercel({
+          integration,
+          secrets,
+          accessToken
+        });
+        break;
+      case INTEGRATION_NETLIFY:
+        await syncSecretsNetlify({
+          integration,
+          integrationAuth,
+          secrets,
+          accessToken
+        });
+        break;
+      case INTEGRATION_GITHUB:
+        await syncSecretsGitHub({
+          integration,
+          secrets,
+          accessToken
+        });
+        break;
     }
-}
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed to sync secrets to integration');
+  }
+};
 
 /**
  * Sync/push [secrets] to Heroku [app]
@@ -77,47 +87,49 @@ const syncSecrets = async ({
  * @param {Object} obj.secrets - secrets to push to integration (object where keys are secret keys and values are secret values)
  */
 const syncSecretsHeroku = async ({
-    integration,
-    secrets,
-    accessToken
+  integration,
+  secrets,
+  accessToken
 }: {
-    integration: IIntegration,
-    secrets: any;
-    accessToken: string;
+  integration: IIntegration;
+  secrets: any;
+  accessToken: string;
 }) => {
-    try {
-        const herokuSecrets = (await axios.get( 
-            `${INTEGRATION_HEROKU_API_URL}/apps/${integration.app}/config-vars`,
-            {
-                headers: {
-                    Accept: 'application/vnd.heroku+json; version=3',
-                    Authorization: `Bearer ${accessToken}`
-                }
-            }
-        )).data;
-        
-        Object.keys(herokuSecrets).forEach(key => {
-            if (!(key in secrets)) {
-                secrets[key] = null;
-            }
-        });
+  try {
+    const herokuSecrets = (
+      await axios.get(
+        `${INTEGRATION_HEROKU_API_URL}/apps/${integration.app}/config-vars`,
+        {
+          headers: {
+            Accept: 'application/vnd.heroku+json; version=3',
+            Authorization: `Bearer ${accessToken}`
+          }
+        }
+      )
+    ).data;
 
-        await axios.patch(
-            `${INTEGRATION_HEROKU_API_URL}/apps/${integration.app}/config-vars`,
-            secrets,
-			{
-				headers: {
-					Accept: 'application/vnd.heroku+json; version=3',
-					Authorization: `Bearer ${accessToken}`
-				}
-			}
-		);
-    } catch (err) {
-        Sentry.setUser(null);
-        Sentry.captureException(err);
-        throw new Error('Failed to sync secrets to Heroku');
-    }
-}
+    Object.keys(herokuSecrets).forEach((key) => {
+      if (!(key in secrets)) {
+        secrets[key] = null;
+      }
+    });
+
+    await axios.patch(
+      `${INTEGRATION_HEROKU_API_URL}/apps/${integration.app}/config-vars`,
+      secrets,
+      {
+        headers: {
+          Accept: 'application/vnd.heroku+json; version=3',
+          Authorization: `Bearer ${accessToken}`
+        }
+      }
+    );
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed to sync secrets to Heroku');
+  }
+};
 
 /**
  * Sync/push [secrets] to Heroku [app]
@@ -474,8 +486,120 @@ const syncSecretsNetlify = async ({
         throw new Error('Failed to sync secrets to Heroku');
     }
 }
-   
 
-export {
-    syncSecrets
-}
+/**
+ * Sync/push [secrets] to GitHub [repo]
+ * @param {Object} obj
+ * @param {IIntegration} obj.integration - integration details
+ * @param {IIntegrationAuth} obj.integrationAuth - integration auth details
+ * @param {Object} obj.secrets - secrets to push to integration (object where keys are secret keys and values are secret values)
+ */
+const syncSecretsGitHub = async ({
+  integration,
+  secrets,
+  accessToken
+}: {
+  integration: IIntegration;
+  secrets: any;
+  accessToken: string;
+}) => {
+  try {
+    
+    interface GitHubRepoKey {
+      key_id: string;
+      key: string;
+    }
+    
+    interface GitHubSecret {
+      name: string;
+      created_at: string;
+      updated_at: string;
+    }
+
+    interface GitHubSecretRes {
+        [index: string]: GitHubSecret;
+    }
+
+    const deleteSecrets: GitHubSecret[] = [];
+
+    const octokit = new Octokit({
+      auth: accessToken
+    });
+
+    const user = (await octokit.request('GET /user', {})).data;
+    
+    const repoPublicKey: GitHubRepoKey = (await octokit.request(
+      'GET /repos/{owner}/{repo}/actions/secrets/public-key',
+      {
+        owner: user.login,
+        repo: integration.app
+      }
+    )).data;
+
+    // // Get local copy of decrypted secrets. We cannot decrypt them as we dont have access to GH private key
+    const encryptedSecrets: GitHubSecretRes = (await octokit.request(
+      'GET /repos/{owner}/{repo}/actions/secrets',
+      {
+        owner: user.login,
+        repo: integration.app
+      }
+    ))
+    .data
+    .secrets
+    .reduce((obj: any, secret: any) => ({
+      ...obj,
+      [secret.name]: secret
+    }), {});
+    
+    Object.keys(encryptedSecrets).map(async (key) => {
+      if (!(key in secrets)) {
+        await octokit.request(
+          'DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}',
+          {
+            owner: user.login,
+            repo: integration.app,
+            secret_name: key
+          }
+        );
+      }
+    });
+    
+    Object.keys(secrets).map((key) => {
+      // let encryptedSecret;
+      sodium.ready.then(async () => {
+          // convert secret & base64 key to Uint8Array.
+          const binkey = sodium.from_base64(
+            repoPublicKey.key,
+            sodium.base64_variants.ORIGINAL
+          );
+          const binsec = sodium.from_string(secrets[key]);
+
+          // encrypt secret using libsodium
+          const encBytes = sodium.crypto_box_seal(binsec, binkey);
+
+          // convert encrypted Uint8Array to base64
+          const encryptedSecret = sodium.to_base64(
+            encBytes,
+            sodium.base64_variants.ORIGINAL
+          );
+          
+          await octokit.request(
+            'PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}',
+            {
+              owner: user.login,
+              repo: integration.app,
+              secret_name: key,
+              encrypted_value: encryptedSecret,
+              key_id: repoPublicKey.key_id
+            }
+          );
+      });
+    });
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    throw new Error('Failed to sync secrets to GitHub');
+  }
+};
+
+export { syncSecrets };