webhook demo

Signed-off-by: shmck <shawn.j.mckay@gmail.com>

Author: ShMcK

src/services/hooks/index.ts

@@ -7,14 +7,18 @@ import runCommands from './utils/runCommands'
 import runVSCodeCommands from './utils/runVSCodeCommands'
 import * as telemetry from '../telemetry'
 import { runTest } from '../../actions/onTest'
-import logger from '../logger'
 import { VERSION } from '../../environment'
+import * as webhooks from './webhooks'
 
 // run at the end of when a tutorial is configured
 export const onInit = async (actions: TT.StepActions): Promise<void> => {
   await loadCommits(actions?.commits)
   await runCommands(actions?.commands)
   await runVSCodeCommands(actions?.vscodeCommands)
+  webhooks.onInit({
+    // tutorialId,
+    version: VERSION,
+  })
 }
 
 // run when a level starts
@@ -47,6 +51,10 @@ export const onReset = async (actions: TT.StepActions): Promise<void> => {
   await resetWatchers()
   await runCommands(actions?.commands)
   await runVSCodeCommands(actions?.vscodeCommands)
+  webhooks.onReset({
+    // tutorialId,
+    version: VERSION,
+  })
 }
 
 // run when an uncaught exception is thrown
@@ -66,6 +74,12 @@ export const onStepComplete = async ({
 }): Promise<void> => {
   git.saveCommit(`Save progress: ${stepId}`)
   telemetry.onEvent('step_complete', { tutorialId, stepId, levelId, version: VERSION })
+  webhooks.onStepComplete({
+    tutorialId,
+    version: VERSION,
+    levelId,
+    stepId,
+  })
 }
 
 // run when a level is complete (all tasks pass or no tasks)
@@ -77,9 +91,18 @@ export const onLevelComplete = async ({
   levelId: string
 }): Promise<void> => {
   telemetry.onEvent('level_complete', { tutorialId, levelId, version: VERSION })
+  webhooks.onLevelComplete({
+    tutorialId,
+    version: VERSION,
+    levelId,
+  })
 }
 
 // run when all levels are complete
 export const onTutorialComplete = async ({ tutorialId }: { tutorialId: string }): Promise<void> => {
   telemetry.onEvent('tutorial_complete', { tutorialId, version: VERSION })
+  webhooks.onTutorialComplete({
+    tutorialId,
+    version: VERSION,
+  })
 }

src/services/hooks/webhooks.ts

@@ -0,0 +1,73 @@
+import fetch from 'node-fetch'
+import logger from '../logger'
+
+const WEBHOOKS = {
+  init: true,
+  reset: true,
+  step_complete: true,
+  level_complete: true,
+  tutorial_complete: true,
+}
+
+const callWebhookEndpoint = async <B>(bodyObject: B): Promise<void> => {
+  const endpoint = 'http://localhost:3000'
+  const body = JSON.stringify(bodyObject)
+  try {
+    const sendEvent = await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body,
+    })
+    if (!sendEvent.ok) {
+      throw new Error('Error sending event')
+    }
+  } catch (err: unknown) {
+    logger(`Failed to call webhook endpoint ${endpoint} with body ${body}`)
+  }
+}
+
+type InitEvent = {
+  // tutorialId: string;
+  version: string
+}
+
+export const onInit = (event: InitEvent): void => {
+  if (WEBHOOKS.init) {
+    callWebhookEndpoint<InitEvent>(event)
+  }
+}
+
+type ResetEvent = {
+  // tutorialId: string;
+  version: string
+}
+
+export const onReset = (event: ResetEvent): void => {
+  if (WEBHOOKS.reset) {
+    callWebhookEndpoint<ResetEvent>(event)
+  }
+}
+
+type StepCompleteEvent = { tutorialId: string; version: string; levelId: string; stepId: string }
+
+export const onStepComplete = (event: StepCompleteEvent): void => {
+  if (WEBHOOKS.step_complete) {
+    callWebhookEndpoint<StepCompleteEvent>(event)
+  }
+}
+
+type LevelCompleteEvent = { tutorialId: string; version: string; levelId: string }
+
+export const onLevelComplete = (event: LevelCompleteEvent): void => {
+  if (WEBHOOKS.level_complete) {
+    callWebhookEndpoint<LevelCompleteEvent>(event)
+  }
+}
+
+type TutorialCompleteEvent = { tutorialId: string; version: string }
+
+export const onTutorialComplete = (event: TutorialCompleteEvent): void => {
+  if (WEBHOOKS.tutorial_complete) {
+    callWebhookEndpoint<TutorialCompleteEvent>(event)
+  }
+}