@intranefr/superbackend 1.4.3

package/src/models/ActionEvent.js

@@ -0,0 +1,31 @@
+const mongoose = require('mongoose');
+
+const actionEventSchema = new mongoose.Schema({
+  action: {
+    type: String,
+    required: true,
+    index: true,
+  },
+  actorType: {
+    type: String,
+    enum: ['user', 'anonymous', 'system'],
+    required: true,
+    index: true,
+  },
+  actorId: {
+    type: String,
+    required: true,
+    index: true,
+  },
+  meta: {
+    type: mongoose.Schema.Types.Mixed,
+    default: null,
+  },
+}, {
+  timestamps: true,
+});
+
+// actionEventSchema.index({ action: 1, createdAt: -1 }); // Removed duplicate index
+actionEventSchema.index({ actorType: 1, actorId: 1, createdAt: -1 });
+
+module.exports = mongoose.model('ActionEvent', actionEventSchema);

package/src/models/ActivityLog.js

@@ -0,0 +1,41 @@
+const mongoose = require('mongoose');
+
+const activityLogSchema = new mongoose.Schema({
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true,
+    index: true
+  },
+  action: {
+    type: String,
+    required: true
+  },
+  category: {
+    type: String,
+    required: true,
+    enum: ['auth', 'billing', 'content', 'settings', 'admin', 'other']
+  },
+  description: {
+    type: String,
+    required: true
+  },
+  ipAddress: {
+    type: String
+  },
+  userAgent: {
+    type: String
+  },
+  metadata: {
+    type: mongoose.Schema.Types.Mixed,
+    default: {}
+  }
+}, {
+  timestamps: true
+});
+
+activityLogSchema.index({ userId: 1, createdAt: -1 });
+activityLogSchema.index({ category: 1 });
+activityLogSchema.index({ action: 1 });
+
+module.exports = mongoose.model('ActivityLog', activityLogSchema);

package/src/models/Asset.js

@@ -0,0 +1,84 @@
+const mongoose = require('mongoose');
+
+const assetSchema = new mongoose.Schema({
+  key: {
+    type: String,
+    required: true,
+    unique: true,
+    index: true
+  },
+  provider: {
+    type: String,
+    required: true,
+    enum: ['s3', 'fs'],
+    default: 'fs'
+  },
+  bucket: {
+    type: String,
+    required: true,
+    default: 'fs'
+  },
+  originalName: {
+    type: String,
+    required: true
+  },
+  contentType: {
+    type: String,
+    required: true
+  },
+  sizeBytes: {
+    type: Number,
+    required: true
+  },
+  visibility: {
+    type: String,
+    required: true,
+    enum: ['public', 'private'],
+    default: 'private'
+  },
+  namespace: {
+    type: String,
+    required: true,
+    default: 'default',
+    index: true,
+  },
+  visibilityEnforced: {
+    type: Boolean,
+    required: true,
+    default: false,
+  },
+  tags: {
+    type: [String],
+    required: true,
+    default: [],
+    index: true,
+  },
+  ownerUserId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    index: true,
+    default: null
+  },
+  orgId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Organization',
+    index: true,
+    default: null
+  },
+  status: {
+    type: String,
+    required: true,
+    enum: ['uploaded', 'deleted'],
+    default: 'uploaded'
+  }
+}, {
+  timestamps: true
+});
+
+assetSchema.index({ ownerUserId: 1, createdAt: -1 });
+assetSchema.index({ visibility: 1, status: 1 });
+assetSchema.index({ orgId: 1, createdAt: -1 });
+assetSchema.index({ namespace: 1, createdAt: -1 });
+assetSchema.index({ tags: 1, createdAt: -1 });
+
+module.exports = mongoose.model('Asset', assetSchema);

package/src/models/AuditEvent.js

