@learnpack/learnpack 5.0.329 → 5.0.331

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.331",
   "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",