@intranefr/superbackend 1.4.3

package/src/models/JsonConfig.js

@@ -0,0 +1,46 @@
+const mongoose = require('mongoose');
+
+const jsonConfigSchema = new mongoose.Schema(
+  {
+    title: {
+      type: String,
+      required: true,
+    },
+    slug: {
+      type: String,
+      required: true,
+      unique: true,
+      index: true,
+    },
+    alias: {
+      type: String,
+      unique: true,
+      sparse: true,
+      index: true,
+    },
+    publicEnabled: {
+      type: Boolean,
+      default: false,
+    },
+    cacheTtlSeconds: {
+      type: Number,
+      default: 0,
+    },
+    jsonRaw: {
+      type: String,
+      required: true,
+    },
+    jsonHash: {
+      type: String,
+      default: null,
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+// jsonConfigSchema.index({ slug: 1 }); // Removed duplicate index
+// jsonConfigSchema.index({ alias: 1 }); // Removed duplicate index
+
+module.exports = mongoose.model('JsonConfig', jsonConfigSchema);

package/src/models/Notification.js

@@ -0,0 +1,60 @@
+const mongoose = require('mongoose');
+
+const notificationSchema = new mongoose.Schema({
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true,
+    index: true
+  },
+  type: {
+    type: String,
+    required: true,
+    enum: ['info', 'success', 'warning', 'error']
+  },
+  title: {
+    type: String,
+    required: true
+  },
+  message: {
+    type: String,
+    required: true
+  },
+  read: {
+    type: Boolean,
+    default: false
+  },
+  metadata: {
+    type: mongoose.Schema.Types.Mixed,
+    default: {}
+  },
+  channel: {
+    type: String,
+    enum: ['in_app', 'email', 'both'],
+    default: 'in_app'
+  },
+  emailStatus: {
+    type: String,
+    enum: ['pending', 'sent', 'failed', 'skipped'],
+    default: 'skipped'
+  },
+  emailSentAt: {
+    type: Date
+  },
+  sentByAdminId: {
+    type: String
+  },
+  broadcastId: {
+    type: String,
+    index: true
+  }
+}, {
+  timestamps: true
+});
+
+notificationSchema.index({ userId: 1, read: 1 });
+notificationSchema.index({ createdAt: -1 });
+notificationSchema.index({ sentByAdminId: 1, createdAt: -1 });
+notificationSchema.index({ channel: 1, emailStatus: 1 });
+
+module.exports = mongoose.model('Notification', notificationSchema);

package/src/models/Organization.js

@@ -0,0 +1,57 @@
+const mongoose = require('mongoose');
+
+const organizationSchema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  slug: {
+    type: String,
+    required: true,
+    unique: true,
+    lowercase: true,
+    trim: true
+  },
+  ownerUserId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true,
+    index: true
+  },
+  billingOwnerUserId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  },
+  description: {
+    type: String,
+    trim: true
+  },
+  allowPublicJoin: {
+    type: Boolean,
+    default: false
+  },
+  status: {
+    type: String,
+    enum: ['active', 'disabled'],
+    default: 'active'
+  },
+  settings: {
+    type: mongoose.Schema.Types.Mixed,
+    default: {}
+  }
+}, {
+  timestamps: true
+});
+
+// organizationSchema.index({ slug: 1 }, { unique: true }); // Removed duplicate index
+organizationSchema.index({ ownerUserId: 1, createdAt: -1 });
+organizationSchema.index({ status: 1 });
+
+organizationSchema.methods.toJSON = function() {
+  const obj = this.toObject();
+  delete obj.__v;
+  return obj;
+};
+
+module.exports = mongoose.model('Organization', organizationSchema);

package/src/models/OrganizationMember.js

@@ -0,0 +1,43 @@
+const mongoose = require('mongoose');
+
+const organizationMemberSchema = new mongoose.Schema({
+  orgId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Organization',
+    required: true,
+    index: true
+  },
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true,
+    index: true
+  },
+  role: {
+    type: String,
+    default: 'member'
+  },
+  status: {
+    type: String,
+    enum: ['active', 'removed'],
+    default: 'active'
+  },
+  addedByUserId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  }
+}, {
+  timestamps: true
+});
+
+organizationMemberSchema.index({ orgId: 1, userId: 1 }, { unique: true });
+organizationMemberSchema.index({ userId: 1, status: 1, createdAt: -1 });
+organizationMemberSchema.index({ orgId: 1, status: 1, role: 1 });
+
+organizationMemberSchema.methods.toJSON = function() {
+  const obj = this.toObject();
+  delete obj.__v;
+  return obj;
+};
+
+module.exports = mongoose.model('OrganizationMember', organizationMemberSchema);

