@aurabase/aurabase-js 0.3.0 → 0.4.0

package/packages/db/tests/scale/scale-compile.test.ts

@@ -1,167 +0,0 @@
-// LOT 6 (B5 — TS2589 non testé à l'échelle) : harnais de compile à l'échelle.
-//
-// But : détecter, AVANT la prod, le "mur" TypeScript TS2589 ("Type
-// instantiation is excessively deep and possibly infinite") sur un schéma
-// réaliste (≥50 tables, embeds imbriqués sur plusieurs niveaux, select() large).
-// Ce test est 100% offline (aucune stack requise) : il fabrique un `Database`
-// synthétique via le vrai générateur `@aurabase/gen`, écrit une "sonde" TS qui
-// exerce le query builder dessus, et la compile en sous-processus `tsc` avec
-// `--extendedDiagnostics` pour mesurer le nombre de types instanciés et la
-// durée — puis vérifie que les deux restent sous un budget.
-//
-// Pourquoi un tsconfig autonome plutôt que `-p tsconfig.test-d.json` :
-// le fixture généré et la sonde vivent dans un dossier temporaire (nettoyé en
-// `finally`), hors de l'arborescence du package. Étendre `tsconfig.json` /
-// `tsconfig.test-d.json` tel quel échoue pour ce cas précis, vérifié
-// empiriquement : TS6059 (fichiers hors `rootDir: "src"`) et TS2688
-// (résolution de `types: ["vitest/globals"]" impossible hors de l'arbre du
-// package). Le tsconfig ci-dessous recopie donc 1:1 les `compilerOptions`
-// qui comptent pour l'inférence (strict, target ES2022, moduleResolution
-// bundler, esModuleInterop, skipLibCheck) — c'est le même moteur de type que
-// la vraie compile du package, appliqué à un fichier hors-arbre.
-import { describe, expect, it } from 'vitest'
-import { execFileSync } from 'node:child_process'
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { generateDatabaseTypes } from '../../../gen/src/generate'
-import { buildLargeSchemaTables } from './build-large-schema'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const DB_PACKAGE_DIR = join(__dirname, '..', '..') // packages/db
-const DB_SRC_DIR = join(DB_PACKAGE_DIR, 'src')
-
-// --- Budget (mesuré empiriquement le 12/07/2026, TypeScript 5.9.3, machine de dev) ---
-// Ce fixture exact (60 tables, chaîne d'embed à 4 niveaux + select nommé de
-// 20 colonnes sur une table "large") compile en ~65 000-75 000 instanciations,
-// ~6-12s (npx inclus). Pour calibrer : un `select()` de 250 colonnes nommées
-// sur une seule table donne ~2,5M instanciations (~8s, toujours OK) ; à 400
-// colonnes, TS2589 apparaît réellement à ~5,3M instanciations (~18-20s) — ce
-// qui confirme que ce harnais détecte bel et bien le mur quand on le franchit
-// (vérifié manuellement pendant le développement de ce test, hors suite
-// committée pour ne pas rendre `npm test` rouge par construction).
-// Budget retenu : ~3,4x l'observé (assez serré pour capter une régression de
-// complexité type-level bien avant TS2589, assez large pour la variance CI).
-const INSTANTIATION_BUDGET = 250_000
-const DURATION_BUDGET_MS = 30_000
-
-describe('LOT 6 — garde TS2589 à l\'échelle (schéma ≥50 tables)', () => {
-  it(
-    'compile un Database à l\'échelle (embed 4 niveaux + select large + eq + insert) sans TS2589, sous budget',
-    () => {
-      const tables = buildLargeSchemaTables({ tableCount: 60, wideTableColumnCount: 20 })
-      expect(tables.length).toBeGreaterThanOrEqual(50)
-
-      const databaseTypesSource = generateDatabaseTypes(tables)
-
-      const tempDir = mkdtempSync(join(tmpdir(), 'aura-db-scale-'))
-      try {
-        const typesFile = join(tempDir, 'database.types.ts')
-        writeFileSync(typesFile, databaseTypesSource)
-
-        // t10 : première table "large" hors de la chaîne d'embed dédiée
-        // (t0..t3) — voir build-large-schema.ts (une table sur dix est large).
-        const wideTable = tables.find((t) => t.name === 't10')
-        if (!wideTable) throw new Error('fixture: table "t10" absente (le générateur de fixture a changé ?)')
-        const wideColumns = wideTable.columns
-          .slice(0, 20)
-          .map((c) => c.name)
-          .join(', ')
-
-        const probeSource = `// Sonde de compile à l'échelle — générée par scale-compile.test.ts (LOT 6).
-// Compilée en sous-processus tsc, jamais exécutée (pas de runtime réel).
-import type { Database } from './database.types'
-import { DatabaseService } from '${DB_SRC_DIR}/DatabaseService'
-
-declare const db: DatabaseService<Database>
-
-async function probe() {
-  // Embed imbriqué sur 4 niveaux, sens many-to-one (t0 -> t1 -> t2 -> t3),
-  // même sens que le cas déjà testé unitairement (posts.author_id -> users.id).
-  const deep = await db.from('t0').select('*, t1(*, t2(*, t3(name)))')
-
-  // select() avec une longue liste de colonnes nommées sur une table "large"
-  // (chemin qui, empiriquement, fait le plus grossir le nombre d'instanciations).
-  const wide = await db.from('${wideTable.name}').select('${wideColumns}')
-
-  // .eq() typé sur une colonne connue.
-  const filtered = db.from('t0').select('id, name').eq('name', 'x')
-
-  // Mutation typée (insert).
-  const inserted = db.from('t0').insert({ name: 'n', t1_id: 'x' })
-
-  return { deep, wide, filtered, inserted }
-}
-void probe
-`
-        const probeFile = join(tempDir, 'probe.ts')
-        writeFileSync(probeFile, probeSource)
-
-        const tsconfig = {
-          compilerOptions: {
-            target: 'ES2022',
-            module: 'ESNext',
-            moduleResolution: 'bundler',
-            lib: ['ES2022', 'DOM'],
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            noEmit: true,
-            declaration: false,
-            types: [],
-          },
-          include: [probeFile],
-        }
-        const tsconfigFile = join(tempDir, 'tsconfig.json')
-        writeFileSync(tsconfigFile, JSON.stringify(tsconfig, null, 2))
-
-        const startedAt = Date.now()
-        let stdout = ''
-        let compileError: (Error & { stdout?: string; stderr?: string }) | undefined
-        try {
-          stdout = execFileSync(
-            'npx',
-            ['tsc', '--noEmit', '-p', tsconfigFile, '--extendedDiagnostics'],
-            { cwd: DB_PACKAGE_DIR, encoding: 'utf8', timeout: 90_000 },
-          )
-        } catch (e) {
-          compileError = e as Error & { stdout?: string; stderr?: string }
-          stdout = compileError.stdout ?? ''
-        }
-        const durationMs = Date.now() - startedAt
-
-        // Le mur à détecter avant la prod : `error TS2589: Type instantiation
-        // is excessively deep and possibly infinite.`
-        const hasTS2589 = /TS2589/.test(stdout) || /TS2589/.test(compileError?.stderr ?? '')
-        expect(hasTS2589, `TS2589 détecté — mur d'instanciation atteint :\n${stdout}`).toBe(false)
-
-        // Toute autre erreur de compilation est aussi un échec : la sonde doit
-        // être 100% valide vis-à-vis du query builder réel.
-        if (compileError) {
-          throw new Error(`tsc a échoué (hors TS2589) :\n${stdout}\n${compileError.stderr ?? ''}`)
-        }
-
-        const instantiationsMatch = /Instantiations:\s*([\d,]+)/.exec(stdout)
-        expect(
-          instantiationsMatch,
-          `--extendedDiagnostics n'a pas produit de ligne "Instantiations:" :\n${stdout}`,
-        ).not.toBeNull()
-        const instantiations = Number(instantiationsMatch![1].replace(/,/g, ''))
-
-        expect(
-          instantiations,
-          `${instantiations} instanciations > budget ${INSTANTIATION_BUDGET} — régression de complexité ` +
-            'type-level probable (voir marge documentée en tête de fichier)',
-        ).toBeLessThan(INSTANTIATION_BUDGET)
-
-        expect(durationMs, `compile à ${durationMs}ms > budget ${DURATION_BUDGET_MS}ms`).toBeLessThan(
-          DURATION_BUDGET_MS,
-        )
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true })
-      }
-    },
-    90_000,
-  )
-})

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

