@learnpack/learnpack 5.0.358 → 5.0.360

package/src/commands/publish.ts

@@ -19,282 +19,78 @@ import api, { getConsumable, RIGOBOT_HOST, TAcademy } from "../utils/api"
 import * as prompts from "prompts"
 import { isValidRigoToken } from "../utils/rigoActions"
 import { minutesToISO8601Duration } from "../utils/misc"
-import { getReadmeExtension, slugify } from "../utils/creatorUtilities"
+import { getReadmeExtension } from "../utils/creatorUtilities"
 import { getFallbackPreviewUrl } from "../utils/branding"
+import {
+  determineAcademyMode,
+  getAvailableLangs,
+  PackageAssetsResolution,
+  resolvePackageAssets,
+} from "../utils/assetResolver"
+import { getLocalizedValue, syncPackageAssets } from "../utils/assetSync"
 
 const uploadZipEndpont = RIGOBOT_HOST + "/v1/learnpack/upload"
 
-const getAvailableLangs = (learnJson: any): string[] => {
-  const langs = Object.keys(learnJson?.title || {})
-  return langs.filter((l) => typeof l === "string" && l.length > 0)
-}
-
 const getDefaultLang = (learnJson: any): string => {
   const availableLangs = getAvailableLangs(learnJson)
   if (availableLangs.length === 0) return "en"
   return availableLangs.includes("en") ? "en" : availableLangs[0]
 }
 
-const getLocalizedValue = (
-  translations: Record<string, any> | undefined,
-  lang: string,
-  fallbackLangs: string[] = ["en", "us"]
-): string => {
-  if (!translations || typeof translations !== "object") return ""
-
-  const direct = translations[lang]
-  if (typeof direct === "string" && direct.trim().length > 0) return direct
-
-  for (const fb of fallbackLangs) {
-    const v = translations[fb]
-    if (typeof v === "string" && v.trim().length > 0) return v
-  }
-
-  const firstKey = Object.keys(translations)[0]
-  const first = firstKey ? translations[firstKey] : ""
-  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,
-  selectedLang: string,
-  learnpackDeployUrl: string,
-  b64IndexReadme: string,
-  academyId: number | undefined,
-  learnpackId: number,
-  preflightInfo?: ExistingAssetInfo,
-  all_translations: string[] = []
-) => {
-  const category = "uncategorized"
-
+const readReadmeFromDisk = async (lang: string): Promise<string> => {
+  const readmePath = path.join(
+    process.cwd(),
+    `README${getReadmeExtension(lang)}`
+  )
   try {
-    const user = await api.validateToken(sessionPayload.token)
-
-    const assetTitle = getLocalizedValue(learnJson?.title, selectedLang)
-    const assetDescription = getLocalizedValue(
-      learnJson?.description,
-      selectedLang
-    )
-
-    if (!assetTitle) {
-      throw new Error(
-        `Missing learn.json title for language "${selectedLang}"`
-      )
-    }
-
-    let slug = slugify(assetTitle).slice(0, 47)
-    slug = `${slug}-${selectedLang}`
-
-    // 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 :
-    //   []
-
-    if (!exists) {
-      Console.info("Asset does not exist in this academy, creating it")
-      const assetPayload: any = {
-        slug: slug,
-        title: assetTitle,
-        lang: selectedLang,
-        graded: true,
-        description: assetDescription,
-        learnpack_deploy_url: learnpackDeployUrl,
-        // technologies: technologies.map((tech: unknown) =>
-        //   String(tech).toLowerCase().replace(/\s+/g, "-")
-        // ),
-        technologies: [],
-        url: learnpackDeployUrl,
-        category: category,
-        owner: user.id,
-        author: user.id,
-        preview: learnJson.preview,
-        readme_raw: b64IndexReadme,
-        all_translations,
-        learnpack_id: learnpackId,
-      }
-      if (academyId !== undefined) {
-        assetPayload.academy_id = academyId
-      }
-
-      const asset = await api.createAsset(sessionPayload.token, assetPayload)
-      try {
-        await api.updateRigoPackage(
-          sessionPayload.rigobotToken.trim(),
-          learnJson.slug,
-          {
-            asset_id: asset.id,
-          }
-        )
-      } catch (error) {
-        Console.error("Error updating Rigo package:", error)
-      }
-
-      Console.info("Asset created with id", asset.id)
-      return asset
-    }
-
-    Console.info("Asset exists, updating it")
-    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(),
-        learnJson.slug,
-        {
-          asset_id: asset.id,
-        }
-      )
-    } catch (error) {
-      Console.error("Error updating Rigo package:", error)
-    }
-
-    Console.info("Asset updated with id", asset.id)
-    return asset
+    return fs.existsSync(readmePath) ?
+      fs.readFileSync(readmePath, "utf-8") :
+      ""
   } catch (error) {
-    Console.error("Error updating or creating asset:", error)
-    throw error
+    Console.error("Error reading index readme:", error)
+    return ""
   }
 }
 