package/src/models/StripeCatalogItem.js

@@ -0,0 +1,77 @@
+const mongoose = require('mongoose');
+
+const stripeCatalogItemSchema = new mongoose.Schema({
+  stripeProductId: {
+    type: String,
+    required: true,
+    index: true
+  },
+  stripePriceId: {
+    type: String,
+    required: true,
+    unique: true,
+    index: true
+  },
+  planKey: {
+    type: String,
+    required: true,
+    trim: true,
+    index: true
+  },
+  displayName: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  description: {
+    type: String,
+    trim: true,
+    default: ''
+  },
+  billingType: {
+    type: String,
+    enum: ['subscription', 'one_time'],
+    required: true
+  },
+  currency: {
+    type: String,
+    required: true,
+    lowercase: true,
+    default: 'usd'
+  },
+  unitAmount: {
+    type: Number,
+    required: true
+  },
+  interval: {
+    type: String,
+    enum: ['month', 'year', 'week', 'day', null],
+    default: null
+  },
+  intervalCount: {
+    type: Number,
+    default: 1
+  },
+  active: {
+    type: Boolean,
+    default: true,
+    index: true
+  },
+  metadata: {
+    type: mongoose.Schema.Types.Mixed,
+    default: {}
+  },
+  createdByAdminId: {
+    type: String
+  },
+  updatedByAdminId: {
+    type: String
+  }
+}, {
+  timestamps: true
+});
+
+stripeCatalogItemSchema.index({ planKey: 1, active: 1 });
+stripeCatalogItemSchema.index({ stripeProductId: 1, active: 1 });
+
+module.exports = mongoose.model('StripeCatalogItem', stripeCatalogItemSchema);

package/src/models/StripeWebhookEvent.js

@@ -0,0 +1,57 @@
+const mongoose = require('mongoose');
+
+const stripeWebhookEventSchema = new mongoose.Schema({
+  stripeEventId: {
+    type: String,
+    required: true,
+    unique: true,
+    index: true
+  },
+  eventType: {
+    type: String,
+    required: true,
+    index: true
+  },
+  data: {
+    type: Object,
+    required: true
+  },
+  previousAttributes: {
+    type: Object
+  },
+  api_version: {
+    type: String
+  },
+  request: {
+    type: Object
+  },
+  status: {
+    type: String,
+    enum: ['received', 'processed', 'failed', 'skipped'],
+    default: 'received',
+    index: true
+  },
+  processingErrors: [{
+    message: String,
+    timestamp: Date
+  }],
+  retryCount: {
+    type: Number,
+    default: 0
+  },
+  receivedAt: {
+    type: Date,
+    default: Date.now,
+    index: true
+  },
+  processedAt: {
+    type: Date
+  }
+}, {
+  timestamps: true
+});
+
+stripeWebhookEventSchema.index({ status: 1, receivedAt: 1 });
+stripeWebhookEventSchema.index({ eventType: 1, createdAt: -1 });
+
+module.exports = mongoose.model('StripeWebhookEvent', stripeWebhookEventSchema);

package/src/models/User.js

