@aurabase/gen 0.5.2 → 0.5.4

package/README.md

@@ -1,6 +1,6 @@
 # @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).
+Générateur de types TypeScript `Database` pour le SDK Aurabase : introspecte le schéma d'un projet et produit un fichier de types complet avec helpers génériques (`Tables`, `TablesInsert`, `TablesUpdate`, `Enums`) compatible avec l'inférence de `@aurabase/db`.
 
 ![npm](https://img.shields.io/npm/v/@aurabase/gen) ![license](https://img.shields.io/badge/license-MIT-blue)
 
@@ -14,71 +14,83 @@ Fait partie de l'écosystème du SDK **[@aurabase/aurabase-js](../aurabase)**, m
 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.
+> S'installe typiquement en devDependency (ou s'exécute via `npx` sans installation).
 
 ## Usage
 
 ### CLI `aurabase-gen`
 
+Le CLI détecte automatiquement les variables d'environnement de votre projet (`.env`, `.env.local`, `.env.development`) :
+
+```bash
+# Détection automatique de AURABASE_URL et AURABASE_ANON_KEY / AURABASE_SERVICE_ROLE_KEY :
+npx @aurabase/gen --out src/types/database.types.ts
+```
+
+Ou en passant les paramètres explicitement :
+
 ```bash
-npx aurabase-gen --url https://mon-projet.aurabase.cloud --key aura_anon_xxx --out database.types.ts
+npx @aurabase/gen --url https://mon-projet.aurabase.cloud --key aura_anon_xxx --out database.types.ts
 ```
 
 Options complètes :
 
 ```
-aurabase-gen --url <projectUrl> --key <apiKey> [--out database.types.ts] [--schema public] [--type-name Database]
+aurabase-gen [options]
+
+  --url <url>         URL du projet Aurabase (ex: https://mon-projet.aurabase.cloud)
+                      [Auto-détection : AURABASE_URL, NEXT_PUBLIC_AURABASE_URL, VITE_AURABASE_URL]
+  --key <cle>         Clé API du projet (anon ou service_role)
+                      [Auto-détection : AURABASE_API_KEY, AURABASE_ANON_KEY, AURABASE_SERVICE_ROLE_KEY]
+  -o, --out <fichier> Fichier de destination (ex: src/types/database.types.ts)
+                      Si omis, le résultat est écrit sur stdout.
+  -s, --schema <nom>  Nom du schéma de base de données (défaut : 'public')
+  -t, --type-name <t> Nom de l'interface principale générée (défaut : 'Database')
+  --allow-empty       Générer les types même si des tables n'ont pas de colonnes déclarées
+  -h, --help          Afficher l'aide
+  -v, --version       Afficher la version
 ```
 
-Sans `--out`, la sortie est écrite sur `stdout` plutôt que dans un fichier.
+### Type Helpers générés
 
-### Utilisation programmatique
+Le fichier généré exporte l'interface principale `Database` ainsi que des type helpers de commodité pour vos composants et services :
 
 ```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' })
+import type { Tables, TablesInsert, TablesUpdate, Enums } from './database.types'
+
+// Type d'une ligne d'une table ou vue
+type Post = Tables<'posts'>
+
+// Type de la charge utile d'insertion (id, created_at optionnels)
+type NewPost = TablesInsert<'posts'>
+
+// Type de la charge utile de mise à jour (tous champs optionnels)
+type PostUpdate = TablesUpdate<'posts'>
+
+// Type d'une énumération Postgres
+type UserRole = Enums<'user_role'>
 ```
 
-### Workflow complet (typage bout-en-bout avec `@aurabase/db`)
+### Workflow complet avec `@aurabase/db`
 
 ```bash
-npx aurabase-gen --url https://mon-projet.aurabase.cloud --key aura_anon_xxx --out database.types.ts
+npx @aurabase/gen --out src/types/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
+import type { Database } from './database.types'
 
 const aura = createClient<Database>('https://mon-projet.aurabase.cloud', '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()
+// select(), filtres, embeds et mutations sont désormais typés et auto-complétés :
+const { data, count, error } = await aura.db
+  .from('posts')
+  .select('id,title,author:users(name)', { count: 'exact' })
+  .eq('published', true)
+  .range(0, 9)
 ```
 
-## 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

@@ -2,6 +2,7 @@
 'use strict';
 
 var fs = require('fs');
