Usando polyfills em ambientes serverless e edge

Em ambientes de serverless e edge computing, garantir a compatibilidade entre navegadores, runtimes e servidores é mais importante do que nunca. Polyfills—pequenos trechos de código que imitam recursos mais recentes da web—permitem a execução de código moderno em diversas plataformas, desde navegadores até edge functions, sem perder funcionalidade.

Neste artigo, exploraremos como os polyfills são essenciais não apenas para a compatibilidade com navegadores, mas também para melhorar o desempenho e tornar o desenvolvimento mais fluido em arquiteturas serverless e edge.

Por que os polyfills são essenciais

À medida que as tecnologias web evoluíram, os desenvolvedores enfrentaram o desafio de aproveitar novos recursos ao mesmo tempo que mantinham a compatibilidade com navegadores mais antigos. Os polyfills surgiram como uma solução inteligente para esse problema. Eles são trechos de código projetados para replicar funcionalidades mais recentes da web em ambientes mais antigos ou menos capazes, garantindo que os desenvolvedores possam utilizar os padrões mais atuais sem comprometer a compatibilidade.

Aqui está um exemplo básico de um polyfill:

if (!Array.prototype.includes) {
  Array.prototype.includes = function (searchElement /*, fromIndex*/) {
    'use strict'
    var O = Object(this)
    var len = parseInt(O.length) || 0
    if (len === 0) {
      return false
    }
    var n = parseInt(arguments[1]) || 0
    var k
    if (n >= 0) {
      k = n
    } else {
      k = len + n
      if (k < 0) {
        k = 0
      }
    }
    var currentElement
    while (k < len) {
      currentElement = O[k]
      if (
        searchElement === currentElement ||
        (searchElement !== searchElement && currentElement !== currentElement)
      ) {
        // NaN !== NaN
        return true
      }
      k++
    }
    return false
  }
}

Este polyfill fornece uma implementação do método Array.prototype.includes, que não está disponível em alguns navegadores mais antigos. Com polyfills, os desenvolvedores podem escrever código utilizando os padrões mais recentes sem se preocupar com problemas de compatibilidade.

Os polyfills começaram como uma forma de fazer código moderno funcionar em navegadores antigos, mas tornaram-se igualmente importantes em ambientes serverless e edge, onde algumas APIs podem estar ausentes. Eles ajudam a garantir que o código seja executado de maneira consistente em diferentes plataformas, sem obrigar os desenvolvedores a reescrever funcionalidades para cada ambiente.

Isso é especialmente relevante ao trabalhar com APIs do Node.js, que não foram projetadas para edge runtimes, mas continuam sendo uma parte essencial de muitas aplicações web. À medida que os desenvolvedores adaptam seu código a essas restrições, os polyfills se tornam uma ferramenta fundamental para fazer bibliotecas dependentes do Node.js funcionarem além do ambiente tradicional de servidores.

Preenchendo lacunas: APIs do Node.js em ambientes de edge

Muitas bibliotecas do Node.js dependem de módulos internos (fs, crypto, http), que não estão disponíveis em navegadores ou edge runtimes. É aqui que os polyfills entram em cena, substituindo APIs específicas do Node por APIs Web equivalentes para manter a funcionalidade em diferentes ambientes.

A transição de bibliotecas baseadas em Node.js para implementações compatíveis com runtimes de workers exige um planejamento cuidadoso. Por exemplo, se uma biblioteca depende do módulo crypto, mas o ambiente de destino não oferece esse suporte, os desenvolvedores podem recorrer a alternativas como a Web API window.crypto para fornecer funcionalidades similares.

if (typeof window === 'undefined') {
  global.window = {}
}
window.crypto = require('crypto')

Este polyfill substitui o módulo crypto do Node pela Web API window.crypto em ambientes onde o Node.js não está disponível.

