@aurabase/aurabase-js 0.3.0

package/packages/db/tests/filters.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest'
+import { QueryBuilder } from '../src/QueryBuilder'
+import { BaseAuthStore } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+
+function client(): AuraClientLike {
+  return {
+    baseUrl: 'http://x', projectId: 'p', apiKey: 'k',
+    fetchFn: (async () => new Response('[]')) as unknown as typeof globalThis.fetch,
+    authStore: new BaseAuthStore(),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+  }
+}
+const qb = () => new QueryBuilder(client(), '/base')
+const get = (b: QueryBuilder, key: string) => new URLSearchParams(b.buildQueryString()).get(key)
+
+describe('QueryBuilder — filtres PostgREST', () => {
+  it('notIn', () => { expect(get(qb().notIn('id', [1, 2]), 'id')).toBe('not.in.(1,2)') })
+  it('contains array/objet/string', () => {
+    expect(get(qb().contains('tags', ['a', 'b']), 'tags')).toBe('cs.{a,b}')
+    expect(get(qb().contains('meta', { a: 1 }), 'meta')).toBe('cs.{"a":1}')
+    expect(get(qb().contains('r', '[1,2)'), 'r')).toBe('cs.[1,2)')
+  })
+  it('containedBy / overlaps', () => {
+    expect(get(qb().containedBy('tags', ['a']), 'tags')).toBe('cd.{a}')
+    expect(get(qb().overlaps('tags', ['a', 'b']), 'tags')).toBe('ov.{a,b}')
+  })
+  it('ranges', () => {
+    expect(get(qb().rangeGt('r', '[1,2)'), 'r')).toBe('sr.[1,2)')
+    expect(get(qb().rangeGte('r', '[1,2)'), 'r')).toBe('nxl.[1,2)')
+    expect(get(qb().rangeLt('r', '[1,2)'), 'r')).toBe('sl.[1,2)')
+    expect(get(qb().rangeLte('r', '[1,2)'), 'r')).toBe('nxr.[1,2)')
+    expect(get(qb().rangeAdjacent('r', '[1,2)'), 'r')).toBe('adj.[1,2)')
+  })
+  it('textSearch', () => {
+    expect(get(qb().textSearch('body', 'cat'), 'body')).toBe('fts.cat')
+    expect(get(qb().textSearch('body', 'cat', { type: 'plain' }), 'body')).toBe('plfts.cat')
+    expect(get(qb().textSearch('body', 'cat', { type: 'phrase' }), 'body')).toBe('phfts.cat')
+    expect(get(qb().textSearch('body', 'cat', { type: 'websearch' }), 'body')).toBe('wfts.cat')
+    expect(get(qb().textSearch('body', 'cat', { config: 'english' }), 'body')).toBe('fts(english).cat')
+  })
+  it('isDistinct / not / filter', () => {
+    expect(get(qb().isDistinct('x', 1), 'x')).toBe('isdistinct.1')
+    expect(get(qb().not('x', 'eq', 1), 'x')).toBe('not.eq.1')
+    expect(get(qb().not('id', 'in', [1, 2]), 'id')).toBe('not.in.(1,2)')
+    expect(get(qb().filter('x', 'gte', 5), 'x')).toBe('gte.5')
+  })
+  it('like/ilike all/any', () => {
+    expect(get(qb().likeAllOf('n', ['a%', 'b%']), 'n')).toBe('like(all).{a%,b%}')
+    expect(get(qb().likeAnyOf('n', ['a%']), 'n')).toBe('like(any).{a%}')
+    expect(get(qb().ilikeAllOf('n', ['a%']), 'n')).toBe('ilike(all).{a%}')
+    expect(get(qb().ilikeAnyOf('n', ['a%']), 'n')).toBe('ilike(any).{a%}')
+  })
+  it('match → multi eq', () => {
+    const b = qb().match({ a: 1, b: 'x' })
+    const p = new URLSearchParams(b.buildQueryString())
+    expect(p.get('a')).toBe('eq.1')
+    expect(p.get('b')).toBe('eq.x')
+  })
+})
+
+describe('QueryBuilder — correctifs post-audit', () => {
+  it('D5 : valeurs à caractères réservés quotées (in / contains / like-any)', () => {
+    expect(get(qb().in('city', ['Paris', 'Aix, FR']), 'city')).toBe('in.(Paris,"Aix, FR")')
+    expect(get(qb().notIn('city', ['A(x)']), 'city')).toBe('not.in.("A(x)")')
+    expect(get(qb().contains('tags', ['a,b', 'c']), 'tags')).toBe('cs.{"a,b",c}')
+    expect(get(qb().likeAnyOf('n', ['a,b']), 'n')).toBe('like(any).{"a,b"}')
+    // guillemets internes doublés
+    expect(get(qb().in('q', ['a"b']), 'q')).toBe('in.("a""b")')
+  })
+  it('D6 : is(not.null) → not.is.null (et pas neq.null)', () => {
+    expect(get(qb().is('deleted_at', 'not.null'), 'deleted_at')).toBe('not.is.null')
+  })
+  it('D1 : single()/maybeSingle() ne posent PLUS limit (Accept object+json — corrige la mutation filtrée)', () => {
+    // Le `limit=2` cassait `.eq().update().select().single()` (PostgREST rejette `limit`
+    // sans `order` sur une mutation). La cardinalité passe désormais par l'en-tête Accept.
+    expect(get(qb().single(), 'limit')).toBeNull()
+    expect(get(qb().maybeSingle(), 'limit')).toBeNull()
+  })
+})

