@intranefr/superbackend 1.5.0 → 1.5.2

package/src/services/healthChecksBootstrap.service.js

@@ -0,0 +1,109 @@
+const GlobalSetting = require('../models/GlobalSetting');
+const ScriptDefinition = require('../models/ScriptDefinition');
+const CronJob = require('../models/CronJob');
+
+const globalSettingsService = require('./globalSettings.service');
+
+const PUBLIC_STATUS_SETTING_KEY = 'healthChecks.publicStatusEnabled';
+
+const CLEANUP_SCRIPT_CODE_IDENTIFIER = 'health-checks-cleanup-history';
+const CLEANUP_CRON_NAME = 'Health Checks: Cleanup run history';
+
+function cleanupScriptSource() {
+  // This script runs out-of-process (host runner). It connects to Mongo and performs cleanup.
+  return `
+(async () => {
+  const mongoose = require('mongoose');
+
+  const uri = process.env.MONGODB_URI || process.env.MONGO_URI;
+  if (!uri) {
+    console.error('MONGODB_URI (or MONGO_URI) is required');
+    process.exit(1);
+  }
+
+  const days = Number(process.env.HEALTHCHECKS_RETENTION_DAYS || 30);
+  const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+
+  await mongoose.connect(uri, { serverSelectionTimeoutMS: 5000, maxPoolSize: 2 });
+
+  const res = await mongoose.connection.db
+    .collection('health_check_runs')
+    .deleteMany({ startedAt: { $lt: cutoff } });
+
+  console.log('Deleted', res.deletedCount || 0, 'health_check_runs older than', days, 'days');
+
+  await mongoose.disconnect();
+})().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+`.trim();
+}
+
+async function ensurePublicStatusSettingExists() {
+  const existing = await GlobalSetting.findOne({ key: PUBLIC_STATUS_SETTING_KEY }).lean();
+  if (existing) return;
+
+  await GlobalSetting.create({
+    key: PUBLIC_STATUS_SETTING_KEY,
+    value: 'false',
+    type: 'boolean',
+    description: 'Enable the public health checks status summary endpoint (/api/health-checks/status).',
+    templateVariables: [],
+    public: false,
+  });
+
+  globalSettingsService.clearSettingsCache();
+}
+
+async function ensureCleanupScriptExists() {
+  let script = await ScriptDefinition.findOne({ codeIdentifier: CLEANUP_SCRIPT_CODE_IDENTIFIER });
+  if (script) return script;
+
+  script = await ScriptDefinition.create({
+    name: 'Health Checks: Cleanup run history (> 30 days)',
+    codeIdentifier: CLEANUP_SCRIPT_CODE_IDENTIFIER,
+    description: 'Deletes HealthCheckRun documents older than 30 days (configurable via HEALTHCHECKS_RETENTION_DAYS env var).',
+    type: 'node',
+    runner: 'host',
+    script: cleanupScriptSource(),
+    defaultWorkingDirectory: '',
+    env: [],
+    timeoutMs: 5 * 60 * 1000,
+    enabled: true,
+  });
+
+  return script;
+}
+
+async function ensureCleanupCronExists(scriptId) {
+  const existing = await CronJob.findOne({ name: CLEANUP_CRON_NAME, taskType: 'script' }).lean();
+  if (existing) return existing;
+
+  const cron = await CronJob.create({
+    name: CLEANUP_CRON_NAME,
+    description: 'Weekly cleanup of health check run history (disabled by default).',
+    cronExpression: '0 3 * * 0',
+    timezone: 'UTC',
+    enabled: false,
+    nextRunAt: null,
+    taskType: 'script',
+    scriptId,
+    scriptEnv: [],
+    timeoutMs: 5 * 60 * 1000,
+    createdBy: 'system',
+  });
+
+  return cron.toObject();
+}
+
+async function bootstrap() {
+  await ensurePublicStatusSettingExists();
+  const script = await ensureCleanupScriptExists();
+  await ensureCleanupCronExists(script._id);
+}
+
+module.exports = {
+  bootstrap,
+  PUBLIC_STATUS_SETTING_KEY,
+};

package/src/services/healthChecksScheduler.service.js

