@intranefr/superbackend 1.5.0 → 1.5.2

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 },
+
+    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 },
+  },
+  { 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/Experiment.js

@@ -0,0 +1,75 @@
+const mongoose = require('mongoose');
+
+const experimentVariantSchema = new mongoose.Schema(
+  {
+    key: { type: String, required: true },
+    weight: { type: Number, default: 0 },
+    configSlug: { type: String, default: '' },
+  },
+  { _id: false },
+);
+
+const metricDefinitionSchema = new mongoose.Schema(
+  {
+    key: { type: String, required: true },
+    kind: { type: String, enum: ['count', 'sum', 'avg', 'rate'], default: 'count' },
+    numeratorEventKey: { type: String, default: '' },
+    denominatorEventKey: { type: String, default: '' },
+    objective: { type: String, enum: ['maximize', 'minimize'], default: 'maximize' },
+  },
+  { _id: false },
+);
+
+const winnerPolicySchema = new mongoose.Schema(
+  {
+    mode: { type: String, enum: ['manual', 'automatic'], default: 'manual' },
+    pickAfterMs: { type: Number, default: 0 },
+    minAssignments: { type: Number, default: 0 },
+    minExposures: { type: Number, default: 0 },
+    minConversions: { type: Number, default: 0 },
+    statMethod: { type: String, enum: ['simple_rate', 'bayesian_beta'], default: 'simple_rate' },
+    overrideWinnerVariantKey: { type: String, default: '' },
+  },
+  { _id: false },
+);
+
+const experimentSchema = new mongoose.Schema(
+  {
+    organizationId: { type: mongoose.Schema.Types.ObjectId, ref: 'Organization', default: null, index: true },
+
+    code: { type: String, required: true },
+    name: { type: String, default: '' },
+    description: { type: String, default: '' },
+
+    status: { type: String, enum: ['draft', 'running', 'paused', 'completed'], default: 'draft', index: true },
+
+    startedAt: { type: Date, default: null },
+    endsAt: { type: Date, default: null },
+
+    assignment: {
+      unit: { type: String, enum: ['subjectId'], default: 'subjectId' },
+      sticky: { type: Boolean, default: true },
+      salt: { type: String, default: '' },
+    },
+
+    variants: { type: [experimentVariantSchema], default: [] },
+
+    primaryMetric: { type: metricDefinitionSchema, required: true },
+    secondaryMetrics: { type: [metricDefinitionSchema], default: [] },
+
+    winnerPolicy: { type: winnerPolicySchema, default: () => ({}) },
+
+    winnerVariantKey: { type: String, default: '' },
+    winnerDecidedAt: { type: Date, default: null },
+    winnerReason: { type: String, default: '' },
+
+    createdByUserId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedByUserId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', default: null },
+  },
+  { timestamps: true, collection: 'experiments' },
+);
+
+experimentSchema.index({ organizationId: 1, code: 1 }, { unique: true });
+experimentSchema.index({ status: 1, startedAt: 1 });
+
+module.exports = mongoose.models.Experiment || mongoose.model('Experiment', experimentSchema);

package/src/models/ExperimentAssignment.js

@@ -0,0 +1,23 @@
+const mongoose = require('mongoose');
+
+const experimentAssignmentSchema = new mongoose.Schema(
+  {
+    experimentId: { type: mongoose.Schema.Types.ObjectId, ref: 'Experiment', required: true, index: true },
+    organizationId: { type: mongoose.Schema.Types.ObjectId, ref: 'Organization', default: null, index: true },
+
+    subjectKey: { type: String, required: true },
+
+    variantKey: { type: String, required: true },
+    assignedAt: { type: Date, default: () => new Date() },
+
+    context: { type: mongoose.Schema.Types.Mixed, default: {} },
+  },
+  { timestamps: true, collection: 'experiment_assignments' },
+);
+
+experimentAssignmentSchema.index({ experimentId: 1, subjectKey: 1 }, { unique: true });
+experimentAssignmentSchema.index({ organizationId: 1, subjectKey: 1 });
+
+module.exports =
+  mongoose.models.ExperimentAssignment ||
+  mongoose.model('ExperimentAssignment', experimentAssignmentSchema);

package/src/models/ExperimentEvent.js

@@ -0,0 +1,26 @@
+const mongoose = require('mongoose');
+
+const experimentEventSchema = new mongoose.Schema(
+  {
+    experimentId: { type: mongoose.Schema.Types.ObjectId, ref: 'Experiment', required: true, index: true },
+    organizationId: { type: mongoose.Schema.Types.ObjectId, ref: 'Organization', default: null, index: true },
+
+    subjectKey: { type: String, required: true },
+
+    variantKey: { type: String, required: true, index: true },
+
+    eventKey: { type: String, required: true, index: true },
+    value: { type: Number, default: 1 },
+
+    ts: { type: Date, required: true, index: true },
+
+    meta: { type: mongoose.Schema.Types.Mixed, default: {} },
+  },
+  { timestamps: true, collection: 'experiment_events' },
+);
+
+experimentEventSchema.index({ experimentId: 1, ts: 1 });
+experimentEventSchema.index({ organizationId: 1, ts: 1 });
+experimentEventSchema.index({ experimentId: 1, eventKey: 1, ts: 1 });
+
+module.exports = mongoose.models.ExperimentEvent || mongoose.model('ExperimentEvent', experimentEventSchema);

package/src/models/ExperimentMetricBucket.js

@@ -0,0 +1,30 @@
+const mongoose = require('mongoose');
+
+const experimentMetricBucketSchema = new mongoose.Schema(
+  {
+    experimentId: { type: mongoose.Schema.Types.ObjectId, ref: 'Experiment', required: true, index: true },
+    organizationId: { type: mongoose.Schema.Types.ObjectId, ref: 'Organization', default: null, index: true },
+
+    variantKey: { type: String, required: true, index: true },
+    metricKey: { type: String, required: true, index: true },
+
+    bucketStart: { type: Date, required: true, index: true },
+    bucketMs: { type: Number, required: true },
+
+    count: { type: Number, default: 0 },
+    sum: { type: Number, default: 0 },
+    sumSq: { type: Number, default: 0 },
+    min: { type: Number, default: null },
+    max: { type: Number, default: null },
+  },
+  { timestamps: true, collection: 'experiment_metric_buckets' },
+);
+
+experimentMetricBucketSchema.index(
+  { experimentId: 1, variantKey: 1, metricKey: 1, bucketStart: 1, bucketMs: 1 },
+  { unique: true },
+);
+
+module.exports =
+  mongoose.models.ExperimentMetricBucket ||
+  mongoose.model('ExperimentMetricBucket', experimentMetricBucketSchema);

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/GlobalSetting.js

@@ -4,8 +4,7 @@ const globalSettingSchema = new mongoose.Schema({
   key: {
     type: String,
     required: true,
-    unique: true,
-    index: true
+    unique: true
   },
   value: {
     type: String,

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