Enterprise

La documentation Enterprise se concentre sur le contrôle, la gouvernance et l'évolution architecturale reproductible. Mockomat Enterprise est conçu pour les organisations qui nécessitent une isolation maximale, des capacités de conformité et la possibilité de faire évoluer la modélisation de domaine à travers plusieurs équipes.

Priorités Enterprise

Les équipes Enterprise opèrent sous des contraintes différentes de celles des développeurs individuels ou des petites équipes. Les priorités clés sont :

• Isolation et limites claires — séparation stricte entre les tenants, projets et données.
• Exposition API contrôlée — endpoints privés avec accès authentifié pour chaque consommateur.
• États d'architecture reproductibles — la capacité de recréer ou d'auditer tout état de modèle à tout moment.
• Flux de changements auditables — visibilité sur qui a changé quoi, quand et pourquoi.
• Préparation à la conformité — pratiques de traitement des données conformes aux exigences réglementaires.

ent-01-tenant-isolationMissing

Aperçu du modèle d'isolation des tenants et du runtime.

Isolation des tenants

Chaque client Enterprise opère au sein d'un tenant dédié qui fournit des limites strictes à chaque niveau du système.

Isolation des données

• Collections MongoDB séparées — les données mock de chaque tenant sont stockées dans des collections isolées, jamais mélangées avec celles d'autres tenants.
• Requêtes scopées par tenant — chaque requête de base de données est automatiquement filtrée par identifiant de tenant, empêchant les fuites de données inter-tenants.
• Espaces de projets indépendants — les projets au sein d'un tenant ne partagent aucune donnée ni configuration avec les projets d'autres tenants.

Isolation du runtime

• Génération de schéma par tenant — les schémas GraphQL sont générés indépendamment par projet au sein du tenant.
• Endpoints API isolés — chaque projet obtient son propre chemin d'endpoint, scopé aux contrôles d'accès du tenant.
• Limitation de débit indépendante — les limites de requêtes et le throttling sont configurés par tenant, pas partagés globalement.

Isolation de la configuration

• Limites de sessions personnalisées — les tenants Enterprise peuvent définir leurs propres limites de sessions concurrentes et d'acteurs API.
• Timeouts d'inactivité personnalisés — les valeurs de timeout d'inactivité des sessions et des acteurs sont configurables par tenant.
• Limitation de débit personnalisée — les limites de débit de requêtes peuvent être ajustées pour correspondre aux patterns d'utilisation de l'organisation.

ent-01b-isolation-architectureMissing

Couches d'isolation des données, du runtime et de la configuration.

Modèle de gouvernance

Une approche de gouvernance pratique garantit que la modélisation de domaine reste cohérente et de haute qualité à mesure que l'organisation se développe.

Propriété de domaine

Attribue une propriété claire pour chaque domaine métier :

• Propriétaire de domaine — responsable du nommage des entités, des définitions d'attributs et de la stratégie de relations dans son domaine.
• Réviseurs — membres de l'équipe qui valident les changements avant qu'ils ne soient promus en utilisation production.
• Consommateurs — développeurs frontend et intégrateurs qui interrogent l'API mock mais ne modifient pas le modèle.

Conventions de nommage partagées

Définis des standards à l'échelle de l'organisation pour :

• Nommage des entités — PascalCase, noms au singulier, vocabulaire métier (ex. Customer et non customers_tbl)
• Nommage des attributs — camelCase, descriptif, sans abréviations (ex. totalAmount et non tot_amt)
• Nommage des relations — direction et indicateurs de cardinalité clairs
• Nommage des requêtes — pluralisation cohérente pour les requêtes de liste, singulier pour les requêtes de détail

Documente ces conventions et distribue-les via des blueprints internes pour que chaque équipe démarre avec les mêmes standards.

Points de contrôle de revue

Établis des checkpoints de revue aux étapes clés :

Étape	Focus de la revue	Qui révise
Changement de modèle	Cohérence du nommage, complétude des attributs, exactitude des relations	Propriétaire de domaine
Changement d'exposition API	Surface des opérations, nommage des requêtes, valeurs par défaut de pagination	Propriétaire de domaine + intégrateur
Validation pré-export	Comportement runtime, exactitude filtres/tri, traversée des relations	Propriétaire de domaine + QA
Revue post-export	Qualité du code généré, limites de modules, couverture DTO	Lead de l'équipe de développement

