20 new API endpoints

.gitea/workflows/release.yml

@@ -0,0 +1,28 @@
+name: Build Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Login to Gitea Registry
+        run: |
+          echo "${{ secrets.REGISTRY_PASSWORD }}" | \
+          docker login https://gitea.johannesbot.de -u ${{ secrets.REGISTRY_USER }} --password-stdin
+
+      - name: Extract Tag
+        id: tag
+        run: echo "VERSION=${GITHUB_REF#refs/tags/v}" >> "$GITHUB_OUTPUT"
+
+      - name: Build Image
+        run: docker build -t gitea.johannesbot.de/johannesbot/stupid-apis:${{ steps.tag.outputs.VERSION }} .
+
+      - name: Push Image
+        run: docker push gitea.johannesbot.de/johannesbot/stupid-apis:${{ steps.tag.outputs.VERSION }}

.gitignore

@@ -2,3 +2,5 @@ node_modules
 test.*
 *.log
 .idea
+
+package-lock.json

Dockerfile

@@ -1,5 +1,5 @@
 # Basis-Image
-FROM node:20
+FROM node:24.14
 
 # Arbeitsverzeichnis
 WORKDIR /app

doc/api.md

@@ -1,158 +0,0 @@
-
-# 📄 API Documentation – **Stupid APIs**
-
-## Base URL
-
-```
-http://localhost:3000/api
-```
-
-**Default Headers:**
-
-```
-Content-Type: application/json
-```
-
----
-
-## POST `/sort`
-
-Sorts an array (numeric or alphabetical) and returns the sorted array.
-
-### Request
-
-**URL:**
-
-```
-POST /sort
-```
-
-
-**Body Example:**
-
-```json
-{
-  "input": [3, 1, 4, 1, 5, 9]
-}
-```
-
-### Successful Response
-
-```json
-{
-  "sortedArray": [1, 1, 3, 4, 5, 9]
-}
-```
-
-
-## POST `/isOdd`
-
-Checks if a given number is odd.
-
-### Request
-
-**URL:**
-
-```
-POST /isOdd
-```
-
-**Body Example:**
-
-```json
-{
-  "input": 7
-}
-```
-
-### Successful Response
-
-```json
-{
-  "ret": true
-}
-```
-
----
-
-## POST `/isEven`
-
-Checks if a given number is even.
-
-### Request
-
-**URL:**
-
-```
-POST /isEven
-```
-
-**Body Example:**
-
-```json
-{
-  "input": 4
-}
-```
-
-### Successful Response
-
-```json
-{
-  "ret": true
-}
-```
-
-## POST `/toString`
-
-calls .toString()
-
-### Request
-
-**URL:**
-
-```
-POST /toString
-```
-
-**Body Example:**
-
-```json
-{
-  "input": 7
-}
-```
-
-### Successful Response
-
-```json
-{
-  "ret": "7"
-}
-```
-
-## 📌 Example Usage with `curl`
-
-### Sort an array (Linux/macOS)
-
-```bash
-curl -X POST http://localhost:3000/sort \
-  -H "Content-Type: application/json" \
-  -d '{"array":[3,1,4,1,5,9]}'
-```
-
-### Check if odd
-
-```bash
-curl -X POST http://localhost:3000/is-odd \
-  -H "Content-Type: application/json" \
-  -d '{"number":7}'
-```
-
-### Check if even
-
-```bash
-curl -X POST http://localhost:3000/is-even \
-  -H "Content-Type: application/json" \
-  -d '{"number":4}'
-```

nginx.conf

@@ -1,23 +0,0 @@
-events {}
-
-http {
-  upstream stupid_apis {
-    server stupid-apis-1:3000;
-    server stupid-apis-2:3000;
-    server stupid-apis-3:3000;
-  }
-
-  server {
-    listen 80;
-
-    location / {
-      proxy_pass http://stupid_apis;
-      proxy_http_version 1.1;
-      proxy_set_header Upgrade $http_upgrade;
-      proxy_set_header Connection 'upgrade';
-      proxy_set_header Host $host;
-      proxy_cache_bypass $http_upgrade;
-    }
-  }
-}
-

package.json

