@intranefr/superbackend 1.5.1 → 1.5.3

package/src/models/ExperimentAssignment.js

@@ -0,0 +1,23 @@
+const mongoose = require('mongoose');
+
+const experimentAssignmentSchema = new mongoose.Schema(
+  {
+    experimentId: { type: mongoose.Schema.Types.ObjectId, ref: 'Experiment', required: true, index: true },
+    organizationId: { type: mongoose.Schema.Types.ObjectId, ref: 'Organization', default: null, index: true },
+
+    subjectKey: { type: String, required: true },
+
+    variantKey: { type: String, required: true },
+    assignedAt: { type: Date, default: () => new Date() },
+
+    context: { type: mongoose.Schema.Types.Mixed, default: {} },
+  },
+  { timestamps: true, collection: 'experiment_assignments' },
+);
+
+experimentAssignmentSchema.index({ experimentId: 1, subjectKey: 1 }, { unique: true });
+experimentAssignmentSchema.index({ organizationId: 1, subjectKey: 1 });
+
+module.exports =
+  mongoose.models.ExperimentAssignment ||
+  mongoose.model('ExperimentAssignment', experimentAssignmentSchema);

package/src/models/ExperimentEvent.js

@@ -0,0 +1,26 @@
+const mongoose = require('mongoose');
+
+const experimentEventSchema = new mongoose.Schema(
+  {
+    experimentId: { type: mongoose.Schema.Types.ObjectId, ref: 'Experiment', required: true, index: true },
+    organizationId: { type: mongoose.Schema.Types.ObjectId, ref: 'Organization', default: null, index: true },
+
+    subjectKey: { type: String, required: true },
+
+    variantKey: { type: String, required: true, index: true },
+
+    eventKey: { type: String, required: true, index: true },
+    value: { type: Number, default: 1 },
+
+    ts: { type: Date, required: true, index: true },
+
+    meta: { type: mongoose.Schema.Types.Mixed, default: {} },
+  },
+  { timestamps: true, collection: 'experiment_events' },
+);
+
+experimentEventSchema.index({ experimentId: 1, ts: 1 });
+experimentEventSchema.index({ organizationId: 1, ts: 1 });
+experimentEventSchema.index({ experimentId: 1, eventKey: 1, ts: 1 });
+
+module.exports = mongoose.models.ExperimentEvent || mongoose.model('ExperimentEvent', experimentEventSchema);

package/src/models/ExperimentMetricBucket.js

@@ -0,0 +1,30 @@
+const mongoose = require('mongoose');
+
+const experimentMetricBucketSchema = new mongoose.Schema(
+  {
+    experimentId: { type: mongoose.Schema.Types.ObjectId, ref: 'Experiment', required: true, index: true },
+    organizationId: { type: mongoose.Schema.Types.ObjectId, ref: 'Organization', default: null, index: true },
+
+    variantKey: { type: String, required: true, index: true },
+    metricKey: { type: String, required: true, index: true },
+
+    bucketStart: { type: Date, required: true, index: true },
+    bucketMs: { type: Number, required: true },
+
+    count: { type: Number, default: 0 },
+    sum: { type: Number, default: 0 },
+    sumSq: { type: Number, default: 0 },
+    min: { type: Number, default: null },
+    max: { type: Number, default: null },
+  },
+  { timestamps: true, collection: 'experiment_metric_buckets' },
+);
+
+experimentMetricBucketSchema.index(
+  { experimentId: 1, variantKey: 1, metricKey: 1, bucketStart: 1, bucketMs: 1 },
+  { unique: true },
+);
+
+module.exports =
+  mongoose.models.ExperimentMetricBucket ||
+  mongoose.model('ExperimentMetricBucket', experimentMetricBucketSchema);

package/src/models/GlobalSetting.js

@@ -4,8 +4,7 @@ const globalSettingSchema = new mongoose.Schema({
   key: {
     type: String,
     required: true,
-    unique: true,
-    index: true
+    unique: true
   },
   value: {
     type: String,

package/src/models/Markdown.js

@@ -0,0 +1,75 @@
+const mongoose = require('mongoose');
+
+const markdownSchema = new mongoose.Schema(
+  {
+    title: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    slug: {
+      type: String,
+      required: true,
+      index: true,
+      trim: true,
+    },
+    category: {
+      type: String,
+      required: true,
+      index: true,
+      trim: true,
+      default: 'general',
+    },
+    group_code: {
+      type: String,
+      required: false,
+      index: true,
+      trim: true,
+      default: '',
+    },
+    markdownRaw: {
+      type: String,
+      required: true,
+      default: '',
+    },
+    publicEnabled: {
+      type: Boolean,
+      default: false,
+      index: true,
+    },
+    cacheTtlSeconds: {
+      type: Number,
+      default: 0,
+    },
+    status: {
+      type: String,
+      enum: ['draft', 'published', 'archived'],
+      default: 'draft',
+      index: true,
+    },
+    ownerUserId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User',
+      index: true,
+      default: null,
+    },
+    orgId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Organization',
+      index: true,
+      default: null,
+    },
+  },
+  { timestamps: true },
+);
+
+// Compound unique index for fast lookups
+markdownSchema.index({ category: 1, group_code: 1, slug: 1 }, { unique: true });
+
+// Additional indexes for common queries
+markdownSchema.index({ status: 1, publicEnabled: 1 });
+markdownSchema.index({ category: 1, status: 1 });
+markdownSchema.index({ ownerUserId: 1, createdAt: -1 });
+markdownSchema.index({ orgId: 1, createdAt: -1 });
+
+module.exports = mongoose.model('Markdown', markdownSchema);

package/src/models/RateLimitCounter.js

@@ -8,7 +8,7 @@ const rateLimitCounterSchema = new mongoose.Schema(
 
     count: { type: Number, default: 0 },
 
-    expiresAt: { type: Date, default: null, index: true },
+    expiresAt: { type: Date, default: null },
   },
   { timestamps: true, collection: 'rate_limit_counters' },
 );