@@ -1,77 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { DatabaseService } from '../src/DatabaseService'
-import { BaseAuthStore } from '@aurabase/core'
-import type { AuraClientLike } from '@aurabase/core'
-
-function client(extra?: Record<string, unknown>): AuraClientLike {
-  const body = JSON.stringify({
-    data: {
-      project_id: 'p',
-      engine: 'postgres',
-      tables: [{ name: 'users', columns: [], indexes: [], rls_enabled: false, realtime_enabled: false }],
-      ...extra,
-    },
-  })
-  return {
-    baseUrl: 'http://x', projectId: 'p', apiKey: 'k',
-    fetchFn: (async () =>
-      new Response(body, { status: 200, headers: { 'Content-Type': 'application/json' } })) 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 },
-  }
-}
-
-describe('DatabaseService.schema()', () => {
-  it('déballe SchemaDefinition.tables ET .functions — le backend renvoie { project_id, engine, tables, functions }', async () => {
-    const db = new DatabaseService(
-      client({
-        functions: [
-          { name: 'add', args: [{ name: 'a', data_type: 'int4', mode: 'IN' }], returns: 'int4', is_set_returning: false },
-        ],
-      }),
-    )
-    const { data, error } = await db.schema()
-    expect(error).toBeNull()
-    expect(Array.isArray(data?.tables)).toBe(true)
-    expect(data?.tables).toHaveLength(1)
-    expect(data?.tables[0].name).toBe('users')
-    expect(Array.isArray(data?.functions)).toBe(true)
-    expect(data?.functions).toHaveLength(1)
-    expect(data?.functions[0]).toEqual({
-      name: 'add',
-      args: [{ name: 'a', data_type: 'int4', mode: 'IN' }],
-      returns: 'int4',
-      is_set_returning: false,
-    })
-  })
-
-  it('functions absentes du backend → []', async () => {
-    const db = new DatabaseService(client())
-    const { data, error } = await db.schema()
-    expect(error).toBeNull()
-    expect(data?.functions).toEqual([])
-  })
-
-  it('déballe .enums ET .views (LOT C) — le backend renvoie enums/views', async () => {
-    const db = new DatabaseService(
-      client({
-        enums: [{ name: 'mood', values: ['happy', 'sad'] }],
-        views: [{ name: 'v_x', columns: [], indexes: [], rls_enabled: false, realtime_enabled: false }],
-      }),
-    )
-    const { data, error } = await db.schema()
-    expect(error).toBeNull()
-    expect(data?.enums).toEqual([{ name: 'mood', values: ['happy', 'sad'] }])
-    expect(data?.views).toHaveLength(1)
-    expect(data?.views[0].name).toBe('v_x')
-  })
-
-  it('enums/views absents du backend → [] (rétrocompat)', async () => {
-    const db = new DatabaseService(client())
-    const { data, error } = await db.schema()
-    expect(error).toBeNull()
-    expect(data?.enums).toEqual([])
-    expect(data?.views).toEqual([])
-  })
-})

