@intranefr/superbackend 1.4.4 → 1.5.1

package/src/models/BlockDefinition.js

@@ -0,0 +1,27 @@
+const mongoose = require('mongoose');
+
+const blockDefinitionSchema = 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 block code'],
+    },
+
+    label: { type: String, required: true, trim: true },
+    description: { type: String, default: '' },
+
+    // Fields schema (server-side validation happens in services)
+    fields: { type: mongoose.Schema.Types.Mixed, default: {} },
+
+    version: { type: Number, default: 1 },
+    isActive: { type: Boolean, default: true, index: true },
+  },
+  { timestamps: true, collection: 'page_builder_block_definitions' },
+);
+
+module.exports = mongoose.models.BlockDefinition || mongoose.model('BlockDefinition', blockDefinitionSchema);

package/src/models/BlogAutomationLock.js

@@ -0,0 +1,14 @@
+const mongoose = require('mongoose');
+
+const blogAutomationLockSchema = new mongoose.Schema(
+  {
+    key: { type: String, required: true, unique: true, index: true },
+    lockedUntil: { type: Date, required: true },
+    ownerId: { type: String, required: true },
+  },
+  { timestamps: true, collection: 'blog_automation_locks' },
+);
+
+module.exports =
+  mongoose.models.BlogAutomationLock ||
+  mongoose.model('BlogAutomationLock', blogAutomationLockSchema);

package/src/models/BlogAutomationRun.js

@@ -0,0 +1,39 @@
+const mongoose = require('mongoose');
+
+const blogAutomationRunSchema = new mongoose.Schema(
+  {
+    status: {
+      type: String,
+      enum: ['queued', 'running', 'succeeded', 'failed', 'partial', 'skipped'],
+      default: 'queued',
+      index: true,
+    },
+    configId: {
+      type: String,
+      default: '',
+      index: true,
+    },
+    trigger: {
+      type: String,
+      enum: ['scheduled', 'manual'],
+      required: true,
+      index: true,
+    },
+    startedAt: { type: Date },
+    finishedAt: { type: Date },
+    configSnapshot: { type: mongoose.Schema.Types.Mixed, default: {} },
+    topic: { type: mongoose.Schema.Types.Mixed, default: {} },
+    results: { type: mongoose.Schema.Types.Mixed, default: {} },
+    steps: { type: [mongoose.Schema.Types.Mixed], default: [] },
+    error: { type: String, default: '' },
+  },
+  { timestamps: true, collection: 'blog_automation_runs' },
+);
+
+blogAutomationRunSchema.index({ createdAt: -1 });
+blogAutomationRunSchema.index({ trigger: 1, createdAt: -1 });
+blogAutomationRunSchema.index({ configId: 1, createdAt: -1 });
+
+module.exports =
+  mongoose.models.BlogAutomationRun ||
+  mongoose.model('BlogAutomationRun', blogAutomationRunSchema);

package/src/models/BlogPost.js

@@ -0,0 +1,42 @@
+const mongoose = require('mongoose');
+
+const blogPostSchema = new mongoose.Schema(
+  {
+    title: { type: String, required: true },
+    slug: { type: String, required: true, index: true },
+    status: {
+      type: String,
+      enum: ['draft', 'scheduled', 'published', 'archived'],
+      default: 'draft',
+      index: true,
+    },
+    excerpt: { type: String, default: '' },
+    markdown: { type: String, default: '' },
+    html: { type: String, default: '' },
+    coverImageUrl: { type: String, default: '' },
+    category: { type: String, default: '' },
+    tags: { type: [String], default: [] },
+    authorName: { type: String, default: '' },
+    seoTitle: { type: String, default: '' },
+    seoDescription: { type: String, default: '' },
+    scheduledAt: { type: Date },
+    publishedAt: { type: Date },
+  },
+  { timestamps: true, collection: 'blog_posts' },
+);
+
+blogPostSchema.index({ status: 1, publishedAt: -1 });
+blogPostSchema.index({ status: 1, scheduledAt: 1 });
+
+// Enforce slug uniqueness among non-archived posts. Archived posts free up slugs.
+blogPostSchema.index(
+  { slug: 1 },
+  {
+    unique: true,
+    partialFilterExpression: {
+      status: { $in: ['draft', 'scheduled', 'published'] },
+    },
+  },
+);
+
+module.exports = mongoose.models.BlogPost || mongoose.model('BlogPost', blogPostSchema);

