chore: Pull before push

Author: CodeMaster17

express_backend/.prettierrc

@@ -0,0 +1,10 @@
+{
+    "trailingComma": "none",
+    "tabWidth": 4,
+    "semi": true,
+    "singleQuote": true,
+    "bracketSameLine": true,
+    "printWidth": 150,
+    "singleAttributePerLine": true,
+    "endOfLine": "crlf"
+}

express_backend/commitlint.config.js

@@ -0,0 +1,29 @@
+// commitlint.config.js
+
+module.exports = {
+    extends: ['@commitlint/cli', '@commitlint/config-conventional'],
+    rules: {
+        'type-enum': [
+            2, // level: error
+            'always', // applicable condition
+            [
+                'feat',    // New feature
+                'fix',     // Bug fix
+                'docs',    // Documentation changes
+                'style',   // Code style changes (formatting, missing semi colons, etc.)
+                'refactor',// Code refactoring (neither fixes a bug nor adds a feature)
+                'perf',    // Performance improvements
+                'test',    // Adding missing tests or correcting existing tests
+                'build',   // Changes affecting the build system or external dependencies
+                'ci',      // Changes to CI configuration files and scripts
+                'chore',   // Other changes that don’t modify src or test files
+                'revert'   // Reverts a previous commit
+            ]
+        ],
+        'subject-case': [
+            2, // level: error
+            'always', // applicable condition
+            ['sentence-case', 'start-case', 'pascal-case', 'upper-case']
+        ],
+    },
+};

express_backend/ecosystem.config.js

@@ -0,0 +1,29 @@
+// @ts-check
+
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import eslintConfigPrettier from 'eslint-config-prettier'
+
+export default tseslint.config(
+    {
+        languageOptions: {
+            parserOptions: {
+                project: true,
+                tsconfigRootDir: import.meta.dirname,
+            },
+        },
+        files: ['**/*.ts'],
+        extends: [
+            eslint.configs.recommended,
+            ...tseslint.configs.recommended,
+            eslintConfigPrettier
+        ],
+        rules: {
+            // this is done so that there is no console while we push code to github production
+            // large number of consoles slow down the performance of the code
+            'no-console': 'off',
+            'no-useless-catch': 0,
+            quotes: ['error', 'single', { allowTemplateLiterals: true }],
+        }
+    }
+);

express_backend/eslint.config.mjs

@@ -0,0 +1,41 @@
+// we don't need an output file for this becuase python is interpreted langauge
+const { exec } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const outputPath = path.join(__dirname, "outputs");
+
+if (!fs.existsSync(outputPath)) {
+  fs.mkdirSync(outputPath, { recursive: true });
+}
+const executePy = (filepath, inputs) => {
+
+  const jobId = path.basename(filepath).split(".")[0];
+
+  // getting the output path where the ouput will be generated
+  const outPath = path.join(outputPath, `${jobId}.out`);
+
+  // creating input file path
+  const inputFilePath = path.join(outputPath, `${jobId}.txt`);
+  fs.writeFileSync(inputFilePath, inputs);
+  return new Promise((resolve, reject) => {
+    exec(
+      `python3 ${filepath} < ${inputFilePath}`,
+      (error, stdout, stderr) => {
+        fs.unlinkSync(inputFilePath);
+
+        if (error) {
+          reject({ error, stderr });
+        } else if (stderr) {
+          reject(stderr);
+        } else {
+          resolve(stdout);
+        }
+      }
+    );
+  });
+};
+
+module.exports = {
+  executePy,
+};

express_backend/src/code/code_execution/executePy.js

@@ -0,0 +1,36 @@
+const { exec } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const outputPath = path.join(__dirname, "outputs");
+
+if (!fs.existsSync(outputPath)) {
+    fs.mkdirSync(outputPath, { recursive: true });
+}
+
+const executeCpp = (filepath, inputs) => {
+    // getting the file name
+    const jobId = path.basename(filepath).split(".")[0];
+
+    // getting the output path where the ouput will be generated
+    const outPath = path.join(outputPath, `${jobId}.out`);
+
+    // creating input file path
+    const inputFilePath = path.join(outputPath, `${jobId}.txt`);
+    fs.writeFileSync(inputFilePath, inputs);
+
+    return new Promise((resolve, reject) => {
+        exec(
+            `g++ ${filepath} -o ${outPath} && cd ${outputPath} && ./${jobId}.out < ${inputFilePath}`,
+            (error, stdout, stderr) => {
+                error && reject({ error, stderr });
+                stderr && reject(stderr);
+                resolve(stdout);
+            }
+        );
+    });
+};
+
+module.exports = {
+    executeCpp,
+};

express_backend/src/code/code_execution/execute_cpp.js

@@ -0,0 +1,30 @@
+const fs = require("fs");
+const path = require("path");
+const { v4: uuid } = require("uuid");
+
+const dirCodes = path.join(__dirname, "generated_codes");
+
+if (!fs.existsSync(dirCodes)) {
+  fs.mkdirSync(dirCodes, { recursive: true });
+}
+
+const generateFile = async (format, content) => {
+
+  // generating random id
+  const jobId = uuid();
+
+  // generating name of the file
+  const filename = `${jobId}.${format}`;
+
+  // fetching file name
+  const filepath = path.join(dirCodes, filename);
+
+  // write incoming on the file
+  fs.writeFileSync(filepath, content);
+
+  return filepath;
+};
+
+module.exports = {
+  generateFile,
+};

express_backend/src/code/generateFile.js

