Aller au contenu

Bac à sable

Un bac à sable est une organisation LexOpti isolée des vraies structures, pour développer, tester en intégration continue ou faire une démonstration. Votre application y fonctionne exactement comme avec une vraie structure : OAuth, /v1, composants embarqués et serveur MCP. Les comptes développeur et professionnel sont distincts : si vous utilisez déjà LexOpti en tant que professionnel, créez votre compte développeur avec une autre adresse e-mail.

Propriété Valeur
Par application 5 au plus, chacun avec un nom unique dans l’application
Premier bac à sable créé avec votre application, dans la console développeur ou par LexOpti quand elle l’enregistre, au nom de votre compte développeur
Les suivants créés par le développeur de l’application, depuis Gérer les bacs à sable dans le sélecteur d’organisation
Profession choisie à la création (avocat, notaire, expert-comptable, agent immobilier, autre profession assujettie) : elle fixe le vocabulaire, les natures des dossiers, les rôles des parties et le questionnaire de classification
Marque une pastille traduite Bac à sable dans le sélecteur et sur la page d’autorisation, un bandeau sur chaque page ; le nom ne porte aucune marque
GET /v1/organization sandbox: true
Contenu des webhooks livemode: false
Simulé Réel
Analyses : chaque entité analysée reçoit un résultat déterministe, aucune source n’est consultée, aucune tâche ne tourne Webhooks vers vos propres points de réception
Recherches d’entreprises et d’adresses : réponses fictives Invitations de collègues
Facturation : rien n’est facturé ni prélevé ; chaque dossier, analyse ou partie est chiffré et facturé comme celui d’une vraie structure (les mêmes prévisualisations, credits_charged, douze mois de couverture, renouvellements), mais le solde reste à ses 1 000 crédits gratuits et les mouvements restent vides ; une réinitialisation les rend après quota_exhausted
Vigilance continue : jamais programmée

Mettez un mot-clé dans le nom de la personne ou de la société (casse et accents ignorés), ou un SIREN réservé :

Mot-clé SIREN Résultat
SANCTION 999000011 correspondances de sanctions (internationales, UE, gels d’avoirs français) et alertes
EXPOSE 999000029 personne politiquement exposée et une alerte
PROCEDURE 999000037 procédure collective au BODACC et alertes
PRESSE 999000045 presse défavorable et une alerte
ERREUR 999000052 toutes les sources échouent : check.failed
tout le reste tout autre aucun risque

Les noms des résultats sont vos propres entrées fictives.

Les mêmes entrées règlent l’analyse préliminaire gratuite des clients que crée votre application, aussitôt et sans consulter les listes : SANCTION donne une correspondance possible sur le registre national des gels et une correspondance OFAC, ERREUR une analyse en échec, toute autre entrée aucune correspondance.

Un bac à sable n’est pas vide : à sa création, et de nouveau après chaque réinitialisation, il contient des clients et des dossiers d’exemple couvrant chaque entrée magique, déjà analysés avec les résultats du bac à sable, pour que votre application lise tout de suite des données réalistes (GET /v1/clients, GET /v1/cases, GET /v1/alerts). Tous les noms sont fictifs.

Exemple Nature Entrée magique Résultat
Camille EXEMPLE personne, client aucune aucun risque
Léa EXEMPLE-SANCTION personne, client SANCTION correspondances de sanctions et leurs alertes en attente
Hugo EXEMPLE-EXPOSE personne, client EXPOSE personne politiquement exposée et son alerte
EXEMPLE PRESSE SAS société, client PRESSE, 999000045 presse défavorable et son alerte
EXEMPLE PROCEDURE SARL société, client PROCEDURE, 999000037 procédure collective au BODACC et ses alertes
EXEMPLE ERREUR SAS société, client ERREUR, 999000052 toutes les analyses ont échoué
Exemple : vente d’un appartement dossier de Camille EXEMPLE parties : Paul EXEMPLE-PRESSE (vendeur), EXEMPLE IMMOBILIER SCI (acquéreur) la presse défavorable du vendeur lève une alerte sur Camille EXEMPLE
Exemple : cession de parts sociales dossier d’EXEMPLE PROCEDURE SARL partie : Inès EXEMPLE (cessionnaire) partie sans risque

