Merge dev to main

.github/workflows/CI.yml

@@ -0,0 +1,105 @@
+# This is a basic workflow to help you get started with Actions
+
+name: CI
+
+# Controls when the workflow will run
+on:
+  # Triggers the workflow on push or pull request events but only for the "main" branch
+  push:
+    branches: [ "dev" ]
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - 'frontend/**'
+      - 'backend/**'
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "build"
+  build:
+    # The type of runner that the job will run on
+    runs-on: ubuntu-latest
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - uses: actions/checkout@v4
+
+      # Set up Node.js environment
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '23.6.0' # You can specify the Node.js version you need
+
+      # Runs a single command using the runners shell
+      - name: CI starting
+        run: | 
+          echo ⏳ CI testing begin...
+
+      - name: Install Dependencies
+        run: |
+          echo ⏳ install frontend dependencies...
+          cd ./frontend/
+          npm install
+          echo ✅ frontend dependencies installed!
+          echo ⏳ install backend dependencies...
+          cd ../backend/
+          npm install
+          echo ✅ backend dependencies installed!
+
+      - name: Building
+        run: | 
+          echo ⏳ Building...
+          cd ./frontend/
+          npm run build
+          echo ✅ Built!
+
+  frontend-testing:
+
+      runs-on: ubuntu-latest
+
+      steps:
+
+        - uses: actions/checkout@v4
+
+        # Deploy Render app
+        - name: Deploy Application
+          env:
+              deploy_url: ${{ secrets.RENDER_DEPLOY_HOOK_URL }}
+          run: |
+            echo ⏳ Frontend testing is setting up...
+            if [[ -z "$deploy_url" ]]; then
+              echo "❌ Error: deploy_url is not set!"
+              exit 1
+            fi
+            echo "⏳ Triggering deployment..."
+            curl -v "$deploy_url"
+            sleep 60
+            echo ✅ Application deployed!
+
+        - name: Run e2e testing
+          run: | 
+            echo ⏳ frontend e2e testing begin...
+            cd ./frontend/
+            npm i
+            npm run test:e2e
+            echo ✅ frontend e2e testing ended!
+
+  backend-testing:
+
+    runs-on: ubuntu-latest
+
+    steps: 
+
+      - uses: actions/checkout@v4
+
+      - name: Run API e2e testing
+        run: |
+          echo ⏳ API testing begin...
+          cd ./backend/
+          npm i
+          npm run test:e2e
+          echo ✅ backend e2e testing ended!

.gitignore

@@ -1,2 +1,32 @@
 .DS_Store
-.vscode/
+.vscode/
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+temp_user_data
+package-lock.json
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+# API files
+parsed_files
+.env

backend/index.js