@@ -0,0 +1,105 @@
+const { Queue, Worker } = require('bullmq');
+const jobs = require('../models/jobs');
+const { executeCpp } = require('./code_execution/execute_cpp');
+const { executePy } = require('./code_execution/executePy');
+const Problem = require('../models/problem_model');
+
+const getRedisClient = require('../config/get_redis_client');
+
+const redisClient = getRedisClient();
+
+// Create a new BullMQ queue
+const jobQueue = new Queue('job-queue', {
+    connection: redisClient
+});
+
+
+// Create a worker to process jobs
+const worker = new Worker('job-queue', async job => {
+    const jobId = job.data.id;
+    console.log(jobId)
+    const jobDoc = await jobs.findById(jobId);
+    if (!jobDoc) {
+        throw new Error(`Cannot find Job with id ${jobId}`);
+    }
+    const problemId = job.data.problemId;
+
+    const problem = await Problem.findOne({ id: problemId }).populate('testCases');
+
+    if (!problem) {
+        throw Error(`Cannot find Problem with id ${problemId}`);
+    }
+
+    console.log("Processing job:", job.data);
+
+    const mismatches = [];
+    try {
+        let output;
+        jobDoc.startedAt = new Date();
+
+        if (jobDoc.language === "cpp") {
+            for (const testCase of problem.testCases) {
+                output = await executeCpp(jobDoc.filepath, testCase.input);
+                if (output.trim() !== testCase.output.trim()) {
+                    mismatches.push({
+                        input: testCase.input,
+                        expectedOutput: testCase.output,
+                        actualOutput: output
+                    });
+                }
+            }
+        } else if (jobDoc.language === "py") {
+            output = await executePy(jobDoc.filepath);
+        }
+
+        jobDoc.completedAt = new Date();
+        jobDoc.output = output;
+        jobDoc.status = mismatches.length ? "error" : "success";
+        jobDoc.mismatches = mismatches;
+
+        await jobDoc.save();
+        return true;
+    } catch (err) {
+        jobDoc.completedAt = new Date();
+        jobDoc.output = JSON.stringify(err);
+        jobDoc.status = "error";
+        jobDoc.mismatches = mismatches;
+
+        await jobDoc.save();
+        throw err;
+    }
+}, {
+    connection: redisClient,
+    concurrency: 5
+});
+
+
+worker.on('failed', (job, err) => {
+    console.error(`Job ${job.id} failed with error:`, err);
+});
+
+process.on('SIGINT', async () => {
+    console.log('Shutting down gracefully...');
+    await worker.close();
+    await redisClient.quit();
+    process.exit(0);
+});
+
+// Add jobs to the queue
+const addJobToQueue = async ({ jobId, problemId, language, filepath }) => {
+    try {
+        await jobQueue.add('job', {
+            id: jobId,
+            problemId: problemId,
+            language: language,
+            filepath: filepath
+        });
+        console.log(`Added job ${jobId} to the queue.`);
+    } catch (err) {
+        console.error(`Error adding job ${jobId} to queue:`, err);
+    }
+}
+
+module.exports = {
+    addJobToQueue
+}

express_backend/src/code/job_queue.js

@@ -0,0 +1,80 @@
+const Queue = require('bull');
+const jobs = require('../models/jobs');
+const { executeCpp } = require('./code_execution/execute_cpp');
+const { executePy } = require('./code_execution/executePy');
+
+const jobQueuePlayground = new Queue('job-queue-playground');
+const NUM_WORKERS = 5;
+
+jobQueuePlayground.process(NUM_WORKERS, async ({ data }) => {
+    const jobId = data.id;
+
+    // finding the job with id of the job
+    const job = await jobs.findById(jobId);
+
+    // if job not found, throw error
+    if (job === undefined) {
+        throw Error(`cannot find Job with id ${jobId}`);
+    }
+
+
+    try {
+
+        let output;
+
+        // writing started at time
+        job["startedAt"] = new Date();
+
+        // 
+        if (job.language === "cpp") {
+
+            // executing code for C++
+            output = await executeCpp(job.filepath, data.inputs);
+
+        } else if (job.language === "py") {
+
+            // executing code for python
+            output = await executePy(job.filepath, data.inputs);
+        }
+
+        job["completedAt"] = new Date();
+
+        // setting up the output generated by the code
+        job["output"] = output;
+
+        // output generated -> success, job executed successfully
+        // doesn't matter if code contains error
+        // it just shows, wheather code entered executed correctly
+        // or not
+        job["status"] = "success";
+
+        // saving the job
+        await job.save();
+
+        return true;
+
+    } catch (err) {
+        job["completedAt"] = new Date();
+        job["output"] = JSON.stringify(err);
+        job["status"] = "error";
+        await job.save();
+        throw Error(JSON.stringify(err));
+    }
+})
+
+jobQueuePlayground.on("failed", (error) => {
+    console.error(error.data.id, error.failedReason);
+});
+
+const addJobToQueueForPlayground = async ({ jobId, inputs, language, filepath }) => {
+    await jobQueuePlayground.add({
+        id: jobId,
+        inputs: inputs,
+        language: language,
+        filepath: filepath
+    });
+}
+
+module.exports = {
+    addJobToQueueForPlayground
+}

express_backend/src/code/job_queue_playground.js

@@ -0,0 +1,18 @@
+const mongoose = require("mongoose");
+require("dotenv").config();
+
+const { MONGODB_URL } = process.env;
+
+exports.connect = () => {
+	mongoose
+		.connect(MONGODB_URL, {
+			useNewUrlparser: true,
+			useUnifiedTopology: true,
+		})
+		.then(console.log(`DB Connection Success`))
+		.catch((err) => {
+			console.log(`DB Connection Failed`);
+			console.log(err);
+			process.exit(1);
+		});
+};