@intranefr/superbackend 1.4.4 → 1.5.0

package/src/models/UiComponent.js

@@ -0,0 +1,29 @@
+const mongoose = require('mongoose');
+
+const uiComponentSchema = 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 component code'],
+    },
+    name: { type: String, required: true, trim: true },
+
+    html: { type: String, default: '' },
+    js: { type: String, default: '' },
+    css: { type: String, default: '' },
+
+    api: { type: mongoose.Schema.Types.Mixed, default: null },
+    usageMarkdown: { type: String, default: '' },
+
+    version: { type: Number, default: 1 },
+    isActive: { type: Boolean, default: true, index: true },
+  },
+  { timestamps: true, collection: 'ui_components' },
+);
+
+module.exports = mongoose.models.UiComponent || mongoose.model('UiComponent', uiComponentSchema);

package/src/models/UiComponentProject.js

@@ -0,0 +1,26 @@
+const mongoose = require('mongoose');
+
+const uiComponentProjectSchema = new mongoose.Schema(
+  {
+    projectId: {
+      type: String,
+      required: true,
+      unique: true,
+      index: true,
+      trim: true,
+      match: [/^prj_[a-z0-9]{8,32}$/, 'Invalid projectId'],
+    },
+    name: { type: String, required: true, trim: true },
+
+    isPublic: { type: Boolean, default: true, index: true },
+    apiKeyHash: { type: String, default: null },
+
+    allowedOrigins: { type: [String], default: [] },
+
+    isActive: { type: Boolean, default: true, index: true },
+  },
+  { timestamps: true, collection: 'ui_component_projects' },
+);
+
+module.exports = mongoose.models.UiComponentProject ||
+  mongoose.model('UiComponentProject', uiComponentProjectSchema);

package/src/models/UiComponentProjectComponent.js

@@ -0,0 +1,18 @@
+const mongoose = require('mongoose');
+
+const uiComponentProjectComponentSchema = new mongoose.Schema(
+  {
+    projectId: { type: String, required: true, index: true },
+    componentCode: { type: String, required: true, index: true },
+    enabled: { type: Boolean, default: true, index: true },
+  },
+  { timestamps: true, collection: 'ui_component_project_components' },
+);
+
+uiComponentProjectComponentSchema.index(
+  { projectId: 1, componentCode: 1 },
+  { unique: true },
+);
+
+module.exports = mongoose.models.UiComponentProjectComponent ||
+  mongoose.model('UiComponentProjectComponent', uiComponentProjectComponentSchema);

package/src/routes/admin.routes.js

@@ -11,6 +11,7 @@ router.post('/users/register', adminController.registerUser);
 router.get('/users/:id', adminController.getUser);
 router.put('/users/:id/subscription', adminController.updateUserSubscription);
 router.patch('/users/:id', adminController.updateUserPassword);
+router.delete('/users/:id', adminController.deleteUser);
 router.post('/users/:id/reconcile', adminController.reconcileUser);
 router.post('/generate-token', adminController.generateToken);
 

package/src/routes/adminHeadless.routes.js

@@ -13,6 +13,12 @@ router.post('/models', adminHeadlessController.createModel);
 router.put('/models/:codeIdentifier', adminHeadlessController.updateModel);
 router.delete('/models/:codeIdentifier', adminHeadlessController.deleteModel);
 
+// External models (Mongo collections)
+router.get('/external/collections', adminHeadlessController.listExternalCollections);
+router.post('/external/infer', adminHeadlessController.inferExternalCollection);
+router.post('/external/import', adminHeadlessController.importExternalModel);
+router.post('/models/:codeIdentifier/sync', adminHeadlessController.syncExternalModel);
+
 // Advanced JSON / bulk helpers
 router.post('/models/validate', adminHeadlessController.validateModelDefinition);
 router.post('/models/apply', adminHeadlessController.applyModelProposal);

package/src/routes/adminScripts.routes.js

@@ -0,0 +1,21 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/adminScripts.controller');
+
+router.use(basicAuth);
+
+router.get('/', controller.listScripts);
+router.post('/', controller.createScript);
+router.get('/runs', controller.listRuns);
+router.get('/runs/:runId', controller.getRun);
+router.get('/runs/:runId/stream', controller.streamRun);
+
+router.get('/:id', controller.getScript);
+router.put('/:id', controller.updateScript);
+router.delete('/:id', controller.deleteScript);
+
+router.post('/:id/run', controller.runScript);
+
+module.exports = router;