@@ -7,11 +7,11 @@
     "start": "node src/server.js"
   },
   "dependencies": {
-    "express": "^4.18.2",
     "body-parser": "^1.20.2",
+    "express": "^4.18.2",
     "is-even": "^1.0.0",
     "is-odd": "^3.0.1",
-    "showdown": "^2.1.0",
+    "swagger-jsdoc": "^6.2.8",
-    "fs": "^0.0.1-security"
+    "swagger-ui-express": "^5.0.1"
   }
 }

src/routes/api/array/arrayMax.js

@@ -0,0 +1,11 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    if (!Array.isArray(input) || input.length === 0)
+        return res.status(400).json({ error: 'input must be a non-empty array' });
+    res.json({ ret: Math.max(...input.map(Number)) });
+});
+
+module.exports = router;

src/routes/api/array/arrayMin.js

@@ -0,0 +1,11 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    if (!Array.isArray(input) || input.length === 0)
+        return res.status(400).json({ error: 'input must be a non-empty array' });
+    res.json({ ret: Math.min(...input.map(Number)) });
+});
+
+module.exports = router;

src/routes/api/array/arrayUnique.js

@@ -0,0 +1,10 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    if (!Array.isArray(input)) return res.status(400).json({ error: 'input must be an array' });
+    res.json({ ret: [...new Set(input)] });
+});
+
+module.exports = router;

src/routes/api/array/average.js

@@ -0,0 +1,11 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    if (!Array.isArray(input) || input.length === 0)
+        return res.status(400).json({ error: 'input must be a non-empty array' });
+    res.json({ ret: input.reduce((acc, n) => acc + Number(n), 0) / input.length });
+});
+
+module.exports = router;

src/routes/api/array/reverseArray.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+
+    if (!Array.isArray(input)) {
+        return res.status(400).json({ error: 'input must be an array' });
+    }
+
+    res.json({ ret: [...input].reverse() });
+});
+
+module.exports = router;

src/routes/api/array/sort.js

@@ -15,7 +15,7 @@ router.post('/', (req, res) => {
         return String(a).localeCompare(String(b));
     });
 
-    res.json({ sortedArray });
+    res.json({ ret: sortedArray });
 });
 
 module.exports = router;

src/routes/api/array/sum.js

@@ -0,0 +1,10 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    if (!Array.isArray(input)) return res.status(400).json({ error: 'input must be an array' });
+    res.json({ ret: input.reduce((acc, n) => acc + Number(n), 0) });
+});
+
+module.exports = router;

src/routes/api/checks/isEven.js

@@ -4,13 +4,11 @@ const router = express.Router();
 
 router.post('/', (req, res) => {
     const { input } = req.body;
-
     res.json({ ret: isEven(Number(input)) });
 });
 
 router.get('/:number', (req, res) => {
     const input = req.params.number;
-
     res.json({ ret: isEven(Number(input)) });
 });
 

src/routes/api/checks/isNumber.js

@@ -3,13 +3,11 @@ const router = express.Router();
 
 router.post('/', (req, res) => {
     const { input } = req.body;
-
     res.json({ ret: !isNaN(input) });
 });
 
 router.get('/:number', (req, res) => {
     const input = req.params.number;
-
     res.json({ ret: !isNaN(input) });
 });
 

src/routes/api/checks/isOdd.js

@@ -4,13 +4,11 @@ const router = express.Router();
 
 router.post('/', (req, res) => {
     const { input } = req.body;
-
     res.json({ ret: isOdd(Number(input)) });
 });
 
 router.get('/:number', (req, res) => {
     const input = req.params.number;
-
     res.json({ ret: isOdd(Number(input)) });
 });
 

src/routes/api/index.js