+var path = require('path');
 var aurabaseJs = require('@aurabase/aurabase-js');
 
 // src/generate.ts
@@ -260,10 +261,123 @@ export interface ${typeName} {
     CompositeTypes: Record<string, never>
   }
 }
+
+export type Tables<
+  PublicTableNameOrOptions extends
+    | keyof (${typeName}['${schemaName}']['Tables'] & ${typeName}['${schemaName}']['Views'])
+    | { schema: keyof ${typeName} },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof (${typeName}[PublicTableNameOrOptions['schema']]['Tables'] &
+        ${typeName}[PublicTableNameOrOptions['schema']]['Views'])
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+  ? (${typeName}[PublicTableNameOrOptions['schema']]['Tables'] &
+      ${typeName}[PublicTableNameOrOptions['schema']]['Views'])[TableName] extends {
+      Row: infer R
+    }
+    ? R
+    : never
+  : PublicTableNameOrOptions extends keyof (${typeName}['${schemaName}']['Tables'] &
+        ${typeName}['${schemaName}']['Views'])
+    ? (${typeName}['${schemaName}']['Tables'] &
+        ${typeName}['${schemaName}']['Views'])[PublicTableNameOrOptions] extends {
+        Row: infer R
+      }
+      ? R
+      : never
+    : never
+
+export type TablesInsert<
+  PublicTableNameOrOptions extends
+    | keyof ${typeName}['${schemaName}']['Tables']
+    | { schema: keyof ${typeName} },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof ${typeName}[PublicTableNameOrOptions['schema']]['Tables']
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+  ? ${typeName}[PublicTableNameOrOptions['schema']]['Tables'][TableName] extends {
+      Insert: infer I
+    }
+    ? I
+    : never
+  : PublicTableNameOrOptions extends keyof ${typeName}['${schemaName}']['Tables']
+    ? ${typeName}['${schemaName}']['Tables'][PublicTableNameOrOptions] extends {
+        Insert: infer I
+      }
+      ? I
+      : never
+    : never
+
+export type TablesUpdate<
+  PublicTableNameOrOptions extends
+    | keyof ${typeName}['${schemaName}']['Tables']
+    | { schema: keyof ${typeName} },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof ${typeName}[PublicTableNameOrOptions['schema']]['Tables']
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+  ? ${typeName}[PublicTableNameOrOptions['schema']]['Tables'][TableName] extends {
+      Update: infer U
+    }
+    ? U
+    : never
+  : PublicTableNameOrOptions extends keyof ${typeName}['${schemaName}']['Tables']
+    ? ${typeName}['${schemaName}']['Tables'][PublicTableNameOrOptions] extends {
+        Update: infer U
+      }
+      ? U
+      : never
+    : never
+
+export type Enums<
+  PublicEnumNameOrOptions extends
+    | keyof ${typeName}['${schemaName}']['Enums']
+    | { schema: keyof ${typeName} },
+  EnumName extends PublicEnumNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof ${typeName}[PublicEnumNameOrOptions['schema']]['Enums']
+    : never = never,
+> = PublicEnumNameOrOptions extends { schema: keyof ${typeName} }
+  ? ${typeName}[PublicEnumNameOrOptions['schema']]['Enums'][EnumName]
+  : PublicEnumNameOrOptions extends keyof ${typeName}['${schemaName}']['Enums']
+    ? ${typeName}['${schemaName}']['Enums'][PublicEnumNameOrOptions]
+    : never
 `;
 }
 
 // src/cli.ts
+var VERSION = "0.5.4";
+function loadEnvFiles() {
+  const envCandidates = [".env.local", ".env.development.local", ".env.development", ".env"];
+  for (const file of envCandidates) {
+    const fullPath = path.resolve(process.cwd(), file);
+    if (fs.existsSync(fullPath)) {
+      try {
+        if (typeof process.loadEnvFile === "function") {
+          ;
+          process.loadEnvFile(fullPath);
+        } else {
+          const content = fs.readFileSync(fullPath, "utf-8");
+          for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#")) continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx > 0) {
+              const k = trimmed.slice(0, eqIdx).trim();
+              let v = trimmed.slice(eqIdx + 1).trim();
+              if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+                v = v.slice(1, -1);
+              }
+              if (!process.env[k]) {
+                process.env[k] = v;
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+}
 function diagnostiquerSchema(tables) {
   if (tables.length === 0) {
     return "Sch\xE9ma vide : aucune table. Les types g\xE9n\xE9r\xE9s seraient inutilisables.";
@@ -277,8 +391,9 @@ function diagnostiquerSchema(tables) {
 function parseArgs(argv) {
   const a = {};
   for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
     const v = argv[i + 1];
-    switch (argv[i]) {
+    switch (arg) {
       case "--url":
         a.url = v;
         i++;
@@ -288,14 +403,17 @@ function parseArgs(argv) {
         i++;
         break;
       case "--out":
+      case "-o":
         a.out = v;
         i++;
         break;
       case "--schema":
+      case "-s":
         a.schema = v;
         i++;
         break;
       case "--type-name":
+      case "-t":
         a.typeName = v;
         i++;
         break;
@@ -303,18 +421,69 @@ function parseArgs(argv) {
       case "--allow-empty":
         a.allowEmpty = true;
         break;
+      case "--help":
+      case "-h":
+        a.help = true;
+        break;
+      case "--version":
+      case "-v":
+        a.version = true;
+        break;
     }
   }
   return a;
 }
-var USAGE = `Usage: aurabase-gen --url <projectUrl> --key <apiKey> [--out database.types.ts] [--schema public] [--type-name Database] [--allow-empty]`;
+var HELP_TEXT = `
+aurabase-gen (v${VERSION}) \u2014 G\xE9n\xE9rateur de types TypeScript pour Aurabase
+
+USAGE :
+  npx @aurabase/gen [options]
+  aurabase-gen --url <projectUrl> --key <apiKey> [--out <fichier>]
+
+OPTIONS :
+  --url <url>         URL du projet Aurabase (ex: https://mon-projet.aurabase.cloud)
+                      [Auto-d\xE9tection : AURABASE_URL, NEXT_PUBLIC_AURABASE_URL, VITE_AURABASE_URL]
+  --key <cle>         Cl\xE9 API du projet (anon ou service_role)
+                      [Auto-d\xE9tection : AURABASE_API_KEY, AURABASE_ANON_KEY, AURABASE_SERVICE_ROLE_KEY]
+  -o, --out <fichier> Fichier de destination (ex: src/types/database.types.ts)
+                      Si omis, le r\xE9sultat est \xE9crit sur stdout.
+  -s, --schema <nom>  Nom du sch\xE9ma de base de donn\xE9es (d\xE9faut : 'public')
+  -t, --type-name <t> Nom de l'interface principale g\xE9n\xE9r\xE9e (d\xE9faut : 'Database')
+  --allow-empty       G\xE9n\xE9rer les types m\xEAme si des tables n'ont pas de colonnes d\xE9clar\xE9es
+  -h, --help          Afficher cette aide
+  -v, --version       Afficher la version
+
+EXEMPLES :
+  # G\xE9n\xE9ration avec lecture automatique des variables d'environnement (.env / .env.local) :
+  npx @aurabase/gen --out src/types/database.types.ts
+
+  # Param\xE8tres explicites :
+  npx @aurabase/gen --url https://xyz.aurabase.cloud --key aura_anon_123 --out db.types.ts
+`;
 async function main() {
+  loadEnvFiles();
   const args = parseArgs(process.argv.slice(2));
-  if (!args.url || !args.key) {
-    console.error(USAGE);
+  if (args.help) {
+    console.log(HELP_TEXT.trim());
+    process.exit(0);
+  }
+  if (args.version) {
+    console.log(`aurabase-gen v${VERSION}`);
+    process.exit(0);
+  }
+  const url = args.url ?? process.env.AURABASE_URL ?? process.env.NEXT_PUBLIC_AURABASE_URL ?? process.env.VITE_AURABASE_URL;
+  const key = args.key ?? process.env.AURABASE_SERVICE_ROLE_KEY ?? process.env.AURABASE_API_KEY ?? process.env.AURABASE_ANON_KEY ?? process.env.NEXT_PUBLIC_AURABASE_ANON_KEY ?? process.env.VITE_AURABASE_ANON_KEY;
+  if (!url || !key) {
+    console.error("[aurabase-gen] Erreur : URL et/ou cl\xE9 API du projet manquantes.\n");
+    console.error("Sp\xE9cifiez-les via les arguments CLI (--url et --key) ou dans vos variables d\u2019environnement (.env / .env.local) :");
+    console.error("  AURABASE_URL=https://<slug>.aurabase.cloud");
+    console.error("  AURABASE_ANON_KEY=aura_anon_...\n");
+    console.error("Ex\xE9cutez `npx @aurabase/gen --help` pour afficher toutes les options disponibles.");
     process.exit(1);
   }
-  const client = aurabaseJs.createClient(args.url, args.key);
+  const schemaName = args.schema ?? process.env.AURABASE_SCHEMA ?? "public";
+  const outPath = args.out ?? process.env.AURABASE_TYPES_OUT;
+  const client = aurabaseJs.createClient(url, key);
   const { data, error } = await client.db.schema();
   if (error) {
     console.error(`[aurabase-gen] Erreur de r\xE9cup\xE9ration du sch\xE9ma : ${error.message}`);
@@ -332,16 +501,16 @@ async function main() {
     console.error(`[aurabase-gen] Avertissement (--allow-empty) : ${probleme}`);
   }
   const output = generateDatabaseTypes(tables, {
-    schemaName: args.schema,
+    schemaName,
     typeName: args.typeName,
     functions,
     enums,
     views
   });
-  if (args.out) {
-    fs.writeFileSync(args.out, output);
+  if (outPath) {
+    fs.writeFileSync(outPath, 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)).`
+      `[aurabase-gen] \u2713 Types \xE9crits dans ${outPath} (${tables.length} table(s), ${functions.length} fonction(s), ${enums.length} enum(s), ${views.length} vue(s)).`
     );
   } else {
     process.stdout.write(output);
@@ -354,4 +523,7 @@ if (process.argv[1] && /aurabase-gen|cli\.(ts|js|mjs|cjs)$/.test(process.argv[1]
   });
 }
 
