jira-pat 1.0.0

package/backend/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "backend",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "test": "jest",
+    "test:coverage": "jest --coverage"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.13.6",
+    "cors": "^2.8.6",
+    "dotenv": "^17.3.1",
+    "express": "^5.2.1",
+    "express-rate-limit": "^8.3.1",
+    "form-data": "^4.0.5",
+    "multer": "^2.1.1",
+    "node-cache": "^5.1.2"
+  },
+  "devDependencies": {
+    "jest": "^30.3.0",
+    "supertest": "^7.2.2"
+  }
+}

package/backend/routes/issues.js

@@ -0,0 +1,246 @@
+const express = require('express');
+const multer = require('multer');
+const rateLimit = require('express-rate-limit');
+const router = express.Router();
+const jiraService = require('../service/jiraService');
+
+const upload = multer({ 
+    storage: multer.memoryStorage(),
+    limits: { fileSize: 10 * 1024 * 1024 }
+});
+
+const mutationLimiter = rateLimit({
+    windowMs: 60 * 1000,
+    max: 10,
+    standardHeaders: true,
+    legacyHeaders: false,
+    message: { error: 'Too many requests, please slow down.' },
+});
+
+const ISSUE_KEY_REGEX = /^[A-Z]+-\d+$/;
+const DANGEROUS_CHARS = /['";\\-]|--/g;
+
+const escapeJql = (str) => String(str).replace(/'/g, "\\'");
+
+const validateIssueKey = (key) => {
+    if (!ISSUE_KEY_REGEX.test(key)) {
+        return 'Invalid issue key format. Expected format: PROJECT-123';
+    }
+    return null;
+};
+
+// GET /api/issues
+router.get('/', async (req, res) => {
+    try {
+        if (req.query.search) {
+            req.query.search = String(req.query.search).replace(DANGEROUS_CHARS, '');
+        }
+        const data = await jiraService.searchIssues(req.query);
+        
+        if (!data || !data.issues || data.issues.length === 0) {
+            return res.status(200).json({ issues: [], total: 0, message: 'No issues found' });
+        }
+
+        res.json(data);
+    } catch (error) {
+        console.error('Error fetching issues:', error.message);
+        res.status(500).json({ 
+            error: 'Failed to fetch issues', 
+            details: error.message 
+        });
+    }
+});
+
+// POST /api/issues
+router.post('/', mutationLimiter, async (req, res) => {
+    try {
+        if (!req.body.summary || typeof req.body.summary !== 'string') {
+            return res.status(400).json({ error: 'Summary is required' });
+        }
+
+        const summary = req.body.summary.trim();
+        if (summary.length === 0) {
+            return res.status(400).json({ error: 'Summary cannot be empty' });
+        }
+
+        if (summary.length > 255) {
+            return res.status(400).json({ error: 'Summary must be under 255 characters' });
+        }
+
+        req.body.summary = summary;
+        const newIssue = await jiraService.createIssue(req.body);
+        res.status(201).json(newIssue);
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to create issue', details: error.message });
+    }
+});
+
+// GET /api/issues/labels
+router.get('/labels/search', async (req, res) => {
+    try {
+        const { query } = req.query;
+        const labels = await jiraService.searchLabels(query);
+        res.json(labels);
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to search labels', details: error.message });
+    }
+});
+
+// GET /api/issues/image/proxy
+router.get('/image/proxy', async (req, res) => {
+    try {
+        const { url } = req.query;
+        if (!url) return res.status(400).send('URL is required');
+
+        const remoteResponse = await jiraService.downloadAttachment(url);
+        // Relay headers (content-type)
+        if (remoteResponse.headers['content-type']) {
+            res.set('Content-Type', remoteResponse.headers['content-type']);
+        }
+        // Browser-only cache for 24 hours
+        res.set('Cache-Control', 'public, max-age=86400');
+        remoteResponse.data.pipe(res);
+    } catch (error) {
+        console.error('Error proxying image:', error.message);
+        res.status(500).send('Failed to fetch image');
+    }
+});
+
+// GET /api/issues/:issueKey
+router.get('/:issueKey', async (req, res) => {
+    const error = validateIssueKey(req.params.issueKey);
+    if (error) return res.status(400).json({ error });
+    
+    try {
+        const issue = await jiraService.getIssueDetail(req.params.issueKey);
+        res.json(issue);
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to fetch issue details', details: error.message });
+    }
+});
+
+// GET /api/issues/:issueKey/comments
+router.get('/:issueKey/comments', async (req, res) => {
+    const error = validateIssueKey(req.params.issueKey);
+    if (error) return res.status(400).json({ error });
+    
+    try {
+        const comments = await jiraService.getComments(req.params.issueKey);
+        res.json(comments);
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to fetch comments', details: error.message });
+    }
+});
+
+// POST /api/issues/:issueKey/comments
+router.post('/:issueKey/comments', mutationLimiter, async (req, res) => {
+    const error = validateIssueKey(req.params.issueKey);
+    if (error) return res.status(400).json({ error });
+    
+    try {
+        const { body } = req.body;
+        if (!body || !body.trim()) {
+            return res.status(400).json({ error: 'Comment body cannot be empty' });
+        }
+        
+        const comment = await jiraService.addComment(req.params.issueKey, body);
+        res.status(201).json(comment);
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to post comment', details: error.message });
+    }
+});
+
+// GET /api/issues/:issueKey/transitions
+router.get('/:issueKey/transitions', async (req, res) => {
+    const error = validateIssueKey(req.params.issueKey);
+    if (error) return res.status(400).json({ error });
+    
+    try {
+        const transitions = await jiraService.getTransitions(req.params.issueKey);
+        res.json(transitions);
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to fetch transitions', details: error.message });
+    }
+});
+
+// POST /api/issues/:issueKey/transitions
+router.post('/:issueKey/transitions', mutationLimiter, async (req, res) => {
+    const error = validateIssueKey(req.params.issueKey);
+    if (error) return res.status(400).json({ error });
+    
+    try {
+        const { transitionId } = req.body;
+        if (!transitionId) return res.status(400).json({ error: 'transitionId is required' });
+        await jiraService.transitionIssue(req.params.issueKey, transitionId);
+        res.json({ success: true });
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to transition issue', details: error.message });
+    }
+});
+
+// GET /api/issues/:issueKey/assignable
+router.get('/:issueKey/assignable', async (req, res) => {
+    const error = validateIssueKey(req.params.issueKey);
+    if (error) return res.status(400).json({ error });
+    
+    try {
+        const { query } = req.query;
+        const users = await jiraService.getAssignableUsers(req.params.issueKey, query);
+        res.json(users);
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to fetch assignable users', details: error.message });
+    }
+});
+
+// PUT /api/issues/:issueKey/assignee
+router.put('/:issueKey/assignee', mutationLimiter, async (req, res) => {
+    const error = validateIssueKey(req.params.issueKey);
+    if (error) return res.status(400).json({ error });
+    
+    try {
+        const { accountId } = req.body;
+        await jiraService.assignIssue(req.params.issueKey, accountId);
+        res.json({ success: true });
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to assign issue', details: error.message });
+    }
+});
+
+// POST /api/issues/:issueKey/attachments
+router.post('/:issueKey/attachments', mutationLimiter, upload.single('file'), async (req, res) => {
+    const error = validateIssueKey(req.params.issueKey);
+    if (error) return res.status(400).json({ error });
+    
+    try {
+        if (!req.file) {
+            return res.status(400).json({ error: 'No file uploaded' });
+        }
+        
+        const attachments = await jiraService.attachFile(
+            req.params.issueKey, 
+            req.file.buffer, 
+            req.file.originalname, 
+            req.file.mimetype
+        );
+        res.status(201).json(attachments);
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to upload attachment', details: error.message });
+    }
+});
+
+// PUT /api/issues/:issueKey
+router.put('/:issueKey', mutationLimiter, async (req, res) => {
+    const error = validateIssueKey(req.params.issueKey);
+    if (error) return res.status(400).json({ error });
+    
+    try {
+        const { fields } = req.body;
+        if (!fields) return res.status(400).json({ error: 'fields are required' });
+        await jiraService.updateIssue(req.params.issueKey, fields);
+        res.json({ success: true });
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to update issue', details: error.message });
+    }
+});
+
+module.exports = router;

package/backend/routes/projects.js

@@ -0,0 +1,35 @@
+const express = require('express');
+const router = express.Router();
+const jiraService = require('../service/jiraService');
+
+// GET /api/projects
+router.get('/', async (req, res) => {
+    try {
+        const projects = await jiraService.getProjects();
+        res.json(projects);
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to fetch projects', details: error.message });
+    }
+});
+
+// GET /api/projects/:projectKey/issuetypes
+router.get('/:projectKey/issuetypes', async (req, res) => {
+    try {
+        const types = await jiraService.getIssueTypes(req.params.projectKey);
+        res.json(types);
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to fetch issue types', details: error.message });
+    }
+});
+
+// GET /api/projects/:projectKey/versions
+router.get('/:projectKey/versions', async (req, res) => {
+    try {
+        const versions = await jiraService.getProjectVersions(req.params.projectKey);
+        res.json(versions);
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to fetch versions', details: error.message });
+    }
+});
+
+module.exports = router;