Critères de validation runtime

Définis ce que « prêt » signifie pour chaque entité avant sa promotion :

• Tous les attributs obligatoires ont des valeurs stables et non-null
• Toutes les relations se résolvent correctement en prévisualisation
• Les opérations de filtrage et de tri fonctionnent sur tous les champs configurés
• La pagination produit des transitions de page propres
• Aucune indication ou avertissement non résolu ne subsiste

ent-02-governance-controlsMissing

Contrôles de gouvernance à travers les étapes de modélisation et de runtime.

Collaboration d'équipe

Les forfaits Enterprise supportent des équipes multi-utilisateurs avec un contrôle d'accès basé sur les rôles.

Rôles utilisateur

Rôle	Capacités
Admin	Accès complet : créer/supprimer des projets, gérer les membres de l'équipe, configurer les paramètres du tenant
User Admin	Gérer les membres de l'équipe, attribuer les rôles, consulter les logs d'audit
User	Créer et modifier des projets, exécuter la prévisualisation, exporter des backends
Guest	Accès en lecture seule aux projets partagés et à la prévisualisation

Gestion des sessions concurrentes

Les tenants Enterprise supportent jusqu'à 50+ sessions concurrentes (configurable). Chaque session navigateur authentifiée compte dans la limite.

Comportement des sessions :

• Les sessions sont suivies dans Redis avec des timeouts d'inactivité configurables.
• Lorsqu'une session est inactive au-delà de la période de timeout, elle est automatiquement libérée.
• Lorsque la limite de sessions est atteinte, les nouvelles tentatives de connexion sont bloquées jusqu'à ce qu'une session devienne disponible.
• Les administrateurs peuvent consulter et gérer les sessions actives.

Limites d'acteurs API

Pour la consommation API externe, les tenants Enterprise peuvent configurer des limites d'acteurs concurrents par clé API :

• Par défaut : 20 acteurs concurrents par tenant
• Par clé API : Limites configurables par clé pour différents consommateurs ou environnements
• Tokens d'acteur : Chaque consommateur externe reçoit un token d'acteur à durée limitée qui compte dans la limite de concurrence
• Nettoyage automatique : Les tokens d'acteur expirés sont automatiquement libérés

ent-02b-team-collaborationMissing

Gestion des membres d'équipe et attribution des rôles.

Jeux de données personnalisés

Les clients Enterprise peuvent télécharger et utiliser des jeux de données propriétaires en complément des sources de données intégrées de Mockomat.

Téléchargement et association

