DEV Community

Heiker
Heiker

Posted on • Edited on • Originally published at vonheikemen.github.io

Extendiendo deno cli usando una función

#deno #shell #spanish

Estos días he estado usando deno con más frecuencia y debo decirles que aún hay un par de cosas que me molestan. Sí logré resolver algunos de esos problemas "agregando" algunos sub-comandos. No, no es magia negra, sólo un pequeño truco que aprendí hace tiempo y hoy voy a decirles cómo funciona.

¿Qué necesitamos?

En teoría cualquier intérprete que nos permita crear funciones debería ser suficiente. En este artículo les estaré mostrando los ejemplos usando una sintaxis compatibles con intérpretes que obedecen el estándar POSIX (piensen en "shells" como zsh, bash, ash, etc...).

¿Qué queremos lograr?

Personalmente a mí me encantaría que deno tuviera algún equivalente nativo a los npm scripts, pero parece que no tendremos nada de eso aún. Quisiera poder hacer algo así.

deno start hello world
Enter fullscreen mode Exit fullscreen mode

También me gustaría poder inicializar esos scripts, porque deben existir en algún lado.

deno init
Enter fullscreen mode Exit fullscreen mode

Como ya deben saber los sub-comandos start e init no existen y vamos a arreglar eso (casi).

Empecemos

El primer paso sería ubicar el archivo que su intérprete favorito ejecuta cada vez que lo invocan. En zsh por ejemplo, pueden usar ~/.zshrc. En bash pueden usar ~/.bashrc. Esos dos son los únicos que conozco, si usan otro intérprete busquen en su documentación algún equivalente.

La Definición

¿Están listos? Ahora deben crear una función en ese archivo.

deno()
{
  echo "Hola"
}
Enter fullscreen mode Exit fullscreen mode

Ahora si reinician el intérprete (o "recargan" su configuración) e invocan el comando deno deberían obtener Hola como resultado. Genial, hemos creado un problema, no podemos usar el comando deno. No teman, vamos por buen camino.

Vuelve a mi, deno

Si quisieramos invocar el comando deno lo único que tenemos que hacer es usar el comando command así:

command deno --version
Enter fullscreen mode Exit fullscreen mode

Eso debería mostrarle la información de deno.

deno x.x.x (release, x86_64-unknown-linux-gnu)
v8 x
typescript x.x
Enter fullscreen mode Exit fullscreen mode

Con este nuevo conocimiento podemos resolver nuestro problema. Vamos a hacer una prueba.

deno()
{
  echo "Estás usando"
  command deno --version
}
Enter fullscreen mode Exit fullscreen mode

Y esto es lo que debería ocurrir al invocarlo.

$ deno

Estás usando
deno x.x.x (release, x86_64-unknown-linux-gnu)
v8 x
typescript x.x
Enter fullscreen mode Exit fullscreen mode

Volviendo a la normalidad

Ahora que sabemos cómo llamar a deno lo que deberíamos hacer ahora es imitar el comportamiento de deno en nuestra función. Debemos hacer esto de una manera que nos deje espacio para agregar nuestros propios comandos, para esto vamos a usar la declaración case.

deno()
{
  local cmd=$1; shift;

  case "$cmd" in
    *)
      command deno $cmd $@
    ;;
  esac
}
Enter fullscreen mode Exit fullscreen mode

La primera línea lo que hace es asignar el primer parámetro ($1) a la variable cmd y luego lo elimina de la lista de argumentos ($@). Después lo que hacemos es comparar cmd con un patrón. Por ahora el único patrón que tenemos es *, que actúa como un comodín que coincide con todo, básicamente es nuestro default. Probemos.

deno --version
Enter fullscreen mode Exit fullscreen mode

Bien, pero ahora si intentamos usar deno sin argumentos nos dará un error. Para arreglar eso vamos verificar si el primer parámetro está vacío, si ese es el caso sólo llamamos deno.

deno()
{
  if [ -z "$1" ];then
    command deno
    return
  fi

  local cmd=$1; shift;

  case "$cmd" in
    *)
      command deno $cmd $@
    ;;
  esac
}
Enter fullscreen mode Exit fullscreen mode

Invocando sub-comandos