package/src/models/CacheEntry.js

@@ -0,0 +1,26 @@
+const mongoose = require('mongoose');
+
+const cacheEntrySchema = new mongoose.Schema(
+  {
+    namespace: { type: String, required: true, index: true },
+    key: { type: String, required: true, index: true },
+
+    value: { type: String, required: true },
+    atRestFormat: { type: String, enum: ['string', 'base64'], default: 'string', index: true },
+
+    sizeBytes: { type: Number, default: 0 },
+
+    expiresAt: { type: Date, default: null, index: true },
+
+    hits: { type: Number, default: 0 },
+    lastAccessAt: { type: Date, default: null },
+
+    source: { type: String, enum: ['offloaded', 'manual'], default: 'manual', index: true },
+  },
+  { timestamps: true, collection: 'cache_entries' },
+);
+
+cacheEntrySchema.index({ namespace: 1, key: 1 }, { unique: true });
+cacheEntrySchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+
+module.exports = mongoose.models.CacheEntry || mongoose.model('CacheEntry', cacheEntrySchema);

package/src/models/ConsoleEntry.js

@@ -0,0 +1,32 @@
+const mongoose = require('mongoose');
+
+const consoleEntrySchema = new mongoose.Schema(
+  {
+    hash: { type: String, required: true, unique: true, index: true },
+    method: { type: String, enum: ['debug', 'log', 'info', 'warn', 'error'], required: true, index: true },
+
+    messageTemplate: { type: String, default: '', maxlength: 500 },
+    topFrame: { type: String, default: '' },
+
+    enabled: { type: Boolean, default: true, index: true },
+    enabledExplicit: { type: Boolean, default: false, index: true },
+
+    persistToCache: { type: Boolean, default: false },
+    persistToDb: { type: Boolean, default: false },
+    persistExplicit: { type: Boolean, default: false, index: true },
+
+    tags: { type: [String], default: [], index: true },
+
+    countTotal: { type: Number, default: 0 },
+    firstSeenAt: { type: Date, default: Date.now },
+    lastSeenAt: { type: Date, default: Date.now, index: true },
+
+    lastSample: { type: mongoose.Schema.Types.Mixed, default: null },
+  },
+  { timestamps: true, collection: 'console_entries' },
+);
+
+consoleEntrySchema.index({ method: 1, lastSeenAt: -1 });
+consoleEntrySchema.index({ enabled: 1, lastSeenAt: -1 });
+
+module.exports = mongoose.models.ConsoleEntry || mongoose.model('ConsoleEntry', consoleEntrySchema);

package/src/models/ConsoleLog.js

@@ -0,0 +1,23 @@
+const mongoose = require('mongoose');
+
+const consoleLogSchema = new mongoose.Schema(
+  {
+    entryHash: { type: String, required: true, index: true },
+    method: { type: String, enum: ['debug', 'log', 'info', 'warn', 'error'], required: true, index: true },
+
+    message: { type: String, default: '', maxlength: 2000 },
+    argsPreview: { type: String, default: '', maxlength: 5000 },
+
+    tagsSnapshot: { type: [String], default: [], index: true },
+    requestId: { type: String, default: '', index: true },
+
+    createdAt: { type: Date, default: Date.now, index: true },
+    expiresAt: { type: Date, default: null, index: true },
+  },
+  { timestamps: false, collection: 'console_logs' },
+);
+
+consoleLogSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+consoleLogSchema.index({ entryHash: 1, createdAt: -1 });
+
+module.exports = mongoose.models.ConsoleLog || mongoose.model('ConsoleLog', consoleLogSchema);

package/src/models/ContextBlockDefinition.js

@@ -0,0 +1,33 @@
+const mongoose = require('mongoose');
+
+const contextBlockDefinitionSchema = 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 context block code'],
+    },
+
+    label: { type: String, required: true, trim: true },
+    description: { type: String, default: '' },
+
+    type: {
+      type: String,
+      required: true,
+      enum: ['context.db_query', 'context.service_invoke'],
+      index: true,
+    },
+
+    props: { type: mongoose.Schema.Types.Mixed, default: {} },
+
+    version: { type: Number, default: 1 },
+    isActive: { type: Boolean, default: true, index: true },
+  },
+  { timestamps: true, collection: 'page_builder_context_block_definitions' },
+);
+
+module.exports = mongoose.models.ContextBlockDefinition || mongoose.model('ContextBlockDefinition', contextBlockDefinitionSchema);

