add tutorial id to webhooks

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

Author: ShMcK

src/actions/onRunReset.ts

@@ -32,7 +32,10 @@ const onRunReset = async (action: ResetAction, context: Context): Promise<void>
   // if tutorial.config.reset.command, run it
   const resetActions = tutorial?.config?.reset
   if (resetActions) {
-    hooks.onReset({ commands: resetActions?.commands, vscodeCommands: resetActions?.vscodeCommands })
+    hooks.onReset(
+      { commands: resetActions?.commands, vscodeCommands: resetActions?.vscodeCommands },
+      tutorial?.id as string,
+    )
   }
 }
 

src/commands.ts

@@ -65,7 +65,7 @@ export const createCommands = ({ extensionPath, workspaceState }: CreateCommandP
       if (!alreadyConfigured) {
         const setupActions = data.config.setup
         if (setupActions) {
-          hooks.onInit(setupActions)
+          hooks.onInit(setupActions, data.id)
         }
       }
       testRunner = createTestRunner(data, {

src/services/hooks/index.ts

@@ -11,12 +11,12 @@ 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> => {
+export const onInit = async (actions: TT.StepActions, tutorialId: string): Promise<void> => {
   await loadCommits(actions?.commits)
   await runCommands(actions?.commands)
   await runVSCodeCommands(actions?.vscodeCommands)
   webhooks.onInit({
-    // tutorialId,
+    tutorialId,
     coderoadVersion: VERSION,
   })
 }
@@ -47,12 +47,12 @@ export const onSolutionEnter = async (actions: TT.StepActions): Promise<void> =>
 }
 
 // run when "reset" is triggered
-export const onReset = async (actions: TT.StepActions): Promise<void> => {
+export const onReset = async (actions: TT.StepActions, tutorialId: string): Promise<void> => {
   await resetWatchers()
   await runCommands(actions?.commands)
   await runVSCodeCommands(actions?.vscodeCommands)
   webhooks.onReset({
-    // tutorialId,
+    tutorialId,
   })
 }
 

src/services/hooks/webhooks.ts

@@ -26,47 +26,47 @@ const callWebhookEndpoint = async <B>(bodyObject: B): Promise<void> => {
   }
 }
 
-type InitEvent = {
-  // tutorialId: string;
+type WebhookEventInit = {
+  tutorialId: string
   coderoadVersion: string
 }
 
-export const onInit = (event: InitEvent): void => {
+export const onInit = (event: WebhookEventInit): void => {
   if (WEBHOOKS.init) {
-    callWebhookEndpoint<InitEvent>(event)
+    callWebhookEndpoint<WebhookEventInit>(event)
   }
 }
 
-type ResetEvent = {
-  // tutorialId: string;
+type WebhookEventReset = {
+  tutorialId: string
 }
 
-export const onReset = (event: ResetEvent): void => {
+export const onReset = (event: WebhookEventReset): void => {
   if (WEBHOOKS.reset) {
-    callWebhookEndpoint<ResetEvent>(event)
+    callWebhookEndpoint<WebhookEventReset>(event)
   }
 }
 
-type StepCompleteEvent = { tutorialId: string; version: string; levelId: string; stepId: string }
+type WebhookEventStepComplete = { tutorialId: string; version: string; levelId: string; stepId: string }
 
-export const onStepComplete = (event: StepCompleteEvent): void => {
+export const onStepComplete = (event: WebhookEventStepComplete): void => {
   if (WEBHOOKS.step_complete) {
-    callWebhookEndpoint<StepCompleteEvent>(event)
+    callWebhookEndpoint<WebhookEventStepComplete>(event)
   }
 }
 
-type LevelCompleteEvent = { tutorialId: string; version: string; levelId: string }
+type WebhookEventLevelComplete = { tutorialId: string; version: string; levelId: string }
 
-export const onLevelComplete = (event: LevelCompleteEvent): void => {
+export const onLevelComplete = (event: WebhookEventLevelComplete): void => {
   if (WEBHOOKS.level_complete) {
-    callWebhookEndpoint<LevelCompleteEvent>(event)
+    callWebhookEndpoint<WebhookEventLevelComplete>(event)
   }
 }
 
-type TutorialCompleteEvent = { tutorialId: string; version: string }
+type WebhookEevntTutorialComplete = { tutorialId: string; version: string }
 
-export const onTutorialComplete = (event: TutorialCompleteEvent): void => {
+export const onTutorialComplete = (event: WebhookEevntTutorialComplete): void => {
   if (WEBHOOKS.tutorial_complete) {
-    callWebhookEndpoint<TutorialCompleteEvent>(event)
+    callWebhookEndpoint<WebhookEevntTutorialComplete>(event)
   }
 }