@aurabase/gen 0.4.1 → 0.5.1

package/README.md

@@ -21,13 +21,13 @@ npm i -D @aurabase/gen
 ### CLI `aurabase-gen`
 
 ```bash
-npx aurabase-gen --url http://localhost:8080 --project my-project --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 <baseUrl> --project <id> [--key <apiKey>] [--out database.types.ts] [--schema public] [--type-name Database]
+aurabase-gen --url <projectUrl> --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.
@@ -58,14 +58,14 @@ const source = generateDatabaseTypes(tables, { schemaName: 'public', typeName: '
 ### 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
+npx aurabase-gen --url https://mon-projet.aurabase.cloud --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')
+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()

package/dist/cli.cjs

@@ -217,7 +217,12 @@ function generateDatabaseTypes(tables, options = {}) {
   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 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);
@@ -259,6 +264,16 @@ export interface ${typeName} {
 }
 
 // src/cli.ts
+function diagnostiquerSchema(tables) {
+  if (tables.length === 0) {
+    return "Sch\xE9ma vide : aucune table. Les types g\xE9n\xE9r\xE9s seraient inutilisables.";
+  }
+  const vides = tables.filter((t) => !t.columns || t.columns.length === 0).map((t) => t.name);
+  if (vides.length > 0) {
+    return `Tables sans aucune colonne : ${vides.join(", ")}. Les types g\xE9n\xE9r\xE9s pour elles seraient \xAB Row: {} \xBB \u2014 sans garantie : ils acceptent n'importe quel champ et n'en garantissent aucun. C'est le cas d'un projet MongoDB, dont le sch\xE9ma n'est pas d\xE9clar\xE9. Utilisez --allow-empty pour g\xE9n\xE9rer quand m\xEAme.`;
+  }
+  return null;
+}
 function parseArgs(argv) {
   const a = {};
   for (let i = 0; i < argv.length; i++) {
@@ -268,10 +283,6 @@ function parseArgs(argv) {
         a.url = v;
         i++;
         break;
-      case "--project":
-        a.project = v;
-        i++;
-        break;
       case "--key":
         a.key = v;
         i++;
@@ -288,18 +299,22 @@ function parseArgs(argv) {
         a.typeName = v;
         i++;
         break;
+      // A10 : échappatoire explicite pour générer malgré un schéma sans colonnes.
+      case "--allow-empty":
+        a.allowEmpty = true;
+        break;
     }
   }
   return a;
 }
-var USAGE = `Usage: aurabase-gen --url <baseUrl> --project <id> [--key <apiKey>] [--out database.types.ts] [--schema public] [--type-name Database]`;
+var USAGE = `Usage: aurabase-gen --url <projectUrl> --key <apiKey> [--out database.types.ts] [--schema public] [--type-name Database] [--allow-empty]`;
 async function main() {
   const args = parseArgs(process.argv.slice(2));
-  if (!args.url || !args.project) {
+  if (!args.url || !args.key) {
     console.error(USAGE);
     process.exit(1);
   }
-  const client = aurabaseJs.createClient(args.url, args.project, args.key);
+  const client = aurabaseJs.createClient(args.url, 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}`);
@@ -309,8 +324,12 @@ async function main() {
   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 probleme = diagnostiquerSchema(tables);
+  if (probleme && !args.allowEmpty) {
+    console.error(`[aurabase-gen] ${probleme}`);
+    process.exit(1);
+  } else if (probleme) {
+    console.error(`[aurabase-gen] Avertissement (--allow-empty) : ${probleme}`);
   }
   const output = generateDatabaseTypes(tables, {
     schemaName: args.schema,
@@ -328,7 +347,11 @@ async function main() {
     process.stdout.write(output);
   }
 }
-main().catch((e) => {
-  console.error("[aurabase-gen]", e instanceof Error ? e.message : e);
-  process.exit(1);
-});
+if (process.argv[1] && /aurabase-gen|cli\.(ts|js|mjs|cjs)$/.test(process.argv[1])) {
+  main().catch((e) => {
+    console.error("[aurabase-gen]", e instanceof Error ? e.message : e);
+    process.exit(1);
+  });
+}
+
+exports.diagnostiquerSchema = diagnostiquerSchema;

package/dist/cli.d.cts

@@ -1 +1,17 @@
 #!/usr/bin/env node
+/**
+ * A10 — refuse de faire passer pour un succès un typage qui ne garantit rien.
+ *
+ * Un projet MongoDB rend un schéma dont chaque table a `columns: []` (le moteur n'a pas de
+ * schéma déclaré) : le générateur écrivait alors `Row: {}` — un type qui accepte n'importe
+ * quel champ et n'en garantit aucun — puis sortait en **code 0**. Une CI qui régénère les
+ * types ne voyait rien du tout : le garde-fou de typage disparaissait en silence.
+ *
+ * Retourne `null` si le schéma est exploitable, sinon le message à afficher.
+ */
+declare function diagnostiquerSchema(tables: Array<{
+    name: string;
+    columns?: unknown[];
+}>): string | null;
+
+export { diagnostiquerSchema };

package/dist/cli.d.ts

@@ -1 +1,17 @@
 #!/usr/bin/env node
+/**
+ * A10 — refuse de faire passer pour un succès un typage qui ne garantit rien.
+ *
+ * Un projet MongoDB rend un schéma dont chaque table a `columns: []` (le moteur n'a pas de
+ * schéma déclaré) : le générateur écrivait alors `Row: {}` — un type qui accepte n'importe
+ * quel champ et n'en garantit aucun — puis sortait en **code 0**. Une CI qui régénère les
+ * types ne voyait rien du tout : le garde-fou de typage disparaissait en silence.
+ *
+ * Retourne `null` si le schéma est exploitable, sinon le message à afficher.
+ */
+declare function diagnostiquerSchema(tables: Array<{
+    name: string;
+    columns?: unknown[];
+}>): string | null;
+
+export { diagnostiquerSchema };

package/dist/cli.js

@@ -215,7 +215,12 @@ function generateDatabaseTypes(tables, options = {}) {
   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 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);
@@ -257,6 +262,16 @@ export interface ${typeName} {
 }
 
 // src/cli.ts
+function diagnostiquerSchema(tables) {
+  if (tables.length === 0) {
+    return "Sch\xE9ma vide : aucune table. Les types g\xE9n\xE9r\xE9s seraient inutilisables.";
+  }
+  const vides = tables.filter((t) => !t.columns || t.columns.length === 0).map((t) => t.name);
+  if (vides.length > 0) {
+    return `Tables sans aucune colonne : ${vides.join(", ")}. Les types g\xE9n\xE9r\xE9s pour elles seraient \xAB Row: {} \xBB \u2014 sans garantie : ils acceptent n'importe quel champ et n'en garantissent aucun. C'est le cas d'un projet MongoDB, dont le sch\xE9ma n'est pas d\xE9clar\xE9. Utilisez --allow-empty pour g\xE9n\xE9rer quand m\xEAme.`;
+  }
+  return null;
+}
 function parseArgs(argv) {
   const a = {};
   for (let i = 0; i < argv.length; i++) {
@@ -266,10 +281,6 @@ function parseArgs(argv) {
         a.url = v;
         i++;
         break;
-      case "--project":
-        a.project = v;
-        i++;
-        break;
       case "--key":
         a.key = v;
         i++;
@@ -286,18 +297,22 @@ function parseArgs(argv) {
         a.typeName = v;
         i++;
         break;
+      // A10 : échappatoire explicite pour générer malgré un schéma sans colonnes.
+      case "--allow-empty":
+        a.allowEmpty = true;
+        break;
     }
   }
   return a;
 }
-var USAGE = `Usage: aurabase-gen --url <baseUrl> --project <id> [--key <apiKey>] [--out database.types.ts] [--schema public] [--type-name Database]`;
+var USAGE = `Usage: aurabase-gen --url <projectUrl> --key <apiKey> [--out database.types.ts] [--schema public] [--type-name Database] [--allow-empty]`;
 async function main() {
   const args = parseArgs(process.argv.slice(2));
-  if (!args.url || !args.project) {
+  if (!args.url || !args.key) {
     console.error(USAGE);
     process.exit(1);
   }
-  const client = createClient(args.url, args.project, args.key);
+  const client = createClient(args.url, 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}`);
@@ -307,8 +322,12 @@ async function main() {
   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 probleme = diagnostiquerSchema(tables);
+  if (probleme && !args.allowEmpty) {
+    console.error(`[aurabase-gen] ${probleme}`);
+    process.exit(1);
+  } else if (probleme) {
+    console.error(`[aurabase-gen] Avertissement (--allow-empty) : ${probleme}`);
   }
   const output = generateDatabaseTypes(tables, {
     schemaName: args.schema,
@@ -326,7 +345,11 @@ async function main() {
     process.stdout.write(output);
   }
 }
-main().catch((e) => {
-  console.error("[aurabase-gen]", e instanceof Error ? e.message : e);
-  process.exit(1);
-});
+if (process.argv[1] && /aurabase-gen|cli\.(ts|js|mjs|cjs)$/.test(process.argv[1])) {
+  main().catch((e) => {
+    console.error("[aurabase-gen]", e instanceof Error ? e.message : e);
+    process.exit(1);
+  });
+}
+
+export { diagnostiquerSchema };

package/dist/index.cjs

@@ -213,7 +213,12 @@ function generateDatabaseTypes(tables, options = {}) {
   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 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);

package/dist/index.js

@@ -211,7 +211,12 @@ function generateDatabaseTypes(tables, options = {}) {
   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 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aurabase/gen",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Générateur de types TypeScript Database pour le SDK Aurabase (CLI aurabase-gen)",
   "type": "module",
   "main": "dist/index.cjs",
@@ -37,7 +37,7 @@
     "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",
+  "homepage": "https://aurabase.cloud",
   "bugs": {
     "url": "https://github.com/daylami555/aurabase/issues"
   },
@@ -48,20 +48,21 @@
     "generator",
     "types"
   ],
-  "dependencies": {
-    "@aurabase/core": "0.4.1",
-    "@aurabase/aurabase-js": "0.4.1"
-  },
-  "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 && tsc --noEmit -p tsconfig.test.json",
+    "prepack": "pnpm build",
     "typecheck:tests": "tsc --noEmit -p tsconfig.test.json"
+  },
+  "dependencies": {
+    "@aurabase/core": "workspace:*",
+    "@aurabase/aurabase-js": "workspace:*"
+  },
+  "devDependencies": {
+    "tsup": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:",
+    "@types/node": "catalog:"
   }
-}
+}