@intranefr/superbackend 1.5.2 → 1.6.3

package/src/controllers/adminMarkdowns.controller.js

@@ -0,0 +1,157 @@
+const {
+  ERROR_CODES,
+  listMarkdowns,
+  getMarkdownById,
+  createMarkdown,
+  updateMarkdown,
+  deleteMarkdown,
+  getFolderContents,
+  getUniqueGroupCodes,
+  validatePathUniqueness,
+} = require('../services/markdowns.service');
+
+function handleServiceError(res, error) {
+  const msg = error?.message || 'Operation failed';
+  const code = error?.code;
+
+  if (code === 'VALIDATION' || code === 'INVALID_MARKDOWN' || code === 'INVALID_GROUP_CODE') {
+    return res.status(400).json({ error: msg });
+  }
+  if (code === 'NOT_FOUND') {
+    return res.status(404).json({ error: msg });
+  }
+  if (code === 'PATH_NOT_UNIQUE') {
+    return res.status(409).json({ error: msg });
+  }
+
+  return res.status(500).json({ error: msg });
+}
+
+function parseJsonMaybe(value) {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== 'string') return value;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch (_) {
+    return null;
+  }
+}
+
+exports.list = async (req, res) => {
+  try {
+    const filters = {
+      category: req.query.category,
+      group_code: req.query.group_code,
+      status: req.query.status,
+      ownerUserId: req.query.ownerUserId,
+      orgId: req.query.orgId,
+      search: req.query.search,
+    };
+    
+    const pagination = {
+      page: Number(req.query.page) || 1,
+      limit: Number(req.query.limit) || 50,
+      sort: parseJsonMaybe(req.query.sort) || { updatedAt: -1 },
+    };
+    
+    const result = await listMarkdowns(filters, pagination, { isAdmin: true });
+    return res.json(result);
+  } catch (error) {
+    console.error('Error listing markdowns:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.get = async (req, res) => {
+  try {
+    const item = await getMarkdownById(req.params.id);
+    if (!item) return res.status(404).json({ error: 'Markdown not found' });
+    return res.json({ item });
+  } catch (error) {
+    console.error('Error fetching markdown:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.create = async (req, res) => {
+  try {
+    const item = await createMarkdown(req.body || {});
+    return res.status(201).json({ item });
+  } catch (error) {
+    console.error('Error creating markdown:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.update = async (req, res) => {
+  try {
+    const item = await updateMarkdown(req.params.id, req.body || {});
+    return res.json({ item });
+  } catch (error) {
+    console.error('Error updating markdown:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.remove = async (req, res) => {
+  try {
+    const result = await deleteMarkdown(req.params.id);
+    return res.json(result);
+  } catch (error) {
+    console.error('Error deleting markdown:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.getFolderContents = async (req, res) => {
+  try {
+    const { category } = req.params;
+    const { group_code } = req.params;
+    
+    const pagination = {
+      page: Number(req.query.page) || 1,
+      limit: Number(req.query.limit) || 100,
+      sort: parseJsonMaybe(req.query.sort) || { title: 1 },
+    };
+    
+    const result = await getFolderContents(category, group_code, pagination, { isAdmin: true });
+    return res.json(result);
+  } catch (error) {
+    console.error('Error getting folder contents:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.validatePath = async (req, res) => {
+  try {
+    const { category, group_code, slug, excludeId } = req.body;
+    
+    if (!category || !slug) {
+      return res.status(400).json({ error: 'category and slug are required' });
+    }
+    
+    const isUnique = await validatePathUniqueness(category, group_code, slug, excludeId);
+    return res.json({ unique: isUnique });
+  } catch (error) {
+    console.error('Error validating path:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.getGroupCodes = async (req, res) => {
+  try {
+    const { category } = req.params;
+    
+    if (!category) {
+      return res.status(400).json({ error: 'category is required' });
+    }
+    
+    const groupCodes = await getUniqueGroupCodes(category, { isAdmin: true });
+    return res.json(groupCodes);
+  } catch (error) {
+    console.error('Error getting group codes:', error);
+    return handleServiceError(res, error);
+  }
+};

package/src/controllers/adminPlugins.controller.js

@@ -0,0 +1,55 @@
+const pluginsService = require('../services/plugins.service');
+
+function handleError(res, error) {
+  const code = error?.code;
+  const message = error?.message || 'Operation failed';
+
+  if (code === 'NOT_FOUND') return res.status(404).json({ error: message });
+  if (code === 'VALIDATION') return res.status(400).json({ error: message });
+  return res.status(500).json({ error: message });
+}
+
+function runtimeContext(req) {
+  const superbackend = globalThis.superbackend || globalThis.saasbackend || {};
+  return {
+    services: superbackend.services || {},
+    helpers: superbackend.helpers || {},
+    request: req,
+  };
+}
+
+exports.list = async (req, res) => {
+  try {
+    const items = await pluginsService.listPlugins();
+    return res.json({ items });
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.enable = async (req, res) => {
+  try {
+    const result = await pluginsService.enablePlugin(req.params.id, { context: runtimeContext(req) });
+    return res.json(result);
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.disable = async (req, res) => {
+  try {
+    const result = await pluginsService.disablePlugin(req.params.id);
+    return res.json(result);
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.install = async (req, res) => {
+  try {
+    const result = await pluginsService.installPlugin(req.params.id, { context: runtimeContext(req) });
+    return res.json(result);
+  } catch (error) {
+    return handleError(res, error);
+  }
+};

package/src/controllers/adminRegistry.controller.js

@@ -0,0 +1,106 @@
+const registryService = require('../services/registry.service');
+
+function handleError(res, error) {
+  const code = error?.code;
+  const message = error?.message || 'Operation failed';
+
+  if (code === 'VALIDATION') return res.status(400).json({ error: message });
+  if (code === 'NOT_FOUND') return res.status(404).json({ error: message });
+  if (code === 'CONFLICT') return res.status(409).json({ error: message });
+  return res.status(500).json({ error: message });
+}
+
+exports.listRegistries = async (req, res) => {
+  try {
+    const items = await registryService.listRegistries();
+    return res.json({ items });
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.createRegistry = async (req, res) => {
+  try {
+    const item = await registryService.createRegistry(req.body || {});
+    return res.status(201).json({ item });
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.getRegistry = async (req, res) => {
+  try {
+    const item = await registryService.getRegistry(req.params.id);
+    if (!item) return res.status(404).json({ error: 'registry not found' });
+    return res.json({ item });
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.updateRegistry = async (req, res) => {
+  try {
+    const item = await registryService.updateRegistry(req.params.id, req.body || {});
+    return res.json({ item });
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.deleteRegistry = async (req, res) => {
+  try {
+    const result = await registryService.deleteRegistry(req.params.id);
+    return res.json(result);
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.createToken = async (req, res) => {
+  try {
+    const result = await registryService.createToken(req.params.id, req.body || {});
+    return res.status(201).json(result);
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.deleteToken = async (req, res) => {
+  try {
+    const result = await registryService.deleteToken(req.params.id, req.params.tokenId);
+    return res.json(result);
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.listItems = async (req, res) => {
+  try {
+    const result = await registryService.listItemsForRegistry(
+      req.params.id,
+      req.query,
+      req.headers.authorization,
+    );
+    return res.json(result);
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.upsertItem = async (req, res) => {
+  try {
+    const item = await registryService.upsertItem(req.params.id, req.body || {});
+    return res.json({ item });
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.deleteItem = async (req, res) => {
+  try {
+    const result = await registryService.deleteItem(req.params.id, req.params.itemId);
+    return res.json(result);
+  } catch (error) {
+    return handleError(res, error);
+  }
+};

package/src/controllers/adminScripts.controller.js

@@ -349,3 +349,141 @@ exports.streamRun = async (req, res) => {
     return res.end();
   }
 };
+
+// Get programmatic output (clean result for API consumption)
+async function getProgrammaticOutput(req, res) {
+  try {
+    const { runId } = req.params;
+    if (!runId) {
+      return res.status(400).json({ error: 'runId is required' });
+    }
+
+    const run = await ScriptRun.findById(runId).lean();
+    if (!run) {
+      return res.status(404).json({ error: 'Script run not found' });
+    }
+
+    // Parse programmatic output if it's JSON
+    let parsedResult = null;
+    let isJson = false;
+    
+    if (run.programmaticOutput) {
+      try {
+        parsedResult = JSON.parse(run.programmaticOutput);
+        isJson = true;
+      } catch {
+        // Not JSON, keep as string
+        parsedResult = null;
+        isJson = false;
+      }
+    }
+
+    res.json({
+      runId: run._id,
+      status: run.status,
+      exitCode: run.exitCode,
+      programmaticOutput: run.programmaticOutput || 'No output',
+      outputType: run.outputType || 'none',
+      isJson: isJson,
+      parsedResult: parsedResult,
+      returnResult: run.returnResult,
+      lastConsoleLog: run.lastConsoleLog,
+      createdAt: run.createdAt,
+      updatedAt: run.updatedAt,
+      startedAt: run.startedAt,
+      finishedAt: run.finishedAt
+    });
+  } catch (err) {
+    console.error('Error getting programmatic output:', err);
+    res.status(500).json({ error: err?.message || 'Internal server error' });
+  }
+}
+
+// Get full script output
+async function getFullOutput(req, res) {
+  try {
+    const { runId } = req.params;
+    if (!runId) {
+      return res.status(400).json({ error: 'runId is required' });
+    }
+
+    const run = await ScriptRun.findById(runId).lean();
+    if (!run) {
+      return res.status(404).json({ error: 'Script run not found' });
+    }
+
+    res.json({
+      runId: run._id,
+      status: run.status,
+      exitCode: run.exitCode,
+      fullOutput: run.fullOutput || '',
+      outputSize: run.outputSize || 0,
+      lineCount: run.lineCount || 0,
+      lastOutputUpdate: run.lastOutputUpdate,
+      createdAt: run.createdAt,
+      updatedAt: run.updatedAt,
+      startedAt: run.startedAt,
+      finishedAt: run.finishedAt
+    });
+  } catch (err) {
+    console.error('Error getting full output:', err);
+    res.status(500).json({ error: err?.message || 'Internal server error' });
+  }
+}
+
+// Download script output as file
+async function downloadOutput(req, res) {
+  try {
+    const { runId } = req.params;
+    if (!runId) {
+      return res.status(400).json({ error: 'runId is required' });
+    }
+
+    const run = await ScriptRun.findById(runId).lean();
+    if (!run) {
+      return res.status(404).json({ error: 'Script run not found' });
+    }
+
+    const filename = `script-output-${runId}-${run.createdAt.toISOString().slice(0, 19).replace(/:/g, '-')}.txt`;
+    
+    res.setHeader('Content-Type', 'text/plain');
+    res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+    
+    // Include metadata at the top
+    const metadata = [
+      `Script Run ID: ${runId}`,
+      `Status: ${run.status}`,
+      `Exit Code: ${run.exitCode || 'N/A'}`,
+      `Started: ${run.startedAt || 'N/A'}`,
+      `Finished: ${run.finishedAt || 'N/A'}`,
+      `Output Size: ${run.outputSize || 0} characters`,
+      `Line Count: ${run.lineCount || 0}`,
+      `Created: ${run.createdAt}`,
+      '=' .repeat(50),
+      ''
+    ].join('\n');
+
+    res.send(metadata + (run.fullOutput || run.outputTail || 'No output available'));
+  } catch (err) {
+    console.error('Error downloading output:', err);
+    res.status(500).json({ error: err?.message || 'Internal server error' });
+  }
+}
+
+exports.getFullOutput = getFullOutput;
+exports.downloadOutput = downloadOutput;
+
+module.exports = {
+  listScripts: exports.listScripts,
+  getScript: exports.getScript,
+  createScript: exports.createScript,
+  updateScript: exports.updateScript,
+  deleteScript: exports.deleteScript,
+  runScript: exports.runScript,
+  listRuns: exports.listRuns,
+  getRun: exports.getRun,
+  streamRunLogs: exports.streamRun,
+  getProgrammaticOutput: getProgrammaticOutput,
+  getFullOutput: exports.getFullOutput,
+  downloadOutput: exports.downloadOutput,
+};

package/src/controllers/adminStats.controller.js

@@ -4,7 +4,7 @@ const AuditEvent = require('../models/AuditEvent');
 const ErrorAggregate = require('../models/ErrorAggregate');
 const Asset = require('../models/Asset');
 const FormSubmission = require('../models/FormSubmission');
-const WaitingList = require('../models/WaitingList');
+const waitingListService = require('../services/waitingListJson.service');
 const EmailLog = require('../models/EmailLog');
 const VirtualEjsFile = require('../models/VirtualEjsFile');
 const JsonConfig = require('../models/JsonConfig');
@@ -35,7 +35,7 @@ exports.getOverviewStats = async (req, res) => {
       totalJsonConfigs,
       // SaaS & Billing
       totalForms,
-      totalWaiting,
+      waitingListStats,
       totalPlans,
       totalWorkflows
     ] = await Promise.all([
@@ -51,7 +51,7 @@ exports.getOverviewStats = async (req, res) => {
       VirtualEjsFile.countDocuments(),
       JsonConfig.countDocuments(),
       FormSubmission.countDocuments(),
-      WaitingList.countDocuments(),
+      waitingListService.getWaitingListStats().catch(() => ({ totalSubscribers: 0 })), // Fallback to 0 if service fails
       StripeCatalogItem.countDocuments({ active: true }),
       Workflow.countDocuments()
     ]);
@@ -106,7 +106,7 @@ exports.getOverviewStats = async (req, res) => {
         },
         saas: {
           forms: totalForms,
-          waiting: totalWaiting,
+          waiting: waitingListStats.totalSubscribers || 0,
           plans: totalPlans,
           workflows: totalWorkflows
         }

package/src/controllers/adminTelegram.controller.js

@@ -0,0 +1,72 @@
+const TelegramBot = require('../models/TelegramBot');
+const Agent = require('../models/Agent');
+const telegramService = require('../services/telegram.service');
+
+exports.listBots = async (req, res) => {
+  try {
+    const bots = await TelegramBot.find().populate('defaultAgentId', 'name').lean();
+    return res.json({ items: bots });
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.createBot = async (req, res) => {
+  try {
+    const data = { ...req.body };
+    if (data.defaultAgentId === '') delete data.defaultAgentId;
+    
+    const bot = await TelegramBot.create(data);
+    if (bot.isActive) {
+      await telegramService.startBot(bot._id);
+    }
+    return res.json(bot);
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.updateBot = async (req, res) => {
+  try {
+    const data = { ...req.body };
+    if (data.defaultAgentId === '') data.defaultAgentId = null;
+
+    const bot = await TelegramBot.findByIdAndUpdate(req.params.id, data, { new: true });
+    if (bot.isActive) {
+      await telegramService.startBot(bot._id);
+    } else {
+      await telegramService.stopBot(bot._id);
+    }
+    return res.json(bot);
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.deleteBot = async (req, res) => {
+  try {
+    await telegramService.stopBot(req.params.id);
+    await TelegramBot.findByIdAndDelete(req.params.id);
+    return res.json({ success: true });
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.toggleBot = async (req, res) => {
+  try {
+    const bot = await TelegramBot.findById(req.params.id);
+    bot.isActive = !bot.isActive;
+    await bot.save();
+    
+    if (bot.isActive) {
+      await telegramService.startBot(bot._id);
+    } else {
+      await telegramService.stopBot(bot._id);
+    }
+    
+    return res.json(bot);
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};

package/src/controllers/markdowns.controller.js

@@ -0,0 +1,42 @@
+const { getMarkdownByPath, searchMarkdowns } = require('../services/markdowns.service');
+
+exports.getByPath = async (req, res) => {
+  try {
+    const { category, group_code, slug } = req.params;
+    // Check if JSON is requested via query or if we are on a .json route
+    const isJson = req.query?.json === 'true' || req.query?.json === '1' || req.path.endsWith('/json');
+
+    const doc = await getMarkdownByPath(category, group_code, slug);
+    
+    if (isJson) {
+      return res.json({ item: doc });
+    }
+    
+    // Serve raw markdown with correct MIME type
+    return res.type('text/markdown').send(doc.markdownRaw);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'NOT_FOUND') {
+      return res.status(404).json({ error: 'Markdown not found' });
+    }
+
+    console.error('Error fetching markdown:', error);
+    return res.status(500).json({ error: error?.message || 'Failed to fetch markdown' });
+  }
+};
+
+exports.search = async (req, res) => {
+  try {
+    const { q: query, category, group_code, limit = 50 } = req.query;
+    
+    if (!query) {
+      return res.status(400).json({ error: 'Search query (q) is required' });
+    }
+
+    const results = await searchMarkdowns(query, { category, group_code, limit: Number(limit) });
+    return res.json({ results });
+  } catch (error) {
+    console.error('Error searching markdowns:', error);
+    return res.status(500).json({ error: error?.message || 'Failed to search markdowns' });
+  }
+};

package/src/controllers/registry.controller.js

@@ -0,0 +1,32 @@
+const registryService = require('../services/registry.service');
+
+function handleError(res, error) {
+  const code = error?.code;
+  const message = error?.message || 'Operation failed';
+
+  if (code === 'VALIDATION') return res.status(400).json({ error: { code: 'INVALID_REQUEST', message } });
+  if (code === 'NOT_FOUND') return res.status(404).json({ error: { code: 'NOT_FOUND', message } });
+  return res.status(500).json({ error: { code: 'INTERNAL_ERROR', message } });
+}
+
+exports.auth = async (req, res) => {
+  try {
+    const payload = await registryService.getAuthStatus(req.params.id, req.headers.authorization);
+    return res.json(payload);
+  } catch (error) {
+    return handleError(res, error);
+  }
+};
+
+exports.list = async (req, res) => {
+  try {
+    const payload = await registryService.listItemsForRegistry(
+      req.params.id,
+      req.query,
+      req.headers.authorization,
+    );
+    return res.json(payload);
+  } catch (error) {
+    return handleError(res, error);
+  }
+};