@intranefr/superbackend 1.5.1 → 1.5.2

package/src/services/experimentsAggregation.service.js

@@ -0,0 +1,308 @@
+const mongoose = require('mongoose');
+
+const Experiment = require('../models/Experiment');
+const ExperimentEvent = require('../models/ExperimentEvent');
+const ExperimentMetricBucket = require('../models/ExperimentMetricBucket');
+
+const experimentsService = require('./experiments.service');
+const { broadcastWinnerChanged } = require('./experimentsWs.service');
+const webhookService = require('./webhook.service');
+
+function normalizeStr(v) {
+  return String(v || '').trim();
+}
+
+function floorToBucket(date, bucketMs) {
+  const t = new Date(date).getTime();
+  const ms = Number(bucketMs || 0) || 0;
+  if (!Number.isFinite(t) || ms <= 0) return null;
+  return new Date(Math.floor(t / ms) * ms);
+}
+
+function resolveMetricKeys(exp) {
+  const defs = [];
+  if (exp?.primaryMetric) defs.push(exp.primaryMetric);
+  for (const m of exp?.secondaryMetrics || []) defs.push(m);
+
+  const keys = new Set();
+  for (const d of defs) {
+    const kind = normalizeStr(d?.kind);
+    const key = normalizeStr(d?.key);
+    if (!key) continue;
+
+    if (kind === 'rate') {
+      const num = normalizeStr(d?.numeratorEventKey);
+      const den = normalizeStr(d?.denominatorEventKey);
+      if (num) keys.add(num);
+      if (den) keys.add(den);
+      continue;
+    }
+
+    keys.add(key);
+  }
+  return Array.from(keys);
+}
+
+async function aggregateExperiment({ experimentId, bucketMs, start, end }) {
+  const exp = await Experiment.findById(experimentId).lean();
+  if (!exp) {
+    const err = new Error('Experiment not found');
+    err.code = 'NOT_FOUND';
+    throw err;
+  }
+
+  const metricEventKeys = resolveMetricKeys(exp);
+  if (!metricEventKeys.length) {
+    return { experimentId: String(exp._id), aggregated: 0 };
+  }
+
+  const startAt = start ? new Date(start) : (exp.startedAt ? new Date(exp.startedAt) : new Date(Date.now() - 24 * 60 * 60 * 1000));
+  const endAt = end ? new Date(end) : new Date();
+
+  const bucket = Number(bucketMs || 0) || 3600000;
+
+  const pipeline = [
+    {
+      $match: {
+        experimentId: new mongoose.Types.ObjectId(String(exp._id)),
+        ts: { $gte: startAt, $lte: endAt },
+        eventKey: { $in: metricEventKeys },
+      },
+    },
+    {
+      $addFields: {
+        bucketStart: {
+          $toDate: {
+            $multiply: [
+              { $floor: { $divide: [{ $toLong: '$ts' }, bucket] } },
+              bucket,
+            ],
+          },
+        },
+      },
+    },
+    {
+      $group: {
+        _id: {
+          variantKey: '$variantKey',
+          metricKey: '$eventKey',
+          bucketStart: '$bucketStart',
+        },
+        count: { $sum: 1 },
+        sum: { $sum: '$value' },
+        sumSq: { $sum: { $multiply: ['$value', '$value'] } },
+        min: { $min: '$value' },
+        max: { $max: '$value' },
+      },
+    },
+  ];
+
+  const rows = await ExperimentEvent.aggregate(pipeline);
+
+  let aggregated = 0;
+  for (const r of rows || []) {
+    if (!r || !r._id) continue;
+
+    await ExperimentMetricBucket.updateOne(
+      {
+        experimentId: exp._id,
+        organizationId: exp.organizationId || null,
+        variantKey: String(r._id.variantKey),
+        metricKey: String(r._id.metricKey),
+        bucketStart: new Date(r._id.bucketStart),
+        bucketMs: bucket,
+      },
+      {
+        $set: {
+          count: Number(r.count || 0) || 0,
+          sum: Number(r.sum || 0) || 0,
+          sumSq: Number(r.sumSq || 0) || 0,
+          min: r.min === undefined ? null : r.min,
+          max: r.max === undefined ? null : r.max,
+        },
+      },
+      { upsert: true },
+    );
+
+    aggregated += 1;
+  }
+
+  return { experimentId: String(exp._id), aggregated };
+}
+
+async function computeTotalsForMetric({ experimentId, variantKey, metricKey, startAt }) {
+  const q = {
+    experimentId: new mongoose.Types.ObjectId(String(experimentId)),
+    variantKey: String(variantKey),
+    metricKey: String(metricKey),
+  };
+
+  if (startAt) {
+    q.bucketStart = { $gte: new Date(startAt) };
+  }
+
+  const rows = await ExperimentMetricBucket.find(q).select('count sum').lean();
+
+  let count = 0;
+  let sum = 0;
+  for (const r of rows || []) {
+    count += Number(r.count || 0) || 0;
+    sum += Number(r.sum || 0) || 0;
+  }
+
+  return { count, sum };
+}
+
+async function evaluateWinner({ experimentId }) {
+  const exp = await Experiment.findById(experimentId);
+  if (!exp) {
+    const err = new Error('Experiment not found');
+    err.code = 'NOT_FOUND';
+    throw err;
+  }
+
+  if (exp.winnerPolicy?.mode !== 'automatic') {
+    return { decided: false, reason: 'manual_mode' };
+  }
+
+  if (exp.winnerVariantKey && exp.winnerDecidedAt) {
+    return { decided: true, reason: 'already_decided', winnerVariantKey: exp.winnerVariantKey };
+  }
+
+  const pickAfterMs = Number(exp.winnerPolicy?.pickAfterMs || 0) || 0;
+  const startedAt = exp.startedAt ? new Date(exp.startedAt) : null;
+  if (!startedAt) {
+    return { decided: false, reason: 'missing_startedAt' };
+  }
+
+  if (pickAfterMs > 0 && Date.now() - startedAt.getTime() < pickAfterMs) {
+    return { decided: false, reason: 'too_early' };
+  }
+
+  const primary = exp.primaryMetric || {};
+  const kind = normalizeStr(primary.kind) || 'count';
+
+  const variants = (exp.variants || []).map((v) => normalizeStr(v?.key)).filter(Boolean);
+  if (!variants.length) {
+    return { decided: false, reason: 'no_variants' };
+  }
+
+  const evalStart = startedAt;
+
+  const scores = [];
+  for (const variantKey of variants) {
+    if (kind === 'rate') {
+      const numeratorKey = normalizeStr(primary.numeratorEventKey);
+      const denominatorKey = normalizeStr(primary.denominatorEventKey);
+
+      if (!numeratorKey || !denominatorKey) {
+        return { decided: false, reason: 'invalid_primary_rate_metric' };
+      }
+
+      const num = await computeTotalsForMetric({ experimentId: exp._id, variantKey, metricKey: numeratorKey, startAt: evalStart });
+      const den = await computeTotalsForMetric({ experimentId: exp._id, variantKey, metricKey: denominatorKey, startAt: evalStart });
+
+      const conversions = num.sum;
+      const exposures = den.sum;
+
+      const score = exposures > 0 ? conversions / exposures : 0;
+      scores.push({ variantKey, score, conversions, exposures });
+      continue;
+    }
+
+    const metricKey = normalizeStr(primary.key);
+    if (!metricKey) {
+      return { decided: false, reason: 'invalid_primary_metric' };
+    }
+
+    const totals = await computeTotalsForMetric({ experimentId: exp._id, variantKey, metricKey, startAt: evalStart });
+
+    let score = 0;
+    if (kind === 'count') score = totals.count;
+    else if (kind === 'sum') score = totals.sum;
+    else if (kind === 'avg') score = totals.count > 0 ? totals.sum / totals.count : 0;
+    else score = totals.sum;
+
+    scores.push({ variantKey, score, count: totals.count, sum: totals.sum });
+  }
+
+  const minAssignments = Number(exp.winnerPolicy?.minAssignments || 0) || 0;
+  const minExposures = Number(exp.winnerPolicy?.minExposures || 0) || 0;
+  const minConversions = Number(exp.winnerPolicy?.minConversions || 0) || 0;
+
+  if (kind === 'rate') {
+    const anyOk = scores.some((s) => (Number(s.exposures || 0) || 0) >= minExposures && (Number(s.conversions || 0) || 0) >= minConversions);
+    if (!anyOk) return { decided: false, reason: 'insufficient_data' };
+  }
+
+  if (minAssignments > 0) {
+    // Placeholder: assignment counts could be derived from assignments collection.
+    // We enforce it later once we implement an efficient counter.
+  }
+
+  const objective = normalizeStr(primary.objective) || 'maximize';
+  const sorted = [...scores].sort((a, b) => (objective === 'minimize' ? a.score - b.score : b.score - a.score));
+  const winner = sorted[0];
+  if (!winner) return { decided: false, reason: 'no_scores' };
+
+  const override = normalizeStr(exp.winnerPolicy?.overrideWinnerVariantKey);
+  const winnerKey = override || winner.variantKey;
+
+  exp.winnerVariantKey = winnerKey;
+  exp.winnerDecidedAt = new Date();
+  exp.winnerReason = override ? 'manual_override' : `auto:${kind}:${objective}`;
+  exp.status = 'completed';
+
+  await exp.save();
+
+  await experimentsService.clearExperimentCaches(exp._id);
+
+  broadcastWinnerChanged({
+    experimentId: String(exp._id),
+    experimentCode: exp.code,
+    organizationId: exp.organizationId ? String(exp.organizationId) : null,
+    winnerVariantKey: exp.winnerVariantKey,
+    decidedAt: exp.winnerDecidedAt,
+  });
+
+  if (exp.organizationId) {
+    webhookService.emit(
+      'experiment.winner_changed',
+      {
+        experimentId: String(exp._id),
+        code: exp.code,
+        winnerVariantKey: exp.winnerVariantKey,
+        decidedAt: exp.winnerDecidedAt,
+      },
+      String(exp.organizationId),
+    );
+  }
+
+  return { decided: true, reason: exp.winnerReason, winnerVariantKey: exp.winnerVariantKey, scores };
+}
+
+async function runAggregationAndWinner({ bucketMs, start, end } = {}) {
+  const now = new Date();
+  const bucket = Number(bucketMs || 0) || 3600000;
+
+  const startAt = start ? new Date(start) : new Date(now.getTime() - 6 * 60 * 60 * 1000);
+  const endAt = end ? new Date(end) : now;
+
+  const experiments = await Experiment.find({ status: { $in: ['running', 'completed'] } }).select('_id').lean();
+
+  const out = [];
+  for (const e of experiments || []) {
+    const res = await aggregateExperiment({ experimentId: e._id, bucketMs: bucket, start: startAt, end: endAt });
+    const win = await evaluateWinner({ experimentId: e._id }).catch((err) => ({ decided: false, reason: err.message }));
+    out.push({ experimentId: String(e._id), aggregated: res.aggregated, winner: win });
+  }
+
+  return { range: { start: startAt.toISOString(), end: endAt.toISOString() }, bucketMs: bucket, items: out };
+}
+
+module.exports = {
+  floorToBucket,
+  aggregateExperiment,
+  evaluateWinner,
+  runAggregationAndWinner,
+};