@@ -0,0 +1,106 @@
+const cron = require('node-cron');
+const parser = require('cron-parser');
+
+const HealthCheck = require('../models/HealthCheck');
+
+const healthChecksService = require('./healthChecks.service');
+
+class HealthChecksScheduler {
+  constructor() {
+    this.scheduledChecks = new Map(); // Map<checkId, cron.ScheduledTask>
+    this.isRunning = false;
+  }
+
+  async start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+
+    const enabled = await HealthCheck.find({ enabled: true }).lean();
+    for (const check of enabled) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        await this.scheduleCheck(check);
+      } catch (err) {
+        console.error(`Failed to schedule health check ${check.name}:`, err);
+      }
+    }
+
+    console.log(`Health checks scheduler started with ${enabled.length} checks`);
+  }
+
+  async stop() {
+    for (const [, task] of this.scheduledChecks) {
+      task.stop();
+    }
+    this.scheduledChecks.clear();
+    this.isRunning = false;
+    console.log('Health checks scheduler stopped');
+  }
+
+  calculateNextRun(cronExpression, timezone = 'UTC') {
+    try {
+      const interval = parser.parseExpression(String(cronExpression || '').trim(), { tz: String(timezone || 'UTC') });
+      return interval.next().toDate();
+    } catch (err) {
+      console.error('Failed to calculate next run for health check:', err);
+      return null;
+    }
+  }
+
+  async scheduleCheck(healthCheck) {
+    const checkId = String(healthCheck._id);
+
+    if (this.scheduledChecks.has(checkId)) {
+      await this.unscheduleCheck(checkId);
+    }
+
+    if (!cron.validate(healthCheck.cronExpression)) {
+      throw new Error(`Invalid cron expression: ${healthCheck.cronExpression}`);
+    }
+
+    const task = cron.schedule(
+      healthCheck.cronExpression,
+      async () => {
+        try {
+          await healthChecksService.runHealthCheckOnce(checkId, { trigger: 'schedule' });
+        } catch (err) {
+          console.error(`Health check run failed (${healthCheck.name}):`, err);
+        }
+      },
+      {
+        scheduled: false,
+        timezone: healthCheck.timezone || 'UTC',
+      },
+    );
+
+    task.start();
+    this.scheduledChecks.set(checkId, task);
+
+    const nextRunAt = this.calculateNextRun(healthCheck.cronExpression, healthCheck.timezone);
+    await HealthCheck.updateOne({ _id: checkId }, { $set: { nextRunAt } });
+
+    console.log(`Scheduled health check: ${healthCheck.name} (${healthCheck.cronExpression})`);
+  }
+
+  async unscheduleCheck(checkId) {
+    const task = this.scheduledChecks.get(String(checkId));
+    if (!task) return;
+
+    task.stop();
+    this.scheduledChecks.delete(String(checkId));
+
+    await HealthCheck.updateOne({ _id: checkId }, { $set: { nextRunAt: null } });
+  }
+
+  async trigger(checkId) {
+    return await healthChecksService.runHealthCheckOnce(checkId, { trigger: 'manual' });
+  }
+
+  getScheduledChecks() {
+    return Array.from(this.scheduledChecks.keys());
+  }
+}
+
+const scheduler = new HealthChecksScheduler();
+
+module.exports = scheduler;

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) {

package/src/services/llmDefaults.service.js

@@ -0,0 +1,190 @@
+const { getSettingValue } = require('./globalSettings.service');
+
+const GLOBAL_DEFAULT_PROVIDER_KEY = 'llm.defaults.providerKey';
+const GLOBAL_DEFAULT_MODEL_KEY = 'llm.defaults.model';
+const SYSTEM_DEFAULTS_PREFIX = 'llm.systemDefaults.';
+const PROVIDER_MODELS_KEY = 'llm.providerModels';
+
+const CACHE_TTL = 60_000;
+let cache = {
+  ts: 0,
+  globalDefaults: null,
+  systemDefaults: null,
+  providerModels: null,
+};
+
+function trimOrEmpty(value) {
+  return String(value || '').trim();
+}
+
+function parseJsonOrDefault(raw, fallback) {
+  if (!raw) return fallback;
+  try {
+    const parsed = JSON.parse(String(raw));
+    return parsed ?? fallback;
+  } catch (_) {
+    return fallback;
+  }
+}
+
+async function loadCentralConfig() {
+  const now = Date.now();
+  if (cache.ts && now - cache.ts < CACHE_TTL && cache.globalDefaults && cache.systemDefaults && cache.providerModels) {
+    return cache;
+  }
+
+  const providerKey = trimOrEmpty(await getSettingValue(GLOBAL_DEFAULT_PROVIDER_KEY, ''));
+  const model = trimOrEmpty(await getSettingValue(GLOBAL_DEFAULT_MODEL_KEY, ''));
+
+  const systemDefaultsRaw = await getSettingValue('llm.systemDefaults', '{}');
+  const systemDefaults = parseJsonOrDefault(systemDefaultsRaw, {});
+
+  const providerModelsRaw = await getSettingValue(PROVIDER_MODELS_KEY, '{}');
+  const providerModels = parseJsonOrDefault(providerModelsRaw, {});
+
+  cache = {
+    ts: now,
+    globalDefaults: { providerKey, model },
+    systemDefaults: systemDefaults && typeof systemDefaults === 'object' ? systemDefaults : {},
+    providerModels: providerModels && typeof providerModels === 'object' ? providerModels : {},
+  };
+
+  return cache;
+}
+
+function getLegacyResolver(systemKey) {
+  const key = String(systemKey || '').trim();
+
+  const map = {
+    'pageBuilder.blocks.generate': {
+      legacyProviderSettingKey: 'pageBuilder.blocks.ai.providerKey',
+      legacyModelSettingKey: 'pageBuilder.blocks.ai.model',
+      envProviderKey: 'DEFAULT_LLM_PROVIDER_KEY',
+      envModelKey: 'DEFAULT_LLM_MODEL',
+      hardDefaultModel: 'x-ai/grok-code-fast-1',
+    },
+    'pageBuilder.blocks.propose': {
+      legacyProviderSettingKey: 'pageBuilder.blocks.ai.providerKey',
+      legacyModelSettingKey: 'pageBuilder.blocks.ai.model',
+      envProviderKey: 'DEFAULT_LLM_PROVIDER_KEY',
+      envModelKey: 'DEFAULT_LLM_MODEL',
+      hardDefaultModel: 'x-ai/grok-code-fast-1',
+    },
+    'ejsVirtual.vibe.apply': {
+      legacyProviderSettingKey: 'ejsVirtual.ai.providerKey',
+      legacyModelSettingKey: 'ejsVirtual.ai.model',
+      envProviderKey: 'DEFAULT_LLM_PROVIDER_KEY',
+      envModelKey: 'DEFAULT_LLM_MODEL',
+      hardDefaultModel: 'x-ai/grok-code-fast-1',
+    },
+    'uiComponents.proposeEdit': {
+      legacyProviderSettingKey: 'uiComponents.ai.providerKey',
+      legacyModelSettingKey: 'uiComponents.ai.model',
+      envProviderKey: 'DEFAULT_LLM_PROVIDER_KEY',
+      envModelKey: 'DEFAULT_LLM_MODEL',
+      hardDefaultModel: 'x-ai/grok-code-fast-1',
+    },
+    'headless.modelBuilder.chat': {
+      legacyProviderSettingKey: 'headless.aiProviderKey',
+      legacyModelSettingKey: 'headless.aiModel',
+      envProviderKey: 'HEADLESS_AI_PROVIDER_KEY',
+      envModelKey: 'HEADLESS_AI_MODEL',
+      hardDefaultProviderKey: 'openrouter',
+      hardDefaultModel: 'google/gemini-2.5-flash-lite',
+    },
+    'workflow.node.llm': {
+      envProviderKey: 'DEFAULT_LLM_PROVIDER_KEY',
+      envModelKey: 'DEFAULT_LLM_MODEL',
+      hardDefaultProviderKey: 'openrouter',
+      hardDefaultModel: 'minimax/minimax-m2.1',
+    },
+    'seoConfig.entry.generate': {
+      legacyModelSettingKey: 'seoconfig.ai.openrouter.model',
+      envProviderKey: 'DEFAULT_LLM_PROVIDER_KEY',
+      envModelKey: 'DEFAULT_LLM_MODEL',
+      hardDefaultProviderKey: 'openrouter',
+    },
+    'seoConfig.entry.improve': {
+      legacyModelSettingKey: 'seoconfig.ai.openrouter.model',
+      envProviderKey: 'DEFAULT_LLM_PROVIDER_KEY',
+      envModelKey: 'DEFAULT_LLM_MODEL',
+      hardDefaultProviderKey: 'openrouter',
+    },
+    'seoConfig.ogSvg.edit': {
+      legacyModelSettingKey: 'seoconfig.ai.openrouter.model',
+      envProviderKey: 'DEFAULT_LLM_PROVIDER_KEY',
+      envModelKey: 'DEFAULT_LLM_MODEL',
+      hardDefaultProviderKey: 'openrouter',
+    },
+    'i18n.translate.preview': {
+      legacyModelSettingKey: 'i18n.ai.model',
+      envProviderKey: 'DEFAULT_LLM_PROVIDER_KEY',
+      envModelKey: 'DEFAULT_LLM_MODEL',
+      hardDefaultProviderKey: 'openrouter',
+      hardDefaultModel: 'google/gemini-2.5-flash-lite',
+    },
+    'i18n.translate.text': {
+      legacyModelSettingKey: 'i18n.ai.model',
+      envProviderKey: 'DEFAULT_LLM_PROVIDER_KEY',
+      envModelKey: 'DEFAULT_LLM_MODEL',
+      hardDefaultProviderKey: 'openrouter',
+      hardDefaultModel: 'google/gemini-2.5-flash-lite',
+    },
+  };
+
+  return map[key] || null;
+}
+
+async function resolveLlmProviderModel({ systemKey, providerKey, model }) {
+  const uiProviderKey = trimOrEmpty(providerKey);
+  const uiModel = trimOrEmpty(model);
+
+  const { globalDefaults, systemDefaults } = await loadCentralConfig();
+
+  const perSystem = systemKey && systemDefaults && typeof systemDefaults === 'object'
+    ? systemDefaults[String(systemKey)]
+    : null;
+
+  const systemProviderKey = trimOrEmpty(perSystem && perSystem.providerKey);
+  const systemModel = trimOrEmpty(perSystem && perSystem.model);
+
+  const globalProviderKey = trimOrEmpty(globalDefaults && globalDefaults.providerKey);
+  const globalModel = trimOrEmpty(globalDefaults && globalDefaults.model);
+
+  const legacy = getLegacyResolver(systemKey);
+
+  const legacyProviderKey = legacy?.legacyProviderSettingKey
+    ? trimOrEmpty(await getSettingValue(legacy.legacyProviderSettingKey, ''))
+    : '';
+  const legacyModel = legacy?.legacyModelSettingKey
+    ? trimOrEmpty(await getSettingValue(legacy.legacyModelSettingKey, ''))
+    : '';
+
+  const envProviderKey = legacy?.envProviderKey ? trimOrEmpty(process.env[legacy.envProviderKey]) : '';
+  const envModel = legacy?.envModelKey ? trimOrEmpty(process.env[legacy.envModelKey]) : '';
+
+  const resolvedProviderKey = uiProviderKey || systemProviderKey || globalProviderKey || legacyProviderKey || envProviderKey || trimOrEmpty(legacy?.hardDefaultProviderKey);
+  if (!resolvedProviderKey) {
+    const err = new Error('Missing LLM providerKey');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const resolvedModel = uiModel || systemModel || globalModel || legacyModel || envModel || trimOrEmpty(legacy?.hardDefaultModel);
+
+  return { providerKey: resolvedProviderKey, model: resolvedModel };
+}
+
+async function getProviderModelsMap() {
+  const { providerModels } = await loadCentralConfig();
+  return providerModels && typeof providerModels === 'object' ? providerModels : {};
+}
+
+module.exports = {
+  GLOBAL_DEFAULT_PROVIDER_KEY,
+  GLOBAL_DEFAULT_MODEL_KEY,
+  SYSTEM_DEFAULTS_PREFIX,
+  PROVIDER_MODELS_KEY,
+  resolveLlmProviderModel,
+  getProviderModelsMap,
+};

package/src/services/migrationAssets/s3.js

@@ -1,3 +1,5 @@
+const { S3Client, HeadBucketCommand, CreateBucketCommand, PutObjectCommand, GetObjectCommand } = require('@aws-sdk/client-s3');
+
 async function createS3Endpoint({ endpoint, region, bucket, accessKeyId, secretAccessKey, forcePathStyle } = {}) {
   const safeEndpoint = String(endpoint || '').trim();
   const safeBucket = String(bucket || '').trim();
@@ -10,8 +12,6 @@ async function createS3Endpoint({ endpoint, region, bucket, accessKeyId, secretA
     throw err;
   }
 
-  const { S3Client, HeadBucketCommand, CreateBucketCommand, PutObjectCommand, GetObjectCommand } = await import('@aws-sdk/client-s3');
-
   const client = new S3Client({
     endpoint: safeEndpoint,
     region: String(region || 'us-east-1').trim() || 'us-east-1',