@learnpack/learnpack 5.0.329 → 5.0.332

package/lib/managers/historyManager.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryManager = void 0;
+const fs = require("fs");
+const path = require("path");
+class HistoryManager {
+    constructor(redisClient) {
+        this.TTL = "432000"; // 5 days in seconds
+        this.LIMIT = 5; // Keep last 5 states
+        this.redis = redisClient;
+        // Load Lua scripts
+        const luaDir = path.join(__dirname, "../lua");
+        this.saveStateLua = fs.readFileSync(path.join(luaDir, "saveState.lua"), "utf8");
+        this.undoLua = fs.readFileSync(path.join(luaDir, "undo.lua"), "utf8");
+        this.redoLua = fs.readFileSync(path.join(luaDir, "redo.lua"), "utf8");
+    }
+    /**
+     * Builds Redis keys for an exercise in a specific language
+     * @param courseSlug - The course slug identifier
+     * @param exerciseSlug - The exercise slug identifier
+     * @param lang - The language code
+     * @returns Object containing undo, redo, and version keys
+     */
+    getKeys(courseSlug, exerciseSlug, lang) {
+        const baseKey = `${courseSlug}:${exerciseSlug}:${lang}`;
+        return {
+            undo: `undo:${baseKey}`,
+            redo: `redo:${baseKey}`,
+            version: `undo:${baseKey}:version`,
+        };
+    }
+    /**
+     * Saves a new state in history
+     * @param courseSlug - The course slug identifier
+     * @param exerciseSlug - The exercise slug identifier
+     * @param lang - The language code
+     * @param content - The content of the state
+     * @param versionId - The version ID
+     * @returns Object containing success, newVersion, and error
+     */
+    async saveState(courseSlug, exerciseSlug, lang, content, versionId) {
+        const keys = this.getKeys(courseSlug, exerciseSlug, lang);
+        const state = {
+            content,
+            timestamp: Date.now(),
+        };
+        const stateJson = JSON.stringify(state);
+        try {
+            // Official Redis client syntax: eval(script, { keys: [...], arguments: [...] })
+            const result = await this.redis.eval(this.saveStateLua, {
+                keys: [keys.undo, keys.redo, keys.version],
+                arguments: [
+                    stateJson,
+                    versionId,
+                    this.TTL.toString(),
+                    this.LIMIT.toString(),
+                ],
+            });
+            // Check if it's an error response (table with err field)
+            if (result && typeof result === "object" && result.err) {
+                return { success: false, error: result.err };
+            }
+            // Success response is a string (the new version)
+            const newVersion = typeof result === "string" ? result : String(result);
+            return { success: true, newVersion };
+        }
+        catch (error) {
+            console.error("⏮️  HISTORY: Error saving state to Redis:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Performs an undo operation
+     * @param courseSlug - The course slug identifier
+     * @param exerciseSlug - The exercise slug identifier
+     * @param lang - The language code
+     * @param currentContent - The current content of the state
+     * @param versionId - The version ID
+     * @returns Object containing success, newVersion, and error
+     */
+    async undo(courseSlug, exerciseSlug, lang, currentContent, versionId) {
+        const keys = this.getKeys(courseSlug, exerciseSlug, lang);
+        const currentState = {
+            content: currentContent,
+            timestamp: Date.now(),
+        };
+        try {
+            const result = await this.redis.eval(this.undoLua, {
+                keys: [keys.undo, keys.redo, keys.version],
+                arguments: [
+                    JSON.stringify(currentState),
+                    versionId,
+                    this.TTL.toString(),
+                ],
+            });
+            // Check if it's an error response (table with err field)
+            if (result && typeof result === "object" && result.err) {
+                return { success: false, error: result.err };
+            }
+            // Success response is an array: [newVersion, previousState]
+            if (!Array.isArray(result) || result.length < 2) {
+                console.error("⏮️  HISTORY: Invalid response from undo script:", result);
+                return { success: false, error: "INVALID_RESPONSE" };
+            }
+            const [newVersion, previousStateJson] = result;
+            if (!previousStateJson) {
+                console.error("⏮️  HISTORY: No state returned from undo script");
+                return { success: false, error: "NO_STATE_RETURNED" };
+            }
+            const previousState = JSON.parse(previousStateJson);
+            return {
+                success: true,
+                newVersion: String(newVersion),
+                content: previousState.content,
+            };
+        }
+        catch (error) {
+            console.error("⏮️  HISTORY: Error performing undo:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Performs a redo operation
+     * @param courseSlug - The course slug identifier
+     * @param exerciseSlug - The exercise slug identifier
+     * @param lang - The language code
+     * @param currentContent - The current content of the state
+     * @param versionId - The version ID
+     * @returns Object containing success, newVersion, and error
+     */
+    async redo(courseSlug, exerciseSlug, lang, currentContent, versionId) {
+        const keys = this.getKeys(courseSlug, exerciseSlug, lang);
+        const currentState = {
+            content: currentContent,
+            timestamp: Date.now(),
+        };
+        try {
+            const result = await this.redis.eval(this.redoLua, {
+                keys: [keys.undo, keys.redo, keys.version],
+                arguments: [
+                    JSON.stringify(currentState),
+                    versionId,
+                    this.TTL.toString(),
+                ],
+            });
+            // Check if it's an error response (table with err field)
+            if (result && typeof result === "object" && result.err) {
+                return { success: false, error: result.err };
+            }
+            // Success response is an array: [newVersion, futureState]
+            if (!Array.isArray(result) || result.length < 2) {
+                console.error("⏮️  HISTORY: Invalid response from redo script:", result);
+                return { success: false, error: "INVALID_RESPONSE" };
+            }
+            const [newVersion, futureStateJson] = result;
+            if (!futureStateJson) {
+                console.error("⏮️  HISTORY: No state returned from redo script");
+                return { success: false, error: "NO_STATE_RETURNED" };
+            }
+            const futureState = JSON.parse(futureStateJson);
+            return {
+                success: true,
+                newVersion: String(newVersion),
+                content: futureState.content,
+            };
+        }
+        catch (error) {
+            console.error("⏮️  HISTORY: Error performing redo:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Gets the history status (can undo/redo, current version)
+     * @param courseSlug - The course slug identifier
+     * @param exerciseSlug - The exercise slug identifier
+     * @param lang - The language code
+     * @returns Object containing canUndo, canRedo, and version
+     */
+    async getHistoryStatus(courseSlug, exerciseSlug, lang) {
+        const keys = this.getKeys(courseSlug, exerciseSlug, lang);
+        try {
+            const [undoLen, redoLen, version] = await Promise.all([
+                this.redis.lLen(keys.undo),
+                this.redis.lLen(keys.redo),
+                this.redis.get(keys.version),
+            ]);
+            return {
+                canUndo: undoLen >= 1, // Need at least 1 (we save state BEFORE changes)
+                canRedo: redoLen > 0,
+                version: version || "0",
+            };
+        }
+        catch (error) {
+            console.error("⏮️  HISTORY: Error getting history status:", error);
+            return {
+                canUndo: false,
+                canRedo: false,
+                version: "0",
+            };
+        }
+    }
+}
+exports.HistoryManager = HistoryManager;

package/lib/managers/readmeHistoryService.d.ts

@@ -0,0 +1,76 @@
+import type { Bucket } from "@google-cloud/storage";
+import type { HistoryManager } from "./historyManager";
+export interface SaveReadmeWithHistoryOptions {
+    courseSlug: string;
+    exerciseSlug: string;
+    lang: string;
+    fileName: string;
+    newContent: string;
+    previousContent?: string;
+    currentVersion?: string;
+    throwOnConflict?: boolean;
+}
+export interface SaveReadmeResult {
+    success: boolean;
+    newVersion: string;
+    error?: string;
+}
+/**
+ * Service to handle README file updates with automatic history tracking
+ * Encapsulates the logic of saving state to history before updating files
+ */
+export declare class ReadmeHistoryService {
+    private historyManager;
+    private bucket;
+    /**
+     * Constructor for the ReadmeHistoryService
+     * @param historyManager - The history manager to use
+     * @param bucket - The bucket to use
+     */
+    constructor(historyManager: HistoryManager | null, bucket: Bucket);
+    /**
+     * Saves a README file to GCS with automatic history tracking
+     *
+     * Workflow:
+     * 1. If previousContent is not provided, downloads it from GCS
+     * 2. If currentVersion is not provided, gets it from history
+     * 3. Saves the PREVIOUS state to history (for undo)
+     * 4. Saves the NEW content to GCS
+     *
+     * @param options - Options for the saveReadmeWithHistory method
+     * @returns Result with success status and new version
+     */
+    saveReadmeWithHistory(options: SaveReadmeWithHistoryOptions): Promise<SaveReadmeResult>;
+    /**
+     * Gets the previous content of a README from GCS
+     * Returns undefined if file doesn't exist (first version)
+     * @param courseSlug - The slug of the course
+     * @param exerciseSlug - The slug of the exercise
+     * @param fileName - The name of the file
+     * @returns The previous content of the file or undefined if it doesn't exist
+     */
+    private getPreviousContent;
+    /**
+     * Gets the current version from history
+     * @param courseSlug - The slug of the course
+     * @param exerciseSlug - The slug of the exercise
+     * @param lang - The language of the file
+     * @returns The current version of the file
+     */
+    private getCurrentVersion;
+    /**
+     * Saves content to Google Cloud Storage
+     * @param courseSlug - The slug of the course
+     * @param exerciseSlug - The slug of the exercise
+     * @param fileName - The name of the file
+     * @param content - The content to save
+     * @returns void
+     */
+    private saveToGCS;
+    /**
+     * Helper to get README extension from language code
+     * @param lang - The language of the file
+     * @returns The name of the README file
+     */
+    static getReadmeFileName(lang: string): string;
+}

package/lib/managers/readmeHistoryService.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadmeHistoryService = void 0;
+/**
+ * Service to handle README file updates with automatic history tracking
+ * Encapsulates the logic of saving state to history before updating files
+ */
+class ReadmeHistoryService {
+    /**
+     * Constructor for the ReadmeHistoryService
+     * @param historyManager - The history manager to use
+     * @param bucket - The bucket to use
+     */
+    constructor(historyManager, bucket) {
+        this.historyManager = historyManager;
+        this.bucket = bucket;
+    }
+    /**
+     * Saves a README file to GCS with automatic history tracking
+     *
+     * Workflow:
+     * 1. If previousContent is not provided, downloads it from GCS
+     * 2. If currentVersion is not provided, gets it from history
+     * 3. Saves the PREVIOUS state to history (for undo)
+     * 4. Saves the NEW content to GCS
+     *
+     * @param options - Options for the saveReadmeWithHistory method
+     * @returns Result with success status and new version
+     */
+    async saveReadmeWithHistory(options) {
+        const { courseSlug, exerciseSlug, lang, fileName, newContent, previousContent: providedPreviousContent, currentVersion: providedVersion, throwOnConflict = false, } = options;
+        // Guard: Only process README files
+        if (!fileName.startsWith("README")) {
+            console.warn(`⚠️ ReadmeHistoryService called for non-README file: ${fileName}`);
+            return { success: false, newVersion: "0", error: "NOT_README_FILE" };
+        }
+        // Guard: History manager not available
+        if (!this.historyManager) {
+            console.warn("⚠️ History manager not available, skipping history");
+            // Still save the file without history
+            await this.saveToGCS(courseSlug, exerciseSlug, fileName, newContent);
+            return {
+                success: false,
+                newVersion: "0",
+                error: "HISTORY_NOT_AVAILABLE",
+            };
+        }
+        try {
+            // Step 1: Get previous content if not provided
+            const previousContent = providedPreviousContent !== null && providedPreviousContent !== void 0 ? providedPreviousContent : (await this.getPreviousContent(courseSlug, exerciseSlug, fileName));
+            // If there's no previous content, we can't save to history
+            // (this is the first version of the file)
+            if (!previousContent) {
+                console.log(`📝 HISTORY: First version of ${fileName} for ${lang}, skipping history`);
+                await this.saveToGCS(courseSlug, exerciseSlug, fileName, newContent);
+                return {
+                    success: false,
+                    newVersion: "0",
+                    error: "NO_PREVIOUS_CONTENT",
+                };
+            }
+            // Step 2: Get current version if not provided
+            const currentVersion = providedVersion !== null && providedVersion !== void 0 ? providedVersion : (await this.getCurrentVersion(courseSlug, exerciseSlug, lang));
+            // Step 3: Save to history BEFORE updating the file
+            const historyResult = await this.historyManager.saveState(courseSlug, exerciseSlug, lang, previousContent, // Save the content BEFORE the change
+            currentVersion);
+            // Step 4: Handle history save result
+            if (!historyResult.success) {
+                // VERSION_CONFLICT: Another user/process modified the file
+                if (historyResult.error === "VERSION_CONFLICT") {
+                    const message = "Version conflict detected. Content may have been modified by another process.";
+                    if (throwOnConflict) {
+                        throw new Error(message);
+                    }
+                    else {
+                        console.error(`⏮️  HISTORY: ${message}`);
+                        // Still save the file despite conflict
+                        await this.saveToGCS(courseSlug, exerciseSlug, fileName, newContent);
+                        return {
+                            success: false,
+                            newVersion: currentVersion,
+                            error: "VERSION_CONFLICT",
+                        };
+                    }
+                }
+                // Other errors: log but don't fail
+                console.error(`⏮️  HISTORY: Failed to save history (non-critical): ${historyResult.error}`);
+                await this.saveToGCS(courseSlug, exerciseSlug, fileName, newContent);
+                return {
+                    success: false,
+                    newVersion: currentVersion,
+                    error: historyResult.error,
+                };
+            }
+            // Step 5: History saved successfully, now save the new content
+            await this.saveToGCS(courseSlug, exerciseSlug, fileName, newContent);
+            console.log(`✅ HISTORY: Saved ${fileName} (${lang}) - version ${historyResult.newVersion}`);
+            return {
+                success: true,
+                newVersion: historyResult.newVersion,
+            };
+        }
+        catch (error) {
+            const errorMessage = error.message || "Unknown error";
+            console.error(`❌ HISTORY: Error in saveReadmeWithHistory: ${errorMessage}`);
+            // Try to save the file anyway (best effort)
+            try {
+                await this.saveToGCS(courseSlug, exerciseSlug, fileName, newContent);
+            }
+            catch (saveError) {
+                console.error("❌ Failed to save file after history error:", saveError);
+            }
+            return {
+                success: false,
+                newVersion: "0",
+                error: errorMessage,
+            };
+        }
+    }
+    /**
+     * Gets the previous content of a README from GCS
+     * Returns undefined if file doesn't exist (first version)
+     * @param courseSlug - The slug of the course
+     * @param exerciseSlug - The slug of the exercise
+     * @param fileName - The name of the file
+     * @returns The previous content of the file or undefined if it doesn't exist
+     */
+    async getPreviousContent(courseSlug, exerciseSlug, fileName) {
+        try {
+            const filePath = `courses/${courseSlug}/exercises/${exerciseSlug}/${fileName}`;
+            const [content] = await this.bucket.file(filePath).download();
+            return content.toString();
+        }
+        catch (error) {
+            // File doesn't exist (404) - this is normal for first save
+            if (error.code === 404) {
+                return undefined;
+            }
+            console.error(`⚠️ Error downloading previous content: ${error.message}`);
+            return undefined;
+        }
+    }
+    /**
+     * Gets the current version from history
+     * @param courseSlug - The slug of the course
+     * @param exerciseSlug - The slug of the exercise
+     * @param lang - The language of the file
+     * @returns The current version of the file
+     */
+    async getCurrentVersion(courseSlug, exerciseSlug, lang) {
+        if (!this.historyManager) {
+            return "0";
+        }
+        try {
+            const status = await this.historyManager.getHistoryStatus(courseSlug, exerciseSlug, lang);
+            return status.version;
+        }
+        catch (error) {
+            console.error("⚠️ Error getting current version, defaulting to '0':", error);
+            return "0";
+        }
+    }
+    /**
+     * Saves content to Google Cloud Storage
+     * @param courseSlug - The slug of the course
+     * @param exerciseSlug - The slug of the exercise
+     * @param fileName - The name of the file
+     * @param content - The content to save
+     * @returns void
+     */
+    async saveToGCS(courseSlug, exerciseSlug, fileName, content) {
+        const filePath = `courses/${courseSlug}/exercises/${exerciseSlug}/${fileName}`;
+        const file = this.bucket.file(filePath);
+        await file.save(content, {
+            resumable: false,
+        });
+    }
+    /**
+     * Helper to get README extension from language code
+     * @param lang - The language of the file
+     * @returns The name of the README file
+     */
+    static getReadmeFileName(lang) {
+        if (lang === "en") {
+            return "README.md";
+        }
+        // es -> README.es.md, fr -> README.fr.md
+        return `README.${lang}.md`;
+    }
+}
+exports.ReadmeHistoryService = ReadmeHistoryService;

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.329",
+  "version": "5.0.332",
   "author": "Alejandro Sanchez @alesanchezr",
   "contributors": [
     {
@@ -62,6 +62,7 @@
     "node-persist": "^3.1.0",
     "ora": "^8.2.0",
     "prompts": "^2.3.2",
+    "redis": "^5.10.0",
     "rimraf": "^6.0.1",
     "shelljs": "^0.8.4",
     "socket.io": "^4.4.1",

package/src/commands/publish.ts

@@ -19,10 +19,41 @@ 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 { slugify } from "../utils/creatorUtilities"
+import { getReadmeExtension, slugify } from "../utils/creatorUtilities"
 
 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 : ""
+}
+
 export const handleAssetCreation = async (
   sessionPayload: { token: string; rigobotToken: string },
   learnJson: any,
@@ -36,7 +67,19 @@ export const handleAssetCreation = async (
   try {
     const user = await api.validateToken(sessionPayload.token)
 
-    let slug = slugify(learnJson.title[selectedLang]).slice(0, 47)
+    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}`
 
     const { exists } = await api.doesAssetExists(sessionPayload.token, slug)
@@ -45,10 +88,10 @@ export const handleAssetCreation = async (
       Console.info("Asset does not exist in this academy, creating it")
       const asset = await api.createAsset(sessionPayload.token, {
         slug: slug,
-        title: learnJson.title[selectedLang],
+        title: assetTitle,
         lang: selectedLang,
         graded: true,
-        description: learnJson.description[selectedLang],
+        description: assetDescription,
         learnpack_deploy_url: learnpackDeployUrl,
         technologies: learnJson.technologies.map((tech: string) =>
           tech.toLowerCase().replace(/\s+/g, "-")
@@ -81,9 +124,9 @@ export const handleAssetCreation = async (
     const asset = await api.updateAsset(sessionPayload.token, slug, {
       graded: true,
       learnpack_deploy_url: learnpackDeployUrl,
-      title: learnJson.title[selectedLang],
+      title: assetTitle,
       category: category,
-      description: learnJson.description[selectedLang],
+      description: assetDescription,
       all_translations,
     })
     try {
@@ -106,6 +149,58 @@ export const handleAssetCreation = async (
   }
 }
 
+const createMultiLangAssetFromDisk = async (
+  sessionPayload: { token: string; rigobotToken: string },
+  learnJson: any,
+  deployUrl: string
+) => {
+  const availableLangs = getAvailableLangs(learnJson)
+
+  if (availableLangs.length === 0) {
+    Console.error(
+      "No languages found in learn.json.title. Add at least one language (e.g. title.en)."
+    )
+    return
+  }
+
+  const all_translations: string[] = []
+  for (const lang of availableLangs) {
+    const readmePath = path.join(
+      process.cwd(),
+      `README${getReadmeExtension(lang)}`
+    )
+
+    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")
+
+    // eslint-disable-next-line no-await-in-loop
+    const asset = await handleAssetCreation(
+      sessionPayload,
+      learnJson,
+      lang,
+      deployUrl,
+      b64IndexReadme,
+      all_translations
+    )
+
+    if (!asset) {
+      Console.debug("Could not create/update asset for lang", lang)
+      continue
+    }
+
+    all_translations.push(asset.slug)
+  }
+}
+
 const runAudit = (strict: boolean) => {
   try {
     Console.info("Running learnpack audit before publishing...")
@@ -362,9 +457,13 @@ class BuildCommand extends SessionCommand {
     if (fs.existsSync(indexHtmlPath)) {
       let indexHtmlContent = fs.readFileSync(indexHtmlPath, "utf-8")
 
-      const description = learnJson.description.en || "LearnPack is awesome!"
+      const selectedLang = getDefaultLang(learnJson)
+      const description =
+        getLocalizedValue(learnJson?.description, selectedLang) ||
+        "LearnPack is awesome!"
       const title =
-        learnJson.title.en || "LearnPack: Interactive Learning as a Service"
+        getLocalizedValue(learnJson?.title, selectedLang) ||
+        "LearnPack: Interactive Learning as a Service"
 
       const previewUrl =
         learnJson.preview ||
@@ -386,9 +485,15 @@ class BuildCommand extends SessionCommand {
 
     if (fs.existsSync(manifestPWA)) {
       let manifestPWAContent = fs.readFileSync(manifestPWA, "utf-8")
+      const selectedLang = getDefaultLang(learnJson)
+      const courseTitle =
+        getLocalizedValue(learnJson?.title, selectedLang) ||
+        getLocalizedValue(learnJson?.title, "us") ||
+        getLocalizedValue(learnJson?.title, "en") ||
+        "LearnPack"
       manifestPWAContent = manifestPWAContent.replace(
         "{{course_title}}",
-        learnJson.title.us
+        courseTitle
       )
 
       const courseShortName = { answer: "testing-tutorial" }
@@ -454,13 +559,10 @@ class BuildCommand extends SessionCommand {
         fs.unlinkSync(zipFilePath)
         this.removeDirectory(buildDir)
 
-        await handleAssetCreation(
-          sessionPayload,
+        await createMultiLangAssetFromDisk(
+          { token: sessionPayload.token, rigobotToken: rigoToken },
           learnJson,
-          "en",
-          res.data.url,
-          "",
-          []
+          res.data.url
         )
       } catch (error) {
         if (axios.isAxiosError(error)) {