@aurabase/aurabase-js 0.3.0 → 0.4.0

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

@@ -1,81 +0,0 @@
-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

@@ -1,132 +0,0 @@
-// ---------------------------------------------------------------------------
-// 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

@@ -1,188 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,94 +0,0 @@
-// 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
-}