@intranefr/superbackend 1.5.0 → 1.5.2

package/src/routes/adminBlogAutomation.routes.js

@@ -0,0 +1,27 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/blogAutomationAdmin.controller');
+const rateLimiter = require('../services/rateLimiter.service');
+
+router.use(basicAuth);
+router.use(express.json({ limit: '2mb' }));
+
+router.get('/blog-automation/config', controller.getConfig);
+router.put('/blog-automation/config', controller.saveConfig);
+
+router.get('/blog-automation/configs', controller.listConfigs);
+router.post('/blog-automation/configs', controller.createConfig);
+router.get('/blog-automation/configs/:id', controller.getConfigById);
+router.post('/blog-automation/configs/:id/preview-prompts', controller.previewPromptsByConfigId);
+router.put('/blog-automation/configs/:id', controller.updateConfigById);
+router.delete('/blog-automation/configs/:id', controller.deleteConfigById);
+
+router.get('/blog-automation/style-guide', controller.getStyleGuide);
+router.put('/blog-automation/style-guide', controller.saveStyleGuide);
+
+router.get('/blog-automation/runs', controller.listRuns);
+router.post('/blog-automation/run-now', rateLimiter.limit('blogAiLimiter'), controller.runNow);
+
+module.exports = router;

package/src/routes/adminCache.routes.js

@@ -0,0 +1,20 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/adminCache.controller');
+
+router.use(basicAuth);
+
+router.get('/config', controller.getConfig);
+router.put('/config', controller.updateConfig);
+
+router.get('/keys', controller.listKeys);
+router.get('/entry', controller.getEntry);
+router.put('/entry', controller.setEntry);
+router.delete('/entry', controller.deleteEntry);
+
+router.post('/clear', controller.clearCache);
+router.get('/metrics', controller.metrics);
+
+module.exports = router;

package/src/routes/adminConsoleManager.routes.js