package/packages/db/tests/mutations-filtered.e2e.test.ts

@@ -0,0 +1,132 @@
+// ---------------------------------------------------------------------------
+// E2E réel (stack live) — LOT A : mutations filtrées (parité PostgREST).
+//
+// Gaté par RUN_E2E + credentials (AURA_E2E_URL / AURA_E2E_PROJECT / AURA_E2E_KEY,
+// clé service_role requise pour le SQL brut). Skip PROPRE sinon (describe.runIf).
+//
+// Le package `@aurabase/db` ne dépend que de `@aurabase/core` (pas de
+// `createClient` — ce serait circulaire), donc on monte un `DatabaseService`
+// directement au-dessus d'un `AuraClientLike` minimal pointant sur le backend
+// live (auth data-plane via apikey service_role).
+//
+// Flux : crée une table de test (SQL brut NON qualifié — le schéma tenant est
+// `project_<pid>`, pas `public`), GRANT + reload PostgREST, insère 2 lignes,
+// puis vérifie :
+//   1. `.eq(col,v).update({...}).select().single()` → renvoie la ligne modifiée projetée ;
+//   2. `.eq(col,v).delete().select()` → renvoie la ligne supprimée ;
+//   3. `update({...})` sans filtre → `unfiltered_mutation` (ZÉRO appel réseau).
+// Nettoyage (drop table) en `finally`.
+//
+// Le run réel n'est PAS lancé ici (pas de creds) — le contrôleur le fera ; ce
+// fichier doit seulement compiler et skip proprement.
+// ---------------------------------------------------------------------------
+
+import { describe, it, expect } from 'vitest'
+import { BaseAuthStore } from '@aurabase/core'
+import type { AuraClientLike, AuraResponse } from '@aurabase/core'
+import { DatabaseService } from '../src/DatabaseService'
+
+const URL = process.env.AURA_E2E_URL
+const PROJECT = process.env.AURA_E2E_PROJECT
+const KEY = process.env.AURA_E2E_KEY
+const RUN = Boolean(process.env.RUN_E2E && URL && PROJECT && KEY)
+
+/** Monte un `DatabaseService` réel au-dessus d'un `AuraClientLike` minimal. */
+function makeDb(): DatabaseService {
+  const client: AuraClientLike = {
+    baseUrl: URL!,
+    projectId: PROJECT!,
+    apiKey: KEY!,
+    fetchFn: globalThis.fetch,
+    authStore: new BaseAuthStore(),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+  }
+  return new DatabaseService(client)
+}
+
+/**
+ * Rejoue tant que la réponse est transitoire, borné. Inclut **404** : une table
+ * fraîchement créée en SQL brut n'est visible par PostgREST qu'après propagation du
+ * `reload schema` (fenêtre pendant laquelle il renvoie 404 « not found »), en plus des
+ * 503 (reload/indispo). Aligné sur le smoke db E2E (commit 7dc9f72d).
+ */
+async function retry503<T>(fn: () => Promise<AuraResponse<T>>): Promise<AuraResponse<T>> {
+  const transient = (s?: number): boolean => s === 404 || s === 503
+  let res = await fn()
+  for (let i = 0; i < 25 && transient(res.error?.status); i++) {
+    await new Promise((r) => setTimeout(r, 1000))
+    res = await fn()
+  }
+  return res
+}
+
+describe.runIf(RUN)('mutations filtrées E2E — .eq().update()/.delete() + garde-fou', () => {
+  it(
+    'update/delete filtrés renvoient la ligne projetée ; mutation sans filtre refusée',
+    async () => {
+      const db = makeDb()
+      const suffix = process.env.AURA_E2E_SUFFIX ?? 'mut'
+      const table = `e2e_mut_${suffix}`
+
+      // Création via SQL brut (service_role requis). Noms NON qualifiés → schéma tenant.
+      await db.sql(`DROP TABLE IF EXISTS ${table}`)
+      await db.sql(
+        `CREATE TABLE ${table} (id uuid PRIMARY KEY DEFAULT gen_random_uuid(), name text NOT NULL, n int NOT NULL DEFAULT 0)`,
+      )
+      // GRANTs larges + reload du cache PostgREST (débloque la couche CRUD sur la table jetable).
+      await db.sql(`GRANT ALL ON ${table} TO PUBLIC`)
+      await db.sql(`SELECT pg_notify('pgrst', 'reload schema')`)
+
+      try {
+        // -- Seed : 2 lignes --------------------------------------------------
+        // TESTS-1.1 : PLUS de graceful-skip silencieux. `retry503` absorbe les 503/404
+        // TRANSITOIRES ; un 503 PERSISTANT après retries doit FAIRE ÉCHOUER le test.
+        const seeded = await retry503(() =>
+          db.from(table).insert([
+            { name: 'alpha', n: 1 },
+            { name: 'beta', n: 2 },
+          ]),
+        )
+        expect(seeded.error).toBeNull()
+
+        // -- 1. UPDATE filtré + select() → ligne modifiée projetée ------------
+        // NB : pas de `.single()` sur une mutation — le mécanisme `single()` d'Aurabase
+        // ajoute `limit=2`, que PostgREST rejette sur une mutation sans `order`
+        // (limite pré-existante du single() limit-based ; postgrest-js utilise
+        // l'en-tête Accept object+json). LOT A = la mutation filtrée + projection.
+        const updated = await retry503(() =>
+          db.from(table).eq('name', 'alpha').update({ n: 99 }).select('name,n'),
+        )
+        expect(updated.error).toBeNull()
+        const updatedRows = updated.data as Array<{ name: string; n: number }> | null
+        expect(Array.isArray(updatedRows)).toBe(true)
+        expect(updatedRows!).toContainEqual({ name: 'alpha', n: 99 })
+
+        // -- 2. DELETE filtré + select() → ligne supprimée --------------------
+        const deleted = await retry503(() =>
+          db.from(table).eq('name', 'beta').delete().select('name,n'),
+        )
+        expect(deleted.error).toBeNull()
+        const deletedRows = deleted.data as Array<{ name: string; n: number }> | null
+        expect(Array.isArray(deletedRows)).toBe(true)
+        expect(deletedRows!.some((r) => r.name === 'beta')).toBe(true)
+
+        // -- 3. GARDE-FOU : update sans filtre → refusé sans appel réseau -----
+        const wipe = await db.from(table).update({ n: 0 })
+        expect(wipe.data).toBeNull()
+        expect(wipe.error?.code).toBe('unfiltered_mutation')
+
+        // La table doit être intacte (alpha toujours là, n=99) malgré le garde-fou.
+        const still = await retry503(() =>
+          db.from(table).eq('name', 'alpha').select('name,n').single(),
+        )
+        expect(still.error).toBeNull()
+        expect(still.data).toMatchObject({ name: 'alpha', n: 99 })
+      } finally {
+        await db.sql(`DROP TABLE IF EXISTS ${table}`)
+      }
+    },
+    120_000,
+  )
+})

