@aurabase/gen 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aurabase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# @aurabase/gen
+
+Générateur de types TypeScript `Database` pour le SDK Aurabase : introspecte le schéma d'un projet et produit un fichier de types compatible avec l'inférence de `@aurabase/db` (parité `Database` façon Supabase).
+
+![npm](https://img.shields.io/npm/v/@aurabase/gen) ![license](https://img.shields.io/badge/license-MIT-blue)
+
+> Pre-release — pas encore publié sur npm.
+
+Fait partie de l'écosystème du SDK **[aurabase](../aurabase)**, mais publié et installé **séparément** : contrairement aux autres packages `@aurabase/*`, le méta-package `aurabase` ne dépend pas de `@aurabase/gen` — c'est un outil de développement (CLI de génération de types), pas une dépendance runtime de votre application.
+
+## Installation
+
+```bash
+npm i -D @aurabase/gen
+```
+
+> S'installe typiquement en devDependency (ou s'exécute via `npx` sans installation) : c'est un outil exécuté ponctuellement (local ou CI) pour régénérer un fichier `.ts`, pas un module importé par votre application en production.
+
+## Usage
+
+### CLI `aurabase-gen`
+
+```bash
+npx aurabase-gen --url http://localhost:8080 --project my-project --key aura_anon_xxx --out database.types.ts
+```
+
+Options complètes :
+
+```
+aurabase-gen --url <baseUrl> --project <id> [--key <apiKey>] [--out database.types.ts] [--schema public] [--type-name Database]
+```
+
+Sans `--out`, la sortie est écrite sur `stdout` plutôt que dans un fichier.
+
+### Utilisation programmatique
+
+```ts
+import { generateDatabaseTypes } from '@aurabase/gen'
+import type { SchemaTable } from '@aurabase/core'
+
+const tables: SchemaTable[] = [
+  {
+    name: 'posts',
+    primary_key: 'id',
+    columns: [
+      { name: 'id', col_type: 'uuid', nullable: false, unique: true, default_val: 'gen_random_uuid()', references: null },
+      { name: 'title', col_type: 'text', nullable: false, unique: false, default_val: null, references: null },
+    ],
+    indexes: [],
+    rls_enabled: false,
+    realtime_enabled: false,
+  },
+]
+
+const source = generateDatabaseTypes(tables, { schemaName: 'public', typeName: 'Database' })
+```
+
+### Workflow complet (typage bout-en-bout avec `@aurabase/db`)
+
+```bash
+npx aurabase-gen --url http://localhost:8080 --project my-project --key aura_anon_xxx --out database.types.ts
+```
+
+```ts
+import { createClient } from '@aurabase/aurabase-js'
+import type { Database } from './database.types' // fichier généré à l'étape précédente
+
+const aura = createClient<Database>('http://localhost:8080', 'my-project', 'aura_anon_xxx')
+
+// select()/insert()/update() sont désormais inférés depuis les colonnes réelles de `posts`.
+const { data } = await aura.db.from('posts').select('id,title').eq('id', 'post-id').single()
+```
+
+## Limitations
+
+- `Views`, `Functions`, `Enums` et `CompositeTypes` sont toujours générés vides (`Record<string, never>`) — seules les `Tables` sont introspectées et typées.
+- Un seul schéma à la fois (`--schema`, défaut `public`) : pas de génération multi-schémas en une seule invocation.
+- Dépend de l'endpoint `/schema` exposé par `aura.db.schema()` côté backend — un projet ou une clé sans droit de lecture du schéma ne peut pas générer de types (erreur explicite, pas de repli silencieux).
+- Pas de détection de types enum Postgres dédiés : un `col_type` non reconnu retombe sur `unknown`.
+- Le fichier généré est un instantané : il ne se met pas à jour automatiquement quand le schéma change côté backend (pas de mode watch).
+
+## Documentation
+
+Référence complète du SDK (tous les services, types partagés, SSR) : [README racine](../../README.md).

