@aurabase/aurabase-js 0.3.0 → 0.4.0

package/packages/db/tests/types/from-views.test-d.ts

@@ -1,18 +0,0 @@
-import { expectTypeOf } from 'vitest'
-import { DatabaseService } from '../../src/DatabaseService'
-import type { Database } from './fixtures'
-
-declare const db: DatabaseService<Database>
-
-// COMPL LOT 4 : `from()` accepte les Views (générées par LOT C), pas seulement les
-// Tables. La vue `active_users` est non updatable → uniquement queryable en lecture.
-
-test('from(view).select(col) compile et infère le Row de la vue', async () => {
-  const { data } = await db.from('active_users').select('email')
-  expectTypeOf(data).toEqualTypeOf<{ email: string }[] | null>()
-})
-
-test('from(view).select(*) → Row complète de la vue', async () => {
-  const { data } = await db.from('active_users').select('*')
-  expectTypeOf(data).toEqualTypeOf<{ id: string; email: string }[] | null>()
-})

package/packages/db/tests/types/mutations.test-d.ts

@@ -1,23 +0,0 @@
-import { DatabaseService } from '../../src/DatabaseService'
-import type { Database } from './fixtures'
-
-declare const db: DatabaseService<Database>
-
-test('insert exige les champs requis', () => {
-  db.from('posts').insert({ author_id: 'u', title: 't' }) // OK (id optionnel)
-  // @ts-expect-error title requis manquant
-  db.from('posts').insert({ author_id: 'u' })
-})
-
-test('update accepte un body partiel typé', () => {
-  db.from('posts').update('id1', { title: 'new' }) // OK
-  // @ts-expect-error colonne inconnue
-  db.from('posts').update('id1', { nope: 1 })
-})
-
-test('upsert typé sur Insert (array ou objet)', () => {
-  db.from('posts').upsert({ author_id: 'u', title: 't' }) // OK
-  db.from('posts').upsert([{ author_id: 'u', title: 't' }]) // OK
-  // @ts-expect-error title requis manquant
-  db.from('posts').upsert({ author_id: 'u' })
-})

package/packages/db/tests/types/rpc.test-d.ts

@@ -1,60 +0,0 @@
-import { expectTypeOf } from 'vitest'
-import { DatabaseService } from '../../src/DatabaseService'
-
-// Fixture Database locale avec une fonction scalaire et une fonction SETOF liée
-// à une table (parité avec la sortie attendue de `@aurabase/gen` Phase B).
-type DB = {
-  public: {
-    Tables: {
-      things: {
-        Row: { id: number; name: string }
-        Insert: { id?: number; name: string }
-        Update: { id?: number; name?: string }
-        Relationships: []
-      }
-    }
-    Views: Record<string, never>
-    Functions: {
-      add: { Args: { a: number; b: number }; Returns: number }
-      list_things: {
-        Args: Record<string, never>
-        Returns: { id: number; name: string }[]
-        SetofOptions: { isSetofReturn: true; isOneToOne: false; to: 'things'; from: '*' }
-      }
-    }
-    Enums: Record<string, never>
-    CompositeTypes: Record<string, never>
-  }
-}
-
-declare const db: DatabaseService<DB>
-// Fallback permissif : Database = any (comportement historique conservé).
-declare const untyped: DatabaseService
-
-test('rpc fort : args typés sur Schema["Functions"]', () => {
-  db.rpc('add', { a: 1, b: 2 }) // OK
-  // @ts-expect-error mauvais type d'arg (a doit être number)
-  db.rpc('add', { a: 'x', b: 2 })
-})
-
-test('rpc SETOF : select post-rpc typé sur la table liée (SetofOptions.to)', async () => {
-  const { data } = await db.rpc('list_things', {}).select('id,name').single()
-  expectTypeOf(data).toMatchTypeOf<{ id: number; name: string } | null>()
-})
-
-// Verrouille le fix #1 (double-emballage) : `Fn['Result']` est DÉJÀ la charge
-// utile complète (scalaire pour une fonction scalaire, tableau pour un SETOF)
-// — le 5e générique du builder ne doit PAS ajouter un `[]` par-dessus.
-test('rpc fort : retour scalaire (Result), pas de sur-emballage en tableau', async () => {
-  const { data } = await db.rpc('add', { a: 1, b: 2 })
-  expectTypeOf(data).toEqualTypeOf<number | null>()
-})
-
-test('rpc SETOF sans .select() : Result est déjà un tableau (pas `[][]`)', async () => {
-  const { data } = await db.rpc('list_things', {})
-  expectTypeOf(data).toEqualTypeOf<{ id: number; name: string }[] | null>()
-})
-
-test('rpc fallback permissif (Database = any)', () => {
-  untyped.rpc('whatever', { anything: true }) // OK, pas d'erreur de compilation
-})