@@ -0,0 +1,93 @@
+const mongoose = require('mongoose');
+
+const auditEventSchema = new mongoose.Schema(
+  {
+    actorType: {
+      type: String,
+      required: true,
+      enum: ['admin', 'admin_basic', 'user', 'system', 'anonymous'],
+    },
+    actorUserId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User',
+      default: null,
+      index: true,
+    },
+    actorRole: {
+      type: String,
+      default: null,
+    },
+    actorId: {
+      type: String,
+      default: null,
+    },
+    action: {
+      type: String,
+      required: true,
+      index: true,
+    },
+    entityType: {
+      type: String,
+      required: false,
+      index: true,
+    },
+    entityId: {
+      type: String,
+      required: false,
+      default: null,
+      index: true,
+    },
+    before: {
+      type: mongoose.Schema.Types.Mixed,
+      default: null,
+    },
+    after: {
+      type: mongoose.Schema.Types.Mixed,
+      default: null,
+    },
+    meta: {
+      type: mongoose.Schema.Types.Mixed,
+      default: null,
+    },
+
+    outcome: {
+      type: String,
+      enum: ['success', 'failure'],
+      default: 'success',
+      index: true,
+    },
+    context: {
+      ip: String,
+      userAgent: String,
+      requestId: String,
+      path: String,
+      method: String,
+    },
+    targetType: {
+      type: String,
+      default: null,
+      index: true,
+    },
+    targetId: {
+      type: String,
+      default: null,
+      index: true,
+    },
+  },
+  { timestamps: true },
+);
+
+auditEventSchema.index({ action: 1, createdAt: -1 });
+auditEventSchema.index({ entityType: 1, entityId: 1, createdAt: -1 });
+auditEventSchema.index({ outcome: 1, createdAt: -1 });
+auditEventSchema.index({ targetType: 1, targetId: 1, createdAt: -1 });
+
+auditEventSchema.set('toJSON', {
+  transform: (doc, ret) => {
+    ret.id = ret._id;
+    delete ret.__v;
+    return ret;
+  },
+});
+
+module.exports = mongoose.model('AuditEvent', auditEventSchema);

package/src/models/EmailLog.js

@@ -0,0 +1,28 @@
+const mongoose = require('mongoose');
+
+const emailLogSchema = new mongoose.Schema({
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    index: true
+  },
+  to: [String],
+  subject: String,
+  type: {
+    type: String,
+    default: 'other',
+    index: true
+  },
+  providerId: String,
+  status: {
+    type: String,
+    enum: ['sent', 'failed'],
+    default: 'sent'
+  },
+  error: String,
+  metadata: mongoose.Schema.Types.Mixed
+}, {
+  timestamps: true
+});
+
+module.exports = mongoose.model('EmailLog', emailLogSchema);

package/src/models/ErrorAggregate.js

@@ -0,0 +1,72 @@
+const mongoose = require('mongoose');
+
+const errorSampleSchema = new mongoose.Schema(
+  {
+    at: { type: Date, default: Date.now },
+    message: { type: String, maxlength: 2000 },
+    stack: { type: String, maxlength: 5000 },
+    actor: {
+      userId: { type: String },
+      role: String,
+      ip: String,
+      userAgent: String,
+    },
+    request: {
+      method: String,
+      path: String,
+      statusCode: Number,
+      requestId: String,
+    },
+    runtime: {
+      url: String,
+      referrer: String,
+      viewport: String,
+      locale: String,
+      appVersion: String,
+      nodeVersion: String,
+      hostname: String,
+    },
+    extra: { type: mongoose.Schema.Types.Mixed },
+  },
+  { _id: false },
+);
+
+const errorAggregateSchema = new mongoose.Schema(
+  {
+    fingerprint: { type: String, required: true, unique: true, index: true },
+    source: { type: String, enum: ['frontend', 'backend'], required: true, index: true },
+    severity: { type: String, enum: ['fatal', 'error', 'warn', 'info'], default: 'error', index: true },
+    errorName: { type: String, index: true },
+    errorCode: String,
+    messageTemplate: { type: String, maxlength: 500 },
+    topFrame: String,
+    httpStatusBucket: String,
+    countTotal: { type: Number, default: 0 },
+    countsByDay: { type: Map, of: Number, default: {} },
+    firstSeenAt: { type: Date, default: Date.now },
+    lastSeenAt: { type: Date, default: Date.now, index: true },
+    samples: {
+      type: [errorSampleSchema],
+      default: [],
+      validate: [arr => arr.length <= 20, 'samples cannot exceed 20'],
+    },
+    status: { type: String, enum: ['open', 'ignored', 'resolved'], default: 'open', index: true },
+    resolvedAt: Date,
+  },
+  { timestamps: true },
+);
+
+errorAggregateSchema.index({ source: 1, lastSeenAt: -1 });
+errorAggregateSchema.index({ countTotal: -1 });
+errorAggregateSchema.index({ status: 1, lastSeenAt: -1 });
+
+errorAggregateSchema.set('toJSON', {
+  transform: (doc, ret) => {
+    ret.id = ret._id;
+    delete ret._id;
+    delete ret.__v;
+    return ret;
+  },
+});
+
+module.exports = mongoose.model('ErrorAggregate', errorAggregateSchema);