@@ -0,0 +1,247 @@
+import express from 'express';
+import multer from 'multer';
+import { fileURLToPath } from 'url';
+import { dirname, join, extname } from 'path';
+import { promises as fs } from 'fs';
+import cors from 'cors';
+// import { resolve } from 'path';
+
+import { parseSDF } from './src/sdfProcess.js';
+import { parseVerilog } from './src/vProcess.js';
+import { mergeJsonForD3 } from './src/mergeVerilogSdf.js';
+
+export const app = express();
+const port = 3001;
+
+// Get absolute path
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Authorize CORS
+app.use(cors());
+app.use(express.json());
+
+// Configure multer for handling SDF file upload
+// Store file in memory, not on disk
+const storage = multer.memoryStorage(); 
+
+// Filter to verify file type
+const upload = multer({
+    storage: storage,
+    fileFilter: (req, file, cb) => {
+        // Définition des extensions autorisées PAR CHAMP
+        const fieldExtensionMap = {
+            sdfFile: ['.sdf'],
+            verilogFile: ['.v']
+        };
+
+        const fileExtension = extname(file.originalname).toLowerCase();
+        const allowedExtensions = fieldExtensionMap[file.fieldname];
+
+        // Vérifier si l'extension correspond au bon champ
+        if (allowedExtensions && allowedExtensions.includes(fileExtension)) {
+            cb(null, true);
+        } else {
+            req.fileValidationError = `Invalid file type for ${file.fieldname}, only ${allowedExtensions?.join(', ')} files are allowed!`;
+            cb(null, false);
+        }
+    },
+});
+
+
+// Endpoint for uploading and parsing SDF & Verilog file
+app.post('/api/upload', upload.fields([{ name: 'sdfFile' }, { name: 'verilogFile' }]), async (req, res) => {
+    try {
+        // Vérification des erreurs de validation de fichier
+        if (req.fileValidationError) {
+            return res.status(400).send(req.fileValidationError);
+        }   
+
+        const sdfFile = req.files?.['sdfFile']?.[0];
+        const verilogFile = req.files?.['verilogFile']?.[0];
+
+        // Check if files are uploaded
+        if (!sdfFile || !verilogFile) {
+            return res.status(400).send('Both SDF and Verilog files must be uploaded.');
+        }
+
+        const sdfContent = sdfFile.buffer.toString('utf-8').trim();
+        const verilogContent = verilogFile.buffer.toString('utf-8').trim();
+
+        if (!sdfContent || !verilogContent) {
+            return res.status(400).send('One or both uploaded files are empty.');
+        }
+
+        // Parse SDF and Verilog files
+        let sdfData, verilogData, commonInstances;
+        try {
+            sdfData = parseSDF(sdfContent);
+        } catch (error) {
+            return res.status(500).send('Error parsing SDF file.');
+        }
+
+        try {
+            verilogData = parseVerilog(verilogContent);
+        } catch (error) {
+            return res.status(500).send('Error parsing Verilog file.');
+        }
+
+        try {
+            commonInstances = mergeJsonForD3(verilogData, sdfData);
+        } catch (error) {
+            console.log('Error merging files:', error);
+
+            return res.status(500).send('Error merging files.');
+        }
+
+        // Save parsed SDF and Verilog files
+        try {
+            const projectName = req.body.projectName;
+            if (!projectName) {
+                return res.status(400).send('Project name is required.');
+            }
+
+            //try if folder 'parsed_files' exists
+            try {
+                await fs.access(join(__dirname, 'parsed_files'));
+            } catch (error) {
+                try {
+                    await fs.mkdir(join(__dirname, 'parsed_files'));
+                } catch (error) {
+                    return res.status(500).send('Error creating directory.');
+                }
+            }
+
+            const projectJSON_Path = join(__dirname, 'parsed_files', `${projectName}.json`);
+
+            //check if files exists
+            try {
+                // check if file exists
+                await fs.access(projectJSON_Path);
+                console.error('Project already exists');
+                return res.status(400).send('Project already exists');
+
+            } catch (error) {
+                try {
+                    await fs.writeFile(join(projectJSON_Path), JSON.stringify(commonInstances, null, 2));
+                    res.send('SDF and Verilog files successfully parsed and merged.');
+
+                } catch (error) {
+                    console.error('Error saving parsed JSON files:', error);
+                    res.status(500).send('Error saving parsed JSON files.');
+                }
+            }
+
+        } catch (error) {
+            console.log('Error saving parsed JSON files:', error);
+            res.status(500).send('Error saving parsed JSON files.');
+        }
+
+    } catch (error) {
+        res.status(500).send('Unexpected server error.');
+    }
+});
+
+
+// Endpoint API for sending parsed SDF file
+app.get('/api/map/:projectName', async (req, res) => {
+    try {
+        const projectName = req.params.projectName;
+        if (!projectName) {
+            return res.status(400).send('Project name is required.');
+        }
+
+        // Construct the file path using string concatenation
+        const jsonFilePath = join(__dirname, 'parsed_files', `${projectName}.json`);
+
+        // Check if the file exists
+        await fs.access(jsonFilePath);
+
+        // Read the file content
+        const jsonData = await fs.readFile(jsonFilePath, 'utf-8');
+        res.json(JSON.parse(jsonData));
+
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            // File does not exist
+            return res.status(404).send('File not found.');
+        }
+        console.error('Error reading parsed SDF JSON file:', error);
+        res.status(500).send('Error reading parsed SDF JSON file.');
+    }
+});
+
+// Endpoint to delete a parsed SDF JSON file
+app.delete('/api/delete-project/:projectName', async (req, res) => {
+    try {
+        const projectName = req.params.projectName;
+
+        // Validate projectName
+        if (!projectName || typeof projectName !== 'string') {
+            return res.status(400).send('Invalid project name.');
+        }
+
+        const projectPath = join(__dirname, 'parsed_files', `${projectName}.json`);
+
+        try {
+            // verify if file exists
+            await fs.access(projectPath);
+        } catch (err) {
+            // file does not exist
+            return res.status(404).send('File does not exist.');    
+        }
+
+        // Delete file
+        await fs.unlink(projectPath);
+        res.send('File deleted successfully.');
+
+    } catch (error) {
+        console.error('Error deleting file:', error);
+        res.status(500).send('Error deleting file, please try again later.');
+    }
+});
+
+
+// Endpoint to list all SDF files
+app.get('/api/list', async (req, res) => {
+    try {
+        const directoryPath = join(__dirname, 'parsed_files');
+        const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+
+        // Prepare an array to hold file information
+        const filesInfo = [];
+
+        // Iterate over entries to get file names and creation dates
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith('.json')) {
+                const filePath = join(directoryPath, entry.name);
+                const stats = await fs.stat(filePath);
+
+                // Format the date to only include the date part (YYYY-MM-DD)
+                const createdDate = stats.birthtime.toISOString().split('T')[0];
+
+                filesInfo.push({
+                    name: entry.name.replace('.json', ''),
+                    createdDate
+                });
+            }
+        }
+
+        res.json(filesInfo);
+    } catch (error) {
+        console.error('Error listing files:', error);
+        res.status(500).send('Error listing files.');
+    }
+});
+
+// Part of production code
+// app.use(express.static(join(__dirname, '../frontend/')));
+
+// app.get('*', (req, res) => {
+//     res.sendFile(resolve(__dirname, '../frontend/', 'index.html'));
+// });
+// 
+
+export const server = app.listen(port, () => {
+    console.log(`Backend launched on http://localhost:${port}`);
+});