package/src/models/ScriptDefinition.js

@@ -16,6 +16,7 @@ const scriptDefinitionSchema = new mongoose.Schema(
     type: { type: String, enum: ['bash', 'node', 'browser'], required: true },
     runner: { type: String, enum: ['host', 'vm2', 'browser'], required: true },
     script: { type: String, required: true },
+    scriptFormat: { type: String, enum: ['string', 'base64'], default: 'string' },
     defaultWorkingDirectory: { type: String, default: '' },
     env: { type: [envVarSchema], default: [] },
     timeoutMs: { type: Number, default: 5 * 60 * 1000 },

package/src/models/ScriptRun.js

@@ -14,6 +14,14 @@ const scriptRunSchema = new mongoose.Schema(
     finishedAt: { type: Date, default: null },
     exitCode: { type: Number, default: null },
     outputTail: { type: String, default: '' },
+    fullOutput: { type: String, default: '' },
+    programmaticOutput: { type: String, default: '' },
+    returnResult: { type: String, default: '' },
+    lastConsoleLog: { type: String, default: '' },
+    outputType: { type: String, enum: ['return', 'console', 'none'], default: 'none' },
+    outputSize: { type: Number, default: 0 },
+    lineCount: { type: Number, default: 0 },
+    lastOutputUpdate: { type: Date, default: null },
     meta: { type: mongoose.Schema.Types.Mixed, default: null },
   },
   { timestamps: true, collection: 'script_runs' },

package/src/models/TelegramBot.js

@@ -0,0 +1,42 @@
+const mongoose = require('mongoose');
+
+const telegramBotSchema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  token: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  isActive: {
+    type: Boolean,
+    default: false
+  },
+  allowedUserIds: {
+    type: [String],
+    default: []
+  },
+  defaultAgentId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Agent'
+  },
+  orgId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Organization'
+  },
+  status: {
+    type: String,
+    enum: ['stopped', 'running', 'error'],
+    default: 'stopped'
+  },
+  lastError: {
+    type: String
+  }
+}, {
+  timestamps: true
+});
+
+module.exports = mongoose.model('TelegramBot', telegramBotSchema);

package/src/models/Webhook.js

@@ -26,6 +26,8 @@ const webhookSchema = new mongoose.Schema({
       'organization.updated',
       'member.added',
       'form.submitted',
+      'experiment.winner_changed',
+      'experiment.status_changed',
       'audit.event'
     ]
   }],

package/src/routes/admin.routes.js

@@ -25,4 +25,6 @@ router.post('/stripe-webhooks/retry', adminController.retryFailedWebhookEvents);
 router.post('/stripe-webhooks/:id/retry', adminController.retrySingleWebhookEvent);
 router.get('/stripe-webhooks-stats', adminController.getWebhookStats);
 
+router.post('/users/email/token', adminController.generateTokenForEmail);
+
 module.exports = router;

package/src/routes/adminAgents.routes.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+const adminAgentsController = require('../controllers/adminAgents.controller');
+const { basicAuth } = require('../middleware/auth');
+
+router.use(basicAuth);
+
+router.get('/', adminAgentsController.listAgents);
+router.post('/', adminAgentsController.createAgent);
+router.put('/:id', adminAgentsController.updateAgent);
+router.delete('/:id', adminAgentsController.deleteAgent);
+
+module.exports = router;

package/src/routes/adminConsoleManager.routes.js

@@ -5,7 +5,7 @@ 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');
+const { consoleManager } = require('../services/consoleManager.service');
 
 function normalizeTags(val) {
   if (!val) return [];

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/adminLlm.routes.js

@@ -5,6 +5,7 @@ const adminLlmController = require("../controllers/adminLlm.controller");
 const rateLimiter = require("../services/rateLimiter.service");
 
 router.get("/config", basicAuth, adminLlmController.getConfig);
+router.get("/providers", basicAuth, adminLlmController.listProviders);
 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);

