@learnpack/learnpack 5.0.358 → 5.0.360

package/lib/utils/assetResolver.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPublishedAsset = exports.determineAcademyMode = exports.describeAmbiguity = exports.slugCandidatesForLang = exports.dedupeLangs = exports.getAvailableLangs = exports.canonicalLang = void 0;
+exports.resolvePackageAssets = resolvePackageAssets;
+/**
+ * Resolves which Breathecode assets already represent a Learnpack package,
+ * one per language, before publish decides whether to create or update.
+ *
+ * The anchor is the package's `asset_ids` in Rigobot, read back by id from
+ * Breathecode. The title-derived slug is only a fallback for packages that
+ * predate `asset_ids`; it is never the criterion for a package whose ids are
+ * known. Every "could not check" outcome is reported as such, never as "does
+ * not exist", so a network hiccup cannot turn into a duplicate asset.
+ */
+const api_1 = require("./api");
+const creatorUtilities_1 = require("./creatorUtilities");
+/**
+ * Breathecode stores "en" as "us"; both name the same language.
+ * @param lang - Language code as found in learn.json or on an asset.
+ * @returns The canonical code, or null when there is none.
+ */
+const canonicalLang = (lang) => {
+    if (typeof lang !== "string")
+        return null;
+    const lower = lang.trim().toLowerCase();
+    if (!lower)
+        return null;
+    return lower === "en" ? "us" : lower;
+};
+exports.canonicalLang = canonicalLang;
+/**
+ * Language keys of learn.json.title, in declaration order.
+ * @param learnJson - Parsed learn.json.
+ * @returns Non-empty string keys of `title`.
+ */
+const getAvailableLangs = (learnJson) => {
+    const langs = Object.keys((learnJson === null || learnJson === void 0 ? void 0 : learnJson.title) || {});
+    return langs.filter(l => typeof l === "string" && l.length > 0);
+};
+exports.getAvailableLangs = getAvailableLangs;
+/**
+ * Drops keys that name the same language ("en" and "us"), keeping "en" when
+ * both are present and the first one declared otherwise.
+ * @param langs - Language keys as declared in learn.json.
+ * @returns One key per canonical language.
+ */
+const dedupeLangs = (langs) => {
+    const byCanonical = new Map();
+    for (const lang of langs) {
+        const canonical = (0, exports.canonicalLang)(lang);
+        if (canonical === null)
+            continue;
+        const current = byCanonical.get(canonical);
+        if (current === undefined || (lang === "en" && current === "us")) {
+            byCanonical.set(canonical, lang);
+        }
+    }
+    return [...byCanonical.values()];
+};
+exports.dedupeLangs = dedupeLangs;
+/**
+ * Slugs an asset for this language may have been created under.
+ *
+ * One per learn.json title naming this language (title.en and title.us can
+ * differ, and a historical asset came from whichever existed at the time),
+ * each with both suffixes when the language is "us"/"en".
+ * @param learnJson - Parsed learn.json.
+ * @param canonical - Canonical language.
+ * @returns Distinct candidate slugs, most likely first.
+ */
+const slugCandidatesForLang = (learnJson, canonical) => {
+    const suffixes = canonical === "us" ? ["en", "us"] : [canonical];
+    const seen = new Set();
+    const out = [];
+    for (const key of (0, exports.getAvailableLangs)(learnJson)) {
+        if ((0, exports.canonicalLang)(key) !== canonical)
+            continue;
+        const title = learnJson.title[key];
+        if (typeof title !== "string" || !title.trim())
+            continue;
+        for (const suffix of suffixes) {
+            const slug = (0, creatorUtilities_1.buildAssetSlug)(title, suffix);
+            if (!seen.has(slug)) {
+                seen.add(slug);
+                out.push(slug);
+            }
+        }
+    }
+    return out;
+};
+exports.slugCandidatesForLang = slugCandidatesForLang;
+const describeAsset = (asset) => {
+    var _a;
+    return `#${asset.id} ${asset.slug} (${(_a = asset.status) !== null && _a !== void 0 ? _a : "?"}${asset.academyId === null ? "" : `, academy ${asset.academyId}`})`;
+};
+/**
+ * Text for the error a language gets when more than one asset claims it.
+ * @param lang - Language key from learn.json.
+ * @param candidates - The competing assets.
+ * @returns An actionable message naming every candidate.
+ */
+const describeAmbiguity = (lang, candidates) => `Found ${candidates.length} Breathecode assets for language "${lang}": ${candidates
+    .map(describeAsset)
+    .join("; ")}. Nothing was created or updated for this language. Keep only the definitive ids in the Rigobot package (asset_ids) and publish again.`;
+exports.describeAmbiguity = describeAmbiguity;
+/**
+ * Resolves the existing Breathecode asset for every language of a package.
+ * @param input - Tokens, package slug and parsed learn.json.
+ * @returns Per-language resolution plus the package-level facts publish needs.
+ */
+async function resolvePackageAssets(input) {
+    var _a, _b, _c, _d;
+    const deps = (_a = input.deps) !== null && _a !== void 0 ? _a : api_1.default;
+    const warnings = [];
+    const langs = (0, exports.dedupeLangs)((0, exports.getAvailableLangs)(input.learnJson));
+    const byLang = new Map();
+    const unknownEverywhere = (error, learnpackId) => {
+        for (const lang of langs) {
+            byLang.set((0, exports.canonicalLang)(lang), { status: "unknown", error });
+        }
+        return {
+            packageSlug: input.packageSlug,
+            learnpackId,
+            packageState: "unknown",
+            packageError: error,
+            knownAssetIds: [],
+            orphanIds: [],
+            byLang,
+            warnings,
+        };
+    };
+    // Step 0: the package in Rigobot, and the asset ids it already knows.
+    let learnpackId = null;
+    let previousIds = [];
+    if ((_b = input.rigoToken) === null || _b === void 0 ? void 0 : _b.trim()) {
+        const pkg = await deps.getRigoPackage(input.rigoToken, input.packageSlug);
+        if (pkg.kind === "error") {
+            return unknownEverywhere(`Could not read the Rigobot package "${input.packageSlug}": ${pkg.error}`, null);
+        }
+        if (pkg.kind === "found") {
+            learnpackId = pkg.id;
+            previousIds = [...new Set(pkg.assetIds)];
+        }
+    }
+    else {
+        warnings.push("No Rigobot token: existing assets are looked up by slug only.");
+    }
+    // Step 1: read every known id back from Breathecode.
+    const knownAssetIds = [];
+    const orphanIds = [];
+    const candidatesByLang = new Map();
+    for (const id of previousIds) {
+        // eslint-disable-next-line no-await-in-loop
+        const lookup = await deps.getAssetById(input.bcToken, id);
+        if (lookup.kind === "error") {
+            return unknownEverywhere(`Could not read Breathecode asset #${id}: ${lookup.error}`, learnpackId);
+        }
+        if (lookup.kind === "missing") {
+            warnings.push(`Asset #${id} listed in the Rigobot package no longer exists in Breathecode; dropped.`);
+            continue;
+        }
+        const asset = lookup.asset;
+        if (asset.learnpackId !== null &&
+            learnpackId !== null &&
+            asset.learnpackId !== learnpackId) {
+            warnings.push(`Asset ${describeAsset(asset)} belongs to Learnpack package ${asset.learnpackId}, not ${learnpackId}; ignored.`);
+            continue;
+        }
+        const canonical = (0, exports.canonicalLang)(asset.lang);
+        if (canonical === null) {
+            orphanIds.push(asset.id);
+            warnings.push(`Asset ${describeAsset(asset)} has no language; kept in the package but not used.`);
+            continue;
+        }
+        knownAssetIds.push(asset.id);
+        const group = (_c = candidatesByLang.get(canonical)) !== null && _c !== void 0 ? _c : [];
+        group.push(asset);
+        candidatesByLang.set(canonical, group);
+    }
+    // Step 2: languages with no known id fall back to the title-derived slugs.
+    for (const lang of langs) {
+        const canonical = (0, exports.canonicalLang)(lang);
+        const known = (_d = candidatesByLang.get(canonical)) !== null && _d !== void 0 ? _d : [];
+        if (known.length === 1) {
+            byLang.set(canonical, { status: "found", asset: known[0], via: "id" });
+            continue;
+        }
+        if (known.length > 1) {
+            byLang.set(canonical, { status: "ambiguous", candidates: known });
+            continue;
+        }
+        const found = new Map();
+        let error = null;
+        for (const slug of (0, exports.slugCandidatesForLang)(input.learnJson, canonical)) {
+            // eslint-disable-next-line no-await-in-loop
+            const lookup = await deps.getAssetBySlug(input.bcToken, slug);
+            if (lookup.kind === "error") {
+                error = `Could not check Breathecode asset "${slug}": ${lookup.error}`;
+                break;
+            }
+            if (lookup.kind === "missing")
+                continue;
+            const asset = lookup.asset;
+            if (asset.learnpackId !== null &&
+                learnpackId !== null &&
+                asset.learnpackId !== learnpackId) {
+                warnings.push(`Asset ${describeAsset(asset)} matches the slug for "${lang}" but belongs to Learnpack package ${asset.learnpackId}; ignored.`);
+                continue;
+            }
+            found.set(asset.id, asset);
+        }
+        if (error !== null) {
+            byLang.set(canonical, { status: "unknown", error });
+        }
+        else if (found.size === 0) {
+            byLang.set(canonical, { status: "missing" });
+        }
+        else if (found.size === 1) {
+            const asset = [...found.values()][0];
+            if (previousIds.length > 0) {
+                warnings.push(`Asset ${describeAsset(asset)} for "${lang}" was found by slug, not through the Rigobot package; it will be added to asset_ids.`);
+            }
+            byLang.set(canonical, { status: "found", asset, via: "slug" });
+        }
+        else {
+            byLang.set(canonical, {
+                status: "ambiguous",
+                candidates: [...found.values()],
+            });
+        }
+    }
+    return {
+        packageSlug: input.packageSlug,
+        learnpackId,
+        packageState: "ok",
+        knownAssetIds,
+        orphanIds,
+        byLang,
+        warnings,
+    };
+}
+/**
+ * Academy handling for the publish prompt, from the assets that were found.
+ * @param resolution - Output of resolvePackageAssets.
+ * @returns `select` when no found asset has an academy, `locked` when they all share one, `conflict` otherwise.
+ */
+const determineAcademyMode = (resolution) => {
+    const academyIds = [];
+    for (const entry of resolution.byLang.values()) {
+        if (entry.status === "found" && entry.asset.academyId !== null) {
+            academyIds.push(entry.asset.academyId);
+        }
+    }
+    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 };
+};
+exports.determineAcademyMode = determineAcademyMode;
+/**
+ * Whether at least one language already has an asset.
+ * @param resolution - Output of resolvePackageAssets.
+ * @returns True when any language resolved to `found`.
+ */
+const hasPublishedAsset = (resolution) => [...resolution.byLang.values()].some(entry => entry.status === "found");
+exports.hasPublishedAsset = hasPublishedAsset;

