Connect IT

Qu'est-ce que Connect IT ?

Connect IT est un moteur de transformation de données écrit en Perl. Il lit des données depuis une source (fichier ou corps de requête HTTP), applique des règles de transformation déclaratives, puis écrit le résultat dans une destination.

📄

Déclaratif

Les transformations sont décrites dans des fichiers de règles au format texte. Aucune connaissance de Perl n'est requise pour les configurer.

🔄

Différentiel

Un mécanisme de cache permet de ne traiter que les données nouvelles ou modifiées depuis la dernière exécution.

🔍

Qualité

Des contrôles de qualité sur les valeurs en entrée et en sortie produisent des rapports de conformité ligne par ligne.

🌐

Proxy HTTP

En mode proxy, le moteur transforme à la volée les corps de requêtes et de réponses entre un client et une API tierce.

Pipeline de traitement

1 Lecture
du fichier de règles

→

2 Chargement
des données source

→

3 Application
des règles

→

4 Contrôles
qualité

→

5 Écriture
destination

Formats supportés

Connect IT prend en charge les principaux formats d'échange de données. Le format est détecté automatiquement à partir de l'extension du fichier ou déclaré explicitement dans la section source.

CSV Entrée & Sortie

Fichiers texte délimités. Séparateur de champ et délimiteur de chaîne configurables. Gestion du multi-lignes et des encodages (UTF-8, ISO-8859-1…).

Exemple source

id;libelle;statut
P001;Produit A;actif
P002;Produit B;inactif

XLSX Entrée & Sortie

Feuilles de calcul Excel. Sélection de la feuille par nom (sheetName). La première ligne est toujours traitée comme en-tête.

Règle de configuration

type      = xlsx
sheetName = Catalogue

XML Entrée & Sortie

Documents XML avec balise racine et balise d'item configurables. Les attributs de source sont référencés par leur chemin de balise préfixé d'un /.

Exemple source

<root>
  <item>
    <id>P001</id>
    <libelle>Produit A</libelle>
  </item>
</root>

JSON Entrée & Sortie

Objets JSON avec un tableau d'items. Le chemin vers le tableau est défini par itemPath. Les champs sont référencés avec le préfixe ..

Exemple source

{
  "products": [
    { "id": "P001",
      "libelle": "Produit A" }
  ]
}

Configuration

Chaque transformation est décrite dans un fichier de règles structuré en trois sections : source, destination et rules.

Fichier de règles — structure complète

<source>
    name         = ERP produits          # Nom affiché dans les logs
    type         = csv                   # csv | xlsx | xml | json
    file         = ./data/produits.csv   # Fichier source
    key          = ${sku}               # Attribut clé (unicité)
    cache        = iterate              # iterate | total | false
    sheetName    = Feuil1               # XLSX uniquement
    itemPath     = products             # JSON : chemin vers le tableau
    rootTag      = root                 # XML : balise racine
    itemPath     = item                 # XML : balise d'item
</source>

<destination>
    name         = PIM Akeneo
    type         = csv
    file         = ./out/akeneo.csv
</destination>

<rules>
    <rule>
        function   = syncString
        srcAttr    = ${sku}
        dstAttr    = identifiant
    </rule>
    <rule>
        function   = syncString
        srcAttr    = ${libelle}
        dstAttr    = nom_produit
        substitute = s/^\s+|\s+$//g     # Trim espaces
    </rule>
</rules>

Paramètres de la section `source`

Paramètre	Description	Valeurs
`type`	Format du fichier source	`csv` · `xlsx` · `xml` · `json`
`key`	Attribut identifiant chaque ligne (utilisé pour le cache)	`${nomColonne}`
`cache`	Stratégie de mise en cache différentielle	`iterate` · `total` · `false`
`sheetName`	Nom de la feuille (XLSX uniquement)	Texte libre
`itemPath`	Chemin vers le tableau d'items (JSON) ou balise d'item (XML)	Texte libre
`rootTag`	Balise racine XML	Texte libre
`encode`	Encodage du fichier source	`utf-8` · `iso-8859-1`…

Référencement des attributs source

CSV / XLSX