1. Télécharger les données — fournis ton jeu de données dans un format supporté (CSV, JSON).
2. Extraction des métadonnées — Mockomat scanne le jeu de données et génère les métadonnées (noms de champs, types, valeurs d'exemple).
3. Associer aux attributs — utilise les données téléchargées comme source d'association (comme OFF_FIELD) pour tout attribut de ton modèle.
4. Stockage isolé — les jeux de données personnalisés sont stockés dans des collections isolées par tenant, jamais partagés avec d'autres tenants.

Cas d'utilisation

• Données spécifiques à l'industrie — utilise de vrais catalogues produits, répertoires d'employés ou données d'inventaire pour des APIs mock plus réalistes.
• Tests de conformité — teste avec des données qui correspondent à la structure de ton schéma de production sans utiliser de vraies données de production.
• Préparation de démonstrations — crée des APIs mock avec des données réalistes et brandées pour les présentations clients.

ent-03b-custom-datasetsMissing

Workflow de téléchargement et d'association de jeux de données personnalisés.

Sécurité et conformité

Les forfaits Enterprise incluent des fonctionnalités de sécurité renforcées pour les organisations ayant des exigences de conformité strictes.

Authentification

• Authentification JWT — tout accès à l'API de gestion nécessite des tokens JWT valides.
• Authentification par clé API — les consommateurs externes s'authentifient avec des clés API scopées par projet.
• Tokens d'acteur — tokens à durée limitée pour la gestion de la concurrence des consommateurs API.
• Intégration SSO/SAML — planifiée pour les organisations nécessitant une gestion centralisée des identités.

Contrôle d'accès

• Accès basé sur les rôles — permissions granulaires basées sur le rôle utilisateur (admin, user admin, user, guest).
• Permissions au niveau projet — contrôle de qui peut accéder, modifier ou exporter des projets spécifiques.
• Isolation au niveau tenant — tout accès est automatiquement scopé à la limite du tenant.

Protection des données

• Aucune donnée de production requise — les APIs mock utilisent des données synthétiques ou adossées à des jeux de données, jamais de vraies informations client.
• Stockage isolé par tenant — les données de chaque tenant sont stockées séparément et inaccessibles aux autres tenants.
• Communication chiffrée — tout le trafic API utilise HTTPS.
• Journalisation d'audit — suivi des patterns d'accès, changements de modèle et événements d'export (planifiée).

Considérations de conformité

• Préparation RGPD — les données synthétiques éliminent les préoccupations liées aux données personnelles dans les environnements de développement.
• Résidence des données — option de déploiement on-premise pour les organisations avec des exigences de souveraineté des données.
• Politiques de rétention — rétention configurable pour les données de session et d'utilisation.

ent-03c-security-overviewMissing

Aperçu des fonctionnalités de sécurité et de conformité Enterprise.

Déploiement on-premise

Pour les organisations qui nécessitent un contrôle complet sur leurs données et leur infrastructure, Mockomat propose une option de déploiement on-premise.

Ce que tu obtiens :

• Une instance Mockomat auto-hébergée fonctionnant sur ta propre infrastructure
• Souveraineté totale des données — toutes les données restent dans ton réseau
• Domaine personnalisé et configuration SSL
• Intégration avec tes systèmes d'authentification existants
• Accès direct à la base de données pour les cas d'utilisation avancés

Prérequis :

• Environnement d'hébergement compatible Docker
• Instances MongoDB, MariaDB et Redis (services managés ou auto-hébergés)
• Runtime Node.js (v20+)

Tarification : 1 000 $ de setup + 199 $/mois de maintenance (inclut mises à jour et support).

Runtime et attentes opérationnelles

Les équipes Enterprise devraient traiter le comportement runtime comme une surface de qualité explicite avec des standards mesurables.

Ce à quoi s'attendre

• Suffisamment déterministe pour la collaboration — la même requête produit la même forme structurelle à chaque fois, pour que les membres de l'équipe puissent compter sur un comportement cohérent.
• Suffisamment transparent pour la revue — chaque décision runtime (résolution de filtre, lookup de relation, ordre de tri) est traçable jusqu'à la configuration du modèle.
• Suffisamment flexible pour l'itération contrôlée — les modèles peuvent évoluer sans casser les consommateurs existants, tant que les changements sont validés via la prévisualisation d'abord.

Bonnes pratiques opérationnelles

1. Définir les critères de validation par entité avant de l'attribuer à une équipe.
2. Inclure les vérifications runtime dans les processus de revue — traiter la validation de prévisualisation comme une étape obligatoire.
3. Versionner tes exports de modèle — conserver un historique des backends générés liés aux snapshots de modèle.
4. Surveiller l'utilisation API — suivre les patterns de requêtes, taux d'erreur et temps de réponse à travers les endpoints.
5. Établir une cadence de mise à jour — planifier des revues régulières du modèle pour maintenir les définitions de domaine alignées avec les exigences métier en évolution.

ent-03-enterprise-runtimeMissing

Validation runtime Enterprise et points de contrôle opérationnels.

Note d'implémentation Enterprise

Enterprise User

Adopte un catalogue de domaines avec une propriété explicite et une cadence de revue des changements. C'est la base pour faire évoluer l'architecture sans perdre en clarté. Commence par un petit pilote (un domaine, une équipe) et étends les pratiques de gouvernance à mesure que tu intègres des équipes supplémentaires.

Note intégrateur pour les contextes Enterprise

Developer / Integrator

Construis des pipelines d'intégration autour de snapshots de modèle stables et de vérifications runtime documentées pour réduire les surprises de déploiement. Utilise des clés API versionnées par environnement (développement, staging, production) et valide le comportement runtime en CI avant de promouvoir les changements.