> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Criando Funções

> As funções Base44 são funções de backend serverless que rodam no Deno. Elas são definidas localmente no seu projeto e implantadas no backend Base44.

<Warning>
  Esta página faz parte de uma habilidade de agente de código IA e é escrita para agentes, não para humanos. Para a documentação legível por humanos da Base44, veja a [documentação para desenvolvedores](/developers).
</Warning>

# Criando Funções

As funções Base44 são funções de backend serverless que rodam no Deno. Elas são definidas localmente no seu projeto e implantadas no backend Base44.

## Diretório de funções

Todas as definições de função devem ser colocadas na pasta `base44/functions/` no seu projeto. A função mais simples é uma pasta com um arquivo `entry.ts` ou `entry.js` dentro dela.

Estrutura de exemplo:

```
my-app/
  base44/
    functions/
      process-order/
        entry.ts
      send-notification/
        entry.ts
```

## Como criar uma função

1. Crie um novo diretório em `base44/functions/` com o nome da sua função (use kebab-case)
2. Crie `entry.ts` (ou `entry.js`) nesse diretório
3. Implante a função usando a CLI

## Descoberta de funções

A CLI descobre funções a partir de arquivos `entry.ts` ou `entry.js`. Uma pasta que contém um desses arquivos é uma função:

```
base44/
  functions/
    process-order/
      entry.ts
```

O nome da função é o caminho da raiz de funções até essa pasta. Por exemplo:

| Arquivo                                    | Nome da função   |
| ------------------------------------------ | ---------------- |
| `base44/functions/process-order/entry.ts`  | `process-order`  |
| `base44/functions/orders/process/entry.ts` | `orders/process` |

Regras:

* `entry.ts` ou `entry.js` deve estar dentro de uma subpasta nomeada, não diretamente em `base44/functions/`
* todos os arquivos `*.js`, `*.ts` e `*.json` sob a pasta da função são incluídos ao implantar
* caminhos de função com um ponto em qualquer segmento de caminho são ignorados

## Arquivo de ponto de entrada

As funções rodam no Deno e devem exportar usando `Deno.serve()`. Use o prefixo `npm:` para pacotes npm.

```typescript theme={null}
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  // Get authenticated client from request
  const base44 = createClientFromRequest(req);
  
  // Parse input
  const { orderId, action } = await req.json();
  
  // Your logic here
  const order = await base44.entities.Orders.get(orderId);
  
  // Return response
  return Response.json({
    success: true,
    order: order
  });
});
```

### Objeto Request

A função recebe um objeto `Request` padrão do Deno:

* `req.json()` - Analisa o corpo JSON
* `req.text()` - Obtém o corpo de texto bruto
* `req.headers` - Acessa cabeçalhos da solicitação
* `req.method` - Método HTTP

### Objeto Response

Retorne usando `Response.json()` para respostas JSON:

```typescript theme={null}
// Success response
return Response.json({ data: result });

// Error response with status code
return Response.json({ error: "Something went wrong" }, { status: 400 });

// Not found
return Response.json({ error: "Order not found" }, { status: 404 });
```

## Exemplo completo

### Estrutura de diretórios

```
base44/
  functions/
    process-order/
      entry.ts
```

### entry.ts

```typescript theme={null}
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  try {
    const base44 = createClientFromRequest(req);
    const { orderId } = await req.json();
    
    // Validate input
    if (!orderId) {
      return Response.json(
        { error: "Order ID is required" },
        { status: 400 }
      );
    }
    
    // Fetch and process the order
    const order = await base44.entities.Orders.get(orderId);
    if (!order) {
      return Response.json(
        { error: "Order not found" },
        { status: 404 }
      );
    }
    
    return Response.json({
      success: true,
      orderId: order.id,
      processedAt: new Date().toISOString()
    });
    
  } catch (error) {
    return Response.json(
      { error: error.message },
      { status: 500 }
    );
  }
});
```

## Usando acesso Service Role

Para operações em nível de administrador, use `asServiceRole`:

```typescript theme={null}
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);
  
  // Check user is authenticated
  const user = await base44.auth.me();
  if (!user) {
    return Response.json({ error: "Unauthorized" }, { status: 401 });
  }
  
  // Use service role for admin operations
  const allOrders = await base44.asServiceRole.entities.Orders.list();
  
  return Response.json({ orders: allOrders });
});
```

## Usando segredos

Acesse variáveis de ambiente configuradas no painel do aplicativo:

```typescript theme={null}
Deno.serve(async (req) => {
  // Access environment variables (configured in app settings)
  const apiKey = Deno.env.get("STRIPE_API_KEY");
  
  const response = await fetch("https://api.stripe.com/v1/charges", {
    headers: {
      "Authorization": `Bearer ${apiKey}`
    }
  });
  
  return Response.json(await response.json());
});
```

## Convenções de nomenclatura

* **Nome do diretório**: Use kebab-case (por exemplo, `process-order`, `send-notification`)
* **Nome da função**: Vem do caminho do diretório em `base44/functions/`
  * Válido: `process-order`, `orders/process`, `send_notification`, `myFunction`
  * Inválido: `process.order`, `send.notification.v2`
* **Arquivo de entrada**: Use `entry.ts` ou `entry.js`

## Implantando funções

Depois de criar sua função, implante-a na Base44:

```bash theme={null}
npx base44 functions deploy
```

Para mais detalhes sobre implantação, veja [functions-deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-deploy.md).

## Notas

* As funções rodam no runtime Deno, não no Node.js
* Use o prefixo `npm:` para pacotes npm (por exemplo, `npm:@base44/sdk`)
* Use `createClientFromRequest(req)` para obter um cliente que herda o contexto de autenticação do chamador
* Configure segredos pelo painel do aplicativo para chaves de API
* Certifique-se de tratar erros graciosamente e retornar códigos de status HTTP apropriados

## Erros comuns

| Errado                                           | Correto                                 | Por quê                                           |
| ------------------------------------------------ | --------------------------------------- | ------------------------------------------------- |
| `base44/functions/myFunction.js` (arquivo único) | `base44/functions/my-function/entry.ts` | As funções devem estar em um subdiretório nomeado |
| `base44/functions/entry.ts`                      | `base44/functions/my-function/entry.ts` | O nome da função vem do caminho do subdiretório   |
| `import { ... } from "@base44/sdk"`              | `import { ... } from "npm:@base44/sdk"` | O Deno requer o prefixo `npm:` para pacotes npm   |
| Diretório `MyFunction` ou `myFunction`           | Diretório `my-function`                 | Use kebab-case para nomes de diretório            |

<Note>Esta página foi traduzida usando IA. Para informações mais precisas e atualizadas, consulte a [versão em inglês](/). </Note>