${nomColonne}

Nom de la colonne de l'en-tête

srcAttr = ${prix_ht}

XML

/nomBalise

Chemin de la balise enfant

srcAttr = /prix_ht

JSON

.nomChamp

Nom du champ JSON

srcAttr = .prix_ht

Fonctions de transformation

Chaque règle possède une propriété function qui détermine comment la valeur source est traitée pour produire la valeur destination.

syncString Copie et transforme une valeur source vers un attribut destination

C'est la fonction de base. Elle lit une valeur source (une ou plusieurs colonnes), lui applique optionnellement une chaîne de substitutions Perl, et l'écrit dans l'attribut de destination.

Paramètres

Paramètre	Description
`srcAttr`	Attribut(s) source — peut combiner plusieurs colonnes
`dstAttr`	Attribut destination
`substitute`	Une ou plusieurs substitutions Perl (chaînables)

Exemples courants

# Mise en majuscules
substitute = s/^(.*)$/uc($1)/e

# Suppression des accents
substitute = tr/àâäèéêëîïôüç/aaaeeeeiiouc/

# Suppression espaces en début/fin
substitute = s/^\s+|\s+$//g

# Remplacement d'un motif
substitute = s/ /-/g

# Extraction d'une partie
substitute = s/^.*>([^>]*)$/$1/

Exemples de règles

# Copie simple
<rule>
    function   = syncString
    srcAttr    = ${libelle}
    dstAttr    = nom
</rule>

# Concaténation de deux colonnes
<rule>
    function   = syncString
    srcAttr    = ${prenom} ${nom}
    dstAttr    = nom_complet
</rule>

# Transformation en majuscules avec suppression d'accents
<rule>
    function   = syncString
    srcAttr    = ${libelle}
    dstAttr    = libelle_clean
    substitute = s/^\s+|\s+$//g
    substitute = tr/àâäèéêëîïôüç/aaaeeeeiiouc/
    substitute = s/^(.*)$/uc($1)/e
</rule>

# Valeur statique
<rule>
    function   = syncString
    srcAttr    = actif
    dstAttr    = statut_defaut
</rule>

Syntaxe courte — Pour les règles simples, une notation condensée sur une ligne est disponible :

- ||${libelle}|nom|s/^\s+|\s+$//g

Format : - ||srcAttr|dstAttr|substitution

groupString Regroupe dynamiquement plusieurs attributs en paires clé/valeur

Utilisée pour transformer un ensemble de colonnes sources (sélectionnées par un filtre) en une liste de paires nom_attribut / valeur, utile pour alimenter des PIM ou des systèmes EAV.

Paramètres

Paramètre	Description
`filterFieldsSubstitute`	Filtre les colonnes à inclure (retourne `1` pour inclure)
`dstAttr`	Nom de l'attribut destination, avec `%` pour l'index
`substitute`	Transformation appliquée à chaque valeur
`withExistingFields`	Inclut les colonnes déjà traitées (`true`)
`filterValue`	Filtre sur la valeur transformée

Résultat produit

Pour chaque colonne sélectionnée, deux colonnes destination sont générées :

# dstAttr = attribut%
attribut1 = accentedAttribute5
valeur1   = ÀÇÇÉNTÜÈ
attribut2 = quotedAttribute8
valeur2   =    UNCLEANED VALUE

Exemple

# Regroupe toutes les colonnes dont le nom contient "accent" ou "quoted"
<rule>
    function              = groupString
    filterFieldsSubstitute = m/.*accent.*|.*quoted.*/ ? 1 : 0
    dstAttr               = groupeAttribut%
    substitute            = s/^(.*)$/uc($1)/e
</rule>

searchString Recherche des correspondances dans le jeu de données chargé

Parcourt l'ensemble des lignes sources pour trouver celles qui satisfont un critère de recherche, puis retourne la (ou les) valeur(s) correspondante(s). Équivalent d'un RECHERCHEV paramétrable, avec support multi-résultats.

Paramètres

