configure webhook with token

Signed-off-by: shmck <[email protected]>

Author: ShMcK

docs/docs/env-vars.md

@@ -18,6 +18,8 @@ CodeRoad has a number of configurations:
 
 - `CODEROAD_CONTENT_SECURITY_POLICY_EXEMPTIONS` - a list of CSP exemption hashes. For multiples, separate the list with a space.
 
+- `CODEROAD_WEBHOOK_TOKEN` - an optional token for authenticating/authorizing webhook endpoints. Passed to the webhook endpoint in a `CodeRoad-User-Token` header.
+
 ## How to Use Variables
 
 ### Local

src/actions/onTutorialConfigContinue.ts

@@ -5,6 +5,7 @@ import Context from '../services/context/context'
 import tutorialConfig from './utils/tutorialConfig'
 import { COMMANDS, send } from '../commands'
 import logger from '../services/logger'
+import { setupWebhook } from '../services/hooks/webhooks'
 
 const onTutorialConfigContinue = async (action: T.Action, context: Context): Promise<void> => {
   logger('onTutorialConfigContinue', action)
@@ -19,6 +20,11 @@ const onTutorialConfigContinue = async (action: T.Action, context: Context): Pro
       data: tutorialToContinue,
       alreadyConfigured: true,
     })
+
+    // configure webhook
+    if (tutorialToContinue.config?.webhook) {
+      setupWebhook(tutorialToContinue.config.webhook)
+    }
   } catch (e) {
     const error = {
       type: 'UnknownError',

src/actions/onTutorialConfigNew.ts

@@ -8,6 +8,7 @@ import { version, compareVersions } from '../services/dependencies'
 import Context from '../services/context/context'
 import tutorialConfig from './utils/tutorialConfig'
 import { send } from '../commands'
+import { setupWebhook } from '../services/hooks/webhooks'
 
 const onTutorialConfigNew = async (action: T.Action, context: Context): Promise<void> => {
   try {
@@ -108,6 +109,11 @@ const onTutorialConfigNew = async (action: T.Action, context: Context): Promise<
       return
     }
 
+    // configure webhook
+    if (data.config?.webhook) {
+      setupWebhook(data.config.webhook)
+    }
+
     // report back to the webview that setup is complete
     send({ type: 'TUTORIAL_CONFIGURED' })
   } catch (e) {

src/environment.ts

@@ -43,3 +43,6 @@ export const DISABLE_RUN_ON_SAVE = (process.env.CODEROAD_DISABLE_RUN_ON_SAVE ||
 // for multiple exemptions, separate each with a space "a1 b1"
 export const CONTENT_SECURITY_POLICY_EXEMPTIONS: string | null =
   process.env.CODEROAD_CONTENT_SECURITY_POLICY_EXEMPTIONS || null
+
+// optional token for authorization/authentication of webhook calls
+export const WEBHOOK_TOKEN = process.env.CODEROAD_WEBHOOK_TOKEN || null

src/services/hooks/webhooks.ts

@@ -1,28 +1,57 @@
+import * as TT from 'typings/tutorial'
 import fetch from 'node-fetch'
 import logger from '../logger'
+import { WEBHOOK_TOKEN } from '../../environment'
 
-const WEBHOOKS = {
-  init: true,
-  reset: true,
-  step_complete: true,
-  level_complete: true,
-  tutorial_complete: true,
+const WEBHOOK_EVENTS = {
+  init: false,
+  reset: false,
+  step_complete: false,
+  level_complete: false,
+  tutorial_complete: false,
+}
+
+// varaibles set on init
+let WEBHOOK_URI: string | undefined
+
+export const setupWebhook = (webhookConfig: TT.WebhookConfig) => {
+  if (!webhookConfig.url) {
+    return
+  }
+  // set webhook uri
+  WEBHOOK_URI = webhookConfig.url
+
+  // set webhook event triggers
+  const events = webhookConfig.events as TT.WebhookConfigEvents
+  for (const eventName of Object.keys(events || {})) {
+    WEBHOOK_EVENTS[eventName] = events[eventName]
+  }
 }
 
 const callWebhookEndpoint = async <B>(bodyObject: B): Promise<void> => {
-  const endpoint = 'http://localhost:3000'
+  if (!WEBHOOK_URI) {
+    return
+  }
+
+  const headers = { 'Content-Type': 'application/json' }
+  // if the webhook token is specified as env var, sends a token with the request
+  if (WEBHOOK_TOKEN) {
+    headers['CodeRoad-User-Token'] = WEBHOOK_TOKEN
+  }
+
   const body = JSON.stringify(bodyObject)
+
   try {
-    const sendEvent = await fetch(endpoint, {
+    const sendEvent = await fetch(WEBHOOK_URI, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
+      headers,
       body,
     })
     if (!sendEvent.ok) {
       throw new Error('Error sending event')
     }
   } catch (err: unknown) {
-    logger(`Failed to call webhook endpoint ${endpoint} with body ${body}`)
+    logger(`Failed to call webhook endpoint ${WEBHOOK_URI} with body ${body}`)
   }
 }
 
@@ -32,7 +61,7 @@ type WebhookEventInit = {
 }
 
 export const onInit = (event: WebhookEventInit): void => {
-  if (WEBHOOKS.init) {
+  if (WEBHOOK_EVENTS.init) {
     callWebhookEndpoint<WebhookEventInit>(event)
   }
 }
@@ -42,31 +71,31 @@ type WebhookEventReset = {
 }
 
 export const onReset = (event: WebhookEventReset): void => {
-  if (WEBHOOKS.reset) {
+  if (WEBHOOK_EVENTS.reset) {
     callWebhookEndpoint<WebhookEventReset>(event)
   }
 }
 
 type WebhookEventStepComplete = { tutorialId: string; version: string; levelId: string; stepId: string }
 
 export const onStepComplete = (event: WebhookEventStepComplete): void => {
-  if (WEBHOOKS.step_complete) {
+  if (WEBHOOK_EVENTS.step_complete) {
     callWebhookEndpoint<WebhookEventStepComplete>(event)
   }
 }
 
 type WebhookEventLevelComplete = { tutorialId: string; version: string; levelId: string }
 
 export const onLevelComplete = (event: WebhookEventLevelComplete): void => {
-  if (WEBHOOKS.level_complete) {
+  if (WEBHOOK_EVENTS.level_complete) {
     callWebhookEndpoint<WebhookEventLevelComplete>(event)
   }
 }
 
 type WebhookEevntTutorialComplete = { tutorialId: string; version: string }
 
 export const onTutorialComplete = (event: WebhookEevntTutorialComplete): void => {
-  if (WEBHOOKS.tutorial_complete) {
+  if (WEBHOOK_EVENTS.tutorial_complete) {
     callWebhookEndpoint<WebhookEevntTutorialComplete>(event)
   }
 }

typings/tutorial.d.ts

@@ -94,16 +94,14 @@ export interface TutorialAppVersions {
 
 export type VSCodeCommand = string | [string, any]
 
+export interface WebhookConfigEvents {
+  init?: boolean
+  reset?: boolean
+  step_complete?: boolean
+  level_complete?: boolean
+  tutorial_complete?: boolean
+}
 export interface WebhookConfig {
   url: string
-  config: {
-    token: boolean
-  }
-  events: {
-    init?: boolean
-    reset?: boolean
-    step_complete?: boolean
-    level_complete?: boolean
-    tutorial_complete?: boolean
-  }
+  events?: WebhookConfigEvents
 }