@learnpack/learnpack 5.0.320 → 5.0.323

package/lib/utils/errorHandler.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createError = exports.errorHandler = exports.notFoundHandler = exports.asyncHandler = exports.InternalServerError = exports.ConflictError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.ValidationError = exports.OperationalError = void 0;
+/**
+ * Base class for operational errors (expected errors)
+ */
+class OperationalError extends Error {
+    constructor(message, details, statusCode = 500, code = "OPERATIONAL_ERROR") {
+        super(message);
+        this.name = this.constructor.name;
+        this.statusCode = statusCode;
+        this.code = code;
+        this.isOperational = true;
+        this.details = details;
+        // Maintains correct stack trace
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.OperationalError = OperationalError;
+/**
+ * Validation error (400)
+ */
+class ValidationError extends OperationalError {
+    constructor(message, details) {
+        super(message, details, 400, "VALIDATION_ERROR");
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Authentication error (401)
+ */
+class UnauthorizedError extends OperationalError {
+    constructor(message, details) {
+        super(message, details, 401, "UNAUTHORIZED");
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+/**
+ * Authorization error (403)
+ */
+class ForbiddenError extends OperationalError {
+    constructor(message, details) {
+        super(message, details, 403, "FORBIDDEN");
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+/**
+ * Resource not found error (404)
+ */
+class NotFoundError extends OperationalError {
+    constructor(message, details) {
+        super(message, details, 404, "NOT_FOUND");
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * Conflict error (409)
+ */
+class ConflictError extends OperationalError {
+    constructor(message, details) {
+        super(message, details, 409, "CONFLICT");
+    }
+}
+exports.ConflictError = ConflictError;
+/**
+ * Internal server error (500)
+ */
+class InternalServerError extends OperationalError {
+    constructor(message, details) {
+        super(message, details, 500, "INTERNAL_SERVER_ERROR");
+    }
+}
+exports.InternalServerError = InternalServerError;
+/**
+ * Determines if an error is operational (expected) or programming (unexpected)
+ * @param error - The error to check
+ * @returns true if the error is operational, false otherwise
+ */
+function isOperationalError(error) {
+    if (error instanceof OperationalError) {
+        return error.isOperational === true;
+    }
+    return false;
+}
+/**
+ * Formats the error for HTTP response
+ * @param error - The error to format
+ * @param isDevelopment - Whether in development mode
+ * @returns Object with the formatted response
+ */
+function formatError(error, isDevelopment = false) {
+    const isOperational = isOperationalError(error);
+    const appError = error;
+    const baseResponse = {
+        status: "error",
+        message: appError.message || "An unexpected error occurred",
+        code: appError.code || "INTERNAL_ERROR",
+    };
+    // In development, include more details
+    if (isDevelopment) {
+        baseResponse.stack = appError.stack;
+        baseResponse.details = appError.details;
+    }
+    // If it's an operational error, include details if they exist
+    if (isOperational && appError.details) {
+        baseResponse.details = appError.details;
+    }
+    // If not operational, don't expose details in production
+    if (!isOperational && !isDevelopment) {
+        baseResponse.message = "An unexpected error occurred";
+        baseResponse.code = "INTERNAL_ERROR";
+    }
+    return baseResponse;
+}
+/**
+ * Determines the appropriate HTTP status code
+ * @param error - The error from which to get the status code
+ * @returns The HTTP status code
+ */
+function getStatusCode(error) {
+    if (error.statusCode) {
+        return error.statusCode;
+    }
+    // Common Node.js errors
+    if (error.name === "ValidationError")
+        return 400;
+    if (error.name === "UnauthorizedError")
+        return 401;
+    if (error.name === "ForbiddenError")
+        return 403;
+    if (error.name === "NotFoundError")
+        return 404;
+    if (error.name === "ConflictError")
+        return 409;
+    // Default to server error
+    return 500;
+}
+/**
+ * Logs the error in a structured format
+ * @param error - The error to log
+ * @param req - Express Request object
+ * @returns void
+ */
+function logError(error, req) {
+    const appError = error;
+    const isOperational = isOperationalError(error);
+    const logData = {
+        timestamp: new Date().toISOString(),
+        method: req.method,
+        url: req.originalUrl,
+        statusCode: getStatusCode(error),
+        error: {
+            name: error.name,
+            message: error.message,
+            code: appError.code,
+            isOperational,
+            stack: error.stack,
+            details: appError.details,
+        },
+        ip: req.ip || req.socket.remoteAddress,
+        userAgent: req.get("user-agent"),
+    };
+    // Different log based on error type
+    if (isOperational) {
+        console.error("⚠️  Operational Error:", JSON.stringify(logData, null, 2));
+    }
+    else {
+        console.error("❌ Unexpected Error:", JSON.stringify(logData, null, 2));
+    }
+}
+/**
+ * Wrapper for async handlers that automatically catches errors
+ *
+ * Usage:
+ * app.get('/route', asyncHandler(async (req, res) => {
+ *   // your async code here
+ * }))
+ * @param fn - Async handler function to wrap
+ * @returns Express middleware that automatically catches errors
+ */
+const asyncHandler = (fn) => {
+    return (req, res, next) => {
+        Promise.resolve(fn(req, res, next)).catch(next);
+    };
+};
+exports.asyncHandler = asyncHandler;
+/**
+ * Middleware to handle not found routes (404)
+ * Must be placed after all routes but before the error handler
+ * @param req - Express Request object
+ * @param res - Express Response object
+ * @param next - Express next function
+ * @returns void
+ */
+const notFoundHandler = (req, res, next) => {
+    const error = new NotFoundError(`Route ${req.method} ${req.originalUrl} not found`);
+    next(error);
+};
+exports.notFoundHandler = notFoundHandler;
+/**
+ * Global error handling middleware
+ * Must be the last middleware in the chain
+ *
+ * Catches all unhandled synchronous and asynchronous errors
+ * @param error - The caught error
+ * @param req - Express Request object
+ * @param res - Express Response object
+ * @param next - Express next function
+ * @returns void
+ */
+const errorHandler = (error, req, res, next) => {
+    // If response already sent, delegate to Express default handler
+    if (res.headersSent) {
+        return next(error);
+    }
+    // Determine if we're in development mode
+    const isDevelopment = process.env.NODE_ENV === "development" || process.env.DEBUG === "true";
+    // Log the error
+    logError(error, req);
+    // Get status code
+    const statusCode = getStatusCode(error);
+    // Format response
+    const response = formatError(error, isDevelopment);
+    // Send response
+    res.status(statusCode).json(response);
+};
+exports.errorHandler = errorHandler;
+/**
+ * Helper to quickly create operational errors
+ * @param message - Error message
+ * @param details - Additional error details
+ * @param statusCode - HTTP status code
+ * @param code - Custom error code
+ * @returns New OperationalError instance
+ */
+const createError = (message, details, statusCode, code) => {
+    return new OperationalError(message, details, statusCode || 500, code || "OPERATIONAL_ERROR");
+};
+exports.createError = createError;

package/lib/utils/rigoActions.d.ts

@@ -95,6 +95,8 @@ type TInitialContentGeneratorInputs = {
     output_language: string;
     current_syllabus: string;
     lesson_description: string;
+    target_word_count: string;
+    topic_description?: string;
 };
 export declare const initialContentGenerator: (token: string, inputs: TInitialContentGeneratorInputs, webhookUrl?: string, endpointSlug?: string) => Promise<any>;
 type TAddInteractivityInputs = {

package/lib/utils/rigoActions.js

@@ -327,7 +327,7 @@ const addInteractivity = async (token, inputs, webhookUrl) => {
 exports.addInteractivity = addInteractivity;
 const generateCodeChallenge = async (token, inputs, webhookUrl) => {
     try {
-        const response = await axios_1.default.post(`${api_1.RIGOBOT_HOST}/v1/prompting/completion/generate-code-challenge-files/`, {
+        const response = await axios_1.default.post(`${api_1.RIGOBOT_HOST}/v1/prompting/completion/create-structured-coding-filles/`, {
             inputs,
             include_purpose_objective: false,
             execute_async: !!webhookUrl,

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.320",
+  "version": "5.0.323",
   "author": "Alejandro Sanchez @alesanchezr",
   "contributors": [
     {