@@ -0,0 +1,59 @@
+const express = require('express');
+const router = express.Router();
+
+// Math
+router.use('/add', require('./math/add'));
+router.use('/subtract', require('./math/subtract'));
+router.use('/multiply', require('./math/multiply'));
+router.use('/divide', require('./math/divide'));
+router.use('/modulo', require('./math/modulo'));
+router.use('/power', require('./math/power'));
+router.use('/abs', require('./math/abs'));
+router.use('/factorial', require('./math/factorial'));
+router.use('/isPrime', require('./math/isPrime'));
+
+// String
+router.use('/toString', require('./string/toString'));
+router.use('/stringSplit', require('./string/stringSplit'));
+router.use('/reverseString', require('./string/reverseString'));
+router.use('/isPalindrome', require('./string/isPalindrome'));
+router.use('/stringLength', require('./string/stringLength'));
+router.use('/countWords', require('./string/countWords'));
+router.use('/toUpperCase', require('./string/toUpperCase'));
+router.use('/toLowerCase', require('./string/toLowerCase'));
+router.use('/repeat', require('./string/repeat'));
+router.use('/trimString', require('./string/trimString'));
+router.use('/stringContains', require('./string/stringContains'));
+router.use('/randomCase', require('./string/randomCase'));
+
+// Array
+router.use('/sort', require('./array/sort'));
+router.use('/reverseArray', require('./array/reverseArray'));
+router.use('/sum', require('./array/sum'));
+router.use('/average', require('./array/average'));
+router.use('/arrayMax', require('./array/arrayMax'));
+router.use('/arrayMin', require('./array/arrayMin'));
+router.use('/arrayUnique', require('./array/arrayUnique'));
+
+// Checks
+router.use('/isEven', require('./checks/isEven'));
+router.use('/isOdd', require('./checks/isOdd'));
+router.use('/isNumber', require('./checks/isNumber'));
+
+// Misc
+router.use('/coinFlip', require('./misc/coinFlip'));
+router.use('/diceRoll', require('./misc/diceRoll'));
+router.use('/fizzBuzz', require('./misc/fizzBuzz'));
+
+// Meme sorts
+router.use('/stalinSort', require('./sorts/stalinSort'));
+router.use('/bogoSort', require('./sorts/bogoSort'));
+router.use('/thanoSort', require('./sorts/thanoSort'));
+router.use('/sleepSort', require('./sorts/sleepSort'));
+router.use('/miracleSort', require('./sorts/miracleSort'));
+router.use('/intelligentDesignSort', require('./sorts/intelligentDesignSort'));
+router.use('/quantumSort', require('./sorts/quantumSort'));
+router.use('/pancakeSort', require('./sorts/pancakeSort'));
+router.use('/gnomeSort', require('./sorts/gnomeSort'));
+
+module.exports = router;

src/routes/api/math/abs.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: Math.abs(Number(input)) });
+});
+
+router.get('/:n', (req, res) => {
+    res.json({ ret: Math.abs(Number(req.params.n)) });
+});
+
+module.exports = router;

src/routes/api/math/add.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: input.a + input.b });
+});
+
+router.get('/:a/:b', (req, res) => {
+    res.json({ ret: Number(req.params.a) + Number(req.params.b) });
+});
+
+module.exports = router;

src/routes/api/math/divide.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: input.a / input.b });
+});
+
+router.get('/:a/:b', (req, res) => {
+    res.json({ ret: Number(req.params.a) / Number(req.params.b) });
+});
+
+module.exports = router;

src/routes/api/math/factorial.js

@@ -0,0 +1,23 @@
+const express = require('express');
+const router = express.Router();
+
+function factorial(n) {
+    if (n === 0 || n === 1) return 1;
+    let result = 1;
+    for (let i = 2; i <= n; i++) result *= i;
+    return result;
+}
+
+router.post('/', (req, res) => {
+    const n = Math.floor(Number(req.body.input));
+    if (n < 0 || n > 170) return res.status(400).json({ error: 'n must be between 0 and 170' });
+    res.json({ ret: factorial(n) });
+});
+
+router.get('/:n', (req, res) => {
+    const n = Math.floor(Number(req.params.n));
+    if (n < 0 || n > 170) return res.status(400).json({ error: 'n must be between 0 and 170' });
+    res.json({ ret: factorial(n) });
+});
+
+module.exports = router;

src/routes/api/math/isPrime.js

@@ -0,0 +1,23 @@
+const express = require('express');
+const router = express.Router();
+
+function isPrime(n) {
+    if (n < 2) return false;
+    if (n === 2) return true;
+    if (n % 2 === 0) return false;
+    for (let i = 3; i <= Math.sqrt(n); i += 2) {
+        if (n % i === 0) return false;
+    }
+    return true;
+}
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: isPrime(Math.floor(Number(input))) });
+});
+
+router.get('/:n', (req, res) => {
+    res.json({ ret: isPrime(Math.floor(Number(req.params.n))) });
+});
+
+module.exports = router;