package/src/models/CronExecution.js

@@ -0,0 +1,47 @@
+const mongoose = require('mongoose');
+
+const cronExecutionSchema = new mongoose.Schema(
+  {
+    cronJobId: { type: mongoose.Schema.Types.ObjectId, ref: 'CronJob', required: true, index: true },
+    
+    // Execution details
+    status: { 
+      type: String, 
+      enum: ['running', 'succeeded', 'failed', 'timed_out'], 
+      default: 'running',
+      index: true 
+    },
+    startedAt: { type: Date, default: Date.now, index: true },
+    finishedAt: { type: Date },
+    durationMs: { type: Number },
+    
+    // Results
+    output: { type: String },
+    error: { type: String },
+    
+    // HTTP specific
+    httpStatusCode: { type: Number },
+    httpResponseHeaders: { type: mongoose.Schema.Types.Mixed },
+    
+    // Metadata
+    triggeredAt: { type: Date, required: true }, // When it was supposed to run
+    actualRunAt: { type: Date, default: Date.now }, // When it actually started
+  },
+  { timestamps: true, collection: 'cron_executions' },
+);
+
+// Index for efficient queries
+cronExecutionSchema.index({ cronJobId: 1, startedAt: -1 });
+cronExecutionSchema.index({ status: 1, startedAt: -1 });
+
+// Calculate duration before saving
+cronExecutionSchema.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.CronExecution ||
+  mongoose.model('CronExecution', cronExecutionSchema);

package/src/models/CronJob.js

@@ -0,0 +1,70 @@
+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 httpAuthSchema = new mongoose.Schema(
+  {
+    type: { type: String, enum: ['bearer', 'basic', 'none'], default: 'none' },
+    token: { type: String },
+    username: { type: String },
+    password: { type: String },
+  },
+  { _id: false },
+);
+
+const cronJobSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true },
+    description: { type: String, default: '' },
+    
+    // Schedule configuration
+    cronExpression: { type: String, required: true },
+    timezone: { type: String, default: 'UTC' },
+    enabled: { type: Boolean, default: true, index: true },
+    nextRunAt: { type: Date, index: true },
+    
+    // Task configuration
+    taskType: { type: String, enum: ['script', 'http'], required: true },
+    
+    // Script task fields
+    scriptId: { type: mongoose.Schema.Types.ObjectId, ref: 'ScriptDefinition' },
+    scriptEnv: { type: [envVarSchema], default: [] },
+    
+    // HTTP task fields
+    httpMethod: { type: String, enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'], default: 'GET' },
+    httpUrl: { type: String, required: function() { return this.taskType === 'http'; } },
+    httpHeaders: { type: [httpHeaderSchema], default: [] },
+    httpBody: { type: String },
+    httpBodyType: { type: String, enum: ['json', 'raw', 'form'], default: 'raw' },
+    httpAuth: { type: httpAuthSchema, default: () => ({}) },
+    
+    // Common fields
+    timeoutMs: { type: Number, default: 300000 }, // 5 minutes
+    
+    // Metadata
+    createdBy: { type: String, required: true },
+  },
+  { timestamps: true, collection: 'cron_jobs' },
+);
+
+// Index for efficient queries
+cronJobSchema.index({ taskType: 1, enabled: 1 });
+cronJobSchema.index({ nextRunAt: 1, enabled: 1 });
+
+module.exports =
+  mongoose.models.CronJob ||
+  mongoose.model('CronJob', cronJobSchema);

package/src/models/ExternalDbConnection.js

