> ## 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.

# Crear funciones

> Las funciones de Base44 son funciones de backend sin servidor que se ejecutan en Deno. Se definen localmente en tu proyecto y se despliegan al backend de Base44.

<Warning>
  Esta página es parte de una habilidad de agente de codificación con IA y está escrita para agentes, no para humanos. Para la documentación de Base44 legible por humanos, consulta la [documentación para desarrolladores](/developers).
</Warning>

# Crear funciones

Las funciones de Base44 son funciones de backend sin servidor que se ejecutan en Deno. Se definen localmente en tu proyecto y se despliegan al backend de Base44.

## Directorio de funciones

Todas las definiciones de funciones deben colocarse en la carpeta `base44/functions/` en tu proyecto. La función más simple es una carpeta con un archivo `entry.ts` o `entry.js` dentro.

Estructura de ejemplo:

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

## Cómo crear una función

1. Crea un nuevo directorio en `base44/functions/` con el nombre de tu función (usa kebab-case)
2. Crea `entry.ts` (o `entry.js`) en ese directorio
3. Despliega la función usando la CLI

## Descubrimiento de funciones

La CLI descubre funciones desde los archivos `entry.ts` o `entry.js`. Una carpeta que contiene uno de esos archivos es una función:

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

El nombre de la función es la ruta desde la raíz de funciones hasta esa carpeta. Por ejemplo:

| Archivo                                    | Nombre de función |
| ------------------------------------------ | ----------------- |
| `base44/functions/process-order/entry.ts`  | `process-order`   |
| `base44/functions/orders/process/entry.ts` | `orders/process`  |

Reglas:

* `entry.ts` o `entry.js` deben estar dentro de una subcarpeta con nombre, no directamente en `base44/functions/`
* todos los archivos `*.js`, `*.ts` y `*.json` bajo la carpeta de función se incluyen al desplegar
* las rutas de función con un punto en cualquier segmento de ruta se ignoran

## Archivo de punto de entrada

Las funciones se ejecutan en Deno y deben exportar usando `Deno.serve()`. Usa el prefijo `npm:` para paquetes npm.

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

Deno.serve(async (req) => {
  // Obtén el cliente autenticado desde la solicitud
  const base44 = createClientFromRequest(req);
  
  // Analiza la entrada
  const { orderId, action } = await req.json();
  
  // Tu lógica aquí
  const order = await base44.entities.Orders.get(orderId);
  
  // Devuelve la respuesta
  return Response.json({
    success: true,
    order: order
  });
});
```

### Objeto Request

La función recibe un objeto `Request` estándar de Deno:

* `req.json()` - Analiza el cuerpo JSON
* `req.text()` - Obtiene el cuerpo de texto sin procesar
* `req.headers` - Accede a las cabeceras de la solicitud
* `req.method` - Método HTTP

### Objeto Response

Devuelve usando `Response.json()` para respuestas JSON:

```typescript theme={null}
// Respuesta de éxito
return Response.json({ data: result });

// Respuesta de error con código de estado
return Response.json({ error: "Something went wrong" }, { status: 400 });

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

## Ejemplo completo

### Estructura de directorios

```
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();
    
    // Valida la entrada
    if (!orderId) {
      return Response.json(
        { error: "Order ID is required" },
        { status: 400 }
      );
    }
    
    // Obtén y procesa el pedido
    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 }
    );
  }
});
```

## Usar acceso de rol de servicio

Para operaciones de nivel administrador, usa `asServiceRole`:

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

Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);
  
  // Comprueba que el usuario está autenticado
  const user = await base44.auth.me();
  if (!user) {
    return Response.json({ error: "Unauthorized" }, { status: 401 });
  }
  
  // Usa el rol de servicio para operaciones de administrador
  const allOrders = await base44.asServiceRole.entities.Orders.list();
  
  return Response.json({ orders: allOrders });
});
```

## Usar secretos

Accede a las variables de entorno configuradas en el panel de la app:

```typescript theme={null}
Deno.serve(async (req) => {
  // Accede a las variables de entorno (configuradas en la configuración de la app)
  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());
});
```

## Convenciones de nomenclatura

* **Nombre del directorio**: Usa kebab-case (por ejemplo, `process-order`, `send-notification`)
* **Nombre de función**: Proviene de la ruta del directorio bajo `base44/functions/`
  * Válido: `process-order`, `orders/process`, `send_notification`, `myFunction`
  * Inválido: `process.order`, `send.notification.v2`
* **Archivo de entrada**: Usa `entry.ts` o `entry.js`

## Desplegar funciones

Después de crear tu función, despliégala a Base44:

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

Para más detalles sobre el despliegue, consulta [functions-deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-deploy.md).

## Notas

* Las funciones se ejecutan en el runtime de Deno, no en Node.js
* Usa el prefijo `npm:` para paquetes npm (por ejemplo, `npm:@base44/sdk`)
* Usa `createClientFromRequest(req)` para obtener un cliente que hereda el contexto de autenticación del llamante
* Configura secretos mediante el panel de la app para claves API
* Asegúrate de manejar errores con elegancia y devolver códigos de estado HTTP apropiados

## Errores comunes

| Incorrecto                                       | Correcto                                | Por qué                                                       |
| ------------------------------------------------ | --------------------------------------- | ------------------------------------------------------------- |
| `base44/functions/myFunction.js` (archivo único) | `base44/functions/my-function/entry.ts` | Las funciones deben vivir en un subdirectorio con nombre      |
| `base44/functions/entry.ts`                      | `base44/functions/my-function/entry.ts` | El nombre de la función proviene de la ruta del subdirectorio |
| `import { ... } from "@base44/sdk"`              | `import { ... } from "npm:@base44/sdk"` | Deno requiere el prefijo `npm:` para paquetes npm             |
| Directorio `MyFunction` o `myFunction`           | Directorio `my-function`                | Usa kebab-case para nombres de directorio                     |

<Note>Esta página fue traducida usando IA. Para obtener la información más precisa y actualizada, consulta la [versión en inglés](/).</Note>