package/packages/db/tests/types/schema-shape.test-d.ts

@@ -1,8 +0,0 @@
-import { expectTypeOf } from 'vitest'
-import type { GenericSchema } from '../../src/pgrst-types/common/common'
-import type { Database } from './fixtures'
-
-// Un Database à la forme générée par @aurabase/gen (Phase 1) doit satisfaire GenericSchema.
-test('le Database généré satisfait GenericSchema', () => {
-  expectTypeOf<Database['public']>().toMatchTypeOf<GenericSchema>()
-})

package/packages/db/tests/types/select-inference.test-d.ts

@@ -1,38 +0,0 @@
-import { expectTypeOf } from 'vitest'
-import { DatabaseService } from '../../src/DatabaseService'
-import type { Database } from './fixtures'
-
-declare const db: DatabaseService<Database>
-
-test('select colonnes → type restreint', async () => {
-  const { data } = await db.from('users').select('id, email')
-  expectTypeOf(data).toEqualTypeOf<{ id: string; email: string }[] | null>()
-})
-
-test('select embed many-to-one → objet imbriqué', async () => {
-  // Contrat postgrest-js : la FK `posts.author_id` étant NOT NULL dans la Row,
-  // l'embed many-to-one est non nullable (deviendrait `| null` si author_id: string | null).
-  const { data } = await db.from('posts').select('title, author:users(email)')
-  expectTypeOf(data).toEqualTypeOf<{ title: string; author: { email: string } }[] | null>()
-})
-
-test('single() → objet | null', async () => {
-  const { data } = await db.from('users').select('id').single()
-  expectTypeOf(data).toEqualTypeOf<{ id: string } | null>()
-})
-
-test('maybeSingle() → objet | null', async () => {
-  const { data } = await db.from('users').select('email').maybeSingle()
-  expectTypeOf(data).toEqualTypeOf<{ email: string } | null>()
-})
-
-test('select * → Row complète', async () => {
-  const { data } = await db.from('users').select('*')
-  expectTypeOf(data).toEqualTypeOf<{ id: string; email: string; bio: string | null }[] | null>()
-})
-
-test("client non typé (Database = any) → data permissif, pas d'erreur de compilation", async () => {
-  const untyped = db as unknown as DatabaseService
-  const { data } = await untyped.from('whatever').select('a, b')
-  expectTypeOf(data).not.toBeNever()
-})

package/packages/db/tests/vendored/fixtures.ts