src/routes/api/math/modulo.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: input.a % input.b });
+});
+
+router.get('/:a/:b', (req, res) => {
+    res.json({ ret: Number(req.params.a) % Number(req.params.b) });
+});
+
+module.exports = router;

src/routes/api/math/multiply.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: input.a * input.b });
+});
+
+router.get('/:a/:b', (req, res) => {
+    res.json({ ret: Number(req.params.a) * Number(req.params.b) });
+});
+
+module.exports = router;

src/routes/api/math/power.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: Math.pow(input.a, input.b) });
+});
+
+router.get('/:a/:b', (req, res) => {
+    res.json({ ret: Math.pow(Number(req.params.a), Number(req.params.b)) });
+});
+
+module.exports = router;

src/routes/api/math/subtract.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: input.a - input.b });
+});
+
+router.get('/:a/:b', (req, res) => {
+    res.json({ ret: Number(req.params.a) - Number(req.params.b) });
+});
+
+module.exports = router;

src/routes/api/misc/coinFlip.js

@@ -0,0 +1,8 @@
+const express = require('express');
+const router = express.Router();
+
+router.get('/', (req, res) => {
+    res.json({ ret: Math.random() < 0.5 ? 'heads' : 'tails' });
+});
+
+module.exports = router;

src/routes/api/misc/diceRoll.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.get('/', (req, res) => {
+    res.json({ ret: Math.floor(Math.random() * 6) + 1 });
+});
+
+router.get('/:sides', (req, res) => {
+    const sides = Math.max(2, Math.floor(Number(req.params.sides)));
+    res.json({ ret: Math.floor(Math.random() * sides) + 1, sides });
+});
+
+module.exports = router;

src/routes/api/misc/fizzBuzz.js

@@ -0,0 +1,20 @@
+const express = require('express');
+const router = express.Router();
+
+function fizzBuzz(n) {
+    if (n % 15 === 0) return 'FizzBuzz';
+    if (n % 3 === 0) return 'Fizz';
+    if (n % 5 === 0) return 'Buzz';
+    return n;
+}
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: fizzBuzz(Number(input)) });
+});
+
+router.get('/:n', (req, res) => {
+    res.json({ ret: fizzBuzz(Number(req.params.n)) });
+});
+
+module.exports = router;

src/routes/api/sorts/bogoSort.js

@@ -0,0 +1,43 @@
+const express = require('express');
+const router = express.Router();
+
+function isSorted(arr) {
+    for (let i = 1; i < arr.length; i++) {
+        if (arr[i] < arr[i - 1]) return false;
+    }
+    return true;
+}
+
+function shuffle(arr) {
+    const a = [...arr];
+    for (let i = a.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [a[i], a[j]] = [a[j], a[i]];
+    }
+    return a;
+}
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+
+    if (!Array.isArray(input)) {
+        return res.status(400).json({ error: 'input must be an array' });
+    }
+
+    const MAX_ATTEMPTS = 1000;
+    let arr = [...input];
+    let attempts = 0;
+
+    while (!isSorted(arr) && attempts < MAX_ATTEMPTS) {
+        arr = shuffle(arr);
+        attempts++;
+    }
+
+    res.json({
+        ret: arr,
+        attempts,
+        success: isSorted(arr)
+    });
+});
+
+module.exports = router;

src/routes/api/sorts/gnomeSort.js

@@ -0,0 +1,25 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    if (!Array.isArray(input)) return res.status(400).json({ error: 'input must be an array' });
+
+    const arr = [...input];
+    let pos = 0;
+    let moves = 0;
+
+    while (pos < arr.length) {
+        if (pos === 0 || arr[pos] >= arr[pos - 1]) {
+            pos++;
+        } else {
+            [arr[pos], arr[pos - 1]] = [arr[pos - 1], arr[pos]];
+            pos--;
+            moves++;
+        }
+    }
+
+    res.json({ ret: arr, moves });
+});
+
+module.exports = router;

