@intranefr/superbackend 1.4.4 → 1.5.1

package/src/models/HealthCheckRun.js

@@ -0,0 +1,51 @@
+const mongoose = require('mongoose');
+
+const healthCheckRunSchema = new mongoose.Schema(
+  {
+    healthCheckId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'HealthCheck',
+      required: true,
+      index: true,
+    },
+
+    status: {
+      type: String,
+      enum: ['running', 'healthy', 'unhealthy', 'timed_out', 'error'],
+      default: 'running',
+      index: true,
+    },
+
+    attempt: { type: Number, default: 0 },
+
+    startedAt: { type: Date, default: Date.now, index: true },
+    finishedAt: { type: Date },
+    durationMs: { type: Number },
+
+    latencyMs: { type: Number },
+
+    httpStatusCode: { type: Number },
+    httpResponseHeaders: { type: mongoose.Schema.Types.Mixed },
+    responseBodySnippet: { type: String },
+
+    reason: { type: String },
+    errorMessage: { type: String },
+
+    incidentId: { type: mongoose.Schema.Types.ObjectId, ref: 'HealthIncident' },
+  },
+  { timestamps: true, collection: 'health_check_runs' },
+);
+
+healthCheckRunSchema.index({ healthCheckId: 1, startedAt: -1 });
+healthCheckRunSchema.index({ status: 1, startedAt: -1 });
+
+healthCheckRunSchema.pre('save', function preSave(next) {
+  if (this.isModified('finishedAt') && this.finishedAt && this.startedAt) {
+    this.durationMs = this.finishedAt.getTime() - this.startedAt.getTime();
+  }
+  next();
+});
+
+module.exports =
+  mongoose.models.HealthCheckRun ||
+  mongoose.model('HealthCheckRun', healthCheckRunSchema);

package/src/models/HealthIncident.js

@@ -0,0 +1,49 @@
+const mongoose = require('mongoose');
+
+const healthIncidentSchema = new mongoose.Schema(
+  {
+    healthCheckId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'HealthCheck',
+      required: true,
+      index: true,
+    },
+
+    status: {
+      type: String,
+      enum: ['open', 'acknowledged', 'resolved'],
+      default: 'open',
+      index: true,
+    },
+
+    severity: {
+      type: String,
+      enum: ['warning', 'critical'],
+      default: 'warning',
+    },
+
+    openedAt: { type: Date, default: Date.now, index: true },
+    acknowledgedAt: { type: Date },
+    resolvedAt: { type: Date },
+    lastSeenAt: { type: Date, default: Date.now },
+
+    consecutiveFailureCount: { type: Number, default: 0 },
+    consecutiveSuccessCount: { type: Number, default: 0 },
+
+    lastRunId: { type: mongoose.Schema.Types.ObjectId, ref: 'HealthCheckRun' },
+
+    summary: { type: String, default: '' },
+    lastError: { type: String, default: '' },
+
+    autoHealAttemptCount: { type: Number, default: 0 },
+    lastAutoHealAttemptAt: { type: Date },
+  },
+  { timestamps: true, collection: 'health_incidents' },
+);
+
+healthIncidentSchema.index({ healthCheckId: 1, openedAt: -1 });
+healthIncidentSchema.index({ status: 1, openedAt: -1 });
+
+module.exports =
+  mongoose.models.HealthIncident ||
+  mongoose.model('HealthIncident', healthIncidentSchema);

package/src/models/Page.js