Paramètre	Description
`type`	`first` : première correspondance · `concat` : toutes les valeurs concaténées
`srcAttr`	Attribut dont la valeur est retournée
`syncAttr`	Attribut sur lequel porte la recherche
`syncAttrSubstitute`	Critère de sélection : retourne `1` si la ligne est retenue
`filterAttr`	Condition préalable sur la ligne courante
`filterSubstitute`	Critère du filtre (retourne `1` pour activer)
`separator`	Séparateur pour le mode `concat`
`substitute`	Transformation appliquée à chaque valeur trouvée

Fonctionnement

Lignes chargées en mémoire

↓ syncAttrSubstitute retourne 1 ?

→ retourne srcAttr transformé par substitute

first : s'arrête à la 1ère correspondance
concat : accumule toutes les correspondances

Exemple

# Première correspondance : retourne la valeur de simpleAttribute1
# pour la première ligne où simpleAttribute2 vaut "id with space"
<rule>
    function           = searchString
    type               = first
    srcAttr            = ${simpleAttribute1}
    syncAttr           = ${simpleAttribute2}
    syncAttrSubstitute = s/^id with space$/1/
    dstAttr            = resultatRecherche
    substitute         = s/^value/val/
</rule>

# Concaténation : toutes les valeurs correspondantes séparées par |
# avec filtre conditionnel sur la ligne courante
<rule>
    function           = searchString
    type               = concat
    separator          = |
    srcAttr            = ${simpleAttribute1}
    syncAttr           = ${simpleAttribute2}
    syncAttrSubstitute = s/^id with space$/1/
    filterAttr         = ${simpleAttribute3}
    filterSubstitute   = s/^not_quoted$/1/
    dstAttr            = listeResultats
    substitute         = s/^value/val/
</rule>

Substitutions Perl

Les substitutions utilisent la syntaxe Perl standard. Elles sont chaînables : chaque règle peut en déclarer plusieurs, appliquées dans l'ordre.

Substitution simple

s/motif/remplacement/

Remplace la première occurrence du motif.

Substitution globale

s/motif/remplacement/g

Remplace toutes les occurrences.

Évaluation de code

s/^(.*)$/uc($1)/e

Exécute du code Perl dans le remplacement (uc, lc, ucfirst…).

Translittération

tr/àâäèéêëîïôüç/aaaeeeeiiouc/

Remplace caractère par caractère, idéal pour supprimer les accents.

Référence à l'attribut source

s/^.*$/${srcAttr}/e

Utilise le nom de l'attribut source dans le remplacement.

Test conditionnel

m/^valide$/ ? 1 : 0

Retourne 1 si le motif correspond, 0 sinon — utilisé dans les filtres.

Séquençage des substitutions

# Les substitutions sont appliquées dans l'ordre de déclaration
<rule>
    function   = syncString
    srcAttr    = ${description}
    dstAttr    = description_clean
    substitute = s/^\s+|\s+$//g          # 1. Trim
    substitute = tr/àâäèéêëîïôüç/aaaeeeeiiouc/  # 2. Accents
    substitute = s/ /_/g                 # 3. Espaces → underscores
    substitute = s/^(.*)$/uc($1)/e       # 4. Majuscules
</rule>

Contrôles qualité

Deux attributs spéciaux permettent de valider les valeurs avant et après transformation. Un rapport de conformité est émis sur la sortie standard pour chaque attribut contrôlé.

qualityINSubstitute Contrôle en entrée

Appliqué à la valeur source avant toute transformation. La substitution doit retourner 1 pour que la valeur soit considérée conforme.

# Valide que la valeur source est en minuscules
qualityINSubstitute = s/^[a-z]+$/1/

qualityOUTSubstitute Contrôle en sortie

Appliqué à la valeur transformée, après toutes les substitutions. La substitution doit retourner 1 pour que la valeur de sortie soit conforme.

# Valide que la valeur destination est en majuscules
qualityOUTSubstitute = s/^[A-Z]+$/1/

Format des messages de log

OK date=24/03/2026 source=ERP key=P001 file=produits.csv attribute=${libelle} quality=in status=OK

KO

date=24/03/2026 source=ERP key=P002 file=produits.csv attribute=${libelle} quality=in status=KO value=LIBELLE INVALIDE----LIBELLE INVALIDE

