@learnpack/learnpack 5.0.320 → 5.0.323

package/lib/commands/serve.js

@@ -32,6 +32,7 @@ const creatorUtilities_2 = require("../utils/creatorUtilities");
 const sidebarGenerator_1 = require("../utils/sidebarGenerator");
 const publish_1 = require("./publish");
 const export_1 = require("../utils/export");
+const errorHandler_1 = require("../utils/errorHandler");
 const frontMatter = require("front-matter");
 if (process.env.NEW_RELIC_ENABLED === "true") {
     require("newrelic");
@@ -182,15 +183,36 @@ const lessonCleaner = (lesson) => {
     return Object.assign(Object.assign({}, lesson), { duration: undefined, generated: undefined, status: undefined, translations: undefined, uid: undefined, initialContent: undefined, locked: undefined });
 };
 async function startInitialContentGeneration(rigoToken, steps, packageContext, exercise, courseSlug, purposeSlug, lastLesson = "") {
+    // Defensive validation
+    if (!exercise) {
+        throw new errorHandler_1.ValidationError("Exercise is required but was not provided");
+    }
+    console.log("EXERCISE", exercise);
+    if (!exercise.id || !exercise.title) {
+        throw new errorHandler_1.ValidationError(`Exercise is missing required properties: id=${exercise.id}, title=${exercise.title}`);
+    }
     const exSlug = (0, creatorUtilities_2.slugify)(exercise.id + "-" + exercise.title);
     console.log("Starting initial content generation for", exSlug);
     const webhookUrl = `${process.env.HOST}/webhooks/${courseSlug}/initial-content-processor/${exercise.uid}/${rigoToken}`;
-    // Determine if this is the first lesson
     const exerciseIndex = steps.findIndex(lesson => lesson.uid === exercise.uid);
     const isFirstLesson = exerciseIndex === 0;
-    const endpointSlug = isFirstLesson ?
-        "initial-step-content-generator" :
-        "generate-step-initial-content";
+    const isLastLesson = exerciseIndex === steps.length - 1;
+    let endpointSlug;
+    let passTopicDescription = false;
+    if (isFirstLesson) {
+        endpointSlug = "generate-learnpack-intro-content";
+    }
+    else if (isLastLesson) {
+        endpointSlug = "generate-learnpack-outro-content";
+    }
+    else if (exercise.id.endsWith(".0")) {
+        passTopicDescription = true;
+        endpointSlug = "generate-learnpack-topic-intro-content";
+    }
+    else {
+        passTopicDescription = true;
+        endpointSlug = "generate-learnpack-subtopic-content";
+    }
     // Emit notification that initial content generation is starting
     (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
         lesson: exSlug,
@@ -204,12 +226,16 @@ async function startInitialContentGeneration(rigoToken, steps, packageContext, e
     // Add random 6-digit number to avoid cache issues
     // eslint-disable-next-line no-mixed-operators
     const randomCacheEvict = Math.floor(100000 + Math.random() * 900000);
-    const res = await (0, rigoActions_1.initialContentGenerator)(rigoToken.trim(), {
-        // prev_lesson: lastLesson,
+    const inputs = {
         output_language: packageContext.language || "en",
         current_syllabus: JSON.stringify(fullSyllabus),
         lesson_description: JSON.stringify(lessonCleaner(exercise)) + `-${randomCacheEvict}`,
-    }, webhookUrl, endpointSlug);
+        target_word_count: String(PARAMS.max_words),
+        topic_description: passTopicDescription ?
+            String(exercise.description) :
+            undefined,
+    };
+    const res = await (0, rigoActions_1.initialContentGenerator)(rigoToken.trim(), inputs, webhookUrl, endpointSlug);
     console.log("INITIAL CONTENT GENERATOR RES", res);
     return res.id;
 }
@@ -649,9 +675,8 @@ class ServeCommand extends SessionCommand_1.default {
                             return res.status(404).json({ error: "Exercise not found" });
                         }
                         const exerciseDir = `courses/${courseSlug}/exercises/${exercise.slug}`;
-                        for (const fileStr of files) {
+                        for (const fileObj of files) {
                             try {
-                                const fileObj = JSON.parse(fileStr);
                                 console.log(`📄 Processing file: ${fileObj.name}`);
                                 // Save the main file with content
                                 if (fileObj.name && fileObj.content) {
@@ -696,7 +721,7 @@ class ServeCommand extends SessionCommand_1.default {
                 res.status(500).json({ error: error.message });
             }
         });
-        app.post("/actions/continue-generating/:courseSlug/:lessonUid", async (req, res) => {
+        app.post("/actions/continue-generating/:courseSlug/:lessonUid", (0, errorHandler_1.asyncHandler)(async (req, res) => {
             const { courseSlug, lessonUid } = req.params;
             const { feedback, mode } = req.body;
             const rigoToken = req.header("x-rigo-token");
@@ -706,13 +731,23 @@ class ServeCommand extends SessionCommand_1.default {
             // console.log("FEEDBACK", feedback);
             // console.log("MODE", mode);
             if (!rigoToken) {
-                return res.status(400).json({
-                    error: "Rigo token is required. x-rigo-token header is missing",
-                });
+                throw new errorHandler_1.ValidationError("Rigo token is required. x-rigo-token header is missing");
             }
             const syllabus = await getSyllabus(courseSlug, bucket);
             const exercise = syllabus.lessons.find(lesson => lesson.uid === lessonUid);
             const exerciseIndex = syllabus.lessons.findIndex(lesson => lesson.uid === lessonUid);
+            // Validate that exercise exists
+            if (!exercise) {
+                throw new errorHandler_1.NotFoundError(`Lesson with UID "${lessonUid}" not found in course "${courseSlug}"`);
+            }
+            // Validate that exercise index is valid (defensive check)
+            if (exerciseIndex === -1) {
+                throw new errorHandler_1.NotFoundError(`Lesson with UID "${lessonUid}" not found in course "${courseSlug}"`);
+            }
+            // Validate that exercise has required properties
+            if (!exercise.id || !exercise.title) {
+                throw new errorHandler_1.ValidationError(`Lesson "${lessonUid}" is missing required properties (id or title)`);
+            }
             // previous exercise
             let previousReadme = "---";
             const previousExercise = syllabus.lessons[exerciseIndex - 1];
@@ -753,7 +788,7 @@ class ServeCommand extends SessionCommand_1.default {
             syllabus.generationMode = mode;
             await saveSyllabus(courseSlug, syllabus, bucket);
             res.json({ status: "SUCCESS" });
-        });
+        }));
         // TODO: Check if this command is being used
         app.post("/actions/generate-image/:courseSlug", async (req, res) => {
             const rigoToken = req.header("x-rigo-token");
@@ -1255,6 +1290,12 @@ class ServeCommand extends SessionCommand_1.default {
             console.log("RECEIVING TRANSLATION WEBHOOK", body);
             const readmePath = `courses/${courseSlug}/exercises/${exSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(body.parsed.output_language_code)}`;
             await uploadFileToBucket(bucket, body.parsed.translation, readmePath);
+            (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-completed", {
+                exercise: exSlug,
+                language: body.parsed.output_language_code,
+                status: "completed",
+                message: `Translation completed for ${exSlug} to ${body.parsed.output_language_code}`,
+            });
             res.json({ status: "SUCCESS" });
         });
         app.get("/check-preview-image/:slug", async (req, res) => {
@@ -1383,22 +1424,49 @@ class ServeCommand extends SessionCommand_1.default {
             res.set("Content-Disposition", `attachment; filename="${file}"`);
             fileStream.pipe(res);
         });
-        app.put("/exercise/:slug/file/:fileName", express.text(), async (req, res) => {
+        app.put("/exercise/:slug/file/:fileName", express.text(), (0, errorHandler_1.asyncHandler)(async (req, res) => {
+            var _a, _b;
             const { slug, fileName } = req.params;
             const query = req.query;
-            console.log(`PUT /exercise/${slug}/file/${fileName}`);
             const courseSlug = query.slug;
-            // console.log("COURSE SLUG", courseSlug)
-            // Update the file in the bucket
-            const file = await bucket.file(`courses/${courseSlug}/exercises/${slug}/${fileName}`);
-            await file.save(req.body);
-            const created = await file.exists();
-            // console.log("File updated", created)
-            res.send({
-                message: "File updated",
-                created,
-            });
-        });
+            console.log(`PUT /exercise/${slug}/file/${fileName}`);
+            // Validate required parameters
+            if (!courseSlug) {
+                throw new errorHandler_1.ValidationError("Course slug is required in query parameters");
+            }
+            if (!fileName || !slug) {
+                throw new errorHandler_1.ValidationError("File name and exercise slug are required");
+            }
+            try {
+                // Update the file in the bucket
+                const file = bucket.file(`courses/${courseSlug}/exercises/${slug}/${fileName}`);
+                await file.save(req.body, {
+                    resumable: false,
+                });
+                const created = await file.exists();
+                res.send({
+                    message: "File updated",
+                    created,
+                });
+            }
+            catch (error) {
+                // Handle Google Cloud Storage rate limit errors (429)
+                if (error.code === 429 ||
+                    ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes("rate limit")) ||
+                    ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes("rateLimitExceeded"))) {
+                    throw new errorHandler_1.ConflictError("Storage rate limit exceeded. Please try again in a few moments.", {
+                        code: "STORAGE_RATE_LIMIT",
+                        retryAfter: 60, // seconds
+                    });
+                }
+                // Handle other GCS errors
+                if (error.code) {
+                    throw new errorHandler_1.InternalServerError(`Storage error: ${error.message || "Failed to update file"}`, { code: error.code });
+                }
+                // Re-throw if it's already an operational error
+                throw error;
+            }
+        }));
         // Create a new step for a course
         app.post("/course/:slug/create-step", async (req, res) => {
             console.log("POST /course/:slug/create-step");
@@ -1469,35 +1537,40 @@ class ServeCommand extends SessionCommand_1.default {
             }
             res.send({ message: "Files renamed" });
         });
-        app.post("/actions/translate", express.json(), async (req, res) => {
-            console.log("POST /actions/translate");
-            const { exerciseSlugs, languages, rigoToken, currentLanguage } = req.body;
-            const query = req.query;
-            const courseSlug = query.slug;
-            if (!rigoToken) {
-                return res.status(400).json({ error: "RigoToken not found" });
-            }
-            const languagesToTranslate = languages.split(",");
-            const languageCodesRes = await (0, rigoActions_1.getLanguageCodes)(rigoToken, {
-                raw_languages: languagesToTranslate.join(","),
-            });
-            const languageCodes = languageCodesRes.parsed.language_codes;
+        async function processTranslationsAsync(courseSlug, exerciseSlugs, languageCodes, rigoToken, currentLanguage, bucket) {
             try {
+                (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-started", {
+                    languages: languageCodes,
+                    exercises: exerciseSlugs,
+                    status: "started",
+                    message: "Translation process started",
+                });
                 await Promise.all(exerciseSlugs.map(async (slug) => {
                     const readmePath = `courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(currentLanguage)}`;
                     const readme = await bucket.file(readmePath).download();
                     await Promise.all(languageCodes.map(async (language) => {
-                        // verify if the translation already exists
                         const translationPath = `courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(language)}`;
                         const [exists] = await bucket.file(translationPath).exists();
                         if (exists) {
                             console.log(`Translation in ${language} already exists for exercise ${slug}`);
+                            (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-progress", {
+                                exercise: slug,
+                                language: language,
+                                status: "skipped",
+                                message: `Translation in ${language} already exists`,
+                            });
                             return;
                         }
                         await (0, rigoActions_1.translateExercise)(rigoToken, {
                             text_to_translate: readme.toString(),
                             output_language: language,
                         }, `${process.env.HOST}/webhooks/${courseSlug}/${slug}/save-translation`);
+                        (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-progress", {
+                            exercise: slug,
+                            language: language,
+                            status: "initiated",
+                            message: `Translation job initiated for ${slug} to ${language}`,
+                        });
                     }));
                 }));
                 const course = await bucket
@@ -1527,7 +1600,6 @@ class ServeCommand extends SessionCommand_1.default {
                     await uploadFileToBucket(bucket, JSON.stringify(courseJson), `courses/${courseSlug}/learn.json`);
                     currentLanguages = Object.keys(courseJson.title);
                 }
-                // Check that all the READMEs exists
                 const missingReadmeTranslations = [];
                 let firstAvailable = "";
                 for (const languageCode of currentLanguages) {
@@ -1551,7 +1623,49 @@ class ServeCommand extends SessionCommand_1.default {
                         output_language: languageCode,
                     }, `${process.env.HOST}/webhooks/${courseSlug}/initial-readme-processor`);
                 }));
-                return res.status(200).json({ message: "Translated exercises" });
+                (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-initiated", {
+                    status: "completed",
+                    message: "All translation jobs have been initiated",
+                    languages: languageCodes,
+                    exercises: exerciseSlugs,
+                });
+            }
+            catch (error) {
+                console.error("Error processing translations:", error);
+                (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-error", {
+                    status: "error",
+                    error: error.message,
+                    message: "Error occurred during translation processing",
+                });
+                throw error;
+            }
+        }
+        app.post("/actions/translate", express.json(), async (req, res) => {
+            console.log("POST /actions/translate");
+            const { exerciseSlugs, languages, rigoToken, currentLanguage } = req.body;
+            const query = req.query;
+            const courseSlug = typeof query.slug === "string" ? query.slug : undefined;
+            if (!rigoToken) {
+                return res.status(400).json({ error: "RigoToken not found" });
+            }
+            if (!courseSlug) {
+                return res.status(400).json({ error: "Course slug not found" });
+            }
+            const languagesToTranslate = languages.split(",");
+            try {
+                const languageCodesRes = await (0, rigoActions_1.getLanguageCodes)(rigoToken, {
+                    raw_languages: languagesToTranslate.join(","),
+                });
+                const languageCodes = languageCodesRes.parsed.language_codes;
+                res.status(200).json({
+                    message: "Translation started",
+                    languages: languageCodes,
+                    exercises: exerciseSlugs,
+                    status: "processing",
+                });
+                processTranslationsAsync(courseSlug, exerciseSlugs, languageCodes, rigoToken, currentLanguage, bucket).catch(error => {
+                    console.error("Error in background translation processing:", error);
+                });
             }
             catch (error) {
                 console.log(error, "ERROR");
@@ -2393,6 +2507,10 @@ class ServeCommand extends SessionCommand_1.default {
                     .json({ error: "Export failed", details: error.message });
             }
         });
+        // 404 error handler
+        app.use(errorHandler_1.notFoundHandler);
+        // Global error handler
+        app.use(errorHandler_1.errorHandler);
         server.listen(PORT, () => {
             console.log(`🚀 Creator UI server running at http://localhost:${PORT}/creator`);
         });

package/lib/utils/checkNotInstalled.d.ts

@@ -4,5 +4,5 @@ type TNeededPlugins = {
     notInstalled: string[];
 };
 export declare const checkNotInstalledPlugins: (exercises: IExercise[], installedPlugins: string[], command: any) => Promise<TNeededPlugins>;
-export declare const checkNotInstalledDependencies: (neededPlugins: string[]) => Promise<boolean | undefined>;
+export declare const checkNotInstalledDependencies: (neededPlugins: string[]) => Promise<boolean>;
 export {};

package/lib/utils/checkNotInstalled.js

@@ -114,18 +114,47 @@ const installDependencies = async (deps, packageManager) => {
     else if (packageManager === "pip") {
         command = `pip install ${deps.join(" ")}`;
     }
-    const { stdout, stderr } = await exec(command);
-    if (stderr && (stderr.includes("npm ERR!") || stderr.includes("Traceback"))) {
-        console_1.default.error(`Error executing ${command}.`);
-        console_1.default.error(stderr);
-        return;
+    try {
+        const { stdout, stderr } = await exec(command);
+        if (stderr &&
+            (stderr.includes("npm ERR!") || stderr.includes("Traceback"))) {
+            console_1.default.error(`Error executing ${command}.`);
+            console_1.default.error(stderr);
+            return;
+        }
+        console_1.default.info(`Dependencies ${deps.join(" ")} installed...`);
+        return true;
+    }
+    catch (error) {
+        // Si npm/pip retorna código > 0, exec lanzará una excepción
+        const execError = error;
+        const stdout = execError.stdout || "";
+        const stderr = execError.stderr || "";
+        const errorMessage = stderr || execError.message || String(error);
+        // Verificar si es un error real
+        if (errorMessage.includes("npm ERR!") ||
+            errorMessage.includes("Traceback")) {
+            console_1.default.error(`Error executing ${command}.`);
+            console_1.default.error(errorMessage);
+            return;
+        }
+        // Si no es un error real, podría ser solo un warning
+        // Verificar si la instalación fue exitosa a pesar del warning
+        if (stdout &&
+            (stdout.includes("added") || stdout.includes("Successfully installed"))) {
+            console_1.default.info(`Dependencies ${deps.join(" ")} installed...`);
+            return true;
+        }
+        // Si no hay indicios de éxito, se asume fallo (retorna undefined implícitamente)
+        console_1.default.debug(`${command} returned non-zero exit code, but may be just a warning:`, errorMessage);
     }
-    console_1.default.info(`Dependencies ${deps.join(" ")} installed...`);
-    return true;
 };
 const checkNotInstalledDependencies = async (neededPlugins) => {
     console_1.default.info("Checking needed dependencies...");
-    const jsPluginsDependencies = ["jest@29.7.0", "jest-environment-jsdom@29.7.0"];
+    const jsPluginsDependencies = [
+        "jest@29.7.0",
+        "jest-environment-jsdom@29.7.0",
+    ];
     // pytest up to 6.2.5
     const pyPluginsDependencies = ["pytest", "pytest-testdox", "mock"];
     const npmLsCommand = "npm ls jest jest-environment-jsdom -g";
@@ -141,14 +170,29 @@ const checkNotInstalledDependencies = async (neededPlugins) => {
         pytestNeeded = true;
     }
     if (jestNeeded) {
-        const { stdout, stderr } = await exec("npm ls -g");
-        if (stderr) {
-            console_1.default.error(`Error executing ${npmLsCommand}. Use debug for more info`);
-            console_1.default.debug(stderr);
-            return false;
+        try {
+            const { stdout, stderr } = await exec("npm ls -g");
+            // Solo considerar errores reales, no warnings
+            if (stderr && stderr.includes("npm ERR!")) {
+                console_1.default.error(`Error executing npm ls -g. Use debug for more info`);
+                console_1.default.debug(stderr);
+                return false;
+            }
+            if (includesAll(stdout, jsPluginsDependencies))
+                return true;
+        }
+        catch (error) {
+            // Si npm retorna código > 0, exec lanzará una excepción
+            // Verificar si es un error real o solo un warning
+            const errorMessage = (error === null || error === void 0 ? void 0 : error.stderr) || (error === null || error === void 0 ? void 0 : error.message) || String(error);
+            if (errorMessage.includes("npm ERR!")) {
+                console_1.default.error(`Error executing npm ls -g. Use debug for more info`);
+                console_1.default.debug(errorMessage);
+                return false;
+            }
+            // Si no es un error real, continuar (podría ser solo un warning)
+            console_1.default.debug("npm ls -g returned non-zero exit code, but may be just a warning:", errorMessage);
         }
-        if (includesAll(stdout, jsPluginsDependencies))
-            return true;
         console_1.default.error("The jest dependencies are not installed");
         const confirmInstall = await cli_ux_1.cli.confirm("Do you want to install the needed dependencies? (y/n)");
         if (!confirmInstall) {
@@ -167,14 +211,28 @@ const checkNotInstalledDependencies = async (neededPlugins) => {
             console_1.default.error("Error upgrading pip. Please install pip manually, run: pip install --upgrade pip");
             console_1.default.debug(error);
         }
-        const { stdout, stderr } = await exec("pip list");
-        if (stderr) {
-            console_1.default.error(`Error executing pip list. Use debug for more info`);
-            console_1.default.debug(stderr);
-            return;
+        try {
+            const { stdout, stderr } = await exec("pip list");
+            // Solo considerar errores reales, no warnings
+            if (stderr && stderr.includes("Traceback")) {
+                console_1.default.error(`Error executing pip list. Use debug for more info`);
+                console_1.default.debug(stderr);
+                return false;
+            }
+            if (includesAll(stdout, pyPluginsDependencies))
+                return true;
+        }
+        catch (error) {
+            // Si pip retorna código > 0, verificar si es un error real
+            const errorMessage = (error === null || error === void 0 ? void 0 : error.stderr) || (error === null || error === void 0 ? void 0 : error.message) || String(error);
+            if (errorMessage.includes("Traceback")) {
+                console_1.default.error(`Error executing pip list. Use debug for more info`);
+                console_1.default.debug(errorMessage);
+                return false;
+            }
+            // Si no es un error real, continuar
+            console_1.default.debug("pip list returned non-zero exit code, but may be just a warning:", errorMessage);
         }
-        if (includesAll(stdout, pyPluginsDependencies))
-            return true;
         console_1.default.error("The pytest dependencies are not installed");
         const confirmInstall = await cli_ux_1.cli.confirm("Do you want to install the needed dependencies? (y/n)");
         if (!confirmInstall) {

package/lib/utils/errorHandler.d.ts

@@ -0,0 +1,97 @@
+import { Request, Response, NextFunction } from "express";
+/**
+ * Interface for application errors with additional information
+ */
+export interface AppError extends Error {
+    statusCode?: number;
+    code?: string;
+    isOperational?: boolean;
+    details?: any;
+}
+/**
+ * Base class for operational errors (expected errors)
+ */
+export declare class OperationalError extends Error implements AppError {
+    statusCode: number;
+    code: string;
+    isOperational: boolean;
+    details?: any;
+    constructor(message: string, details?: any, statusCode?: number, code?: string);
+}
+/**
+ * Validation error (400)
+ */
+export declare class ValidationError extends OperationalError {
+    constructor(message: string, details?: any);
+}
+/**
+ * Authentication error (401)
+ */
+export declare class UnauthorizedError extends OperationalError {
+    constructor(message: string, details?: any);
+}
+/**
+ * Authorization error (403)
+ */
+export declare class ForbiddenError extends OperationalError {
+    constructor(message: string, details?: any);
+}
+/**
+ * Resource not found error (404)
+ */
+export declare class NotFoundError extends OperationalError {
+    constructor(message: string, details?: any);
+}
+/**
+ * Conflict error (409)
+ */
+export declare class ConflictError extends OperationalError {
+    constructor(message: string, details?: any);
+}
+/**
+ * Internal server error (500)
+ */
+export declare class InternalServerError extends OperationalError {
+    constructor(message: string, details?: any);
+}
+/**
+ * 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
+ */
+export declare const asyncHandler: (fn: (req: Request, res: Response, next: NextFunction) => Promise<any>) => (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * 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
+ */
+export declare const notFoundHandler: (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * 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
+ */
+export declare const errorHandler: (error: AppError | Error, req: Request, res: Response, next: NextFunction) => void;
+/**
+ * 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
+ */
+export declare const createError: (message: string, details?: any, statusCode?: number, code?: string) => OperationalError;