package/src/routes/adminTerminals.routes.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/adminTerminals.controller');
+
+router.use(basicAuth);
+
+router.post('/sessions', controller.createSession);
+router.get('/sessions', controller.listSessions);
+router.delete('/sessions/:sessionId', controller.killSession);
+
+module.exports = router;

package/src/routes/adminUiComponents.routes.js

@@ -0,0 +1,29 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const adminUiComponentsController = require('../controllers/adminUiComponents.controller');
+const adminUiComponentsAiController = require('../controllers/adminUiComponentsAi.controller');
+
+router.use(basicAuth);
+
+router.get('/projects', adminUiComponentsController.listProjects);
+router.post('/projects', adminUiComponentsController.createProject);
+router.get('/projects/:projectId', adminUiComponentsController.getProject);
+router.put('/projects/:projectId', adminUiComponentsController.updateProject);
+router.delete('/projects/:projectId', adminUiComponentsController.deleteProject);
+router.post('/projects/:projectId/rotate-key', adminUiComponentsController.rotateProjectKey);
+
+router.get('/components', adminUiComponentsController.listComponents);
+router.post('/components', adminUiComponentsController.createComponent);
+router.get('/components/:code', adminUiComponentsController.getComponent);
+router.put('/components/:code', adminUiComponentsController.updateComponent);
+router.delete('/components/:code', adminUiComponentsController.deleteComponent);
+
+router.get('/projects/:projectId/components', adminUiComponentsController.listProjectAssignments);
+router.post('/projects/:projectId/components/:code', adminUiComponentsController.setAssignment);
+router.delete('/projects/:projectId/components/:code', adminUiComponentsController.deleteAssignment);
+
+router.post('/ai/components/:code/propose', adminUiComponentsAiController.propose);
+
+module.exports = router;

package/src/routes/llmUi.routes.js

@@ -0,0 +1,26 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const adminUiComponentsController = require('../controllers/adminUiComponents.controller');
+
+router.use(basicAuth);
+
+router.get('/projects', adminUiComponentsController.listProjects);
+router.post('/projects', adminUiComponentsController.createProject);
+router.get('/projects/:projectId', adminUiComponentsController.getProject);
+router.put('/projects/:projectId', adminUiComponentsController.updateProject);
+router.delete('/projects/:projectId', adminUiComponentsController.deleteProject);
+router.post('/projects/:projectId/rotate-key', adminUiComponentsController.rotateProjectKey);
+
+router.get('/components', adminUiComponentsController.listComponents);
+router.post('/components', adminUiComponentsController.createComponent);
+router.get('/components/:code', adminUiComponentsController.getComponent);
+router.put('/components/:code', adminUiComponentsController.updateComponent);
+router.delete('/components/:code', adminUiComponentsController.deleteComponent);
+
+router.get('/projects/:projectId/components', adminUiComponentsController.listProjectAssignments);
+router.post('/projects/:projectId/components/:code', adminUiComponentsController.setAssignment);
+router.delete('/projects/:projectId/components/:code', adminUiComponentsController.deleteAssignment);
+
+module.exports = router;

package/src/routes/orgAdmin.routes.js

@@ -6,7 +6,12 @@ const orgAdminController = require('../controllers/orgAdmin.controller');
 const asyncHandler = require('../utils/asyncHandler');
 
 router.get('/', basicAuth, asyncHandler(orgAdminController.listOrgs));
+router.post('/', basicAuth, asyncHandler(orgAdminController.createOrganization));
 router.get('/:orgId', basicAuth, asyncHandler(orgAdminController.getOrg));
+router.put('/:orgId', basicAuth, asyncHandler(orgAdminController.updateOrganization));
+router.patch('/:orgId/disable', basicAuth, asyncHandler(orgAdminController.disableOrganization));
+router.patch('/:orgId/enable', basicAuth, asyncHandler(orgAdminController.enableOrganization));
+router.delete('/:orgId', basicAuth, asyncHandler(orgAdminController.deleteOrganization));
 
 router.get('/:orgId/members', basicAuth, asyncHandler(orgAdminController.listMembers));
 router.patch('/:orgId/members/:memberId', basicAuth, asyncHandler(orgAdminController.updateMember));

package/src/routes/uiComponentsPublic.routes.js

