@aurabase/aurabase-js 0.3.0 → 0.4.0

package/packages/gen/node_modules/.bin/vitest

@@ -1,22 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*)
-        if command -v cygpath > /dev/null 2>&1; then
-            basedir=`cygpath -w "$basedir"`
-        fi
-    ;;
-esac
-
-if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/Users/affanedaylami/aurabase/aurabase-js/node_modules/.pnpm/vitest@4.1.9_@types+node@20.14.15_vite@8.1.3_@types+node@20.14.15_esbuild@0.27.7_/node_modules/vitest/node_modules:/Users/affanedaylami/aurabase/aurabase-js/node_modules/.pnpm/vitest@4.1.9_@types+node@20.14.15_vite@8.1.3_@types+node@20.14.15_esbuild@0.27.7_/node_modules:/Users/affanedaylami/aurabase/aurabase-js/node_modules/.pnpm/node_modules"
-else
-  export NODE_PATH="/Users/affanedaylami/aurabase/aurabase-js/node_modules/.pnpm/vitest@4.1.9_@types+node@20.14.15_vite@8.1.3_@types+node@20.14.15_esbuild@0.27.7_/node_modules/vitest/node_modules:/Users/affanedaylami/aurabase/aurabase-js/node_modules/.pnpm/vitest@4.1.9_@types+node@20.14.15_vite@8.1.3_@types+node@20.14.15_esbuild@0.27.7_/node_modules:/Users/affanedaylami/aurabase/aurabase-js/node_modules/.pnpm/node_modules:$NODE_PATH"
-fi
-if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../vitest/vitest.mjs" "$@"
-else
-  exec node  "$basedir/../vitest/vitest.mjs" "$@"
-fi
-# cmd-shim-target=/Users/affanedaylami/aurabase/aurabase-js/packages/gen/node_modules/vitest/vitest.mjs

package/packages/gen/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -1 +0,0 @@
-{"version":"4.1.9","results":[[":tests/generate.test.ts",{"duration":284.61229099999946,"failed":false}],[":tests/compile.test.ts",{"duration":86465.322083,"failed":false}],[":tests/e2e.test.ts",{"duration":0,"failed":false}]]}

package/packages/gen/package.json

@@ -1,66 +0,0 @@
-{
-  "name": "@aurabase/gen",
-  "version": "0.3.0",
-  "description": "Générateur de types TypeScript Database pour le SDK Aurabase (CLI aurabase-gen)",
-  "type": "module",
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "aurabase-gen": "./dist/cli.js"
-  },
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
-    }
-  },
-  "sideEffects": false,
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "license": "MIT",
-  "author": "Aurabase",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/daylami555/aurabase.git",
-    "directory": "aurabase-js/packages/gen"
-  },
-  "homepage": "https://github.com/daylami555/aurabase/tree/main/aurabase-js/packages/gen#readme",
-  "bugs": {
-    "url": "https://github.com/daylami555/aurabase/issues"
-  },
-  "keywords": [
-    "aurabase",
-    "baas",
-    "sdk",
-    "generator",
-    "types"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "test": "vitest run --passWithNoTests",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@aurabase/core": "workspace:*",
-    "aurabase": "workspace:*"
-  },
-  "devDependencies": {
-    "tsup": "catalog:",
-    "typescript": "catalog:",
-    "vitest": "catalog:",
-    "@types/node": "catalog:"
-  }
-}

package/packages/gen/src/cli.ts

