# Como resolver APIs do Node.js por meio de polyfills

Através da [Azion CLI](/pt-br/documentacao/produtos/azion-cli/visao-geral/), você pode inicializar uma aplicação baseada em templates ou vincular um projeto existente. A lista de web frameworks inclui Next.js, React, Vue, Angular, Astro, JavaScript e outros. Esses frameworks JavaScript são executados no edge da Azion, em cima do [Azion Runtime](/pt-br/documentacao/runtime/visao-geral/).

Os projetos com esses frameworks geralmente fazem uso de APIs de Node.js. Através do processo de build da Azion, realizado pelo [Azion Bundler](https://github.com/aziontech/bundler), essas APIs são resolvidas através do uso de *polyfills*.

Este guia mostrará como usar a API Buffer do Node.js através de polyfills em um projeto JavaScript na Azion usando a Azion CLI e o Azion Bundler.

---

## Pré-requisitos

Antes de começar, você deve ter:

- Uma conta na [plataforma da Azion](/pt-br/documentacao/produtos/contas/criar-uma-conta/) com o módulo [Functions](/pt-br/documentacao/produtos/build/applications/functions/) habilitado.
- [A versão mais recente da Azion CLI instalada](/pt-br/documentacao/produtos/azion-cli/visao-geral/).
- Um editor de código.
- Acesso ao terminal.
- Node.js ≥ 18 instalado.

---

## Inicialize um projeto JavaScript

1. No terminal, inicialize o projeto:

```sh 
azion init
```

2. Digite o nome `polyfills-guide`:

```sh 
Your application's name:  (glorious-curiosity) polyfills-guide
```

3. Escolha o template de JavaScript:

:::tip
Você pode começar a digitar o nome do preset para filtrar os resultados.
:::

```sh 
? Choose a preset:  [Use arrows to move, type to filter]
  Angular
  Astro
  Docusaurus
  Eleventy
  Emscripten
  Gatsby
  Hexo
  Hono
  Hugo
> Javascript
  Jekyll
  ...
```

4. Escolha o template `Hello World`:

:::tip
Você pode começar a digitar o nome do template para filtrar os resultados.
:::

```sh
? Choose a template:  [Use arrows to move, type to filter]
  Azion SQL Database
  Drizzle + Neon Sample
  Drizzle + TiDB Sample
  Drizzle + Turso Sample
  Functions GitHub AutoDeploy
  Fauna DB Boilerplate
> Hello World
  HTMX Boilerplate
  Simple Javascript Router Node
  ...
```

5. Digite `y` para iniciar um servidor de desenvolvimento local. 

6. Digite `y` para instalar as dependências do projeto.

7. Acesse a porta que foi retornada no terminal. Exemplo:

```bash 
[Azion Bundler] [Server] › ✔  success   Function running on port 0.0.0.0:3333, url: http://localhost:3333
``` 

8. Retorne ao terminal e encerre o processo.

9. Acesse seu projeto: 

```bash
cd polyfills-guide
```

10. Abra o arquivo `azion.config.js`. Você verá algo semelhante a isto:

```js title="polyfills-guide/azion.config.js"
import { defineConfig } from 'azion';

export default defineConfig({
  build: {
    entry: 'main.js',
    preset: {
      name: 'javascript',
    },
  },
});
```

Este é o arquivo onde você pode adicionar configurações específicas para o seu projeto. Por exemplo, a propriedade `polyfills` pode ser definida como `true` ou `false` para controlar se os polyfills devem ou não ser permitidos:

```js title="polyfills-guide/azion.config.js"
import { defineConfig } from 'azion';

export default defineConfig({
  build: {
    entry: 'main.js',
    preset: {
      name: 'javascript',
    },
    polyfills: true, // permite usar polyfills
  },
});
```

Em nosso exemplo, você pode deixar o arquivo como está. Os polyfills são permitidos por padrão.

:::note
Para mais informações sobre como configurar o seu projeto, verifique a [referência do arquivo azion.config.js](/pt-br/documentacao/devtools/cli/configs/azion-config-js/).
:::

11. Após aplicar estas configurações, você pode importar as APIs necessárias para o seu projeto. Neste exemplo, estamos usando a API Buffer do Node.js:

**Dentro do  arquivo main.js**:

```js title="polyfills-guide/main.js"
// Importa a classe Buffer do módulo 'buffer' no Node.js
import { Buffer } from "node:buffer";

const main = async (event) => {
  // Cria um buffer a partir da string "Hello Edge!" com codificação UTF-8
  const helloBuffer = Buffer.from("Hello Edge!", "utf8");

  // Registra o conteúdo do buffer como uma string hexadecimal
  console.log(helloBuffer.toString("hex"));
  // Saída esperada: 48656c6c6f204564676521

  // Registra o conteúdo do buffer como uma string base64
  console.log(helloBuffer.toString("base64"));
  // Saída esperada: SGVsbG8gRWRnZSE=

  // Sobrescreve parte do buffer com a string "World" no deslocamento e comprimento especificados
  helloBuffer.write("World", 6, 5, "utf8");

  // Registra o conteúdo atualizado do buffer como uma string
  console.log(helloBuffer.toString());
  // Saída esperada: Hello World!

  // Retorna o conteúdo do buffer como uma resposta com um status 200
  return new Response(helloBuffer.toString(), { status: 200 });
};

export default main;
```

12. Execute o projeto localmente rodando: 

```bash 
azion dev
```

Agora você pode verificar os logs no terminal e ver a API Buffer funcionando através de polyfills. 

:::tip
Você pode acessar uma lista de APIs que são resolvidas através de polyfills no [repósitório do Azion Bundler](https://github.com/aziontech/bundler) e na [documentacão de compatibilidade da Azion](/pt-br/documentacao/produtos/devtools/azion-edge-runtime/compatibilidade/node/). Azion Bundler é um projeto **open-source** e você pode propor novos presets e implementações.
:::

---

## Fazer o deploy da function na Azion

Após testar localmente com `azion dev`, faça o deploy da sua function para a Azion Platform:

13. Execute o comando de deploy:

```bash
azion deploy
```

O CLI realiza o build do projeto, aplica os polyfills configurados e publica a function na plataforma. Ao final do processo, você receberá a URL de acesso à sua aplicação.

### Opções úteis do comando deploy

| Flag | Descrição |
|------|-----------|
| `--auto` | Executa o fluxo completo de build, provisionamento e distribuição sem interrupções ou prompts interativos. |
| `--workers <número>` | Define o número de workers paralelos para upload de arquivos estáticos para o Object Storage. Por padrão, é calculado automaticamente com base nos núcleos de CPU disponíveis (máximo: 20). |
| `--dry-run` | Simula o processo de deploy localmente, validando as regras de roteamento geradas sem afetar recursos em produção. |

**Exemplo com flags:**

```bash
azion deploy --auto --workers 10
```

:::note
O processo de build aplica os polyfills automaticamente com base na configuração do arquivo `azion.config.js`. Certifique-se de que os módulos necessários estão listados na propriedade `polyfills` antes de fazer o deploy.
:::