No desenvolvimento web serverless, os polyfills são ferramentas valiosas que tornam a transição de ambientes tradicionais baseados em servidores para ambientes serverless mais fluida. Eles permitem que os desenvolvedores continuem usando suas APIs preferidas enquanto garantem compatibilidade entre diferentes plataformas.

Além disso, os polyfills oferecem vantagens significativas na manutenção e atualização de bases de código. Eles criam uma camada de abstração que isola o código específico de cada ambiente, facilitando a atualização ou substituição de APIs subjacentes sem impactar o restante do código.

Aqui estão os benefícios dos polyfills:

• Transição fluida de ambientes baseados em servidores para serverless.
• Compatibilidade entre diferentes ambientes.
• Facilidade na manutenção e atualização do código.

Em essência, os polyfills garantem que seu código seja executado sem problemas em qualquer plataforma.

Polyfills em ação

Imagine um cenário em que um desenvolvedor precisa usar a API TextDecoderStream para se conectar a uma Web API, mas o ambiente de runtime não oferece suporte a ela. É aqui que os polyfills entram em cena. Eles podem simular a funcionalidade da API, fornecendo ao desenvolvedor as ferramentas necessárias para continuar trabalhando sem interrupções.

Para ilustrar isso, considere o seguinte trecho de código sem o uso de polyfills:

let decoder = new TextDecoderStream()
let readableStream = new ReadableStream({
  start(controller) {
    controller.enqueue(new Uint8Array([65, 66, 67]))
    controller.close()
  }
})
let decodedStream = readableStream.pipeThrough(decoder)

Este código falharia em um ambiente de runtime que não oferece suporte a essa API. No entanto, o desenvolvedor pode utilizar um polyfill de código aberto, como os disponíveis no unenv. O código equivalente com o polyfill seria o seguinte:

import { TextDecoderStream } from 'unenv'

let decoder = new TextDecoderStream()
let readableStream = new ReadableStream({
  start(controller) {
    controller.enqueue(new Uint8Array([65, 66, 67]))
    controller.close()
  }
})
let decodedStream = readableStream.pipeThrough(decoder)

Agora, o código pode ser executado sem problemas, mesmo em um ambiente que não oferece suporte nativo à API TextDecoderStream. No entanto, embora a inclusão manual de polyfills seja uma abordagem válida, o uso de um bundler pode aprimorar significativamente a experiência de desenvolvimento.

Um bundler detecta automaticamente e inclui os polyfills necessários, eliminando a necessidade de intervenção manual. Isso pode economizar muito tempo e esforço dos desenvolvedores, permitindo que eles foquem mais na construção de funcionalidades em vez de se preocuparem com problemas de compatibilidade. Mas esse é um tema para outra seção, onde exploraremos como uma ferramenta como o Azion Bundler pode otimizar seu fluxo de trabalho ao lidar com polyfills.

Azion Bundler e polyfills

Um edge runtime enfrenta desafios significativos para garantir a compatibilidade. Nós desenvolvemos o Azion Bundler, um bundler open-source equipado com polyfills para melhorar a experiência do desenvolvedor e a compatibilidade. Esse bundler foi projetado para ser altamente flexível, adaptável e intuitivo. Como um projeto open-source, ele está em constante evolução através do desenvolvimento colaborativo.

O Azion Bundler inclui as seguintes funcionalidades:

• Unenv: uma biblioteca open-source que fornece polyfills para diferentes ambientes.

• Custom Polyfills: esses polyfills são especificamente projetados para estender a compatibilidade do edge runtime e preencher as lacunas deixadas pelos polyfills ausentes no unenv.

A flexibilidade do bundler permite que os desenvolvedores se adaptem ao ambiente dinâmico do desenvolvimento web.

Conclusão

Os polyfills garantem a compatibilidade entre diversos ambientes, permitindo que os desenvolvedores utilizem os padrões mais recentes sem sacrificar a funcionalidade, além de otimizar o desempenho para uma melhor experiência do usuário.

O uso de polyfills em ambientes serverless contribui para a agilidade e escalabilidade do desenvolvimento web serverless.