Cuando trabajamos en un proyecto centrado en la automatización de procesos e infraestructura en zCloud, frecuentemente nos encontramos con la necesidad de crear múltiples funciones para realizar validaciones y procesos comunes. Todo funciona bien cuando se utiliza un solo sistema operativo, pero la situación se complica cuando se trata de más de un sistema.

En nuestro caso, la mayor parte del desarrollo se realiza en Linux, pero también debemos garantizar la compatibilidad con macOS. Esto a menudo resulta en incompatibilidades de código.

Para solucionar este problema, estamos migrando nuestras funciones de script de shell a archivos JavaScript, utilizando Bun como intérprete. Elegimos Bun porque proporciona una forma sencilla de ejecutar comandos como un shell a través de su funcionalidad Shell API.

A continuación se muestra un ejemplo de una función que utilizamos para comprobar si hay cambios en el código antes de aplicar modificaciones en la infraestructura.

Código de script de 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
}

||

; entonces regresar 0 fi local not_pristine=0 archivos_modificados locales="" # Compruebe si hay cambios preparados pero no confirmados staged_changes=$(git diff --solo nombre --cached) if [ -n "$cambios_por etapas" ]; entonces not_pristine=1 modificado_files ="Cambios por etapas:\n$staged_changes" fi # Comprobar cambios no realizados unstaged_changes=$(git diff --solo nombre) if [ -n "$cambios_unstaged" ]; entonces not_pristine=1 modificad_files ="Cambios no preparados:\n$unstaged_changes" fi # Buscar archivos sin seguimiento untracked_files=$(git ls-files --otros --exclude-standard) if [ -n "$archivos_sin seguimiento" ]; entonces not_pristine=1 modificó_files ="Archivos sin seguimiento:\n$archivos_sin seguimiento" fi # Comprobar si la rama actual está por delante de la remota forward_commits=$(git log @{u}.. --oneline) si [ -n "$ahead_commits" ]; entonces not_pristine=1 modificado_files ="Se confirma antes que el control remoto:\n$ahead_commits\n\n" fi si [ $not_pristine -eq 1 ]; entonces echo -e "$archivos_modificados" regresar 1 fi regresar 0 }

Para convertir este código a JavaScript, creamos un archivo llamado zc_check_pristine_git en el directorio bin del proyecto (que ya está en la RUTA) con el siguiente contenido:

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

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

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

#!/usr/bin/env bollo // @idioma JavaScript importar {checkPristineGit} desde '../js/helpers/helpers.js'; espere checkPristineGit({ currentEnv: process.env.ZC_CURRENT_ENV });

Usamos el shebang #!/usr/bin/env bun para indicar que estamos usando Bun como intérprete.

Agregamos el comentario // @language JavaScript para que el IDE reconozca el archivo como JavaScript (utilizamos principalmente herramientas Jetbrains).

Luego, importamos la función que realmente se ejecutará.
Implementación de la función convertida de shell a JavaScript:

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

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

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

exportar const checkPristineGit = async ({ currentEnv }) => { salidaOnError(() => { notEmpty(currentEnv, 'se requiere currentEnv'); }); if (['puesta en escena', 'dev'].includes(currentEnv)) { devolver; } no sea Pristine = 0; dejar archivos modificados = ''; // Comprobar cambios preparados pero no confirmados const stagedChanges = await $`git diff --name-only --cached`.text(); if (cambios por etapas! == '') { noPrístina = 1; modificóFiles = `Cambios por etapas:\n${stagedChanges}`; } // Comprobar cambios no preparados const unstagedChanges = await $`git diff --name-only`.text(); if (cambios sin etapas! == '') { noPrístina = 1; modificóFiles = `Cambios no preparados:\n${unstagedChanges}`; } //Buscar archivos sin seguimiento const untrackedFiles = await $`git ls-files --others --exclude-standard`.text(); if (archivos sin seguimiento! == '') { noPrístina = 1; modificóFiles = `Archivos sin seguimiento:\n${untrackedFiles}`; } // Comprobar si la rama actual está por delante de la remota const forwardCommits = await $`git log @{u}.. --oneline`.text(); si (aheadCommits! == '') { noPrístina = 1; modificóFiles = `Se confirma antes del control remoto:\n${aheadCommits}`; } si (no prístino) { console.warn('Error: solo puede aplicar cambios en entornos de producción si el repositorio está en un estado impecable.'); console.warn(archivos modificados); proceso.salir(1); } };

---

De esta manera, hemos estandarizado el código JavaScript que se ejecutará como un script de shell.

Hay llamadas a funciones (exitOnError, notEmpty) que no están implementadas en el ejemplo proporcionado.