@@ -0,0 +1,89 @@
+const mongoose = require('mongoose');
+const bcrypt = require('bcryptjs');
+
+const userSchema = new mongoose.Schema({
+  email: {
+    type: String,
+    required: true,
+    unique: true,
+    lowercase: true,
+    trim: true,
+    index: true
+  },
+  clerkUserId: {
+    type: String,
+    index: true,
+    sparse: true
+  },
+  passwordHash: {
+    type: String,
+    required: function () {
+      return !this.clerkUserId;
+    }
+  },
+  name: {
+    type: String,
+    trim: true
+  },
+  subscriptionStatus: {
+    type: String,
+    enum: ['none', 'active', 'cancelled', 'past_due', 'incomplete', 'incomplete_expired', 'trialing', 'unpaid'],
+    default: 'none'
+  },
+  stripeCustomerId: {
+    type: String,
+    sparse: true
+  },
+  stripeSubscriptionId: {
+    type: String,
+    sparse: true
+  },
+  currentPlan: {
+    type: String,
+    default: 'free',
+    trim: true
+  },
+  settings: {
+    type: mongoose.Schema.Types.Mixed,
+    default: {}
+  },
+  passwordResetToken: {
+    type: String,
+    sparse: true
+  },
+  passwordResetExpiry: {
+    type: Date
+  },
+  role: {
+    type: String,
+    enum: ['user', 'admin'],
+    default: 'user'
+  }
+}, {
+  timestamps: true
+});
+
+// userSchema.index({ email: 1 }); // Removed duplicate index
+
+// Hash password before saving
+userSchema.pre('save', async function(next) {
+  if (!this.isModified('passwordHash')) return next();
+  this.passwordHash = await bcrypt.hash(this.passwordHash, 10);
+  next();
+});
+
+// Method to compare password
+userSchema.methods.comparePassword = async function(candidatePassword) {
+  if (!this.passwordHash) return false;
+  return bcrypt.compare(candidatePassword, this.passwordHash);
+};
+
+// Clean up response
+userSchema.methods.toJSON = function() {
+  const obj = this.toObject();
+  delete obj.passwordHash;
+  delete obj.__v;
+  return obj;
+};
+
+module.exports = mongoose.model('User', userSchema);

package/src/models/VirtualEjsFile.js

@@ -0,0 +1,60 @@
+const mongoose = require('mongoose');
+
+const virtualEjsFileSchema = new mongoose.Schema(
+  {
+    path: {
+      type: String,
+      required: true,
+      unique: true,
+      index: true,
+    },
+    enabled: {
+      type: Boolean,
+      default: true,
+      index: true,
+    },
+    content: {
+      type: String,
+      default: '',
+    },
+    source: {
+      type: String,
+      default: 'manual',
+      enum: ['filesystem_snapshot', 'manual', 'llm', 'rollback'],
+      index: true,
+    },
+    baseSha: {
+      type: String,
+      default: null,
+    },
+    inferred: {
+      type: Boolean,
+      default: false,
+      index: true,
+    },
+    integrated: {
+      type: Boolean,
+      default: false,
+      index: true,
+    },
+    renderCount: {
+      type: Number,
+      default: 0,
+    },
+    lastRenderedAt: {
+      type: Date,
+      default: null,
+    },
+    lastSeenAt: {
+      type: Date,
+      default: null,
+    },
+  },
+  { timestamps: true },
+);
+
+// virtualEjsFileSchema.index({ path: 1 }); // Removed duplicate index
+virtualEjsFileSchema.index({ inferred: 1, integrated: 1 });
+virtualEjsFileSchema.index({ enabled: 1, updatedAt: -1 });
+
+module.exports = mongoose.model('VirtualEjsFile', virtualEjsFileSchema);

package/src/models/VirtualEjsFileVersion.js

@@ -0,0 +1,43 @@
+const mongoose = require('mongoose');
+
+const virtualEjsFileVersionSchema = new mongoose.Schema(
+  {
+    fileId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'VirtualEjsFile',
+      required: true,
+      index: true,
+    },
+    path: {
+      type: String,
+      required: true,
+      index: true,
+    },
+    content: {
+      type: String,
+      default: '',
+    },
+    source: {
+      type: String,
+      default: 'manual',
+      enum: ['filesystem_snapshot', 'manual', 'llm', 'rollback'],
+      index: true,
+    },
+    description: {
+      type: String,
+      default: '',
+    },
+    groupId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'VirtualEjsGroupChange',
+      default: null,
+      index: true,
+    },
+  },
+  { timestamps: true },
+);
+
+virtualEjsFileVersionSchema.index({ fileId: 1, createdAt: -1 });
+virtualEjsFileVersionSchema.index({ path: 1, createdAt: -1 });
+
+module.exports = mongoose.model('VirtualEjsFileVersion', virtualEjsFileVersionSchema);

package/src/models/VirtualEjsGroupChange.js