package/packages/db/tests/mutations-filtered.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect } from 'vitest'
+import { QueryBuilder } from '../src/QueryBuilder'
+import { BaseAuthStore } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+
+interface RecordedCall {
+  url: string
+  method: string
+  headers: Record<string, string>
+  body: unknown
+}
+
+/**
+ * Client factice qui enregistre chaque appel (url/méthode/headers/body) et
+ * renvoie une réponse JSON contrôlée. Sert à asserter l'URL exacte (route
+ * Table vs id-based), le verbe HTTP et l'en-tête `Prefer` posés par les
+ * mutations, SANS appel réseau.
+ */
+function client(rows: unknown = []): { c: AuraClientLike; calls: RecordedCall[] } {
+  const calls: RecordedCall[] = []
+  const fetchFn = (async (url: string, init: RequestInit) => {
+    calls.push({
+      url,
+      method: (init.method ?? 'GET').toUpperCase(),
+      headers: (init.headers ?? {}) as Record<string, string>,
+      body: init.body,
+    })
+    return new Response(JSON.stringify(rows), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    })
+  }) as unknown as typeof globalThis.fetch
+  const c: AuraClientLike = {
+    baseUrl: 'http://x',
+    projectId: 'p',
+    apiKey: 'k',
+    fetchFn,
+    authStore: new BaseAuthStore(),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+  }
+  return { c, calls }
+}
+
+const qb = (rows?: unknown) => {
+  const { c, calls } = client(rows)
+  return { b: new QueryBuilder(c, '/base'), calls }
+}
+
+describe('QueryBuilder — mutations filtrées (parité PostgREST)', () => {
+  it('.eq().update() émet PATCH sur la route Table avec filtre (pas /id)', async () => {
+    const { b, calls } = qb([{ id: 'x', n: 1 }])
+    await b.eq('id', 'x').update({ n: 1 })
+    expect(calls).toHaveLength(1)
+    expect(calls[0]!.method).toBe('PATCH')
+    expect(calls[0]!.url).toBe('http://x/base?id=eq.x')
+  })
+
+  it('.eq().delete() émet DELETE sur la route Table avec filtre', async () => {
+    const { b, calls } = qb([])
+    await b.eq('id', 'x').delete()
+    expect(calls).toHaveLength(1)
+    expect(calls[0]!.method).toBe('DELETE')
+    expect(calls[0]!.url).toBe('http://x/base?id=eq.x')
+  })
+
+  it('compat : update(id, body) conserve la route id-based /base/{id}', async () => {
+    const { b, calls } = qb([{ id: 'x' }])
+    await b.update('x', { n: 2 })
+    expect(calls[0]!.method).toBe('PATCH')
+    expect(calls[0]!.url).toBe('http://x/base/x')
+  })
+
+  it('compat : delete(id) conserve la route id-based /base/{id}', async () => {
+    const { b, calls } = qb([])
+    await b.delete('x')
+    expect(calls[0]!.method).toBe('DELETE')
+    expect(calls[0]!.url).toBe('http://x/base/x')
+  })
+
+  it('.eq().update().select() ajoute select= + Prefer: return=representation', async () => {
+    const { b, calls } = qb([{ id: 'x', n: 1 }])
+    await b.eq('id', 'x').update({ n: 1 }).select('id,n')
+    const u = new URL(calls[0]!.url)
+    expect(u.searchParams.get('id')).toBe('eq.x')
+    expect(u.searchParams.get('select')).toBe('id,n')
+    expect(calls[0]!.headers['Prefer']).toContain('return=representation')
+  })
+
+  it('.eq().delete().select() pose Prefer: return=representation (indispensable DELETE)', async () => {
+    const { b, calls } = qb([{ id: 'x' }])
+    await b.eq('id', 'x').delete().select('*')
+    expect(calls[0]!.headers['Prefer']).toContain('return=representation')
+  })
+
+  it('insert().select() envoie select= + Prefer: return=representation', async () => {
+    const { b, calls } = qb([{ id: 'x' }])
+    await b.insert({ n: 1 }).select('id')
+    expect(calls[0]!.method).toBe('POST')
+    const u = new URL(calls[0]!.url)
+    expect(u.searchParams.get('select')).toBe('id')
+    expect(calls[0]!.headers['Prefer']).toContain('return=representation')
+  })
+
+  it('insert() sans select : aucun Prefer, route Table nue', async () => {
+    const { b, calls } = qb([{ id: 'x' }])
+    await b.insert({ n: 1 })
+    expect(calls[0]!.url).toBe('http://x/base')
+    expect(calls[0]!.headers['Prefer']).toBeUndefined()
+  })
+
+  it('count sur mutation → Prefer: count=<mode>', async () => {
+    const { b, calls } = qb([{ id: 'x' }])
+    await b.eq('id', 'x').update({ n: 1 }).count('exact')
+    expect(calls[0]!.headers['Prefer']).toContain('count=exact')
+  })
+
+  it('upsert conserve on_conflict et accepte des filtres/select', async () => {
+    const { b, calls } = qb([{ id: 'x' }])
+    await b.upsert({ id: 'x', n: 1 }, { onConflict: 'id' }).select('id')
+    const u = new URL(calls[0]!.url)
+    expect(calls[0]!.method).toBe('POST')
+    expect(u.searchParams.get('on_conflict')).toBe('id')
+    expect(u.searchParams.get('select')).toBe('id')
+    expect(calls[0]!.headers['Prefer']).toContain('return=representation')
+  })
+
+  it('GARDE-FOU : update() sans filtre → unfiltered_mutation, ZÉRO appel réseau', async () => {
+    const { b, calls } = qb()
+    const { data, error } = await b.update({ n: 1 })
+    expect(calls).toHaveLength(0)
+    expect(data).toBeNull()
+    expect(error?.code).toBe('unfiltered_mutation')
+  })
+
+  it('GARDE-FOU : delete() sans filtre → unfiltered_mutation, ZÉRO appel réseau', async () => {
+    const { b, calls } = qb()
+    const { error } = await b.delete()
+    expect(calls).toHaveLength(0)
+    expect(error?.code).toBe('unfiltered_mutation')
+  })
+
+  it('GARDE-FOU : un orGroup suffit à autoriser la mutation', async () => {
+    const { b, calls } = qb([{ id: 'x' }])
+    await b.or([{ column: 'id', op: 'eq', value: 'x' }]).delete()
+    expect(calls).toHaveLength(1)
+    expect(calls[0]!.method).toBe('DELETE')
+  })
+
+  // -- DB-F2 : le garde-fou compte les filtres EFFECTIFS (anti-contournement) ---
+
+  it('GARDE-FOU DB-F2 : .delete().or([]) (OrGroup vide) → refusé, ZÉRO appel réseau', async () => {
+    const { b, calls } = qb()
+    const { data, error } = await b.or([]).delete()
+    expect(calls).toHaveLength(0)
+    expect(data).toBeNull()
+    expect(error?.code).toBe('unfiltered_mutation')
+  })
+
+  it("GARDE-FOU DB-F2 : .filter('','','') (colonne vide) → refusé, ZÉRO appel réseau", async () => {
+    const { b, calls } = qb()
+    const { error } = await b.filter('', '', '').update({ n: 0 })
+    expect(calls).toHaveLength(0)
+    expect(error?.code).toBe('unfiltered_mutation')
+  })
+
+  // -- DB-F3 : insert 1 ligne + select renvoie un tableau (parité postgrest-js) --
+
+  it('DB-F3 : insert(uneLigne).select() → tableau à 1 élément (gateway déballe le 201)', async () => {
+    // Le gateway déballe le 201 mono-ligne en objet ; le SDK re-emballe en tableau.
+    const { b } = qb({ id: 'x', n: 1 })
+    const { data } = await b.insert({ n: 1 }).select('*')
+    expect(Array.isArray(data)).toBe(true)
+    expect(data).toEqual([{ id: 'x', n: 1 }])
+  })
+
+  it('DB-F3 : insert multi-lignes.select() → tableau inchangé (pas de double emballage)', async () => {
+    const { b } = qb([{ id: 'x' }, { id: 'y' }])
+    const { data } = await b.insert([{ n: 1 }, { n: 2 }]).select('*')
+    expect(data).toEqual([{ id: 'x' }, { id: 'y' }])
+  })
+
+  it('DB-F3 : upsert(uneLigne).select() → tableau à 1 élément', async () => {
+    const { b } = qb({ id: 'x', n: 1 })
+    const { data } = await b.upsert({ id: 'x', n: 1 }).select('*')
+    expect(data).toEqual([{ id: 'x', n: 1 }])
+  })
+})