@@ -0,0 +1,95 @@
+const mongoose = require('mongoose');
+
+const seoMetaSchema = new mongoose.Schema(
+  {
+    title: { type: String, default: '' },
+    description: { type: String, default: '' },
+    keywords: { type: String, default: '' },
+    ogImage: { type: String, default: '' },
+    canonicalUrl: { type: String, default: '' },
+  },
+  { _id: false },
+);
+
+const pageSchema = new mongoose.Schema(
+  {
+    slug: {
+      type: String,
+      required: true,
+      index: true,
+    },
+    collectionId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'PageCollection',
+      default: null,
+      index: true,
+    },
+    title: {
+      type: String,
+      required: true,
+    },
+    templateKey: {
+      type: String,
+      default: 'default',
+    },
+    layoutKey: {
+      type: String,
+      default: 'default',
+    },
+    blocks: {
+      type: mongoose.Schema.Types.Mixed,
+      default: [],
+    },
+    repeat: {
+      type: mongoose.Schema.Types.Mixed,
+      default: null,
+    },
+    customCss: {
+      type: String,
+      default: '',
+    },
+    customJs: {
+      type: String,
+      default: '',
+    },
+    seoMeta: {
+      type: seoMetaSchema,
+      default: () => ({}),
+    },
+    tenantId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Organization',
+      default: null,
+      index: true,
+    },
+    isGlobal: {
+      type: Boolean,
+      default: true,
+      index: true,
+    },
+    status: {
+      type: String,
+      enum: ['draft', 'published', 'archived'],
+      default: 'draft',
+      index: true,
+    },
+    publishedAt: {
+      type: Date,
+      default: null,
+    },
+  },
+  { timestamps: true },
+);
+
+pageSchema.index({ slug: 1, collectionId: 1, tenantId: 1 }, { unique: true });
+pageSchema.index({ status: 1, isGlobal: 1 });
+pageSchema.index({ collectionId: 1, status: 1 });
+
+pageSchema.virtual('routePath').get(function () {
+  return this._routePath || null;
+});
+
+pageSchema.set('toJSON', { virtuals: true });
+pageSchema.set('toObject', { virtuals: true });
+
+module.exports = mongoose.model('Page', pageSchema);

package/src/models/PageCollection.js

@@ -0,0 +1,42 @@
+const mongoose = require('mongoose');
+
+const pageCollectionSchema = new mongoose.Schema(
+  {
+    slug: {
+      type: String,
+      required: true,
+      index: true,
+    },
+    name: {
+      type: String,
+      required: true,
+    },
+    description: {
+      type: String,
+      default: '',
+    },
+    tenantId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Organization',
+      default: null,
+      index: true,
+    },
+    isGlobal: {
+      type: Boolean,
+      default: true,
+      index: true,
+    },
+    status: {
+      type: String,
+      enum: ['active', 'archived'],
+      default: 'active',
+      index: true,
+    },
+  },
+  { timestamps: true },
+);
+
+pageCollectionSchema.index({ slug: 1, tenantId: 1 }, { unique: true });
+pageCollectionSchema.index({ isGlobal: 1, status: 1 });
+
+module.exports = mongoose.model('PageCollection', pageCollectionSchema);

package/src/models/ProxyEntry.js