+exports.VERSION = VERSION;
 exports.diagnostiquerSchema = diagnostiquerSchema;
+exports.loadEnvFiles = loadEnvFiles;
+exports.parseArgs = parseArgs;

package/dist/cli.d.cts

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+declare const VERSION = "0.5.4";
+/**
+ * Charge les fichiers .env locaux s'ils existent dans le répertoire courant.
+ * Tente .env.local, .env.development.local, .env.development, .env par ordre de priorité.
+ */
+declare function loadEnvFiles(): void;
 /**
  * A10 — refuse de faire passer pour un succès un typage qui ne garantit rien.
  *
@@ -13,5 +19,16 @@ declare function diagnostiquerSchema(tables: Array<{
     name: string;
     columns?: unknown[];
 }>): string | null;
+interface Args {
+    url?: string;
+    key?: string;
+    out?: string;
+    schema?: string;
+    typeName?: string;
+    allowEmpty?: boolean;
+    help?: boolean;
+    version?: boolean;
+}
+declare function parseArgs(argv: string[]): Args;
 
-export { diagnostiquerSchema };
+export { VERSION, diagnostiquerSchema, loadEnvFiles, parseArgs };

package/dist/cli.d.ts

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+declare const VERSION = "0.5.4";
+/**
+ * Charge les fichiers .env locaux s'ils existent dans le répertoire courant.
+ * Tente .env.local, .env.development.local, .env.development, .env par ordre de priorité.
+ */
+declare function loadEnvFiles(): void;
 /**
  * A10 — refuse de faire passer pour un succès un typage qui ne garantit rien.
  *
@@ -13,5 +19,16 @@ declare function diagnostiquerSchema(tables: Array<{
     name: string;
     columns?: unknown[];
 }>): string | null;
+interface Args {
+    url?: string;
+    key?: string;
+    out?: string;
+    schema?: string;
+    typeName?: string;
+    allowEmpty?: boolean;
+    help?: boolean;
+    version?: boolean;
+}
+declare function parseArgs(argv: string[]): Args;
 
-export { diagnostiquerSchema };
+export { VERSION, diagnostiquerSchema, loadEnvFiles, parseArgs };

package/dist/cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { writeFileSync } from 'fs';
+import { writeFileSync, existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
 import { createClient } from '@aurabase/aurabase-js';
 
 // src/generate.ts
@@ -258,10 +259,123 @@ export interface ${typeName} {
     CompositeTypes: Record<string, never>
   }
 }
+
+export type Tables<
+  PublicTableNameOrOptions extends
+    | keyof (${typeName}['${schemaName}']['Tables'] & ${typeName}['${schemaName}']['Views'])
+    | { schema: keyof ${typeName} },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof (${typeName}[PublicTableNameOrOptions['schema']]['Tables'] &
+        ${typeName}[PublicTableNameOrOptions['schema']]['Views'])
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+  ? (${typeName}[PublicTableNameOrOptions['schema']]['Tables'] &
+      ${typeName}[PublicTableNameOrOptions['schema']]['Views'])[TableName] extends {
+      Row: infer R
+    }
+    ? R
+    : never
+  : PublicTableNameOrOptions extends keyof (${typeName}['${schemaName}']['Tables'] &
+        ${typeName}['${schemaName}']['Views'])
+    ? (${typeName}['${schemaName}']['Tables'] &
+        ${typeName}['${schemaName}']['Views'])[PublicTableNameOrOptions] extends {
+        Row: infer R
+      }
+      ? R
+      : never
+    : never
+
+export type TablesInsert<
+  PublicTableNameOrOptions extends
+    | keyof ${typeName}['${schemaName}']['Tables']
+    | { schema: keyof ${typeName} },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof ${typeName}[PublicTableNameOrOptions['schema']]['Tables']
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+  ? ${typeName}[PublicTableNameOrOptions['schema']]['Tables'][TableName] extends {
+      Insert: infer I
+    }
+    ? I
+    : never
+  : PublicTableNameOrOptions extends keyof ${typeName}['${schemaName}']['Tables']
+    ? ${typeName}['${schemaName}']['Tables'][PublicTableNameOrOptions] extends {
+        Insert: infer I
+      }
+      ? I
+      : never
+    : never
+
+export type TablesUpdate<
+  PublicTableNameOrOptions extends
+    | keyof ${typeName}['${schemaName}']['Tables']
+    | { schema: keyof ${typeName} },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof ${typeName}[PublicTableNameOrOptions['schema']]['Tables']
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+  ? ${typeName}[PublicTableNameOrOptions['schema']]['Tables'][TableName] extends {
+      Update: infer U
+    }
+    ? U
+    : never
+  : PublicTableNameOrOptions extends keyof ${typeName}['${schemaName}']['Tables']
+    ? ${typeName}['${schemaName}']['Tables'][PublicTableNameOrOptions] extends {
+        Update: infer U
+      }
+      ? U
+      : never
+    : never
+
+export type Enums<
+  PublicEnumNameOrOptions extends
+    | keyof ${typeName}['${schemaName}']['Enums']
+    | { schema: keyof ${typeName} },
+  EnumName extends PublicEnumNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof ${typeName}[PublicEnumNameOrOptions['schema']]['Enums']
+    : never = never,
+> = PublicEnumNameOrOptions extends { schema: keyof ${typeName} }
+  ? ${typeName}[PublicEnumNameOrOptions['schema']]['Enums'][EnumName]
+  : PublicEnumNameOrOptions extends keyof ${typeName}['${schemaName}']['Enums']
+    ? ${typeName}['${schemaName}']['Enums'][PublicEnumNameOrOptions]
+    : never
 `;
 }
 
 // src/cli.ts
+var VERSION = "0.5.4";
+function loadEnvFiles() {
+  const envCandidates = [".env.local", ".env.development.local", ".env.development", ".env"];
+  for (const file of envCandidates) {
+    const fullPath = resolve(process.cwd(), file);
+    if (existsSync(fullPath)) {
+      try {
+        if (typeof process.loadEnvFile === "function") {
+          ;
+          process.loadEnvFile(fullPath);
+        } else {
+          const content = readFileSync(fullPath, "utf-8");
+          for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#")) continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx > 0) {
+              const k = trimmed.slice(0, eqIdx).trim();
+              let v = trimmed.slice(eqIdx + 1).trim();
+              if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+                v = v.slice(1, -1);
+              }
+              if (!process.env[k]) {
+                process.env[k] = v;
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+}
 function diagnostiquerSchema(tables) {
   if (tables.length === 0) {
     return "Sch\xE9ma vide : aucune table. Les types g\xE9n\xE9r\xE9s seraient inutilisables.";
@@ -275,8 +389,9 @@ function diagnostiquerSchema(tables) {
 function parseArgs(argv) {
   const a = {};
   for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
     const v = argv[i + 1];
-    switch (argv[i]) {
+    switch (arg) {
       case "--url":
         a.url = v;
         i++;
@@ -286,14 +401,17 @@ function parseArgs(argv) {
         i++;
         break;
       case "--out":
+      case "-o":
         a.out = v;
         i++;
         break;
       case "--schema":
+      case "-s":
         a.schema = v;
         i++;
         break;
       case "--type-name":
+      case "-t":
         a.typeName = v;
         i++;
         break;
@@ -301,18 +419,69 @@ function parseArgs(argv) {
       case "--allow-empty":
         a.allowEmpty = true;
         break;
+      case "--help":
+      case "-h":
+        a.help = true;
+        break;
+      case "--version":
+      case "-v":
+        a.version = true;
+        break;
     }
   }
   return a;
 }
-var USAGE = `Usage: aurabase-gen --url <projectUrl> --key <apiKey> [--out database.types.ts] [--schema public] [--type-name Database] [--allow-empty]`;
+var HELP_TEXT = `
+aurabase-gen (v${VERSION}) \u2014 G\xE9n\xE9rateur de types TypeScript pour Aurabase
+
+USAGE :
+  npx @aurabase/gen [options]
+  aurabase-gen --url <projectUrl> --key <apiKey> [--out <fichier>]
+
+OPTIONS :
+  --url <url>         URL du projet Aurabase (ex: https://mon-projet.aurabase.cloud)
+                      [Auto-d\xE9tection : AURABASE_URL, NEXT_PUBLIC_AURABASE_URL, VITE_AURABASE_URL]
+  --key <cle>         Cl\xE9 API du projet (anon ou service_role)
+                      [Auto-d\xE9tection : AURABASE_API_KEY, AURABASE_ANON_KEY, AURABASE_SERVICE_ROLE_KEY]
+  -o, --out <fichier> Fichier de destination (ex: src/types/database.types.ts)
+                      Si omis, le r\xE9sultat est \xE9crit sur stdout.
+  -s, --schema <nom>  Nom du sch\xE9ma de base de donn\xE9es (d\xE9faut : 'public')
+  -t, --type-name <t> Nom de l'interface principale g\xE9n\xE9r\xE9e (d\xE9faut : 'Database')
+  --allow-empty       G\xE9n\xE9rer les types m\xEAme si des tables n'ont pas de colonnes d\xE9clar\xE9es
+  -h, --help          Afficher cette aide
+  -v, --version       Afficher la version
+
+EXEMPLES :
+  # G\xE9n\xE9ration avec lecture automatique des variables d'environnement (.env / .env.local) :
+  npx @aurabase/gen --out src/types/database.types.ts
+
+  # Param\xE8tres explicites :
+  npx @aurabase/gen --url https://xyz.aurabase.cloud --key aura_anon_123 --out db.types.ts
+`;
 async function main() {
+  loadEnvFiles();
   const args = parseArgs(process.argv.slice(2));
-  if (!args.url || !args.key) {
-    console.error(USAGE);
+  if (args.help) {
+    console.log(HELP_TEXT.trim());
+    process.exit(0);
+  }
+  if (args.version) {
+    console.log(`aurabase-gen v${VERSION}`);
+    process.exit(0);
+  }
+  const url = args.url ?? process.env.AURABASE_URL ?? process.env.NEXT_PUBLIC_AURABASE_URL ?? process.env.VITE_AURABASE_URL;
+  const key = args.key ?? process.env.AURABASE_SERVICE_ROLE_KEY ?? process.env.AURABASE_API_KEY ?? process.env.AURABASE_ANON_KEY ?? process.env.NEXT_PUBLIC_AURABASE_ANON_KEY ?? process.env.VITE_AURABASE_ANON_KEY;
+  if (!url || !key) {
+    console.error("[aurabase-gen] Erreur : URL et/ou cl\xE9 API du projet manquantes.\n");
+    console.error("Sp\xE9cifiez-les via les arguments CLI (--url et --key) ou dans vos variables d\u2019environnement (.env / .env.local) :");
+    console.error("  AURABASE_URL=https://<slug>.aurabase.cloud");
+    console.error("  AURABASE_ANON_KEY=aura_anon_...\n");
+    console.error("Ex\xE9cutez `npx @aurabase/gen --help` pour afficher toutes les options disponibles.");
     process.exit(1);
   }
-  const client = createClient(args.url, args.key);
+  const schemaName = args.schema ?? process.env.AURABASE_SCHEMA ?? "public";
+  const outPath = args.out ?? process.env.AURABASE_TYPES_OUT;
+  const client = createClient(url, key);
   const { data, error } = await client.db.schema();
   if (error) {
     console.error(`[aurabase-gen] Erreur de r\xE9cup\xE9ration du sch\xE9ma : ${error.message}`);
@@ -330,16 +499,16 @@ async function main() {
     console.error(`[aurabase-gen] Avertissement (--allow-empty) : ${probleme}`);
   }
   const output = generateDatabaseTypes(tables, {
-    schemaName: args.schema,
+    schemaName,
     typeName: args.typeName,
     functions,
     enums,
     views
   });
-  if (args.out) {
-    writeFileSync(args.out, output);
+  if (outPath) {
+    writeFileSync(outPath, 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)).`
+      `[aurabase-gen] \u2713 Types \xE9crits dans ${outPath} (${tables.length} table(s), ${functions.length} fonction(s), ${enums.length} enum(s), ${views.length} vue(s)).`
     );
   } else {
     process.stdout.write(output);
@@ -352,4 +521,4 @@ if (process.argv[1] && /aurabase-gen|cli\.(ts|js|mjs|cjs)$/.test(process.argv[1]
   });
 }
 
-export { diagnostiquerSchema };
+export { VERSION, diagnostiquerSchema, loadEnvFiles, parseArgs };

package/dist/index.cjs

@@ -256,6 +256,86 @@ export interface ${typeName} {
     CompositeTypes: Record<string, never>
   }
 }
+
+export type Tables<
+  PublicTableNameOrOptions extends
+    | keyof (${typeName}['${schemaName}']['Tables'] & ${typeName}['${schemaName}']['Views'])
+    | { schema: keyof ${typeName} },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof (${typeName}[PublicTableNameOrOptions['schema']]['Tables'] &
+        ${typeName}[PublicTableNameOrOptions['schema']]['Views'])
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+  ? (${typeName}[PublicTableNameOrOptions['schema']]['Tables'] &
+      ${typeName}[PublicTableNameOrOptions['schema']]['Views'])[TableName] extends {
+      Row: infer R
+    }
+    ? R
+    : never
+  : PublicTableNameOrOptions extends keyof (${typeName}['${schemaName}']['Tables'] &
+        ${typeName}['${schemaName}']['Views'])
+    ? (${typeName}['${schemaName}']['Tables'] &
+        ${typeName}['${schemaName}']['Views'])[PublicTableNameOrOptions] extends {
+        Row: infer R
+      }
+      ? R
+      : never
+    : never
+
+export type TablesInsert<
+  PublicTableNameOrOptions extends
+    | keyof ${typeName}['${schemaName}']['Tables']
+    | { schema: keyof ${typeName} },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof ${typeName}[PublicTableNameOrOptions['schema']]['Tables']
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+  ? ${typeName}[PublicTableNameOrOptions['schema']]['Tables'][TableName] extends {
+      Insert: infer I
+    }
+    ? I
+    : never
+  : PublicTableNameOrOptions extends keyof ${typeName}['${schemaName}']['Tables']
+    ? ${typeName}['${schemaName}']['Tables'][PublicTableNameOrOptions] extends {
+        Insert: infer I
+      }
+      ? I
+      : never
+    : never
+
+export type TablesUpdate<
+  PublicTableNameOrOptions extends
+    | keyof ${typeName}['${schemaName}']['Tables']
+    | { schema: keyof ${typeName} },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof ${typeName}[PublicTableNameOrOptions['schema']]['Tables']
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+  ? ${typeName}[PublicTableNameOrOptions['schema']]['Tables'][TableName] extends {
+      Update: infer U
+    }
+    ? U
+    : never
+  : PublicTableNameOrOptions extends keyof ${typeName}['${schemaName}']['Tables']
+    ? ${typeName}['${schemaName}']['Tables'][PublicTableNameOrOptions] extends {
+        Update: infer U
+      }
+      ? U
+      : never
+    : never
+
+export type Enums<
+  PublicEnumNameOrOptions extends
+    | keyof ${typeName}['${schemaName}']['Enums']
+    | { schema: keyof ${typeName} },
+  EnumName extends PublicEnumNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof ${typeName}[PublicEnumNameOrOptions['schema']]['Enums']
+    : never = never,
+> = PublicEnumNameOrOptions extends { schema: keyof ${typeName} }
+  ? ${typeName}[PublicEnumNameOrOptions['schema']]['Enums'][EnumName]
+  : PublicEnumNameOrOptions extends keyof ${typeName}['${schemaName}']['Enums']
+    ? ${typeName}['${schemaName}']['Enums'][PublicEnumNameOrOptions]
+    : never
 `;
 }
 

package/dist/index.js

@@ -254,6 +254,86 @@ export interface ${typeName} {
     CompositeTypes: Record<string, never>
   }
 }
+
+export type Tables<
+  PublicTableNameOrOptions extends
+    | keyof (${typeName}['${schemaName}']['Tables'] & ${typeName}['${schemaName}']['Views'])
+    | { schema: keyof ${typeName} },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof (${typeName}[PublicTableNameOrOptions['schema']]['Tables'] &
+        ${typeName}[PublicTableNameOrOptions['schema']]['Views'])
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+  ? (${typeName}[PublicTableNameOrOptions['schema']]['Tables'] &
+      ${typeName}[PublicTableNameOrOptions['schema']]['Views'])[TableName] extends {
+      Row: infer R
+    }
+    ? R
+    : never
+  : PublicTableNameOrOptions extends keyof (${typeName}['${schemaName}']['Tables'] &
+        ${typeName}['${schemaName}']['Views'])
+    ? (${typeName}['${schemaName}']['Tables'] &
+        ${typeName}['${schemaName}']['Views'])[PublicTableNameOrOptions] extends {
+        Row: infer R
+      }
+      ? R
+      : never
+    : never
+
+export type TablesInsert<
+  PublicTableNameOrOptions extends
+    | keyof ${typeName}['${schemaName}']['Tables']
+    | { schema: keyof ${typeName} },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof ${typeName}[PublicTableNameOrOptions['schema']]['Tables']
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+  ? ${typeName}[PublicTableNameOrOptions['schema']]['Tables'][TableName] extends {
+      Insert: infer I
+    }
+    ? I
+    : never
+  : PublicTableNameOrOptions extends keyof ${typeName}['${schemaName}']['Tables']
+    ? ${typeName}['${schemaName}']['Tables'][PublicTableNameOrOptions] extends {
+        Insert: infer I
+      }
+      ? I
+      : never
+    : never
+
+export type TablesUpdate<
+  PublicTableNameOrOptions extends
+    | keyof ${typeName}['${schemaName}']['Tables']
+    | { schema: keyof ${typeName} },
+  TableName extends PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof ${typeName}[PublicTableNameOrOptions['schema']]['Tables']
+    : never = never,
+> = PublicTableNameOrOptions extends { schema: keyof ${typeName} }
+  ? ${typeName}[PublicTableNameOrOptions['schema']]['Tables'][TableName] extends {
+      Update: infer U
+    }
+    ? U
+    : never
+  : PublicTableNameOrOptions extends keyof ${typeName}['${schemaName}']['Tables']
+    ? ${typeName}['${schemaName}']['Tables'][PublicTableNameOrOptions] extends {
+        Update: infer U
+      }
+      ? U
+      : never
+    : never
+
+export type Enums<
+  PublicEnumNameOrOptions extends
+    | keyof ${typeName}['${schemaName}']['Enums']
+    | { schema: keyof ${typeName} },
+  EnumName extends PublicEnumNameOrOptions extends { schema: keyof ${typeName} }
+    ? keyof ${typeName}[PublicEnumNameOrOptions['schema']]['Enums']
+    : never = never,
+> = PublicEnumNameOrOptions extends { schema: keyof ${typeName} }
+  ? ${typeName}[PublicEnumNameOrOptions['schema']]['Enums'][EnumName]
+  : PublicEnumNameOrOptions extends keyof ${typeName}['${schemaName}']['Enums']
+    ? ${typeName}['${schemaName}']['Enums'][PublicEnumNameOrOptions]
+    : never
 `;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aurabase/gen",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Générateur de types TypeScript Database pour le SDK Aurabase (CLI aurabase-gen)",
   "type": "module",
   "main": "dist/index.cjs",
@@ -49,8 +49,8 @@
     "types"
   ],
   "dependencies": {
-    "@aurabase/core": "0.5.2",
-    "@aurabase/aurabase-js": "0.5.2"
+    "@aurabase/core": "0.5.4",
+    "@aurabase/aurabase-js": "0.5.4"
   },
   "devDependencies": {
     "tsup": "^8.0.0",