@@ -0,0 +1,302 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const ConsoleEntry = require('../models/ConsoleEntry');
+const ConsoleLog = require('../models/ConsoleLog');
+const GlobalSetting = require('../models/GlobalSetting');
+const { consoleManager } = require('../services/consoleManager.service');
+
+function normalizeTags(val) {
+  if (!val) return [];
+  if (Array.isArray(val)) return val.map((t) => String(t).trim()).filter(Boolean);
+  return String(val)
+    .split(',')
+    .map((t) => t.trim())
+    .filter(Boolean);
+}
+
+function toInt(val, fallback) {
+  const n = parseInt(String(val), 10);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+router.use(basicAuth);
+
+router.get('/config', async (req, res) => {
+  try {
+    const cfg = await consoleManager.getConfig();
+    res.json({ config: cfg });
+  } catch (err) {
+    res.status(500).json({ error: err?.message || 'Failed to load config' });
+  }
+});
+
+router.put('/config', async (req, res) => {
+  try {
+    const cfg = req.body || {};
+    await consoleManager.updateConfig(cfg);
+    await consoleManager.applyDefaultsRetroactively(cfg);
+    const next = await consoleManager.getConfig();
+    res.json({ ok: true, config: next });
+  } catch (err) {
+    res.status(500).json({ error: err?.message || 'Failed to update config' });
+  }
+});
+
+router.get('/entries', async (req, res) => {
+  try {
+    const {
+      method,
+      enabled,
+      q,
+      sort = 'lastSeenAt',
+      order = 'desc',
+      page = 1,
+      pageSize = 50,
+      tags,
+    } = req.query;
+
+    const filter = {};
+
+    if (method && ['debug', 'log', 'info', 'warn', 'error'].includes(String(method))) {
+      filter.method = String(method);
+    }
+
+    if (enabled !== undefined) {
+      if (String(enabled) === 'true') filter.enabled = true;
+      if (String(enabled) === 'false') filter.enabled = false;
+    }
+
+    const tagList = normalizeTags(tags);
+    if (tagList.length) {
+      filter.tags = { $all: tagList };
+    }
+
+    if (q) {
+      filter.$or = [
+        { messageTemplate: { $regex: String(q), $options: 'i' } },
+        { topFrame: { $regex: String(q), $options: 'i' } },
+        { hash: { $regex: String(q), $options: 'i' } },
+      ];
+    }
+
+    const sortField = ['lastSeenAt', 'countTotal', 'firstSeenAt', 'method'].includes(sort) ? sort : 'lastSeenAt';
+    const sortOrder = String(order) === 'asc' ? 1 : -1;
+
+    const limit = Math.min(200, Math.max(1, toInt(pageSize, 50)));
+    const skip = (Math.max(1, toInt(page, 1)) - 1) * limit;
+
+    const [items, total] = await Promise.all([
+      ConsoleEntry.find(filter)
+        .sort({ [sortField]: sortOrder })
+        .skip(skip)
+        .limit(limit)
+        .lean(),
+      ConsoleEntry.countDocuments(filter),
+    ]);
+
+    res.json({
+      items,
+      pagination: {
+        total,
+        page: Math.max(1, toInt(page, 1)),
+        pageSize: limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    });
+  } catch (err) {
+    res.status(500).json({ error: err?.message || 'Failed to list entries' });
+  }
+});
+
+router.put('/entries/bulk-enable', async (req, res) => {
+  try {
+    const body = req.body || {};
+    const hashes = Array.isArray(body.hashes) ? body.hashes.map((h) => String(h).trim()).filter(Boolean) : [];
+    const nextEnabled = Boolean(body.enabled);
+
+    if (!hashes.length) {
+      return res.status(400).json({ error: 'hashes is required' });
+    }
+
+    const result = await ConsoleEntry.updateMany(
+      { hash: { $in: hashes } },
+      { $set: { enabled: nextEnabled, enabledExplicit: true } },
+    );
+
+    res.json({ ok: true, matched: result.matchedCount ?? result.n, modified: result.modifiedCount ?? result.nModified });
+  } catch (err) {
+    res.status(500).json({ error: err?.message || 'Failed to bulk update entries' });
+  }
+});
+
+router.put('/entries/bulk-tags', async (req, res) => {
+  try {
+    const body = req.body || {};
+    const hashes = Array.isArray(body.hashes) ? body.hashes.map((h) => String(h).trim()).filter(Boolean) : [];
+
+    if (!hashes.length) {
+      return res.status(400).json({ error: 'hashes is required' });
+    }
+
+    const add = normalizeTags(body.add);
+    const remove = normalizeTags(body.remove);
+
+    const update = {};
+    if (add.length) {
+      update.$addToSet = { tags: { $each: add } };
+    }
+    if (remove.length) {
+      update.$pull = { tags: { $in: remove } };
+    }
+
+    if (!Object.keys(update).length) {
+      return res.status(400).json({ error: 'add or remove tags required' });
+    }
+
+    await ConsoleEntry.updateMany({ hash: { $in: hashes } }, update);
+
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err?.message || 'Failed to update tags' });
+  }
+});
+
+router.get('/tags', async (req, res) => {
+  try {
+    const items = await ConsoleEntry.aggregate([
+      { $unwind: '$tags' },
+      { $group: { _id: '$tags', count: { $sum: 1 } } },
+      { $sort: { count: -1, _id: 1 } },
+    ]);
+
+    res.json({
+      items: items.map((it) => ({ tag: it._id, count: it.count })),
+    });
+  } catch (err) {
+    res.status(500).json({ error: err?.message || 'Failed to list tags' });
+  }
+});
+
+router.get('/logs', async (req, res) => {
+  try {
+    const { method, q, entryHash, page = 1, pageSize = 50, tags } = req.query;
+
+    const filter = {};
+
+    if (method && ['debug', 'log', 'info', 'warn', 'error'].includes(String(method))) {
+      filter.method = String(method);
+    }
+
+    if (entryHash) {
+      filter.entryHash = String(entryHash);
+    }
+
+    const tagList = normalizeTags(tags);
+    if (tagList.length) {
+      filter.tagsSnapshot = { $all: tagList };
+    }
+
+    if (q) {
+      filter.$or = [
+        { message: { $regex: String(q), $options: 'i' } },
+        { argsPreview: { $regex: String(q), $options: 'i' } },
+        { entryHash: { $regex: String(q), $options: 'i' } },
+      ];
+    }
+
+    const limit = Math.min(200, Math.max(1, toInt(pageSize, 50)));
+    const skip = (Math.max(1, toInt(page, 1)) - 1) * limit;
+
+    const [items, total] = await Promise.all([
+      ConsoleLog.find(filter)
+        .sort({ createdAt: -1 })
+        .skip(skip)
+        .limit(limit)
+        .lean(),
+      ConsoleLog.countDocuments(filter),
+    ]);
+
+    res.json({
+      items,
+      pagination: {
+        total,
+        page: Math.max(1, toInt(page, 1)),
+        pageSize: limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    });
+  } catch (err) {
+    res.status(500).json({ error: err?.message || 'Failed to list logs' });
+  }
+});
+
+router.delete('/entries/bulk-delete', async (req, res) => {
+  try {
+    const body = req.body || {};
+    const hashes = Array.isArray(body.hashes) ? body.hashes.map((h) => String(h).trim()).filter(Boolean) : [];
+    const deleteLogs = Boolean(body.deleteLogs);
+
+    if (!hashes.length) {
+      return res.status(400).json({ error: 'hashes is required and cannot be empty' });
+    }
+
+    // Delete ConsoleEntry documents
+    const entryResult = await ConsoleEntry.deleteMany({ hash: { $in: hashes } });
+    let deletedLogs = 0;
+
+    // Optionally delete associated ConsoleLog documents
+    if (deleteLogs) {
+      const logResult = await ConsoleLog.deleteMany({ entryHash: { $in: hashes } });
+      deletedLogs = logResult.deletedCount ?? logResult.n;
+    }
+
+    res.json({
+      ok: true,
+      deletedEntries: entryResult.deletedCount ?? entryResult.n,
+      deletedLogs,
+    });
+  } catch (err) {
+    res.status(500).json({ error: err?.message || 'Failed to bulk delete entries' });
+  }
+});
+
+// Global Settings endpoint for console manager control
+router.get('/global-setting', async (req, res) => {
+  try {
+    const globalSetting = await GlobalSetting.findOne({ key: 'CONSOLE_MANAGER_ENABLED' }).lean();
+    const value = globalSetting ? globalSetting.value : 'true';
+    res.json({ enabled: String(value) === 'true' });
+  } catch (err) {
+    res.status(500).json({ error: err?.message || 'Failed to load global setting' });
+  }
+});
+
+router.put('/global-setting', async (req, res) => {
+  try {
+    const { enabled } = req.body;
+    const enabledValue = Boolean(enabled) ? 'true' : 'false';
+    
+    await GlobalSetting.findOneAndUpdate(
+      { key: 'CONSOLE_MANAGER_ENABLED' },
+      { 
+        key: 'CONSOLE_MANAGER_ENABLED', 
+        value: enabledValue,
+        type: 'string',
+        description: 'Enable/disable console manager initialization (requires restart)'
+      },
+      { upsert: true, new: true }
+    );
+    
+    res.json({ 
+      ok: true, 
+      enabled: Boolean(enabled),
+      message: 'Console manager global setting updated. Restart required for changes to take effect.'
+    });
+  } catch (err) {
+    res.status(500).json({ error: err?.message || 'Failed to update global setting' });
+  }
+});
+
+module.exports = router;

package/src/routes/adminCrons.routes.js

@@ -0,0 +1,25 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/adminCrons.controller');
+
+router.use(basicAuth);
+
+router.get('/', controller.listCronJobs);
+router.post('/', controller.createCronJob);
+router.get('/presets', controller.getCronPresets);
+router.post('/preview', controller.previewNextRuns);
+
+router.get('/:id', controller.getCronJob);
+router.put('/:id', controller.updateCronJob);
+router.delete('/:id', controller.deleteCronJob);
+
+router.post('/:id/enable', controller.enableCronJob);
+router.post('/:id/disable', controller.disableCronJob);
+router.post('/:id/trigger', controller.triggerCronJob);
+
+router.get('/:id/executions', controller.getExecutionHistory);
+router.get('/:id/executions/:eid', controller.getExecution);
+
+module.exports = router;

package/src/routes/adminDbBrowser.routes.js

@@ -0,0 +1,65 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const { auditMiddleware } = require('../services/auditLogger');
+const controller = require('../controllers/adminDbBrowser.controller');
+
+router.use(basicAuth);
+
+// Connection profiles
+router.get('/connections', controller.listConnections);
+router.get('/connections/:id', controller.getConnection);
+
+router.post(
+  '/connections',
+  auditMiddleware('admin.db_browser.connections.create', { entityType: 'ExternalDbConnection' }),
+  controller.createConnection,
+);
+
+router.patch(
+  '/connections/:id',
+  auditMiddleware('admin.db_browser.connections.update', { entityType: 'ExternalDbConnection' }),
+  controller.updateConnection,
+);
+
+router.delete(
+  '/connections/:id',
+  auditMiddleware('admin.db_browser.connections.delete', { entityType: 'ExternalDbConnection' }),
+  controller.deleteConnection,
+);
+
+router.post(
+  '/connections/:id/test',
+  auditMiddleware('admin.db_browser.connections.test', { entityType: 'ExternalDbConnection' }),
+  controller.testConnection,
+);
+
+// Browsing
+router.get(
+  '/connections/:id/databases',
+  auditMiddleware('admin.db_browser.browse.databases', { entityType: 'ExternalDbConnection' }),
+  controller.listDatabases,
+);
+router.get(
+  '/connections/:id/databases/:database/namespaces',
+  auditMiddleware('admin.db_browser.browse.namespaces', { entityType: 'ExternalDbConnection' }),
+  controller.listNamespaces,
+);
+router.get(
+  '/connections/:id/databases/:database/namespaces/:namespace/schema',
+  auditMiddleware('admin.db_browser.browse.schema', { entityType: 'ExternalDbConnection' }),
+  controller.getSchema,
+);
+router.get(
+  '/connections/:id/databases/:database/namespaces/:namespace/records',
+  auditMiddleware('admin.db_browser.browse.records', { entityType: 'ExternalDbConnection' }),
+  controller.listRecords,
+);
+router.get(
+  '/connections/:id/databases/:database/namespaces/:namespace/records/:recordId',
+  auditMiddleware('admin.db_browser.browse.record', { entityType: 'ExternalDbConnection' }),
+  controller.getRecord,
+);
+
+module.exports = router;

package/src/routes/adminEjsVirtual.routes.js

@@ -2,6 +2,7 @@ const express = require('express');
 const router = express.Router();
 const { basicAuth } = require('../middleware/auth');
 const controller = require('../controllers/adminEjsVirtual.controller');
+const rateLimiter = require('../services/rateLimiter.service');
 
 router.use(basicAuth);
 
@@ -11,7 +12,7 @@ router.put('/file', controller.saveFile);
 router.post('/file/revert', controller.revertToDefault);
 router.get('/history', controller.listHistory);
 router.post('/rollback', controller.rollback);
-router.post('/vibe', controller.vibe);
+router.post('/vibe', rateLimiter.limit('aiOperationsLimiter'), controller.vibe);
 router.post('/cache/clear', controller.clearCache);
 
 module.exports = router;

package/src/routes/adminExperiments.routes.js

@@ -0,0 +1,29 @@
+const express = require('express');
+const router = express.Router();
+
+const { authenticate } = require('../middleware/auth');
+const { requireRight } = require('../middleware/rbac');
+const controller = require('../controllers/adminExperiments.controller');
+
+const getOrgId = (req) => req.headers['x-org-id'] || req.query?.orgId || req.body?.organizationId || req.body?.orgId;
+
+router.use(express.json({ limit: '1mb' }));
+
+router.use((req, res, next) => {
+  const auth = String(req.headers?.authorization || '');
+  if (auth.toLowerCase().startsWith('bearer ')) {
+    return authenticate(req, res, next);
+  }
+  return next();
+});
+
+router.get('/', requireRight('experiments:admin', { getOrgId }), controller.list);
+router.post('/', requireRight('experiments:admin', { getOrgId }), controller.create);
+
+router.get('/:id', requireRight('experiments:admin', { getOrgId }), controller.get);
+router.put('/:id', requireRight('experiments:admin', { getOrgId }), controller.update);
+router.delete('/:id', requireRight('experiments:admin', { getOrgId }), controller.remove);
+
+router.get('/:id/metrics', requireRight('experiments:admin', { getOrgId }), controller.getMetrics);
+
+module.exports = router;

package/src/routes/adminHeadless.routes.js

@@ -3,6 +3,7 @@ const router = express.Router();
 
 const { basicAuth } = require('../middleware/auth');
 const adminHeadlessController = require('../controllers/adminHeadless.controller');
+const rateLimiter = require('../services/rateLimiter.service');
 
 router.use(basicAuth);
 
@@ -24,7 +25,7 @@ router.post('/models/validate', adminHeadlessController.validateModelDefinition)
 router.post('/models/apply', adminHeadlessController.applyModelProposal);
 
 // AI model builder
-router.post('/ai/model-builder/chat', adminHeadlessController.aiModelBuilderChat);
+router.post('/ai/model-builder/chat', rateLimiter.limit('aiOperationsLimiter'), adminHeadlessController.aiModelBuilderChat);
 
 // Admin collections CRUD (UI)
 router.get('/collections/:modelCode', adminHeadlessController.listCollectionItems);

package/src/routes/adminHealthChecks.routes.js

@@ -0,0 +1,28 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/adminHealthChecks.controller');
+
+router.use(basicAuth);
+
+router.get('/config', controller.getConfig);
+router.put('/config', controller.updateConfig);
+
+router.get('/', controller.listHealthChecks);
+router.post('/', controller.createHealthCheck);
+
+router.get('/:id', controller.getHealthCheck);
+router.put('/:id', controller.updateHealthCheck);
+router.delete('/:id', controller.deleteHealthCheck);
+
+router.post('/:id/enable', controller.enableHealthCheck);
+router.post('/:id/disable', controller.disableHealthCheck);
+router.post('/:id/trigger', controller.triggerHealthCheck);
+
+router.get('/:id/runs', controller.getRunHistory);
+router.get('/:id/incidents', controller.getIncidents);
+router.post('/:id/incidents/:incidentId/acknowledge', controller.acknowledgeIncident);
+router.post('/:id/incidents/:incidentId/resolve', controller.resolveIncident);
+
+module.exports = router;

package/src/routes/adminI18n.routes.js

@@ -3,6 +3,7 @@ const router = express.Router();
 const { basicAuth } = require('../middleware/auth');
 
 const adminI18nController = require('../controllers/adminI18n.controller');
+const rateLimiter = require('../services/rateLimiter.service');
 
 router.use(basicAuth);
 
@@ -15,8 +16,8 @@ router.post('/entries', adminI18nController.createEntry);
 router.put('/entries/:id', adminI18nController.updateEntry);
 router.delete('/entries/:id', adminI18nController.deleteEntry);
 
-router.post('/ai/preview', adminI18nController.aiPreview);
-router.post('/ai/apply', adminI18nController.aiApply);
-router.post('/ai/translate-text', adminI18nController.aiTranslateText);
+router.post('/ai/preview', rateLimiter.limit('i18nAiLimiter'), adminI18nController.aiPreview);
+router.post('/ai/apply', rateLimiter.limit('i18nAiLimiter'), adminI18nController.aiApply);
+router.post('/ai/translate-text', rateLimiter.limit('i18nAiLimiter'), adminI18nController.aiTranslateText);
 
 module.exports = router;

package/src/routes/adminLlm.routes.js

@@ -2,10 +2,12 @@ const express = require("express");
 const router = express.Router();
 const { basicAuth } = require("../middleware/auth");
 const adminLlmController = require("../controllers/adminLlm.controller");
+const rateLimiter = require("../services/rateLimiter.service");
 
 router.get("/config", basicAuth, adminLlmController.getConfig);
-router.post("/config", basicAuth, adminLlmController.saveConfig);
-router.post("/prompts/:key/test", basicAuth, adminLlmController.testPrompt);
+router.post("/config", basicAuth, rateLimiter.limit("llmConfigLimiter"), adminLlmController.saveConfig);
+router.get("/openrouter/models", basicAuth, adminLlmController.listOpenRouterModels);
+router.post("/prompts/:key/test", basicAuth, rateLimiter.limit("llmConfigLimiter"), adminLlmController.testPrompt);
 router.get("/audit", basicAuth, adminLlmController.listAudit);
 router.get("/costs", basicAuth, adminLlmController.listCosts);
 

package/src/routes/adminPages.routes.js

@@ -0,0 +1,55 @@
+const express = require('express');
+const router = express.Router();
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/adminPages.controller');
+const adminBlockDefinitionsController = require('../controllers/adminBlockDefinitions.controller');
+const adminBlockDefinitionsAiController = require('../controllers/adminBlockDefinitionsAi.controller');
+const adminContextBlockDefinitionsController = require('../controllers/adminContextBlockDefinitions.controller');
+const adminPagesContextBlocksAiController = require('../controllers/adminPagesContextBlocksAi.controller');
+const rateLimiter = require('../services/rateLimiter.service');
+
+router.use(basicAuth);
+
+router.get('/collections', controller.listCollections);
+router.get('/collections/:id', controller.getCollection);
+router.post('/collections', controller.createCollection);
+router.put('/collections/:id', controller.updateCollection);
+router.delete('/collections/:id', controller.deleteCollection);
+
+router.get('/pages', controller.listPages);
+router.get('/pages/:id', controller.getPage);
+router.post('/pages', controller.createPage);
+router.put('/pages/:id', controller.updatePage);
+router.delete('/pages/:id', controller.deletePage);
+
+router.post('/pages/:id/publish', controller.publishPage);
+router.post('/pages/:id/unpublish', controller.unpublishPage);
+
+router.post('/pages/:id/test-context', controller.testPageContextPhase);
+router.post('/pages/:id/test-block', controller.testPageContextBlock);
+router.post('/test-block', controller.testContextBlockAdhoc);
+
+router.get('/templates', controller.getAvailableTemplates);
+router.get('/layouts', controller.getAvailableLayouts);
+router.get('/blocks', controller.getAvailableBlocks);
+router.get('/blocks-schema', controller.getBlocksSchema);
+
+router.get('/block-definitions', adminBlockDefinitionsController.list);
+router.post('/block-definitions', adminBlockDefinitionsController.create);
+router.get('/block-definitions/:code', adminBlockDefinitionsController.get);
+router.put('/block-definitions/:code', adminBlockDefinitionsController.update);
+router.delete('/block-definitions/:code', adminBlockDefinitionsController.remove);
+
+router.get('/context-block-definitions', adminContextBlockDefinitionsController.list);
+router.post('/context-block-definitions', adminContextBlockDefinitionsController.create);
+router.get('/context-block-definitions/:code', adminContextBlockDefinitionsController.get);
+router.put('/context-block-definitions/:code', adminContextBlockDefinitionsController.update);
+router.delete('/context-block-definitions/:code', adminContextBlockDefinitionsController.remove);
+
+router.post('/ai/block-definitions/generate', rateLimiter.limit('aiOperationsLimiter'), adminBlockDefinitionsAiController.generate);
+router.post('/ai/block-definitions/:code/propose', rateLimiter.limit('aiOperationsLimiter'), adminBlockDefinitionsAiController.propose);
+
+router.post('/ai/context-blocks/generate', rateLimiter.limit('aiOperationsLimiter'), adminPagesContextBlocksAiController.generate);
+router.post('/ai/context-blocks/propose', rateLimiter.limit('aiOperationsLimiter'), adminPagesContextBlocksAiController.propose);
+
+module.exports = router;

package/src/routes/adminProxy.routes.js

@@ -0,0 +1,15 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/adminProxy.controller');
+
+router.use(basicAuth);
+
+router.get('/entries', controller.list);
+router.get('/entries/:id', controller.get);
+router.post('/entries', controller.create);
+router.put('/entries/:id', controller.update);
+router.delete('/entries/:id', controller.delete);
+
+module.exports = router;

package/src/routes/adminRateLimits.routes.js

@@ -0,0 +1,17 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const adminRateLimitsController = require('../controllers/adminRateLimits.controller');
+
+router.get('/', basicAuth, adminRateLimitsController.list);
+router.get('/config', basicAuth, adminRateLimitsController.getConfig);
+router.put('/config', basicAuth, adminRateLimitsController.updateConfig);
+router.get('/metrics', basicAuth, adminRateLimitsController.getMetrics);
+
+router.post('/bulk-enabled', basicAuth, adminRateLimitsController.bulkEnabled);
+
+router.put('/:id', basicAuth, adminRateLimitsController.updateLimiter);
+router.post('/:id/reset', basicAuth, adminRateLimitsController.resetLimiter);
+
+module.exports = router;