-const createMultiLangAssetFromDisk = async (
+const syncAssetsFromDisk = async (
   sessionPayload: { token: string; rigobotToken: string },
   learnJson: any,
   deployUrl: string,
-  selectedAcademyId?: number,
-  existingAssetsInfo: ExistingAssetInfo[] = []
+  selectedAcademyId: number | undefined,
+  resolution: PackageAssetsResolution
 ) => {
-  const availableLangs = getAvailableLangs(learnJson)
-
-  if (availableLangs.length === 0) {
+  if (getAvailableLangs(learnJson).length === 0) {
     Console.error(
       "No languages found in learn.json.title. Add at least one language (e.g. title.en)."
     )
     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
-  }
+  // The pre-upload resolution is reused unless the package did not exist in
+  // Rigobot yet (first publish): the upload has just created it.
+  const result = await syncPackageAssets({
+    bcToken: sessionPayload.token,
+    rigoToken: sessionPayload.rigobotToken,
+    packageSlug: learnJson.slug,
+    learnJson,
+    deployUrl,
+    academyId: selectedAcademyId,
+    readReadme: readReadmeFromDisk,
+    resolution: resolution.learnpackId === null ? undefined : resolution,
+  })
 
-  const all_translations: string[] = []
-  for (const lang of availableLangs) {
-    const readmePath = path.join(
-      process.cwd(),
-      `README${getReadmeExtension(lang)}`
+  for (const warning of result.warnings) Console.warning(warning)
+  for (const synced of result.synced) {
+    Console.info(
+      `Asset ${synced.action} for "${synced.lang}": #${synced.asset.id} ${synced.asset.slug}`
     )
+  }
 
-    let indexReadmeString = ""
-    try {
-      if (fs.existsSync(readmePath)) {
-        indexReadmeString = fs.readFileSync(readmePath, "utf-8")
-      }
-    } catch (error) {
-      Console.error("Error reading index readme:", error)
-      indexReadmeString = ""
-    }
-
-    const b64IndexReadme = Buffer.from(indexReadmeString).toString("base64")
-    const preflightInfo = existingAssetsInfo.find((a) => a.lang === lang)
-
-    try {
-      // eslint-disable-next-line no-await-in-loop
-      const asset = await handleAssetCreation(
-        sessionPayload,
-        learnJson,
-        lang,
-        deployUrl,
-        b64IndexReadme,
-        selectedAcademyId,
-        learnpackId,
-        preflightInfo,
-        all_translations
-      )
-
-      if (!asset) {
-        Console.debug("Could not create/update asset for lang", lang)
-        continue
-      }
-
-      all_translations.push(asset.slug)
-    } catch (error) {
-      Console.error("Error creating asset for language", lang, error)
-      // Continue with other languages
+  for (const error of result.errors) {
+    if (error.kind === "lang_error") {
+      Console.error(`Asset for "${error.lang}": ${error.error.detail}`)
+    } else {
+      Console.error(error.error.detail)
     }
   }
 }
@@ -488,11 +284,21 @@ class BuildCommand extends SessionCommand {
     }
 
     Console.info("Checking existing assets...")
-    const existingAssetsInfo = await getExistingAssetsInfo(
-      sessionPayload.token,
-      learnJson
-    )
-    const academyMode = determinePublishAcademyMode(existingAssetsInfo)
+    const resolution = await resolvePackageAssets({
+      bcToken: sessionPayload.token,
+      rigoToken: rigoToken,
+      packageSlug: learnJson.slug,
+      learnJson,
+    })
+    for (const warning of resolution.warnings) Console.warning(warning)
+    if (resolution.packageState === "unknown") {
+      Console.error(
+        `${resolution.packageError}. Existing assets cannot be checked, so publishing now could create duplicates. Try again later.`
+      )
+      process.exit(1)
+    }
+
+    const academyMode = determineAcademyMode(resolution)
 
     let selectedAcademyId: number | undefined
 
@@ -688,12 +494,12 @@ class BuildCommand extends SessionCommand {
         fs.unlinkSync(zipFilePath)
         this.removeDirectory(buildDir)
 
-        await createMultiLangAssetFromDisk(
+        await syncAssetsFromDisk(
           { token: sessionPayload.token, rigobotToken: rigoToken },
           learnJson,
           res.data.url,
           selectedAcademyId,
-          existingAssetsInfo
+          resolution
         )
       } catch (error) {
         if (axios.isAxiosError(error)) {

package/src/commands/serve.ts

@@ -55,9 +55,7 @@ import api, {
   RIGOBOT_HOST,
   RIGOBOT_REALTIME_HOST,
   listUserAcademies,
-  doesAssetExists,
   type AssetSyncError,
-  resolveLearnpackPackageId,
 } from "../utils/api"
 import {
   createUploadMiddleware,
@@ -66,7 +64,12 @@ import {
 import { buildConfig } from "../utils/configBuilder"
 import { checkReadability, slugify } from "../utils/creatorUtilities"
 import { checkAndFixSidebarPure } from "../utils/sidebarGenerator"
-import { handleAssetCreation } from "./publish"
+import {
+  determineAcademyMode,
+  hasPublishedAsset,
+  resolvePackageAssets,
+} from "../utils/assetResolver"
+import { syncPackageAssets } from "../utils/assetSync"
 import {
   FormState,
   Lesson,
@@ -538,36 +541,6 @@ const cleanFormStateForSyllabus = (formState: FormState) => {
   }
 }
 
-const getLocalizedValue = (
-  translations: Record<string, any> | undefined,
-  lang: string,
-  fallbackLangs: string[] = ["en", "us"]
-): string => {
-  if (!translations || typeof translations !== "object") return ""
-
-  const direct = translations[lang]
-  if (typeof direct === "string" && direct.trim().length > 0) return direct
-
-  for (const fb of fallbackLangs) {
-    const v = translations[fb]
-    if (typeof v === "string" && v.trim().length > 0) return v
-  }
-
-  const firstKey = Object.keys(translations)[0]
-  const first = firstKey ? translations[firstKey] : ""
-  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,
@@ -577,85 +550,38 @@ const createMultiLangAsset = async (
   deployUrl: string,
   academyId?: number
 ): 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: AssetSyncError[] = []
-
-  for (const lang of availableLangs) {
-    // eslint-disable-next-line no-await-in-loop
-    const indexReadme = await bucket.file(
+  const readReadme = async (lang: string): Promise<string> => {
+    const indexReadme = bucket.file(
       `courses/${courseSlug}/README${getReadmeExtension(lang)}`
     )
-    let indexReadmeString = ""
     try {
-      // eslint-disable-next-line no-await-in-loop
-      const [indexReadmeContent] = await indexReadme.download()
-      indexReadmeString = indexReadmeContent.toString()
+      const [content] = await indexReadme.download()
+      return content.toString()
     } catch (error) {
       console.error("Error downloading index readme", error)
       // TODO: Trigger generation of the index readme
-      indexReadmeString = ""
+      return ""
     }
+  }
 
-    const b64IndexReadme = Buffer.from(indexReadmeString).toString("base64")
-
-    try {
-      // eslint-disable-next-line no-await-in-loop
-      const asset = await handleAssetCreation(
-        { token: bcToken, rigobotToken: rigoToken.trim() },
-        courseJson,
-        lang,
-        deployUrl,
-        b64IndexReadme,
-        academyId,
-        learnpackId,
-        undefined,
-        all_translations
-      )
-
-      if (!asset) {
-        errors.push({
-          kind: "lang_error",
-          lang,
-          error: { detail: "Failed to create asset" },
-        })
-        console.log("No se pudo crear el asset, saltando idioma", lang)
-        continue
-      }
+  const result = await syncPackageAssets({
+    bcToken,
+    rigoToken,
+    packageSlug: courseSlug,
+    learnJson: courseJson,
+    deployUrl,
+    academyId,
+    readReadme,
+  })
 
-      all_translations.push(asset.slug)
-    } catch (error) {
-      const errorData =
-        error && typeof error === "object" && "response" in error ?
-          (error as any).response?.data || error :
-          error
-      errors.push({
-        kind: "lang_error",
-        lang,
-        error: { detail: assetSyncErrorDetail(errorData) },
-      })
-      console.error(`Error creating asset for language ${lang}:`, error)
-    }
+  for (const warning of result.warnings) console.warn("[assets]", warning)
+  for (const synced of result.synced) {
+    console.log(
+      `[assets] ${synced.action} "${synced.lang}": #${synced.asset.id} ${synced.asset.slug}`
+    )
   }
 
-  return { errors }
+  return { errors: result.errors }
 }
 
 const lessonCleaner = (lesson: Lesson) => {
@@ -5392,6 +5318,10 @@ class ServeCommand extends SessionCommand {
           })
         }
 
+        // Older IDEs only send the Breathecode token; without the Rigobot
+        // token the lookup falls back to the title-derived slugs.
+        const rigoToken = req.header("x-rigo-token")
+
         const configFile = await bucket.file(
           `courses/${slug}/.learn/config.json`
         )
@@ -5399,56 +5329,51 @@ class ServeCommand extends SessionCommand {
         const configJson = JSON.parse(configContent.toString())
         const { config } = configJson
 
-        const availableLangs = Object.keys(config.title || {})
-        let isPublished = false
-
-        // Collect academy ids from all existing assets
-        const foundAcademyIds: number[] = []
-
-        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 resolution = await resolvePackageAssets({
+          bcToken,
+          rigoToken,
+          packageSlug: slug,
+          learnJson: config,
+        })
+        for (const warning of resolution.warnings) {
+          console.warn("[package-academy]", warning)
+        }
 
-        const assetChecks = await Promise.all(
-          slugsToCheck.map(slug => doesAssetExists(bcToken, slug))
-        )
+        const isPublished = hasPublishedAsset(resolution)
+        const academyMode = determineAcademyMode(resolution)
+        const warnings = [...resolution.warnings]
+        if (resolution.packageState === "unknown") {
+          warnings.push(
+            `${resolution.packageError}; existing assets could not be checked.`
+          )
+        }
 
-        for (const { exists, academyId: existingAcademyId } of assetChecks) {
-          if (exists) {
-            isPublished = true
-            if (existingAcademyId !== undefined) {
-              foundAcademyIds.push(existingAcademyId)
-            }
+        for (const [lang, entry] of resolution.byLang) {
+          if (entry.status === "unknown") {
+            warnings.push(`"${lang}": ${entry.error}`)
+          } else if (entry.status === "ambiguous") {
+            warnings.push(
+              `"${lang}": ${
+                entry.candidates.length
+              } assets found (${entry.candidates
+                .map(c => `#${c.id} ${c.slug}`)
+                .join(", ")})`
+            )
           }
         }
 
-        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
-        }
+        const mode = academyMode.type
+        const lockedAcademyId =
+          academyMode.type === "locked" ? academyMode.academyId : undefined
+        const conflictAcademies =
+          academyMode.type === "conflict" ? academyMode.academies : undefined
 
         return res.json({
           isPublished,
           mode,
           lockedAcademyId,
           conflictAcademies,
+          warnings,
         })
       } catch (error) {
         console.error("Error fetching package academy:", error)