@intranefr/superbackend 1.5.1 → 1.5.3

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

@@ -2,6 +2,18 @@ const crypto = require('crypto');
 
 const JsonConfig = require('../models/JsonConfig');
 
+const logger = {
+  log: (...args) => {
+    if (process.env.DEBUG_JSON_CONFIGS === 'true' && !process.env.TUI_MODE) console.log(...args);
+  },
+  warn: (...args) => {
+    if (process.env.DEBUG_JSON_CONFIGS === 'true' && !process.env.TUI_MODE) console.warn(...args);
+  },
+  error: (...args) => {
+    console.error(...args);
+  }
+};
+
 const cache = new Map();
 
 function normalizeSlugBase(title) {
@@ -122,7 +134,7 @@ async function getJsonConfigById(id) {
 }
 
 async function createJsonConfig({ title, jsonRaw, publicEnabled = false, cacheTtlSeconds = 0, alias }) {
-  console.log('createJsonConfig called with:', { title, jsonRaw, publicEnabled, cacheTtlSeconds, alias });
+  logger.log('createJsonConfig called with:', { title, jsonRaw, publicEnabled, cacheTtlSeconds, alias });
   
   const normalizedTitle = String(title || '').trim();
   if (!normalizedTitle) {
@@ -142,7 +154,7 @@ async function createJsonConfig({ title, jsonRaw, publicEnabled = false, cacheTt
   let normalizedAlias = null;
   if (alias !== undefined && alias !== null) {
     normalizedAlias = normalizeAlias(alias);
-    console.log('Normalized alias:', normalizedAlias);
+    logger.log('Normalized alias:', normalizedAlias);
     if (normalizedAlias && !(await validateAliasUniqueness(normalizedAlias))) {
       const err = new Error('Alias must be unique and not conflict with existing slugs or aliases');
       err.code = 'ALIAS_NOT_UNIQUE';
@@ -162,10 +174,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) {
@@ -175,7 +187,7 @@ async function createJsonConfig({ title, jsonRaw, publicEnabled = false, cacheTt
 }
 
 async function updateJsonConfig(id, patch) {
-  console.log('updateJsonConfig called with id:', id, 'patch:', patch);
+  logger.log('updateJsonConfig called with id:', id, 'patch:', patch);
   
   const doc = await JsonConfig.findById(id);
   if (!doc) {
@@ -184,7 +196,7 @@ async function updateJsonConfig(id, patch) {
     throw err;
   }
 
-  console.log('Found document:', doc.toObject());
+  logger.log('Found document:', doc.toObject());
 
   const oldSlug = doc.slug;
   const oldAlias = doc.alias;
@@ -222,14 +234,14 @@ async function updateJsonConfig(id, patch) {
 
   if (patch && Object.prototype.hasOwnProperty.call(patch, 'alias')) {
     const newAlias = patch.alias;
-    console.log('Processing alias update. newAlias:', newAlias);
+    logger.log('Processing alias update. newAlias:', newAlias);
     
     if (newAlias === null || newAlias === undefined || newAlias === '') {
       doc.alias = undefined;
-      console.log('Setting alias to undefined');
+      logger.log('Setting alias to undefined');
     } else {
       const normalizedAlias = normalizeAlias(newAlias);
-      console.log('Normalized alias for update:', normalizedAlias);
+      logger.log('Normalized alias for update:', normalizedAlias);
       
       if (!normalizedAlias) {
         const err = new Error('Invalid alias format');
@@ -244,7 +256,7 @@ async function updateJsonConfig(id, patch) {
       }
       
       doc.alias = normalizedAlias;
-      console.log('Setting alias to:', normalizedAlias);
+      logger.log('Setting alias to:', normalizedAlias);
     }
   }
 
@@ -252,9 +264,9 @@ async function updateJsonConfig(id, patch) {
     doc.slug = await generateUniqueSlugFromTitle(doc.title);
   }
 
-  console.log('Document before save:', doc.toObject());
+  logger.log('Document before save:', doc.toObject());
   await doc.save();
-  console.log('Document after save:', doc.toObject());
+  logger.log('Document after save:', doc.toObject());
 
   clearJsonConfigCache(oldSlug);
   clearJsonConfigCache(doc.slug);