@@ -0,0 +1,66 @@
+const mongoose = require('mongoose');
+
+const proxyRuleSchema = new mongoose.Schema(
+  {
+    enabled: { type: Boolean, default: true },
+    type: { type: String, enum: ['contains', 'regexp'], required: true },
+    value: { type: String, required: true },
+    applyTo: { type: String, enum: ['targetUrl', 'host', 'path'], default: 'targetUrl' },
+    flags: { type: String, default: 'i' },
+  },
+  { _id: false },
+);
+
+const proxyEntrySchema = new mongoose.Schema(
+  {
+    name: { type: String, default: '' },
+    enabled: { type: Boolean, default: false, index: true },
+    match: {
+      type: {
+        type: String,
+        enum: ['exact', 'contains', 'regexp'],
+        default: 'contains',
+      },
+      value: { type: String, required: true },
+      applyTo: { type: String, enum: ['targetUrl', 'host', 'path'], default: 'host' },
+      flags: { type: String, default: 'i' },
+    },
+    policy: {
+      mode: { type: String, enum: ['blacklist', 'whitelist', 'allowAll', 'denyAll'], default: 'whitelist' },
+      rules: { type: [proxyRuleSchema], default: [] },
+    },
+    rateLimit: {
+      enabled: { type: Boolean, default: false },
+      limiterId: { type: String, default: null },
+    },
+    cache: {
+      enabled: { type: Boolean, default: false },
+      ttlSeconds: { type: Number, default: 60 },
+      namespace: { type: String, default: 'proxy' },
+      methods: { type: [String], default: ['GET', 'HEAD'] },
+      keyParts: {
+        url: { type: Boolean, default: true },
+        query: { type: Boolean, default: true },
+        bodyHash: { type: Boolean, default: true },
+        headersHash: { type: Boolean, default: true },
+      },
+      keyHeaderAllowList: { type: [String], default: [] },
+    },
+    headers: {
+      forwardAuthorization: { type: Boolean, default: true },
+      forwardCookie: { type: Boolean, default: true },
+      allowList: { type: [String], default: [] },
+      denyList: { type: [String], default: [] },
+    },
+    transform: {
+      enabled: { type: Boolean, default: false },
+      timeoutMs: { type: Number, default: 200 },
+      code: { type: String, default: '' },
+    },
+  },
+  { timestamps: true, collection: 'proxy_entries' },
+);
+
+proxyEntrySchema.index({ 'match.type': 1, 'match.applyTo': 1 });
+
+module.exports = mongoose.models.ProxyEntry || mongoose.model('ProxyEntry', proxyEntrySchema);

package/src/models/RateLimitCounter.js

@@ -0,0 +1,19 @@
+const mongoose = require('mongoose');
+
+const rateLimitCounterSchema = new mongoose.Schema(
+  {
+    limiterId: { type: String, required: true, index: true },
+    identityKey: { type: String, required: true, index: true },
+    windowStart: { type: Date, required: true, index: true },
+
+    count: { type: Number, default: 0 },
+
+    expiresAt: { type: Date, default: null, index: true },
+  },
+  { timestamps: true, collection: 'rate_limit_counters' },
+);
+
+rateLimitCounterSchema.index({ limiterId: 1, identityKey: 1, windowStart: 1 }, { unique: true });
+rateLimitCounterSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+
+module.exports = mongoose.models.RateLimitCounter || mongoose.model('RateLimitCounter', rateLimitCounterSchema);

package/src/models/RateLimitMetricBucket.js

@@ -0,0 +1,20 @@
+const mongoose = require('mongoose');
+
+const rateLimitMetricBucketSchema = new mongoose.Schema(
+  {
+    bucketStart: { type: Date, required: true, index: true },
+    limiterId: { type: String, required: true, index: true },
+
+    checked: { type: Number, default: 0 },
+    allowed: { type: Number, default: 0 },
+    blocked: { type: Number, default: 0 },
+
+    expiresAt: { type: Date, default: null, index: true },
+  },
+  { timestamps: true, collection: 'rate_limit_metric_buckets' },
+);
+
+rateLimitMetricBucketSchema.index({ limiterId: 1, bucketStart: 1 }, { unique: true });
+rateLimitMetricBucketSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+
+module.exports = mongoose.models.RateLimitMetricBucket || mongoose.model('RateLimitMetricBucket', rateLimitMetricBucketSchema);

package/src/models/RbacGrant.js

@@ -0,0 +1,25 @@
+const mongoose = require('mongoose');
+
+const rbacGrantSchema = new mongoose.Schema(
+  {
+    subjectType: { type: String, enum: ['user', 'role', 'group', 'org'], required: true, index: true },
+    subjectId: { type: mongoose.Schema.Types.ObjectId, required: true, index: true },
+
+    scopeType: { type: String, enum: ['global', 'org'], required: true, index: true },
+    scopeId: { type: mongoose.Schema.Types.ObjectId, ref: 'Organization', default: null, index: true },
+
+    right: { type: String, required: true, trim: true, index: true },
+    effect: { type: String, enum: ['allow', 'deny'], default: 'allow', index: true },
+
+    createdByActorType: { type: String, default: null },
+    createdByActorId: { type: String, default: null },
+  },
+  { timestamps: true, collection: 'rbac_grants' },
+);
+
+rbacGrantSchema.index(
+  { subjectType: 1, subjectId: 1, scopeType: 1, scopeId: 1, right: 1 },
+  { unique: true },
+);
+
+module.exports = mongoose.models.RbacGrant || mongoose.model('RbacGrant', rbacGrantSchema);

