@aurabase/aurabase-js 0.3.0

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

@@ -0,0 +1,22 @@
+#!/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

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

@@ -0,0 +1,66 @@
+{
+  "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

@@ -0,0 +1,67 @@
+#!/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

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

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

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

@@ -0,0 +1,130 @@
+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)
+})