@@ -0,0 +1,49 @@
+const mongoose = require('mongoose');
+
+const externalDbConnectionSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+      unique: true,
+      trim: true,
+      index: true,
+    },
+    type: {
+      type: String,
+      required: true,
+      enum: ['mongo', 'mysql'],
+      index: true,
+    },
+    enabled: {
+      type: Boolean,
+      default: true,
+      index: true,
+    },
+
+    // Non-secret (safe to return)
+    uriMasked: {
+      type: String,
+      default: null,
+    },
+
+    // Encrypted at rest (NEVER return decrypted)
+    uriEncrypted: {
+      type: mongoose.Schema.Types.Mixed,
+      required: true,
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+externalDbConnectionSchema.set('toJSON', {
+  transform: (_doc, ret) => {
+    delete ret.uriEncrypted;
+    delete ret.__v;
+    return ret;
+  },
+});
+
+module.exports = mongoose.model('ExternalDbConnection', externalDbConnectionSchema);

package/src/models/FileEntry.js

@@ -0,0 +1,22 @@
+const mongoose = require('mongoose');
+
+const fileEntrySchema = new mongoose.Schema(
+  {
+    orgId: { type: mongoose.Schema.Types.ObjectId, ref: 'Organization', required: true, index: true },
+    driveType: { type: String, enum: ['user', 'group', 'org'], required: true, index: true },
+    driveId: { type: mongoose.Schema.Types.ObjectId, required: true, index: true },
+    parentPath: { type: String, required: true, default: '/', index: true },
+    name: { type: String, required: true },
+    assetId: { type: mongoose.Schema.Types.ObjectId, ref: 'Asset', required: true, index: true },
+    visibility: { type: String, enum: ['public', 'private'], required: true, default: 'private', index: true },
+    deletedAt: { type: Date, default: null, index: true },
+  },
+  { timestamps: true, collection: 'file_entries' },
+);
+
+fileEntrySchema.index(
+  { orgId: 1, driveType: 1, driveId: 1, parentPath: 1, name: 1 },
+  { unique: true, partialFilterExpression: { deletedAt: null } },
+);
+
+module.exports = mongoose.models.FileEntry || mongoose.model('FileEntry', fileEntrySchema);

package/src/models/HeadlessModelDefinition.js

@@ -28,6 +28,16 @@ const headlessModelDefinitionSchema = new mongoose.Schema(
     description: { type: String, default: '' },
     fields: { type: [headlessFieldSchema], default: [] },
     indexes: { type: [headlessIndexSchema], default: [] },
+    sourceType: { type: String, enum: ['internal', 'external'], default: 'internal', index: true },
+    sourceCollectionName: { type: String, default: null, index: true },
+    isExternal: { type: Boolean, default: false, index: true },
+    inference: {
+      enabled: { type: Boolean, default: false },
+      lastInferredAt: { type: Date, default: null },
+      sampleSize: { type: Number, default: null },
+      warnings: { type: [String], default: [] },
+      stats: { type: mongoose.Schema.Types.Mixed, default: null },
+    },
     isActive: { type: Boolean, default: true, index: true },
     version: { type: Number, default: 1 },
     fieldsHash: { type: String, default: null },

package/src/models/HealthAutoHealAttempt.js

@@ -0,0 +1,57 @@
+const mongoose = require('mongoose');
+
+const actionResultSchema = new mongoose.Schema(
+  {
+    actionType: { type: String, default: '' },
+    status: { type: String, enum: ['succeeded', 'failed'], required: true },
+    output: { type: String, default: '' },
+    error: { type: String, default: '' },
+  },
+  { _id: false },
+);
+
+const healthAutoHealAttemptSchema = new mongoose.Schema(
+  {
+    healthCheckId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'HealthCheck',
+      required: true,
+      index: true,
+    },
+    incidentId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'HealthIncident',
+      required: true,
+      index: true,
+    },
+
+    attemptNumber: { type: Number, required: true },
+
+    status: {
+      type: String,
+      enum: ['running', 'succeeded', 'failed'],
+      default: 'running',
+      index: true,
+    },
+
+    startedAt: { type: Date, default: Date.now, index: true },
+    finishedAt: { type: Date },
+    durationMs: { type: Number },
+
+    actionResults: { type: [actionResultSchema], default: [] },
+  },
+  { timestamps: true, collection: 'health_autoheal_attempts' },
+);
+
+healthAutoHealAttemptSchema.index({ incidentId: 1, startedAt: -1 });
+
+healthAutoHealAttemptSchema.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.HealthAutoHealAttempt ||
+  mongoose.model('HealthAutoHealAttempt', healthAutoHealAttemptSchema);

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