package/packages/db/tests/single-accept.e2e.test.ts

@@ -1,123 +0,0 @@
-// ---------------------------------------------------------------------------
-// E2E réel (stack live) — single()/maybeSingle() via Accept: object+json.
-//
-// Vérifie la parité postgrest-js et le correctif du cas qui cassait :
-// `.eq().update().select().single()` (PostgREST rejette `limit` sans `order` sur
-// une mutation ; le nouvel en-tête Accept n'a pas ce problème).
-//
-// 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).
-//
-// Table de test créée en SQL brut NON qualifié (schéma tenant `project_<pid>`).
-// Retry borné sur 404 (propagation `reload schema` post-DDL) + 503 (reload/indispo).
-//
-// 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 (404 propagation schéma / 503 reload), borné. */
-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)('single()/maybeSingle() E2E — Accept object+json + mutation filtrée', () => {
-  it(
-    'select/mutation .single() renvoient l’objet ; 0/>1 → PGRST116 ; maybeSingle 0 → null',
-    async () => {
-      const db = makeDb()
-      const suffix = process.env.AURA_E2E_SUFFIX ?? 'single'
-      const table = `e2e_single_${suffix}`
-
-      // Création via SQL brut (service_role). 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)`,
-      )
-      await db.sql(`GRANT ALL ON ${table} TO PUBLIC`)
-      await db.sql(`SELECT pg_notify('pgrst', 'reload schema')`)
-
-      try {
-        // -- Seed : 3 lignes, dont 2 partageant name='dup' (pour le cas >1 ligne) ---
-        // TESTS-1.1 : PLUS de graceful-skip silencieux. `retry503` absorbe les 503/404
-        // TRANSITOIRES (reload schéma) ; un 503 PERSISTANT après retries doit FAIRE
-        // ÉCHOUER le test (`expect(...).toBeNull()`), pas être masqué par un `return`.
-        const seeded = await retry503(() =>
-          db.from(table).insert([
-            { name: 'uno', n: 1 },
-            { name: 'dup', n: 2 },
-            { name: 'dup', n: 3 },
-          ]),
-        )
-        expect(seeded.error).toBeNull()
-
-        // -- (a) SELECT .eq(pk unique).single() → l'objet --------------------------
-        const one = await retry503(() =>
-          db.from(table).eq('name', 'uno').select('name,n').single(),
-        )
-        expect(one.error).toBeNull()
-        expect(one.data).toMatchObject({ name: 'uno', n: 1 })
-
-        // -- (b1) .select().single() sur 0 ligne → PGRST116 -----------------------
-        const zero = await retry503(() =>
-          db.from(table).eq('name', 'absent').select('name,n').single(),
-        )
-        expect(zero.data).toBeNull()
-        expect(zero.error?.code).toBe('PGRST116')
-
-        // -- (b2) .select().single() sur >1 ligne → PGRST116 ----------------------
-        const many = await retry503(() =>
-          db.from(table).eq('name', 'dup').select('name,n').single(),
-        )
-        expect(many.data).toBeNull()
-        expect(many.error?.code).toBe('PGRST116')
-
-        // -- (c) maybeSingle sur 0 ligne → null SANS erreur -----------------------
-        const maybeZero = await retry503(() =>
-          db.from(table).eq('name', 'absent').select('name,n').maybeSingle(),
-        )
-        expect(maybeZero.data).toBeNull()
-        expect(maybeZero.error).toBeNull()
-
-        // -- (d) LE CAS QUI CASSAIT : .eq().update().select().single() ------------
-        const updated = await retry503(() =>
-          db.from(table).eq('name', 'uno').update({ n: 99 }).select('name,n').single(),
-        )
-        expect(updated.error).toBeNull()
-        expect(updated.data).toMatchObject({ name: 'uno', n: 99 })
-      } finally {
-        await db.sql(`DROP TABLE IF EXISTS ${table}`)
-      }
-    },
-    120_000,
-  )
-})

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

