@aurabase/functions 0.5.3 → 0.6.0

package/README.md

@@ -26,6 +26,10 @@ import { createClient } from '@aurabase/aurabase-js'
 const aura = createClient('https://mon-projet.aurabase.cloud', 'aura_anon_xxx')
 ```
 
+### Qui peut appeler quoi
+
+Seule l'**invocation** (`invoke`) est ouverte à la clé publique `anon` et aux JWT utilisateur. Tout le reste (`list`, `get`, `listJobs`, `getJob`, `enqueueJob`, `listCronJobs`, `createCronJob`, `deleteCronJob`) exige une clé `service_role` et s'utilise **côté serveur** : une `FunctionDef` contient le code source et les variables d'environnement de la fonction, donc ces appels répondent `403` à une clé publique. `createClient` refuse d'ailleurs une clé `service_role` dans un navigateur.
+
 ### Invocation
 
 `invoke<T>()` décrit la requête que votre fonction doit recevoir (`{ method, path, headers, body }`) et dé-wrap la réponse JSON du backend — tout est bufferisé, pas de streaming (voir Limitations).
@@ -44,6 +48,8 @@ console.log(data.ok)
 
 Options complètes : `body`, `method`, `path` (sous-route à l'intérieur de la fonction), `headers` (transmis à la fonction elle-même, pas des headers de transport), `signal`, `timeout`, `responseType`.
 
+Le `body` doit être sérialisable en JSON (objet, tableau, chaîne, nombre, booléen). Un `Blob`, un `ArrayBuffer`, un tableau typé, un `FormData`, un `URLSearchParams` ou un `ReadableStream` est refusé avant tout appel réseau avec le code `invalid_body` : le runtime ne reçoit que du JSON, et ces objets seraient transmis vides ou déformés. Encodez-les (par exemple en base64) ou passez par Storage.
+
 ```ts
 const controller = new AbortController()
 
@@ -85,7 +91,7 @@ Deno.serve(async (req) => {
 })
 ```
 
-Défauts si vous ne précisez rien : `POST` sur `/`. `GET` et `HEAD` sont envoyés sans corps (la spec Fetch l'interdit) ; un `body` non-chaîne est sérialisé en JSON et `content-type: application/json` est posé si vous n'en fixez pas un.
+Défauts si vous ne précisez rien : `POST` sur `/`. `GET` et `HEAD` sont envoyés sans corps (la spec Fetch l'interdit) ; un `body` non-chaîne est sérialisé en JSON ; `content-type: application/json` est posé si vous n'en fixez pas un — y compris pour une chaîne, que la fonction reçoit alors telle quelle : lisez-la avec `await req.text()` plutôt que `req.json()`.
 
 Sans `body`, la fonction reçoit une requête **sans corps** (parité `@supabase/functions-js`) : un `await req.json()` inconditionnel y échoue. Écrivez `await req.json().catch(() => ({}))` si l'appel peut être fait sans charge utile.
 
@@ -95,7 +101,7 @@ Les en-têtes de cadrage/transport (`content-length`, `transfer-encoding`, `conn
 
 #### Type de réponse (`responseType`)
 