package/lib/utils/assetSync.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Creates or updates the Breathecode assets of a published package, one per
+ * language, and writes the resulting ids back to the Rigobot package.
+ *
+ * Kept free of fs, oclif and express so the whole decision table can be
+ * exercised with HTTP mocks alone; `publish` and `serve` only supply the
+ * readme of each language and the tokens.
+ */
+import { AssetSyncError } from "./api";
+import { PackageAssetsResolution } from "./assetResolver";
+export type AssetSyncInput = {
+    bcToken: string;
+    rigoToken: string;
+    packageSlug: string;
+    learnJson: any;
+    deployUrl: string;
+    academyId?: number;
+    /** Raw readme for a language ("" when there is none). Base64 encoding happens here. */
+    readReadme: (lang: string) => Promise<string>;
+    /** A resolution computed earlier (e.g. before the upload) to reuse instead of resolving again. */
+    resolution?: PackageAssetsResolution;
+};
+export type SyncedAsset = {
+    lang: string;
+    action: "created" | "updated";
+    asset: {
+        id: number;
+        slug: string;
+    };
+};
+export type AssetSyncResult = {
+    errors: AssetSyncError[];
+    warnings: string[];
+    synced: SyncedAsset[];
+};
+/**
+ * Localized value with the same fallbacks the publish flow always used.
+ * @param translations - A learn.json map such as `title` or `description`.
+ * @param lang - Preferred language key.
+ * @returns The value for `lang`, else "en"/"us", else the first one, else "".
+ */
+export declare const getLocalizedValue: (translations: Record<string, any> | undefined, lang: string) => string;
+/**
+ * Synchronises every language of a package with Breathecode.
+ * @param input - Tokens, package data, deploy url and readme provider.
+ * @returns Per-language errors (the publish itself is never blocked), warnings worth logging, and what was written.
+ */
+export declare function syncPackageAssets(input: AssetSyncInput): Promise<AssetSyncResult>;