package/packages/db/tests/order.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest'
+import { QueryBuilder } from '../src/QueryBuilder'
+import { BaseAuthStore } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+
+function client(): AuraClientLike {
+  return {
+    baseUrl: 'http://x', projectId: 'p', apiKey: 'k',
+    fetchFn: (async () => new Response('[]')) as unknown as typeof globalThis.fetch,
+    authStore: new BaseAuthStore(),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+  }
+}
+const qb = () => new QueryBuilder(client(), '/base')
+const get = (b: QueryBuilder, key: string) => new URLSearchParams(b.buildQueryString()).get(key)
+
+/**
+ * Verrouille le contrat de tri contre le backend `aura-db` : le handler CRUD
+ * (services/aura-db/src/handlers/crud.rs:79-97) lit `sort_by` + `sort_order`
+ * (et `order` en multi-colonnes, prioritaire). Le SDK émet `sort_by`/`sort_order`
+ * — ce test garantit qu'on ne dérive pas vers `order=col.dir` par mégarde, ce qui
+ * casserait silencieusement le tri single-colonne.
+ */
+describe('QueryBuilder — tri (contrat aura-db sort_by / sort_order)', () => {
+  it('order(col) émet sort_by=col + sort_order=asc par défaut', () => {
+    const b = qb().order('created_at')
+    expect(get(b, 'sort_by')).toBe('created_at')
+    expect(get(b, 'sort_order')).toBe('asc')
+    // Ne doit PAS émettre la syntaxe PostgREST `order=` (non lue en single-col).
+    expect(get(b, 'order')).toBeNull()
+  })
+
+  it('order(col, "desc") émet sort_order=desc', () => {
+    const b = qb().order('created_at', 'desc')
+    expect(get(b, 'sort_by')).toBe('created_at')
+    expect(get(b, 'sort_order')).toBe('desc')
+  })
+
+  it('sans order() : aucun paramètre de tri', () => {
+    const b = qb()
+    expect(get(b, 'sort_by')).toBeNull()
+    expect(get(b, 'sort_order')).toBeNull()
+  })
+})