@@ -0,0 +1,32 @@
+const mongoose = require('mongoose');
+
+const virtualEjsGroupChangeSchema = new mongoose.Schema(
+  {
+    title: {
+      type: String,
+      default: '',
+    },
+    summary: {
+      type: String,
+      default: '',
+    },
+    filePaths: {
+      type: [String],
+      default: [],
+    },
+    versionIds: {
+      type: [mongoose.Schema.Types.ObjectId],
+      ref: 'VirtualEjsFileVersion',
+      default: [],
+    },
+    createdBy: {
+      type: String,
+      default: null,
+    },
+  },
+  { timestamps: true },
+);
+
+virtualEjsGroupChangeSchema.index({ createdAt: -1 });
+
+module.exports = mongoose.model('VirtualEjsGroupChange', virtualEjsGroupChangeSchema);

package/src/models/WaitingList.js

@@ -0,0 +1,41 @@
+const mongoose = require('mongoose');
+
+const waitingListSchema = new mongoose.Schema({
+  email: {
+    type: String,
+    required: true,
+    unique: true,
+    lowercase: true,
+    trim: true,
+    index: true
+  },
+  type: {
+    type: String,
+    required: true,
+    default: 'both'
+  },
+  status: {
+    type: String,
+    enum: ['active', 'subscribed', 'launched'],
+    default: 'active'
+  },
+  referralSource: {
+    type: String,
+    trim: true
+  }
+}, {
+  timestamps: true
+});
+
+// waitingListSchema.index({ email: 1 }); // Removed duplicate index
+waitingListSchema.index({ type: 1 });
+waitingListSchema.index({ status: 1 });
+
+// Clean up response
+waitingListSchema.methods.toJSON = function() {
+  const obj = this.toObject();
+  delete obj.__v;
+  return obj;
+};
+
+module.exports = mongoose.model('WaitingList', waitingListSchema);

package/src/models/Webhook.js

@@ -0,0 +1,63 @@
+const mongoose = require('mongoose');
+
+const webhookSchema = new mongoose.Schema({
+  name: {
+    type: String,
+    trim: true,
+    index: true,
+    default: () => `Webhook-${require('crypto').randomBytes(4).toString('hex')}`
+  },
+  targetUrl: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  secret: {
+    type: String,
+    required: true,
+    default: () => require('crypto').randomBytes(32).toString('hex')
+  },
+  events: [{
+    type: String,
+    required: true,
+    enum: [
+      'user.login',
+      'user.registered',
+      'organization.updated',
+      'member.added',
+      'form.submitted',
+      'audit.event'
+    ]
+  }],
+  organizationId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Organization',
+    required: false,
+    index: true
+  },
+  status: {
+    type: String,
+    enum: ['active', 'paused', 'failed'],
+    default: 'active'
+  },
+  timeout: {
+    type: Number,
+    default: 5000, // 5 seconds default
+    min: 1000,
+    max: 30000 // 30 seconds max
+  },
+  isAsync: {
+    type: Boolean,
+    default: false
+  },
+  metadata: {
+    type: mongoose.Schema.Types.Mixed,
+    default: {}
+  }
+}, {
+  timestamps: true
+});
+
+webhookSchema.index({ name: 1, organizationId: 1 }, { unique: true });
+
+module.exports = mongoose.model('Webhook', webhookSchema);

package/src/models/Workflow.js

@@ -0,0 +1,29 @@
+const mongoose = require('mongoose');
+
+const workflowSchema = new mongoose.Schema({
+  name: { type: String, required: true },
+  status: { type: String, enum: ['active', 'inactive'], default: 'inactive' },
+  organizationId: { type: mongoose.Schema.Types.ObjectId, ref: 'Organization', index: true },
+  entrypoint: {
+    type: { type: String, default: 'webhook' },
+    allowedMethods: { type: [String], default: ['POST', 'GET'] },
+    auth: {
+      type: { type: String, enum: ['none', 'header', 'bearer'], default: 'none' },
+      headerName: String,
+      headerValue: String
+    },
+    awaitResponse: { type: Boolean, default: false }
+  },
+  testDataset: {
+    method: { type: String, default: 'POST' },
+    body: { type: Object, default: {} },
+    query: { type: Object, default: {} },
+    headers: { type: Object, default: {} }
+  },
+  webhookSlug: { type: String, unique: true, sparse: true },
+  nodes: { type: Array, default: [] },
+  createdAt: { type: Date, default: Date.now },
+  updatedAt: { type: Date, default: Date.now }
+});
+
+module.exports = mongoose.model('Workflow', workflowSchema);