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

# Funktionen erstellen

> Base44-Funktionen sind serverlose Backend-Funktionen, die auf Deno laufen. Sie werden lokal in deinem Projekt definiert und im Base44-Backend deployt.

<Warning>
  Diese Seite ist Teil eines KI-Coding-Agent-Skills und für Agenten geschrieben, nicht für Menschen. Für die menschenlesbare Base44-Dokumentation siehe die [Entwicklerdokumentation](/developers).
</Warning>

# Funktionen erstellen

Base44-Funktionen sind serverlose Backend-Funktionen, die auf Deno laufen. Sie werden lokal in deinem Projekt definiert und im Base44-Backend deployt.

## Funktionsverzeichnis

Alle Funktionsdefinitionen müssen im Ordner `base44/functions/` in deinem Projekt abgelegt werden. Die einfachste Funktion ist ein Ordner mit einer Datei `entry.ts` oder `entry.js` darin.

Beispielstruktur:

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

## So erstellst du eine Funktion

1. Erstelle ein neues Verzeichnis in `base44/functions/` mit deinem Funktionsnamen (verwende kebab-case)
2. Erstelle `entry.ts` (oder `entry.js`) in diesem Verzeichnis
3. Deploye die Funktion mit der CLI

## Funktionserkennung

Die CLI erkennt Funktionen anhand von `entry.ts`- oder `entry.js`-Dateien. Ein Ordner, der eine dieser Dateien enthält, ist eine Funktion:

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

Der Funktionsname ist der Pfad vom Funktions-Root zu diesem Ordner. Zum Beispiel:

| Datei                                      | Funktionsname    |
| ------------------------------------------ | ---------------- |
| `base44/functions/process-order/entry.ts`  | `process-order`  |
| `base44/functions/orders/process/entry.ts` | `orders/process` |

Regeln:

* `entry.ts` oder `entry.js` muss in einem benannten Unterordner liegen, nicht direkt in `base44/functions/`
* Alle `*.js`-, `*.ts`- und `*.json`-Dateien im Funktionsordner werden beim Deployen einbezogen
* Funktionspfade mit einem Punkt in irgendeinem Pfadsegment werden ignoriert

## Einstiegspunkt-Datei

Funktionen laufen auf Deno und müssen mit `Deno.serve()` exportieren. Verwende das Präfix `npm:` für npm-Pakete.

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

### Request-Objekt

Die Funktion erhält ein standardmäßiges Deno-`Request`-Objekt:

* `req.json()` — JSON-Body parsen
* `req.text()` — rohen Text-Body abrufen
* `req.headers` — auf Request-Header zugreifen
* `req.method` — HTTP-Methode

### Response-Objekt

Verwende `Response.json()` für JSON-Antworten:

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

## Vollständiges Beispiel

### Verzeichnisstruktur

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

## Service-Role-Zugriff verwenden

Für Admin-Operationen verwende `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 });
});
```

## Secrets verwenden

Greife auf im App-Dashboard konfigurierte Umgebungsvariablen zu:

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

## Benennungskonventionen

* **Verzeichnisname**: Verwende kebab-case (z. B. `process-order`, `send-notification`)
* **Funktionsname**: Ergibt sich aus dem Verzeichnispfad unter `base44/functions/`
  * Gültig: `process-order`, `orders/process`, `send_notification`, `myFunction`
  * Ungültig: `process.order`, `send.notification.v2`
* **Einstiegspunkt-Datei**: Verwende `entry.ts` oder `entry.js`

## Funktionen deployen

Nach dem Erstellen deiner Funktion deploye sie zu Base44:

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

Weitere Details zum Deployen siehe [functions-deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-deploy.md).

## Hinweise

* Funktionen laufen auf der Deno-Runtime, nicht Node.js
* Verwende das Präfix `npm:` für npm-Pakete (z. B. `npm:@base44/sdk`)
* Verwende `createClientFromRequest(req)`, um einen Client zu erhalten, der den Auth-Kontext des Aufrufers erbt
* Konfiguriere Secrets über das App-Dashboard für API-Schlüssel
* Behandle Fehler ordentlich und gib passende HTTP-Statuscodes zurück

## Häufige Fehler

| Falsch                                            | Richtig                                 | Warum                                                        |
| ------------------------------------------------- | --------------------------------------- | ------------------------------------------------------------ |
| `base44/functions/myFunction.js` (einzelne Datei) | `base44/functions/my-function/entry.ts` | Funktionen müssen in einem benannten Unterverzeichnis liegen |
| `base44/functions/entry.ts`                       | `base44/functions/my-function/entry.ts` | Der Funktionsname ergibt sich aus dem Unterverzeichnispfad   |
| `import { ... } from "@base44/sdk"`               | `import { ... } from "npm:@base44/sdk"` | Deno benötigt das `npm:`-Präfix für npm-Pakete               |
| Verzeichnis `MyFunction` oder `myFunction`        | Verzeichnis `my-function`               | Verwende kebab-case für Verzeichnisnamen                     |

<Note>Diese Seite wurde mit KI übersetzt. Für die genauesten und aktuellsten Informationen siehe die [englische Version](/). </Note>