-Défaut `'json'` : le corps est parsé et dé-wrappé (`{data}` → contenu). Les autres valeurs renvoient le corps brut de la fonction, sans dé-wrapping, et `error.status` porte alors le **vrai** statut HTTP de la fonction :
+Défaut `'json'` : le corps est parsé et dé-wrappé (`{data}` → contenu). Une réponse texte (`text/plain`…) arrive telle quelle, en chaîne. Un contenu **binaire** (image, PDF…) ne peut pas passer par ce mode : le SDK renvoie `invalid_response` en vous orientant vers `responseType`. Les autres valeurs renvoient le corps brut de la fonction, sans dé-wrapping, et `error.status` porte alors le **vrai** statut HTTP de la fonction :
 
 ```ts
 const { data: csv } = await aura.functions.invoke<string>('export', { responseType: 'text' })
@@ -109,27 +115,31 @@ Parité `@supabase/functions-js`. Les deux classes sous-classent `AuraError` (do
 
 | Classe | Quand | Statuts |
 |---|---|---|
-| `FunctionsHttpError` | **votre fonction** a répondu en erreur | tout non-2xx hors relais (400, 404, 500…) |
-| `FunctionsRelayError` | la réponse de votre fonction n'est jamais arrivée | 0 (réseau), 502, 503, 504 |
+| `FunctionsHttpError` | **votre fonction** a répondu en erreur, ou une route de gestion a échoué | tout non-2xx venant de la fonction (400, 404, 500, **y compris 502/503/504 qu'elle renvoie elle-même**) |
+| `FunctionsRelayError` | la **plateforme** a échoué : la réponse de votre fonction n'est jamais arrivée | 0 (réseau), 502, 503, 504 produits par la passerelle ou le runtime |
+
+Le message d'une `FunctionsHttpError` est celui que votre fonction a renvoyé : texte brut, `{ "message": "…" }`, `{ "error": "…" }` ou `{ "error": { "message": "…" } }`. `error.context` conserve le corps d'origine (objet JSON ou texte). Une fonction qui répond 500 sans corps donne « Function returned HTTP 500 ».
 
 Deux statuts de relais à ne pas confondre — ils ne se rejouent pas de la même façon :
 
 - **503 `SERVICE_UNAVAILABLE`** : l'edge-runtime est injoignable, votre fonction **n'a pas** été exécutée → réessayer est sûr ;
-- **504 `TIMEOUT`** : votre fonction a dépassé son budget (`permissions.timeout_secs` + marge). Elle **a été lancée** et a pu produire ses effets de bord ; seule la réponse manque → ne rejouez pas une opération non idempotente à l'aveugle.
+- **504 `TIMEOUT`** : l'attente a dépassé le budget de la fonction (`permissions.timeout_secs` + marge). La fonction **a été lancée** et a pu produire ses effets de bord ; seule la réponse manque → ne rejouez pas une opération non idempotente à l'aveugle.
 
 ```ts
-import { FunctionsHttpError, FunctionsRelayError, isRelayStatus } from '@aurabase/functions'
+import { FunctionsHttpError, FunctionsRelayError, isRelayStatus } from '@aurabase/aurabase-js'
 
 const { error } = await aura.functions.invoke('checkout', { responseType: 'text' })
 if (error instanceof FunctionsRelayError) {
-  // rien n'a été exécuté côté fonction → réessayer est sûr
+  // panne de plateforme : 503 → rien n'a été exécuté, 504 → peut-être exécuté, vérifiez avant de rejouer
 } else if (error instanceof FunctionsHttpError) {
   // la fonction a bien tourné et a répondu en erreur → déboguer VOTRE code
 }
 isRelayStatus(error?.status ?? 0) // même décision, sans instanceof
 ```
 
-Une annulation (`timeout`/`signal`) reste une `AuraError` de code `timeout`, jamais une de ces deux classes.
+Une annulation (`timeout`/`signal`) reste une `AuraError` de code `timeout`, jamais une de ces deux classes. Sans `timeout` ni `signal`, le délai par défaut du client (`requestTimeoutMs`, 30 s) s'applique à tous les modes, `responseType` compris.
+
+Les segments passés à `invoke`, `get`, `getJob` et `deleteCronJob` sont encodés (`encodeURIComponent`) : un nom contenant `/`, `?` ou `#` ne peut pas sortir de sa position dans l'URL.
 
 ### Fonctions (métadonnées)
 
@@ -144,6 +154,14 @@ const { data: parNom } = await aura.functions.get('hello-world')
 ### Jobs asynchrones (extra vs `@supabase/functions-js`)
 
 ```ts
+// Enfiler un nouveau job d'exécution en arrière-plan
+const { data: jobInfo, error } = await aura.functions.enqueueJob('generate-report', {
+  payload: { month: '2026-10', sendEmail: true },
+  maxAttempts: 3,
+  delaySecs: 60, // exécuter dans 60 secondes
+})
+
+// Consulter les jobs
 const { data: jobs } = await aura.functions.listJobs({ status: 'pending', limit: 20 })
 const { data: job } = await aura.functions.getJob(jobs![0]!.id)
 ```
