Lorsque nous travaillons sur un projet axé sur l'automatisation des processus et l'infrastructure chez zCloud, nous rencontrons fréquemment le besoin de créer plusieurs fonctions pour effectuer des validations et des processus communs. Tout fonctionne bien lorsque vous utilisez un seul système d'exploitation, mais la situation se complique lorsque plusieurs systèmes sont impliqués.

Dans notre cas, la majeure partie du développement se déroule sous Linux, mais nous devons également garantir la compatibilité avec macOS. Cela entraîne souvent des incompatibilités de code.

Pour résoudre ce problème, nous migrons nos fonctions de script shell vers des fichiers JavaScript, en utilisant Bun comme interpréteur. Nous avons choisi Bun car il offre un moyen simple d'exécuter des commandes comme un shell via sa fonctionnalité API Shell.

Vous trouverez ci-dessous un exemple de fonction que nous utilisons pour vérifier toute modification de code avant d'appliquer des modifications à l'infrastructure.

Code du script Shell :

function zc_check_pristine_git() {
    if [ "$ZC_CURRENT_ENV" = "staging" ] || [ "$ZC_CURRENT_ENV" = "dev" ]; then
      return 0
    fi

    local not_pristine=0
    local modified_files=""

    # Check for staged but uncommitted changes
    staged_changes=$(git diff --name-only --cached)
    if [ -n "$staged_changes" ]; then
        not_pristine=1
        modified_files ="Staged changes:\n$staged_changes"
    fi

    # Check for unstaged changes
    unstaged_changes=$(git diff --name-only)
    if [ -n "$unstaged_changes" ]; then
        not_pristine=1
        modified_files ="Unstaged changes:\n$unstaged_changes"
    fi

    # Check for untracked files
    untracked_files=$(git ls-files --others --exclude-standard)
    if [ -n "$untracked_files" ]; then
        not_pristine=1
        modified_files ="Untracked files:\n$untracked_files"
    fi

    # Check if the current branch is ahead of the remote
    ahead_commits=$(git log @{u}.. --oneline)
    if [ -n "$ahead_commits" ]; then
        not_pristine=1
        modified_files ="Commits ahead of the remote:\n$ahead_commits\n\n"
    fi

    if [ $not_pristine -eq 1 ]; then
        echo -e "$modified_files"
        return 1
    fi

    return 0
}

||

; alors retourner 0 fi local not_pristine=0 fichiers_modifiés locaux="" # Vérifiez les modifications échelonnées mais non validées staged_changes=$(git diff --name-only --cached) si [ -n "$staged_changes" ]; alors not_pristine=1 modifié_files ="Modifications par étapes :\n$staged_changes" fi # Vérifiez les modifications non planifiées unstaged_changes=$(git diff --name-only) if [ -n "$unstaged_changes" ]; alors not_pristine=1 modifié_files ="Modifications non planifiées :\n$unstaged_changes" fi # Vérifier les fichiers non suivis untracked_files=$(git ls-files --others --exclude-standard) if [ -n "$untracked_files" ]; alors not_pristine=1 modifié_files ="Fichiers non suivis :\n$untracked_files" fi # Vérifiez si la branche actuelle est en avance sur la branche distante advance_commits=$(git log @{u}.. --oneline) if [ -n "$ahead_commits" ]; alors not_pristine=1 modifié_files ="Commits avant le distant :\n$ahead_commits\n\n" fi si [ $not_pristine -eq 1 ]; alors echo -e "$fichiers_modifiés" retour 1 fi retourner 0 }

Pour convertir ce code en JavaScript, nous avons créé un fichier nommé zc_check_pristine_git dans le répertoire bin du projet (qui se trouve déjà dans le PATH) avec le contenu suivant :

#!/usr/bin/env bun
// @language JavaScript

import { checkPristineGit } from '../js/helpers/helpers.js';

await checkPristineGit({ currentEnv: process.env.ZC_CURRENT_ENV });

#!/usr/bin/env petit pain // @langue JavaScript importer { checkPristineGit } depuis '../js/helpers/helpers.js' ; wait checkPristineGit({ currentEnv: process.env.ZC_CURRENT_ENV });

Nous avons utilisé le shebang #!/usr/bin/env bun pour indiquer que nous utilisons Bun comme interprète.

Nous avons ajouté le commentaire // @langage JavaScript afin que l'EDI reconnaisse le fichier comme JavaScript (nous utilisons principalement les outils Jetbrains).

Ensuite, nous avons importé la fonction qui sera réellement exécutée.
Implémentation de la fonction convertie du shell vers JavaScript :

#!/usr/bin/env bun
// @language JavaScript

import { checkPristineGit } from '../js/helpers/helpers.js';

await checkPristineGit({ currentEnv: process.env.ZC_CURRENT_ENV });

export const checkPristineGit = async ({ currentEnv }) => { exitOnError(() => { notEmpty(currentEnv, 'currentEnv est requis'); }); if (['staging', 'dev'].includes(currentEnv)) { retour; } laissez notPristine = 0; laissez fichiers modifiés = ''; // Vérifie les modifications planifiées mais non validées const stagedChanges = wait $`git diff --name-only --cached`.text(); if (stagedChanges !== '') { notPristine = 1 ; modifiéFiles = `Modifications par étapes :\n${stagedChanges}` ; } // Vérifie les modifications non planifiées const unstagedChanges = wait $`git diff --name-only`.text(); if (modifications non mises en scène !== '') { notPristine = 1 ; modifiéFiles = `Modifications non planifiées :\n${unstagedChanges}` ; } // Recherche les fichiers non suivis const untrackedFiles = wait $`git ls-files --others --exclude-standard`.text(); if (fichiers non suivis !== '') { notPristine = 1 ; modifiéFiles = `Fichiers non suivis :\n${untrackedFiles}` ; } // Vérifie si la branche actuelle est en avance sur la branche distante const advanceCommits = wait $`git log @{u}.. --oneline`.text(); if (aheadCommits !== '') { notPristine = 1 ; modifiéFiles = `Commits avant le distant :\n${aheadCommits}` ; } si (pas vierge) { console.warn('Erreur : vous ne pouvez appliquer les modifications dans les environnements de production que si le référentiel est dans un état impeccable.'); console.warn(fichiers modifiés); processus.exit(1); } } ;

---

De cette façon, nous avons standardisé le code JavaScript qui sera exécuté comme un script shell.

Il existe des appels à des fonctions (exitOnError, notEmpty) qui ne sont pas implémentés dans l'exemple fourni.