@@ -0,0 +1,9 @@
+const express = require('express');
+const router = express.Router();
+
+const uiComponentsPublicController = require('../controllers/uiComponentsPublic.controller');
+
+router.get('/projects/:projectId/manifest', uiComponentsPublicController.getManifest);
+router.get('/projects/:projectId/components/:code', uiComponentsPublicController.getComponent);
+
+module.exports = router;

package/src/services/headlessExternalModels.service.js

@@ -0,0 +1,292 @@
+const mongoose = require('mongoose');
+
+const HeadlessModelDefinition = require('../models/HeadlessModelDefinition');
+const { normalizeCodeIdentifier, computeSchemaHash } = require('./headlessModels.service');
+
+function isObjectId(value) {
+  if (!value) return false;
+  if (value instanceof mongoose.Types.ObjectId) return true;
+  if (value && typeof value === 'object' && value._bsontype === 'ObjectID') return true;
+  return false;
+}
+
+function detectFieldType(value) {
+  if (value === null || value === undefined) return null;
+  if (isObjectId(value)) return 'objectid';
+  if (value instanceof Date) return 'date';
+  if (Array.isArray(value)) return 'array';
+  const t = typeof value;
+  if (t === 'string') return 'string';
+  if (t === 'number') return 'number';
+  if (t === 'boolean') return 'boolean';
+  if (t === 'object') return 'object';
+  return null;
+}
+
+function pickBestType(seenTypes) {
+  const types = new Set(Array.from(seenTypes || []).filter(Boolean));
+  if (types.size === 0) return { type: 'object', warning: 'No non-null sample values' };
+  if (types.size === 1) return { type: Array.from(types)[0], warning: null };
+  if (types.has('array')) return { type: 'array', warning: `Mixed types: ${Array.from(types).join('|')}` };
+  if (types.has('object')) return { type: 'object', warning: `Mixed types: ${Array.from(types).join('|')}` };
+  return { type: 'string', warning: `Mixed types: ${Array.from(types).join('|')}` };
+}
+
+function tryInferRefFromFieldName(fieldName, externalModelsByCollection) {
+  const name = String(fieldName || '').trim();
+  if (!name) return null;
+
+  const lower = name.toLowerCase();
+  if (!lower.endsWith('id') || lower === 'id') return null;
+
+  const stem = name.slice(0, -2);
+  const candidates = [stem, `${stem}s`, `${stem}es`];
+  for (const c of candidates) {
+    const match = externalModelsByCollection.get(String(c).toLowerCase());
+    if (match) return match;
+  }
+  return null;
+}
+
+function normalizeIndexFromMongo(idx) {
+  if (!idx || typeof idx !== 'object') return null;
+  const fields = idx.key;
+  if (!fields || typeof fields !== 'object') return null;
+
+  const options = { ...idx };
+  delete options.key;
+  delete options.v;
+  delete options.ns;
+
+  return { fields, options };
+}
+
+async function listExternalCollections({ q, includeSystem } = {}) {
+  if (!mongoose.connection || !mongoose.connection.db) {
+    const err = new Error('Mongo connection not ready');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const filter = {};
+  if (q) filter.name = { $regex: String(q), $options: 'i' };
+
+  const cursor = await mongoose.connection.db.listCollections(filter, { nameOnly: true });
+  const items = await cursor.toArray();
+
+  const out = [];
+  for (const c of items) {
+    const name = String(c && c.name ? c.name : '').trim();
+    if (!name) continue;
+    if (!includeSystem && name.startsWith('system.')) continue;
+    out.push({ name, type: 'collection' });
+  }
+
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  return out;
+}
+
+async function inferExternalModelFromCollection({ collectionName, sampleSize = 200 } = {}) {
+  if (!mongoose.connection || !mongoose.connection.db) {
+    const err = new Error('Mongo connection not ready');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const collName = String(collectionName || '').trim();
+  if (!collName) {
+    const err = new Error('collectionName is required');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const N = Math.max(1, Math.min(Number(sampleSize) || 200, 1000));
+  const coll = mongoose.connection.db.collection(collName);
+
+  let docs;
+  try {
+    docs = await coll.aggregate([{ $sample: { size: N } }]).toArray();
+  } catch {
+    docs = await coll.find({}).limit(N).toArray();
+  }
+
+  const externalModels = await HeadlessModelDefinition.find({ isActive: true, sourceType: 'external' })
+    .select({ codeIdentifier: 1, sourceCollectionName: 1 })
+    .lean();
+
+  const externalModelsByCollection = new Map();
+  for (const m of externalModels || []) {
+    const cn = String(m?.sourceCollectionName || '').trim();
+    const code = String(m?.codeIdentifier || '').trim();
+    if (cn && code) externalModelsByCollection.set(cn.toLowerCase(), code);
+  }
+
+  const perField = new Map();
+  const warnings = [];
+
+  for (const doc of docs || []) {
+    if (!doc || typeof doc !== 'object') continue;
+    for (const [k, v] of Object.entries(doc)) {
+      if (!k || k === '_id') continue;
+      const type = detectFieldType(v);
+      let stats = perField.get(k);
+      if (!stats) {
+        stats = { seenTypes: new Set(), objectIdCount: 0, nonNullCount: 0 };
+        perField.set(k, stats);
+      }
+      if (type) stats.seenTypes.add(type);
+      if (type === 'objectid') stats.objectIdCount += 1;
+      if (v !== null && v !== undefined) stats.nonNullCount += 1;
+    }
+  }
+
+  const fields = [];
+  for (const [name, stats] of perField.entries()) {
+    const { type, warning } = pickBestType(stats.seenTypes);
+
+    if (warning) warnings.push(`Field ${name}: ${warning}`);
+
+    if (type === 'objectid') {
+      const refModelCode = tryInferRefFromFieldName(name, externalModelsByCollection);
+      if (refModelCode) {
+        fields.push({ name, type: 'ref', required: false, unique: false, refModelCode });
+      } else {
+        fields.push({ name, type: 'string', required: false, unique: false });
+      }
+      continue;
+    }
+
+    if (type === 'date') {
+      fields.push({ name, type: 'date', required: false, unique: false });
+      continue;
+    }
+
+    if (type === 'array') {
+      fields.push({ name, type: 'array', required: false, unique: false });
+      continue;
+    }
+
+    if (type === 'object') {
+      fields.push({ name, type: 'object', required: false, unique: false });
+      continue;
+    }
+
+    if (type === 'number' || type === 'boolean' || type === 'string') {
+      fields.push({ name, type, required: false, unique: false });
+      continue;
+    }
+
+    fields.push({ name, type: 'object', required: false, unique: false });
+  }
+
+  fields.sort((a, b) => a.name.localeCompare(b.name));
+
+  let indexes = [];
+  try {
+    const idx = await coll.indexes();
+    indexes = (idx || []).map(normalizeIndexFromMongo).filter(Boolean);
+  } catch {
+    indexes = [];
+  }
+
+  const fieldsHash = computeSchemaHash({ fields, indexes });
+
+  return {
+    collectionName: collName,
+    fields,
+    indexes,
+    warnings,
+    stats: {
+      sampled: (docs || []).length,
+      maxSampleSize: N,
+      fields: fields.length,
+    },
+    fieldsHash,
+  };
+}
+
+async function createOrUpdateExternalModel({ collectionName, codeIdentifier, displayName, sampleSize } = {}) {
+  const cn = String(collectionName || '').trim();
+  if (!cn) {
+    const err = new Error('collectionName is required');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const code = normalizeCodeIdentifier(codeIdentifier);
+  if (!code.startsWith('ext_')) {
+    const err = new Error('External model codeIdentifier must start with ext_');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const name = String(displayName || code).trim();
+  if (!name) {
+    const err = new Error('displayName is required');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const inferred = await inferExternalModelFromCollection({ collectionName: cn, sampleSize });
+
+  const existing = await HeadlessModelDefinition.findOne({ codeIdentifier: code, isActive: true });
+  if (!existing) {
+    const doc = await HeadlessModelDefinition.create({
+      codeIdentifier: code,
+      displayName: name,
+      description: '',
+      fields: inferred.fields,
+      indexes: inferred.indexes,
+      fieldsHash: inferred.fieldsHash,
+      version: 1,
+      previousFields: [],
+      previousIndexes: [],
+      sourceType: 'external',
+      sourceCollectionName: cn,
+      isExternal: true,
+      inference: {
+        enabled: true,
+        lastInferredAt: new Date(),
+        sampleSize: Number(sampleSize) || null,
+        warnings: inferred.warnings || [],
+        stats: inferred.stats || null,
+      },
+      isActive: true,
+    });
+
+    return { created: true, item: doc.toObject(), inference: inferred };
+  }
+
+  existing.displayName = name;
+  existing.sourceType = 'external';
+  existing.sourceCollectionName = cn;
+  existing.isExternal = true;
+
+  const newHash = inferred.fieldsHash;
+  if (newHash !== existing.fieldsHash) {
+    existing.previousFields = existing.fields;
+    existing.previousIndexes = existing.indexes;
+    existing.fields = inferred.fields;
+    existing.indexes = inferred.indexes;
+    existing.fieldsHash = newHash;
+    existing.version = Number(existing.version || 1) + 1;
+  }
+
+  existing.inference = {
+    enabled: true,
+    lastInferredAt: new Date(),
+    sampleSize: Number(sampleSize) || null,
+    warnings: inferred.warnings || [],
+    stats: inferred.stats || null,
+  };
+
+  await existing.save();
+
+  return { created: false, item: existing.toObject(), inference: inferred };
+}
+
+module.exports = {
+  listExternalCollections,
+  inferExternalModelFromCollection,
+  createOrUpdateExternalModel,
+};

package/src/services/headlessModels.service.js

@@ -89,6 +89,18 @@ function getMongoCollectionName(codeIdentifier) {
   return `${MODEL_COLLECTION_PREFIX}${code}`;
 }
 
+function isExternalDefinition(def) {
+  return def && (def.sourceType === 'external' || def.isExternal === true);
+}
+
+function getCollectionNameForDefinition(def) {
+  if (isExternalDefinition(def)) {
+    const cn = String(def.sourceCollectionName || '').trim();
+    return cn || getMongoCollectionName(def.codeIdentifier);
+  }
+  return getMongoCollectionName(def.codeIdentifier);
+}
+
 function buildSchemaFromDefinition(def) {
   const schemaShape = {};
   for (const field of def.fields || []) {
@@ -99,12 +111,14 @@ function buildSchemaFromDefinition(def) {
     schemaShape[fieldName] = toMongooseField(field);
   }
 
-  schemaShape._headlessModelCode = { type: String, default: def.codeIdentifier, index: true };
-  schemaShape._headlessSchemaVersion = { type: Number, default: def.version, index: true };
+  if (!isExternalDefinition(def)) {
+    schemaShape._headlessModelCode = { type: String, default: def.codeIdentifier, index: true };
+    schemaShape._headlessSchemaVersion = { type: Number, default: def.version, index: true };
+  }
 
   const schema = new mongoose.Schema(schemaShape, {
     timestamps: true,
-    collection: getMongoCollectionName(def.codeIdentifier),
+    collection: getCollectionNameForDefinition(def),
     strict: false,
   });
 
@@ -254,6 +268,8 @@ async function disableModelDefinition(codeIdentifier) {
 const modelCache = new Map();
 
 async function ensureAutoMigration(modelDef) {
+  if (isExternalDefinition(modelDef)) return;
+
   const collectionName = getMongoCollectionName(modelDef.codeIdentifier);
   const coll = mongoose.connection.collection(collectionName);
 
@@ -318,7 +334,8 @@ async function getDynamicModel(codeIdentifier) {
     throw err;
   }
 
-  const cacheKey = `${def.codeIdentifier}:${def.version}:${def.fieldsHash}`;
+  const collectionName = getCollectionNameForDefinition(def);
+  const cacheKey = `${def.codeIdentifier}:${def.version}:${def.fieldsHash}:${collectionName}`;
   const cached = modelCache.get(cacheKey);
   if (cached) return cached;
 
@@ -334,8 +351,10 @@ async function getDynamicModel(codeIdentifier) {
   const schema = buildSchemaFromDefinition(def);
   const Model = mongoose.model(modelName, schema);
 
-  await ensureAutoMigration(def);
-  await ensureIndexesBestEffort(Model);
+  if (!isExternalDefinition(def)) {
+    await ensureAutoMigration(def);
+    await ensureIndexesBestEffort(Model);
+  }
 
   modelCache.set(cacheKey, Model);
   return Model;
@@ -346,6 +365,7 @@ module.exports = {
   normalizeCodeIdentifier,
   getMongooseModelName,
   getMongoCollectionName,
+  getCollectionNameForDefinition,
   computeSchemaHash,
   listModelDefinitions,
   getModelDefinitionByCode,