@@ -1,83 +0,0 @@
-// LOT 6 (I7 — vendoré sans tests type-level) : fixture dédiée aux tests de
-// régression sur le code vendoré (`select-query-parser/*`, `pgrst-types/*`).
-// Volontairement distincte de `tests/types/fixtures.ts` (utilisé par les tests
-// de `DatabaseService`/`QueryBuilder`) : celle-ci couvre en plus le cas
-// one-to-many (tableau) et un embed imbriqué sur 2 niveaux, nécessaires pour
-// tester `GetResult` directement (voir `get-result.test-d.ts`).
-export interface Database {
-  public: {
-    Tables: {
-      users: {
-        Row: { id: string; email: string }
-        Insert: { id?: string; email: string }
-        Update: { id?: string; email?: string }
-        Relationships: []
-      }
-      // many-to-one NOT NULL : posts.author_id -> users.id
-      posts: {
-        Row: { id: string; author_id: string; title: string }
-        Insert: { id?: string; author_id: string; title: string }
-        Update: { id?: string; author_id?: string; title?: string }
-        Relationships: [
-          {
-            foreignKeyName: 'posts_author_id_fkey'
-            columns: ['author_id']
-            isOneToOne: false
-            referencedRelation: 'users'
-            referencedColumns: ['id']
-          },
-        ]
-      }
-      // many-to-one NULLABLE : reviews.reviewer_id -> users.id (nullable)
-      reviews: {
-        Row: { id: string; reviewer_id: string | null; comment: string }
-        Insert: { id?: string; reviewer_id?: string | null; comment: string }
-        Update: { id?: string; reviewer_id?: string | null; comment?: string }
-        Relationships: [
-          {
-            foreignKeyName: 'reviews_reviewer_id_fkey'
-            columns: ['reviewer_id']
-            isOneToOne: false
-            referencedRelation: 'users'
-            referencedColumns: ['id']
-          },
-        ]
-      }
-      // one-to-many (côté "many") : comments.post_id -> posts.id NOT NULL.
-      // Embedder `comments` DEPUIS `posts` donne un tableau (voir get-result.test-d.ts).
-      comments: {
-        Row: { id: string; post_id: string; body: string }
-        Insert: { id?: string; post_id: string; body: string }
-        Update: { id?: string; post_id?: string; body?: string }
-        Relationships: [
-          {
-            foreignKeyName: 'comments_post_id_fkey'
-            columns: ['post_id']
-            isOneToOne: false
-            referencedRelation: 'posts'
-            referencedColumns: ['id']
-          },
-        ]
-      }
-      // 2e niveau d'imbrication pour l'embed profond : replies.comment_id -> comments.id.
-      replies: {
-        Row: { id: string; comment_id: string; text: string }
-        Insert: { id?: string; comment_id: string; text: string }
-        Update: { id?: string; comment_id?: string; text?: string }
-        Relationships: [
-          {
-            foreignKeyName: 'replies_comment_id_fkey'
-            columns: ['comment_id']
-            isOneToOne: false
-            referencedRelation: 'comments'
-            referencedColumns: ['id']
-          },
-        ]
-      }
-    }
-    Views: Record<string, never>
-    Functions: Record<string, never>
-    Enums: Record<string, never>
-    CompositeTypes: Record<string, never>
-  }
-}

package/packages/db/tests/vendored/get-result.test-d.ts

@@ -1,75 +0,0 @@
-// LOT 6 (I7 — vendoré sans tests type-level) : régression de forme sur le
-// résolveur vendoré (`GetResult`, `select-query-parser/*`), testé ICI
-// directement (pas via `DatabaseService`/`QueryBuilder`) pour détecter une
-// régression de comportement dès le prochain resync (voir VENDORED.md),
-// indépendamment de l'évolution du reste du query builder.
-//
-// Couvre les trois formes d'embed dont la nullabilité/l'arité diffère :
-// - many-to-one NOT NULL  → objet non-null
-// - many-to-one NULLABLE  → objet | null
-// - one-to-many           → tableau
-// … plus l'aliasing (colonne scalaire + clé d'embed) et un embed imbriqué sur
-// 2 niveaux (tableau de tableaux correctement typé).
-import { expectTypeOf } from 'vitest'
-import type { GetResult } from '../../src/select-query-parser/result'
-import type { Database } from './fixtures'
-
-type Public = Database['public']
-// Même pin que `AuraClientOptionsT` (src/QueryBuilder.ts) — voir VENDORED.md
-// « PostgrestVersion figé à '12' ».
-type ClientOpts = { PostgrestVersion: '12' }
-
-type PostsRow = Public['Tables']['posts']['Row']
-type PostsRel = Public['Tables']['posts']['Relationships']
-type ReviewsRow = Public['Tables']['reviews']['Row']
-type ReviewsRel = Public['Tables']['reviews']['Relationships']
-
-test('embed many-to-one NOT NULL (posts.author_id -> users, NOT NULL) → objet non-null, clé aliasée', () => {
-  type Result = GetResult<Public, PostsRow, 'posts', PostsRel, '*, author:users(email)', ClientOpts>
-  expectTypeOf<Result>().toEqualTypeOf<{
-    id: string
-    author_id: string
-    title: string
-    author: { email: string }
-  }>()
-})
-
-test('embed many-to-one NULLABLE (reviews.reviewer_id -> users, nullable) → objet | null', () => {
-  type Result = GetResult<Public, ReviewsRow, 'reviews', ReviewsRel, '*, reviewer:users(email)', ClientOpts>
-  expectTypeOf<Result>().toEqualTypeOf<{
-    id: string
-    reviewer_id: string | null
-    comment: string
-    reviewer: { email: string } | null
-  }>()
-})
-
-test('embed one-to-many (posts -> comments, comments.post_id -> posts) → tableau', () => {
-  type Result = GetResult<Public, PostsRow, 'posts', PostsRel, '*, comments(*)', ClientOpts>
-  expectTypeOf<Result>().toEqualTypeOf<{
-    id: string
-    author_id: string
-    title: string
-    comments: { id: string; post_id: string; body: string }[]
-  }>()
-})
-
-test('alias sur colonne scalaire', () => {
-  type Result = GetResult<Public, PostsRow, 'posts', PostsRel, 'renamedTitle:title', ClientOpts>
-  expectTypeOf<Result>().toEqualTypeOf<{ renamedTitle: string }>()
-})
-
-test('embed imbriqué 2 niveaux (posts -> comments -> replies) → forme correcte (tableau de tableaux)', () => {
-  type Result = GetResult<Public, PostsRow, 'posts', PostsRel, '*, comments(*, replies(*))', ClientOpts>
-  expectTypeOf<Result>().toEqualTypeOf<{
-    id: string
-    author_id: string
-    title: string
-    comments: {
-      id: string
-      post_id: string
-      body: string
-      replies: { id: string; comment_id: string; text: string }[]
-    }[]
-  }>()
-})