src/routes/api/sorts/intelligentDesignSort.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    if (!Array.isArray(input)) return res.status(400).json({ error: 'input must be an array' });
+    res.json({
+        ret: input,
+        message: 'The array has been sorted by a higher power. Who are we to question it?'
+    });
+});
+
+module.exports = router;

src/routes/api/sorts/miracleSort.js

@@ -0,0 +1,25 @@
+const express = require('express');
+const router = express.Router();
+
+function isSorted(arr) {
+    for (let i = 1; i < arr.length; i++) {
+        if (arr[i] < arr[i - 1]) return false;
+    }
+    return true;
+}
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+
+    if (!Array.isArray(input)) {
+        return res.status(400).json({ error: 'input must be an array' });
+    }
+
+    if (isSorted(input)) {
+        res.json({ ret: input, miracle: true, message: 'A miracle has occurred!' });
+    } else {
+        res.json({ ret: input, miracle: false, message: 'Waiting for cosmic miracle... Please try again later.' });
+    }
+});
+
+module.exports = router;

src/routes/api/sorts/pancakeSort.js

@@ -0,0 +1,35 @@
+const express = require('express');
+const router = express.Router();
+
+function flip(arr, k) {
+    let left = 0;
+    while (left < k) {
+        [arr[left], arr[k]] = [arr[k], arr[left]];
+        left++;
+        k--;
+    }
+}
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    if (!Array.isArray(input)) return res.status(400).json({ error: 'input must be an array' });
+
+    const arr = [...input];
+    const flips = [];
+
+    for (let size = arr.length; size > 1; size--) {
+        const maxIdx = arr.slice(0, size).indexOf(Math.max(...arr.slice(0, size)));
+        if (maxIdx !== size - 1) {
+            if (maxIdx !== 0) {
+                flip(arr, maxIdx);
+                flips.push(maxIdx + 1);
+            }
+            flip(arr, size - 1);
+            flips.push(size);
+        }
+    }
+
+    res.json({ ret: arr, flips, totalFlips: flips.length });
+});
+
+module.exports = router;

src/routes/api/sorts/quantumSort.js

@@ -0,0 +1,15 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    if (!Array.isArray(input)) return res.status(400).json({ error: 'input must be an array' });
+    res.json({
+        ret: [...input].sort((a, b) => a - b),
+        universeCollapsed: true,
+        parallelUniversesDestroyed: Math.pow(2, input.length),
+        message: 'Wave function collapsed successfully. All other quantum states have been discarded.'
+    });
+});
+
+module.exports = router;

src/routes/api/sorts/sleepSort.js

@@ -0,0 +1,21 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+
+    if (!Array.isArray(input)) {
+        return res.status(400).json({ error: 'input must be an array' });
+    }
+
+    const sorted = [...input].sort((a, b) => a - b);
+    const totalSleepMs = input.reduce((sum, n) => sum + Math.abs(Number(n)), 0);
+
+    res.json({
+        ret: sorted,
+        totalSleepTimeMs: totalSleepMs,
+        note: "We simulated the sleep. You're welcome."
+    });
+});
+
+module.exports = router;

src/routes/api/sorts/stalinSort.js

@@ -0,0 +1,29 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+
+    if (!Array.isArray(input)) {
+        return res.status(400).json({ error: 'Request body muss ein Feld "array" mit einem Array enthalten' });
+    }
+
+    const sortedArray = Array();
+    sortedArray.push(input[0]);
+    let executions = 0;
+
+    for (let i = 1; i < input.length; i++) {
+        if (input[i] > input[i - 1]) {
+            sortedArray.push(input[i]);
+        } else {
+            executions++;
+        }
+    }
+
+    res.json({
+        ret: sortedArray,
+        executions
+    });
+});
+
+module.exports = router;

src/routes/api/sorts/thanoSort.js