package/src/models/RbacGroup.js

@@ -0,0 +1,16 @@
+const mongoose = require('mongoose');
+
+const rbacGroupSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true, trim: true },
+    description: { type: String, default: '', trim: true },
+    status: { type: String, enum: ['active', 'disabled'], default: 'active', index: true },
+    isGlobal: { type: Boolean, default: true, index: true },
+    orgId: { type: mongoose.Schema.Types.ObjectId, ref: 'Organization', default: null, index: true },
+  },
+  { timestamps: true, collection: 'rbac_groups' },
+);
+
+rbacGroupSchema.index({ isGlobal: 1, orgId: 1, name: 1 });
+
+module.exports = mongoose.models.RbacGroup || mongoose.model('RbacGroup', rbacGroupSchema);

package/src/models/RbacGroupMember.js

@@ -0,0 +1,13 @@
+const mongoose = require('mongoose');
+
+const rbacGroupMemberSchema = new mongoose.Schema(
+  {
+    groupId: { type: mongoose.Schema.Types.ObjectId, ref: 'RbacGroup', required: true, index: true },
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true, index: true },
+  },
+  { timestamps: true, collection: 'rbac_group_members' },
+);
+
+rbacGroupMemberSchema.index({ groupId: 1, userId: 1 }, { unique: true });
+
+module.exports = mongoose.models.RbacGroupMember || mongoose.model('RbacGroupMember', rbacGroupMemberSchema);

package/src/models/RbacGroupRole.js

@@ -0,0 +1,13 @@
+const mongoose = require('mongoose');
+
+const rbacGroupRoleSchema = new mongoose.Schema(
+  {
+    groupId: { type: mongoose.Schema.Types.ObjectId, ref: 'RbacGroup', required: true, index: true },
+    roleId: { type: mongoose.Schema.Types.ObjectId, ref: 'RbacRole', required: true, index: true },
+  },
+  { timestamps: true, collection: 'rbac_group_roles' },
+);
+
+rbacGroupRoleSchema.index({ groupId: 1, roleId: 1 }, { unique: true });
+
+module.exports = mongoose.models.RbacGroupRole || mongoose.model('RbacGroupRole', rbacGroupRoleSchema);

package/src/models/RbacRole.js

@@ -0,0 +1,25 @@
+const mongoose = require('mongoose');
+
+const rbacRoleSchema = new mongoose.Schema(
+  {
+    key: { type: String, required: true, trim: true, lowercase: true, index: true },
+    name: { type: String, required: true, trim: true },
+    description: { type: String, default: '', trim: true },
+    status: { type: String, enum: ['active', 'disabled'], default: 'active', index: true },
+    isGlobal: { type: Boolean, default: true, index: true },
+    orgId: { type: mongoose.Schema.Types.ObjectId, ref: 'Organization', default: null, index: true },
+  },
+  { timestamps: true, collection: 'rbac_roles' },
+);
+
+rbacRoleSchema.index({ isGlobal: 1, orgId: 1, key: 1 });
+rbacRoleSchema.index(
+  { key: 1 },
+  { unique: true, partialFilterExpression: { isGlobal: true } },
+);
+rbacRoleSchema.index(
+  { orgId: 1, key: 1 },
+  { unique: true, partialFilterExpression: { isGlobal: false } },
+);
+
+module.exports = mongoose.models.RbacRole || mongoose.model('RbacRole', rbacRoleSchema);

package/src/models/RbacUserRole.js