package/packages/db/tests/rpc.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest'
+import { DatabaseService } from '../src/DatabaseService'
+
+function mkClient(capture: (url: string, init: any) => void) {
+  return {
+    baseUrl: 'http://x', projectId: 'p', apiKey: 'k',
+    fetchFn: async (url: string, init: any) => {
+      capture(url, init)
+      return new Response(JSON.stringify({ data: [{ id: 1 }], meta: {} }), { status: 200, headers: { 'content-type': 'application/json' } })
+    },
+    authStore: { token: null, refreshToken: null, save() {}, clear() {}, onChange() { return () => {} }, removalEpoch: 0, getItem() { return null }, setItem() {}, removeItem() {}, persistent: false },
+    auth: { refreshSession: async () => ({ data: null, error: null }) },
+  } as any
+}
+
+describe('rpc runtime', () => {
+  it('POST /rpc/{fn} avec args en body + filtre en query', async () => {
+    let url = '', init: any = null
+    const db = new DatabaseService(mkClient((u, i) => { url = u; init = i }))
+    await db.rpc('add', { a: 1, b: 2 }).eq('id', 1)
+    expect(url).toContain('/v1/db/p/rpc/add')
+    expect(url).toContain('id=eq.1')
+    expect(init.method).toBe('POST')
+    expect(JSON.parse(init.body)).toEqual({ a: 1, b: 2 })
+  })
+
+  it('get:true → GET, pas de body', async () => {
+    let init: any = null
+    const db = new DatabaseService(mkClient((_u, i) => { init = i }))
+    await db.rpc('now', undefined, { get: true })
+    expect(init.method).toBe('GET')
+    expect(init.body).toBeUndefined()
+  })
+
+  it('count → query param count=exact', async () => {
+    let url = ''
+    const db = new DatabaseService(mkClient((u) => { url = u }))
+    await db.rpc('list_things', {}, { count: 'exact' })
+    expect(url).toContain('count=exact')
+  })
+})

