Invoquer une fonction

invoke est le seul appel qu'une clé publique peut effectuer. Cela fonctionne de la même manière dans un navigateur et sur un serveur.

import { createClient } from '@aurabase/aurabase-js'

const aura = createClient(process.env.AURA_URL!, process.env.AURA_ANON_KEY!)

const { data, error } = await aura.functions.invoke<{ greeting: string }>('hello', {
  body: { name: 'Ada' },
})
if (error) throw error
console.log(data?.greeting)

// Après la connexion, le SDK ajoute le JWT de l'utilisateur à chaque appel : aucun code supplémentaire.
await aura.auth.signInWithPassword({ email, password })
const { data } = await aura.functions.invoke('whoami')
// La fonction voit x-aura-role: authentifié et l'identifiant de l'utilisateur.

Le invoke<T> générique tape uniquement la réponse. Le nom et le corps ne sont pas vérifiés au moment de la compilation.

Votre fonction reçoit exactement la requête que vous décrivez, pas un wrapper autour d'elle.

await aura.functions.invoke('items', {
  method: 'PUT',
  path: '/items/1',
  headers: { 'x-source': 'dashboard' },
  body: { qty: 2 },
})

Deno.serve(async (req) => {
  const url = new URL(req.url)          // chemin d'accès : '/items/1'
  const source = req.headers.get('x-source') // 'tableau de bord'
  const body = await req.json()         // { quantité : 2 }
  return Response.json({ method: req.method, id: url.pathname.split('/').pop(), source, body })
})

Règles à connaître :

• GET et HEAD sont envoyés sans corps.
• Un corps qui n'est pas une chaîne est envoyé au format JSON, avec content-type: application/json sauf si vous en définissez un. Un corps de chaîne est envoyé tel quel et obtient également content-type: application/json, alors lisez-le avec req.text().
• Sans body, la fonction reçoit une requête sans corps. Un simple await req.json() est lancé, alors écrivez await req.json().catch(() => ({})) lorsque l'appel peut être effectué sans charge utile.
• Le corps doit être au format JSON : un objet, un tableau, une chaîne, un nombre ou un booléen. Un Blob, ArrayBuffer, tableau typé, FormData, URLSearchParams ou ReadableStream est refusé avec le code d'erreur invalid_body avant l'envoi de toute requête.
• Les en-têtes de tramage (content-length, transfer-encoding, connection, host, …) sont ignorés.

La plateforme valide la clé et le jeton de l'utilisateur avant l'exécution de votre fonction, puis ajoute ces en-têtes :

Deno.serve((req) => {
  if (req.headers.get('x-aura-role') !== 'authenticated') {
    return new Response('Sign in first', { status: 401 })
  }
  return Response.json({ userId: req.headers.get('x-aura-user-id') })
})

Résultats réels de cet appel avec trois clés différentes :

{ "role": "anon",          "userId": null }
{ "role": "authenticated", "userId": "b125f8cd-ddc8-4042-9d9d-2e0aa3cebe51" }
{ "role": "service_role",  "userId": null }

Sans le SDK, envoyez un objet JSON qui décrit la requête. Le champ body est ce que votre fonction reçoit.

curl -X POST "$AURA_URL/v1/functions/hello/invoke" \
  -H "apikey: $AURA_ANON_KEY" \
  -H "Content-Type: application/json" \
  -d '{"body":{"name":"Ada"}}'

apikey et Content-Type: application/json sont requis. Ajoutez Authorization: Bearer <user JWT> pour appeler en tant qu'utilisateur connecté. La réponse par défaut est une enveloppe ; l'en-tête X-Aurabase-Invoke-Mode: raw renvoie à la place la propre réponse de votre fonction, voir réponses non JSON.

invoke ne lance jamais. Il renvoie { data, error }:

const { data, error } = await aura.functions.invoke('hello', { body: { name: 'Ada' } })

if (error) {
  // error.status : état HTTP de l'échec
  // error.message : le texte renvoyé par votre fonction ou l'explication de la plateforme
  return
}
// les données sont nulles lorsque la fonction n'a renvoyé aucun contenu (par exemple un 204)
if (data === null) return
console.log(data)

Testez data plutôt que error lorsque vous avez besoin de la valeur : TypeScript sait alors que ce n'est pas null. Pour gérer les échecs avec précision, lisez les erreurs , les délais d'attente et les tentatives.