Ya estamos en el lugar que queremos, finalmente podremos agregar nuestros propios sub-comandos. Veamos cómo funcionaría.

  deno()
  {
    if [ -z "$1" ];then
      command deno
      return
    fi

    local cmd=$1; shift;

    case "$cmd" in
+     hola)
+       command deno eval "console.log('deno dice hola')"
+     ;;
      *)
        command deno $cmd $@
      ;;
    esac
  }
Enter fullscreen mode Exit fullscreen mode

Si invocamos el comando hola:

$ deno hola

deno dice hola
Enter fullscreen mode Exit fullscreen mode

Ahora estamos seguros que funciona.

deno scripts

Ya podemos comenzar con lo más importante, nuestro reemplazo para los npm scripts. Lo que quiero hacer primero es crear el comando start, el cual es el más común que usaría.

  deno()
  {
    if [ -z "$1" ];then
      command deno
      return
    fi

    local cmd=$1; shift;

    case "$cmd" in
+     start)
+       command deno run --allow-run ./Taskfile.js start $@
+     ;;
      *)
        command deno $cmd $@
      ;;
    esac
  }
Enter fullscreen mode Exit fullscreen mode

Esto lo que hará será ejecutar un archivo llamado Taskfile.js usando deno. --allow-run nos permitirá usar Deno.run en nuestro código para poder llamar comandos externos dentro de Taskfile.js. Ahora vamos a usarlo.

Creamos Taskfile.js.

const cmd = ['echo', 'Taskfile: ', ...Deno.args];
Deno.run({ cmd });
Enter fullscreen mode Exit fullscreen mode

Y llamamos start de esta manera.

$ deno start hola

Taskfile start hola
Enter fullscreen mode Exit fullscreen mode

Genial. El siguiente paso sería crear un Taskfile.js "más inteligente," que sea capaz de ejecutar varias tareas. Ya he hecho algo así en el pasado (pueden encontrar los detalles aquí), así que les mostraré el código que yo usaría.

const entrypoint = "./src/main.js";

run(Deno.args, {
  start(...args) {
    exec(["deno", "run", entrypoint, ...args]);
  },
  list() {
    console.log('Available tasks: ');
    Object.keys(this).forEach((k) => console.log(`* ${k}`));
  },
});

function run([name, ...args], tasks) {
  if(tasks[name]) {
    tasks[name](...args);
  } else {
    console.log(`Task "${name}" not found\n`);
    tasks.list();
  }
}

async function exec(args) {
  const proc = await Deno.run({ cmd: args }).status();

  if (proc.success == false) {
    Deno.exit(proc.code);
  }

  return proc;
}
Enter fullscreen mode Exit fullscreen mode

Con esto podríamos ejecutar el archivo ./src/main.js al invocar deno start. Ahora tenemos otro problema, no queremos escribir todo eso cada vez que queremos iniciar un proyecto. Lo que haremos será crear un comando init que copie esta plantilla en la carpeta de nuestro proyecto.

  deno()
  {
    if [ -z "$1" ];then
      command deno
      return
    fi

    local cmd=$1; shift;

    case "$cmd" in
      start)
        command deno run --allow-run ./Taskfile.js start $@
      ;;
+     init)
+       cp /path/to/template/Taskfile.js ./
+       echo "Taskfile.js created"
+     ;;
      *)
        command deno $cmd $@
      ;;
    esac
  }
Enter fullscreen mode Exit fullscreen mode

Ya tiene buena forma. La última cosa que nos quedaría por hacer es manejar otras tareas además de start. Con npm podemos invocar npm run para elegir qué script queremos ejecutar, nuestro equivalente se llamará x.

  deno()
  {
    if [ -z "$1" ];then
      command deno
      return
    fi

    local cmd=$1; shift;

    case "$cmd" in
+     x)
+       command deno run --allow-run ./Taskfile.js $@
+     ;;
      start)
        command deno run --allow-run ./Taskfile.js start $@
      ;;
      init)
        cp /path/to/template/Taskfile.js ./
        echo "Taskfile.js created"
      ;;
      *)
        command deno $cmd $@
      ;;
    esac
  }
Enter fullscreen mode Exit fullscreen mode

Ahora podríamos tener una "tarea" llamada test:api y llamarla de esta manera.

deno x test:api
Enter fullscreen mode Exit fullscreen mode