package/src/services/experimentsCronsBootstrap.service.js

@@ -0,0 +1,118 @@
+const crypto = require('crypto');
+
+const GlobalSetting = require('../models/GlobalSetting');
+const CronJob = require('../models/CronJob');
+
+const globalSettingsService = require('./globalSettings.service');
+
+const INTERNAL_CRON_TOKEN_SETTING_KEY = 'experiments.internalCronToken';
+
+const CRON_NAME_AGGREGATE = 'Experiments: Aggregate + Evaluate Winner';
+const CRON_NAME_RETENTION = 'Experiments: Retention Cleanup';
+
+function getDefaultInternalCronToken() {
+  return crypto.randomBytes(24).toString('hex');
+}
+
+async function ensureSettingExists({ key, type, description, defaultValue }) {
+  const existing = await GlobalSetting.findOne({ key }).lean();
+  if (existing) return existing;
+
+  const doc = await GlobalSetting.create({
+    key,
+    type,
+    description,
+    value: type === 'json' ? JSON.stringify(defaultValue) : String(defaultValue ?? ''),
+    templateVariables: [],
+    public: false,
+  });
+
+  globalSettingsService.clearSettingsCache();
+  return doc.toObject();
+}
+
+async function ensureInternalTokenExists() {
+  await ensureSettingExists({
+    key: INTERNAL_CRON_TOKEN_SETTING_KEY,
+    type: 'string',
+    description: 'Bearer token used by CronJobs to call internal experiments endpoints.',
+    defaultValue: getDefaultInternalCronToken(),
+  });
+
+  const raw = await globalSettingsService.getSettingValue(INTERNAL_CRON_TOKEN_SETTING_KEY, '');
+  return String(raw || '').trim();
+}
+
+async function ensureCronJobs({ baseUrl }) {
+  const aggregateUrl = `${baseUrl}/api/internal/experiments/aggregate/run`;
+  const retentionUrl = `${baseUrl}/api/internal/experiments/retention/run`;
+
+  // Use the same Basic Auth credentials as the admin API.
+  // This keeps a single source of truth and avoids CronJobs drifting to other env vars.
+  const internalCronUsername = process.env.ADMIN_USERNAME || 'admin';
+  const internalCronPassword = process.env.ADMIN_PASSWORD || 'admin';
+
+  const aggDoc = {
+    name: CRON_NAME_AGGREGATE,
+    description: 'Aggregates experiment events into buckets and evaluates winners.',
+    cronExpression: '*/15 * * * *',
+    timezone: 'UTC',
+    enabled: true,
+    nextRunAt: null,
+    taskType: 'http',
+    httpMethod: 'POST',
+    httpUrl: aggregateUrl,
+    httpHeaders: [],
+    httpBody: JSON.stringify({}),
+    httpBodyType: 'json',
+    httpAuth: { type: 'basic', username: internalCronUsername, password: internalCronPassword },
+    timeoutMs: 5 * 60 * 1000,
+    createdBy: 'system',
+  };
+
+  await CronJob.updateOne(
+    { name: CRON_NAME_AGGREGATE, taskType: 'http' },
+    { $set: aggDoc, $setOnInsert: { createdAt: new Date() } },
+    { upsert: true },
+  );
+
+  const retentionDoc = {
+    name: CRON_NAME_RETENTION,
+    description: 'Deletes old experiment events and metric buckets based on retention settings.',
+    cronExpression: '0 3 * * *',
+    timezone: 'UTC',
+    enabled: true,
+    nextRunAt: null,
+    taskType: 'http',
+    httpMethod: 'POST',
+    httpUrl: retentionUrl,
+    httpHeaders: [],
+    httpBody: JSON.stringify({}),
+    httpBodyType: 'json',
+    httpAuth: { type: 'basic', username: internalCronUsername, password: internalCronPassword },
+    timeoutMs: 10 * 60 * 1000,
+    createdBy: 'system',
+  };
+
+  await CronJob.updateOne(
+    { name: CRON_NAME_RETENTION, taskType: 'http' },
+    { $set: retentionDoc, $setOnInsert: { createdAt: new Date() } },
+    { upsert: true },
+  );
+}
+
+async function bootstrap() {
+  // CronScheduler HTTP jobs need an absolute base URL.
+  const baseUrl =
+    String(process.env.SUPERBACKEND_BASE_URL || process.env.PUBLIC_URL || '').trim() ||
+    'http://localhost:3000';
+
+  await ensureCronJobs({ baseUrl: baseUrl.replace(/\/+$/, '') });
+}
+
+module.exports = {
+  bootstrap,
+  INTERNAL_CRON_TOKEN_SETTING_KEY,
+  CRON_NAME_AGGREGATE,
+  CRON_NAME_RETENTION,
+};