@@ -1,67 +0,0 @@
-#!/usr/bin/env node
-import { writeFileSync } from 'node:fs'
-import { createClient } from 'aurabase'
-import { generateDatabaseTypes } from './generate'
-
-interface Args { url?: string; project?: string; key?: string; out?: string; schema?: string; typeName?: string }
-
-function parseArgs(argv: string[]): Args {
-  const a: Args = {}
-  for (let i = 0; i < argv.length; i++) {
-    const v = argv[i + 1]
-    switch (argv[i]) {
-      case '--url': a.url = v; i++; break
-      case '--project': a.project = v; i++; break
-      case '--key': a.key = v; i++; break
-      case '--out': a.out = v; i++; break
-      case '--schema': a.schema = v; i++; break
-      case '--type-name': a.typeName = v; i++; break
-    }
-  }
-  return a
-}
-
-const USAGE = `Usage: aurabase-gen --url <baseUrl> --project <id> [--key <apiKey>] [--out database.types.ts] [--schema public] [--type-name Database]`
-
-async function main(): Promise<void> {
-  const args = parseArgs(process.argv.slice(2))
-  if (!args.url || !args.project) {
-    console.error(USAGE)
-    process.exit(1)
-  }
-  const client = createClient(args.url, args.project, args.key)
-  const { data, error } = await client.db.schema()
-  if (error) {
-    console.error(`[aurabase-gen] Erreur de récupération du schéma : ${error.message}`)
-    process.exit(1)
-  }
-  // `schema()` renvoie `{ tables, functions, enums, views }`. Le typage généré
-  // sérialise Functions (Args/Returns/SetofOptions), Enums (unions) et Views (Row).
-  const tables = data?.tables ?? []
-  const functions = data?.functions ?? []
-  const enums = data?.enums ?? []
-  const views = data?.views ?? []
-  if (tables.length === 0) {
-    console.error('[aurabase-gen] Avertissement : schéma vide (aucune table).')
-  }
-  const output = generateDatabaseTypes(tables, {
-    schemaName: args.schema,
-    typeName: args.typeName,
-    functions,
-    enums,
-    views,
-  })
-  if (args.out) {
-    writeFileSync(args.out, output)
-    console.error(
-      `[aurabase-gen] ✓ Types écrits dans ${args.out} (${tables.length} table(s), ${functions.length} fonction(s), ${enums.length} enum(s), ${views.length} vue(s)).`,
-    )
-  } else {
-    process.stdout.write(output)
-  }
-}
-
-main().catch((e) => {
-  console.error('[aurabase-gen]', e instanceof Error ? e.message : e)
-  process.exit(1)
-})

package/packages/gen/src/index.ts

@@ -1,2 +0,0 @@
-export { generateDatabaseTypes } from './generate'
-export type { GenerateOptions } from './generate'

package/packages/gen/tests/compile.test.ts