@@ -0,0 +1,38 @@
+const express = require('express');
+const router = express.Router();
+
+function isSorted(arr) {
+    for (let i = 1; i < arr.length; i++) {
+        if (arr[i] < arr[i - 1]) return false;
+    }
+    return true;
+}
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+
+    if (!Array.isArray(input)) {
+        return res.status(400).json({ error: 'input must be an array' });
+    }
+
+    let arr = [...input];
+    let snaps = 0;
+
+    while (!isSorted(arr) && arr.length > 1) {
+        const survivors = Math.ceil(arr.length / 2);
+        const indices = new Set();
+        while (indices.size < survivors) {
+            indices.add(Math.floor(Math.random() * arr.length));
+        }
+        arr = arr.filter((_, i) => indices.has(i));
+        snaps++;
+    }
+
+    res.json({
+        ret: arr,
+        snaps,
+        perfectly_balanced: isSorted(arr)
+    });
+});
+
+module.exports = router;

src/routes/api/string/countWords.js

@@ -0,0 +1,17 @@
+const express = require('express');
+const router = express.Router();
+
+function countWords(str) {
+    return String(str).trim().split(/\s+/).filter(w => w.length > 0).length;
+}
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: countWords(input) });
+});
+
+router.get('/:string', (req, res) => {
+    res.json({ ret: countWords(req.params.string) });
+});
+
+module.exports = router;

src/routes/api/string/isPalindrome.js

@@ -0,0 +1,18 @@
+const express = require('express');
+const router = express.Router();
+
+function checkPalindrome(str) {
+    const clean = String(str).toLowerCase().replace(/[^a-z0-9]/g, '');
+    return clean === clean.split('').reverse().join('');
+}
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: checkPalindrome(input) });
+});
+
+router.get('/:string', (req, res) => {
+    res.json({ ret: checkPalindrome(req.params.string) });
+});
+
+module.exports = router;

src/routes/api/string/randomCase.js

@@ -0,0 +1,19 @@
+const express = require('express');
+const router = express.Router();
+
+function randomCase(str) {
+    return String(str).split('').map(c =>
+        Math.random() > 0.5 ? c.toUpperCase() : c.toLowerCase()
+    ).join('');
+}
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: randomCase(input) });
+});
+
+router.get('/:string', (req, res) => {
+    res.json({ ret: randomCase(req.params.string) });
+});
+
+module.exports = router;

src/routes/api/string/repeat.js

@@ -0,0 +1,10 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    const times = Math.min(Math.max(0, Math.floor(Number(input.times))), 1000);
+    res.json({ ret: String(input.string).repeat(times) });
+});
+
+module.exports = router;

src/routes/api/string/reverseString.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: String(input).split('').reverse().join('') });
+});
+
+router.get('/:string', (req, res) => {
+    res.json({ ret: req.params.string.split('').reverse().join('') });
+});
+
+module.exports = router;

src/routes/api/string/stringContains.js

@@ -0,0 +1,9 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: String(input.string).includes(String(input.search)) });
+});
+
+module.exports = router;

src/routes/api/string/stringLength.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: String(input).length });
+});
+
+router.get('/:string', (req, res) => {
+    res.json({ ret: req.params.string.length });
+});
+
+module.exports = router;

src/routes/api/string/stringSplit.js

@@ -3,7 +3,6 @@ const router = express.Router();
 
 router.post('/', (req, res) => {
     const { input } = req.body;
-
     res.json({ ret: input.string.toString().split(input.seperator) });
 });
 

src/routes/api/string/toLowerCase.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: String(input).toLowerCase() });
+});
+
+router.get('/:string', (req, res) => {
+    res.json({ ret: req.params.string.toLowerCase() });
+});
+
+module.exports = router;

src/routes/api/string/toString.js

@@ -3,7 +3,6 @@ const router = express.Router();
 
 router.post('/', (req, res) => {
     const { input } = req.body;
-
     res.json({ ret: input.toString() });
 });
 

src/routes/api/string/toUpperCase.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: String(input).toUpperCase() });
+});
+
+router.get('/:string', (req, res) => {
+    res.json({ ret: req.params.string.toUpperCase() });
+});
+
+module.exports = router;

src/routes/api/string/trimString.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+router.post('/', (req, res) => {
+    const { input } = req.body;
+    res.json({ ret: String(input).trim() });
+});
+
+router.get('/:string', (req, res) => {
+    res.json({ ret: req.params.string.trim() });
+});
+
+module.exports = router;

src/routes/docs/main.js

@@ -1,41 +1,9 @@
 const express = require('express');