package/src/models/FormSubmission.js

@@ -0,0 +1,41 @@
+const mongoose = require('mongoose');
+
+const formSubmissionSchema = new mongoose.Schema({
+  formKey: {
+    type: String,
+    required: true,
+    index: true,
+  },
+  actorType: {
+    type: String,
+    enum: ['user', 'anonymous', 'system'],
+    required: true,
+    index: true,
+  },
+  actorId: {
+    type: String,
+    required: true,
+    index: true,
+  },
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    default: null,
+    index: true,
+  },
+  fields: {
+    type: mongoose.Schema.Types.Mixed,
+    required: true,
+  },
+  meta: {
+    type: mongoose.Schema.Types.Mixed,
+    default: null,
+  },
+}, {
+  timestamps: true,
+});
+
+formSubmissionSchema.index({ formKey: 1, createdAt: -1 });
+formSubmissionSchema.index({ actorType: 1, actorId: 1, createdAt: -1 });
+
+module.exports = mongoose.model('FormSubmission', formSubmissionSchema);

package/src/models/GlobalSetting.js

@@ -0,0 +1,38 @@
+const mongoose = require('mongoose');
+
+const globalSettingSchema = new mongoose.Schema({
+  key: {
+    type: String,
+    required: true,
+    unique: true,
+    index: true
+  },
+  value: {
+    type: String,
+    required: true
+  },
+  type: {
+    type: String,
+    required: true,
+    enum: ['string', 'html', 'boolean', 'json', 'number', 'encrypted'],
+    default: 'string'
+  },
+  description: {
+    type: String,
+    required: true
+  },
+  templateVariables: {
+    type: [String],
+    default: []
+  },
+  public: {
+    type: Boolean,
+    default: false
+  }
+}, {
+  timestamps: true
+});
+
+// globalSettingSchema.index({ key: 1 }); // Removed duplicate index
+
+module.exports = mongoose.model('GlobalSetting', globalSettingSchema);

package/src/models/HeadlessApiToken.js

@@ -0,0 +1,24 @@
+const mongoose = require('mongoose');
+
+const tokenPermissionSchema = new mongoose.Schema(
+  {
+    modelCode: { type: String, required: true },
+    operations: { type: [String], default: [] },
+  },
+  { _id: false },
+);
+
+const headlessApiTokenSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true },
+    tokenHash: { type: String, required: true, unique: true, index: true },
+    permissions: { type: [tokenPermissionSchema], default: [] },
+    expiresAt: { type: Date, default: null, index: true },
+    isActive: { type: Boolean, default: true, index: true },
+    lastUsedAt: { type: Date, default: null },
+  },
+  { timestamps: true, collection: 'headless_api_tokens' },
+);
+
+module.exports = mongoose.models.HeadlessApiToken ||
+  mongoose.model('HeadlessApiToken', headlessApiTokenSchema);

package/src/models/HeadlessModelDefinition.js

@@ -0,0 +1,41 @@
+const mongoose = require('mongoose');
+
+const headlessFieldSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true },
+    type: { type: String, required: true },
+    required: { type: Boolean, default: false },
+    unique: { type: Boolean, default: false },
+    default: { type: mongoose.Schema.Types.Mixed, default: undefined },
+    validation: { type: mongoose.Schema.Types.Mixed, default: null },
+    refModelCode: { type: String, default: null },
+  },
+  { _id: false },
+);
+
+const headlessIndexSchema = new mongoose.Schema(
+  {
+    fields: { type: mongoose.Schema.Types.Mixed, required: true },
+    options: { type: mongoose.Schema.Types.Mixed, default: {} },
+  },
+  { _id: false },
+);
+
+const headlessModelDefinitionSchema = new mongoose.Schema(
+  {
+    codeIdentifier: { type: String, required: true, unique: true, index: true },
+    displayName: { type: String, required: true },
+    description: { type: String, default: '' },
+    fields: { type: [headlessFieldSchema], default: [] },
+    indexes: { type: [headlessIndexSchema], default: [] },
+    isActive: { type: Boolean, default: true, index: true },
+    version: { type: Number, default: 1 },
+    fieldsHash: { type: String, default: null },
+    previousFields: { type: [headlessFieldSchema], default: [] },
+    previousIndexes: { type: [headlessIndexSchema], default: [] },
+  },
+  { timestamps: true, collection: 'headless_model_definitions' },
+);
+
+module.exports = mongoose.models.HeadlessModelDefinition ||
+  mongoose.model('HeadlessModelDefinition', headlessModelDefinitionSchema);