@@ -0,0 +1,13 @@
+const mongoose = require('mongoose');
+
+const rbacUserRoleSchema = new mongoose.Schema(
+  {
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true, index: true },
+    roleId: { type: mongoose.Schema.Types.ObjectId, ref: 'RbacRole', required: true, index: true },
+  },
+  { timestamps: true, collection: 'rbac_user_roles' },
+);
+
+rbacUserRoleSchema.index({ userId: 1, roleId: 1 }, { unique: true });
+
+module.exports = mongoose.models.RbacUserRole || mongoose.model('RbacUserRole', rbacUserRoleSchema);

package/src/models/ScriptDefinition.js

@@ -0,0 +1,42 @@
+const mongoose = require('mongoose');
+
+const envVarSchema = new mongoose.Schema(
+  {
+    key: { type: String, required: true },
+    value: { type: String, required: true },
+  },
+  { _id: false },
+);
+
+const scriptDefinitionSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true },
+    codeIdentifier: { type: String, required: true, unique: true, index: true },
+    description: { type: String, default: '' },
+    type: { type: String, enum: ['bash', 'node', 'browser'], required: true },
+    runner: { type: String, enum: ['host', 'vm2', 'browser'], required: true },
+    script: { type: String, required: true },
+    defaultWorkingDirectory: { type: String, default: '' },
+    env: { type: [envVarSchema], default: [] },
+    timeoutMs: { type: Number, default: 5 * 60 * 1000 },
+    enabled: { type: Boolean, default: true, index: true },
+  },
+  { timestamps: true, collection: 'script_definitions' },
+);
+
+function normalizeCodeIdentifier(codeIdentifier) {
+  return String(codeIdentifier || '')
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, '-')
+    .replace(/[^a-z0-9_-]/g, '');
+}
+
+scriptDefinitionSchema.pre('validate', function preValidate(next) {
+  this.codeIdentifier = normalizeCodeIdentifier(this.codeIdentifier);
+  next();
+});
+
+module.exports =
+  mongoose.models.ScriptDefinition ||
+  mongoose.model('ScriptDefinition', scriptDefinitionSchema);

package/src/models/ScriptRun.js

@@ -0,0 +1,22 @@
+const mongoose = require('mongoose');
+
+const scriptRunSchema = new mongoose.Schema(
+  {
+    scriptId: { type: mongoose.Schema.Types.ObjectId, ref: 'ScriptDefinition', required: true, index: true },
+    status: {
+      type: String,
+      enum: ['queued', 'running', 'succeeded', 'failed', 'canceled', 'timed_out'],
+      default: 'queued',
+      index: true,
+    },
+    trigger: { type: String, enum: ['manual', 'schedule', 'api'], default: 'manual', index: true },
+    startedAt: { type: Date, default: null },
+    finishedAt: { type: Date, default: null },
+    exitCode: { type: Number, default: null },
+    outputTail: { type: String, default: '' },
+    meta: { type: mongoose.Schema.Types.Mixed, default: null },
+  },
+  { timestamps: true, collection: 'script_runs' },
+);
+
+module.exports = mongoose.models.ScriptRun || mongoose.model('ScriptRun', scriptRunSchema);

package/src/models/UiComponent.js

@@ -0,0 +1,29 @@
+const mongoose = require('mongoose');
+
+const uiComponentSchema = new mongoose.Schema(
+  {
+    code: {
+      type: String,
+      required: true,
+      unique: true,
+      index: true,
+      trim: true,
+      lowercase: true,
+      match: [/^[a-z][a-z0-9_-]{1,63}$/, 'Invalid component code'],
+    },
+    name: { type: String, required: true, trim: true },
+
+    html: { type: String, default: '' },
+    js: { type: String, default: '' },
+    css: { type: String, default: '' },
+
+    api: { type: mongoose.Schema.Types.Mixed, default: null },
+    usageMarkdown: { type: String, default: '' },
+
+    version: { type: Number, default: 1 },
+    isActive: { type: Boolean, default: true, index: true },
+  },
+  { timestamps: true, collection: 'ui_components' },
+);
+
+module.exports = mongoose.models.UiComponent || mongoose.model('UiComponent', uiComponentSchema);

