Version 1.0.0-alpha.1dernière version
Chapitre 2.27
Scénarios de développement
Un recueil de treize réalisations, d'une simple compétence à une livraison en environnement isolé (air-gapped). Chaque recette indique l'objectif, les briques de base, les étapes et les commandes, la porte de contrôle qui prouve son bon fonctionnement, et ce qui change selon l'édition et le mode de livraison.
Cette page a été traduite par l'IA à partir de l'original en anglais. En cas de doute, la page en anglais fait foi. Lire cette page en anglais

Voici les recettes auxquelles j'ai recours lorsque quelqu'un chez Corrán Orbital, ou chez un client, dit « nous voulons que Nexus fasse X ». Chacune est volontairement courte. Le raisonnement derrière les étapes figure dans les chapitres qui précèdent celui-ci : le chapitre 2.20, Skills, et le chapitre 2.21, Le Plugin SDK, qui traite du kit de développement logiciel, puis le chapitre 2.23, Domain packs, et les trois chapitres suivants consacrés à la construction. Vous trouverez ici l'objectif, les briques à utiliser, les étapes, les commandes, le contrôle qui vous indique que cela a fonctionné, ainsi que les remarques sur l'édition et la livraison.
Le contrôle est ce qui compte le plus. Une recette est terminée lorsque son contrôle est au vert. Chaque contrôle de ce chapitre est quelque chose que vous pouvez exécuter ou que la plateforme exécute pour vous, et chacun se termine avec un code de sortie non nul ou refuse avec un code lorsqu'il n'est pas satisfait.
| Scénario | Brique principale | Le contrôle qui le prouve | Édition |
|---|---|---|---|
| Un nouveau skill du Skills Engine | Package SKILL.md |
skill:validate sans aucune erreur |
Community et Enterprise |
Un skill de manifeste avec host_callback |
Manifeste de plugin skills[] |
create-nexus-plugin validate et nexus-gates |
Community et Enterprise |
| Étendre un pack existant | pack.json avec inherits |
Vérification de la politique des lentilles au contrôle pilote | Enterprise et une licence de pack |
| Un nouveau pack à partir de zéro | Parcours de référence des domain packs | Contrôles de préproduction et pilote | Enterprise |
| Un connecteur de données | Skill plugin_queue |
validate, nexus-gates, refus de sortie réseau |
Community et Enterprise |
| Un outil MCP (Model Context Protocol) | Manifeste mcpTools[] |
validate (aucun combinateur de premier niveau) |
Community et Enterprise |
| Une vitrine en marque blanche | Manifeste domains et branding |
Règle publique scope-adherence |
Enterprise et le module complémentaire Storefront |
| Un pack de mission Edge | Pack de mission | Cas de test embarqués, deux signatures sur trois | Enterprise et le module complémentaire Nexus Edge |
| Une livraison en environnement isolé | Bundle scellé | nexus-airgap verify |
Enterprise |
| Un module réservé à Enterprise | @adverant/nexus-spi |
Contrôle de la ligne de licence, builds par édition | Enterprise |
| Forker ou étendre le cœur open source | Le code source Community | Tests, lint et vérification des types | Community |
| Une application cloud de l'édition Team | Cluster d'éditeur | Version signée, revue, autorisation client | Team |
| Encapsuler une application interne existante | /plugin-create |
migrate, validate, nexus-gates |
Community et Enterprise |
1. Une nouvelle compétence du Skills Engine
L'objectif est une instruction réutilisable que l'assistant, les agents, les workflows et les outils de développement peuvent tous exécuter, par exemple vérifier une déclaration en douane au regard de ses règles. Vos briques sont un package SKILL.md dans un dossier portant le nom du skill, un skill.yaml facultatif pour les déclencheurs et les étiquettes, et un dossier scripts/ facultatif fourni avec.
- Créez
skills/<slug>/et rédigezSKILL.mdavec un frontmatter :name(en kebab-case, identique au nom du dossier),description(jusqu'à 500 caractères),allowed-toolset, facultativement,triggers,capabilitiesetversion. - Rédigez le corps à l'intention du modèle : quand utiliser le skill, ses étapes, des exemples et ce qu'il ne doit jamais faire.
- Ajoutez des cas de test. Incluez-en un avec une instruction dissimulée dans l'entrée que le skill ne doit pas suivre.
- Validez, examinez le plan de téléversement, puis téléversez.
- Publiez. Un skill qui ajoute un outil d'écriture est retenu jusqu'à ce que deux personnes nommément désignées l'approuvent avec des passkeys, et l'auteur de la proposition ne peut pas approuver sa propre modification.
npm run skill:validate skills/check-a-customs-filing
npm run skill:upload skills/check-a-customs-filing --dry-run
npm run skill:upload skills/check-a-customs-filingLe contrôle est skill:validate, qui doit signaler zéro erreur avant que quoi que ce soit puisse être publié. Les erreurs bloquantes sont l'absence de nom ou de description et un slug ou un type de tâche en double. Téléverser un contenu déjà publié renvoie la version existante (CONTENT_HASH_ALREADY_PUBLISHED) : le téléversement peut donc être répété sans risque.
Community dispose de l'ensemble de l'éditeur, de la bibliothèque, des versions, du retour arrière, de l'import et des tests. Sur Enterprise, la publication passe également par les phases shadow et canary : la version approuvée s'exécute en mode shadow, puis pour une unité derrière des contrôles nommés, puis pour tout le monde, et elle s'arrête d'elle-même si un contrôle n'est pas satisfait. Pour un client en environnement isolé, les skills sont transmis pré-signés à l'intérieur du bundle scellé (scénario 9).
2. Une compétence de manifeste avec host_callback
L'objectif est un calcul déterministe dans votre propre plugin que la plateforme peut distribuer, par exemple ouvrir un enregistrement d'écart à partir d'une mesure. Vous utiliserez une ligne dans le skills[] du manifeste avec le niveau host_callback, et une route /internal dans votre backend protégée par le service guard du SDK.
- Déclarez le skill :
iden lower_snake,tier: "host_callback", unclassificationinférieur ou égal au plafond de confiance de votre plugin,inputSchema,outputSchemaet untimeoutMscompris entre 1 seconde et 6 heures. - Renseignez
hostCallback: le nom de votre propre Service, son port, un chemin relatif tel que/internal/skills/excursion_open, les deux plafonds d'octets (maxRequestBytesetmaxResponseBytes) ettenantHeader: "X-Organization-ID". - Déclarez la route dans
api.endpoints[]avecauth: "service-key"ouauth: "internal", et protégez-la avecrequireServiceouserviceMiddleware, jamais avec le guard de portée utilisateur. - Validez, exécutez les contrôles et laissez l'intégration synchroniser les skills avec le registre via
compileRegistry. Vous n'écrivez jamais de SQL de registre à la main.
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --self-testvalidate applique les propres règles de la synchronisation du registre avant toute synchronisation, chaque refus portant le code du destinataire. Un chemin comportant un schéma, // ou une barre oblique inverse est refusé comme cross-origin. Un plafond d'octets manquant donne ENDPOINT_BYTE_CAP_REQUIRED, un champ d'un autre niveau donne FIELD_NOT_FOR_TIER, et un délai hors plage donne TIMEOUT_OUT_OF_BOUNDS. Ensuite, nexus-gates vérifie que la route /internal porte le service guard et est déclarée internal ou service-key. Cette paire de contrôles constitue la preuve.
La synchronisation est déclarative. Envoyez l'ensemble complet des skills à chaque fois, car un skill omis est désactivé, et faites échouer votre étape de déploiement pour tout statut autre que 200. Sur Enterprise, la synchronisation d'un plugin est vérifiée dans son ensemble : si un skill enfreint une règle, rien de cette synchronisation n'est retenu (PLUGIN_SYNC_ALL_OR_NOTHING) et la version précédente continue de s'exécuter. Un plugin de confiance communautaire ne peut pas utiliser les niveaux qui accèdent à un modèle, tool_using et llm_only ; ceux-ci exigent la confiance core ou verified.
3. Étendre un pack existant
L'objectif est un nouveau secteur ou sous-secteur qui réutilise l'essentiel d'un pack existant, comme le crédit et les litiges sur cartes reposant sur la structure du pack Insurance. La brique est un pack.json qui nomme son parent dans inherits et n'ajoute que ses propres groupes de lentilles et son propre vocabulaire.
- Démarrez le pack avec le parcours de référence des domain packs, puis définissez
inheritssur l'identifiant du pack parent. - Ajoutez vos propres groupes
lens, chacun avec ses postes, son objet et sa référence de lexique. - Ajoutez vos termes au lexique, chacun avec une glose simple. Marquez un terme
exactlorsqu'il doit être affiché tel quel. - Réutilisez les lentilles partagées plutôt que de dessiner les vôtres : un régime dont plusieurs packs ont besoin, comme un registre des prestations technologiques externalisées, constitue une seule lentille partagée.
- Vérifiez la chaîne de licences. Votre pack hérite des exigences de modules complémentaires de son parent.
- Prévisualisez chaque lentille en vous mettant à la place d'une personne, sur une branche synthétique.
{ "id": "fintech", "name": "Banking and payments", "version": "0.1", "inherits": "insurance" }La preuve est la vérification de politique du contrôle pilote, qui confirme que chaque lentille ne fait que restreindre sa base et que les champs personnels restent masqués par défaut. Une lentille qui tente d'afficher ce que sa base masque est refusée avec LENS_CANNOT_WIDEN. Côté licences, la console refuse d'émettre une licence pour votre pack sans les modules complémentaires requis par son parent ; le pack Insurance requiert les salles de décision et les enregistrements scellés.
Les domain packs relèvent d'Enterprise et sont licenciés par pack. Les écrans mobiles d'un pack nécessitent également le module complémentaire Mobile apps. Un pack enfant ne peut pas modifier le shell, les composants ni les règles de rédaction.
4. Un nouveau pack de A à Z
L'objectif est la vue d'un secteur sur Nexus : son modèle de connaissances, les lentilles de chaque rôle, les preuves exigées par ses règles et le plugin qui maintient ses données à jour. Le chapitre 2.24, Construire une verticale personnalisée de bout en bout, détaille entièrement cette construction ; en voici la version courte.
- Exécutez le parcours de référence des domain packs et décrivez le pack : objet, unités, modèle de base et règles qu'il couvre.
- Construisez le modèle de connaissances sur un modèle de base et classez chaque propriété au fur et à mesure que vous l'ajoutez.
- Lisez le plan, confirmez son empreinte avec votre passkey, puis créez.
- Façonnez les lentilles dans le Lens builder, chacune restreignant une lentille de base.
- Écrivez le plugin et les éventuels skills du Skills Engine dont le pack a besoin.
- Générez des données synthétiques à partir d'une graine, avec les cas particuliers qui vous importent, et prévisualisez chaque lentille en vous mettant à la place d'une personne.
- Promouvez de l'espace de développement vers la préproduction, puis vers une unité pilote, puis vers toutes les unités.
La preuve réside dans les contrôles de promotion : tous les tests réussis sur les branches synthétiques pour passer en préproduction, puis deux relecteurs qui ne sont pas l'auteur, puis 14 jours en pilote avec moins de 1 erreur sur 1,000. Aucune étape ne peut être sautée (GATE_CANNOT_BE_SKIPPED). Les packs relèvent d'Enterprise. Sur Community, le parcours de référence des domain packs n'est pas proposé.
5. Un connecteur de données
L'objectif est que des données d'un système externe alimentent les tables de votre plugin selon un calendrier, par exemple les événements de portail provenant d'un système d'exploitation de terminal. Les briques sont un skill plugin_queue, un worker qui consomme votre file, une migration pour la table cible et une adresse sortante déclarée dans le manifeste.
- Déclarez un skill
plugin_queueavecqueueNameécrit<plugin name>.<name>. Aucun deux-points n'est autorisé, et le nom doit figurer dans le manifeste, car l'orchestrateur y place directement les tâches. - Écrivez le worker qui consomme la file et appelle le système externe.
- Déclarez l'adresse du système externe comme adresse sortante. Tout ce qui n'est pas listé est bloqué.
- Stockez ce qui arrive dans votre propre schéma, avec
organization_id,owner_user_idetbusiness_unit_idsur chaque ligne. - Lisez l'identifiant du système externe par son nom depuis l'environnement, et listez la variable dans
scripts/ci/required-env. - Déclenchez les récupérations via UNO, le moteur de workflows, jamais avec un minuteur qui appelle directement les moteurs.
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --only no-credentials --only no-direct-compute --only migrations-are-scoped
node scripts/ci/required-envvalidate vérifie le nom de la file et le délai au regard des règles de la synchronisation du registre. Les trois contrôles prouvent l'absence d'identifiant de modèle, l'absence de calcul direct et une table correctement délimitée. Exécutez le nexus-gates complet avant de pousser, car --only restreint l'exécution et l'indique dans son résumé. À l'exécution, un appel vers une adresse non déclarée dans le manifeste est arrêté en périphérie avec EGRESS_NOT_DECLARED.
Les connecteurs propres à la plateforme vers les disques, wikis, messageries et systèmes hérités, avec capture des modifications et traçabilité, sont fournis avec le module complémentaire Data connectors. Un connecteur que vous construisez vous-même est un plugin et fonctionne sur toutes les éditions. L'ajout d'une adresse sortante dans une version ultérieure constitue un élargissement, retenu jusqu'à ce que deux relecteurs l'acceptent.
6. Un outil MCP
L'objectif est un outil que Claude Code, les agents et d'autres clients MCP (Model Context Protocol) peuvent appeler, par exemple pour consulter l'historique d'inspection d'un navire. La brique est une entrée dans le mcpTools[] du manifeste, avec un name, un description et un inputSchema.
- Nommez l'outil et décrivez-le simplement. La description est ce que lit un modèle pour décider de l'appeler ou non.
- Rédigez le
inputSchemasous la forme d'un seul schéma d'objet. Ne placez pasoneOf,allOfnianyOfà son premier niveau. - Conservez la route qui sert l'outil derrière le garde de portée, comme toute autre route
/api, afin que le locataire soit déterminé à partir du jeton de l'appelant. - Validez le manifeste.
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.jsonLa preuve est validate : un combinateur de premier niveau est refusé dès la rédaction, car à l'exécution il ferait échouer l'outil pour chaque sous-agent MCP qui l'importe, et l'outil existerait sans que personne puisse l'appeler.
Sur Enterprise, chaque outil qu'un IDE (environnement de développement intégré) peut appeler est répertorié dans le catalogue d'outils du Workbench avec son niveau, le fait qu'il modifie ou non des données, une empreinte figée et les rôles autorisés à l'utiliser. Si la description de votre outil change dans une nouvelle version, le catalogue retient l'outil jusqu'à ce qu'une personne examine la modification. C'est délibéré : une description modifiée est la manière dont un outil peut commencer à demander à un modèle quelque chose qu'il ne devrait pas. Un appel à tout élément hors du laissez-passer de l'appelant est refusé avec CONNECTION_SCOPE_EXCEEDED.
7. Une vitrine en marque blanche
L'objectif est une application utilisée par les propres clients de votre client, sur le domaine du client et à sa marque, sans aucune trace d'Adverant. Les briques sont les blocs domains et branding du manifeste, les fonctions de connexion du SDK et le module complémentaire Storefront / marque blanche du client.
- Placez le domaine du client dans
domains[]sous la formeprimary, avec les éventuelsaliases. - Renseignez
branding:appName,tagline,primaryColor,accentColor, unpasskeyRpIdidentique au domaine, etoauthClientRef. - Connectez les utilisateurs via les fonctions de connexion du SDK, et déclarez exactement leurs deux routes publiques, avec
auth: "public"etallowAnonymous: true. - Faites passer chaque appel du frontend par le proxy à liste d'autorisation du backend for frontend. Ne placez jamais d'adresse de service dans le client.
- Laissez les paiements à l'administrateur du client, qui connecte les passerelles et configure le paiement à sa marque.
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --only scope-adherence --only api-contractLa preuve est scope-adherence. Il n'admet une route /api non protégée que lorsque le manifeste déclare cette méthode et ce chemin exacts comme publics et que le chemin est l'une des routes de connexion ; toute autre déclaration publique échoue et indique les deux chemins autorisés. api-contract compare ensuite les routes déclarées aux routes réelles dans les deux sens. definePlugin refuse également un frontend.basePath qui n'est pas un chemin relatif de même origine.
La marque blanche correspond au module complémentaire Storefront / marque blanche de l'offre Enterprise, qui donne également droit aux paiements. Les données de carte ne transitent jamais par Nexus. L'administrateur du client est propriétaire de la marque, et la plateforme la détermine à partir de l'organisation plutôt qu'à partir de votre code.
8. Un pack de mission Edge
L'objectif est une mission nouvelle ou mise à jour pour un satellite ou un drone exécutant Nexus Edge, par exemple l'ajout d'un adaptateur de détection de navires à une mission de veille maritime. L'élément de base est un pack de mission, construit et signé au sol.
- Partez du pack actuel sur la page Construire un pack de mission, qui prépare la nouvelle version à partir de l'ancienne et signale chaque modification.
- Ne modifiez que ce dont la mission a besoin. Conservez les éléments volumineux, le modèle de langage et l'ontologie, inchangés lorsque c'est possible.
- Vérifiez la table de placement à chaque étape dégradée, afin que chaque carte reste adaptée à ce qu'elle exécute.
- Exécutez les cas de test embarqués du pack sur un banc d'essai équipé des mêmes cartes.
- Envoyez-le pour signature : deux signatures sur trois sont requises.
- Publiez-le sur une seule plateforme. Il est placé dans l'emplacement inactif et n'est activé qu'une fois ses cas de test réussis à bord.
- Déployez-le sur la plateforme suivante après une semaine sans incident.
Cette recette ne comporte aucune commande ; elle se réalise dans les pages Nexus Edge de la console. La preuve réside dans les cas de test embarqués, qui doivent tous réussir avant l'activation du pack, et dans les deux signatures. Si un test échoue à bord, la plateforme reste sur son pack précédent et l'échec est transmis lors du passage suivant. L'installation d'un pack sur un matériel pour lequel il n'a pas été vérifié est refusée avec PACK_NOT_CHECKED_FOR_HARDWARE.
Nexus Edge est un module complémentaire, sous licence par plateforme ou par flotte. Les packs restent valides lorsqu'une plateforme est hors de contact. La liaison montante est étroite ; planifiez donc les tailles en conséquence : notre version 1.5 pesait 412 MB, contre 9.8 GB pour un pack comportant un nouveau modèle de langage.
9. Une livraison en environnement isolé (air-gapped) à un client
L'objectif est l'installation de votre plugin ou de votre pack sur un site client sans réseau. Les éléments de base sont un bundle scellé issu de @adverant/nexus-sovereign, votre clé de signature de publication et les canaux de publication propres au client.
- Construisez le plugin et ses images exactement comme pour un client connecté, avec tous les contrôles au vert.
- Créez un bundle scellé avec le profil
airgap, contenant les images, les migrations, les compétences pré-signées et une SBOM (nomenclature logicielle) avec les licences. - Signez-le avec votre clé de publication Ed25519.
- Vérifiez-le vous-même sur une machine vierge.
- Envoyez le bundle sur un support physique, et transmettez votre clé publique et le SHA-256 du bundle par un canal distinct.
- L'opérateur du client vérifie le bundle avec votre clé, puis intègre la version par ses propres canaux de publication.
nexus-airgap bundle
nexus-airgap verify --bundle cold-chain-0.4.0.tar.gz --trusted-key corran-release.pub.pem --profile airgapnexus-airgap bundle construit le bundle à partir de votre configuration de bundle. La preuve est nexus-airgap verify côté client. Il recalcule l'empreinte de chaque fichier, rejette tout fichier absent du manifeste, exige un signataire de confiance et refuse un bundle dont la liste d'autorisation réseau n'est pas vide. Un fichier modifié échoue avec BUNDLE_INTEGRITY_VIOLATION. Personne ne doit jamais désactiver la vérification stricte pour la contourner.
Les installations isolées (air-gapped) relèvent de l'offre Enterprise. Rien dans le bundle ne doit télécharger quoi que ce soit lors de l'installation, et un modèle nécessaire au plugin provient du serveur de modèles propre au client via l'AI (intelligence artificielle) Provider Router.
10. Un module réservé à l'édition Enterprise
L'objectif est une fonctionnalité fermée et sous licence qui se greffe au cœur ouvert, comme une piste d'audit à longue rétention vendue uniquement aux clients Enterprise. L'élément de base est le paquet d'interface @adverant/nexus-spi, et rien d'autre provenant de Community.
- Conservez dans votre dépôt une copie figée à l'octet près du paquet d'interface construit, en tant que paquet local
file:, avec son épinglageSHA256SUMS. - Écrivez un
RouteModule(ou unScreenModulepour les écrans de la console) qui s'appuie dessus, avec le groupe de fonctionnalités qu'il dessert. - Placez chaque route derrière
ctx.requireScope, et vérifiez le droit propre au module avant de répondre. - Refusez avec
LICENCE_LOCKEDlorsque l'organisation n'y a pas droit, et affichez l'aperçu de la fonctionnalité, jamais ses données. - Maintenez le dépôt dans le respect de la ligne de licence, puis construisez l'arborescence composée de chaque édition.
npm ci
npm test
npm run buildLa preuve est la règle de la ligne de licence : aucun import depuis un périmètre Community à l'exception du paquet d'interface, aucun import relatif sortant du dépôt, et aucune dépendance file:, link: ou workspace: en dehors de celui-ci. Ensuite, les trois commandes ci-dessus doivent réussir dans l'arborescence composée de chaque édition, et pas seulement dans votre arborescence de travail. Le chapitre 2.25, Construire pour chaque édition, contient le squelette du module.
Un module se charge dans un service Community au démarrage, sur les installations dont la licence inclut son groupe de fonctionnalités. Sans ce droit, il refuse ; la même version est donc livrée partout et ne fait rien là où elle n'est pas sous licence.
11. Dupliquer (forker) ou étendre le cœur open source
L'objectif est une modification de Community lui-même, conservée dans votre fork ou reversée au projet. L'élément de base est le code source de Community sous Apache License, Version 2.0.
- Forkez le dépôt et créez une branche à partir de
main. - Privilégiez un plugin ou une compétence si ce que vous souhaitez peut en être un. Une modification du cœur est à votre charge de maintenance à chaque version.
- Effectuez la modification avec des tests qui échouent sans elle.
- Exécutez les vérifications du projet avant de proposer quoi que ce soit.
- Conservez le fichier NOTICE, et n'utilisez pas les noms ou marques d'Adverant au-delà de l'indication de l'origine du travail.
git checkout -b feature/your-change
npm test
npm run lint
npm run typecheckLa preuve est la réussite de ces trois vérifications, ainsi que la démonstration que chaque nouveau test échouait avant votre modification. Préservez dans votre fork une propriété du cœur ouvert : Community exécute un agent de bout en bout sur un modèle local, sans clé et sans réseau. Une modification qui rompt cela rompt ce qui rend Community utilisable de manière autonome.
Ceci concerne uniquement Community. Tout ce qui doit rester fermé relève plutôt d'un module Enterprise (scénario 10), afin que la ligne de licence reste à un endroit que chacun peut désigner.
12. Une application cloud pour l'édition Team
L'objectif est une application que les clients Team peuvent installer. Team fonctionne uniquement sur Adverant cloud ; l'application ne les atteint donc que par le catalogue. Les éléments de base sont un plugin et un cluster éditeur : votre propre cluster virtuel sur Adverant cloud avec des données d'exemple.
- Construisez et testez sur le cluster éditeur, uniquement avec des données d'exemple.
- Déclarez dans son manifeste tout ce dont l'application a besoin, et rien de plus.
- Publiez-la signée, pour examen par Adverant et inscription au catalogue.
- Chaque client l'installe en accordant chaque périmètre déclaré, unité par unité.
La preuve se présente en deux parties. La version signée et examinée vous donne accès au catalogue. Ensuite, l'autorisation du client détermine ce que l'application peut atteindre sur son site, et tout appel non déclaré est refusé avec CONNECTION_SCOPE_EXCEEDED. Vous ne pouvez ajouter un périmètre manquant que dans une nouvelle version examinée par le client.
Un cluster éditeur n'a aucune route vers un client, et toute demande de données d'un client y est refusée avec TENANT_BOUNDARY. Les clients peuvent partager avec vous des résultats de tests, jamais leurs données. Team inclut la fonctionnalité d'opérations de workflows ; si votre application fournit des workflows, les clients Team peuvent donc les promouvoir eux-mêmes d'un environnement à l'autre.
13. Encapsuler une application interne existante sous forme de plugin
L'objectif est une application que votre entreprise exploite déjà, intégrée à Nexus afin qu'elle hérite de la connexion, de l'isolation et de la gouvernance. Les éléments de base sont la compétence /plugin-create pour la première ébauche, ainsi que les outils de manifeste et les contrôles du SDK pour la finaliser.
- Exécutez
/plugin-createavec le dépôt. Il analyse le code et choisit une stratégie d'encapsulation, puis génère le backend, les migrations, l'interface utilisateur (UI), le manifeste et les tests. - Faites passer le manifeste au contrat v2.
migrateajoute les trois phrases de règle et déplacedomainversdomains[], et il refuse d'inventer un point d'entrée. - Remplacez toute valeur de tenant que l'encapsulation lit dans les en-têtes par le garde de périmètre du SDK.
- Ajoutez
organization_id,owner_user_idetbusiness_unit_idà chaque table, avec des clés primaires commençant par le tenant. - Déclarez chaque route avec son droit, et installez le registre des refus.
- Exécutez les contrôles jusqu'à ce qu'ils soient au vert.
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin migrate nexus.manifest.json --write
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --self-testLa preuve est la sortie de nexus-gates avec le code 0, avec scope-adherence, one-fence, migrations-are-scoped, crud-adherence et api-contract tous réussis. Attendez-vous à ce que la première exécution échoue sur la plupart d'entre eux ; la nôtre a signalé chaque route comme sans périmètre, car l'ébauche faisait confiance à des en-têtes que le navigateur pouvait définir. Les contrôles n'ont volontairement aucune option de correction automatique.
Les applications encapsulées fonctionnent sur toutes les éditions. Le déploiement passe uniquement par les canaux de publication de l'installation ; ignorez donc tout fichier de déploiement écrit par l'ébauche. C'est le travail d'isolation qui prend du temps : prévoyez des jours sur une application réelle, et non des heures.


