@learnpack/learnpack 2.1.27 → 2.1.29

package/lib/utils/api.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const console_1 = require("../utils/console");
+const storage = require("node-persist");
+const cli_ux_1 = require("cli-ux");
+const HOST = "https://breathecode.herokuapp.com";
+const RIGOBOT_HOST = "https://rigobot.herokuapp.com";
+// eslint-disable-next-line
+const _fetch = require("node-fetch");
+const fetch = async (url, options = {}) => {
+    const headers = { "Content-Type": "application/json" };
+    console_1.default.log(`Fetching ${url}`);
+    let session = null;
+    try {
+        session = await storage.getItem("bc-payload");
+        if (session.token && session.token !== "" && !url.includes("/token"))
+            headers.Authorization = "Token " + session.token;
+    }
+    catch (_a) { }
+    try {
+        const resp = await _fetch(url, Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({}, headers), options.headers) }));
+        if (resp.status >= 200 && resp.status < 300)
+            return await resp.json();
+        if (resp.status === 401)
+            throw APIError("Invalid authentication credentials", 401);
+        else if (resp.status === 404)
+            throw APIError("Package not found", 404);
+        else if (resp.status >= 500)
+            throw APIError("Impossible to connect with the server", 500);
+        else if (resp.status >= 400) {
+            const error = await resp.json();
+            if (error.detail || error.error) {
+                throw APIError(error.detail || error.error);
+            }
+            else if (error.nonFieldErrors) {
+                throw APIError(error.nonFieldErrors[0], error);
+            }
+            else if (typeof error === "object") {
+                if (Object.keys(error).length > 0) {
+                    const key = error[Object.keys(error)[0]];
+                    throw APIError(`${key}: ${error[key][0]}`, error);
+                }
+            }
+            else {
+                throw APIError("Uknown error");
+            }
+        }
+        else
+            throw APIError("Uknown error");
+    }
+    catch (error) {
+        console_1.default.error(error.message);
+        throw error;
+    }
+};
+const login = async (identification, password) => {
+    try {
+        cli_ux_1.default.action.start(`Looking for credentials with ${identification}`);
+        await cli_ux_1.default.wait(1000);
+        const url = `${HOST}/v1/auth/login/`;
+        // Console.log(url);
+        const data = await fetch(url, {
+            body: JSON.stringify({
+                email: identification,
+                password: password,
+            }),
+            method: "post",
+        });
+        cli_ux_1.default.action.stop("ready");
+        const payload = await loginRigo(data.token);
+        return Object.assign(Object.assign({}, data), { rigobot: payload });
+    }
+    catch (error) {
+        cli_ux_1.default.action.stop("error");
+        console_1.default.error(error.message);
+        console_1.default.debug(error);
+    }
+};
+const loginRigo = async (token) => {
+    const rigoUrl = `${RIGOBOT_HOST}/v1/auth/me/token?breathecode_token=${token}`;
+    const rigoResp = await _fetch(rigoUrl);
+    const rigobotJson = await rigoResp.json();
+    return rigobotJson;
+};
+const getOpenAIToken = async () => {
+    const token = await storage.getItem("openai-token");
+    return token;
+};
+const getRigoFeedback = async (readme, currentCode) => {
+    const payload = {
+        current_code: Buffer.from(currentCode).toString("base64"),
+        tutorial: Buffer.from(readme).toString("base64"),
+    };
+    const session = await storage.getItem("bc-payload");
+    const response = await _fetch(`${RIGOBOT_HOST}/v1/conversation/feedback/`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Token ${session.rigobot.key}`,
+        },
+        body: JSON.stringify(payload),
+    });
+    const responseData = await response.json();
+    return responseData.feedback;
+};
+const publish = async (config) => {
+    const keys = [
+        "difficulty",
+        "language",
+        "skills",
+        "technologies",
+        "slug",
+        "repository",
+        "author",
+        "title",
+    ];
+    const payload = {};
+    for (const k of keys)
+        config[k] ? (payload[k] = config[k]) : null;
+    try {
+        console.log("Package to publish:", payload);
+        cli_ux_1.default.action.start("Updating package information...");
+        await cli_ux_1.default.wait(1000);
+        const data = await fetch(`${HOST}/v1/package/${config.slug}`, {
+            method: "PUT",
+            body: JSON.stringify(payload),
+        });
+        cli_ux_1.default.action.stop("ready");
+        return data;
+    }
+    catch (error) {
+        console.log("payload", payload);
+        console_1.default.error(error.message);
+        console_1.default.debug(error);
+        throw error;
+    }
+};
+const update = async (config) => {
+    try {
+        cli_ux_1.default.action.start("Updating package information...");
+        await cli_ux_1.default.wait(1000);
+        const data = await fetch(`${HOST}/v1/package/`, {
+            method: "POST",
+            body: JSON.stringify(config),
+        });
+        cli_ux_1.default.action.stop("ready");
+        return data;
+    }
+    catch (error) {
+        console_1.default.error(error.message);
+        console_1.default.debug(error);
+        throw error;
+    }
+};
+const getPackage = async (slug) => {
+    try {
+        cli_ux_1.default.action.start("Downloading package information...");
+        await cli_ux_1.default.wait(1000);
+        const data = await fetch(`${HOST}/v1/package/${slug}`);
+        cli_ux_1.default.action.stop("ready");
+        return data;
+    }
+    catch (error) {
+        if (error.status === 404)
+            console_1.default.error(`Package ${slug} does not exist`);
+        else
+            console_1.default.error(`Package ${slug} does not exist`);
+        console_1.default.debug(error);
+        throw error;
+    }
+};
+const getLangs = async () => {
+    try {
+        cli_ux_1.default.action.start("Downloading language options...");
+        await cli_ux_1.default.wait(1000);
+        const data = await fetch(`${HOST}/v1/package/language`);
+        cli_ux_1.default.action.stop("ready");
+        return data;
+    }
+    catch (error) {
+        if (error.status === 404)
+            console_1.default.error("Package slug does not exist");
+        else
+            console_1.default.error("Package slug does not exist");
+        console_1.default.debug(error);
+        throw error;
+    }
+};
+const getAllPackages = async ({ lang = "", slug = "", }) => {
+    try {
+        cli_ux_1.default.action.start("Downloading packages...");
+        await cli_ux_1.default.wait(1000);
+        const data = await fetch(`${HOST}/v1/package/all?limit=100&language=${lang}&slug=${slug}`);
+        cli_ux_1.default.action.stop("ready");
+        return data;
+    }
+    catch (error) {
+        console_1.default.error(`Package ${slug} does not exist`);
+        console_1.default.debug(error);
+        throw error;
+    }
+};
+const APIError = (error, code) => {
+    const message = error.message || error;
+    const _err = new Error(message);
+    _err.status = code || 400;
+    return _err;
+};
+exports.default = {
+    login,
+    publish,
+    update,
+    getPackage,
+    getLangs,
+    getAllPackages,
+    getRigoFeedback,
+    getOpenAIToken,
+};

package/lib/utils/audit.d.ts

@@ -0,0 +1,16 @@
+import { IAuditErrors } from "../models/audit";
+import { IConfigObj } from "../models/config";
+import { ICounter } from "../models/counter";
+import { IFindings } from "../models/findings";
+import { IExercise } from "../models/exercise-obj";
+declare const _default: {
+    isUrl: (url: string, errors: IAuditErrors[], counter: ICounter) => Promise<boolean>;
+    checkForEmptySpaces: (str: string) => boolean;
+    checkLearnpackClean: (configObj: IConfigObj, errors: IAuditErrors[]) => void;
+    findInFile: (types: string[], content: string) => IFindings;
+    checkUrl: (config: IConfigObj, filePath: string, fileName: string, exercise: IExercise | undefined, errors: IAuditErrors[], warnings: IAuditErrors[], counter: ICounter | undefined) => Promise<boolean>;
+    writeFile: (content: string, filePath: string) => Promise<void>;
+    showErrors: (errors: IAuditErrors[], counter: ICounter | undefined) => Promise<unknown>;
+    showWarnings: (warnings: IAuditErrors[]) => Promise<unknown>;
+};
+export default _default;

package/lib/utils/audit.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const console_1 = require("./console");
+const fs = require("fs");
+const path = require("path");
+// eslint-disable-next-line
+const fetch = require("node-fetch");
+// eslint-disable-next-line
+const fm = require("front-matter");
+// This function checks if a url is valid.
+const isUrl = async (url, errors, counter) => {
+    const regexUrl = /(https?:\/\/[\w./-]+)/gm;
+    counter.links.total++;
+    if (!regexUrl.test(url)) {
+        counter.links.error++;
+        errors.push({
+            exercise: undefined,
+            msg: `The repository value of the configuration file is not a link: ${url}`,
+        });
+        return false;
+    }
+    const res = await fetch(url, { method: "HEAD" });
+    if (!res.ok) {
+        counter.links.error++;
+        errors.push({
+            exercise: undefined,
+            msg: `The link of the repository is broken: ${url}`,
+        });
+    }
+    return true;
+};
+const checkForEmptySpaces = (str) => {
+    const isEmpty = true;
+    for (const letter of str) {
+        if (letter !== " ") {
+            return false;
+        }
+    }
+    return isEmpty;
+};
+const checkLearnpackClean = (configObj, errors) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if ((((_a = configObj.config) === null || _a === void 0 ? void 0 : _a.outputPath) &&
+        fs.existsSync((_b = configObj.config) === null || _b === void 0 ? void 0 : _b.outputPath)) ||
+        fs.existsSync(`${(_c = configObj.config) === null || _c === void 0 ? void 0 : _c.dirPath}/_app`) ||
+        fs.existsSync(`${(_d = configObj.config) === null || _d === void 0 ? void 0 : _d.dirPath}/reports`) ||
+        fs.existsSync(`${(_e = configObj.config) === null || _e === void 0 ? void 0 : _e.dirPath}/resets`) ||
+        fs.existsSync(`${(_f = configObj.config) === null || _f === void 0 ? void 0 : _f.dirPath}/app.tar.gz`) ||
+        fs.existsSync(`${(_g = configObj.config) === null || _g === void 0 ? void 0 : _g.dirPath}/config.json`) ||
+        fs.existsSync(`${(_h = configObj.config) === null || _h === void 0 ? void 0 : _h.dirPath}/vscode_queue.json`)) {
+        errors.push({
+            exercise: undefined,
+            msg: "You have to run learnpack clean command",
+        });
+    }
+};
+const findInFile = (types, content) => {
+    const regex = {
+        relativeImages: /!\[.*]\s*\((((\.\/)?(\.{2}\/){1,5})(.*\/)*(.[^\s/]*\.[A-Za-z]{2,4})\S*)\)/gm,
+        externalImages: /!\[.*]\((https?:\/(\/[^)/]+)+\/?)\)/gm,
+        markdownLinks: /(\s)+\[.*]\((https?:\/(\/[^)/]+)+\/?)\)/gm,
+        url: /(https?:\/\/[\w./-]+)/gm,
+        uploadcare: /https:\/\/ucarecdn.com\/(?:.*\/)*([\w./-]+)/gm,
+    };
+    const validTypes = Object.keys(regex);
+    if (!Array.isArray(types))
+        types = [types];
+    const findings = {};
+    for (const type of types) {
+        if (!validTypes.includes(type))
+            throw new Error("Invalid type: " + type);
+        else
+            findings[type] = {};
+    }
+    for (const type of types) {
+        let m;
+        while ((m = regex[type].exec(content)) !== null) {
+            // This is necessary to avoid infinite loops with zero-width matches
+            if (m.index === regex.lastIndex) {
+                regex.lastIndex++;
+            }
+            // The result can be accessed through the `m`-variable.
+            // m.forEach((match, groupIndex) => values.push(match));
+            findings[type][m[0]] = {
+                content: m[0],
+                absUrl: m[1],
+                mdUrl: m[2],
+                relUrl: m[6],
+            };
+        }
+    }
+    return findings;
+};
+// This function checks that each of the url's are working.
+const checkUrl = async (config, filePath, fileName, exercise, errors, warnings, counter) => {
+    var _a, _b, _c, _d;
+    if (!fs.existsSync(filePath))
+        return false;
+    const content = fs.readFileSync(filePath).toString();
+    const isEmpty = checkForEmptySpaces(content);
+    if (isEmpty || !content)
+        errors.push({
+            exercise: exercise === null || exercise === void 0 ? void 0 : exercise.title,
+            msg: `This file (${fileName}) doesn't have any content inside.`,
+        });
+    const frontmatter = fm(content);
+    for (const attribute in frontmatter.attributes) {
+        if (Object.prototype.hasOwnProperty.call(frontmatter.attributes, attribute) &&
+            (attribute === "intro" || attribute === "tutorial")) {
+            counter && counter.links.total++;
+            try {
+                // eslint-disable-next-line
+                let res = await fetch(frontmatter.attributes[attribute], {
+                    method: "HEAD",
+                });
+                if (!res.ok) {
+                    counter && counter.links.error++;
+                    errors.push({
+                        exercise: exercise === null || exercise === void 0 ? void 0 : exercise.title,
+                        msg: `This link is broken (${res.ok}): ${frontmatter.attributes[attribute]}`,
+                    });
+                }
+            }
+            catch (_e) {
+                counter && counter.links.error++;
+                errors.push({
+                    exercise: exercise === null || exercise === void 0 ? void 0 : exercise.title,
+                    msg: `This link is broken: ${frontmatter.attributes[attribute]}`,
+                });
+            }
+        }
+    }
+    // Check url's of each README file.
+    const findings = findInFile(["relativeImages", "externalImages", "markdownLinks"], content);
+    for (const finding in findings) {
+        if (Object.prototype.hasOwnProperty.call(findings, finding)) {
+            const obj = findings[finding];
+            // Valdites all the relative path images.
+            if (finding === "relativeImages" && Object.keys(obj).length > 0) {
+                for (const img in obj) {
+                    if (Object.prototype.hasOwnProperty.call(obj, img)) {
+                        // Validates if the image is in the assets folder.
+                        counter && counter.images.total++;
+                        const relativePath = path
+                            .relative(exercise ? exercise.path.replace(/\\/gm, "/") : "./", `${(_a = config.config) === null || _a === void 0 ? void 0 : _a.dirPath}/assets/${obj[img].relUrl}`)
+                            .replace(/\\/gm, "/");
+                        if (relativePath !== obj[img].absUrl.split("?").shift()) {
+                            counter && counter.images.error++;
+                            errors.push({
+                                exercise: exercise === null || exercise === void 0 ? void 0 : exercise.title,
+                                msg: `This relative path (${obj[img].relUrl}) is not pointing to the assets folder.`,
+                            });
+                        }
+                        if (!fs.existsSync(`${(_b = config.config) === null || _b === void 0 ? void 0 : _b.dirPath}/assets/${obj[img].relUrl}`)) {
+                            counter && counter.images.error++;
+                            errors.push({
+                                exercise: exercise === null || exercise === void 0 ? void 0 : exercise.title,
+                                msg: `The file ${obj[img].relUrl} doesn't exist in the assets folder.`,
+                            });
+                        }
+                    }
+                }
+            }
+            else if (finding === "externalImages" && Object.keys(obj).length > 0) {
+                // Valdites all the aboslute path images.
+                for (const img in obj) {
+                    if (Object.prototype.hasOwnProperty.call(obj, img)) {
+                        counter && counter.images.total++;
+                        if (fs.existsSync(`${(_c = config.config) === null || _c === void 0 ? void 0 : _c.dirPath}/assets${obj[img].mdUrl
+                            .split("?")
+                            .shift()}`)) {
+                            const relativePath = path
+                                .relative(exercise ? exercise.path.replace(/\\/gm, "/") : "./", `${(_d = config.config) === null || _d === void 0 ? void 0 : _d.dirPath}/assets/${obj[img].mdUrl}`)
+                                .replace(/\\/gm, "/");
+                            warnings.push({
+                                exercise: exercise === null || exercise === void 0 ? void 0 : exercise.title,
+                                msg: `On this exercise you have an image with an absolute path "${obj[img].absUrl}". We recommend you to replace it by the relative path: "${relativePath}".`,
+                            });
+                        }
+                        try {
+                            // eslint-disable-next-line
+                            let res = await fetch(obj[img].absUrl, {
+                                method: "HEAD",
+                            });
+                            if (!res.ok) {
+                                counter && counter.images.error++;
+                                errors.push({
+                                    exercise: exercise === null || exercise === void 0 ? void 0 : exercise.title,
+                                    msg: `This link is broken: ${obj[img].absUrl}`,
+                                });
+                            }
+                        }
+                        catch (_f) {
+                            counter && counter.images.error++;
+                            errors.push({
+                                exercise: exercise === null || exercise === void 0 ? void 0 : exercise.title,
+                                msg: `This link is broken: ${obj[img].absUrl}`,
+                            });
+                        }
+                    }
+                }
+            }
+            else if (finding === "markdownLinks" && Object.keys(obj).length > 0) {
+                for (const link in obj) {
+                    if (Object.prototype.hasOwnProperty.call(obj, link)) {
+                        counter && counter.links.total++;
+                        if (!obj[link].mdUrl.includes("twitter")) {
+                            try {
+                                // eslint-disable-next-line
+                                let res = await fetch(obj[link].mdUrl, {
+                                    method: "HEAD",
+                                });
+                                if (res.status > 399 && res.status < 500) {
+                                    counter && counter.links.error++;
+                                    errors.push({
+                                        exercise: exercise === null || exercise === void 0 ? void 0 : exercise.title,
+                                        msg: `This link is broken: ${obj[link].mdUrl}`,
+                                    });
+                                }
+                            }
+                            catch (_g) {
+                                counter && counter.links.error++;
+                                errors.push({
+                                    exercise: exercise === null || exercise === void 0 ? void 0 : exercise.title,
+                                    msg: `This link is broken: ${obj[link].mdUrl}`,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return true;
+};
+// This function writes a given file with the given content.
+const writeFile = async (content, filePath) => {
+    try {
+        await fs.promises.writeFile(filePath, content);
+    }
+    catch (error) {
+        if (error)
+            console_1.default.error(`We weren't able to write the file in this path "${filePath}".`, error);
+    }
+};
+// This function checks if there are errors, and show them in the console at the end.
+const showErrors = (errors, counter) => {
+    return new Promise((resolve, reject) => {
+        if (errors) {
+            if (errors.length > 0) {
+                console_1.default.log("Checking for errors...");
+                for (const [i, error] of errors.entries())
+                    console_1.default.error(`${i + 1}) ${error.msg} ${error.exercise ? `(Exercise: ${error.exercise})` : ""}`);
+                if (counter) {
+                    console_1.default.error(` We found ${errors.length} error${errors.length > 1 ? "s" : ""} among ${counter.images.total} images, ${counter.links.total} link, ${counter.readmeFiles} README files and ${counter.exercises} exercises.`);
+                }
+                else {
+                    console_1.default.error(` We found ${errors.length} error${errors.length > 1 ? "s" : ""} related with the project integrity.`);
+                }
+                process.exit(1);
+            }
+            else {
+                if (counter) {
+                    console_1.default.success(`We didn't find any errors in this repository among ${counter.images.total} images, ${counter.links.total} link, ${counter.readmeFiles} README files and ${counter.exercises} exercises.`);
+                }
+                else {
+                    console_1.default.success(`We didn't find any errors in this repository.`);
+                }
+                process.exit(0);
+            }
+        }
+        else {
+            reject("Failed");
+        }
+    });
+};
+// This function checks if there are warnings, and show them in the console at the end.
+const showWarnings = (warnings) => {
+    return new Promise((resolve, reject) => {
+        if (warnings) {
+            if (warnings.length > 0) {
+                console_1.default.log("Checking for warnings...");
+                for (const [i, warning] of warnings.entries())
+                    console_1.default.warning(`${i + 1}) ${warning.msg} ${warning.exercise ? `File: ${warning.exercise}` : ""}`);
+            }
+            resolve("SUCCESS");
+        }
+        else {
+            reject("Failed");
+        }
+    });
+};
+exports.default = {
+    isUrl,
+    checkForEmptySpaces,
+    checkLearnpackClean,
+    findInFile,
+    checkUrl,
+    writeFile,
+    showErrors,
+    showWarnings,
+};

package/lib/utils/console.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    _debug: boolean;
+    startDebug: () => void;
+    log: (msg: string | Array<string>, ...args: Array<any>) => void;
+    error: (msg: string, ...args: Array<any>) => void;
+    success: (msg: string, ...args: Array<any>) => void;
+    info: (msg: string, ...args: Array<any>) => void;
+    help: (msg: string) => void;
+    debug(...args: Array<any>): void;
+    warning: (msg: string) => void;
+};
+export default _default;

package/lib/utils/console.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk = require("chalk");
+exports.default = {
+    // _debug: true,
+    _debug: process.env.DEBUG === 'true',
+    startDebug: function () {
+        this._debug = true;
+    },
+    log: (msg, ...args) => console.log(chalk.gray(msg), ...args),
+    error: (msg, ...args) => console.log(chalk.red('⨉ ' + msg), ...args),
+    success: (msg, ...args) => console.log(chalk.green('✓ ' + msg), ...args),
+    info: (msg, ...args) => console.log(chalk.blue('ⓘ ' + msg), ...args),
+    help: (msg) => console.log(`${chalk.white.bold('⚠ help:')} ${chalk.white(msg)}`),
+    debug(...args) {
+        this._debug && console.log(chalk.magentaBright('⚠ debug: '), args);
+    },
+    warning: (msg) => console.log(`${chalk.yellow('⚠ warning:')} ${chalk.yellow(msg)}`),
+};

package/lib/utils/errors.d.ts

@@ -0,0 +1,17 @@
+import { ISolution, IError } from '../models/errors';
+export declare const getSolution: (slug?: string | undefined) => ISolution;
+export declare const ValidationError: (error: IError | string) => IError;
+export declare const NotFoundError: (error: IError | string) => IError;
+export declare const CompilerError: (error: IError | string) => IError;
+export declare const TestingError: (error: IError | string) => IError;
+export declare const AuthError: (error: IError | string) => IError;
+export declare const InternalError: (error: IError | string) => IError;
+declare const _default: {
+    ValidationError: (error: string | IError) => IError;
+    CompilerError: (error: string | IError) => IError;
+    TestingError: (error: string | IError) => IError;
+    NotFoundError: (error: string | IError) => IError;
+    InternalError: (error: string | IError) => IError;
+    AuthError: (error: string | IError) => IError;
+};
+export default _default;