Tester et déployer à partir de CI

aura functions serve exécute votre fichier avec Deno et le redémarre lorsque vous enregistrez.

aura functions serve hello --port 54321
curl -X POST http://127.0.0.1:54321/ -H 'Content-Type: application/json' -d '{"name":"Ada"}'

Il s'agit d'un simple serveur Deno. Par rapport à la plateforme, elle a :

• Aucun en-tête de plate-forme. x-aura-role et x-aura-user-id sont absents : envoyez-les vous-même avec curl -H pour tester les branches d'autorisation.
• Aucun secret. Passez-les dans votre shell : STRIPE_SECRET_KEY=sk_test_… aura functions serve checkout.
• Aucune limite. Les limites de mémoire, de délai d'attente, de taille du corps et de débit ne sont pas appliquées.
• Demandes simples. Vous appelez la fonction directement, donc path et method sont ceux de votre curl, pas les options invoke du SDK.

Le SDK ne peut pas cibler ce serveur, car invoke appelle la route de la plateforme. Testez le chemin du SDK par rapport à un projet réel, comme ci-dessous.

Créez un projet de développement (voir votre première fonction), déployez-y la fonction et testez via le SDK. Cela couvre les en-têtes d’identité, les limites et les classes d’erreur de la plateforme.

import { createClient, FunctionsHttpError } from '@aurabase/aurabase-js'
import { describe, expect, it } from 'vitest'

const aura = createClient(process.env.AURA_TEST_URL!, process.env.AURA_TEST_ANON_KEY!)

describe('hello', () => {
  it('greets', async () => {
    const { data, error } = await aura.functions.invoke<{ greeting: string }>('hello', { body: { name: 'Ada' } })
    expect(error).toBeNull()
    expect(data?.greeting).toBe('Hello, Ada!')
  })

  it('reports a missing function as a FunctionsHttpError 404', async () => {
    const { error } = await aura.functions.invoke('does-not-exist')
    expect(error).toBeInstanceOf(FunctionsHttpError)
    expect(error?.status).toBe(404)
  })

  it('refuses to list functions with a public key', async () => {
    const { data, error } = await aura.functions.list()
    expect(data).toBeNull()
    expect(error?.status).toBe(403)
  })
})

Conseils :

• Utilisez un projet dédié, jamais de production, et conservez ses clés dans vos secrets CI.
• La limite du taux d'appel est de 15 appels puis 1 par seconde par IP. Espacez vos tests ou exécutez-les en série.

La CLI aura s'installe à partir de npm sur macOS Apple Silicon et à partir d'une source ailleurs, donc un travail Linux CI est plus simple avec l'API HTTP. Le déploiement consiste en un POST par fonction, authentifié avec une clé service_role. Cette boucle exacte a été exécutée sur un projet réel et la fonction a répondu par la suite.

name: Deploy functions
on:
  push:
    branches: [main]
    paths: ['aurabase/functions/**']

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Deploy every function
        env:
          AURA_PROJECT_URL: ${{ secrets.AURA_PROJECT_URL }}
          AURA_SERVICE_ROLE_KEY: ${{ secrets.AURA_SERVICE_ROLE_KEY }}
        run: |
          set -euo pipefail
          for dir in aurabase/functions/*/; do
            name=$(basename "$dir")
            file="${dir}index.ts"
            [ -f "$file" ] || continue
            jq -n --arg name "$name" --rawfile code "$file" \
              '{name: $name, runtime: "deno", code: $code}' |
            curl -sS --fail-with-body -X POST "$AURA_PROJECT_URL/v1/functions" \
              -H "apikey: $AURA_SERVICE_ROLE_KEY" \
              -H "Content-Type: application/json" \
              --data-binary @-
            echo " deployed $name"
          done

Faits qui permettent de l'exécuter en toute sécurité à chaque poussée :

• Le POST remplace le code d'une fonction existante et garde ses secrets, car le corps n'a pas de env_vars.
• Une fonction est mono-fichier : les importations relatives ne sont pas expédiées. Regroupez d'abord si vous utilisez des modules locaux.
• Il n'y a pas d'historique des versions sur le serveur. Votre historique Git est la restauration : pour revenir en arrière, annulez la validation et laissez CI se déployer à nouveau.

Exécutez ensuite vos tests d'intégration sur le projet que vous venez de déployer, dans une tâche suivante.

Un projet est un environnement. Créez un projet par environnement, chacun avec sa propre URL et ses propres clés, et laissez CI choisir la cible :

Stockez AURA_PROJECT_URL et AURA_SERVICE_ROLE_KEY par environnement GitHub et définissez les secrets de chaque fonction séparément dans chaque projet. Rien n'est partagé entre les projets.