package/packages/db/tests/scale/build-large-schema.ts

@@ -0,0 +1,94 @@
+// LOT 6 (B5 — TS2589 non testé à l'échelle) : fabrique un schéma `SchemaTable[]`
+// synthétique mais réaliste, destiné à stresser l'inférence type-level du query
+// builder (`@aurabase/db`) au même ordre de grandeur qu'une base de production
+// (≥50 tables, colonnes larges sur certaines tables, FK croisées).
+//
+// Utilisé par `scale-compile.test.ts` : ce fichier ne produit que la matière
+// première (SchemaTable[]) — la génération du `Database` TS passe par le vrai
+// générateur `@aurabase/gen` (`generateDatabaseTypes`), pas une réimplémentation.
+import type { SchemaColumn, SchemaTable } from '@aurabase/core'
+
+const COLUMN_TYPE_POOL = ['text', 'int', 'bool', 'jsonb', 'numeric', 'timestamp'] as const
+
+function col(
+  name: string,
+  col_type: string,
+  opts: Partial<Omit<SchemaColumn, 'name' | 'col_type'>> = {},
+): SchemaColumn {
+  return { name, col_type, nullable: false, unique: false, default_val: null, references: null, ...opts }
+}
+
+function fk(name: string, table: string, opts: Partial<Omit<SchemaColumn, 'name' | 'col_type'>> = {}): SchemaColumn {
+  return col(name, 'uuid', { references: { table, column: 'id' }, ...opts })
+}
+
+export interface BuildLargeSchemaOptions {
+  /** Nombre total de tables (défaut 60, ≥50 exigé par LOT 6). */
+  tableCount?: number
+  /** Nombre de colonnes "larges" ajoutées sur les tables "wide" (une table sur dix). */
+  wideTableColumnCount?: number
+}
+
+/**
+ * Fabrique un schéma synthétique pour la sonde de compile à l'échelle.
+ *
+ * Structure :
+ * - `t0 → t1 → t2 → t3` forment une chaîne de FK NOT NULL propre, dédiée à la
+ *   sonde d'embed imbriqué sur 4 niveaux (`from('t0').select('*, t1(*, t2(*, t3(name))))')`),
+ *   dans le sens "many-to-one" (la table courante porte la FK) — c'est le même
+ *   sens que le cas déjà testé unitairement (`posts.author_id → users.id` dans
+ *   `tests/types/fixtures.ts`), donc pas de risque d'emprunter un chemin de
+ *   résolution du parser non couvert par ailleurs.
+ * - Une table sur dix (`t0`, `t10`, `t20`, ...) est "wide" : elle porte
+ *   `wideTableColumnCount` colonnes en plus des 3 colonnes de base, pour stresser
+ *   le cas d'un `select()` avec une longue liste de colonnes nommées (le chemin
+ *   qui, empiriquement, fait le plus grossir le nombre d'instanciations — voir
+ *   `scale-compile.test.ts`).
+ * - À partir de `t4`, chaque table porte deux FK "croisées" vers des tables
+ *   antérieures (`t(i-1)` et `t(i-4)`) pour densifier le graphe de relations
+ *   comme un schéma métier réel, sans jamais introduire d'ambiguïté de FK
+ *   (une seule FK vers une même table donnée par table) qui ferait échouer la
+ *   compilation pour une raison hors-sujet (désambiguïsation de hint).
+ */
+export function buildLargeSchemaTables(options: BuildLargeSchemaOptions = {}): SchemaTable[] {
+  const { tableCount = 60, wideTableColumnCount = 20 } = options
+  const tables: SchemaTable[] = []
+
+  for (let i = 0; i < tableCount; i++) {
+    const name = `t${i}`
+    const columns: SchemaColumn[] = [
+      col('id', 'uuid', { unique: true, default_val: 'gen_random_uuid()' }),
+      col('name', 'text'),
+      col('created_at', 'timestamp', { default_val: 'now()' }),
+    ]
+
+    const isWideTable = i % 10 === 0
+    const extraCount = isWideTable ? wideTableColumnCount : 3
+    for (let w = 0; w < extraCount; w++) {
+      const type = COLUMN_TYPE_POOL[w % COLUMN_TYPE_POOL.length]
+      columns.push(col(`extra_${w}_${type}`, type, { nullable: true }))
+    }
+
+    // Chaîne dédiée à la sonde d'embed profond (t0 → t1 → t2 → t3), NOT NULL.
+    if (i === 0) columns.push(fk('t1_id', 't1', { nullable: false }))
+    if (i === 1) columns.push(fk('t2_id', 't2', { nullable: false }))
+    if (i === 2) columns.push(fk('t3_id', 't3', { nullable: false }))
+
+    // FK croisées pour densifier le graphe au-delà de la chaîne dédiée.
+    if (i >= 4) {
+      columns.push(fk('ref_prev_id', `t${i - 1}`, { nullable: true }))
+      columns.push(fk('ref_cross_id', `t${i - 4}`, { nullable: true }))
+    }
+
+    tables.push({
+      name,
+      columns,
+      primary_key: 'id',
+      indexes: [],
+      rls_enabled: true,
+      realtime_enabled: false,
+    })
+  }
+
+  return tables
+}