Un poco más de conveniencia

Lo último que quiero hacer es crear una forma de ejecutar un script el cual pueda llamar las librerías que uso con más frecuencia sin usar su URL. Podemos hacer esto con el apoyo de un import-map, un archivo .json en el cual podemos vincular un "alias" a una URL.

Yo uso uno como este.

{
  "imports": {
    "@std/": "https://deno.land/std@0.93.0/",
    "@npm/": "https://jspm.dev/",

    "ansi-colors": "https://jspm.dev/ansi-colors@4.1.1",
    "arg": "https://jspm.dev/arg@5.0.0",
    "cheerio": "https://jspm.dev/cheerio@1.0.0-rc.5",
    "exec": "https://deno.land/x/exec@0.0.5/mod.ts",
    "ramda": "https://jspm.dev/ramda@0.27.1",

    "@utils/": "/path/to/deno/utils/"
  }
}
Enter fullscreen mode Exit fullscreen mode

deno puede leerlo si le pasamos el argumento --import-map. Ahora vamos a crear un comando para usarlo.

  deno()
  {
    if [ -z "$1" ];then
      command deno
      return
    fi

    local cmd=$1; shift;

    case "$cmd" in
      x)
        command deno run --allow-run ./Taskfile.js $@
      ;;
      start)
        command deno run --allow-run ./Taskfile.js start $@
      ;;
      init)
        cp /path/to/template/Taskfile.js ./
        echo "Taskfile.js created"
      ;;
+     s|script)
+       command deno run --import-map="/path/to/deno/import-map.json" $@
+     ;;
      *)
        command deno $cmd $@
      ;;
    esac
  }
Enter fullscreen mode Exit fullscreen mode

Como ya es costumbre, tenemos que probar esto. Vamos a crear un script de prueba con este contenido.

import dayjs from '@npm/dayjs';
import c from 'ansi-colors';

c.enabled = !Deno.noColor;

const date = dayjs().format('{YYYY} MM-DDTHH:mm:ss SSS [Z] A');

console.log(c.green(date));
Enter fullscreen mode Exit fullscreen mode

Tal vez quieran especificar la versión de la librería que están usando con @npm, en ese caso harían esto @npm/dayjs@1.10.4

Lo ejecutamos.

$ deno script ./test.js

Download https://jspm.dev/dayjs@1.10.4
Download https://jspm.dev/npm:dayjs@1.10.4!cjs
{2021} 04-18T11:28:05 929 Z AM
Enter fullscreen mode Exit fullscreen mode

¡Jaja! Ahora tengo todo lo que quiero.

El resultado final

Después de todo este proceso la función deno debería quedar así.

deno()
{
  if [ -z "$1" ];then
    command deno
    return
  fi

  local cmd=$1; shift

  case "$cmd" in
    x)
      command deno run --allow-run ./Taskfile.js $@
    ;;
    start)
      command deno run --allow-run ./Taskfile.js start $@
    ;;
    init)
      cp /path/to/template/Taskfile.js ./
      echo "Taskfile.js created"
    ;;
    s|script)
      command deno run --import-map="/path/to/deno/import-map.json" $@
    ;;
    *)
      command deno $cmd $@
    ;;
  esac
}
Enter fullscreen mode Exit fullscreen mode

Conclusión

Entonces, ¿qué hicimos hoy? "Escondimos" el comando deno detrás de una función para poder agregar "sub-comandos" creados por nosotros. Logramos crear una especie de equivalente de npm run para deno y finalmente usamos import maps para simplificar la declaración de dependencias en un script. No está mal para un día de trabajo.

Gracias por su tiempo. Si este artículo les pareció útil y quieren apoyar mis esfuerzos para crear más contenido pueden dejar una propina en ko-fi.com/vonheikemen.

buy me a coffee

Top comments (0)

Read next

keploy profile image

Test Data Management: A Comprehensive Guide

keploy -

abhinowww profile image

Mistral vs GPT: A Comprehensive Comparison of Leading AI Models

Abhinav Anand -

keval_badarakhiya profile image

A Guide to Creating Custom Field Inputs in Strapi (version 5)

Keval Badarakhiya -

insidewhy profile image

Suggested Jira setup for software engineering projects

insidewhy -