@learnpack/learnpack 1.0.0 → 2.0.0

package/src/managers/server/{index.js → index.ts}

@@ -1,19 +1,25 @@
-const express = require("express");
-const Console = require("../../utils/console");
-const cors = require("cors");
-const shell = require("shelljs");
-const addRoutes = require("./routes.js");
-const cli = require("cli-ux").default;
-
-module.exports = async function (
-  configObj,
-  configManager,
+import * as express from "express";
+// eslint-disable-next-line
+import * as cors from "cors";
+import * as http from "http";
+import Console from "../../utils/console";
+import addRoutes from "./routes";
+import cli from "cli-ux";
+import { IConfigObj } from "../../models/config";
+import { IConfigManager } from "../../models/config-manager";
+
+export let TEST_SERVER: http.Server;
+
+export default async function (
+  configObj: IConfigObj,
+  configManager: IConfigManager,
   isTestingEnvironment = false
 ) {
   const { config } = configObj;
-  var app = express();
-  var server = require("http").Server(app);
+  const app = express();
+  const server = require("http").Server(app);
   app.use(cors());
+
   // app.use(function(req, res, next) {
   //     res.header("Access-Control-Allow-Origin", "*")
   //     res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
@@ -24,20 +30,21 @@ module.exports = async function (
   // add all needed endpoints
   await addRoutes(app, configObj, configManager);
 
-  server.listen(isTestingEnvironment ? 5000 : config.port, function () {
+  server.listen(isTestingEnvironment ? 5000 : config?.port, function () {
     if (!isTestingEnvironment) {
       Console.success(
         `Exercises are running 😃 Open your browser to start practicing!`
       );
       Console.success(`\n            Open the exercise on this link:`);
-      Console.log(`            ${config.publicUrl}`);
-      if (config.editor.mode === "standalone") cli.open(`${config.publicUrl}`);
+      Console.log(`            ${config?.publicUrl}`);
+      if (config?.editor.mode === "standalone") 
+cli.open(`${config.publicUrl}`);
     }
   });
 
-  const sockets = new Set();
+  const sockets: any = new Set();
 
-  server.on("connection", (socket) => {
+  server.on("connection", (socket: any) => {
     sockets.add(socket);
 
     server.once("close", () => {
@@ -48,7 +55,7 @@ module.exports = async function (
   /**
    * Forcefully terminates HTTP server.
    */
-  server.terminate = (callback) => {
+  server.terminate = (callback: void) => {
     for (const socket of sockets) {
       socket.destroy();
 
@@ -59,4 +66,4 @@ module.exports = async function (
   };
 
   return server;
-};
+}

package/src/managers/server/routes.ts

@@ -0,0 +1,250 @@
+import Console from "../../utils/console";
+import * as express from "express";
+import * as fs from "fs";
+import * as bodyParser from "body-parser";
+import socket from "../socket";
+import queue from "../../utils/fileQueue";
+// import gitpod from '../gitpod'
+import { detect, filterFiles } from "../config/exercise";
+import { IFile } from "../../models/file";
+import { IConfigObj, TEntries } from "../../models/config";
+import { IConfigManager } from "../../models/config-manager";
+import { IExercise } from "../../models/exercise-obj";
+
+const withHandler =
+  (func: (req: express.Request, res: express.Response) => void) =>
+  (req: express.Request, res: express.Response) => {
+    try {
+      func(req, res);
+    } catch (error) {
+      Console.debug(error);
+      const _err = {
+        message: (error as TypeError).message || "There has been an error",
+        status: (error as any).status || 500,
+        type: (error as any).type || null,
+      };
+      Console.error(_err.message);
+
+      // send rep to the server
+      res.status(_err.status);
+      res.json(_err);
+    }
+  };
+
+export default async function (
+  app: express.Application,
+  configObject: IConfigObj,
+  configManager: IConfigManager
+) {
+  const { config, exercises } = configObject;
+
+  const dispatcher = queue.dispatcher({
+    create: true,
+    path: `${config?.dirPath}/vscode_queue.json`,
+  });
+  app.get(
+    "/config",
+    withHandler((_: express.Request, res: express.Response) => {
+      res.json(configObject);
+    })
+  );
+
+  /**
+     * TODO: replicate a socket action, the request payload must be passed to the socket as well
+  
+   const jsonBodyParser = bodyParser.json()
+   
+   type ISocketActions = "addAllowed" | "removeAllowed" | "start" | "on" | "clean" | "ask" | "reload" | "openWindow" | "log" | "emit" | "ready" | "error" | "fatal" | "success" | "onTestingFinished";
+   
+   app.post('/socket/:actionName', jsonBodyParser, withHandler((req, res) => {
+     if (socket[req.params.actionName as ISocketActions] instanceof Function) {
+       socket[req.params.actionName as ISocketActions](req.body ? req.body.data : null)
+       res.json({ "details": "Socket call executed sucessfully" })
+      } else res.status(400).json({ "details": `Socket action ${req.params.actionName} not found` })
+    }))
+  */
+
+  // symbolic link to maintain path compatiblity
+  const fetchStaticAsset = withHandler((req, res) => {
+    const filePath = `${config?.dirPath}/assets/${req.params.filePath}`;
+    if (!fs.existsSync(filePath)) 
+throw new Error("File not found: " + filePath);
+    const content = fs.readFileSync(filePath);
+    res.write(content);
+    res.end();
+  });
+
+  app.get(
+    `${
+      config?.dirPath.indexOf("./") === 0 ?
+        config.dirPath.slice(1) :
+        config?.dirPath
+    }/assets/:filePath`,
+    fetchStaticAsset
+  );
+
+  app.get("/assets/:filePath", fetchStaticAsset);
+
+  app.get(
+    "/exercise",
+    withHandler((_: express.Request, res: express.Response) => {
+      res.json(exercises);
+    })
+  );
+
+  app.get(
+    "/exercise/:slug/readme",
+    withHandler(
+      (
+        { params: { slug }, query: { lang } }: express.Request,
+        res: express.Response
+      ) => {
+        const excercise: IExercise = configManager.getExercise(slug);
+
+        if (excercise) {
+          const readme = excercise.getReadme((lang as string) || null);
+          res.json(readme);
+        } else {
+          res.status(400);
+        }
+      }
+    )
+  );
+
+  app.get(
+    "/exercise/:slug/report",
+    withHandler(
+      ({ params: { slug } }: express.Request, res: express.Response) => {
+        const report = configManager.getExercise(slug).getTestReport();
+        res.json(JSON.stringify(report));
+      }
+    )
+  );
+
+  app.get(
+    "/exercise/:slug",
+    withHandler((req: express.Request, res: express.Response) => {
+      // no need to re-start exercise if it's already started
+      if (
+        configObject.currentExercise &&
+        req.params.slug === configObject.currentExercise
+      ) {
+        const exercise = configManager.getExercise(req.params.slug);
+        res.json(exercise);
+        return;
+      }
+
+      const exercise = configManager.startExercise(req.params.slug);
+      dispatcher.enqueue(dispatcher.events.START_EXERCISE, req.params.slug);
+
+      type TEntry = "python3" | "html" | "node" | "react" | "java";
+
+      // eslint-disable-next-line
+      const entries = new Set(Object.keys(config?.entries!).map(
+        lang => config?.entries[lang as TEntry]
+      ));
+      // if we are in incremental grading, the entry file can by dinamically detected
+      // based on the changes the student is making during the exercise
+      if (config?.grading === "incremental") {
+        const scanedFiles = fs.readdirSync("./");
+
+        // update the file hierarchy with updates
+        exercise.files = [...exercise.files.filter(f => f.name.includes("test.")), ...filterFiles(scanedFiles)];
+        Console.debug(`Exercise updated files: `, exercise.files);
+      }
+
+      const detected = detect(
+        configObject,
+        exercise.files
+          .filter(fileName => entries.has(fileName.name))
+          .map(f => f.name || f) as string[]
+      );
+
+      // if a new language for the testing engine is detected, we replace it
+      // if not we leave it as it was before
+      if (config?.language && !["", "auto"].includes(config?.language)) {
+        Console.debug(
+          `Exercise language ignored, instead imported from configuration ${config?.language}`
+        );
+        exercise.language = detected?.language;
+      } else if (
+        detected?.language &&
+        (!config?.language || config?.language === "auto")
+      ) {
+        Console.debug(
+          `Switching to ${detected.language} engine in this exercise`
+        );
+        exercise.language = detected.language;
+      }
+
+      // WARNING: has to be the FULL PATH to the entry path
+      // We need to detect entry in both gradings: Incremental and Isolate
+      exercise.entry = detected?.entry;
+      Console.debug(
+        `Exercise detected entry: ${detected?.entry} and language ${exercise.language}`
+      );
+
+      if (
+        !exercise.graded ||
+        config?.disableGrading ||
+        config?.disabledActions?.includes("test")
+      ) {
+        socket.removeAllowed("test");
+      } else {
+        socket.addAllowed("test");
+      }
+
+      if (!exercise.entry || config?.disabledActions?.includes("build")) {
+        socket.removeAllowed("build");
+      } else {
+        socket.addAllowed("build");
+      }
+
+      if (
+        exercise.files.filter(
+          (f: IFile) =>
+            !f.name.toLowerCase().includes("readme.") &&
+            !f.name.toLowerCase().includes("test.")
+        ).length === 0 ||
+        config?.disabledActions?.includes("reset")
+      ) {
+        socket.removeAllowed("reset");
+      } else if (!config?.disabledActions?.includes("reset")) {
+        socket.addAllowed("reset");
+      }
+
+      socket.log("ready");
+
+      res.json(exercise);
+    })
+  );
+
+  app.get(
+    "/exercise/:slug/file/:fileName",
+    withHandler((req: express.Request, res: express.Response) => {
+      res.write(
+        configManager.getExercise(req.params.slug).getFile(req.params.fileName)
+      );
+      res.end();
+    })
+  );
+
+  const textBodyParser = bodyParser.text();
+  app.put(
+    "/exercise/:slug/file/:fileName",
+    textBodyParser,
+    withHandler((req: express.Request, res: express.Response) => {
+      // const result =
+      configManager
+        .getExercise(req.params.slug)
+        .saveFile(req.params.fileName, req.body);
+      res.end();
+    })
+  );
+
+  if (config?.outputPath) {
+    app.use("/preview", express.static(config.outputPath));
+  }
+
+  app.use("/", express.static(`${config?.dirPath}/_app`));
+}

package/src/managers/session.ts

@@ -0,0 +1,118 @@
+import Console from '../utils/console'
+import api from '../utils/api'
+
+import v from 'validator'
+import {ValidationError, InternalError} from '../utils/errors'
+// import moment from 'moment'
+import * as fs from 'fs'
+import cli from 'cli-ux'
+import * as storage from 'node-persist'
+
+import {IPayload, ISession, IStartProps} from '../models/session'
+import {IConfigObj} from '../models/config'
+
+const Session: ISession = {
+  sessionStarted: false,
+  token: null,
+  config: null,
+  currentCohort: null,
+  initialize: async function () {
+    if (!this.sessionStarted) {
+      if (!this.config) {
+        throw InternalError('Configuration not found')
+      }
+
+      if (!fs.existsSync(this.config.dirPath)) {
+        fs.mkdirSync(this.config.dirPath)
+      }
+
+      await storage.init({dir: `${this.config.dirPath}/.session`})
+      this.sessionStarted = true
+    }
+
+    return true
+  },
+  setPayload: async function (value: IPayload) {
+    await this.initialize()
+    await storage.setItem('bc-payload', {token: this.token, ...value})
+    Console.debug('Payload successfuly found and set for ' + value.email)
+    return true
+  },
+  getPayload: async function () {
+    await this.initialize()
+    let payload = null
+    try {
+      payload = await storage.getItem('bc-payload')
+    } catch (error) {
+      // TODO: Remove it
+      console.log(error)
+      Console.debug('Error retriving session payload')
+    }
+
+    return payload
+  },
+  isActive: function () {
+    /* if (this.token) {
+      return true
+    } else {
+      return false
+    } */
+    return !!this.token
+  },
+  get: async function (configObj?: IConfigObj) {
+    if (configObj && configObj.config) {
+      this.config = configObj.config
+    }
+
+    await this.sync()
+    if (!this.isActive()) {
+      return null
+    }
+
+    const payload = await this.getPayload()
+
+    return {
+      payload,
+      token: this.token,
+    }
+  },
+  login: async function () {
+    const email = await cli.prompt('What is your email?')
+    if (!v.isEmail(email)) {
+      throw ValidationError('Invalid email')
+    }
+
+    const password = await cli.prompt('What is your password?', {
+      type: 'hide',
+    })
+
+    const data = await api.login(email, password)
+    if (data) {
+      this.start({token: data.token, payload: data})
+    }
+  },
+  sync: async function () {
+    const payload = await this.getPayload()
+    if (payload) {
+      this.token = payload.token
+    }
+  },
+  start: async function ({token, payload = null}: IStartProps) {
+    if (!token) {
+      throw new Error('A token and email is needed to start a session')
+    }
+
+    this.token = token
+
+    if (payload && (await this.setPayload(payload))) {
+      Console.success(`Successfully logged in as ${payload.email}`)
+    }
+  },
+  destroy: async function () {
+    await storage.clear()
+    this.token = null
+    Console.success('You have logged out')
+  },
+}
+
+export default Session

package/src/managers/socket.ts

@@ -0,0 +1,239 @@
+import {Socket, Server} from 'socket.io'
+import Console from '../utils/console'
+import queue from '../utils/fileQueue'
+
+import {ISocket, TPossibleActions} from '../models/socket'
+import {IConfig} from '../models/config'
+import {ICallback, TAction} from '../models/action'
+import {IExercise, IExerciseData} from '../models/exercise-obj'
+import {TStatus} from '../models/status'
+import {TSuccessType} from '../models/success-types'
+import * as http from 'http'
+
+const SocketManager: ISocket = {
+  socket: null,
+  config: null,
+  allowedActions: [],
+  possibleActions: ['build', 'reset', 'test', 'tutorial'],
+  isTestingEnvironment: false,
+  actionCallBacks: {
+    clean: (_, s: { logs: Array<string> }) => {
+      s.logs = []
+    },
+  },
+  addAllowed: function (actions: Array<TPossibleActions> | TPossibleActions) {
+    if (!Array.isArray(actions))
+      actions = [actions]
+
+    // avoid adding the "test" action if grading is disabled
+    if (
+      actions.includes('test') &&
+      this.config?.disabledActions?.includes('test')
+    ) {
+      actions = actions.filter((a: TPossibleActions) => a !== 'test')
+    }
+
+    this.allowedActions = [
+      ...(this.allowedActions || []).filter(
+        (a: TPossibleActions) => !actions.includes(a),
+      ),
+      ...actions,
+    ]
+  },
+  removeAllowed: function (
+    actions: Array<TPossibleActions> | TPossibleActions,
+  ) {
+    if (!Array.isArray(actions)) {
+      actions = [actions]
+    }
+
+    this.allowedActions = (this.allowedActions || []).filter(
+      (a: TPossibleActions) => !actions.includes(a),
+    )
+  },
+  start: function (
+    config: IConfig,
+    server: http.Server,
+    isTestingEnvironment = false,
+  ) {
+    this.config = config
+    this.isTestingEnvironment = isTestingEnvironment
+
+    this.socket = new Server(server, {allowEIO3: true})
+
+    this.allowedActions = this.config?.disabledActions?.includes('test') ||
+      this.config?.disableGrading ? this.possibleActions.filter(
+        a => !this.config?.disabledActions?.includes(a) && a !== 'test',
+      ) : this.possibleActions.filter(
+        a => !this.allowedActions?.includes(a),
+      )
+
+    if (this.config?.grading === 'incremental') {
+      this.removeAllowed('reset')
+    }
+
+    if (this.socket) {
+      this.socket.on('connection', (socket: Socket) => {
+        Console.debug(
+          'Connection with client successfully established',
+          this.allowedActions,
+        )
+        if (!this.isTestingEnvironment) {
+          this.log('ready', ['Ready to compile or test...'])
+        }
+
+        socket.on(
+          'compiler',
+          ({action, data}: { action: string; data: IExerciseData }) => {
+            this.emit('clean', 'pending', ['Working...'])
+
+            if (typeof data.exerciseSlug === 'undefined') {
+              this.log('internal-error', ['No exercise slug specified'])
+              Console.error('No exercise slug especified')
+              return
+            }
+
+            if (
+              this.actionCallBacks &&
+              typeof this.actionCallBacks[action] === 'function'
+            ) {
+              this.actionCallBacks[action](data)
+            } else {
+              this.log('internal-error', ['Uknown action ' + action])
+            }
+          },
+        )
+      })
+    }
+  },
+  on: function (action: TAction, callBack: ICallback) {
+    if (this.actionCallBacks) {
+      this.actionCallBacks[action] = callBack
+    }
+  },
+  clean: function (_ = 'pending', logs = []) {
+    this.emit('clean', 'pending', logs)
+  },
+  ask: function (questions = []) {
+    return new Promise((resolve, _) => {
+      this.emit('ask', 'pending', ['Waiting for input...'], questions)
+      this.on('input', ({inputs}: any) => {
+        // Workaround to fix issue because null inputs
+        let isNull = false
+        // eslint-disable-next-line
+        inputs.forEach((input: any) => {
+          if (input === null) {
+            isNull = true
+          }
+        })
+
+        if (!isNull) {
+          resolve(inputs)
+        }
+      })
+    })
+  },
+  reload: function (
+    files: Array<string> | null = null,
+    exercises: Array<string> | null = null,
+  ) {
+    this.emit(
+      'reload',
+      files?.join('') || '' /* TODO: Check it out this */,
+      exercises!,
+    )
+  },
+  openWindow: function (url = '') {
+    queue.dispatcher().enqueue(queue.events.OPEN_WINDOW, url)
+    this.emit(
+      queue.events.OPEN_WINDOW as TAction,
+      'ready',
+      [`Opening ${url}`],
+      [],
+      [],
+      url,
+    )
+  },
+  log: function (
+    status: TStatus,
+    messages: string | Array<string> = [],
+    report: Array<string> = [],
+    data: any = null,
+  ) {
+    this.emit('log', status, messages, [], report, data)
+    Console.log(messages)
+  },
+  emit: function (
+    action: TAction,
+    status: TStatus | string = 'ready',
+    logs: string | Array<string> = [],
+    inputs: Array<string> = [],
+    report: Array<string> = [],
+    data: any = null,
+  ) {
+    if (
+      this.config?.compiler &&
+      ['webpack', 'vanillajs', 'vue', 'react', 'css', 'html'].includes(
+        this.config?.compiler,
+      )
+    ) {
+      if (['compiler-success', 'compiler-warning'].includes(status))
+        this.addAllowed('preview')
+      if (['compiler-error'].includes(status) || action === 'ready')
+        this.removeAllowed('preview')
+    }
+
+    if (this.config?.grading === 'incremental') {
+      this.removeAllowed('reset')
+    }
+
+    // eslint-disable-next-line
+    this.config?.disabledActions?.forEach((a) => this.removeAllowed(a));
+
+    this.socket?.emit('compiler', {
+      action,
+      status,
+      logs,
+      allowed: this.allowedActions,
+      inputs,
+      report,
+      data,
+    })
+  },
+
+  ready: function (message: string) {
+    this.log('ready', [message])
+  },
+  success: function (type: TSuccessType, stdout: string) {
+    const types = ['compiler', 'testing']
+    if (!types.includes(type))
+      this.fatal(`Invalid socket success type "${type}" on socket`)
+    else if (stdout === '')
+      this.log((type + '-success') as TSuccessType, [
+        'No stdout to display on the console',
+      ])
+    else
+      this.log((type + '-success') as TSuccessType, [stdout])
+  },
+  error: function (type: TStatus, stdout: string) {
+    console.error('Socket error: ' + type, stdout)
+    this.log(type, [stdout])
+
+    if (this.isTestingEnvironment) {
+      this.onTestingFinished({
+        result: 'failed',
+      })
+    }
+  },
+  fatal: function (msg: string) {
+    this.log('internal-error', [msg])
+    throw msg
+  },
+  onTestingFinished: function (result: any) {
+    if (this.config?.testingFinishedCallback) {
+      this.config.testingFinishedCallback(result)
+    }
+  },
+}
+
+export default SocketManager