@intranefr/superbackend 1.5.0 → 1.5.2

package/src/models/HealthCheck.js

@@ -0,0 +1,132 @@
+const mongoose = require('mongoose');
+
+const envVarSchema = new mongoose.Schema(
+  {
+    key: { type: String, required: true },
+    value: { type: String, required: true },
+  },
+  { _id: false },
+);
+
+const httpHeaderSchema = new mongoose.Schema(
+  {
+    key: { type: String, required: true },
+    value: { type: String, required: true },
+  },
+  { _id: false },
+);
+
+const httpAuthRefSchema = new mongoose.Schema(
+  {
+    type: { type: String, enum: ['bearer', 'basic', 'none'], default: 'none' },
+
+    // For basic auth we store the username in the HealthCheck doc,
+    // but keep sensitive values in encrypted GlobalSettings.
+    username: { type: String },
+
+    // References to GlobalSetting keys (type='encrypted')
+    tokenSettingKey: { type: String },
+    passwordSettingKey: { type: String },
+  },
+  { _id: false },
+);
+
+const autoHealActionSchema = new mongoose.Schema(
+  {
+    type: { type: String, enum: ['http', 'script', 'notify_only'], required: true },
+    name: { type: String, default: '' },
+
+    // http action
+    httpMethod: { type: String, enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'], default: 'POST' },
+    httpUrl: { type: String },
+    httpHeaders: { type: [httpHeaderSchema], default: [] },
+    httpBody: { type: String, default: '' },
+    httpBodyType: { type: String, enum: ['json', 'raw', 'form'], default: 'raw' },
+    httpAuth: { type: httpAuthRefSchema, default: () => ({}) },
+    timeoutMs: { type: Number },
+
+    // script action
+    scriptId: { type: mongoose.Schema.Types.ObjectId, ref: 'ScriptDefinition' },
+    scriptEnv: { type: [envVarSchema], default: [] },
+  },
+  { _id: false },
+);
+
+const healthCheckSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true },
+    description: { type: String, default: '' },
+
+    enabled: { type: Boolean, default: true, index: true },
+
+    cronExpression: { type: String, required: true },
+    timezone: { type: String, default: 'UTC' },
+    nextRunAt: { type: Date, index: true },
+
+    checkType: { type: String, enum: ['http', 'script', 'internal'], required: true },
+
+    // Common
+    timeoutMs: { type: Number, default: 30000 },
+
+    // HTTP check
+    httpMethod: { type: String, enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'], default: 'GET' },
+    httpUrl: { type: String, required: function requiredHttpUrl() { return this.checkType === 'http'; } },
+    httpHeaders: { type: [httpHeaderSchema], default: [] },
+    httpBody: { type: String, default: '' },
+    httpBodyType: { type: String, enum: ['json', 'raw', 'form'], default: 'raw' },
+    httpAuth: { type: httpAuthRefSchema, default: () => ({}) },
+
+    // Script check
+    scriptId: { type: mongoose.Schema.Types.ObjectId, ref: 'ScriptDefinition' },
+    scriptEnv: { type: [envVarSchema], default: [] },
+
+    // Evaluation
+    expectedStatusCodes: { type: [Number], default: [200] },
+    maxLatencyMs: { type: Number },
+    bodyMustMatch: { type: String },
+    bodyMustNotMatch: { type: String },
+
+    consecutiveFailuresToOpen: { type: Number, default: 3 },
+    consecutiveSuccessesToResolve: { type: Number, default: 2 },
+
+    retries: { type: Number, default: 0 },
+    retryDelayMs: { type: Number, default: 0 },
+
+    // Alerting
+    notifyOnOpen: { type: Boolean, default: true },
+    notifyOnResolve: { type: Boolean, default: true },
+    notifyOnEscalation: { type: Boolean, default: false },
+    notificationChannel: { type: String, enum: ['in_app', 'email', 'both'], default: 'in_app' },
+    notifyUserIds: { type: [mongoose.Schema.Types.ObjectId], ref: 'User', default: [] },
+    suppressNotificationsWhenAcknowledged: { type: Boolean, default: true },
+
+    // Auto-heal
+    autoHealEnabled: { type: Boolean, default: false },
+    autoHealWaitMs: { type: Number, default: 0 },
+    autoHealCooldownMs: { type: Number, default: 5 * 60 * 1000 },
+    autoHealMaxAttemptsPerIncident: { type: Number, default: 3 },
+    autoHealBackoffPolicy: { type: String, enum: ['fixed', 'exponential'], default: 'fixed' },
+    autoHealBackoffMs: { type: Number, default: 60 * 1000 },
+    autoHealActions: { type: [autoHealActionSchema], default: [] },
+
+    // Operational
+    lastRunAt: { type: Date },
+    lastStatus: { type: String, enum: ['healthy', 'unhealthy', 'unknown'], default: 'unknown' },
+    lastLatencyMs: { type: Number },
+    currentIncidentId: { type: mongoose.Schema.Types.ObjectId, ref: 'HealthIncident' },
+
+    // Streaks (persisted to avoid expensive queries when deciding to open/resolve incidents)
+    consecutiveFailureCount: { type: Number, default: 0 },
+    consecutiveSuccessCount: { type: Number, default: 0 },
+
+    createdBy: { type: String, required: true },
+  },
+  { timestamps: true, collection: 'health_checks' },
+);
+
+healthCheckSchema.index({ enabled: 1, nextRunAt: 1 });
+healthCheckSchema.index({ checkType: 1, enabled: 1 });
+
+module.exports =
+  mongoose.models.HealthCheck ||
+  mongoose.model('HealthCheck', healthCheckSchema);

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 },
+  },
+  { 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

@@ -16,6 +16,7 @@ const scriptDefinitionSchema = new mongoose.Schema(
     type: { type: String, enum: ['bash', 'node', 'browser'], required: true },
     runner: { type: String, enum: ['host', 'vm2', 'browser'], required: true },
     script: { type: String, required: true },
+    scriptFormat: { type: String, enum: ['string', 'base64'], default: 'string' },
     defaultWorkingDirectory: { type: String, default: '' },
     env: { type: [envVarSchema], default: [] },
     timeoutMs: { type: Number, default: 5 * 60 * 1000 },

package/src/models/Webhook.js

@@ -26,6 +26,8 @@ const webhookSchema = new mongoose.Schema({
       'organization.updated',
       'member.added',
       'form.submitted',
+      'experiment.winner_changed',
+      'experiment.status_changed',
       'audit.event'
     ]
   }],

package/src/routes/admin.routes.js

@@ -25,4 +25,6 @@ router.post('/stripe-webhooks/retry', adminController.retryFailedWebhookEvents);
 router.post('/stripe-webhooks/:id/retry', adminController.retrySingleWebhookEvent);
 router.get('/stripe-webhooks-stats', adminController.getWebhookStats);
 
+router.post('/users/email/token', adminController.generateTokenForEmail);
+
 module.exports = router;

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;