Bei der Arbeit an einem Projekt mit Schwerpunkt auf Prozessautomatisierung und Infrastruktur bei zCloud müssen wir häufig mehrere Funktionen erstellen, um Validierungen und gemeinsame Prozesse durchzuführen. Alles funktioniert gut, wenn nur ein Betriebssystem verwendet wird, aber die Situation wird komplizierter, wenn mehr als ein System beteiligt ist.

In unserem Fall findet der Großteil der Entwicklung unter Linux statt, wir müssen aber auch die Kompatibilität mit macOS sicherstellen. Dies führt häufig zu Code-Inkompatibilitäten.

Um dieses Problem zu beheben, migrieren wir unsere Shell-Skriptfunktionen in JavaScript-Dateien und verwenden dabei Bun als Interpreter. Wir haben uns für Bun entschieden, weil es über seine Shell-API-Funktionalität eine einfache Möglichkeit bietet, Befehle wie eine Shell auszuführen.

Unten finden Sie ein Beispiel für eine Funktion, mit der wir vor der Anwendung von Infrastrukturänderungen nach Codeänderungen suchen.

Shell-Skriptcode:

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
}

||

; Dann 0 zurückgeben fi lokal not_pristine=0 local Modified_files="" # Auf bereitgestellte, aber nicht festgeschriebene Änderungen prüfen staged_changes=$(git diff --name-only --cached) if [ -n "$staged_changes" ]; Dann not_pristine=1 Modified_files = „Inszenierte Änderungen:\n$staged_changes“ fi # Auf nicht bereitgestellte Änderungen prüfen unstaged_changes=$(git diff --name-only) if [ -n "$unstaged_changes" ]; Dann not_pristine=1 Modified_files = „Nicht bereitgestellte Änderungen:\n$unstaged_changes“ fi # Suchen Sie nach nicht verfolgten Dateien untracked_files=$(git ls-files --others --exclude-standard) if [ -n "$untracked_files" ]; Dann not_pristine=1 Modified_files = „Nicht verfolgte Dateien:\n$untracked_files“ fi # Überprüfen Sie, ob der aktuelle Zweig vor dem entfernten Zweig liegt ahead_commits=$(git log @{u}.. --oneline) if [ -n "$ahead_commits" ]; Dann not_pristine=1 Modified_files = „Commits vor dem Remote:\n$ahead_commits\n\n“ fi if [ $not_pristine -eq 1 ]; Dann echo -e "$modified_files" Rückkehr 1 fi 0 zurückgeben }

Um diesen Code in JavaScript zu konvertieren, haben wir eine Datei namens zc_check_pristine_git im bin-Verzeichnis des Projekts (das sich bereits im PATH befindet) mit folgendem Inhalt erstellt:

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

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

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

#!/usr/bin/env bun // @Sprache JavaScript import { checkPristineGit } from '../js/helpers/helpers.js'; Warten Sie auf checkPristineGit({ currentEnv: process.env.ZC_CURRENT_ENV });

Wir haben den Shebang #!/usr/bin/env bun verwendet, um anzuzeigen, dass wir Bun als Interpreter verwenden.

Wir haben den Kommentar // @Language JavaScript hinzugefügt, damit die IDE die Datei als JavaScript erkennt (wir verwenden hauptsächlich Jetbrains-Tools).

Dann haben wir die Funktion importiert, die tatsächlich ausgeführt wird.
Implementierung der von Shell nach JavaScript konvertierten Funktion:

#!/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 ist erforderlich'); }); if (['staging', 'dev'].includes(currentEnv)) { zurückkehren; } let notPristine = 0; let ModifiedFiles = ''; // Auf bereitgestellte, aber nicht festgeschriebene Änderungen prüfen const stagedChanges = waiting $`git diff --name-only --cached`.text(); if (stagedChanges !== '') { notPristine = 1; ModifiedFiles = `Inszenierte Änderungen:\n${stagedChanges}`; } // Auf nicht bereitgestellte Änderungen prüfen const unstagedChanges = waiting $`git diff --name-only`.text(); if (unstagedChanges !== '') { notPristine = 1; ModifiedFiles = `Nicht bereitgestellte Änderungen:\n${unstagedChanges}`; } // Auf nicht verfolgte Dateien prüfen const untrackedFiles = waiting $`git ls-files --others --exclude-standard`.text(); if (untrackedFiles !== '') { notPristine = 1; ModifiedFiles = `Nicht verfolgte Dateien:\n${untrackedFiles}`; } // Überprüfen Sie, ob der aktuelle Zweig vor dem entfernten Zweig liegt const aheadCommits = waiting $`git log @{u}.. --oneline`.text(); if (aheadCommits !== '') { notPristine = 1; ModifiedFiles = `Commits vor dem Remote:\n${aheadCommits}`; } if (notPristine) { console.warn('Fehler: Sie können Änderungen nur in Produktionsumgebungen anwenden, wenn sich das Repository in einem makellosen Zustand befindet.'); console.warn(modifiedFiles); prozess.exit(1); } };

---

Auf diese Weise haben wir standardisierten JavaScript-Code, der wie ein Shell-Skript ausgeführt wird.

Es gibt Aufrufe von Funktionen (exitOnError, notEmpty), die im bereitgestellten Beispiel nicht implementiert sind.