@@ -1,211 +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 Captured {
-  url: string
-  init: RequestInit
-}
-
-/**
- * Client mock enregistrant la requête et renvoyant une réponse paramétrable.
- * `respond` reçoit l'URL et renvoie `{ status, body }` (body sérialisé en JSON).
- */
-function client(
-  respond: (url: string) => { status: number; body: unknown },
-  captured?: Captured[],
-): AuraClientLike {
-  return {
-    baseUrl: 'http://x',
-    projectId: 'p',
-    apiKey: 'k',
-    fetchFn: (async (url: string, init: RequestInit) => {
-      captured?.push({ url, init })
-      const { status, body } = respond(url)
-      return new Response(JSON.stringify(body), {
-        status,
-        headers: { 'Content-Type': 'application/json' },
-      })
-    }) 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 },
-  }
-}
-
-/** Corps d'erreur 406 tel que réécrit par le gateway (code NOT_SINGULAR + détail PostgREST). */
-function notSingular(rows: number): { status: number; body: unknown } {
-  return {
-    status: 406,
-    body: {
-      error: {
-        code: 'NOT_SINGULAR',
-        message: 'JSON object requested, multiple (or no) rows returned',
-        details: `The result contains ${rows} rows`,
-      },
-    },
-  }
-}
-
-/**
- * Corps d'erreur 404 tel que réécrit par le gateway sur la route id-based
- * `/{table}/{id}` quand l'id est introuvable (PGRST116 → `RECORD_NOT_FOUND`).
- */
-function recordNotFound(): { status: number; body: unknown } {
-  return {
-    status: 404,
-    body: { error: { code: 'RECORD_NOT_FOUND', message: 'Record not found' } },
-  }
-}
-
-/** Extrait l'en-tête `Accept` (insensible à la casse de la clé) de l'init capturé. */
-function acceptOf(init: RequestInit): string | undefined {
-  const h = (init.headers ?? {}) as Record<string, string>
-  return h.Accept ?? h.accept
-}
-
-describe('single() / maybeSingle() — en-tête Accept object+json (parité postgrest-js)', () => {
-  it('single() envoie Accept: application/vnd.pgrst.object+json et PAS limit=2', async () => {
-    const cap: Captured[] = []
-    await new QueryBuilder(client(() => ({ status: 200, body: { data: { id: 1 } } }), cap), '/t')
-      .eq('id', 1)
-      .select('*')
-      .single()
-    expect(cap).toHaveLength(1)
-    expect(acceptOf(cap[0]!.init)).toBe('application/vnd.pgrst.object+json')
-    expect(cap[0]!.url).not.toMatch(/limit=/)
-  })
-
-  it('single sur objet unique (200) → renvoie l’objet', async () => {
-    const { data, error } = await new QueryBuilder(
-      client(() => ({ status: 200, body: { data: { id: 1, name: 'a' } } })),
-      '/t',
-    ).single()
-    expect(error).toBeNull()
-    expect(data).toEqual({ id: 1, name: 'a' })
-  })
-
-  it('single sur 0 ligne (406) → erreur PGRST116/406', async () => {
-    const { data, error } = await new QueryBuilder(client(() => notSingular(0)), '/t').single()
-    expect(data).toBeNull()
-    expect(error?.status).toBe(406)
-    expect(error?.code).toBe('PGRST116')
-  })
-
-  it('single sur >1 ligne (406) → erreur PGRST116', async () => {
-    const { error } = await new QueryBuilder(client(() => notSingular(2)), '/t').single()
-    expect(error?.code).toBe('PGRST116')
-    expect(error?.message).toMatch(/multiple/)
-  })
-
-  it('maybeSingle sur 0 ligne (406 « 0 rows ») → null sans erreur', async () => {
-    const { data, error } = await new QueryBuilder(client(() => notSingular(0)), '/t').maybeSingle()
-    expect(data).toBeNull()
-    expect(error).toBeNull()
-  })
-
-  it('maybeSingle sur objet unique (200) → renvoie l’objet', async () => {
-    const { data, error } = await new QueryBuilder(
-      client(() => ({ status: 200, body: { data: { id: 7 } } })),
-      '/t',
-    ).maybeSingle()
-    expect(error).toBeNull()
-    expect(data).toEqual({ id: 7 })
-  })
-
-  it('maybeSingle sur >1 ligne (406) → erreur PGRST116', async () => {
-    const { error } = await new QueryBuilder(client(() => notSingular(2)), '/t').maybeSingle()
-    expect(error?.code).toBe('PGRST116')
-  })
-
-  it('discrimination robuste : « 10 rows » n’est PAS traité comme « 0 rows » (maybeSingle → erreur)', async () => {
-    const { data, error } = await new QueryBuilder(client(() => notSingular(10)), '/t').maybeSingle()
-    expect(data).toBeNull()
-    expect(error?.code).toBe('PGRST116')
-  })
-
-  it('.eq().update().select().single() → en-tête Accept + Prefer, PAS de limit (cas qui cassait)', async () => {
-    const cap: Captured[] = []
-    const { data, error } = await new QueryBuilder(
-      client(() => ({ status: 200, body: { data: { id: 1, n: 99 } } }), cap),
-      '/t',
-    )
-      .eq('id', 1)
-      .update({ n: 99 })
-      .select('*')
-      .single()
-    expect(error).toBeNull()
-    expect(data).toEqual({ id: 1, n: 99 })
-    expect(cap).toHaveLength(1)
-    const h = (cap[0]!.init.headers ?? {}) as Record<string, string>
-    expect(acceptOf(cap[0]!.init)).toBe('application/vnd.pgrst.object+json')
-    expect(h.Prefer).toMatch(/return=representation/)
-    expect(cap[0]!.url).not.toMatch(/limit=/)
-    expect(cap[0]!.init.method).toBe('PATCH')
-  })
-
-  // -- DB-F1 : route id-based → 404 RECORD_NOT_FOUND traité comme 0-ligne -------
-  describe('route id-based (404 RECORD_NOT_FOUND) — parité single/maybeSingle', () => {
-    it('update(idInexistant).select().maybeSingle() → { data:null, error:null }', async () => {
-      const { data, error } = await new QueryBuilder(client(() => recordNotFound()), '/t')
-        .update('missing-id', { n: 1 })
-        .select('*')
-        .maybeSingle()
-      expect(data).toBeNull()
-      expect(error).toBeNull()
-    })
-
-    it('update(idInexistant).select().single() → erreur PGRST116 (0 rows)', async () => {
-      const { data, error } = await new QueryBuilder(client(() => recordNotFound()), '/t')
-        .update('missing-id', { n: 1 })
-        .select('*')
-        .single()
-      expect(data).toBeNull()
-      expect(error?.code).toBe('PGRST116')
-      expect(error?.message).toMatch(/0 rows/)
-    })
-
-    it('delete(idInexistant).select().single() → erreur PGRST116 (0 rows)', async () => {
-      const { error } = await new QueryBuilder(client(() => recordNotFound()), '/t')
-        .delete('missing-id')
-        .select('*')
-        .single()
-      expect(error?.code).toBe('PGRST116')
-    })
-  })
-
-  // -- Chemin défensif : backend renvoyant un TABLEAU (en-tête ignoré) ---------
-  describe('fallback tableau (compat défensive)', () => {
-    it('single sur [obj] → objet', async () => {
-      const { data, error } = await new QueryBuilder(
-        client(() => ({ status: 200, body: { data: [{ id: 1 }] } })),
-        '/t',
-      ).single()
-      expect(error).toBeNull()
-      expect(data).toEqual({ id: 1 })
-    })
-    it('single sur [] → erreur PGRST116', async () => {
-      const { error } = await new QueryBuilder(
-        client(() => ({ status: 200, body: { data: [] } })),
-        '/t',
-      ).single()
-      expect(error?.code).toBe('PGRST116')
-    })
-    it('maybeSingle sur [] → null sans erreur', async () => {
-      const { data, error } = await new QueryBuilder(
-        client(() => ({ status: 200, body: { data: [] } })),
-        '/t',
-      ).maybeSingle()
-      expect(data).toBeNull()
-      expect(error).toBeNull()
-    })
-    it('maybeSingle sur [a,b] → erreur PGRST116', async () => {
-      const { error } = await new QueryBuilder(
-        client(() => ({ status: 200, body: { data: [{ id: 1 }, { id: 2 }] } })),
-        '/t',
-      ).maybeSingle()
-      expect(error?.code).toBe('PGRST116')
-    })
-  })
-})

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