La nature des dossiers et le rôle des parties suivent la profession du bac à sable ; les intitulés des dossiers sont dans la langue de son propriétaire. Les clients Camille EXEMPLE et Léa EXEMPLE-SANCTION portent aussi une analyse préliminaire, sans correspondance et avec une correspondance possible. L’écriture des exemples n’envoie rien : aucun événement, aucun webhook.

POST /v1/sandbox/triggers produit dans le bac à sable un changement comme il se produirait dans une vraie structure, par les mêmes écritures : vos points de réception reçoivent les webhooks mêmes de la production (livemode: false). Il demande lexopti:write et un membre qui peut écrire, et répond 202 avec les événements à attendre ; ailleurs que dans un bac à sable il répond 403 sandbox_required et ne change rien.

type Demande Ce qui se passe Événements
vigilance_alert client_id un nouveau résultat de presse défavorable sur le client lève une alerte en attente alert.created, et client.vigilance_level_changed quand le niveau change
vigilance_level_change client_id le niveau de vigilance du client monte à enhanced, ou, depuis enhanced, redescend ; aucune alerte client.vigilance_level_changed
quota_exhausted rien le dernier crédit de l’organisation est dépensé, et le bac à sable reste sans crédit : tout dossier, analyse ou partie qui coûte est refusée avec quota_exceeded, comme pour une vraie structure ; ce qui est déjà payé continue quota.exhausted
quota_restored rien le bac à sable retrouve ses 1 000 crédits gratuits, après quota_exhausted aucun
access_revoked rien votre application perd réellement son accès au bac à sable : le consentement et les jetons de chaque membre y sont supprimés, si bien que le jeton de cette requête cesse de fonctionner access.revoked, puis vos points de réception sont désactivés avec disabled_reason: access_revoked

Les événements qu’écrit un changement arrivent aussitôt ; ceux que le répartiteur en déduit (client.vigilance_level_changed, access.revoked) en une dizaine de secondes. Après access_revoked, autorisez de nouveau l’application et réactivez vos points de réception (PATCH /v1/webhook-endpoints/{id} avec enabled: true).

import {
function createLexOptiClient(options: LexOptiClientOptions): LexOptiClient

A typed client of the LexOpti API. Every idempotent POST gets an Idempotency-Key (kept across its retries); only requests safe to repeat are retried after a failure, with jittered backoff or Retry-After. Errors are oRPC errors: problemOf(error) reads the problem details.

createLexOptiClient
} from "@lexopti/sdk";
const
const lexopti: LexOptiClient
lexopti
=
function createLexOptiClient(options: LexOptiClientOptions): LexOptiClient

A typed client of the LexOpti API. Every idempotent POST gets an Idempotency-Key (kept across its retries); only requests safe to repeat are retried after a failure, with jittered backoff or Retry-After. Errors are oRPC errors: problemOf(error) reads the problem details.

createLexOptiClient
({
LexOptiClientOptions.accessToken: () => Promise<string> | string

Returns the OAuth access token for each request: refresh it there when it expires (access tokens live 15 minutes).

accessToken
: () =>
function getAccessToken(): Promise<string>
getAccessToken
() });
// Une nouvelle alerte de vigilance sur un client du bac à sable.
const
const trigger: {
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored";
client_id: string | null;
events: string[];
vigilance_level: "simplified" | "standard" | "enhanced" | null;
livemode: false;
}
trigger
= await
const lexopti: LexOptiClient
lexopti
.
sandboxTriggers: {
create: Client<Record<never, never>, {
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored";
client_id?: string | undefined;
}, {
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored";
client_id: string | null;
events: string[];
vigilance_level: "simplified" | "standard" | "enhanced" | null;
livemode: false;
}, Error>;
}
sandboxTriggers
.
create: Client
(input: {
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored";
client_id?: string | undefined;
}, options?: FriendlyClientOptions<Record<never, never>> | undefined) => ClientPromiseResult<{
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored";
client_id: string | null;
events: string[];
vigilance_level: "simplified" | "standard" | "enhanced" | null;
livemode: false;
}, Error>
create
({
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored"
type
: "vigilance_alert",
client_id?: string | undefined
client_id
:
const clientId: string
clientId
,
});
var console: Console