package/packages/db/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": { "outDir": "dist", "rootDir": "src" },
-  "include": ["src"]
-}

package/packages/db/tsconfig.test-d.json

@@ -1,5 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": { "noEmit": true, "rootDir": "." },
-  "include": ["src", "tests/**/*.test-d.ts"]
-}

package/packages/db/tsup.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['cjs', 'esm'],
-  dts: true,
-  splitting: false,
-  clean: true,
-  treeshake: true,
-  minify: false,
-})

package/packages/db/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    typecheck: { enabled: true, include: ['tests/**/*.test-d.ts'] },
-    include: ['tests/**/*.test.ts'],
-  },
-})

package/packages/functions/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Aurabase
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/packages/functions/README.md

@@ -1,96 +0,0 @@
-# @aurabase/functions
-
-Service d'invocation d'edge functions du SDK Aurabase : appel de fonctions avec enveloppe routée (méthode/chemin/headers), jobs asynchrones et cron.
-
-![npm](https://img.shields.io/npm/v/@aurabase/functions) ![license](https://img.shields.io/badge/license-MIT-blue)
-
-> Pre-release — pas encore publié sur npm.
-
-Fait partie du SDK **[aurabase](../aurabase)**. Installé automatiquement avec `aurabase` ; ce package est publié séparément pour un usage ciblé / tree-shaking.
-
-## Installation
-
-```bash
-npm i @aurabase/functions
-```
-
-> Ce package dépend de `@aurabase/core` (`workspace:*` en interne, résolu en semver côté npm). Si vous utilisez déjà le package `aurabase`, `@aurabase/functions` est déjà inclus — cette installation ciblée n'est utile que pour composer votre propre client ou limiter la taille du bundle.
-
-## Usage
-
-Dans l'usage courant, `FunctionsService` n'est jamais instancié directement : il est exposé par le client principal sous `aura.functions`.
-
-```ts
-import { createClient } from 'aurabase'
-
-const aura = createClient('http://localhost:8080', 'my-project', 'aura_anon_xxx')
-```
-
-### Invocation
-
-`invoke<T>()` enveloppe la requête (`{ method, path, headers, body }`) et dé-wrap la réponse JSON du backend — tout est bufferisé, pas de streaming (voir Limitations).
-
-```ts
-const { data, error } = await aura.functions.invoke<{ ok: boolean }>('hello-world', {
-  body: { name: 'Ada' },
-})
-
-if (error) throw error
-console.log(data!.ok)
-```
-
-Options complètes : `method`, `path` (sous-route à l'intérieur de la fonction), `headers` (transmis à la fonction elle-même, pas des headers de transport), `signal`, `timeout`.
-
-```ts
-const controller = new AbortController()
-
-const { error } = await aura.functions.invoke('slow-job', {
-  method: 'POST',
-  path: '/process',
-  headers: { 'x-request-source': 'studio' },
-  timeout: 5000, // ms — annule automatiquement au-delà
-  signal: controller.signal, // ou : annulation manuelle via controller.abort()
-})
-
-// Une annulation (timeout ou signal) remonte toujours en AuraError code 'timeout'.
-if (error?.code === 'timeout') {
-  console.warn('invocation annulée ou trop lente')
-}
-```
-
-### Fonctions (métadonnées)
-
-```ts
-const { data: fns } = await aura.functions.list()
-const { data: fn } = await aura.functions.get(fns![0]!.id)
-```
-
-### Jobs asynchrones (extra vs `@supabase/functions-js`)
-
-```ts
-const { data: jobs } = await aura.functions.listJobs({ status: 'pending', limit: 20 })
-const { data: job } = await aura.functions.getJob(jobs![0]!.id)
-```
-
-### Cron (extra vs `@supabase/functions-js`)
-
-```ts
-await aura.functions.createCronJob('nightly-cleanup', '0 3 * * *', 'cleanup-fn', {
-  payload: { dryRun: false },
-})
-
-const { data: crons } = await aura.functions.listCronJobs()
-await aura.functions.deleteCronJob('nightly-cleanup')
-```
-
-## Limitations
-
-- Pas de streaming de réponse : `invoke()` bufferise toujours l'intégralité du corps JSON avant de résoudre (pas de lecture incrémentale, pas de réponse SSE/chunked exploitable).
-- Pas de `responseType` (`json`/`text`/`blob`) : la réponse est toujours parsée comme JSON puis dé-wrappée (`{data}` → contenu).
-- Pas de sélection de région d'exécution.
-- `headers` est transmis tel quel à 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`, `Content-Type`).
-- Pas de `getCronJob()` ni `updateCronJob()` : seuls `listCronJobs`, `createCronJob` et `deleteCronJob` sont exposés.
-
-## Documentation
-
-Référence complète du SDK (tous les services, types partagés, SSR) : [README racine](../../README.md).

package/packages/functions/dist/index.cjs

@@ -1,173 +0,0 @@
-'use strict';
-
-var core = require('@aurabase/core');
-
-// src/FunctionsService.ts
-var RELAY_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
-function isRelayStatus(status) {
-  return status === 0 || RELAY_STATUSES.has(status);
-}
-var FunctionsHttpError = class _FunctionsHttpError extends core.AuraError {
-  context;
-  constructor(status, body, context) {
-    super(status, body);
-    this.name = "FunctionsHttpError";
-    this.context = context;
-    Object.setPrototypeOf(this, _FunctionsHttpError.prototype);
-  }
-};
-var FunctionsRelayError = class _FunctionsRelayError extends core.AuraError {
-  context;
-  constructor(status, body, context) {
-    super(status, body);
-    this.name = "FunctionsRelayError";
-    this.context = context;
-    Object.setPrototypeOf(this, _FunctionsRelayError.prototype);
-  }
-};
-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);
-}
-
-// src/FunctionsService.ts
-var FunctionsService = class extends core.BaseService {
-  constructor(client) {
-    super(client);
-  }
-  get prefix() {
-    return `/v1/functions/${this.client.projectId}`;
-  }
-  // -- Function invocation ----------------------------------------------------
-  /**
-   * Invoque une edge function.
-   *
-   * `responseType` (parité `@supabase/functions-js`, défaut `'json'`) :
-   *  - `'json'` : chemin PIPELINE inchangé (refresh proactif centralisé, injection
-   *    apikey/Authorization, dé-wrapping `{data,meta}`, retryConfig). Non-régression.
-   *  - `'text' | 'blob' | 'arrayBuffer'` : chemin TRANSPORT BRUT `client.fetchFn`
-   *    (patron `StorageService`, SANS toucher `core/fetch.ts`) — refresh proactif
-   *    manuel, pose de `Authorization`/`apikey`, puis `res.text()/blob()/arrayBuffer()`
-   *    sans dé-wrapping (le corps HTTP est renvoyé tel quel).
-   *
-   * Erreurs typées (parité) : une réponse HTTP non-2xx → `FunctionsHttpError`, une
-   * panne de relais/infra (réseau, 502/503/504) → `FunctionsRelayError` ; les deux
-   * sous-classent `AuraError` (rétrocompat `isAuraError`/champ `error`). `timeout`/
-   * `signal` continuent de produire le code `timeout`.
-   */
-  async invoke(slug, options) {
-    const controller = new AbortController();
-    let timeoutId;
-    const userSignal = options?.signal;
-    const onAbort = () => controller.abort();
-    if (options?.timeout) timeoutId = setTimeout(() => controller.abort(), options.timeout);
-    if (userSignal) {
-      if (userSignal.aborted) controller.abort();
-      else userSignal.addEventListener("abort", onAbort, { once: true });
-    }
-    const cleanup = () => {
-      if (timeoutId) clearTimeout(timeoutId);
-      if (userSignal) userSignal.removeEventListener("abort", onAbort);
-    };
-    const envelope = { method: options?.method, path: options?.path, headers: options?.headers, body: options?.body };
-    const responseType = options?.responseType ?? "json";
-    const timeoutError = () => ({
-      data: null,
-      error: new core.AuraError(0, {
-        error: { code: "timeout", message: "Function invocation aborted or timed out" }
-      })
-    });
-    try {
-      if (responseType === "json") {
-        const res2 = await this.request("POST", `${this.prefix}/${slug}/invoke`, envelope, {
-          signal: controller.signal
-        });
-        if (res2.error && controller.signal.aborted) return timeoutError();
-        if (res2.error) return { data: null, error: toFunctionsError(res2.error) };
-        return res2;
-      }
-      const client = this.client;
-      const store = client.authStore;
-      if (store.token && store.refreshToken && core.isTokenExpired(store.token, 30)) {
-        await core.refreshOnce(client);
-      }
-      const headers = {
-        "Content-Type": "application/json",
-        // Négocie le mode passthrough côté backend : réponse HTTP BRUTE (statut réel de la
-        // fonction + content-type réel + corps brut) au lieu de l'enveloppe `{data,meta}`.
-        // Indispensable pour que `res.text()/blob()/arrayBuffer()` reçoive le corps de la
-        // fonction (et non l'enveloppe JSON) et que `res.status` porte le statut fonction.
-        "X-Aurabase-Invoke-Mode": "raw"
-      };
-      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`), {
-        method: "POST",
-        headers,
-        body: JSON.stringify(envelope),
-        signal: controller.signal
-      });
-      if (!res.ok) {
-        let parsed = null;
-        try {
-          parsed = await res.json();
-        } catch {
-        }
-        return { data: null, error: toFunctionsError(new core.AuraError(res.status, parsed)) };
-      }
-      let data;
-      if (responseType === "text") data = await res.text();
-      else if (responseType === "blob") data = await res.blob();
-      else data = await res.arrayBuffer();
-      return { data, error: null };
-    } catch (err) {
-      if (controller.signal.aborted || core.isAbortError(err)) return timeoutError();
-      return {
-        data: null,
-        error: new FunctionsRelayError(0, {
-          error: { code: "network_error", message: err instanceof Error ? err.message : "Function relay error" }
-        })
-      };
-    } finally {
-      cleanup();
-    }
-  }
-  // -- Function CRUD ----------------------------------------------------------
-  async list() {
-    return this.request("GET", `${this.prefix}`);
-  }
-  async get(id) {
-    return this.request("GET", `${this.prefix}/${id}`);
-  }
-  // -- Jobs -------------------------------------------------------------------
-  async listJobs(options) {
-    const params = new URLSearchParams();
-    if (options?.status) params.set("status", options.status);
-    if (options?.limit !== void 0) params.set("limit", String(options.limit));
-    const qs = params.toString() ? `?${params.toString()}` : "";
-    return this.request("GET", `${this.prefix}/jobs${qs}`);
-  }
-  async getJob(jobId) {
-    return this.request("GET", `${this.prefix}/jobs/${jobId}`);
-  }
-  // -- Cron -------------------------------------------------------------------
-  async listCronJobs() {
-    return this.request("GET", `${this.prefix}/cron`);
-  }
-  async createCronJob(name, schedule, functionName, options) {
-    return this.request("POST", `${this.prefix}/cron`, {
-      name,
-      schedule,
-      function_name: functionName,
-      payload: options?.payload
-    });
-  }
-  async deleteCronJob(name) {
-    return this.request("DELETE", `${this.prefix}/cron/${name}`);
-  }
-};
-
-exports.FunctionsHttpError = FunctionsHttpError;
-exports.FunctionsRelayError = FunctionsRelayError;
-exports.FunctionsService = FunctionsService;
-exports.isRelayStatus = isRelayStatus;