package/dist/cli.cjs

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs = require('fs');
+var aurabaseJs = require('@aurabase/aurabase-js');
+
+// src/generate.ts
+function enumRef(name, ctx) {
+  return ctx.enumNames.has(name) ? `${ctx.typeName}['${ctx.schemaName}']['Enums']['${name}']` : (
+    // Enum inconnu du bloc Enums → auto-référence non résoluble → repli textuel.
+    "string"
+  );
+}
+function mapColType(colType, ctx) {
+  if (typeof colType === "string") {
+    switch (colType) {
+      case "text":
+      case "varchar":
+      case "bpchar":
+      case "uuid":
+      case "timestamp":
+      case "timestamptz":
+      case "date":
+      case "time":
+      case "bytea":
+      case "numeric":
+        return "string";
+      case "int":
+      case "int2":
+      case "int4":
+      case "int8":
+      case "bigint":
+      case "float":
+      case "float4":
+      case "float8":
+        return "number";
+      case "bool":
+        return "boolean";
+      case "json":
+      case "jsonb":
+        return "Json";
+      default:
+        return "unknown";
+    }
+  }
+  if (colType && typeof colType === "object") {
+    if ("array" in colType) return `${mapColType(colType.array, ctx)}[]`;
+    if ("vector" in colType) return "number[]";
+    if ("enum" in colType) return enumRef(String(colType.enum), ctx);
+  }
+  return "unknown";
+}
+function mapPgType(raw, ctx) {
+  if (raw.startsWith("_")) return `${mapPgType(raw.slice(1), ctx)}[]`;
+  switch (raw) {
+    case "int2":
+    case "int4":
+    case "int8":
+    case "float4":
+    case "float8":
+      return "number";
+    case "numeric":
+      return "string";
+    case "bool":
+      return "boolean";
+    case "text":
+    case "varchar":
+    case "bpchar":
+    case "citext":
+    case "uuid":
+    case "date":
+    case "time":
+    case "timetz":
+    case "timestamp":
+    case "timestamptz":
+    case "bytea":
+      return "string";
+    case "json":
+    case "jsonb":
+      return "Json";
+    case "void":
+      return "undefined";
+    case "record":
+      return "unknown";
+    default:
+      return ctx.enumNames.has(raw) ? enumRef(raw, ctx) : "unknown";
+  }
+}
+function tsType(col, ctx) {
+  const base = mapColType(col.col_type, ctx);
+  return col.nullable ? `${base} | null` : base;
+}
+function genRow(cols, ctx) {
+  return cols.map((c) => `          ${c.name}: ${tsType(c, ctx)}`).join("\n");
+}
+var AUTO_COLS = /* @__PURE__ */ new Set(["id", "created_at", "updated_at"]);
+function isInsertOptional(col) {
+  return col.nullable || col.default_val != null || AUTO_COLS.has(col.name);
+}
+function genInsert(cols, ctx) {
+  return cols.map((c) => `          ${c.name}${isInsertOptional(c) ? "?" : ""}: ${tsType(c, ctx)}`).join("\n");
+}
+function genUpdate(cols, ctx) {
+  return cols.map((c) => `          ${c.name}?: ${tsType(c, ctx)}`).join("\n");
+}
+function genRelationships(t) {
+  const fks = t.columns.filter((c) => c.references);
+  if (fks.length === 0) return "[]";
+  const groups = /* @__PURE__ */ new Map();
+  for (const c of fks) {
+    const ref = c.references;
+    const name = ref.constraint_name ?? `${t.name}_${c.name}_fkey`;
+    const key = ref.constraint_name ?? `\0synthetic\0${c.name}`;
+    let g = groups.get(key);
+    if (!g) {
+      g = { name, columns: [], refTable: ref.table, refColumns: [], cols: [] };
+      groups.set(key, g);
+    }
+    g.columns.push(c.name);
+    g.refColumns.push(ref.column);
+    g.cols.push(c);
+  }
+  const entries = [...groups.values()].map((g) => {
+    const isOneToOne = g.cols.every((c) => c.unique || t.primary_key === c.name);
+    const cols = g.columns.map((c) => `'${c}'`).join(", ");
+    const refCols = g.refColumns.map((c) => `'${c}'`).join(", ");
+    return `          {
+            foreignKeyName: '${g.name}'
+            columns: [${cols}]
+            isOneToOne: ${isOneToOne}
+            referencedRelation: '${g.refTable}'
+            referencedColumns: [${refCols}]
+          }`;
+  });
+  return `[
+${entries.join(",\n")}
+        ]`;
+}
+function genFunctionArgs(fn, ctx) {
+  const inputArgs = fn.args.filter((a) => a.mode.toUpperCase() !== "OUT");
+  if (inputArgs.length === 0) return "Record<string, never>";
+  const entries = inputArgs.map((a) => `${a.name}: ${mapPgType(a.data_type, ctx)}`).join("; ");
+  return `{ ${entries} }`;
+}
+function mapReturnType(fn, ctx) {
+  const base = mapPgType(fn.returns, ctx);
+  if (!fn.is_set_returning) return base;
+  return base === "unknown" ? "Record<string, unknown>[]" : `${base}[]`;
+}
+function genSetofOptions(fn, ctx) {
+  if (!fn.is_set_returning) return null;
+  const to = ctx.relationNames.has(fn.returns) ? fn.returns : fn.name;
+  return `{ isSetofReturn: true; isOneToOne: false; to: '${to}'; from: '*' }`;
+}
+function genFunctionsBody(functions, ctx) {
+  if (functions.length === 0) return "Record<string, never>";
+  const groups = /* @__PURE__ */ new Map();
+  for (const fn of functions) {
+    const g = groups.get(fn.name);
+    if (g) g.push(fn);
+    else groups.set(fn.name, [fn]);
+  }
+  const entries = [...groups.values()].map((overloads) => {
+    const argsUnion = uniq(overloads.map((fn) => genFunctionArgs(fn, ctx))).join(" | ");
+    const returnsUnion = uniq(overloads.map((fn) => mapReturnType(fn, ctx))).join(" | ");
+    const lines = [
+      `      ${overloads[0].name}: {`,
+      `        Args: ${argsUnion}`,
+      `        Returns: ${returnsUnion}`
+    ];
+    if (overloads.length === 1) {
+      const setofOptions = genSetofOptions(overloads[0], ctx);
+      if (setofOptions) lines.push(`        SetofOptions: ${setofOptions}`);
+    }
+    lines.push("      }");
+    return lines.join("\n");
+  });
+  return `{
+${entries.join("\n")}
+    }`;
+}
+function uniq(items) {
+  return [...new Set(items)];
+}
+function genEnumsBody(enums) {
+  if (enums.length === 0) return "Record<string, never>";
+  const entries = enums.map((e) => {
+    const union = e.values.length === 0 ? "never" : e.values.map((v) => `'${v}'`).join(" | ");
+    return `      ${e.name}: ${union}`;
+  });
+  return `{
+${entries.join("\n")}
+    }`;
+}
+function genViewsBody(views, ctx) {
+  if (views.length === 0) return "Record<string, never>";
+  const entries = views.map(
+    (v) => `      ${v.name}: {
+        Row: {
+${genRow(v.columns, ctx)}
+        }
+        Relationships: []
+      }`
+  );
+  return `{
+${entries.join("\n")}
+    }`;
+}
+var HEADER = `// ============================================================
+// Types TypeScript auto-g\xE9n\xE9r\xE9s par Aurabase (@aurabase/gen)
+// NE PAS MODIFIER \u2014 r\xE9g\xE9n\xE9rer avec \`npx @aurabase/gen\`
+// ============================================================
+`;
+function generateDatabaseTypes(tables, options = {}) {
+  const schemaName = options.schemaName ?? "public";
+  const typeName = options.typeName ?? "Database";
+  const enums = options.enums ?? [];
+  const views = options.views ?? [];
+  const relationNames = new Set([...tables, ...views].map((r) => r.name));
+  const ctx = { typeName, schemaName, enumNames: new Set(enums.map((e) => e.name)), relationNames };
+  const functionsBody = genFunctionsBody(options.functions ?? [], ctx);
+  const enumsBody = genEnumsBody(enums);
+  const viewsBody = genViewsBody(views, ctx);
+  const tablesBody = tables.length === 0 ? "Record<string, never>" : `{
+${tables.map(
+    (t) => `      ${t.name}: {
+        Row: {
+${genRow(t.columns, ctx)}
+        }
+        Insert: {
+${genInsert(t.columns, ctx)}
+        }
+        Update: {
+${genUpdate(t.columns, ctx)}
+        }
+        Relationships: ${genRelationships(t)}
+      }`
+  ).join("\n")}
+    }`;
+  return `${HEADER}
+export type Json =
+  | string
+  | number
+  | boolean
+  | null
+  | { [key: string]: Json | undefined }
+  | Json[]
+
+export interface ${typeName} {
+  ${schemaName}: {
+    Tables: ${tablesBody}
+    Views: ${viewsBody}
+    Functions: ${functionsBody}
+    Enums: ${enumsBody}
+    CompositeTypes: Record<string, never>
+  }
+}
+`;
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  const a = {};
+  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;
+}
+var USAGE = `Usage: aurabase-gen --url <baseUrl> --project <id> [--key <apiKey>] [--out database.types.ts] [--schema public] [--type-name Database]`;
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (!args.url || !args.project) {
+    console.error(USAGE);
+    process.exit(1);
+  }
+  const client = aurabaseJs.createClient(args.url, args.project, args.key);
+  const { data, error } = await client.db.schema();
+  if (error) {
+    console.error(`[aurabase-gen] Erreur de r\xE9cup\xE9ration du sch\xE9ma : ${error.message}`);
+    process.exit(1);
+  }
+  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\xE9ma vide (aucune table).");
+  }
+  const output = generateDatabaseTypes(tables, {
+    schemaName: args.schema,
+    typeName: args.typeName,
+    functions,
+    enums,
+    views
+  });
+  if (args.out) {
+    fs.writeFileSync(args.out, output);
+    console.error(
+      `[aurabase-gen] \u2713 Types \xE9crits 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/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+import { writeFileSync } from 'fs';
+import { createClient } from '@aurabase/aurabase-js';
+
+// src/generate.ts
+function enumRef(name, ctx) {
+  return ctx.enumNames.has(name) ? `${ctx.typeName}['${ctx.schemaName}']['Enums']['${name}']` : (
+    // Enum inconnu du bloc Enums → auto-référence non résoluble → repli textuel.
+    "string"
+  );
+}
+function mapColType(colType, ctx) {
+  if (typeof colType === "string") {
+    switch (colType) {
+      case "text":
+      case "varchar":
+      case "bpchar":
+      case "uuid":
+      case "timestamp":
+      case "timestamptz":
+      case "date":
+      case "time":
+      case "bytea":
+      case "numeric":
+        return "string";
+      case "int":
+      case "int2":
+      case "int4":
+      case "int8":
+      case "bigint":
+      case "float":
+      case "float4":
+      case "float8":
+        return "number";
+      case "bool":
+        return "boolean";
+      case "json":
+      case "jsonb":
+        return "Json";
+      default:
+        return "unknown";
+    }
+  }
+  if (colType && typeof colType === "object") {
+    if ("array" in colType) return `${mapColType(colType.array, ctx)}[]`;
+    if ("vector" in colType) return "number[]";
+    if ("enum" in colType) return enumRef(String(colType.enum), ctx);
+  }
+  return "unknown";
+}
+function mapPgType(raw, ctx) {
+  if (raw.startsWith("_")) return `${mapPgType(raw.slice(1), ctx)}[]`;
+  switch (raw) {
+    case "int2":
+    case "int4":
+    case "int8":
+    case "float4":
+    case "float8":
+      return "number";
+    case "numeric":
+      return "string";
+    case "bool":
+      return "boolean";
+    case "text":
+    case "varchar":
+    case "bpchar":
+    case "citext":
+    case "uuid":
+    case "date":
+    case "time":
+    case "timetz":
+    case "timestamp":
+    case "timestamptz":
+    case "bytea":
+      return "string";
+    case "json":
+    case "jsonb":
+      return "Json";
+    case "void":
+      return "undefined";
+    case "record":
+      return "unknown";
+    default:
+      return ctx.enumNames.has(raw) ? enumRef(raw, ctx) : "unknown";
+  }
+}
+function tsType(col, ctx) {
+  const base = mapColType(col.col_type, ctx);
+  return col.nullable ? `${base} | null` : base;
+}
+function genRow(cols, ctx) {
+  return cols.map((c) => `          ${c.name}: ${tsType(c, ctx)}`).join("\n");
+}
+var AUTO_COLS = /* @__PURE__ */ new Set(["id", "created_at", "updated_at"]);
+function isInsertOptional(col) {
+  return col.nullable || col.default_val != null || AUTO_COLS.has(col.name);
+}
+function genInsert(cols, ctx) {
+  return cols.map((c) => `          ${c.name}${isInsertOptional(c) ? "?" : ""}: ${tsType(c, ctx)}`).join("\n");
+}
+function genUpdate(cols, ctx) {
+  return cols.map((c) => `          ${c.name}?: ${tsType(c, ctx)}`).join("\n");
+}
+function genRelationships(t) {
+  const fks = t.columns.filter((c) => c.references);
+  if (fks.length === 0) return "[]";
+  const groups = /* @__PURE__ */ new Map();
+  for (const c of fks) {
+    const ref = c.references;
+    const name = ref.constraint_name ?? `${t.name}_${c.name}_fkey`;
+    const key = ref.constraint_name ?? `\0synthetic\0${c.name}`;
+    let g = groups.get(key);
+    if (!g) {
+      g = { name, columns: [], refTable: ref.table, refColumns: [], cols: [] };
+      groups.set(key, g);
+    }
+    g.columns.push(c.name);
+    g.refColumns.push(ref.column);
+    g.cols.push(c);
+  }
+  const entries = [...groups.values()].map((g) => {
+    const isOneToOne = g.cols.every((c) => c.unique || t.primary_key === c.name);
+    const cols = g.columns.map((c) => `'${c}'`).join(", ");
+    const refCols = g.refColumns.map((c) => `'${c}'`).join(", ");
+    return `          {
+            foreignKeyName: '${g.name}'
+            columns: [${cols}]
+            isOneToOne: ${isOneToOne}
+            referencedRelation: '${g.refTable}'
+            referencedColumns: [${refCols}]
+          }`;
+  });
+  return `[
+${entries.join(",\n")}
+        ]`;
+}
+function genFunctionArgs(fn, ctx) {
+  const inputArgs = fn.args.filter((a) => a.mode.toUpperCase() !== "OUT");
+  if (inputArgs.length === 0) return "Record<string, never>";
+  const entries = inputArgs.map((a) => `${a.name}: ${mapPgType(a.data_type, ctx)}`).join("; ");
+  return `{ ${entries} }`;
+}
+function mapReturnType(fn, ctx) {
+  const base = mapPgType(fn.returns, ctx);
+  if (!fn.is_set_returning) return base;
+  return base === "unknown" ? "Record<string, unknown>[]" : `${base}[]`;
+}
+function genSetofOptions(fn, ctx) {
+  if (!fn.is_set_returning) return null;
+  const to = ctx.relationNames.has(fn.returns) ? fn.returns : fn.name;
+  return `{ isSetofReturn: true; isOneToOne: false; to: '${to}'; from: '*' }`;
+}
+function genFunctionsBody(functions, ctx) {
+  if (functions.length === 0) return "Record<string, never>";
+  const groups = /* @__PURE__ */ new Map();
+  for (const fn of functions) {
+    const g = groups.get(fn.name);
+    if (g) g.push(fn);
+    else groups.set(fn.name, [fn]);
+  }
+  const entries = [...groups.values()].map((overloads) => {
+    const argsUnion = uniq(overloads.map((fn) => genFunctionArgs(fn, ctx))).join(" | ");
+    const returnsUnion = uniq(overloads.map((fn) => mapReturnType(fn, ctx))).join(" | ");
+    const lines = [
+      `      ${overloads[0].name}: {`,
+      `        Args: ${argsUnion}`,
+      `        Returns: ${returnsUnion}`
+    ];
+    if (overloads.length === 1) {
+      const setofOptions = genSetofOptions(overloads[0], ctx);
+      if (setofOptions) lines.push(`        SetofOptions: ${setofOptions}`);
+    }
+    lines.push("      }");
+    return lines.join("\n");
+  });
+  return `{
+${entries.join("\n")}
+    }`;
+}
+function uniq(items) {
+  return [...new Set(items)];
+}
+function genEnumsBody(enums) {
+  if (enums.length === 0) return "Record<string, never>";
+  const entries = enums.map((e) => {
+    const union = e.values.length === 0 ? "never" : e.values.map((v) => `'${v}'`).join(" | ");
+    return `      ${e.name}: ${union}`;
+  });
+  return `{
+${entries.join("\n")}
+    }`;
+}
+function genViewsBody(views, ctx) {
+  if (views.length === 0) return "Record<string, never>";
+  const entries = views.map(
+    (v) => `      ${v.name}: {
+        Row: {
+${genRow(v.columns, ctx)}
+        }
+        Relationships: []
+      }`
+  );
+  return `{
+${entries.join("\n")}
+    }`;
+}
+var HEADER = `// ============================================================
+// Types TypeScript auto-g\xE9n\xE9r\xE9s par Aurabase (@aurabase/gen)
+// NE PAS MODIFIER \u2014 r\xE9g\xE9n\xE9rer avec \`npx @aurabase/gen\`
+// ============================================================
+`;
+function generateDatabaseTypes(tables, options = {}) {
+  const schemaName = options.schemaName ?? "public";
+  const typeName = options.typeName ?? "Database";
+  const enums = options.enums ?? [];
+  const views = options.views ?? [];
+  const relationNames = new Set([...tables, ...views].map((r) => r.name));
+  const ctx = { typeName, schemaName, enumNames: new Set(enums.map((e) => e.name)), relationNames };
+  const functionsBody = genFunctionsBody(options.functions ?? [], ctx);
+  const enumsBody = genEnumsBody(enums);
+  const viewsBody = genViewsBody(views, ctx);
+  const tablesBody = tables.length === 0 ? "Record<string, never>" : `{
+${tables.map(
+    (t) => `      ${t.name}: {
+        Row: {
+${genRow(t.columns, ctx)}
+        }
+        Insert: {
+${genInsert(t.columns, ctx)}
+        }
+        Update: {
+${genUpdate(t.columns, ctx)}
+        }
+        Relationships: ${genRelationships(t)}
+      }`
+  ).join("\n")}
+    }`;
+  return `${HEADER}
+export type Json =
+  | string
+  | number
+  | boolean
+  | null
+  | { [key: string]: Json | undefined }
+  | Json[]
+
+export interface ${typeName} {
+  ${schemaName}: {
+    Tables: ${tablesBody}
+    Views: ${viewsBody}
+    Functions: ${functionsBody}
+    Enums: ${enumsBody}
+    CompositeTypes: Record<string, never>
+  }
+}
+`;
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  const a = {};
+  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;
+}
+var USAGE = `Usage: aurabase-gen --url <baseUrl> --project <id> [--key <apiKey>] [--out database.types.ts] [--schema public] [--type-name Database]`;
+async function main() {
+  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\xE9cup\xE9ration du sch\xE9ma : ${error.message}`);
+    process.exit(1);
+  }
+  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\xE9ma 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] \u2713 Types \xE9crits 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/dist/index.cjs