@@ -159,14 +177,19 @@ const { data: crons } = await aura.functions.listCronJobs()
 await aura.functions.deleteCronJob('nightly-cleanup')
 ```
 
+## Contrat d'invocation et comportement des erreurs
+
+- **Déballage transparent :** En mode `responseType: 'json'` (défaut), `data` contient directement le type attendu `T` renvoyé par votre fonction. Pour préserver la compatibilité avec le code existant lisant l'enveloppe, les propriétés `status` et `body` restent accessibles sur l'objet retourné.
+- **Propagation des erreurs HTTP applicatives :** Si votre fonction répond avec un statut HTTP supérieur ou égal à 400, le SDK renvoie une `FunctionsHttpError` avec le statut réel de votre fonction (`error.status`) et son message d'erreur, même lorsque le transport réseau sous-jacent utilise une enveloppe.
+- **Relais et disponibilité :** En cas d'indisponibilité du runtime ou de coupure réseau, une `FunctionsRelayError` est renvoyée.
+- **Propagation d'identité sécurisée :** Les en-têtes d'autorisation (`Authorization: Bearer <token>`, `apikey`) sont validés par la passerelle Aurabase et propagés de façon étanche vers le worker de la fonction (`x-aura-user-id`, `x-aura-role`), protégeant votre backend contre toute falsification client.
+
 ## Limitations
 
-- Pas de streaming de réponse : `invoke()` bufferise toujours l'intégralité du corps avant de résoudre (pas de lecture incrémentale, pas de réponse SSE/chunked exploitable). `responseType` change le DÉCODAGE du corps bufferisé, pas ce point.
-- Pas de sélection de région d'exécution.
-- `headers` est transmis à la fonction invoquée — ce ne sont pas des headers de transport HTTP (pas de contrôle sur ceux injectés par le pipeline : `apikey`, `Authorization`). La fonction ne voit QUE les en-têtes que vous passez (plus le `content-type` par défaut) : les en-têtes internes du transport ne lui sont pas exposés.
-- Le statut réel de la fonction n'est visible qu'avec un `responseType` autre que `'json'` : en mode `'json'` la réponse est enveloppée et le transport rend toujours HTTP 200 (le statut de la fonction est alors dans `data.status`).
-- Pas de `getCronJob()` ni `updateCronJob()` : seuls `listCronJobs`, `createCronJob` et `deleteCronJob` sont exposés. Pas de `deploy()` / `delete()` de fonction depuis le SDK : le déploiement passe par l'API HTTP, la CLI `aura functions deploy` ou le Studio.
-- `deleteCronJob(name)` et les routes `PATCH`/`DELETE`/`invoke` d'une fonction attendent un **nom** ; seul `get()` accepte aussi l'identifiant.
+- Pas de streaming de réponse : `invoke()` bufferise l'intégralité du corps avant de résoudre. `responseType` configure le décodage du corps (`json`, `text`, `blob`, `arrayBuffer`).
+- Pas de sélection de région d'exécution (exécution sur le cluster Edge actif).
+- Les en-têtes de cadrage de transport (`content-length`, `connection`, `host`, etc.) ne sont pas transmissibles à la fonction.
+- Pas de `getCronJob()` ni `updateCronJob()` : seuls `listCronJobs`, `createCronJob` et `deleteCronJob` sont exposés. Le déploiement s'effectue via le CLI `aura functions deploy` ou Aurabase Studio.
 
 ## Documentation
 

package/dist/index.cjs

@@ -29,6 +29,30 @@ function toFunctionsError(err, context) {
   const body = err.details != null ? err.details : { error: { code: err.code, message: err.message } };
   return isRelayStatus(err.status) ? new FunctionsRelayError(err.status, body, err.details) : new FunctionsHttpError(err.status, body, err.details);
 }
+var INVOKE_ORIGIN_HEADER = "x-aurabase-invoke-origin";
+var seg = encodeURIComponent;
+function unserializableBodyKind(body) {
+  if (body === null || typeof body !== "object") return null;
+  const g = globalThis;
+  for (const name of ["Blob", "FormData", "URLSearchParams", "ReadableStream"]) {
+    const ctor = g[name];
+    if (typeof ctor === "function" && body instanceof ctor) return name;
+  }
+  if (body instanceof ArrayBuffer) return "ArrayBuffer";
+  if (ArrayBuffer.isView(body)) return body.constructor.name;
+  return null;
+}
+function envelopeContentType(headers) {
+  if (headers === null || typeof headers !== "object") return void 0;
+  for (const [k, v] of Object.entries(headers)) {
+    if (k.toLowerCase() === "content-type" && typeof v === "string") return v.toLowerCase();
+  }
+  return void 0;
+}
+function isTextual(contentType) {
+  if (!contentType) return true;
+  return contentType.includes("json") || contentType.startsWith("text/") || contentType.includes("xml");
+}
 var FunctionsService = class extends core.BaseService {
   constructor(client) {
     super(client);
@@ -74,11 +98,26 @@ var FunctionsService = class extends core.BaseService {
    * `signal` produisent le code `timeout`.
    */
   async invoke(slug, options) {
+    const badBody = unserializableBodyKind(options?.body);
+    if (badBody) {
+      return {
+        data: null,
+        error: new core.AuraError(0, {
+          error: {
+            code: "invalid_body",
+            message: `Le corps d'invocation doit \xEAtre s\xE9rialisable en JSON (objet, tableau, cha\xEEne, nombre, bool\xE9en) : un ${badBody} serait transmis vide ou d\xE9form\xE9. Encodez-le (par exemple en base64) ou passez par Storage.`
+          }
+        })
+      };
+    }
+    const responseType = options?.responseType ?? "json";
     const controller = new AbortController();
     let timeoutId;
     const userSignal = options?.signal;
     const onAbort = () => controller.abort();
