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

# Creare funzioni

> Le funzioni Base44 sono funzioni backend serverless che vengono eseguite su Deno. Sono definite localmente nel tuo progetto e distribuite al backend di Base44.

<Warning>
  Questa pagina fa parte di una skill per agenti IA di programmazione ed è scritta per gli agenti, non per gli umani. Per la documentazione Base44 leggibile dagli umani, consulta la [documentazione per sviluppatori](/developers).
</Warning>

# Creare funzioni

Le funzioni Base44 sono funzioni backend serverless che vengono eseguite su Deno. Sono definite localmente nel tuo progetto e distribuite al backend di Base44.

## Directory delle funzioni

Tutte le definizioni delle funzioni devono essere posizionate nella cartella `base44/functions/` nel tuo progetto. La funzione più semplice è una cartella con un file `entry.ts` o `entry.js` al suo interno.

Struttura di esempio:

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

## Come creare una funzione

1. Crea una nuova directory in `base44/functions/` con il nome della funzione (usa kebab-case)
2. Crea `entry.ts` (o `entry.js`) in quella directory
3. Distribuisci la funzione usando la CLI

## Rilevamento delle funzioni

La CLI rileva le funzioni dai file `entry.ts` o `entry.js`. Una cartella che contiene uno di questi file è una funzione:

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

Il nome della funzione è il percorso dalla radice delle funzioni a quella cartella. Ad esempio:

| File                                       | Nome della funzione |
| ------------------------------------------ | ------------------- |
| `base44/functions/process-order/entry.ts`  | `process-order`     |
| `base44/functions/orders/process/entry.ts` | `orders/process`    |

Regole:

* `entry.ts` o `entry.js` deve essere all'interno di una sottocartella con nome, non direttamente in `base44/functions/`
* tutti i file `*.js`, `*.ts` e `*.json` nella cartella della funzione sono inclusi durante la distribuzione
* i percorsi delle funzioni con un punto in qualsiasi segmento del percorso vengono ignorati

## File di entry point

Le funzioni vengono eseguite su Deno e devono esportare usando `Deno.serve()`. Usa il prefisso `npm:` per i pacchetti 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
  });
});
```

### Oggetto Request

La funzione riceve un oggetto `Request` Deno standard:

* `req.json()` - Analizza il body JSON
* `req.text()` - Ottiene il body come testo grezzo
* `req.headers` - Accede agli header della richiesta
* `req.method` - Metodo HTTP

### Oggetto Response

Restituisci usando `Response.json()` per le risposte 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 });
```

## Esempio completo

### Struttura della directory

```
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 }
    );
  }
});
```

## Uso dell'accesso Service Role

Per operazioni a livello admin, usa `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 });
});
```

## Uso dei secret

Accedi alle variabili d'ambiente configurate nella dashboard dell'app:

```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());
});
```

## Convenzioni di denominazione

* **Nome della directory**: usa kebab-case (ad es. `process-order`, `send-notification`)
* **Nome della funzione**: proviene dal percorso della directory sotto `base44/functions/`
  * Validi: `process-order`, `orders/process`, `send_notification`, `myFunction`
  * Non validi: `process.order`, `send.notification.v2`
* **File di entry**: usa `entry.ts` o `entry.js`

## Distribuire le funzioni

Dopo aver creato la tua funzione, distribuiscila a Base44:

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

Per ulteriori dettagli sulla distribuzione, consulta [functions-deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-deploy.md).

## Note

* Le funzioni vengono eseguite sul runtime Deno, non Node.js
* Usa il prefisso `npm:` per i pacchetti npm (ad es. `npm:@base44/sdk`)
* Usa `createClientFromRequest(req)` per ottenere un client che eredita il contesto di autenticazione del chiamante
* Configura i secret tramite la dashboard dell'app per le chiavi API
* Assicurati di gestire gli errori con eleganza e restituire codici di stato HTTP appropriati

## Errori comuni

| Sbagliato                                       | Corretto                                | Perché                                                            |
| ----------------------------------------------- | --------------------------------------- | ----------------------------------------------------------------- |
| `base44/functions/myFunction.js` (singolo file) | `base44/functions/my-function/entry.ts` | Le funzioni devono trovarsi in una sottodirectory con nome        |
| `base44/functions/entry.ts`                     | `base44/functions/my-function/entry.ts` | Il nome della funzione proviene dal percorso della sottodirectory |
| `import { ... } from "@base44/sdk"`             | `import { ... } from "npm:@base44/sdk"` | Deno richiede il prefisso `npm:` per i pacchetti npm              |
| Directory `MyFunction` o `myFunction`           | Directory `my-function`                 | Usa kebab-case per i nomi delle directory                         |

<Note>Questa pagina è stata tradotta utilizzando l'IA. Per informazioni più accurate e aggiornate, consulta la [versione inglese](/). </Note>