package/lib/utils/assetSync.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalizedValue = void 0;
+exports.syncPackageAssets = syncPackageAssets;
+/**
+ * Creates or updates the Breathecode assets of a published package, one per
+ * language, and writes the resulting ids back to the Rigobot package.
+ *
+ * Kept free of fs, oclif and express so the whole decision table can be
+ * exercised with HTTP mocks alone; `publish` and `serve` only supply the
+ * readme of each language and the tokens.
+ */
+const api_1 = require("./api");
+const console_1 = require("./console");
+const creatorUtilities_1 = require("./creatorUtilities");
+const assetResolver_1 = require("./assetResolver");
+/**
+ * Localized value with the same fallbacks the publish flow always used.
+ * @param translations - A learn.json map such as `title` or `description`.
+ * @param lang - Preferred language key.
+ * @returns The value for `lang`, else "en"/"us", else the first one, else "".
+ */
+const getLocalizedValue = (translations, lang) => {
+    if (!translations || typeof translations !== "object")
+        return "";
+    const direct = translations[lang];
+    if (typeof direct === "string" && direct.trim().length > 0)
+        return direct;
+    for (const fb of ["en", "us"]) {
+        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 : "";
+};
+exports.getLocalizedValue = getLocalizedValue;
+const packageError = (detail) => ({
+    kind: "package_error",
+    error: { detail },
+});
+const langError = (lang, detail) => ({
+    kind: "lang_error",
+    lang,
+    error: { detail },
+});
+const errorDetail = (error) => {
+    const err = error;
+    if (typeof (err === null || err === void 0 ? void 0 : err.detail) === "string")
+        return err.detail;
+    if (typeof (err === null || err === void 0 ? void 0 : err.message) === "string")
+        return err.message;
+    try {
+        return JSON.stringify(err);
+    }
+    catch (_a) {
+        return String(err);
+    }
+};
+/**
+ * Synchronises every language of a package with Breathecode.
+ * @param input - Tokens, package data, deploy url and readme provider.
+ * @returns Per-language errors (the publish itself is never blocked), warnings worth logging, and what was written.
+ */
+async function syncPackageAssets(input) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const warnings = [];
+    const errors = [];
+    const synced = [];
+    const user = await api_1.default.validateToken(input.bcToken);
+    if (!user || typeof user.id !== "number") {
+        return {
+            errors: [packageError("Invalid Breathecode token; assets not synced.")],
+            warnings,
+            synced,
+        };
+    }
+    const resolution = (_a = input.resolution) !== null && _a !== void 0 ? _a : (await (0, assetResolver_1.resolvePackageAssets)({
+        bcToken: input.bcToken,
+        rigoToken: input.rigoToken,
+        packageSlug: input.packageSlug,
+        learnJson: input.learnJson,
+    }));
+    warnings.push(...resolution.warnings);
+    if (resolution.packageState === "unknown") {
+        return {
+            errors: [
+                packageError(`${(_b = resolution.packageError) !== null && _b !== void 0 ? _b : "Existing assets could not be checked"}; nothing was created or updated to avoid duplicates.`),
+            ],
+            warnings,
+            synced,
+        };
+    }
+    const learnpackId = resolution.learnpackId;
+    if (learnpackId === null) {
+        return {
+            errors: [
+                packageError("Could not resolve Learnpack package id; assets not synced to Breathecode."),
+            ],
+            warnings,
+            synced,
+        };
+    }
+    // Decide every language before touching anything, so all_translations can
+    // name the full set up front (the PUT replaces the relation, it does not add).
+    const langs = (0, assetResolver_1.dedupeLangs)((0, assetResolver_1.getAvailableLangs)(input.learnJson));
+    const plans = [];
+    for (const lang of langs) {
+        const title = (0, exports.getLocalizedValue)((_c = input.learnJson) === null || _c === void 0 ? void 0 : _c.title, lang);
+        if (!title) {
+            plans.push({
+                lang,
+                kind: "skip",
+                detail: `Missing learn.json title for language "${lang}"`,
+            });
+            continue;
+        }
+        const entry = resolution.byLang.get((0, assetResolver_1.canonicalLang)(lang));
+        if (!entry || entry.status === "unknown") {
+            plans.push({
+                lang,
+                kind: "skip",
+                detail: `${(entry === null || entry === void 0 ? void 0 : entry.status) === "unknown" ?
+                    entry.error :
+                    "Existing asset could not be checked"}; nothing was created or updated for this language to avoid duplicates.`,
+            });
+        }
+        else if (entry.status === "ambiguous") {
+            plans.push({
+                lang,
+                kind: "skip",
+                detail: (0, assetResolver_1.describeAmbiguity)(lang, entry.candidates),
+            });
+        }
+        else if (entry.status === "found") {
+            if (entry.asset.ownerId !== null && entry.asset.ownerId !== user.id) {
+                plans.push({
+                    lang,
+                    kind: "skip",
+                    detail: `Asset #${entry.asset.id} ${entry.asset.slug} belongs to another user (owner ${entry.asset.ownerId}); it was not updated and no duplicate was created.`,
+                });
+            }
+            else {
+                plans.push({
+                    lang,
+                    kind: "update",
+                    asset: entry.asset,
+                    slug: entry.asset.slug,
+                });
+            }
+        }
+        else {
+            plans.push({ lang, kind: "create", slug: (0, creatorUtilities_1.buildAssetSlug)(title, lang) });
+        }
+    }
+    const allTranslations = plans
+        .filter(p => p.kind !== "skip")
+        .map(p => p.slug);
+    const rigoToken = input.rigoToken.trim();
+    const createdOrUpdatedIds = [];
+    for (const plan of plans) {
+        if (plan.kind === "skip") {
+            errors.push(langError(plan.lang, plan.detail));
+            continue;
+        }
+        const title = (0, exports.getLocalizedValue)((_d = input.learnJson) === null || _d === void 0 ? void 0 : _d.title, plan.lang);
+        const description = (0, exports.getLocalizedValue)((_e = input.learnJson) === null || _e === void 0 ? void 0 : _e.description, plan.lang);
+        try {
+            if (plan.kind === "update") {
+                // Never send lang or slug: the language of an existing asset is not
+                // ours to change, and a slug would rename it.
+                const updatePayload = {
+                    graded: true,
+                    learnpack_deploy_url: input.deployUrl,
+                    title,
+                    category: "uncategorized",
+                    description,
+                    all_translations: allTranslations,
+                    learnpack_id: learnpackId,
+                };
+                if (plan.asset.academyId === null && input.academyId !== undefined) {
+                    updatePayload.academy_id = input.academyId;
+                }
+                console_1.default.info(`Asset exists for "${plan.lang}" (#${plan.asset.id} ${plan.slug}), updating it`);
+                // eslint-disable-next-line no-await-in-loop
+                const asset = await api_1.default.updateAsset(input.bcToken, plan.asset.id, updatePayload);
+                const id = typeof (asset === null || asset === void 0 ? void 0 : asset.id) === "number" ? asset.id : plan.asset.id;
+                createdOrUpdatedIds.push(id);
+                synced.push({
+                    lang: plan.lang,
+                    action: "updated",
+                    asset: { id, slug: (_f = asset === null || asset === void 0 ? void 0 : asset.slug) !== null && _f !== void 0 ? _f : plan.slug },
+                });
+                continue;
+            }
+            // eslint-disable-next-line no-await-in-loop
+            const readme = await input.readReadme(plan.lang);
+            const assetPayload = {
+                slug: plan.slug,
+                title,
+                lang: plan.lang,
+                graded: true,
+                description,
+                learnpack_deploy_url: input.deployUrl,
+                technologies: [],
+                url: input.deployUrl,
+                category: "uncategorized",
+                owner: user.id,
+                author: user.id,
+                preview: (_g = input.learnJson) === null || _g === void 0 ? void 0 : _g.preview,
+                readme_raw: Buffer.from(readme).toString("base64"),
+                all_translations: allTranslations,
+                learnpack_id: learnpackId,
+            };
+            if (input.academyId !== undefined) {
+                assetPayload.academy_id = input.academyId;
+            }
+            console_1.default.info(`No asset for "${plan.lang}", creating ${plan.slug}`);
+            // eslint-disable-next-line no-await-in-loop
+            const asset = await api_1.default.createAsset(input.bcToken, assetPayload);
+            createdOrUpdatedIds.push(asset.id);
+            synced.push({
+                lang: plan.lang,
+                action: "created",
+                asset: { id: asset.id, slug: (_h = asset.slug) !== null && _h !== void 0 ? _h : plan.slug },
+            });
+            // Record the id right away: a stale Breathecode cache could hide the
+            // new slug from the next publish, but the id never lies.
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                await api_1.default.updateRigoPackage(rigoToken, input.packageSlug, {
+                    asset_id: asset.id,
+                });
+            }
+            catch (error) {
+                warnings.push(`Could not record asset #${asset.id} in the Rigobot package: ${errorDetail(error)}`);
+            }
+        }
+        catch (error) {
+            const errorData = error && typeof error === "object" && "response" in error ?
+                ((_j = error.response) === null || _j === void 0 ? void 0 : _j.data) || error :
+                error;
+            console_1.default.error(`Error syncing asset for language ${plan.lang}:`, error);
+            errors.push(langError(plan.lang, errorDetail(errorData)));
+        }
+    }
+    // Final list: everything Rigobot knew that still exists and is ours, plus
+    // whatever this run touched. Ids that 404 or belong to another package are
+    // the only ones that fall off; duplicates awaiting a manual decision stay.
+    const finalIds = [
+        ...new Set([
+            ...resolution.knownAssetIds,
+            ...resolution.orphanIds,
+            ...createdOrUpdatedIds,
+        ]),
+    ];
+    try {
+        await api_1.default.updateRigoPackage(rigoToken, input.packageSlug, {
+            asset_ids: finalIds,
+        });
+    }
+    catch (error) {
+        warnings.push(`Could not write asset_ids ${JSON.stringify(finalIds)} to the Rigobot package: ${errorDetail(error)}`);
+    }
+    return { errors, warnings, synced };
+}