package/src/services/experimentsRetention.service.js

@@ -0,0 +1,43 @@
+const globalSettingsService = require('./globalSettings.service');
+
+const ExperimentEvent = require('../models/ExperimentEvent');
+const ExperimentMetricBucket = require('../models/ExperimentMetricBucket');
+
+function toInt(val, fallback) {
+  const n = parseInt(String(val), 10);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+async function runRetentionCleanup() {
+  const eventsRetentionDays = toInt(
+    await globalSettingsService.getSettingValue('EXPERIMENT_EVENTS_RETENTION_DAYS', '30'),
+    30,
+  );
+  const metricsRetentionDays = toInt(
+    await globalSettingsService.getSettingValue('EXPERIMENT_METRICS_RETENTION_DAYS', '180'),
+    180,
+  );
+
+  const now = Date.now();
+  const eventsCutoff = new Date(now - eventsRetentionDays * 24 * 60 * 60 * 1000);
+  const metricsCutoff = new Date(now - metricsRetentionDays * 24 * 60 * 60 * 1000);
+
+  const [eventsRes, bucketsRes] = await Promise.all([
+    ExperimentEvent.deleteMany({ ts: { $lt: eventsCutoff } }),
+    ExperimentMetricBucket.deleteMany({ bucketStart: { $lt: metricsCutoff } }),
+  ]);
+
+  return {
+    eventsRetentionDays,
+    metricsRetentionDays,
+    cutoffs: { eventsCutoff: eventsCutoff.toISOString(), metricsCutoff: metricsCutoff.toISOString() },
+    deleted: {
+      events: eventsRes?.deletedCount ?? 0,
+      metricBuckets: bucketsRes?.deletedCount ?? 0,
+    },
+  };
+}
+
+module.exports = {
+  runRetentionCleanup,
+};

package/src/services/experimentsWs.service.js

@@ -0,0 +1,134 @@
+const { WebSocketServer } = require('ws');
+const url = require('url');
+
+const subscribersByCode = new Map(); // experimentCode -> Set<ws>
+
+function safeSend(ws, payload) {
+  try {
+    ws.send(JSON.stringify(payload));
+  } catch {
+  }
+}
+
+function normalizeCode(v) {
+  return String(v || '').trim();
+}
+
+function broadcastWinnerChanged({ experimentCode, winnerVariantKey, decidedAt }) {
+  const code = normalizeCode(experimentCode);
+  if (!code) return;
+
+  const subs = subscribersByCode.get(code);
+  if (!subs || subs.size === 0) return;
+
+  const msg = {
+    type: 'winner',
+    experimentCode: code,
+    winnerVariantKey: winnerVariantKey || null,
+    decidedAt: decidedAt ? new Date(decidedAt).toISOString() : null,
+  };
+
+  for (const ws of subs) {
+    if (ws.readyState !== ws.OPEN) continue;
+    safeSend(ws, msg);
+  }
+}
+
+function attachExperimentsWebsocketServer(server) {
+  const wsPath = '/api/experiments/ws';
+  const wss = new WebSocketServer({ noServer: true });
+
+  server.on('upgrade', (req, socket, head) => {
+    const parsed = url.parse(req.url, true);
+    if (!parsed || parsed.pathname !== wsPath) return;
+
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit('connection', ws, req, parsed);
+    });
+  });
+
+  wss.on('connection', (ws, _req, parsed) => {
+    ws._sbExperimentSubs = new Set();
+
+    safeSend(ws, { type: 'hello' });
+
+    ws.on('message', (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(raw || ''));
+      } catch {
+        return;
+      }
+
+      const type = normalizeCode(msg?.type);
+      const experimentCode = normalizeCode(msg?.experimentCode);
+
+      if (type === 'subscribe') {
+        if (!experimentCode) return;
+
+        let set = subscribersByCode.get(experimentCode);
+        if (!set) {
+          set = new Set();
+          subscribersByCode.set(experimentCode, set);
+        }
+        set.add(ws);
+        ws._sbExperimentSubs.add(experimentCode);
+        safeSend(ws, { type: 'subscribed', experimentCode });
+        return;
+      }
+
+      if (type === 'unsubscribe') {
+        if (!experimentCode) return;
+
+        const set = subscribersByCode.get(experimentCode);
+        if (set) {
+          set.delete(ws);
+          if (set.size === 0) subscribersByCode.delete(experimentCode);
+        }
+        ws._sbExperimentSubs.delete(experimentCode);
+        safeSend(ws, { type: 'unsubscribed', experimentCode });
+      }
+    });
+
+    ws.on('close', () => {
+      for (const code of ws._sbExperimentSubs || []) {
+        const set = subscribersByCode.get(code);
+        if (set) {
+          set.delete(ws);
+          if (set.size === 0) subscribersByCode.delete(code);
+        }
+      }
+    });
+
+    ws.on('error', () => {
+      for (const code of ws._sbExperimentSubs || []) {
+        const set = subscribersByCode.get(code);
+        if (set) {
+          set.delete(ws);
+          if (set.size === 0) subscribersByCode.delete(code);
+        }
+      }
+    });
+
+    // If query provides experimentCode, auto-subscribe.
+    const q = parsed && parsed.query ? parsed.query : {};
+    const initial = normalizeCode(q.experimentCode);
+    if (initial) {
+      let set = subscribersByCode.get(initial);
+      if (!set) {
+        set = new Set();
+        subscribersByCode.set(initial, set);
+      }
+      set.add(ws);
+      ws._sbExperimentSubs.add(initial);
+      safeSend(ws, { type: 'subscribed', experimentCode: initial });
+    }
+  });
+
+  return { wss, wsPath };
+}
+
+module.exports = {
+  attachExperimentsWebsocketServer,
+  broadcastWinnerChanged,
+};

package/src/services/globalSettings.service.js

@@ -39,11 +39,26 @@ async function getSettingValue(key, defaultValue = null) {
   }
 }
 
+async function deleteSetting(key) {
+  try {
+    const setting = await GlobalSetting.findOneAndDelete({ key });
+    
+    // Clear cache for this key
+    settingsCache.delete(key);
+    
+    return setting;
+  } catch (error) {
+    console.error(`Error deleting setting ${key}:`, error);
+    throw error;
+  }
+}
+
 function clearSettingsCache() {
   settingsCache.clear();
 }
 
 module.exports = {
   getSettingValue,
+  deleteSetting,
   clearSettingsCache,
 };

package/src/services/jsonConfigs.service.js

@@ -162,10 +162,10 @@ async function createJsonConfig({ title, jsonRaw, publicEnabled = false, cacheTt
     jsonHash: computeJsonHash(String(jsonRaw)),
   };
   
-  console.log('Creating document with data:', createData);
+  //console.log('Creating document with data:', createData);
 
   const doc = await JsonConfig.create(createData);
-  console.log('Created document:', doc.toObject());
+  //console.log('Created document:', doc.toObject());
 
   clearJsonConfigCache(slug);
   if (normalizedAlias) {