@learnpack/learnpack 5.0.320 → 5.0.323

package/src/commands/serve.ts

@@ -60,6 +60,15 @@ import { checkAndFixSidebarPure } from "../utils/sidebarGenerator"
 import { handleAssetCreation } from "./publish"
 import { FormState, Lesson, Syllabus } from "../models/creator"
 import { exportToScorm, exportToEpub, exportToZip } from "../utils/export"
+import {
+  errorHandler,
+  notFoundHandler,
+  asyncHandler,
+  ValidationError,
+  ConflictError,
+  InternalServerError,
+  NotFoundError,
+} from "../utils/errorHandler"
 
 const frontMatter = require("front-matter")
 
@@ -326,19 +335,44 @@ async function startInitialContentGeneration(
   purposeSlug: string,
   lastLesson = ""
 ): Promise<number> {
+  // Defensive validation
+  if (!exercise) {
+    throw new ValidationError("Exercise is required but was not provided")
+  }
+
+  console.log("EXERCISE", exercise)
+
+  if (!exercise.id || !exercise.title) {
+    throw new ValidationError(
+      `Exercise is missing required properties: id=${exercise.id}, title=${exercise.title}`
+    )
+  }
+
   const exSlug = slugify(exercise.id + "-" + exercise.title)
   console.log("Starting initial content generation for", exSlug)
 
   const webhookUrl = `${process.env.HOST}/webhooks/${courseSlug}/initial-content-processor/${exercise.uid}/${rigoToken}`
 
-  // Determine if this is the first lesson
   const exerciseIndex = steps.findIndex(
     lesson => lesson.uid === exercise.uid
   )
   const isFirstLesson = exerciseIndex === 0
-  const endpointSlug = isFirstLesson ?
-    "initial-step-content-generator" :
-    "generate-step-initial-content"
+  const isLastLesson = exerciseIndex === steps.length - 1
+
+  let endpointSlug: string
+
+  let passTopicDescription = false
+  if (isFirstLesson) {
+    endpointSlug = "generate-learnpack-intro-content"
+  } else if (isLastLesson) {
+    endpointSlug = "generate-learnpack-outro-content"
+  } else if (exercise.id.endsWith(".0")) {
+    passTopicDescription = true
+    endpointSlug = "generate-learnpack-topic-intro-content"
+  } else {
+    passTopicDescription = true
+    endpointSlug = "generate-learnpack-subtopic-content"
+  }
 
   // Emit notification that initial content generation is starting
   emitToCourse(courseSlug, "course-creation", {
@@ -356,15 +390,20 @@ async function startInitialContentGeneration(
   // eslint-disable-next-line no-mixed-operators
   const randomCacheEvict = Math.floor(100_000 + Math.random() * 900_000)
 
+  const inputs = {
+    output_language: packageContext.language || "en",
+    current_syllabus: JSON.stringify(fullSyllabus),
+    lesson_description:
+      JSON.stringify(lessonCleaner(exercise)) + `-${randomCacheEvict}`,
+    target_word_count: String(PARAMS.max_words),
+    topic_description: passTopicDescription ?
+      String(exercise.description) :
+      undefined,
+  }
+
   const res = await initialContentGenerator(
     rigoToken.trim(),
-    {
-      // prev_lesson: lastLesson,
-      output_language: packageContext.language || "en",
-      current_syllabus: JSON.stringify(fullSyllabus),
-      lesson_description:
-        JSON.stringify(lessonCleaner(exercise)) + `-${randomCacheEvict}`,
-    },
+    inputs,
     webhookUrl,
     endpointSlug
   )
@@ -1038,9 +1077,8 @@ export default class ServeCommand extends SessionCommand {
 
               const exerciseDir = `courses/${courseSlug}/exercises/${exercise.slug}`
 
-              for (const fileStr of files) {
+              for (const fileObj of files) {
                 try {
-                  const fileObj = JSON.parse(fileStr)
                   console.log(`📄 Processing file: ${fileObj.name}`)
 
                   // Save the main file with content
@@ -1102,7 +1140,7 @@ export default class ServeCommand extends SessionCommand {
 
     app.post(
       "/actions/continue-generating/:courseSlug/:lessonUid",
-      async (req, res) => {
+      asyncHandler(async (req, res) => {
         const { courseSlug, lessonUid } = req.params
         const { feedback, mode } = req.body
         const rigoToken = req.header("x-rigo-token")
@@ -1114,9 +1152,9 @@ export default class ServeCommand extends SessionCommand {
         // console.log("MODE", mode);
 
         if (!rigoToken) {
-          return res.status(400).json({
-            error: "Rigo token is required. x-rigo-token header is missing",
-          })
+          throw new ValidationError(
+            "Rigo token is required. x-rigo-token header is missing"
+          )
         }
 
         const syllabus = await getSyllabus(courseSlug, bucket)
@@ -1128,6 +1166,27 @@ export default class ServeCommand extends SessionCommand {
           lesson => lesson.uid === lessonUid
         )
 
+        // Validate that exercise exists
+        if (!exercise) {
+          throw new NotFoundError(
+            `Lesson with UID "${lessonUid}" not found in course "${courseSlug}"`
+          )
+        }
+
+        // Validate that exercise index is valid (defensive check)
+        if (exerciseIndex === -1) {
+          throw new NotFoundError(
+            `Lesson with UID "${lessonUid}" not found in course "${courseSlug}"`
+          )
+        }
+
+        // Validate that exercise has required properties
+        if (!exercise.id || !exercise.title) {
+          throw new ValidationError(
+            `Lesson "${lessonUid}" is missing required properties (id or title)`
+          )
+        }
+
         // previous exercise
         let previousReadme = "---"
         const previousExercise = syllabus.lessons[exerciseIndex - 1]
@@ -1154,7 +1213,7 @@ export default class ServeCommand extends SessionCommand {
           rigoToken,
           syllabus.lessons,
           syllabus.courseInfo,
-          exercise!,
+          exercise,
           courseSlug,
           syllabus.courseInfo.purpose,
           previousReadme +
@@ -1182,7 +1241,7 @@ export default class ServeCommand extends SessionCommand {
         await saveSyllabus(courseSlug, syllabus, bucket)
 
         res.json({ status: "SUCCESS" })
-      }
+      })
     )
 
     // TODO: Check if this command is being used
@@ -1857,6 +1916,13 @@ export default class ServeCommand extends SessionCommand {
 
         await uploadFileToBucket(bucket, body.parsed.translation, readmePath)
 
+        emitToCourse(courseSlug, "translation-completed", {
+          exercise: exSlug,
+          language: body.parsed.output_language_code,
+          status: "completed",
+          message: `Translation completed for ${exSlug} to ${body.parsed.output_language_code}`,
+        })
+
         res.json({ status: "SUCCESS" })
       }
     )
@@ -2032,26 +2098,68 @@ export default class ServeCommand extends SessionCommand {
     app.put(
       "/exercise/:slug/file/:fileName",
       express.text(),
-      async (req, res) => {
+      asyncHandler(async (req, res) => {
         const { slug, fileName } = req.params
         const query = req.query
+        const courseSlug = query.slug as string
+
         console.log(`PUT /exercise/${slug}/file/${fileName}`)
 
-        const courseSlug = query.slug
-        // console.log("COURSE SLUG", courseSlug)
+        // Validate required parameters
+        if (!courseSlug) {
+          throw new ValidationError(
+            "Course slug is required in query parameters"
+          )
+        }
 
-        // Update the file in the bucket
-        const file = await bucket.file(
-          `courses/${courseSlug}/exercises/${slug}/${fileName}`
-        )
-        await file.save(req.body)
-        const created = await file.exists()
-        // console.log("File updated", created)
-        res.send({
-          message: "File updated",
-          created,
-        })
-      }
+        if (!fileName || !slug) {
+          throw new ValidationError("File name and exercise slug are required")
+        }
+
+        try {
+          // Update the file in the bucket
+          const file = bucket.file(
+            `courses/${courseSlug}/exercises/${slug}/${fileName}`
+          )
+
+          await file.save(req.body, {
+            resumable: false,
+          })
+
+          const created = await file.exists()
+
+          res.send({
+            message: "File updated",
+            created,
+          })
+        } catch (error: any) {
+          // Handle Google Cloud Storage rate limit errors (429)
+          if (
+            error.code === 429 ||
+            error.message?.includes("rate limit") ||
+            error.message?.includes("rateLimitExceeded")
+          ) {
+            throw new ConflictError(
+              "Storage rate limit exceeded. Please try again in a few moments.",
+              {
+                code: "STORAGE_RATE_LIMIT",
+                retryAfter: 60, // seconds
+              }
+            )
+          }
+
+          // Handle other GCS errors
+          if (error.code) {
+            throw new InternalServerError(
+              `Storage error: ${error.message || "Failed to update file"}`,
+              { code: error.code }
+            )
+          }
+
+          // Re-throw if it's already an operational error
+          throw error
+        }
+      })
     )
     // Create a new step for a course
     app.post("/course/:slug/create-step", async (req, res) => {
@@ -2163,23 +2271,22 @@ export default class ServeCommand extends SessionCommand {
       res.send({ message: "Files renamed" })
     })
 
-    app.post("/actions/translate", express.json(), async (req, res) => {
-      console.log("POST /actions/translate")
-      const { exerciseSlugs, languages, rigoToken, currentLanguage } = req.body
-      const query = req.query
-      const courseSlug = query.slug
-
-      if (!rigoToken) {
-        return res.status(400).json({ error: "RigoToken not found" })
-      }
-
-      const languagesToTranslate: string[] = languages.split(",")
-      const languageCodesRes = await getLanguageCodes(rigoToken, {
-        raw_languages: languagesToTranslate.join(","),
-      })
-      const languageCodes = languageCodesRes.parsed.language_codes
-
+    async function processTranslationsAsync(
+      courseSlug: string,
+      exerciseSlugs: string[],
+      languageCodes: string[],
+      rigoToken: string,
+      currentLanguage: string,
+      bucket: Bucket
+    ) {
       try {
+        emitToCourse(courseSlug, "translation-started", {
+          languages: languageCodes,
+          exercises: exerciseSlugs,
+          status: "started",
+          message: "Translation process started",
+        })
+
         await Promise.all(
           exerciseSlugs.map(async (slug: string) => {
             const readmePath = `courses/${courseSlug}/exercises/${slug}/README${getReadmeExtension(
@@ -2189,7 +2296,6 @@ export default class ServeCommand extends SessionCommand {
 
             await Promise.all(
               languageCodes.map(async (language: string) => {
-                // verify if the translation already exists
                 const translationPath = `courses/${courseSlug}/exercises/${slug}/README${getReadmeExtension(
                   language
                 )}`
@@ -2199,6 +2305,12 @@ export default class ServeCommand extends SessionCommand {
                   console.log(
                     `Translation in ${language} already exists for exercise ${slug}`
                   )
+                  emitToCourse(courseSlug, "translation-progress", {
+                    exercise: slug,
+                    language: language,
+                    status: "skipped",
+                    message: `Translation in ${language} already exists`,
+                  })
                   return
                 }
 
@@ -2210,6 +2322,13 @@ export default class ServeCommand extends SessionCommand {
                   },
                   `${process.env.HOST}/webhooks/${courseSlug}/${slug}/save-translation`
                 )
+
+                emitToCourse(courseSlug, "translation-progress", {
+                  exercise: slug,
+                  language: language,
+                  status: "initiated",
+                  message: `Translation job initiated for ${slug} to ${language}`,
+                })
               })
             )
           })
@@ -2257,8 +2376,6 @@ export default class ServeCommand extends SessionCommand {
           currentLanguages = Object.keys(courseJson.title)
         }
 
-        // Check that all the READMEs exists
-
         const missingReadmeTranslations = []
         let firstAvailable = ""
         for (const languageCode of currentLanguages) {
@@ -2281,6 +2398,7 @@ export default class ServeCommand extends SessionCommand {
 
         await Promise.all(
           missingReadmeTranslations.map(async languageCode => {
+             
             await translateExercise(
               rigoToken,
               {
@@ -2292,7 +2410,63 @@ export default class ServeCommand extends SessionCommand {
           })
         )
 
-        return res.status(200).json({ message: "Translated exercises" })
+        emitToCourse(courseSlug, "translation-initiated", {
+          status: "completed",
+          message: "All translation jobs have been initiated",
+          languages: languageCodes,
+          exercises: exerciseSlugs,
+        })
+      } catch (error) {
+        console.error("Error processing translations:", error)
+        emitToCourse(courseSlug, "translation-error", {
+          status: "error",
+          error: (error as Error).message,
+          message: "Error occurred during translation processing",
+        })
+        throw error
+      }
+    }
+
+    app.post("/actions/translate", express.json(), async (req, res) => {
+      console.log("POST /actions/translate")
+      const { exerciseSlugs, languages, rigoToken, currentLanguage } = req.body
+      const query = req.query
+      const courseSlug =
+        typeof query.slug === "string" ? query.slug : undefined
+
+      if (!rigoToken) {
+        return res.status(400).json({ error: "RigoToken not found" })
+      }
+
+      if (!courseSlug) {
+        return res.status(400).json({ error: "Course slug not found" })
+      }
+
+      const languagesToTranslate: string[] = languages.split(",")
+
+      try {
+        const languageCodesRes = await getLanguageCodes(rigoToken, {
+          raw_languages: languagesToTranslate.join(","),
+        })
+        const languageCodes = languageCodesRes.parsed.language_codes
+
+        res.status(200).json({
+          message: "Translation started",
+          languages: languageCodes,
+          exercises: exerciseSlugs,
+          status: "processing",
+        })
+
+        processTranslationsAsync(
+          courseSlug,
+          exerciseSlugs,
+          languageCodes,
+          rigoToken,
+          currentLanguage,
+          bucket
+        ).catch(error => {
+          console.error("Error in background translation processing:", error)
+        })
       } catch (error) {
         console.log(error, "ERROR")
         return res.status(400).json({ error: (error as Error).message })
@@ -3453,6 +3627,12 @@ export default class ServeCommand extends SessionCommand {
       }
     })
 
+    // 404 error handler
+    app.use(notFoundHandler)
+
+    // Global error handler
+    app.use(errorHandler)
+
     server.listen(PORT, () => {
       console.log(
         `🚀 Creator UI server running at http://localhost:${PORT}/creator`