@@ -1,213 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { execFileSync } from 'node:child_process'
-import { mkdtempSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { generateDatabaseTypes } from '../src/generate'
-import type { SchemaTable, SchemaFunction, SchemaEnum } from '@aurabase/core'
-
-const tables: SchemaTable[] = [
-  { name: 'users', columns: [
-    { name: 'id', col_type: 'uuid', nullable: false, unique: true, default_val: 'gen_random_uuid()', references: null },
-    { name: 'email', col_type: 'text', nullable: false, unique: true, default_val: null, references: null },
-  ], indexes: [], rls_enabled: false, realtime_enabled: false, primary_key: 'id' },
-  { name: 'posts', columns: [
-    { name: 'id', col_type: 'uuid', nullable: false, unique: true, default_val: 'gen_random_uuid()', references: null },
-    { name: 'author_id', col_type: 'uuid', nullable: false, unique: false, default_val: null, references: { table: 'users', column: 'id' } },
-    { name: 'meta', col_type: 'jsonb', nullable: true, unique: false, default_val: null, references: null },
-  ], indexes: [], rls_enabled: false, realtime_enabled: false, primary_key: 'id' },
-]
-
-describe('generateDatabaseTypes — la sortie compile', () => {
-  it('tsc --noEmit --strict sans erreur', () => {
-    const out = generateDatabaseTypes(tables)
-    const dir = mkdtempSync(join(tmpdir(), 'aura-gen-'))
-    const file = join(dir, 'database.types.ts')
-    writeFileSync(file, out)
-    // Compile le fichier isolé (aucun import externe → autonome).
-    expect(() =>
-      execFileSync('npx', ['tsc', '--noEmit', '--strict', '--skipLibCheck', file], { stdio: 'pipe' }),
-    ).not.toThrow()
-  }, 30000)
-})
-
-const functions: SchemaFunction[] = [
-  { name: 'add', args: [
-    { name: 'a', data_type: 'int4', mode: 'IN' },
-    { name: 'b', data_type: 'int4', mode: 'IN' },
-  ], returns: 'int4', is_set_returning: false },
-  { name: 'list_things', args: [], returns: 'record', is_set_returning: true },
-]
-
-// Forme minimale de `GenericSchema['Functions']` (packages/db/src/pgrst-types/common/common.ts),
-// dupliquée ici pour garder ce test autonome (le fichier généré compile isolément).
-const GENERIC_SCHEMA_SHAPE = `
-type GenericFunction = {
-  Args: Record<string, unknown> | never
-  Returns: unknown
-  SetofOptions?: {
-    isSetofReturn?: boolean
-    isOneToOne?: boolean
-    isNotNullable?: boolean
-    to: string
-    from: string
-  }
-}
-type AssertFunctionsShape<T extends Record<string, GenericFunction>> = T
-type _assertFunctions = AssertFunctionsShape<Database['public']['Functions']>
-`
-
-describe('generateDatabaseTypes — le bloc Functions compile et satisfait GenericSchema', () => {
-  it('tsc --noEmit --strict : Args/Returns/SetofOptions valides pour une fonction scalaire + une SETOF', () => {
-    const out = generateDatabaseTypes(tables, { functions })
-    const dir = mkdtempSync(join(tmpdir(), 'aura-gen-fn-'))
-    const file = join(dir, 'database.types.ts')
-    writeFileSync(file, `${out}\n${GENERIC_SCHEMA_SHAPE}`)
-    expect(() =>
-      execFileSync('npx', ['tsc', '--noEmit', '--strict', '--skipLibCheck', file], { stdio: 'pipe' }),
-    ).not.toThrow()
-  }, 30000)
-})
-
-// C5/C6 : preuve que l'auto-référence `Database['public']['Enums']['mood']` (colonnes
-// enum + args de fonction enum) et le bloc Views compilent réellement.
-const enums: SchemaEnum[] = [{ name: 'mood', values: ['happy', 'sad'] }]
-const enumTables: SchemaTable[] = [
-  { name: 'people', columns: [
-    { name: 'id', col_type: 'uuid', nullable: false, unique: true, default_val: 'gen_random_uuid()', references: null },
-    { name: 'mood', col_type: { enum: 'mood' } as unknown as string, nullable: false, unique: false, default_val: null, references: null },
-    { name: 'tags', col_type: { array: 'text' } as unknown as string, nullable: true, unique: false, default_val: null, references: null },
-    { name: 'moods', col_type: { array: { enum: 'mood' } } as unknown as string, nullable: true, unique: false, default_val: null, references: null },
-  ], indexes: [], rls_enabled: false, realtime_enabled: false, primary_key: 'id' },
-]
-const enumViews: SchemaTable[] = [
-  { name: 'v_happy_people', columns: [
-    { name: 'id', col_type: 'uuid', nullable: true, unique: false, default_val: null, references: null },
-    { name: 'mood', col_type: { enum: 'mood' } as unknown as string, nullable: true, unique: false, default_val: null, references: null },
-  ], indexes: [], rls_enabled: false, realtime_enabled: false },
-]
-const enumFunctions: SchemaFunction[] = [
-  { name: 'set_mood', args: [{ name: 'm', data_type: 'mood', mode: 'IN' }], returns: 'mood', is_set_returning: false },
-  { name: 'tags_of', args: [{ name: 'ids', data_type: '_int4', mode: 'IN' }], returns: '_text', is_set_returning: false },
-]
-
-// GEN-M1 : deux overloads de même nom NE DOIVENT PAS produire deux clés dupliquées
-// (TS2300, fichier non compilable). Ils sont fusionnés en union `Args`/`Returns`.
-const overloads: SchemaFunction[] = [
-  { name: 'add', args: [
-    { name: 'a', data_type: 'int4', mode: 'IN' },
-    { name: 'b', data_type: 'int4', mode: 'IN' },
-  ], returns: 'int4', is_set_returning: false },
-  { name: 'add', args: [
-    { name: 'a', data_type: 'text', mode: 'IN' },
-    { name: 'b', data_type: 'text', mode: 'IN' },
-  ], returns: 'text', is_set_returning: false },
-]
-
-describe('generateDatabaseTypes — GEN-M1 : overloads fusionnés (compile, pas de TS2300)', () => {
-  it('deux add(...) → UNE clé add, Args/Returns en union, tsc --strict OK', () => {
-    const out = generateDatabaseTypes(tables, { functions: overloads })
-    // Une seule clé `add:` dans le bloc Functions (pas de duplicate identifier).
-    const fnBlock = out.slice(out.indexOf('Functions:'), out.indexOf('Enums:'))
-    expect(fnBlock.match(/add: {/g)).toHaveLength(1)
-    // Union des signatures (les deux formes d'Args + les deux Returns).
-    expect(fnBlock).toContain('{ a: number; b: number } | { a: string; b: string }')
-    expect(fnBlock).toContain('Returns: number | string')
-    // Et surtout : le fichier compile réellement.
-    const dir = mkdtempSync(join(tmpdir(), 'aura-gen-ovl-'))
-    const file = join(dir, 'database.types.ts')
-    writeFileSync(file, `${out}\n${GENERIC_SCHEMA_SHAPE}`)
-    expect(() =>
-      execFileSync('npx', ['tsc', '--noEmit', '--strict', '--skipLibCheck', file], { stdio: 'pipe' }),
-    ).not.toThrow()
-  }, 30000)
-})
-
-// Probe type-level (P4) : mirroir FIDÈLE des branches `Row` et `Result` du résolveur RPC
-// vendoré (`packages/db/src/pgrst-types/common/rpc.ts:110-135`), dupliqué ici pour rester
-// autonome (le fichier généré compile isolément, sans importer @aurabase/db). Prouve que la
-// sortie de `@aurabase/gen` alimente CORRECTEMENT le narrowing SETOF :
-//  - `.select()` (Row) sur une fonction `SETOF <table>` narrown les colonnes de la table cible
-//    (`SetofOptions.to` = table réelle) — c'est le fix P4 ;
-//  - une fonction `SETOF record` (placeholder) garde un `.rpc()` Result = `Fn['Returns']` =
-//    `Record<string, unknown>[]` (non-régression, comportement identique avant/après le fix).
-const SETOF_NARROWING_PROBE = `
-type Schema = Database['public']
-type TablesAndViews = Schema['Tables'] & Exclude<Schema['Views'], ''>
-
-// Branche Row du résolveur (post-.select) : rpc.ts:111-113 pour le cas table connue.
-type RpcRow<FnName extends keyof Schema['Functions']> =
-  Schema['Functions'][FnName] extends infer Fn
-    ? Fn extends { SetofOptions: { to: infer To } }
-      ? To extends keyof TablesAndViews
-        ? TablesAndViews[To] extends { Row: infer R } ? R : never
-        : never
-      : never
-    : never
-
-// Branche Result du résolveur (.rpc sans .select) : rpc.ts:129-135.
-type RpcResult<FnName extends keyof Schema['Functions']> =
-  Schema['Functions'][FnName] extends infer Fn
-    ? Fn extends { SetofOptions: { isSetofReturn: infer S; isOneToOne: infer O }; Returns: infer R }
-      ? S extends true ? (O extends true ? R[] : R) : R
-      : Fn extends { Returns: infer R2 } ? R2 : never
-    : never
-
-type Assert<T extends true> = T
-type Extends<A, B> = [A] extends [B] ? true : false
-type Equals<A, B> =
-  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false
-
-// SETOF users → Row de la table users (id/email typés, PAS Record<string, unknown>).
-type _P1 = Assert<Extends<RpcRow<'list_users'>, { id: string; email: string }>>
-// La colonne 'id' est bien une clé narrowée.
-type _P2 = Assert<Extends<'id', keyof RpcRow<'list_users'>>>
-// Colonne inexistante NON présente (prouve le narrowing réel, pas un index signature).
-type _P3 = Assert<Extends<'not_a_col', keyof RpcRow<'list_users'>> extends true ? false : true>
-// SETOF record (placeholder) → .rpc() Result reste Record<string, unknown>[] (non-régression).
-type _P4 = Assert<Equals<RpcResult<'list_things'>, Record<string, unknown>[]>>
-`
-
-describe('generateDatabaseTypes — P4 : narrowing SETOF <table> (probe tsc type-level)', () => {
-  it('tsc --strict : SETOF users narrown les colonnes, SETOF record reste Record<string, unknown>', () => {
-    const out = generateDatabaseTypes(
-      [
-        { name: 'users', columns: [
-          { name: 'id', col_type: 'uuid', nullable: false, unique: true, default_val: null, references: null },
-          { name: 'email', col_type: 'text', nullable: false, unique: false, default_val: null, references: null },
-        ], indexes: [], rls_enabled: false, realtime_enabled: false, primary_key: 'id' },
-      ],
-      {
-        functions: [
-          { name: 'list_users', args: [], returns: 'users', is_set_returning: true },
-          { name: 'list_things', args: [], returns: 'record', is_set_returning: true },
-        ],
-      },
-    )
-    // La cible SETOF est bien résolue à la table dans la sortie textuelle.
-    expect(out).toContain("to: 'users'")
-    expect(out).toContain("to: 'list_things'")
-    const dir = mkdtempSync(join(tmpdir(), 'aura-gen-setof-'))
-    const file = join(dir, 'database.types.ts')
-    writeFileSync(file, `${out}\n${SETOF_NARROWING_PROBE}`)
-    expect(() =>
-      execFileSync('npx', ['tsc', '--noEmit', '--strict', '--skipLibCheck', file], { stdio: 'pipe' }),
-    ).not.toThrow()
-  }, 30000)
-})
-
-describe('generateDatabaseTypes — Enums/Views/colonnes enum compilent (C5/C6)', () => {
-  it('tsc --noEmit --strict : auto-référence Enums, array d’enum, view, function enum/array', () => {
-    const out = generateDatabaseTypes(enumTables, {
-      enums,
-      views: enumViews,
-      functions: enumFunctions,
-    })
-    const dir = mkdtempSync(join(tmpdir(), 'aura-gen-enum-'))
-    const file = join(dir, 'database.types.ts')
-    writeFileSync(file, `${out}\n${GENERIC_SCHEMA_SHAPE}`)
-    expect(() =>
-      execFileSync('npx', ['tsc', '--noEmit', '--strict', '--skipLibCheck', file], { stdio: 'pipe' }),
-    ).not.toThrow()
-  }, 30000)
-})

package/packages/gen/tests/e2e.test.ts

@@ -1,130 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { execFileSync } from 'node:child_process'
-import { mkdtempSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { createClient } from 'aurabase'
-import { generateDatabaseTypes } from '../src/generate'
-
-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)
-
-// Suffixe UNIQUE par run : évite les collisions « already exists » sur reruns
-// (l'endpoint /raw interdit les DROP → impossible de nettoyer par SQL brut ; on ne
-// tente donc plus de DROP, on isole chaque run par un suffixe distinct).
-function uniqueSuffix(): string {
-  return (process.env.AURA_E2E_SUFFIX ?? '') + Math.random().toString(36).slice(2, 8)
-}
-
-// Exécute un SQL brut en RETENTANT sur les statuts transitoires — notamment 429
-// (l'endpoint /raw est rate-limité : burst 10 / 30 req/min) et 404/503 (cache
-// PostgREST). ASSERTE le succès : un CREATE avalé silencieusement (429) ne doit
-// plus faire échouer le test plus loin sur « 0 table ».
-async function sqlOk(
-  client: ReturnType<typeof createClient>,
-  query: string,
-): Promise<void> {
-  let res = await client.db.sql(query)
-  for (let i = 0; i < 20 && res.error && [429, 404, 503].includes(res.error.status ?? 0); i++) {
-    await new Promise((r) => setTimeout(r, 1000))
-    res = await client.db.sql(query)
-  }
-  expect(res.error, `SQL a échoué: ${query.slice(0, 60)}… → ${JSON.stringify(res.error)}`).toBeNull()
-}
-
-async function schemaWithRetry<T extends { error: { status?: number } | null }>(
-  fn: () => Promise<T>,
-): Promise<T> {
-  let res = await fn()
-  for (let i = 0; i < 20 && res.error && [429, 404, 503].includes(res.error.status ?? 0); i++) {
-    await new Promise((r) => setTimeout(r, 1000))
-    res = await fn()
-  }
-  return res
-}
-
-describe.runIf(RUN)('gen E2E — schéma réel → génère → compile', () => {
-  it('crée 2 tables liées par FK, génère les types, et ils compilent', async () => {
-    const client = createClient(URL!, PROJECT!, KEY!)
-    const suffix = uniqueSuffix()
-    const authors = `e2e_authors_${suffix}`
-    const books = `e2e_books_${suffix}`
-
-    // Création via SQL brut (service_role). Pas de DROP préalable : /raw les rejette
-    // (blocklist DDL) et ils consommeraient inutilement le budget rate-limit.
-    await sqlOk(client, `CREATE TABLE ${authors} (id uuid PRIMARY KEY DEFAULT gen_random_uuid(), name text NOT NULL)`)
-    await sqlOk(client, `CREATE TABLE ${books} (id uuid PRIMARY KEY DEFAULT gen_random_uuid(), author_id uuid NOT NULL REFERENCES ${authors}(id), title text NOT NULL)`)
-
-    const { data, error } = await schemaWithRetry(() => client.db.schema())
-    expect(error).toBeNull()
-    const tables = (data?.tables ?? []).filter((t) => t.name === authors || t.name === books)
-    expect(tables.length).toBe(2)
-
-    const out = generateDatabaseTypes(tables)
-    expect(out).toContain(`referencedRelation: '${authors}'`)
-    expect(out).toContain(`columns: ['author_id']`)
-
-    const dir = mkdtempSync(join(tmpdir(), 'aura-gen-e2e-'))
-    const file = join(dir, 'database.types.ts')
-    writeFileSync(file, out)
-    expect(() =>
-      execFileSync('npx', ['tsc', '--noEmit', '--strict', '--skipLibCheck', file], { stdio: 'pipe' }),
-    ).not.toThrow()
-  }, 60_000)
-
-  // LOT C — enum + array typé + FK composite + view + function scalaire.
-  it('enum + array + FK composite + view + function → génère blocs Enums/Views/Functions typés et compile', async () => {
-    const client = createClient(URL!, PROJECT!, KEY!)
-    const suffix = uniqueSuffix()
-    const moodEnum = `e2e_mood_${suffix}`
-    const orders = `e2e_orders_${suffix}`
-    const items = `e2e_items_${suffix}`
-    const view = `e2e_v_items_${suffix}`
-    const addFn = `e2e_add_${suffix}`
-
-    // Pas de DROP (voir cas 1). Chaque CREATE est asserté + retenté sur 429/404/503.
-    await sqlOk(client, `CREATE TYPE ${moodEnum} AS ENUM ('happy', 'sad', 'ok')`)
-    await sqlOk(
-      client,
-      `CREATE TABLE ${orders} (tenant uuid NOT NULL, id uuid NOT NULL, mood ${moodEnum} NOT NULL, tags text[] NOT NULL DEFAULT '{}', PRIMARY KEY (tenant, id))`,
-    )
-    await sqlOk(
-      client,
-      `CREATE TABLE ${items} (id uuid PRIMARY KEY DEFAULT gen_random_uuid(), order_tenant uuid NOT NULL, order_id uuid NOT NULL, CONSTRAINT fk_order FOREIGN KEY (order_tenant, order_id) REFERENCES ${orders}(tenant, id))`,
-    )
-    await sqlOk(client, `CREATE VIEW ${view} AS SELECT id, order_id FROM ${items}`)
-    await sqlOk(client, `CREATE FUNCTION ${addFn}(a int, b int) RETURNS int LANGUAGE sql AS 'SELECT a + b'`)
-    await sqlOk(client, `SELECT pg_notify('pgrst', 'reload schema')`)
-
-    const { data, error } = await schemaWithRetry(() => client.db.schema())
-    expect(error).toBeNull()
-    const tables = (data?.tables ?? []).filter((t) => t.name === orders || t.name === items)
-    const enums = (data?.enums ?? []).filter((e) => e.name === moodEnum)
-    const views = (data?.views ?? []).filter((v) => v.name === view)
-    const functions = (data?.functions ?? []).filter((f) => f.name === addFn)
-    expect(tables.length).toBe(2)
-    expect(enums.length).toBe(1)
-    expect(views.length).toBe(1)
-    expect(functions.length).toBe(1)
-
-    const out = generateDatabaseTypes(tables, { enums, views, functions })
-    expect(out).toContain(`${moodEnum}: 'happy' | 'sad' | 'ok'`)
-    expect(out).toContain(`mood: Database['public']['Enums']['${moodEnum}']`)
-    expect(out).toContain('tags: string[]')
-    expect(out).toContain("columns: ['order_tenant', 'order_id']")
-    expect(out).toContain(`${view}: {`)
-    const fnBlock = out.slice(out.indexOf(`${addFn}: {`), out.indexOf(`${addFn}: {`) + 300)
-    expect(fnBlock).toContain('a: number')
-    expect(fnBlock).toContain('Returns: number')
-    expect(fnBlock).not.toContain('unknown')
-
-    const dir = mkdtempSync(join(tmpdir(), 'aura-gen-e2e-c-'))
-    const file = join(dir, 'database.types.ts')
-    writeFileSync(file, out)
-    expect(() =>
-      execFileSync('npx', ['tsc', '--noEmit', '--strict', '--skipLibCheck', file], { stdio: 'pipe' }),
-    ).not.toThrow()
-  }, 60_000)
-})