Video Summary and Transcription
Esta charla explora los enlaces de TypeScript para NodeJS con Rust y WebAssembly, proporcionando un enfoque alternativo para crear módulos nativos de NodeJS y generar automáticamente tipos. Se adentra en el uso de WebAssembly y Rust para módulos de TypeScript, mostrando cómo se pueden definir e importar funciones Rust utilizando la biblioteca wasm.bindgen. La charla también destaca los desafíos de la conversión de cadenas entre Rust y JavaScript, las limitaciones de soporte de los tipos de datos Rust en JavaScript y la integración perfecta de las funciones Rust en aplicaciones TypeScript utilizando tspy. Concluye con la recomendación de TSFI para enlaces seguros y muestra su uso en un motor de búsqueda de texto completo basado en TypeScript con soporte de WebAssembly.
1. Introducción
Esto es TypeScript Bindings para NodeJS con Rust y WebAssembly. Buscaremos un enfoque alternativo y más fácil para crear módulos nativos de NodeJS, al mismo tiempo que generamos automáticamente los tipos para ellos.
Hola a todos, y gracias a Node Congress por tenerme aquí. Esto es TypeScript Bindings para NodeJS con Rust y WebAssembly. Buscaremos un enfoque alternativo y más fácil para crear módulos nativos de NodeJS, al mismo tiempo que generamos automáticamente los tipos para ellos.
Un poco sobre mí. Soy Alberto Schibel. Soy de Venecia, Italia. Soy un ingeniero de software en Prisma donde he portado varios módulos de Rust a WebAssembly. También soy consultor y trabajo con NodeJS, TypeScript y Rust. Puedes encontrarme en línea en j.com.io. También puedes encontrar las diapositivas
2. WebAssembly y Rust para Módulos de TypeScript
WebAssembly, o WASM, es una abstracción de bajo nivel para la CPU en la que se ejecuta tu código. Es un bytecode rápido y compacto diseñado para lograr una velocidad cercana a la nativa y optimizado para un inicio rápido y una huella de memoria pequeña. Es un objetivo de compilación portátil para muchos lenguajes, incluido Rust. Rust es consistentemente votado como el mejor lenguaje para WebAssembly. Veamos cómo podemos crear módulos de TypeScript a partir de él.
para esta charla en mi página de GitHub. Entonces, el elefante en la habitación, ¿qué es WebAssembly y cómo es útil? Bueno, WebAssembly, o WASM, es básicamente una abstracción de bajo nivel para la CPU en la que se ejecuta tu código. Es un bytecode rápido y compacto en el sentido de que es un formato binario portátil para una máquina virtual que modela las operaciones de carga y almacenamiento de números en la memoria lineal. Está diseñado para lograr una velocidad cercana a la nativa y también está optimizado para un inicio rápido y una huella de memoria pequeña. Fue creado por los proveedores de navegadores para portar código C++ a la web sin degradación del rendimiento y ahora es un objetivo de compilación portátil para muchos lenguajes, incluidos Rust, Go y muchos otros. Eso significa que puedes compilar tu código a WASM una vez y luego ejecutar el mismo artefacto compilado en diferentes plataformas. Por ejemplo, Node.js admite WebAssembly desde la versión 8 y ahora puedes importar un módulo WASM exactamente como importarías un paquete estándar de npm. Y ¿por qué es útil un único objetivo de compilación portátil? Considera Node.js, un popular complemento NAPI que compila estilos SAS a CSS. Para admitir múltiples configuraciones del sistema, arquitecturas e incluso versiones de Node.js, esta biblioteca debe compilarse por separado para cada una de estas configuraciones. Esto significa 35 objetivos de compilación diferentes y hace que cada nueva implementación sea una tarea que consume tiempo y recursos. Aquellos de ustedes que usan Prisma probablemente sepan que estamos en una situación similar con el CLI de TypeScript y una biblioteca que descarga algunos binarios compilados de Rust bajo demanda. Esto es lo que nos hizo considerar WebAssembly y adoptarlo tanto como para simplificar nuestro proceso de implementación. Y si alguna vez has intentado escribir complementos nativos de Node.js, probablemente sepas que no es un proceso sencillo. A veces, no jib falla con mensajes de error crípticos y, francamente, las herramientas necesarias para construir e importar módulos de C++ no son tan amigables para los humanos como lo que los desarrolladores de Node.js están acostumbrados a utilizar. Entonces, esta es quizás una de las principales razones por las que Rust es consistentemente votado como el mejor lenguaje para WebAssembly. Entonces, veamos cómo podemos crear los módulos de TypeScript a partir de él. Y para aquellos de ustedes que son nuevos en Rust, definamos algunos conceptos básicos, ¿de acuerdo? Entonces, cualquier cosa que uses un paquete de json para, lo colocarías en un archivo cargo.toml en un proyecto de Rust. Lo que normalmente llamas paquetes de npm son cajas en Rust y operas con ellas a través del comando cargo CLI. Por ejemplo, para compilar código Rust, usarías el comando cargo build y especificarías el objetivo de compilación. En nuestro caso, es Wasm 32 desconocido, desconocido. Utiliza un espacio de direccionamiento de 32 bits y no está vinculado a ningún proveedor de sistema operativo o arquitectura de CPU en particular. Si queremos mover más que solo datos numéricos a través del puente de WebAssembly, necesitaremos una herramienta de enlace. Es tanto un CLI como una biblioteca de Rust. Cuando lo instalas, debes especificar una versión particular, porque aún no sigue la versión semántica. Esto significa que la versión que especificas en tu archivo cargo.toml debe coincidir con la versión de Wasm que tienes instalada en tu máquina. Además, para admitir WebAssembly, debes marcar tu tipo de caja como c.lib. Esto le indicará a Rust que compile tu código como una biblioteca dinámica que puede ser cargada por un runtime compatible con C, como Node.js. Entonces, compilar Rust a WebAssembly es un proceso de dos pasos. Primero, debes ejecutar cargo.build para crear un artefacto de WebAssembly compilado, que tendrá la extensión .wasm, y luego agregarás wasm.bindgen para generar los enlaces de Node.js y TypeScript que utilizarás para importar el módulo wasm compilado. Por supuesto, si wasm.bindgen admitiera todas las estructuras de datos comúnmente utilizadas de Rust y las convenciones de TypeScript, esta charla ya habría terminado, y claramente ese no es el caso. Entonces veamos cómo podemos solucionar esto.
3. Funciones de Rust y WebAssembly
Definamos funciones de Rust que tomen un número, lo dupliquen y lo devuelvan. La sintaxis de Rust puede ser abrumadora, pero podemos importar la biblioteca wasm.bindgen y generar enlaces para las funciones. Tenemos funciones para enteros de 64 bits y números de punto flotante. La declaración de TypeScript generada conserva los nombres de las funciones y asigna los tipos de números correspondientes.
Entonces, para nuestro primer ejemplo, veamos cómo podemos definir funciones de Rust que tomen un número, lo dupliquen y lo devuelvan al llamador. Sé que la sintaxis de Rust puede ser abrumadora, así que ten paciencia. Primero importamos la biblioteca wasm.bindgen. Luego le decimos a Rust que genere enlaces para la función que sigue, que se compilará a WebAssembly. Y cada vez que veas un código con un hashtag y un corchete cuadrado, eso significa que es una macro de Rust, un tipo especial de función que se expande para generar código en tiempo de compilación. Definimos una función pública, duplicate underscore U64, que toma un entero de 64 bits asignado, lo multiplica por dos y lo devuelve. La otra función es similar, pero utiliza números de punto flotante en su lugar. Y wasm.bindgen genera la siguiente declaración de TypeScript que ves en la parte inferior. Vemos que los nombres de las funciones se conservan tal cual. Los números U64 se asignan a BigInt y los números F32 son simplemente números en TypeScript porque realmente no tienen un tipo dedicado.
4. Funciones de Conversión de Cadenas
Aquí tienes un ejemplo con cadenas. Tenemos una función que convierte una cadena a mayúsculas y otra función que convierte un entero de 64 bits con signo en una representación de cadena. Es importante tener en cuenta las diferencias de codificación entre Rust y JavaScript para las cadenas.
tipo de punto flotante. Aquí tienes un ejemplo similar con cadenas. A la izquierda, tenemos una función de dos mayúsculas que toma una cadena y devuelve una nueva cadena en mayúsculas. Observa que en este caso, especificamos un nombre personalizado para la función de los enlaces de JS y usamos la macro WasBinds para eso. A la derecha, tenemos una función NtlString que toma un entero de 64 bits con signo y devuelve una representación de cadena de este. Ten en cuenta que las cadenas en Rust están codificadas en UTF8. Sin embargo, en JavaScript, están codificadas en UTF16. Y esto es algo de lo que debes ser consciente, especialmente si estás manipulando cadenas que pueden contener emojis o caracteres no latinos.
5. Using Functions in TypeScript
¿Qué sucede cuando intentamos usar estas funciones en TypeScript? Si pasamos tipos compatibles, funcionan como se espera. Pero si evitamos las validaciones de TypeScript y pasamos tipos incompatibles, obtendremos errores en tiempo de ejecución. Las estructuras de datos complejas como las estructuras tienen un comportamiento inesperado al generar enlaces de TypeScript. El código generado filtra detalles internos y carece de un constructor. Envolver cadenas en una estructura causa errores de compilación. Las enumeraciones funcionan uno a uno con las enumeraciones de TypeScript, pero pueden ser problemáticas. Las uniones discriminadas, o uniones objetivo, no son compatibles con WasBindgen.
¿Qué sucede cuando intentamos usar estas funciones en TypeScript? Bueno, si pasamos tipos compatibles con las declaraciones de TypeScript, funcionan como se espera en tiempo de ejecución. Pero si escapamos de las validaciones de TypeScript disfrazando una cadena como un número entero grande y llamamos a la función 'n to string' con eso, bueno, en ese caso obtendremos un error de sintaxis en tiempo de ejecución porque la función espera un número pero se está llamando con una cadena.
¿Qué sucede si necesitamos estructuras de datos más complejas? Aquí tienes un ejemplo con nuestra estructura 'scholars' que envuelve valores como números, caracteres o booleanos. Digamos que queremos una función que extraiga el valor de uno de los campos, a saber, la letra. Si tuviéramos que escribir manualmente los enlaces de TypeScript para esto, definiríamos escalares como un diccionario tipado que llamamos 'construct' en su lugar y escribiríamos el campo 'letter' como una cadena porque TypeScript realmente no distingue entre cadenas de un solo carácter y cadenas de varios caracteres. Sin embargo, esto no es lo que hace WasBindgen y esto es lo que obtiene, lo que crea y aunque los cuatro miembros de la estructura tienen los tipos que esperamos, en realidad obtenemos una definición de clase escalar, no un tipo de diccionario. Además, vemos algunos detalles internos que se filtran en el código generado y eso es principalmente el método 'free' que no toma ningún argumento y no devuelve ningún valor. Esto no es algo que hayamos escrito en nuestro tipo Rust. Esto es algo que hace WasBindgen. ¿También te das cuenta de que falta algo más? Bueno, esta clase no tiene un constructor, ¿cómo creamos instancias de ella desde Node.js? Bueno, podemos intentar llamar al constructor JS predeterminado y asignar los campos manualmente. También necesitamos especificar una implementación predeterminada para este método 'free'. Sin embargo, si hacemos esto y pasamos una instancia de la clase Scalar a la función 'get letter', bueno, esto fallará en tiempo de ejecución con un error críptico: 'NullPointerPassToRust'. Resulta que podemos solucionar esto definiendo manualmente un constructor en Rust que tome los cuatro miembros de la estructura como argumentos utilizando la macro constructor y llamando al constructor desde TypeScript. Está claro que esta no es la mejor experiencia que podemos obtener, ¿verdad? Requiere código de plantilla y no es ergonómico para los desarrolladores de TypeScript. Por cierto, observa que el campo 'letter' se trunca automáticamente a una cadena de un solo carácter, aunque lo inicialicemos con una cadena más larga. Y ¿qué sucede si envolvemos cadenas en una estructura, de manera similar a como lo hicimos con los estudiosos? Este código no se compilará. Eso se debe a que las cadenas en Rust no se pueden copiar y WasBindgen necesitará copiar cadenas. Y una forma de solucionar el problema es hacer que WasBindgen clone la cadena con un atributo de macro dedicado, 'getter with clone', pero esto no es algo de lo que un desarrollador de TypeScript deba preocuparse. Es un detalle interno del que no necesitamos ser conscientes. Aún así, obtenemos un enlace de clase en lugar de un tipo de diccionario y hemos visto lo engorroso y torpe que es de usar. ¿Qué hay de las enumeraciones? Mientras que las enumeraciones de estilo C se traducen uno a uno a enumeraciones de TypeScript, por lo que podemos ver que WasBindgen funciona sin problemas en este caso. Sin embargo, las enumeraciones a menudo se consideran una mala práctica en la comunidad de TypeScript, ya que son un poco difíciles de razonar debido a que el tiempo de ejecución de JavaScript no tiene noción de enumeraciones, ¿verdad? Por lo tanto, eso podría llevar a errores inesperados. Idealmente, preferiríamos obtener una unión de tipos literales, como la que vemos en la parte superior derecha. ¿Qué hay de las uniones discriminadas, o uniones objetivo? Son un patrón popular en TypeScript, especialmente cuando se codifican tipos de datos algebraicos. Y resulta que Rust las admite en forma de variantes de enumeración. En este ejemplo, tenemos el tipo 'Either' que en un momento dado codifica un resultado numérico exitoso, con un constructor 'Ok', o un mensaje de error, con un constructor 'Error'. Sin embargo, las variantes de enumeración no son compatibles con WasBindgen, como nos indica el mensaje de error del compilador, por lo que no podemos usarlas tal como están.
6. Supporting Rust Data Types in JavaScript
WasBindgen proporciona soporte parcial para vectores, pero solo para tipos numéricos. Es limitado y no es ideal para los desarrolladores de TypeScript. Serde es una biblioteca no estándar que proporciona utilidades de serialización y deserialización para Rust. Nos permite trabajar con más tipos de datos de Rust en JavaScript al exponer funciones que consumen y devuelven cadenas codificadas en JSON. La SerDeWasmBindingCrate ofrece un enfoque más eficiente con integración binaria nativa, admitiendo variantes de enumeración, generando vectores y mapas. Sin embargo, el uso de argumentos de valor js en funciones de Rust sacrifica la seguridad de tipos.
Finalmente, WasBindgen proporciona soporte parcial para vectores homogéneos, pero solo para tipos numéricos, que se traducen a instancias de matrices tipadas. Y son esencialmente útiles solo cuando se manipulan datos binarios en bruto. Están bastante lejos de las matrices de propósito general estándar que normalmente deseamos. Además, los vectores de tipos no primitivos, vectores anidados o tuplas no son compatibles en absoluto. Entonces, WasBindgen proporciona las herramientas básicas para portar bibliotecas de Rust a Node.js. Pero no es ergonómico ni ideal para los desarrolladores de TypeScript y en general es bastante limitado. ¿Podemos hacerlo mejor que esto?
Bueno, la primera biblioteca no estándar que todo desarrollador de Rust suele encontrar es Serde, que proporciona macros y utilidades para serializar y deserializar tipos comunes de Rust en varios formatos con un mínimo de código repetitivo. Un primer paso para admitir más tipos de datos de Rust en JavaScript es exponer funciones que consuman y devuelvan cadenas codificadas en JSON, que luego podemos analizar y convertir en cadenas en Rust a través de los rasgos de serialización y deserialización de Serde. También he enumerado las dependencias que necesitamos agregar a nuestro archivo cargo.toml y nuestras versiones para la conveniencia de todos. Así es como funcionaría. Primero importamos Serde, luego lo aplicamos a una estructura o enumeración de Rust para que se vuelva automáticamente serializable y deserializable. Piensa en esos rasgos como interfaces necesarias para traducir estructuras de datos a formatos como JSON, y piensa en la macro derive como algo que implementa esos rasgos por nosotros. Luego definimos una función pública de cadena a cadena con la macro WasmBindgen que ya hemos usado. Luego analizamos la cadena de entrada que asumimos que está codificada en JSON en la estructura de estudiosos que definimos anteriormente. Calculamos el resultado y lo serializamos de nuevo a JSON. Y luego lo devolvemos al llamador. Observa que el enlace de TypeScript está técnicamente tipificado, pero no es muy útil, ya que podríamos pasar cualquier JSON o incluso una cadena que no sea JSON en absoluto y TypeScript aún lo aceptará en tiempo de compilación, aunque resultará en un error en tiempo de ejecución. La serialización JSON puede ser costosa en la práctica, por lo que SerDeWasmBindingCrate propuso un enfoque más eficiente que proporciona una integración binaria nativa de SerDe con WasmBinding. Por cierto, el proyecto es mantenido actualmente por CloudFlare y nuevamente, dado que se basa en Serde, obtenemos soporte para muchos otros tipos que podemos usar en JavaScript. Las diferencias notables con el enfoque básico de WasmBinding son que las variantes de enumeración se pueden traducir a uniones etiquetadas. Obtenemos soporte para generar vectores y también soporte para mapas.
De manera similar al ejemplo anterior, podemos definir una estructura escalar. En realidad, esto es un subconjunto del ejemplo. Podemos exponer una función pública que tome el valor escalar como entrada y devuelva su campo de letra a WasmBinding. Sin embargo, observa que esta vez los argumentos de Rust están tipificados como valor js, que modela cualquier valor que se pueda pasar o recibir de JavaScript. Luego depende de nosotros convertir estos valores js en tipos reales. Y lo haremos usando la utilidad Std WasmBinds from value y luego podemos convertir este resultado nuevamente en un valor js. Y sin entrar en demasiados detalles, vemos que la firma de la función nos dice que el resultado es un valor js o un tipo de error específico proporcionado por Std WasmBinds. Específicamente, es un WasmError. Sin embargo, si usamos este enfoque, perdemos por completo la seguridad de tipos, ya que el valor js puede
7. Integración perfecta con tspy
Descubrimos tspy, una herramienta mágica que genera enlaces seguros y ergonómicos para integrar sin problemas funciones de Rust en aplicaciones de TypeScript con WebAssembly. Elimina la necesidad de conversiones manuales y proporciona enlaces fuertes de tipos tardíos. Demostraremos su uso con variantes de Enum y el proceso de serialización. WebAssembly es ideal para tareas intensivas de CPU y lógica compleja, pero carece de soporte de entrada-salida. TSFI es la mejor solución para enlaces seguros de tipos, aunque depende en gran medida de la magia de macros. Los contenedores genéricos como vectores y mapas hash requieren especificar el tipo genérico y envolverlos en una estructura o variante de Enum. Echa un vistazo al ejemplo de uso de TSFI en Lira, un motor de búsqueda de texto completo basado en TypeScript con soporte de WebAssembly.
literalmente ser cualquier valor. Por lo tanto, está tipado como 'any' en TypeScript y no es realmente útil. Así que comenzamos este viaje en un esfuerzo por integrar sin problemas funciones de Rust para estructuras de datos en aplicaciones de TypeScript con WebAssembly. Y parece que deberíamos rendirnos. A menos que tal vez haya una herramienta mágica que pueda ayudarnos generando enlaces seguros de tipos y ergonómicos. Bueno, afortunadamente esa herramienta existe. Se llama tspy y, sinceramente, me encanta. Admite todo lo que hemos visto hasta ahora, pero no necesita ninguna conversión manual y viene con enlaces fuertes de tipos tardíos. Veremos en un segundo que vamos a necesitar un poco más de macros para que las cosas funcionen. Pero aún así, es una gran mejora respecto a los enfoques anteriores. También debemos tener en cuenta que necesitamos instalar tspy con la marca de función JS, lo que nos dará una integración nativa de JavaScript. De lo contrario, utilizará la serialización JSON de forma predeterminada.
Como demostración, adaptaremos el ejemplo anterior utilizando variantes de Enum, que queríamos que se tradujeran a uniones objetivo en TypeScript. Entonces, vemos que necesitamos derivar los rasgos de SerDes, así como el nuevo rasgo de tspy. También necesitamos usar una nueva macro de tspy para indicar a Wasp bind que compile algunos tipos de datos, ya sabes, un tipo de datos que de otra manera no sería compatible con Wasp binding. De hecho, Wasp ABI significa Interfaz Binaria de Aplicación WebAssembly y describe cómo llamar a funciones entre lenguajes en WebAssembly. Luego definimos la variante either familiar con un giro que es común a todos los enfoques que usan SerDe. Necesitamos decirle a Rust cómo serializar esto en una variante porque, ya sabes, esto podría suceder de muchas maneras y para obtener uniones de etiquetas idiomáticas como las que vemos a la derecha, tenemos que decirle a Rust que el nombre de la variante debe asociarse con su clave dominante, es decir, la etiqueta de guion bajo, y que el contenido de la variante, que se define entre los paréntesis del constructor, debe asociarse a una propiedad llamada valor. Luego podemos definir una función que, por ejemplo, tome una instancia de either y devuelva su representación en cadena. Observa que realmente no requiere que escribamos ningún código de plantilla de conversión de tipos y se traduce en una definición limpia de TypeScript. Al igual que SerD vs BindGen, podemos definir un valor either en JavaScript sin necesidad de ningún constructor. Simplemente podemos crearlo en el momento como un diccionario. Pero esta vez obtenemos garantías de TypeScript, por lo que podemos aprovechar el compilador de TypeScript para evitar escribir errores tipográficos en nuestros tipos de datos. Así que resumamos lo que hemos aprendido hasta ahora. WebAssembly está aquí para quedarse, y es bueno para tareas intensivas de CPU que de lo contrario serían demasiado lentas en JavaScript puro, o para trasladar lógica compleja ya existente a la web. Piensa en Figma. Sin embargo, actualmente proporciona casi ningún soporte de entrada-salida. Entonces, si necesitas interactuar con el mundo exterior desde tus funciones, es mejor que te quedes con NAPI por el momento. Hemos iterado a través de varios enfoques para portar funciones de Rust a Node.js, y hemos observado que hay limitaciones o una experiencia de desarrollo incómoda, especialmente para aplicaciones de TypeScript. Finalmente, hemos visto que la mejor solución para enlaces seguros de tipos, TSFI, todavía es relativamente nueva. Una advertencia es que su código fuente depende en gran medida de la magia de macros, ¿verdad? Y eso podría ser un obstáculo para alguien. Además, para cualquier conjunto de enfoques, y eso incluye TSFI, no puedes simplemente usar contenedores genéricos como vectores o mapas hash directamente en una función que enlaces a WebAssembly. En realidad, primero debes especificar el tipo genérico. Entonces, tienes que hacer, tienes que decir, un vector de cadenas y luego tienes que envolverlo en una estructura o variante de Enum que luego expones a SerDe a través de los rasgos serializados o deserializados y luego lo usas en tu función. Y si quieres ver un ejemplo de TSFI siendo utilizado en la práctica, puedes revisar una solicitud de extracción en línea que introdujo soporte de WebAssembly a Lira, un motor de búsqueda de texto completo escrito en TypeScript por Mikhail Eriva, que creo que también habló aquí en el Congreso de Node. Mikhail Eriva estaba bastante satisfecho con las mejoras de rendimiento. Y eso es todo por mi parte. Soy Bertos Ghebel, puedes encontrarme en Twitter y GitHub, también puedes encontrar material adicional y ejemplos de código para esta charla en mi repositorio, node-congress-2023. No dudes en hacer preguntas adicionales ahora mismo o más tarde en Twitter, y gracias por tu atención.
Comments