@@ -1,52 +0,0 @@
-import { DatabaseService } from '../../src/DatabaseService'
-import type { Database } from './fixtures'
-
-declare const db: DatabaseService<Database>
-
-test('eq accepte une colonne connue + type de valeur correct', () => {
-  db.from('users').select('id').eq('email', 'a@b.c') // OK
-})
-
-test('eq refuse une colonne inconnue', () => {
-  // @ts-expect-error colonne inexistante
-  db.from('users').select('id').eq('nope', 'x')
-})
-
-test('eq refuse un mauvais type de valeur', () => {
-  // @ts-expect-error email est string
-  db.from('users').select('id').eq('email', 123)
-})
-
-test('neq/gt/gte/lt/lte typés sur Row', () => {
-  db.from('users').select('id').neq('email', 'a@b.c') // OK
-  // @ts-expect-error colonne inexistante
-  db.from('users').select('id').neq('nope', 'x')
-  // @ts-expect-error mauvais type
-  db.from('users').select('id').neq('email', 123)
-})
-
-test('in accepte column + Row[C][]', () => {
-  db.from('users').select('id').in('email', ['a@b.c', 'd@e.f']) // OK
-  // @ts-expect-error colonne inexistante
-  db.from('users').select('id').in('nope', ['x'])
-  // @ts-expect-error mauvais type de valeur
-  db.from('users').select('id').in('email', [123])
-})
-
-test('like/ilike acceptent colonne connue', () => {
-  db.from('users').select('id').like('email', '%a%') // OK
-  // @ts-expect-error colonne inexistante
-  db.from('users').select('id').like('nope', '%a%')
-})
-
-test('filter/not/match restent permissifs (colonne string)', () => {
-  db.from('users').select('id').filter('anything', 'eq', 'x') // OK, échappatoire
-  db.from('users').select('id').not('anything', 'eq', 'x') // OK, échappatoire
-  db.from('users').select('id').match({ anything: 'x' }) // OK, échappatoire
-})
-
-test('or garde sa signature actuelle (string brute)', () => {
-  db.from('users')
-    .select('id')
-    .or([{ column: 'anything', op: 'eq', value: 'x' }]) // OK, échappatoire
-})

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

@@ -1,40 +0,0 @@
-// Database fixture partagé par les tests type-level (forme + inférence de select).
-// Forme identique à ce que `@aurabase/gen` (Phase 1) produit : chaque table expose
-// Row/Insert/Update/Relationships, avec au moins deux tables liées par une FK.
-
-export interface Database {
-  public: {
-    Tables: {
-      users: {
-        Row: { id: string; email: string; bio: string | null }
-        Insert: { id?: string; email: string; bio?: string | null }
-        Update: { id?: string; email?: string; bio?: string | null }
-        Relationships: []
-      }
-      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']
-          },
-        ]
-      }
-    }
-    Views: {
-      // Vue non updatable (Row seul, pas d'Insert/Update) — parité générateur LOT C.
-      active_users: {
-        Row: { id: string; email: string }
-        Relationships: []
-      }
-    }
-    Functions: Record<string, never>
-    Enums: Record<string, never>
-    CompositeTypes: Record<string, never>
-  }
-}