package/src/routes/adminMarkdowns.routes.js

@@ -0,0 +1,16 @@
+const express = require('express');
+const router = express.Router();
+const { basicAuth } = require('../middleware/auth');
+
+const adminMarkdownsController = require('../controllers/adminMarkdowns.controller');
+
+router.get('/', basicAuth, adminMarkdownsController.list);
+router.get('/group-codes/:category', basicAuth, adminMarkdownsController.getGroupCodes);
+router.get('/folder/:category/:group_code?', basicAuth, adminMarkdownsController.getFolderContents);
+router.get('/:id', basicAuth, adminMarkdownsController.get);
+router.post('/', basicAuth, adminMarkdownsController.create);
+router.put('/:id', basicAuth, adminMarkdownsController.update);
+router.delete('/:id', basicAuth, adminMarkdownsController.remove);
+router.post('/validate-path', basicAuth, adminMarkdownsController.validatePath);
+
+module.exports = router;

package/src/routes/adminScripts.routes.js

@@ -10,7 +10,10 @@ router.get('/', controller.listScripts);
 router.post('/', controller.createScript);
 router.get('/runs', controller.listRuns);
 router.get('/runs/:runId', controller.getRun);
-router.get('/runs/:runId/stream', controller.streamRun);
+router.get('/runs/:runId/stream', controller.streamRunLogs);
+router.get('/runs/:runId/programmatic-output', controller.getProgrammaticOutput);
+router.get('/runs/:runId/full-output', controller.getFullOutput);
+router.get('/runs/:runId/download', controller.downloadOutput);
 
 router.get('/:id', controller.getScript);
 router.put('/:id', controller.updateScript);

package/src/routes/adminTelegram.routes.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const router = express.Router();
+const adminTelegramController = require('../controllers/adminTelegram.controller');
+const { basicAuth } = require('../middleware/auth');
+
+router.use(basicAuth);
+
+router.get('/', adminTelegramController.listBots);
+router.post('/', adminTelegramController.createBot);
+router.put('/:id', adminTelegramController.updateBot);
+router.delete('/:id', adminTelegramController.deleteBot);
+router.post('/:id/toggle', adminTelegramController.toggleBot);
+
+module.exports = router;

package/src/routes/blogInternal.routes.js

@@ -2,11 +2,11 @@ const express = require('express');
 const router = express.Router();
 
 const controller = require('../controllers/blogInternal.controller');
-const { requireInternalCronToken } = require('../middleware/internalCronAuth');
+const { basicAuth } = require('../middleware/auth');
 const rateLimiter = require('../services/rateLimiter.service');
 
 router.use(express.json({ limit: '1mb' }));
-router.use(requireInternalCronToken);
+router.use(basicAuth);
 
 router.post('/blog/automation/run', rateLimiter.limit('blogAiLimiter'), controller.runAutomation);
 router.post('/blog/publish-scheduled/run', controller.publishScheduled);

package/src/routes/experiments.routes.js

@@ -0,0 +1,30 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const rateLimiter = require('../services/rateLimiter.service');
+
+const controller = require('../controllers/experiments.controller');
+
+router.use(express.json({ limit: '1mb' }));
+router.use(basicAuth);
+
+router.get(
+  '/:code/assignment',
+  rateLimiter.limit('experimentsAssignmentLimiter'),
+  controller.getAssignment,
+);
+
+router.post(
+  '/:code/events',
+  rateLimiter.limit('experimentsEventsLimiter'),
+  controller.postEvents,
+);
+
+router.get(
+  '/:code/winner',
+  rateLimiter.limit('experimentsWinnerLimiter'),
+  controller.getWinner,
+);
+
+module.exports = router;

package/src/routes/internalExperiments.routes.js

@@ -0,0 +1,15 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const rateLimiter = require('../services/rateLimiter.service');
+
+const controller = require('../controllers/internalExperiments.controller');
+
+router.use(express.json({ limit: '1mb' }));
+router.use(basicAuth);
+
+router.post('/experiments/aggregate/run', rateLimiter.limit('experimentsInternalAggLimiter'), controller.runAggregation);
+router.post('/experiments/retention/run', rateLimiter.limit('experimentsInternalRetentionLimiter'), controller.runRetention);
+
+module.exports = router;

package/src/routes/markdowns.routes.js

@@ -0,0 +1,16 @@
+const express = require('express');
+const router = express.Router();
+
+const markdownsController = require('../controllers/markdowns.controller');
+
+// JSON versions (more specific first)
+router.get('/:category/:group_code/:slug/json', markdownsController.getByPath);
+router.get('/:category/:slug/json', markdownsController.getByPath);
+
+// Raw versions
+router.get('/:category/:group_code/:slug', markdownsController.getByPath);
+router.get('/:category/:slug', markdownsController.getByPath); // No group_code
+
+router.get('/search', markdownsController.search);
+
+module.exports = router;