-const showdown = require('showdown');
-const fs = require('fs');
-const path = require('path');
-
-const converter = new showdown.Converter({
-    tables: true,          // Tabellen-Unterstützung aktivieren
-    ghCompatibleHeaderId: true,
-    simpleLineBreaks: true,
-    emoji: true
-});
 const router = express.Router();
+const swaggerUi = require('swagger-ui-express');
+const openAPI = require('./openapi.json');
 
-router.get('/', (req, res) => {
+router.use('/', swaggerUi.serve);
-    const filePath = path.join(__dirname, '../../../doc/api.md');
+router.get('/', swaggerUi.setup(openAPI));
-
-    fs.readFile(filePath, 'utf-8', (err, data) => {
-        if (err) {
-            console.error(err);
-            return res.status(500).send("Fehler beim Laden der Markdown-Datei");
-        }
-
-        const htmlContent = converter.makeHtml(data);
-        res.set('Content-Type', 'text/html; charset=utf-8');
-        res.send(`<!doctype html>
-<html lang="de">
-<head>
-  <meta charset="utf-8" />
-  <title>API-Dokumentation</title>
-  <link rel="stylesheet" href="/css/markdown-dark.css">
-</head>
-<body>
-  <main class="markdown-body">
-    ${htmlContent}
-  </main>
-</body>
-</html>`);
-    });
-});
 
 module.exports = router;

src/server.js

@@ -1,27 +1,16 @@
 const express = require('express');
 const bodyParser = require('body-parser');
 const path = require('path');
-const sortRoute = require('./routes/api/sort');
+
-const isEvenRoute = require('./routes/api/isEven');
+const apiRoutes = require('./routes/api');
-const isOddRoute = require('./routes/api/isOdd');
-const toStringRoute = require('./routes/api/toString');
-const isNumberRoute = require('./routes/api/isNumber');
-const stringSplitRoute = require('./routes/api/stringSplit');
 const docsRoute = require('./routes/docs/main');
 
 const app = express();
-
 const PORT = 3000;
 
 app.use(express.static(path.join(__dirname, '../www')));
-
 app.use(bodyParser.json());