OK date=24/03/2026 source=ERP key=P001 file=produits.csv attribute=libelle_clean quality=out status=OK

KO

date=24/03/2026 source=ERP key=P003 file=produits.csv attribute=libelle_clean quality=out status=KO value=  valeur avec espaces

Ordre d'émission — Les messages de qualité sont émis avant les lignes sync_status=synchronized, ce qui permet de les filtrer indépendamment dans les pipelines de log.

Exemple complet

<rule>
    function             = syncString
    srcAttr              = ${libelle}
    dstAttr              = libelle_upper
    substitute           = s/^(.*)$/uc($1)/e
    qualityINSubstitute  = s/^[a-z][a-z ]+$/1/  # entrée : que des minuscules
    qualityOUTSubstitute = s/^[A-Z][A-Z ]+$/1/  # sortie : que des majuscules
</rule>

Mode proxy

En mode proxy, Connect IT s'intercale entre un client et une API tierce. Il transforme le corps de la requête sortante (requestRules), envoie à l'API, puis transforme la réponse reçue (responseRules) avant de la retourner au client.

Client

requête JSON →

Connect IT requestRules

requête transformée →

API tierce

réponse transformée ←

Connect IT responseRules

réponse API ←

Structure du fichier de règles proxy

<source>
    name      = Mon ERP
    type      = json
    itemPath  = products
</source>

<destination>
    name      = API Akeneo
    type      = json
    targetUrl = https://api.akeneo.com/api/products
</destination>

<requestRules>           # Transformation avant envoi à l'API
    <rule>
        function  = syncString
        srcAttr   = .sku
        dstAttr   = identifier
    </rule>
    <rule>
        function  = syncString
        srcAttr   = .libelle
        dstAttr   = values.name.fr_FR
    </rule>
</requestRules>

<responseRules>          # Transformation de la réponse API
    <rule>
        function  = syncString
        srcAttr   = .identifier
        dstAttr   = sku
    </rule>
</responseRules>

Utilisation

Connect IT expose deux modes d'appel depuis votre code Perl : traitement de fichiers et traitement de corps de données.

📁 processFile()

Lit depuis un fichier source, écrit dans un fichier destination. Supporte la mise en cache différentielle.

use syncMain;

syncMain::processFile(
    "./rules/produits.rules",  # fichier de règles
    "./data/in.csv",           # source (optionnel)
    "",                        # source 2 (optionnel)
    "./data/out.csv",          # destination (optionnel)
    "TRUE"                     # mode debug
);

💬 processBody()

Reçoit un corps de données en mémoire (chaîne), retourne le résultat transformé. Utilisé pour les transformations HTTP en mode proxy.

use syncMain;

my $result = syncMain::processBody(
    "./rules/proxy.rules",   # fichier de règles
    $json_input,             # données source (string)
    "",                      # source 2 (optionnel)
    "TRUE",                  # mode debug
    "requestRules"           # section de règles
);

print $result;  # données transformées

Sortie standard (logs)

Chaque ligne traitée génère un message sur la sortie standard. Ces messages sont structurés pour être parsés par des outils de supervision.

date=24/03/2026 - 14:30 source=ERP key=P001 file=produits.csv sync_status=synchronized line=P001;Produit A;ACTIF

date=24/03/2026 - 14:30 source=ERP key=P002 file=produits.csv sync_status=unsynchronized by cache line=P002;Produit B;INACTIF

date=24/03/2026 - 14:30 source=ERP synchronized_lines=1

Qu'est-ce que Connect IT ?

Déclaratif

Différentiel

Qualité

Proxy HTTP

Pipeline de traitement

Formats supportés

Configuration

Paramètres de la section source

Référencement des attributs source

Fonctions de transformation

Paramètres

Exemples courants

Exemples de règles

Paramètres

Résultat produit

Exemple

Paramètres

Fonctionnement

Exemple

Substitutions Perl

Séquençage des substitutions

Contrôles qualité

Format des messages de log

Exemple complet

Mode proxy

Structure du fichier de règles proxy

Utilisation

Sortie standard (logs)

Paramètres de la section `source`