@learnpack/learnpack 5.0.344 → 5.0.347

package/src/commands/publish.ts

@@ -54,6 +54,54 @@ const getLocalizedValue = (
   return typeof first === "string" ? first : ""
 }
 
+type ExistingAssetInfo = {
+  lang: string;
+  slug: string;
+  exists: boolean;
+  academyId?: number;
+};
+
+type AcademyMode =
+  | { type: "select" }
+  | { type: "locked"; academyId: number }
+  | { type: "conflict"; academies: number[] };
+
+const getExistingAssetsInfo = async (
+  token: string,
+  learnJson: any
+): Promise<ExistingAssetInfo[]> => {
+  const availableLangs = getAvailableLangs(learnJson)
+  const results: ExistingAssetInfo[] = []
+
+  for (const lang of availableLangs) {
+    const assetTitle = getLocalizedValue(learnJson?.title, lang)
+    if (!assetTitle) continue
+
+    let slug = slugify(assetTitle).slice(0, 47)
+    slug = `${slug}-${lang}`
+
+    // eslint-disable-next-line no-await-in-loop
+    const { exists, academyId } = await api.doesAssetExists(token, slug)
+    results.push({ lang, slug, exists, academyId })
+  }
+
+  return results
+}
+
+const determinePublishAcademyMode = (
+  existingAssets: ExistingAssetInfo[]
+): AcademyMode => {
+  const academyIds = existingAssets
+    .filter((a) => a.exists && a.academyId !== undefined)
+    .map((a) => a.academyId as number)
+
+  const unique = [...new Set(academyIds)]
+
+  if (unique.length === 0) return { type: "select" }
+  if (unique.length === 1) return { type: "locked", academyId: unique[0] }
+  return { type: "conflict", academies: unique }
+}
+
 export const handleAssetCreation = async (
   sessionPayload: { token: string; rigobotToken: string },
   learnJson: any,
@@ -61,6 +109,8 @@ export const handleAssetCreation = async (
   learnpackDeployUrl: string,
   b64IndexReadme: string,
   academyId: number | undefined,
+  learnpackId: number,
+  preflightInfo?: ExistingAssetInfo,
   all_translations: string[] = []
 ) => {
   const category = "uncategorized"
@@ -83,23 +133,9 @@ export const handleAssetCreation = async (
     let slug = slugify(assetTitle).slice(0, 47)
     slug = `${slug}-${selectedLang}`
 
-    const { exists, academyId: existingAcademyId } = await api.doesAssetExists(
-      sessionPayload.token,
-      slug
-    )
-
-    // Compare academy IDs if asset exists and academyId is provided
-    if (
-      exists &&
-      existingAcademyId !== undefined &&
-      academyId !== undefined &&
-      existingAcademyId !== academyId
-    ) {
-      Console.warning(
-        `Asset exists in academy ${existingAcademyId}, but attempting to publish to academy ${academyId}. ` +
-          `The asset will be updated in its current academy (${existingAcademyId}).`
-      )
-    }
+    // Use pre-flight info when available to avoid an extra GET request
+    const { exists, academyId: existingAcademyId } =
+      preflightInfo ?? (await api.doesAssetExists(sessionPayload.token, slug))
 
     // const technologies: unknown[] = Array.isArray(learnJson?.technologies) ?
     //   learnJson.technologies :
@@ -125,6 +161,7 @@ export const handleAssetCreation = async (
         preview: learnJson.preview,
         readme_raw: b64IndexReadme,
         all_translations,
+        learnpack_id: learnpackId,
       }
       if (academyId !== undefined) {
         assetPayload.academy_id = academyId
@@ -148,14 +185,25 @@ export const handleAssetCreation = async (
     }
 
     Console.info("Asset exists, updating it")
-    const asset = await api.updateAsset(sessionPayload.token, slug, {
+    const updatePayload: any = {
       graded: true,
       learnpack_deploy_url: learnpackDeployUrl,
       title: assetTitle,
       category: category,
       description: assetDescription,
       all_translations,
-    })
+      learnpack_id: learnpackId,
+    }
+    // Only set academy when the asset has none yet and the user selected one
+    if (existingAcademyId === undefined && academyId !== undefined) {
+      updatePayload.academy_id = academyId
+    }
+
+    const asset = await api.updateAsset(
+      sessionPayload.token,
+      slug,
+      updatePayload
+    )
     try {
       await api.updateRigoPackage(
         sessionPayload.rigobotToken.trim(),
@@ -179,7 +227,9 @@ export const handleAssetCreation = async (
 const createMultiLangAssetFromDisk = async (
   sessionPayload: { token: string; rigobotToken: string },
   learnJson: any,
-  deployUrl: string
+  deployUrl: string,
+  selectedAcademyId?: number,
+  existingAssetsInfo: ExistingAssetInfo[] = []
 ) => {
   const availableLangs = getAvailableLangs(learnJson)
 
@@ -190,6 +240,17 @@ const createMultiLangAssetFromDisk = async (
     return
   }
 
+  const learnpackId = await api.resolveLearnpackPackageId(
+    sessionPayload.rigobotToken,
+    learnJson.slug
+  )
+  if (learnpackId === null) {
+    Console.warning(
+      "Breathecode assets skipped: could not resolve Learnpack package id"
+    )
+    return
+  }
+
   const all_translations: string[] = []
   for (const lang of availableLangs) {
     const readmePath = path.join(
@@ -208,6 +269,7 @@ const createMultiLangAssetFromDisk = async (
     }
 
     const b64IndexReadme = Buffer.from(indexReadmeString).toString("base64")
+    const preflightInfo = existingAssetsInfo.find((a) => a.lang === lang)
 
     try {
       // eslint-disable-next-line no-await-in-loop
@@ -217,7 +279,9 @@ const createMultiLangAssetFromDisk = async (
         lang,
         deployUrl,
         b64IndexReadme,
-        undefined,
+        selectedAcademyId,
+        learnpackId,
+        preflightInfo,
         all_translations
       )
 
@@ -406,6 +470,13 @@ class BuildCommand extends SessionCommand {
       this.configManager?.buildIndex()
     }
 
+    const learnJsonPath = path.join(process.cwd(), "learn.json")
+    if (!fs.existsSync(learnJsonPath)) {
+      this.error("learn.json not found")
+    }
+
+    const learnJson = JSON.parse(fs.readFileSync(learnJsonPath, "utf-8"))
+
     const academies = await api.listUserAcademies(sessionPayload.token)
 
     if (academies.length === 0) {
@@ -415,17 +486,36 @@ class BuildCommand extends SessionCommand {
       process.exit(1)
     }
 
-    const { academy, category } = await selectAcademy(
-      academies,
-      sessionPayload.token
+    Console.info("Checking existing assets...")
+    const existingAssetsInfo = await getExistingAssetsInfo(
+      sessionPayload.token,
+      learnJson
     )
+    const academyMode = determinePublishAcademyMode(existingAssetsInfo)
 
-    const learnJsonPath = path.join(process.cwd(), "learn.json")
-    if (!fs.existsSync(learnJsonPath)) {
-      this.error("learn.json not found")
-    }
+    let selectedAcademyId: number | undefined
 
-    const learnJson = JSON.parse(fs.readFileSync(learnJsonPath, "utf-8"))
+    if (academyMode.type === "conflict") {
+      Console.warning(
+        `Some of your assets are associated with different academies ` +
+          `(${academyMode.academies.join(", ")}). ` +
+          `Academy assignment will be skipped to avoid conflicts.`
+      )
+    } else if (academyMode.type === "locked") {
+      const lockedAcademy = academies.find(
+        (a) => a.id === academyMode.academyId
+      )
+      Console.info(
+        `This package is associated with academy: ${
+          lockedAcademy?.name ?? academyMode.academyId
+        }. Academy cannot be changed.`
+      )
+      selectedAcademyId = academyMode.academyId
+    } else {
+      // mode === "select": all existing assets have no academy, user picks one
+      const { academy } = await selectAcademy(academies, sessionPayload.token)
+      selectedAcademyId = academy?.id
+    }
 
     const zipFilePath = path.join(process.cwd(), `${learnJson.slug}.zip`)
 
@@ -595,7 +685,9 @@ class BuildCommand extends SessionCommand {
         await createMultiLangAssetFromDisk(
           { token: sessionPayload.token, rigobotToken: rigoToken },
           learnJson,
-          res.data.url
+          res.data.url,
+          selectedAcademyId,
+          existingAssetsInfo
         )
       } catch (error) {
         if (axios.isAxiosError(error)) {

package/src/commands/serve.ts

@@ -55,6 +55,8 @@ import api, {
   RIGOBOT_REALTIME_HOST,
   listUserAcademies,
   doesAssetExists,
+  type AssetSyncError,
+  resolveLearnpackPackageId,
 } from "../utils/api"
 import {
   createUploadMiddleware,
@@ -87,7 +89,8 @@ import { HistoryManager } from "../managers/historyManager"
 import { ReadmeHistoryService } from "../managers/readmeHistoryService"
 import { sanitizeReadmeNewlines } from "../utils/readmeSanitizer"
 
-const frontMatter = require("front-matter")
+// eslint-disable-next-line
+const frontMatter = require("front-matter");
 
 if (process.env.NEW_RELIC_ENABLED === "true") {
   require("newrelic")
@@ -582,6 +585,16 @@ const getLocalizedValue = (
   return typeof first === "string" ? first : ""
 }
 
+function assetSyncErrorDetail(err: any): string {
+  if (typeof err?.detail === "string") return err.detail
+  if (typeof err?.message === "string") return err.message
+  try {
+    return JSON.stringify(err)
+  } catch {
+    return String(err)
+  }
+}
+
 const createMultiLangAsset = async (
   bucket: Bucket,
   rigoToken: string,
@@ -590,12 +603,27 @@ const createMultiLangAsset = async (
   courseJson: any,
   deployUrl: string,
   academyId?: number
-): Promise<{ errors: Array<{ lang: string; error: any }> }> => {
+): Promise<{ errors: AssetSyncError[] }> => {
+  const learnpackId = await resolveLearnpackPackageId(rigoToken, courseSlug)
+  if (learnpackId === null) {
+    return {
+      errors: [
+        {
+          kind: "package_error",
+          error: {
+            detail:
+              "Could not resolve Learnpack package id; assets not synced to Breathecode.",
+          },
+        },
+      ],
+    }
+  }
+
   const availableLangs = Object.keys(courseJson.title)
   console.log("AVAILABLE LANGUAGES to upload asset", availableLangs)
 
   const all_translations: string[] = []
-  const errors: Array<{ lang: string; error: any }> = []
+  const errors: AssetSyncError[] = []
 
   for (const lang of availableLangs) {
     // eslint-disable-next-line no-await-in-loop
@@ -624,13 +652,16 @@ const createMultiLangAsset = async (
         deployUrl,
         b64IndexReadme,
         academyId,
+        learnpackId,
+        undefined,
         all_translations
       )
 
       if (!asset) {
         errors.push({
+          kind: "lang_error",
           lang,
-          error: { detail: "Failed to create asset", status_code: 500 },
+          error: { detail: "Failed to create asset" },
         })
         console.log("No se pudo crear el asset, saltando idioma", lang)
         continue
@@ -642,7 +673,11 @@ const createMultiLangAsset = async (
         error && typeof error === "object" && "response" in error ?
           (error as any).response?.data || error :
           error
-      errors.push({ lang, error: errorData })
+      errors.push({
+        kind: "lang_error",
+        lang,
+        error: { detail: assetSyncErrorDetail(errorData) },
+      })
       console.error(`Error creating asset for language ${lang}:`, error)
     }
   }
@@ -5451,30 +5486,56 @@ class ServeCommand extends SessionCommand {
         const { config } = configJson
 
         const availableLangs = Object.keys(config.title || {})
-        let academyId: number | null = null
         let isPublished = false
 
-        for (const lang of availableLangs) {
-          const assetTitle = getLocalizedValue(config.title, lang)
-          if (!assetTitle) continue
+        // Collect academy ids from all existing assets
+        const foundAcademyIds: number[] = []
 
-          let assetSlug = slugify(assetTitle).slice(0, 47)
-          assetSlug = `${assetSlug}-${lang}`
+        const slugsToCheck = availableLangs
+          .map(lang => {
+            const assetTitle = getLocalizedValue(config.title, lang)
+            if (!assetTitle) return null
+            const assetSlug = slugify(assetTitle).slice(0, 47)
+            return `${assetSlug}-${lang}`
+          })
+          .filter((slug): slug is string => slug !== null)
 
-          const { exists, academyId: existingAcademyId } =
-            // eslint-disable-next-line no-await-in-loop
-            await doesAssetExists(bcToken, assetSlug)
+        const assetChecks = await Promise.all(
+          slugsToCheck.map(slug => doesAssetExists(bcToken, slug))
+        )
 
+        for (const { exists, academyId: existingAcademyId } of assetChecks) {
           if (exists) {
             isPublished = true
             if (existingAcademyId !== undefined) {
-              academyId = existingAcademyId
-              break
+              foundAcademyIds.push(existingAcademyId)
             }
           }
         }
 
-        return res.json({ academyId, isPublished })
+        const uniqueAcademies = [...new Set(foundAcademyIds)]
+
+        type AcademyMode = "select" | "locked" | "conflict";
+        let mode: AcademyMode
+        let lockedAcademyId: number | undefined
+        let conflictAcademies: number[] | undefined
+
+        if (uniqueAcademies.length === 0) {
+          mode = "select"
+        } else if (uniqueAcademies.length === 1) {
+          mode = "locked"
+          lockedAcademyId = uniqueAcademies[0]
+        } else {
+          mode = "conflict"
+          conflictAcademies = uniqueAcademies
+        }
+
+        return res.json({
+          isPublished,
+          mode,
+          lockedAcademyId,
+          conflictAcademies,
+        })
       } catch (error) {
         console.error("Error fetching package academy:", error)
         return res.status(500).json({ error: (error as Error).message })
@@ -5592,38 +5653,76 @@ class ServeCommand extends SessionCommand {
         const archive = archiver("zip", { zlib: { level: 9 } })
 
         output.on("close", async () => {
-          // 10) Subir ZIP a RigoBot
-          const form = new FormData()
-          form.append("file", fs.createReadStream(zipPath))
-          form.append("config", JSON.stringify(config))
-
-          const rigoRes = await axios.post(
-            `${RIGOBOT_HOST}/v1/learnpack/upload`,
-            form,
-            {
-              headers: {
-                ...form.getHeaders(),
-                Authorization: "Token " + rigoToken.trim(),
-              },
-            }
-          )
+          let rigoPublishUrl: string | undefined
+          try {
+            // 10) Subir ZIP a RigoBot
+            const form = new FormData()
+            form.append("file", fs.createReadStream(zipPath))
+            form.append("config", JSON.stringify(config))
+
+            const rigoRes = await axios.post(
+              `${RIGOBOT_HOST}/v1/learnpack/upload`,
+              form,
+              {
+                headers: {
+                  ...form.getHeaders(),
+                  Authorization: "Token " + rigoToken.trim(),
+                },
+              }
+            )
+            rigoPublishUrl = rigoRes.data.url
 
-          const assetResults = await createMultiLangAsset(
-            bucket,
-            rigoToken,
-            bcToken,
-            slug,
-            fullConfig.config,
-            rigoRes.data.url,
-            academyId
-          )
+            let errors: AssetSyncError[]
+            try {
+              const assetResults = await createMultiLangAsset(
+                bucket,
+                rigoToken,
+                bcToken,
+                slug,
+                fullConfig.config,
+                rigoRes.data.url,
+                academyId
+              )
+              errors = assetResults.errors
+            } catch (error) {
+              console.error("Asset sync failed unexpectedly:", error)
+              errors = [
+                {
+                  kind: "package_error",
+                  error: { detail: "Asset sync failed unexpectedly." },
+                },
+              ]
+            }
 
-          rimraf.sync(tmpRoot)
-          console.log("RigoRes", rigoRes.data)
-          return res.json({
-            url: rigoRes.data.url,
-            errors: assetResults.errors,
-          })
+            if (res.headersSent) return
+            console.log("RigoRes", rigoRes.data)
+            res.json({
+              url: rigoPublishUrl,
+              errors,
+            })
+          } catch (error) {
+            console.error(error)
+            if (res.headersSent) return
+            if (rigoPublishUrl !== undefined) {
+              res.json({
+                url: rigoPublishUrl,
+                errors: [
+                  {
+                    kind: "package_error",
+                    error: { detail: "Asset sync failed unexpectedly." },
+                  },
+                ],
+              })
+            } else {
+              res.status(500).json({ error: (error as Error).message })
+            }
+          } finally {
+            try {
+              rimraf.sync(tmpRoot)
+            } catch (error) {
+              console.error("rimraf tmpRoot:", error)
+            }
+          }
         })
 
         archive.on("error", err => {