-app.use('/api/sort', sortRoute);
+app.use('/api', apiRoutes);
-app.use('/api/isEven', isEvenRoute);
-app.use('/api/isOdd', isOddRoute);
-app.use('/api/toString', toStringRoute);
-app.use('/api/isNumber', isNumberRoute);
-app.use('/api/stringSplit', stringSplitRoute);
 app.use('/docs', docsRoute);
 
 app.listen(PORT, () => {

www/css/markdown-dark.css

@@ -1,194 +0,0 @@
-/* markdown-dark.css */
-/* Basis: neutraler Dark-Mode mit guter Lesbarkeit und sauberem Tabellenlayout */
-:root {
-    --bg: #0d1117;
-    --bg-muted: #161b22;
-    --text: #c9d1d9;
-    --text-muted: #8b949e;
-    --border: #30363d;
-    --link: #58a6ff;
-    --code-bg: #161b22;
-    --code-text: #f0f6fc;
-    --kbd-bg: #0b1020;
-    --kbd-border: #30363d;
-    --accent: #1f6feb;
-}
-
-html, body {
-    background: var(--bg);
-    color: var(--text);
-    margin: 0;
-    padding: 0;
-}
-
-.markdown-body {
-    box-sizing: border-box;
-    max-width: 900px;
-    margin: 0 auto;
-    padding: 24px;
-    line-height: 1.65;
-    font: 16px/1.65 system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, "Helvetica Neue", Arial, "Apple Color Emoji","Segoe UI Emoji";
-}
-
-/* Überschriften */
-.markdown-body h1,
-.markdown-body h2,
-.markdown-body h3,
-.markdown-body h4,
-.markdown-body h5,
-.markdown-body h6 {
-    color: var(--text);
-    margin: 1.6em 0 .6em;
-    font-weight: 700;
-    line-height: 1.25;
-    border-bottom: 1px solid var(--border);
-    padding-bottom: .3em;
-}
-.markdown-body h1 { font-size: 2rem; }
-.markdown-body h2 { font-size: 1.6rem; }
-.markdown-body h3 { font-size: 1.35rem; border-bottom: none; }
-.markdown-body h4 { font-size: 1.15rem; border-bottom: none; }
-.markdown-body h5 { font-size: 1rem; border-bottom: none; }
-.markdown-body h6 { font-size: .95rem; color: var(--text-muted); border-bottom: none; }
-
-/* Text & Links */
-.markdown-body p, .markdown-body ul, .markdown-body ol, .markdown-body blockquote, .markdown-body pre, .markdown-body table {
-    margin: 1em 0;
-}
-.markdown-body a {
-    color: var(--link);
-    text-decoration: none;
-}
-.markdown-body a:hover, .markdown-body a:focus {
-    text-decoration: underline;
-}
-
-/* Listen */
-.markdown-body ul, .markdown-body ol {
-    padding-left: 1.5em;
-}
-.markdown-body li + li {
-    margin-top: .25em;
-}
-
-/* Code */
-.markdown-body code,
-.markdown-body tt {
-    background: var(--code-bg);
-    color: var(--code-text);
-    padding: .15em .35em;
-    border-radius: 6px;
-    border: 1px solid var(--border);
-    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
-    font-size: .95em;
-}
-.markdown-body pre {
-    background: var(--code-bg);
-    border: 1px solid var(--border);
-    border-radius: 8px;
-    padding: 12px 14px;
-    overflow: auto;
-}
-.markdown-body pre code {
-    background: transparent;
-    border: 0;
-    padding: 0;
-    color: var(--text);
-}
-
-/* Blockquote */
-.markdown-body blockquote {
-    border-left: 4px solid var(--border);
-    padding: .5em 1em;
-    margin-left: 0;
-    color: var(--text-muted);
-    background: rgba(22,27,34,.35);
-    border-radius: 6px;
-}
-
-/* Tabellen – wichtig für sauberes Layout */
-.markdown-body table {
-    width: 100%;
-    border-collapse: collapse;
-    border-spacing: 0;
-    overflow: auto;
-    display: block;
-}
-.markdown-body thead {
-    background: var(--bg-muted);
-}
-.markdown-body th, .markdown-body td {
-    border: 1px solid var(--border);
-    padding: 8px 12px;
-    text-align: left;
-    vertical-align: top;
-}
-.markdown-body th {
-    font-weight: 600;
-}
-.markdown-body tr:nth-child(even) td {
-    background: rgba(22,27,34,.5);
-}
-
-/* HR */
-.markdown-body hr {
-    height: 1px;
-    border: 0;
-    background: var(--border);
-    margin: 2em 0;
-}
-
-/* Bilder */
-.markdown-body img {
-    max-width: 100%;
-    height: auto;
-    border-radius: 6px;
-}
-
-/* Details/Summary */
-.markdown-body details {
-    background: var(--bg-muted);
-    border: 1px solid var(--border);
-    border-radius: 6px;
-    padding: .6em .9em;
-}
-.markdown-body summary {
-    cursor: pointer;
-    font-weight: 600;
-}
-
-/* Markierung, KBD */
-.markdown-body mark {
-    background: #99700066;
-    color: var(--text);
-    padding: 0 .2em;
-    border-radius: 3px;
-}
-.markdown-body kbd {
-    background: var(--kbd-bg);
-    border: 1px solid var(--kbd-border);
-    border-bottom-width: 2px;
-    border-radius: 6px;
-    padding: .1em .4em;
-    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
-    font-size: .85em;
-}
-
-/* Zitate/Callouts (Admonitions via blockquote) */
-.markdown-body blockquote > :first-child { margin-top: 0; }
-.markdown-body blockquote > :last-child { margin-bottom: 0; }
-
-/* Inline-Abstände */
-.markdown-body strong { color: var(--text); }
-.markdown-body em { color: var(--text); }
-
-/* Code-Block Scrollbar etwas dezenter */
-.markdown-body pre::-webkit-scrollbar,
-.markdown-body table::-webkit-scrollbar {
-    height: 10px;
-}
-.markdown-body pre::-webkit-scrollbar-thumb,
-.markdown-body table::-webkit-scrollbar-thumb {
-    background: var(--border);
-    border-radius: 6px;
-}