-    if (options?.timeout) timeoutId = setTimeout(() => controller.abort(), options.timeout);
+    const clientTimeout = this.client.requestTimeoutMs ?? core.DEFAULT_REQUEST_TIMEOUT_MS;
+    const timeoutMs = options?.timeout || (responseType !== "json" && userSignal === void 0 && clientTimeout > 0 ? clientTimeout : 0);
+    if (timeoutMs) timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     if (userSignal) {
       if (userSignal.aborted) controller.abort();
       else userSignal.addEventListener("abort", onAbort, { once: true });
@@ -93,7 +132,6 @@ var FunctionsService = class extends core.BaseService {
       headers: options?.headers,
       body: options?.body
     };
-    const responseType = options?.responseType ?? "json";
     const timeoutError = () => ({
       data: null,
       error: new core.AuraError(0, {
@@ -103,11 +141,63 @@ var FunctionsService = class extends core.BaseService {
     try {
       if (responseType === "json") {
         const hasCanceller = options?.timeout !== void 0 || userSignal !== void 0;
-        const res2 = await this.request("POST", `${this.prefix}/${slug}/invoke`, envelope, {
+        const res2 = await this.request("POST", `${this.prefix}/${seg(slug)}/invoke`, envelope, {
           ...hasCanceller ? { signal: controller.signal } : {}
         });
         if (res2.error && controller.signal.aborted) return timeoutError();
         if (res2.error) return { data: null, error: toFunctionsError(res2.error) };
+        const rawData = res2.data;
+        if (rawData && typeof rawData === "object" && "body" in rawData && "status" in rawData) {
+          const invokeStatus = rawData.status;
+          const invokeBody = rawData.body;
+          if (typeof invokeStatus === "number" && invokeStatus >= 400) {
+            const errPayload = typeof invokeBody === "object" && invokeBody !== null ? invokeBody : invokeBody === null || invokeBody === void 0 || invokeBody === "" ? {} : { message: typeof invokeBody === "string" ? invokeBody : JSON.stringify(invokeBody) };
+            const errorMsg = typeof errPayload.message === "string" ? errPayload.message : typeof errPayload.error === "string" ? errPayload.error : typeof errPayload.error?.message === "string" ? String(errPayload.error.message) : `Function returned HTTP ${invokeStatus}`;
+            const normalizedBody = {
+              ...errPayload,
+              message: errorMsg,
+              error: {
+                code: typeof errPayload.code === "string" ? errPayload.code : `http_${invokeStatus}`,
+                message: errorMsg
+              }
+            };
+            return {
+              data: null,
+              error: new FunctionsHttpError(invokeStatus, normalizedBody, invokeBody)
+            };
+          }
+          if (invokeBody === null && invokeStatus !== 204 && !isTextual(envelopeContentType(rawData.headers))) {
+            return {
+              data: null,
+              error: new core.AuraError(0, {
+                error: {
+                  code: "invalid_response",
+                  message: `La fonction a r\xE9pondu un contenu binaire (HTTP ${invokeStatus}) que le mode JSON ne peut pas transmettre : utilisez responseType 'blob' ou 'arrayBuffer'.`
+                }
+              })
+            };
+          }
+          const unwrappedData = invokeBody;
+          if (unwrappedData !== null && typeof unwrappedData === "object") {
+            if (!("body" in unwrappedData)) {
+              Object.defineProperty(unwrappedData, "body", {
+                value: unwrappedData,
+                enumerable: false,
+                writable: true,
+                configurable: true
+              });
+            }
+            if (!("status" in unwrappedData)) {
+              Object.defineProperty(unwrappedData, "status", {
+                value: invokeStatus,
+                enumerable: false,
+                writable: true,
+                configurable: true
+              });
+            }
+          }
+          return { data: unwrappedData, error: null, meta: res2.meta };
+        }
         return res2;
       }
       const client = this.client;
@@ -125,19 +215,34 @@ var FunctionsService = class extends core.BaseService {
       };
       if (store.token) headers["Authorization"] = `Bearer ${store.token}`;
       if (client.apiKey) headers["apikey"] = client.apiKey;
-      const res = await client.fetchFn(this.url(`${this.prefix}/${slug}/invoke`), {
+      const res = await client.fetchFn(this.url(`${this.prefix}/${seg(slug)}/invoke`), {
         method: "POST",
         headers,
         body: JSON.stringify(envelope),
         signal: controller.signal
       });
       if (!res.ok) {
+        let text = "";
+        try {
+          text = await res.text();
+        } catch (e) {
+          if (controller.signal.aborted || core.isAbortError(e)) throw e;
+        }
         let parsed = null;
         try {
-          parsed = await res.json();
+          parsed = text.trim() ? JSON.parse(text) : null;
         } catch {
         }
-        return { data: null, error: toFunctionsError(new core.AuraError(res.status, parsed)) };
+        const isObject = parsed !== null && typeof parsed === "object";
+        const stringError = isObject && typeof parsed.error === "string" ? parsed.error : void 0;
+        const body = isObject ? stringError !== void 0 && typeof parsed.message !== "string" ? { ...parsed, message: stringError } : parsed : text.trim() ? { message: text } : null;
+        if (res.headers.get(INVOKE_ORIGIN_HEADER) === "function") {
+          return {
+            data: null,
+            error: new FunctionsHttpError(res.status, body, isObject ? parsed : text || null)
+          };
+        }
+        return { data: null, error: toFunctionsError(new core.AuraError(res.status, body, res.headers)) };
       }
       let data;
       if (responseType === "text") data = await res.text();
@@ -171,7 +276,7 @@ var FunctionsService = class extends core.BaseService {
    * le NOM l'emporte. Une valeur qui n'est ni l'un ni l'autre produit un 404 qui le dit.
    */
   async get(nameOrId) {
-    return this.request("GET", `${this.prefix}/${nameOrId}`);
+    return this.request("GET", `${this.prefix}/${seg(nameOrId)}`);
   }
   // -- Jobs -------------------------------------------------------------------
   async listJobs(options) {
@@ -182,7 +287,30 @@ var FunctionsService = class extends core.BaseService {
     return this.request("GET", `${this.prefix}/jobs${qs}`);
   }
   async getJob(jobId) {
-    return this.request("GET", `${this.prefix}/jobs/${jobId}`);
+    return this.request("GET", `${this.prefix}/jobs/${seg(jobId)}`);
+  }
+  /**
+   * Enfile un job d'exécution asynchrone en arrière-plan pour une fonction.
+   *
+   * @param functionName Nom de la fonction à exécuter.
+   * @param options Paramètres optionnels : charge utile (`payload`), délai avant exécution (`delaySecs`)
+   *                et nombre maximum de tentatives (`maxAttempts`).
+   */
+  async enqueueJob(functionName, options) {
+    if (!functionName || typeof functionName !== "string" || functionName.trim() === "") {
+      return {
+        data: null,
+        error: new core.AuraError(400, {
+          error: { code: "bad_request", message: "Function name is required to enqueue a job" }
+        })
+      };
+    }
+    return this.request("POST", `${this.prefix}/jobs`, {
+      function_name: functionName.trim(),
+      payload: options?.payload,
+      delay_secs: options?.delaySecs,
+      max_attempts: options?.maxAttempts
+    });
   }
   // -- Cron -------------------------------------------------------------------
   async listCronJobs() {
@@ -197,7 +325,7 @@ var FunctionsService = class extends core.BaseService {
     });
   }
   async deleteCronJob(name) {
-    return this.request("DELETE", `${this.prefix}/cron/${name}`);
+    return this.request("DELETE", `${this.prefix}/cron/${seg(name)}`);
   }
 };
 

package/dist/index.d.cts

@@ -98,6 +98,18 @@ declare class FunctionsService extends BaseService {
         limit?: number;
     }): Promise<AuraResponse<Job[]>>;
     getJob(jobId: string): Promise<AuraResponse<Job>>;
+    /**
+     * Enfile un job d'exécution asynchrone en arrière-plan pour une fonction.
+     *
+     * @param functionName Nom de la fonction à exécuter.
+     * @param options Paramètres optionnels : charge utile (`payload`), délai avant exécution (`delaySecs`)
+     *                et nombre maximum de tentatives (`maxAttempts`).
+     */
+    enqueueJob(functionName: string, options?: {
+        payload?: unknown;
+        delaySecs?: number;
+        maxAttempts?: number;
+    }): Promise<AuraResponse<Job>>;
     listCronJobs(): Promise<AuraResponse<CronJob[]>>;
     createCronJob(name: string, schedule: string, functionName: string, options?: {
         payload?: unknown;

package/dist/index.d.ts

@@ -98,6 +98,18 @@ declare class FunctionsService extends BaseService {
         limit?: number;
     }): Promise<AuraResponse<Job[]>>;
     getJob(jobId: string): Promise<AuraResponse<Job>>;
+    /**
+     * Enfile un job d'exécution asynchrone en arrière-plan pour une fonction.
+     *
+     * @param functionName Nom de la fonction à exécuter.
+     * @param options Paramètres optionnels : charge utile (`payload`), délai avant exécution (`delaySecs`)
+     *                et nombre maximum de tentatives (`maxAttempts`).
+     */
+    enqueueJob(functionName: string, options?: {
+        payload?: unknown;
+        delaySecs?: number;
+        maxAttempts?: number;
+    }): Promise<AuraResponse<Job>>;
     listCronJobs(): Promise<AuraResponse<CronJob[]>>;
     createCronJob(name: string, schedule: string, functionName: string, options?: {
         payload?: unknown;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { AuraError, BaseService, isTokenExpired, refreshOnce, isAbortError } from '@aurabase/core';
+import { AuraError, BaseService, DEFAULT_REQUEST_TIMEOUT_MS, isTokenExpired, refreshOnce, isAbortError } from '@aurabase/core';
 
 // src/errors.ts
 var RELAY_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
@@ -27,6 +27,30 @@ function toFunctionsError(err, context) {
   const body = err.details != null ? err.details : { error: { code: err.code, message: err.message } };
   return isRelayStatus(err.status) ? new FunctionsRelayError(err.status, body, err.details) : new FunctionsHttpError(err.status, body, err.details);
 }
+var INVOKE_ORIGIN_HEADER = "x-aurabase-invoke-origin";
+var seg = encodeURIComponent;
+function unserializableBodyKind(body) {
+  if (body === null || typeof body !== "object") return null;
+  const g = globalThis;
+  for (const name of ["Blob", "FormData", "URLSearchParams", "ReadableStream"]) {
+    const ctor = g[name];
+    if (typeof ctor === "function" && body instanceof ctor) return name;
+  }
+  if (body instanceof ArrayBuffer) return "ArrayBuffer";
+  if (ArrayBuffer.isView(body)) return body.constructor.name;
+  return null;
+}
+function envelopeContentType(headers) {
+  if (headers === null || typeof headers !== "object") return void 0;
+  for (const [k, v] of Object.entries(headers)) {
+    if (k.toLowerCase() === "content-type" && typeof v === "string") return v.toLowerCase();
+  }
+  return void 0;
+}
+function isTextual(contentType) {
+  if (!contentType) return true;
+  return contentType.includes("json") || contentType.startsWith("text/") || contentType.includes("xml");
+}
 var FunctionsService = class extends BaseService {
   constructor(client) {
     super(client);
@@ -72,11 +96,26 @@ var FunctionsService = class extends BaseService {
    * `signal` produisent le code `timeout`.
    */
   async invoke(slug, options) {
+    const badBody = unserializableBodyKind(options?.body);
+    if (badBody) {
+      return {
+        data: null,
+        error: new AuraError(0, {
+          error: {
+            code: "invalid_body",
+            message: `Le corps d'invocation doit \xEAtre s\xE9rialisable en JSON (objet, tableau, cha\xEEne, nombre, bool\xE9en) : un ${badBody} serait transmis vide ou d\xE9form\xE9. Encodez-le (par exemple en base64) ou passez par Storage.`
+          }
+        })
+      };
+    }
+    const responseType = options?.responseType ?? "json";
     const controller = new AbortController();
     let timeoutId;
     const userSignal = options?.signal;
     const onAbort = () => controller.abort();
-    if (options?.timeout) timeoutId = setTimeout(() => controller.abort(), options.timeout);
+    const clientTimeout = this.client.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    const timeoutMs = options?.timeout || (responseType !== "json" && userSignal === void 0 && clientTimeout > 0 ? clientTimeout : 0);
+    if (timeoutMs) timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     if (userSignal) {
       if (userSignal.aborted) controller.abort();
       else userSignal.addEventListener("abort", onAbort, { once: true });
@@ -91,7 +130,6 @@ var FunctionsService = class extends BaseService {
       headers: options?.headers,
       body: options?.body
     };
-    const responseType = options?.responseType ?? "json";
     const timeoutError = () => ({
       data: null,
       error: new AuraError(0, {
@@ -101,11 +139,63 @@ var FunctionsService = class extends BaseService {
     try {
       if (responseType === "json") {
         const hasCanceller = options?.timeout !== void 0 || userSignal !== void 0;
-        const res2 = await this.request("POST", `${this.prefix}/${slug}/invoke`, envelope, {
+        const res2 = await this.request("POST", `${this.prefix}/${seg(slug)}/invoke`, envelope, {
           ...hasCanceller ? { signal: controller.signal } : {}
         });
         if (res2.error && controller.signal.aborted) return timeoutError();
         if (res2.error) return { data: null, error: toFunctionsError(res2.error) };
+        const rawData = res2.data;
+        if (rawData && typeof rawData === "object" && "body" in rawData && "status" in rawData) {
+          const invokeStatus = rawData.status;
+          const invokeBody = rawData.body;
+          if (typeof invokeStatus === "number" && invokeStatus >= 400) {
+            const errPayload = typeof invokeBody === "object" && invokeBody !== null ? invokeBody : invokeBody === null || invokeBody === void 0 || invokeBody === "" ? {} : { message: typeof invokeBody === "string" ? invokeBody : JSON.stringify(invokeBody) };
+            const errorMsg = typeof errPayload.message === "string" ? errPayload.message : typeof errPayload.error === "string" ? errPayload.error : typeof errPayload.error?.message === "string" ? String(errPayload.error.message) : `Function returned HTTP ${invokeStatus}`;
+            const normalizedBody = {
+              ...errPayload,
+              message: errorMsg,
+              error: {
+                code: typeof errPayload.code === "string" ? errPayload.code : `http_${invokeStatus}`,
+                message: errorMsg
+              }
+            };
+            return {
+              data: null,
+              error: new FunctionsHttpError(invokeStatus, normalizedBody, invokeBody)
+            };
+          }
+          if (invokeBody === null && invokeStatus !== 204 && !isTextual(envelopeContentType(rawData.headers))) {
+            return {
+              data: null,
+              error: new AuraError(0, {
+                error: {
+                  code: "invalid_response",
+                  message: `La fonction a r\xE9pondu un contenu binaire (HTTP ${invokeStatus}) que le mode JSON ne peut pas transmettre : utilisez responseType 'blob' ou 'arrayBuffer'.`
+                }
+              })
+            };
+          }
+          const unwrappedData = invokeBody;
+          if (unwrappedData !== null && typeof unwrappedData === "object") {
+            if (!("body" in unwrappedData)) {
+              Object.defineProperty(unwrappedData, "body", {
+                value: unwrappedData,
+                enumerable: false,
+                writable: true,
+                configurable: true
+              });
+            }
+            if (!("status" in unwrappedData)) {
+              Object.defineProperty(unwrappedData, "status", {
+                value: invokeStatus,
+                enumerable: false,
+                writable: true,
+                configurable: true
+              });
+            }
+          }
+          return { data: unwrappedData, error: null, meta: res2.meta };
+        }
         return res2;
       }
       const client = this.client;
@@ -123,19 +213,34 @@ var FunctionsService = class extends BaseService {
       };
       if (store.token) headers["Authorization"] = `Bearer ${store.token}`;
       if (client.apiKey) headers["apikey"] = client.apiKey;
-      const res = await client.fetchFn(this.url(`${this.prefix}/${slug}/invoke`), {
+      const res = await client.fetchFn(this.url(`${this.prefix}/${seg(slug)}/invoke`), {
         method: "POST",
         headers,
         body: JSON.stringify(envelope),
         signal: controller.signal
       });
       if (!res.ok) {
+        let text = "";
+        try {
+          text = await res.text();
+        } catch (e) {
+          if (controller.signal.aborted || isAbortError(e)) throw e;
+        }
         let parsed = null;
         try {
-          parsed = await res.json();
+          parsed = text.trim() ? JSON.parse(text) : null;
         } catch {
         }
-        return { data: null, error: toFunctionsError(new AuraError(res.status, parsed)) };
+        const isObject = parsed !== null && typeof parsed === "object";
+        const stringError = isObject && typeof parsed.error === "string" ? parsed.error : void 0;
+        const body = isObject ? stringError !== void 0 && typeof parsed.message !== "string" ? { ...parsed, message: stringError } : parsed : text.trim() ? { message: text } : null;
+        if (res.headers.get(INVOKE_ORIGIN_HEADER) === "function") {
+          return {
+            data: null,
+            error: new FunctionsHttpError(res.status, body, isObject ? parsed : text || null)
+          };
+        }
+        return { data: null, error: toFunctionsError(new AuraError(res.status, body, res.headers)) };
       }
       let data;
       if (responseType === "text") data = await res.text();
@@ -169,7 +274,7 @@ var FunctionsService = class extends BaseService {
    * le NOM l'emporte. Une valeur qui n'est ni l'un ni l'autre produit un 404 qui le dit.
    */
   async get(nameOrId) {
-    return this.request("GET", `${this.prefix}/${nameOrId}`);
+    return this.request("GET", `${this.prefix}/${seg(nameOrId)}`);
   }
   // -- Jobs -------------------------------------------------------------------
   async listJobs(options) {
@@ -180,7 +285,30 @@ var FunctionsService = class extends BaseService {
     return this.request("GET", `${this.prefix}/jobs${qs}`);
   }
   async getJob(jobId) {
-    return this.request("GET", `${this.prefix}/jobs/${jobId}`);
+    return this.request("GET", `${this.prefix}/jobs/${seg(jobId)}`);
+  }
+  /**
+   * Enfile un job d'exécution asynchrone en arrière-plan pour une fonction.
+   *
+   * @param functionName Nom de la fonction à exécuter.
+   * @param options Paramètres optionnels : charge utile (`payload`), délai avant exécution (`delaySecs`)
+   *                et nombre maximum de tentatives (`maxAttempts`).
+   */
+  async enqueueJob(functionName, options) {
+    if (!functionName || typeof functionName !== "string" || functionName.trim() === "") {
+      return {
+        data: null,
+        error: new AuraError(400, {
+          error: { code: "bad_request", message: "Function name is required to enqueue a job" }
+        })
+      };
+    }
+    return this.request("POST", `${this.prefix}/jobs`, {
+      function_name: functionName.trim(),
+      payload: options?.payload,
+      delay_secs: options?.delaySecs,
+      max_attempts: options?.maxAttempts
+    });
   }
   // -- Cron -------------------------------------------------------------------
   async listCronJobs() {
@@ -195,7 +323,7 @@ var FunctionsService = class extends BaseService {
     });
   }
   async deleteCronJob(name) {
-    return this.request("DELETE", `${this.prefix}/cron/${name}`);
+    return this.request("DELETE", `${this.prefix}/cron/${seg(name)}`);
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aurabase/functions",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Service edge functions du SDK Aurabase (invoke, jobs asynchrones, cron)",
   "type": "module",
   "main": "dist/index.cjs",
@@ -45,7 +45,7 @@
     "functions"
   ],
   "dependencies": {
-    "@aurabase/core": "0.5.3"
+    "@aurabase/core": "0.6.0"
   },
   "devDependencies": {
     "@types/node": "20.14.15",