@@ -0,0 +1,257 @@
+'use strict';
+
+// src/generate.ts
+function enumRef(name, ctx) {
+  return ctx.enumNames.has(name) ? `${ctx.typeName}['${ctx.schemaName}']['Enums']['${name}']` : (
+    // Enum inconnu du bloc Enums → auto-référence non résoluble → repli textuel.
+    "string"
+  );
+}
+function mapColType(colType, ctx) {
+  if (typeof colType === "string") {
+    switch (colType) {
+      case "text":
+      case "varchar":
+      case "bpchar":
+      case "uuid":
+      case "timestamp":
+      case "timestamptz":
+      case "date":
+      case "time":
+      case "bytea":
+      case "numeric":
+        return "string";
+      case "int":
+      case "int2":
+      case "int4":
+      case "int8":
+      case "bigint":
+      case "float":
+      case "float4":
+      case "float8":
+        return "number";
+      case "bool":
+        return "boolean";
+      case "json":
+      case "jsonb":
+        return "Json";
+      default:
+        return "unknown";
+    }
+  }
+  if (colType && typeof colType === "object") {
+    if ("array" in colType) return `${mapColType(colType.array, ctx)}[]`;
+    if ("vector" in colType) return "number[]";
+    if ("enum" in colType) return enumRef(String(colType.enum), ctx);
+  }
+  return "unknown";
+}
+function mapPgType(raw, ctx) {
+  if (raw.startsWith("_")) return `${mapPgType(raw.slice(1), ctx)}[]`;
+  switch (raw) {
+    case "int2":
+    case "int4":
+    case "int8":
+    case "float4":
+    case "float8":
+      return "number";
+    case "numeric":
+      return "string";
+    case "bool":
+      return "boolean";
+    case "text":
+    case "varchar":
+    case "bpchar":
+    case "citext":
+    case "uuid":
+    case "date":
+    case "time":
+    case "timetz":
+    case "timestamp":
+    case "timestamptz":
+    case "bytea":
+      return "string";
+    case "json":
+    case "jsonb":
+      return "Json";
+    case "void":
+      return "undefined";
+    case "record":
+      return "unknown";
+    default:
+      return ctx.enumNames.has(raw) ? enumRef(raw, ctx) : "unknown";
+  }
+}
+function tsType(col, ctx) {
+  const base = mapColType(col.col_type, ctx);
+  return col.nullable ? `${base} | null` : base;
+}
+function genRow(cols, ctx) {
+  return cols.map((c) => `          ${c.name}: ${tsType(c, ctx)}`).join("\n");
+}
+var AUTO_COLS = /* @__PURE__ */ new Set(["id", "created_at", "updated_at"]);
+function isInsertOptional(col) {
+  return col.nullable || col.default_val != null || AUTO_COLS.has(col.name);
+}
+function genInsert(cols, ctx) {
+  return cols.map((c) => `          ${c.name}${isInsertOptional(c) ? "?" : ""}: ${tsType(c, ctx)}`).join("\n");
+}
+function genUpdate(cols, ctx) {
+  return cols.map((c) => `          ${c.name}?: ${tsType(c, ctx)}`).join("\n");
+}
+function genRelationships(t) {
+  const fks = t.columns.filter((c) => c.references);
+  if (fks.length === 0) return "[]";
+  const groups = /* @__PURE__ */ new Map();
+  for (const c of fks) {
+    const ref = c.references;
+    const name = ref.constraint_name ?? `${t.name}_${c.name}_fkey`;
+    const key = ref.constraint_name ?? `\0synthetic\0${c.name}`;
+    let g = groups.get(key);
+    if (!g) {
+      g = { name, columns: [], refTable: ref.table, refColumns: [], cols: [] };
+      groups.set(key, g);
+    }
+    g.columns.push(c.name);
+    g.refColumns.push(ref.column);
+    g.cols.push(c);
+  }
+  const entries = [...groups.values()].map((g) => {
+    const isOneToOne = g.cols.every((c) => c.unique || t.primary_key === c.name);
+    const cols = g.columns.map((c) => `'${c}'`).join(", ");
+    const refCols = g.refColumns.map((c) => `'${c}'`).join(", ");
+    return `          {
+            foreignKeyName: '${g.name}'
+            columns: [${cols}]
+            isOneToOne: ${isOneToOne}
+            referencedRelation: '${g.refTable}'
+            referencedColumns: [${refCols}]
+          }`;
+  });
+  return `[
+${entries.join(",\n")}
+        ]`;
+}
+function genFunctionArgs(fn, ctx) {
+  const inputArgs = fn.args.filter((a) => a.mode.toUpperCase() !== "OUT");
+  if (inputArgs.length === 0) return "Record<string, never>";
+  const entries = inputArgs.map((a) => `${a.name}: ${mapPgType(a.data_type, ctx)}`).join("; ");
+  return `{ ${entries} }`;
+}
+function mapReturnType(fn, ctx) {
+  const base = mapPgType(fn.returns, ctx);
+  if (!fn.is_set_returning) return base;
+  return base === "unknown" ? "Record<string, unknown>[]" : `${base}[]`;
+}
+function genSetofOptions(fn, ctx) {
+  if (!fn.is_set_returning) return null;
+  const to = ctx.relationNames.has(fn.returns) ? fn.returns : fn.name;
+  return `{ isSetofReturn: true; isOneToOne: false; to: '${to}'; from: '*' }`;
+}
+function genFunctionsBody(functions, ctx) {
+  if (functions.length === 0) return "Record<string, never>";
+  const groups = /* @__PURE__ */ new Map();
+  for (const fn of functions) {
+    const g = groups.get(fn.name);
+    if (g) g.push(fn);
+    else groups.set(fn.name, [fn]);
+  }
+  const entries = [...groups.values()].map((overloads) => {
+    const argsUnion = uniq(overloads.map((fn) => genFunctionArgs(fn, ctx))).join(" | ");
+    const returnsUnion = uniq(overloads.map((fn) => mapReturnType(fn, ctx))).join(" | ");
+    const lines = [
+      `      ${overloads[0].name}: {`,
+      `        Args: ${argsUnion}`,
+      `        Returns: ${returnsUnion}`
+    ];
+    if (overloads.length === 1) {
+      const setofOptions = genSetofOptions(overloads[0], ctx);
+      if (setofOptions) lines.push(`        SetofOptions: ${setofOptions}`);
+    }
+    lines.push("      }");
+    return lines.join("\n");
+  });
+  return `{
+${entries.join("\n")}
+    }`;
+}
+function uniq(items) {
+  return [...new Set(items)];
+}
+function genEnumsBody(enums) {
+  if (enums.length === 0) return "Record<string, never>";
+  const entries = enums.map((e) => {
+    const union = e.values.length === 0 ? "never" : e.values.map((v) => `'${v}'`).join(" | ");
+    return `      ${e.name}: ${union}`;
+  });
+  return `{
+${entries.join("\n")}
+    }`;
+}
+function genViewsBody(views, ctx) {
+  if (views.length === 0) return "Record<string, never>";
+  const entries = views.map(
+    (v) => `      ${v.name}: {
+        Row: {
+${genRow(v.columns, ctx)}
+        }
+        Relationships: []
+      }`
+  );
+  return `{
+${entries.join("\n")}
+    }`;
+}
+var HEADER = `// ============================================================
+// Types TypeScript auto-g\xE9n\xE9r\xE9s par Aurabase (@aurabase/gen)
+// NE PAS MODIFIER \u2014 r\xE9g\xE9n\xE9rer avec \`npx @aurabase/gen\`
+// ============================================================
+`;
+function generateDatabaseTypes(tables, options = {}) {
+  const schemaName = options.schemaName ?? "public";
+  const typeName = options.typeName ?? "Database";
+  const enums = options.enums ?? [];
+  const views = options.views ?? [];
+  const relationNames = new Set([...tables, ...views].map((r) => r.name));
+  const ctx = { typeName, schemaName, enumNames: new Set(enums.map((e) => e.name)), relationNames };
+  const functionsBody = genFunctionsBody(options.functions ?? [], ctx);
+  const enumsBody = genEnumsBody(enums);
+  const viewsBody = genViewsBody(views, ctx);
+  const tablesBody = tables.length === 0 ? "Record<string, never>" : `{
+${tables.map(
+    (t) => `      ${t.name}: {
+        Row: {
+${genRow(t.columns, ctx)}
+        }
+        Insert: {
+${genInsert(t.columns, ctx)}
+        }
+        Update: {
+${genUpdate(t.columns, ctx)}
+        }
+        Relationships: ${genRelationships(t)}
+      }`
+  ).join("\n")}
+    }`;
+  return `${HEADER}
+export type Json =
+  | string
+  | number
+  | boolean
+  | null
+  | { [key: string]: Json | undefined }
+  | Json[]
+
+export interface ${typeName} {
+  ${schemaName}: {
+    Tables: ${tablesBody}
+    Views: ${viewsBody}
+    Functions: ${functionsBody}
+    Enums: ${enumsBody}
+    CompositeTypes: Record<string, never>
+  }
+}
+`;
+}
+
+exports.generateDatabaseTypes = generateDatabaseTypes;

