Migration du script shell vers \'Bun script\'

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 fait 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 grâce à 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
}

Pour convertir ce code en JavaScript, nous avons créé un fichier nommé zc_check_pristine_git dans le répertoire bin du projet (qui est 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 });

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 pour 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 en JavaScript :

export const checkPristineGit = async ({ currentEnv }) => {
  exitOnError(() => {
    notEmpty(currentEnv, 'currentEnv is required');
  });
  if (['staging', 'dev'].includes(currentEnv)) {
    return;
  }

  let notPristine = 0;
  let modifiedFiles = '';

  // Check for staged but uncommitted changes
  const stagedChanges = await $`git diff --name-only --cached`.text();
  if (stagedChanges !== '') {
    notPristine = 1;
    modifiedFiles += `Staged changes:\n${stagedChanges}`;
  }

  // Check for unstaged changes
  const unstagedChanges = await $`git diff --name-only`.text();
  if (unstagedChanges !== '') {
    notPristine = 1;
    modifiedFiles += `Unstaged changes:\n${unstagedChanges}`;
  }

  // Check for untracked files
  const untrackedFiles = await $`git ls-files --others --exclude-standard`.text();
  if (untrackedFiles !== '') {
    notPristine = 1;
    modifiedFiles += `Untracked files:\n${untrackedFiles}`;
  }

  // Check if the current branch is ahead of the remote
  const aheadCommits = await $`git log @{u}.. --oneline`.text();
  if (aheadCommits !== '') {
    notPristine = 1;
    modifiedFiles += `Commits ahead of the remote:\n${aheadCommits}`;
  }

  if (notPristine) {
    console.warn('Error: You can only apply changes in production environments if the repository is in a pristine state.');
    console.warn(modifiedFiles);
    process.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ées dans l'exemple fourni.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!