package/src/models/I18nEntry.js

@@ -0,0 +1,77 @@
+const mongoose = require('mongoose');
+
+const i18nEntrySchema = new mongoose.Schema(
+  {
+    key: {
+      type: String,
+      required: true,
+      index: true,
+      trim: true,
+    },
+    locale: {
+      type: String,
+      required: true,
+      index: true,
+      trim: true,
+    },
+    value: {
+      type: String,
+      required: true,
+      default: '',
+    },
+    valueFormat: {
+      type: String,
+      enum: ['text', 'html'],
+      default: 'text',
+    },
+    source: {
+      type: String,
+      enum: ['seed', 'admin', 'ai'],
+      default: 'admin',
+    },
+    seeded: {
+      type: Boolean,
+      default: false,
+    },
+    seedHash: {
+      type: String,
+      default: null,
+    },
+    seedVersion: {
+      type: String,
+      default: null,
+    },
+    edited: {
+      type: Boolean,
+      default: false,
+    },
+    editedAt: {
+      type: Date,
+      default: null,
+    },
+    editedBy: {
+      type: String,
+      default: null,
+    },
+    lastAiProvider: {
+      type: String,
+      default: null,
+    },
+    lastAiModel: {
+      type: String,
+      default: null,
+    },
+    lastAiPromptHash: {
+      type: String,
+      default: null,
+    },
+  },
+  { timestamps: true },
+);
+
+i18nEntrySchema.index({ key: 1, locale: 1 }, { unique: true });
+// i18nEntrySchema.index({ locale: 1, key: 1 }); // Removed duplicate index
+i18nEntrySchema.index({ edited: 1 });
+i18nEntrySchema.index({ seeded: 1 });
+
+module.exports = mongoose.model('I18nEntry', i18nEntrySchema);

package/src/models/I18nLocale.js

@@ -0,0 +1,33 @@
+const mongoose = require('mongoose');
+
+const i18nLocaleSchema = new mongoose.Schema(
+  {
+    code: {
+      type: String,
+      required: true,
+      unique: true,
+      index: true,
+      trim: true,
+    },
+    name: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    enabled: {
+      type: Boolean,
+      default: true,
+    },
+    isDefault: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  { timestamps: true },
+);
+
+// i18nLocaleSchema.index({ code: 1 }); // Removed duplicate index
+i18nLocaleSchema.index({ enabled: 1 });
+i18nLocaleSchema.index({ isDefault: 1 });
+
+module.exports = mongoose.model('I18nLocale', i18nLocaleSchema);

package/src/models/Invite.js

@@ -0,0 +1,70 @@
+const mongoose = require('mongoose');
+const crypto = require('crypto');
+
+const inviteSchema = new mongoose.Schema({
+  email: {
+    type: String,
+    required: true,
+    lowercase: true,
+    trim: true,
+    index: true
+  },
+  tokenHash: {
+    type: String,
+    required: true,
+    unique: true
+  },
+  expiresAt: {
+    type: Date,
+    required: true,
+    index: true
+  },
+  status: {
+    type: String,
+    enum: ['pending', 'accepted', 'revoked', 'expired'],
+    default: 'pending'
+  },
+  createdByUserId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  orgId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Organization',
+    required: true,
+    index: true
+  },
+  role: {
+    type: String,
+    default: 'member'
+  },
+  metadata: {
+    type: mongoose.Schema.Types.Mixed,
+    default: {}
+  }
+}, {
+  timestamps: true
+});
+
+inviteSchema.index({ email: 1, status: 1 });
+inviteSchema.index({ orgId: 1, status: 1 });
+
+inviteSchema.statics.generateToken = function() {
+  const token = 'inv_' + crypto.randomBytes(24).toString('hex');
+  const tokenHash = crypto.createHash('sha256').update(token).digest('hex');
+  return { token, tokenHash };
+};
+
+inviteSchema.statics.hashToken = function(token) {
+  return crypto.createHash('sha256').update(token).digest('hex');
+};
+
+inviteSchema.methods.toJSON = function() {
+  const obj = this.toObject();
+  delete obj.__v;
+  delete obj.tokenHash;
+  return obj;
+};
+
+module.exports = mongoose.model('Invite', inviteSchema);