package/dist/index.d.cts

@@ -0,0 +1,12 @@
+import { SchemaFunction, SchemaEnum, SchemaTable } from '@aurabase/core';
+
+interface GenerateOptions {
+    schemaName?: string;
+    typeName?: string;
+    functions?: SchemaFunction[];
+    enums?: SchemaEnum[];
+    views?: SchemaTable[];
+}
+declare function generateDatabaseTypes(tables: SchemaTable[], options?: GenerateOptions): string;
+
+export { type GenerateOptions, generateDatabaseTypes };

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { SchemaFunction, SchemaEnum, SchemaTable } from '@aurabase/core';
+
+interface GenerateOptions {
+    schemaName?: string;
+    typeName?: string;
+    functions?: SchemaFunction[];
+    enums?: SchemaEnum[];
+    views?: SchemaTable[];
+}
+declare function generateDatabaseTypes(tables: SchemaTable[], options?: GenerateOptions): string;
+
+export { type GenerateOptions, generateDatabaseTypes };

package/dist/index.js

@@ -0,0 +1,255 @@
+// src/generate.ts
+function enumRef(name, ctx) {
+  return ctx.enumNames.has(name) ? `${ctx.typeName}['${ctx.schemaName}']['Enums']['${name}']` : (
+    // Enum inconnu du bloc Enums → auto-référence non résoluble → repli textuel.
+    "string"
+  );
+}
+function mapColType(colType, ctx) {
+  if (typeof colType === "string") {
+    switch (colType) {
+      case "text":
+      case "varchar":
+      case "bpchar":
+      case "uuid":
+      case "timestamp":
+      case "timestamptz":
+      case "date":
+      case "time":
+      case "bytea":
+      case "numeric":
+        return "string";
+      case "int":
+      case "int2":
+      case "int4":
+      case "int8":
+      case "bigint":
+      case "float":
+      case "float4":
+      case "float8":
+        return "number";
+      case "bool":
+        return "boolean";
+      case "json":
+      case "jsonb":
+        return "Json";
+      default:
+        return "unknown";
+    }
+  }
+  if (colType && typeof colType === "object") {
+    if ("array" in colType) return `${mapColType(colType.array, ctx)}[]`;
+    if ("vector" in colType) return "number[]";
+    if ("enum" in colType) return enumRef(String(colType.enum), ctx);
+  }
+  return "unknown";
+}
+function mapPgType(raw, ctx) {
+  if (raw.startsWith("_")) return `${mapPgType(raw.slice(1), ctx)}[]`;
+  switch (raw) {
+    case "int2":
+    case "int4":
+    case "int8":
+    case "float4":
+    case "float8":
+      return "number";
+    case "numeric":
+      return "string";
+    case "bool":
+      return "boolean";
+    case "text":
+    case "varchar":
+    case "bpchar":
+    case "citext":
+    case "uuid":
+    case "date":
+    case "time":
+    case "timetz":
+    case "timestamp":
+    case "timestamptz":
+    case "bytea":
+      return "string";
+    case "json":
+    case "jsonb":
+      return "Json";
+    case "void":
+      return "undefined";
+    case "record":
+      return "unknown";
+    default:
+      return ctx.enumNames.has(raw) ? enumRef(raw, ctx) : "unknown";
+  }
+}
+function tsType(col, ctx) {
+  const base = mapColType(col.col_type, ctx);
+  return col.nullable ? `${base} | null` : base;
+}
+function genRow(cols, ctx) {
+  return cols.map((c) => `          ${c.name}: ${tsType(c, ctx)}`).join("\n");
+}
+var AUTO_COLS = /* @__PURE__ */ new Set(["id", "created_at", "updated_at"]);
+function isInsertOptional(col) {
+  return col.nullable || col.default_val != null || AUTO_COLS.has(col.name);
+}
+function genInsert(cols, ctx) {
+  return cols.map((c) => `          ${c.name}${isInsertOptional(c) ? "?" : ""}: ${tsType(c, ctx)}`).join("\n");
+}
+function genUpdate(cols, ctx) {
+  return cols.map((c) => `          ${c.name}?: ${tsType(c, ctx)}`).join("\n");
+}
+function genRelationships(t) {
+  const fks = t.columns.filter((c) => c.references);
+  if (fks.length === 0) return "[]";
+  const groups = /* @__PURE__ */ new Map();
+  for (const c of fks) {
+    const ref = c.references;
+    const name = ref.constraint_name ?? `${t.name}_${c.name}_fkey`;
+    const key = ref.constraint_name ?? `\0synthetic\0${c.name}`;
+    let g = groups.get(key);
+    if (!g) {
+      g = { name, columns: [], refTable: ref.table, refColumns: [], cols: [] };
+      groups.set(key, g);
+    }
+    g.columns.push(c.name);
+    g.refColumns.push(ref.column);
+    g.cols.push(c);
+  }
+  const entries = [...groups.values()].map((g) => {
+    const isOneToOne = g.cols.every((c) => c.unique || t.primary_key === c.name);
+    const cols = g.columns.map((c) => `'${c}'`).join(", ");
+    const refCols = g.refColumns.map((c) => `'${c}'`).join(", ");
+    return `          {
+            foreignKeyName: '${g.name}'
+            columns: [${cols}]
+            isOneToOne: ${isOneToOne}
+            referencedRelation: '${g.refTable}'
+            referencedColumns: [${refCols}]
+          }`;
+  });
+  return `[
+${entries.join(",\n")}
+        ]`;
+}
+function genFunctionArgs(fn, ctx) {
+  const inputArgs = fn.args.filter((a) => a.mode.toUpperCase() !== "OUT");
+  if (inputArgs.length === 0) return "Record<string, never>";
+  const entries = inputArgs.map((a) => `${a.name}: ${mapPgType(a.data_type, ctx)}`).join("; ");
+  return `{ ${entries} }`;
+}
+function mapReturnType(fn, ctx) {
+  const base = mapPgType(fn.returns, ctx);
+  if (!fn.is_set_returning) return base;
+  return base === "unknown" ? "Record<string, unknown>[]" : `${base}[]`;
+}
+function genSetofOptions(fn, ctx) {
+  if (!fn.is_set_returning) return null;
+  const to = ctx.relationNames.has(fn.returns) ? fn.returns : fn.name;
+  return `{ isSetofReturn: true; isOneToOne: false; to: '${to}'; from: '*' }`;
+}
+function genFunctionsBody(functions, ctx) {
+  if (functions.length === 0) return "Record<string, never>";
+  const groups = /* @__PURE__ */ new Map();
+  for (const fn of functions) {
+    const g = groups.get(fn.name);
+    if (g) g.push(fn);
+    else groups.set(fn.name, [fn]);
+  }
+  const entries = [...groups.values()].map((overloads) => {
+    const argsUnion = uniq(overloads.map((fn) => genFunctionArgs(fn, ctx))).join(" | ");
+    const returnsUnion = uniq(overloads.map((fn) => mapReturnType(fn, ctx))).join(" | ");
+    const lines = [
+      `      ${overloads[0].name}: {`,
+      `        Args: ${argsUnion}`,
+      `        Returns: ${returnsUnion}`
+    ];
+    if (overloads.length === 1) {
+      const setofOptions = genSetofOptions(overloads[0], ctx);
+      if (setofOptions) lines.push(`        SetofOptions: ${setofOptions}`);
+    }
+    lines.push("      }");
+    return lines.join("\n");
+  });
+  return `{
+${entries.join("\n")}
+    }`;
+}
+function uniq(items) {
+  return [...new Set(items)];
+}
+function genEnumsBody(enums) {
+  if (enums.length === 0) return "Record<string, never>";
+  const entries = enums.map((e) => {
+    const union = e.values.length === 0 ? "never" : e.values.map((v) => `'${v}'`).join(" | ");
+    return `      ${e.name}: ${union}`;
+  });
+  return `{
+${entries.join("\n")}
+    }`;
+}
+function genViewsBody(views, ctx) {
+  if (views.length === 0) return "Record<string, never>";
+  const entries = views.map(
+    (v) => `      ${v.name}: {
+        Row: {
+${genRow(v.columns, ctx)}
+        }
+        Relationships: []
+      }`
+  );
+  return `{
+${entries.join("\n")}
+    }`;
+}
+var HEADER = `// ============================================================
+// Types TypeScript auto-g\xE9n\xE9r\xE9s par Aurabase (@aurabase/gen)
+// NE PAS MODIFIER \u2014 r\xE9g\xE9n\xE9rer avec \`npx @aurabase/gen\`
+// ============================================================
+`;
+function generateDatabaseTypes(tables, options = {}) {
+  const schemaName = options.schemaName ?? "public";
+  const typeName = options.typeName ?? "Database";
+  const enums = options.enums ?? [];
+  const views = options.views ?? [];
+  const relationNames = new Set([...tables, ...views].map((r) => r.name));
+  const ctx = { typeName, schemaName, enumNames: new Set(enums.map((e) => e.name)), relationNames };
+  const functionsBody = genFunctionsBody(options.functions ?? [], ctx);
+  const enumsBody = genEnumsBody(enums);
+  const viewsBody = genViewsBody(views, ctx);
+  const tablesBody = tables.length === 0 ? "Record<string, never>" : `{
+${tables.map(
+    (t) => `      ${t.name}: {
+        Row: {
+${genRow(t.columns, ctx)}
+        }
+        Insert: {
+${genInsert(t.columns, ctx)}
+        }
+        Update: {
+${genUpdate(t.columns, ctx)}
+        }
+        Relationships: ${genRelationships(t)}
+      }`
+  ).join("\n")}
+    }`;
+  return `${HEADER}
+export type Json =
+  | string
+  | number
+  | boolean
+  | null
+  | { [key: string]: Json | undefined }
+  | Json[]
+
+export interface ${typeName} {
+  ${schemaName}: {
+    Tables: ${tablesBody}
+    Views: ${viewsBody}
+    Functions: ${functionsBody}
+    Enums: ${enumsBody}
+    CompositeTypes: Record<string, never>
+  }
+}
+`;
+}
+
+export { generateDatabaseTypes };

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@aurabase/gen",
+  "version": "0.4.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"
+  ],
+  "dependencies": {
+    "@aurabase/core": "0.4.0",
+    "@aurabase/aurabase-js": "0.4.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^4.1.6",
+    "@types/node": "20.14.15"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  }
+}