package/src/models/UiComponentProject.js

@@ -0,0 +1,26 @@
+const mongoose = require('mongoose');
+
+const uiComponentProjectSchema = new mongoose.Schema(
+  {
+    projectId: {
+      type: String,
+      required: true,
+      unique: true,
+      index: true,
+      trim: true,
+      match: [/^prj_[a-z0-9]{8,32}$/, 'Invalid projectId'],
+    },
+    name: { type: String, required: true, trim: true },
+
+    isPublic: { type: Boolean, default: true, index: true },
+    apiKeyHash: { type: String, default: null },
+
+    allowedOrigins: { type: [String], default: [] },
+
+    isActive: { type: Boolean, default: true, index: true },
+  },
+  { timestamps: true, collection: 'ui_component_projects' },
+);
+
+module.exports = mongoose.models.UiComponentProject ||
+  mongoose.model('UiComponentProject', uiComponentProjectSchema);

package/src/models/UiComponentProjectComponent.js

@@ -0,0 +1,18 @@
+const mongoose = require('mongoose');
+
+const uiComponentProjectComponentSchema = new mongoose.Schema(
+  {
+    projectId: { type: String, required: true, index: true },
+    componentCode: { type: String, required: true, index: true },
+    enabled: { type: Boolean, default: true, index: true },
+  },
+  { timestamps: true, collection: 'ui_component_project_components' },
+);
+
+uiComponentProjectComponentSchema.index(
+  { projectId: 1, componentCode: 1 },
+  { unique: true },
+);
+
+module.exports = mongoose.models.UiComponentProjectComponent ||
+  mongoose.model('UiComponentProjectComponent', uiComponentProjectComponentSchema);

package/src/routes/admin.routes.js

@@ -11,6 +11,7 @@ router.post('/users/register', adminController.registerUser);
 router.get('/users/:id', adminController.getUser);
 router.put('/users/:id/subscription', adminController.updateUserSubscription);
 router.patch('/users/:id', adminController.updateUserPassword);
+router.delete('/users/:id', adminController.deleteUser);
 router.post('/users/:id/reconcile', adminController.reconcileUser);
 router.post('/generate-token', adminController.generateToken);
 

package/src/routes/adminBlog.routes.js

@@ -0,0 +1,21 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/blogAdmin.controller');
+
+router.use(basicAuth);
+router.use(express.json({ limit: '2mb' }));
+
+router.get('/blog-posts', controller.list);
+router.get('/blog-posts/suggestions', controller.suggestions);
+router.post('/blog-posts', controller.create);
+router.get('/blog-posts/:id', controller.get);
+router.put('/blog-posts/:id', controller.update);
+router.put('/blog-posts/:id/publish', controller.publish);
+router.put('/blog-posts/:id/unpublish', controller.unpublish);
+router.put('/blog-posts/:id/schedule', controller.schedule);
+router.put('/blog-posts/:id/archive', controller.archive);
+router.delete('/blog-posts/:id', controller.remove);
+
+module.exports = router;

package/src/routes/adminBlogAi.routes.js

@@ -0,0 +1,16 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/blogAiAdmin.controller');
+const rateLimiter = require('../services/rateLimiter.service');
+
+router.use(basicAuth);
+router.use(express.json({ limit: '2mb' }));
+
+router.post('/blog-ai/generate-field', rateLimiter.limit('blogAiLimiter'), controller.generateField);
+router.post('/blog-ai/generate-all', rateLimiter.limit('blogAiLimiter'), controller.generateAll);
+router.post('/blog-ai/format-markdown', rateLimiter.limit('blogAiLimiter'), controller.formatMarkdown);
+router.post('/blog-ai/refine-markdown', rateLimiter.limit('blogAiLimiter'), controller.refineMarkdown);
+
+module.exports = router;