The console module provides a simple debugging console that is similar to the JavaScript console mechanism provided by web browsers.

The module exports two specific components:

  • A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
  • A global console instance configured to write to process.stdout and process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently synchronous like the browser APIs they resemble, nor are they consistently asynchronous like all other Node.js streams. See the note on process I/O for more information.

Example using the global console:

console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
// Error: Whoops, something bad happened
// at [eval]:5:15
// at Script.runInThisContext (node:vm:132:18)
// at Object.runInThisContext (node:vm:309:38)
// at node:internal/process/execution:77:19
// at [eval]-wrapper:6:22
// at evalScript (node:internal/process/execution:76:60)
// at node:internal/main/eval_string:23:3
const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr

Example using the Console class:

const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);
myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err
const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err

@see ― source

console
.
Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)

Prints to stdout with newline. Multiple arguments can be passed, with the first used as the primary message and all additional used as substitution values similar to printf(3) (the arguments are all passed to util.format()).

const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout

See util.format() for more information.

@since ― v0.1.100

log
(
const trigger: {
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored";
client_id: string | null;
events: string[];
vigilance_level: "simplified" | "standard" | "enhanced" | null;
livemode: false;
}
trigger
.
events: string[]
events
);
Action Qui Où
Ouvrir, basculer tout membre du bac à sable la section Bacs à sable du sélecteur d’organisation
Quitter tout membre qui appartient aussi à une vraie structure Quitter le bac à sable dans le bandeau : retour à la dernière vraie structure active
Inviter un collègue son propriétaire ou un administrateur la page des membres du bac à sable, par les invitations habituelles ; être membre d’un bac à sable n’ouvre aucune vraie structure
Créer le développeur de l’application Gérer les bacs à sable, 5 par application au plus
Renommer, réinitialiser, supprimer son propriétaire (son créateur, ou le membre à qui il l’a transféré) Gérer les bacs à sable ; la réinitialisation aussi dans le bandeau

LexOpti peut aussi réinitialiser ou supprimer un bac à sable pour vous. Chaque changement est inscrit dans l’activité du bac à sable, ou dans le journal d’audit de la plateforme quand LexOpti le fait.

Une réinitialisation vide le bac à sable sur place, en une seule transaction, puis écrit de nouveau les données d’exemple, avec de nouveaux identifiants :

Gardé Effacé
l’organisation et son identifiant clients, dossiers, entités et leurs liens
ses membres et les invitations en attente contrôles, analyses, alertes et propositions de revue
le consentement et les jetons de votre application : rien à reconnecter classifications et formulaires TRACFIN
vos points de réception de webhooks et leurs secrets commentaires, documents et rapports
les événements et les envois passés (GET /v1/events) tout l’historique d’activité du bac à sable (création, renommages, réinitialisations précédentes, chaque changement d’un dossier) : il repart de cette seule réinitialisation
les notifications d’adhésion (invitations, demandes) les notifications sur les dossiers (analyses, alertes, dossiers, commentaires)
vos external_ref, clés d’idempotence, liens profonds et codes de session embarquée
  • Les anciens identifiants de client, de dossier et de contrôle répondent 404 not_found sur /v1, dans les composants embarqués et dans les outils MCP, jamais 500.
  • Les envois encore en attente sont annulés, et les événements pas encore envoyés ne le seront jamais : une réinitialisation n’envoie rien. Les événements qu’écrirait la réinitialisation elle-même (sur les dossiers qu’elle efface, ou les exemples qu’elle écrit) ne sont pas enregistrés.
  • Au plus une réinitialisation par minute et par bac à sable : une autre est refusée tant que la minute n’est pas écoulée.
  • Le journal d’audit des actions de la plateforme sur le bac à sable est gardé ; seul l’historique d’activité du bac à sable part.

Supprimer un bac à sable l’efface définitivement, avec l’accès de tous ses membres et de toutes les applications : c’est irréversible.