package/lib/utils/creatorUtilities.d.ts

@@ -27,6 +27,7 @@ export declare function checkReadability(markdown: string, wordsPerMinute?: numb
     fkglResult: TFKGLResult;
 };
 export declare const slugify: (text: string) => string;
+export declare const buildAssetSlug: (title: string, lang: string) => string;
 export declare const getExInfo: (title: string) => {
     exNumber: string;
     kind: string;

package/lib/utils/creatorUtilities.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getReadmeExtension = exports.appendAIRules = exports.appendContentIndex = exports.saveTranslatedReadme = exports.makePackageInfo = exports.getExInfo = exports.slugify = exports.estimateReadingTime = void 0;
+exports.getReadmeExtension = exports.appendAIRules = exports.appendContentIndex = exports.saveTranslatedReadme = exports.makePackageInfo = exports.getExInfo = exports.buildAssetSlug = exports.slugify = exports.estimateReadingTime = void 0;
 exports.checkReadability = checkReadability;
 exports.extractImagesFromMarkdown = extractImagesFromMarkdown;
 exports.getFilenameFromUrl = getFilenameFromUrl;
@@ -98,6 +98,22 @@ const slugify = (text) => {
         .replace(/^-+|-+$/g, ""); // Trim hyphens from start/end
 };
 exports.slugify = slugify;
+// Builds the slug of the Breathecode asset for a given title and language.
+// The backend only accepts letters, numbers, underscores and hyphens, so the
+// periods that slugify() keeps (e.g. "Next.js") are turned into hyphens here.
+// Hyphens are collapsed and trimmed BEFORE the 47-char cut on purpose: for a
+// title without periods this must yield exactly slugify(title).slice(0, 47),
+// which is the slug every existing asset was created with (a trailing hyphen
+// left by the cut is part of that historical slug and is kept).
+const buildAssetSlug = (title, lang) => {
+    const slug = (0, exports.slugify)(title)
+        .replace(/\./g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 47);
+    return `${slug}-${lang}`;
+};
+exports.buildAssetSlug = buildAssetSlug;
 const getExInfo = (title) => {
     // Example title: '1.0 - Introduction to AI [READ: Small introduction to important concepts such as AI, machine learning, and their applications]'
     let [exNumber, exTitle] = title.split(" - ");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@learnpack/learnpack",
   "description": "Seamlessly build, sell and/or take interactive & auto-graded tutorials, start learning now or build a new tutorial to your audience.",
-  "version": "5.0.358",
+  "version": "5.0.360",
   "author": "Alejandro Sanchez @alesanchezr",
   "contributors": [
     {