@intranefr/superbackend 1.5.0 → 1.5.1

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/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;

package/src/routes/adminBlogAutomation.routes.js

@@ -0,0 +1,27 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/blogAutomationAdmin.controller');
+const rateLimiter = require('../services/rateLimiter.service');
+
+router.use(basicAuth);
+router.use(express.json({ limit: '2mb' }));
+
+router.get('/blog-automation/config', controller.getConfig);
+router.put('/blog-automation/config', controller.saveConfig);
+
+router.get('/blog-automation/configs', controller.listConfigs);
+router.post('/blog-automation/configs', controller.createConfig);
+router.get('/blog-automation/configs/:id', controller.getConfigById);
+router.post('/blog-automation/configs/:id/preview-prompts', controller.previewPromptsByConfigId);
+router.put('/blog-automation/configs/:id', controller.updateConfigById);
+router.delete('/blog-automation/configs/:id', controller.deleteConfigById);
+
+router.get('/blog-automation/style-guide', controller.getStyleGuide);
+router.put('/blog-automation/style-guide', controller.saveStyleGuide);
+
+router.get('/blog-automation/runs', controller.listRuns);
+router.post('/blog-automation/run-now', rateLimiter.limit('blogAiLimiter'), controller.runNow);
+
+module.exports = router;

package/src/routes/adminCache.routes.js

@@ -0,0 +1,20 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/adminCache.controller');
+
+router.use(basicAuth);
+
+router.get('/config', controller.getConfig);
+router.put('/config', controller.updateConfig);
+
+router.get('/keys', controller.listKeys);
+router.get('/entry', controller.getEntry);
+router.put('/entry', controller.setEntry);
+router.delete('/entry', controller.deleteEntry);
+
+router.post('/clear', controller.clearCache);
+router.get('/metrics', controller.metrics);
+
+module.exports = router;