supatool 0.4.1 → 0.4.3

package/dist/bin/helptext.js

@@ -33,6 +33,19 @@ Common Options:
   --config <path>              Configuration file path
   -f, --force                  Force overwrite
 
+seed command:
+  supatool seed -c <connection> [-t tables.yaml] [-o supabase/seeds]
+
+  tables.yaml format (schema-grouped):
+    public:
+      - users
+      - posts
+    admin:
+      - platforms
+
+  Output: supabase/seeds/<timestamp>/<schema>/<table>_seed.json
+          supabase/seeds/llms.txt  (index for AI)
+
 For details, see the documentation.
 `;
 // Model Schema Usage

package/dist/sync/definitionExtractor.js

@@ -355,6 +355,26 @@ async function fetchFunctions(client, spinner, progress, schemas = ['public']) {
             timestamp: Math.floor(Date.now() / 1000)
         });
     }
+    // Detect overloaded functions (same schema.name, different signatures)
+    const nameCount = new Map();
+    for (const row of result.rows) {
+        const key = `${row.schema_name}.${row.name}`;
+        const sig = `${row.name}(${row.identity_args || ''})`;
+        if (!nameCount.has(key))
+            nameCount.set(key, []);
+        nameCount.get(key).push(sig);
+    }
+    const overloads = [...nameCount.entries()].filter(([, sigs]) => sigs.length > 1);
+    if (overloads.length > 0) {
+        console.warn('\n⚠ Overloaded RPC functions detected (same name, different signatures):');
+        for (const [key, sigs] of overloads) {
+            console.warn(`  ${key}`);
+            for (const sig of sigs) {
+                console.warn(`    - ${sig}`);
+            }
+        }
+        console.warn('  Note: Only the last definition will be written to the output file.\n');
+    }
     return functions;
 }
 /**
@@ -843,19 +863,21 @@ async function generateCreateTableDDL(client, tableName, schemaName = 'public')
     const [columnsResult, primaryKeyResult, tableCommentResult, columnCommentsResult, uniqueConstraintResult, foreignKeyResult] = await Promise.all([
         // Get column info
         client.query(`
-      SELECT 
+      SELECT
         c.column_name,
         c.data_type,
         c.udt_name,
         c.character_maximum_length,
         c.is_nullable,
         c.column_default,
+        c.is_generated,
+        c.generation_expression,
         pg_catalog.format_type(a.atttypid, a.atttypmod) AS full_type
       FROM information_schema.columns c
       JOIN pg_class cl ON cl.relname = c.table_name
       JOIN pg_namespace ns ON ns.nspname = c.table_schema AND ns.oid = cl.relnamespace
       JOIN pg_attribute a ON a.attrelid = cl.oid AND a.attname = c.column_name
-      WHERE c.table_schema = $1 
+      WHERE c.table_schema = $1
         AND c.table_name = $2
       ORDER BY c.ordinal_position
     `, [schemaName, tableName]),
@@ -951,13 +973,19 @@ async function generateCreateTableDDL(client, tableName, schemaName = 'public')
         if (col.character_maximum_length) {
             colDef += `(${col.character_maximum_length})`;
         }
-        // NOT NULL constraint
-        if (col.is_nullable === 'NO') {
-            colDef += ' NOT NULL';
+        // Generated column
+        if (col.is_generated === 'ALWAYS') {
+            colDef += ` GENERATED ALWAYS AS (${col.generation_expression}) STORED`;
         }
-        // Default value
-        if (col.column_default) {
-            colDef += ` DEFAULT ${col.column_default}`;
+        else {
+            // NOT NULL constraint
+            if (col.is_nullable === 'NO') {
+                colDef += ' NOT NULL';
+            }
+            // Default value
+            if (col.column_default) {
+                colDef += ` DEFAULT ${col.column_default}`;
+            }
         }
         columnDefs.push(colDef);
     }
@@ -1041,7 +1069,12 @@ async function saveDefinitionsByType(definitions, outputDir, separateDirectories
         list.push(t.ddl);
         triggersByCategory.set(t.category, list);
     }
-    // Build merged DDL (table/view + RLS + triggers)
+    // schema.table -> RLS status (for appending comment/DDL when no policies)
+    const rlsStatusByCategory = new Map();
+    for (const s of tableRlsStatus) {
+        rlsStatusByCategory.set(`${s.schema}.${s.table}`, s);
+    }
+    // Build merged DDL (table/view + RLS + triggers). Tables with RLS disabled or 0 policies get a comment block in the file.
     const mergeRlsAndTriggers = (def) => {
         const cat = def.schema && def.name ? `${def.schema}.${def.name}` : def.category ?? '';
         let ddl = def.ddl.trimEnd();
@@ -1049,6 +1082,19 @@ async function saveDefinitionsByType(definitions, outputDir, separateDirectories
         if (rlsDdl) {
             ddl += '\n\n' + rlsDdl.trim();
         }
+        else if (def.type === 'table' && def.schema && def.name) {
+            const rlsStatus = rlsStatusByCategory.get(cat);
+            if (rlsStatus) {
+                if (!rlsStatus.rlsEnabled) {
+                    ddl += '\n\n-- RLS: disabled. Consider enabling for production.';
+                    ddl += '\n-- ALTER TABLE ' + def.schema + '.' + def.name + ' ENABLE ROW LEVEL SECURITY;';
+                }
+                else if (rlsStatus.policyCount === 0) {
+                    ddl += '\n\n-- RLS: enabled, no policies defined';
+                    ddl += '\nALTER TABLE ' + def.schema + '.' + def.name + ' ENABLE ROW LEVEL SECURITY;';
+                }
+            }
+        }
         const trgList = triggersByCategory.get(cat);
         if (trgList && trgList.length > 0) {
             ddl += '\n\n' + trgList.map(t => t.trim()).join('\n\n');
@@ -1091,13 +1137,7 @@ async function saveDefinitionsByType(definitions, outputDir, separateDirectories
         if (!fs.existsSync(targetDir)) {
             fs.mkdirSync(targetDir, { recursive: true });
         }
-        let fileName;
-        if (def.type === 'function') {
-            fileName = `fn_${def.name}.sql`;
-        }
-        else {
-            fileName = `${def.name}.sql`;
-        }
+        const fileName = `${def.name}.sql`;
         const filePath = path.join(targetDir, fileName);
         const ddlWithNewline = def.ddl.endsWith('\n') ? def.ddl : def.ddl + '\n';
         await fsPromises.writeFile(filePath, headerComment + ddlWithNewline);
@@ -1157,7 +1197,7 @@ async function generateIndexFile(definitions, outputDir, separateDirectories = t
     // Build relative path per file (schema/type/file when multiSchema)
     const getRelPath = (def) => {
         const typeDir = separateDirectories ? (typeDirNames[def.type] ?? def.type) : '.';
-        const fileName = def.type === 'function' ? `fn_${def.name}.sql` : `${def.name}.sql`;
+        const fileName = `${def.name}.sql`;
         if (multiSchema && def.schema) {
             return `${def.schema}/${typeDir}/${fileName}`;
         }

package/dist/sync/seedGenerator.js

@@ -8,17 +8,55 @@ const pg_1 = require("pg");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
+/**
+ * Parse tables.yaml into { schema -> table[] } map.
+ * Format:
+ *   public:
+ *     - users
+ *     - posts
+ *   admin:
+ *     - platforms
+ */
+function parseTablesYaml(yamlPath) {
+    const yamlObj = js_yaml_1.default.load(fs_1.default.readFileSync(yamlPath, 'utf8'));
+    if (!yamlObj || typeof yamlObj !== 'object' || Array.isArray(yamlObj)) {
+        throw new Error('Invalid tables.yaml format. Use schema-grouped format:\n  public:\n    - users\n  admin:\n    - platforms');
+    }
+    // Detect old format: top-level "tables:" key with array value
+    if ('tables' in yamlObj && Array.isArray(yamlObj.tables)) {
+        throw new Error('Outdated tables.yaml format detected.\n\n' +
+            'Migrate to schema-grouped format:\n\n' +
+            '  Before:          After:\n' +
+            '  tables:          public:\n' +
+            '    - users    →     - users\n' +
+            '    - posts          - posts\n' +
+            '    - admin.x      admin:\n' +
+            '                     - x\n');
+    }
+    const entries = [];
+    for (const [schema, tables] of Object.entries(yamlObj)) {
+        if (!Array.isArray(tables)) {
+            throw new Error(`tables.yaml: value of "${schema}" must be a list of table names`);
+        }
+        for (const table of tables) {
+            // Detect dot notation inside a schema group
+            if (table.includes('.')) {
+                throw new Error(`tables.yaml: "${table}" under "${schema}" uses dot notation.\n` +
+                    `Use schema-grouped format instead:\n` +
+                    `  ${table.split('.')[0]}:\n` +
+                    `    - ${table.split('.')[1]}`);
+            }
+            entries.push({ schema, table });
+        }
+    }
+    return entries;
+}
 /**
  * Fetch table data from remote DB and generate AI seed JSON
  * @param options SeedGenOptions
  */
 async function generateSeedsFromRemote(options) {
-    // Load tables.yaml
-    const yamlObj = js_yaml_1.default.load(fs_1.default.readFileSync(options.tablesYamlPath, 'utf8'));
-    if (!yamlObj || !Array.isArray(yamlObj.tables)) {
-        throw new Error('Invalid tables.yaml format. Specify as tables: [ ... ]');
-    }
-    const tables = yamlObj.tables;
+    const tables = parseTablesYaml(options.tablesYamlPath);
     // Generate datetime subdir name (e.g. 20250705_1116_supatool)
     const now = new Date();
     const y = now.getFullYear();
@@ -28,67 +66,54 @@ async function generateSeedsFromRemote(options) {
     const mm = String(now.getMinutes()).padStart(2, '0');
     const folderName = `${y}${m}${d}_${hh}${mm}_supatool`;
     const outDir = path_1.default.join(options.outputDir, folderName);
-    // Create output directory
-    if (!fs_1.default.existsSync(outDir)) {
-        fs_1.default.mkdirSync(outDir, { recursive: true });
-    }
     // DB connection
     const client = new pg_1.Client({ connectionString: options.connectionString });
     await client.connect();
-    let processedCount = 0;
-    for (const tableFullName of tables) {
-        // No schema specified -> public
-        let schema = 'public';
-        let table = tableFullName;
-        if (tableFullName.includes('.')) {
-            [schema, table] = tableFullName.split('.');
+    const processedFiles = [];
+    for (const { schema, table } of tables) {
+        // Create schema subdir
+        const schemaDir = path_1.default.join(outDir, schema);
+        if (!fs_1.default.existsSync(schemaDir)) {
+            fs_1.default.mkdirSync(schemaDir, { recursive: true });
         }
         // Fetch data
         const res = await client.query(`SELECT * FROM "${schema}"."${table}"`);
         const rows = res.rows;
-        // File name
-        const fileName = `${table}_seed.json`;
-        const filePath = path_1.default.join(outDir, fileName);
         // Output JSON
+        const fileName = `${table}_seed.json`;
+        const filePath = path_1.default.join(schemaDir, fileName);
         const json = {
             table: `${schema}.${table}`,
             fetched_at: now.toISOString(),
-            fetched_by: 'supatool v0.3.5',
+            fetched_by: 'supatool',
             note: 'This data is a snapshot of the remote DB at the above time. For AI coding reference. You can update it by running the update command again.',
             rows
         };
         fs_1.default.writeFileSync(filePath, JSON.stringify(json, null, 2), 'utf8');
-        processedCount++;
+        processedFiles.push({ schema, table, fileName, rowCount: rows.length });
     }
     await client.end();
-    // llms.txt index output (overwrite under supabase/seeds each run)
-    const files = fs_1.default.readdirSync(outDir);
-    const seedFiles = files.filter(f => f.endsWith('_seed.json'));
+    // llms.txt index (schema/file paths, overwrite each run)
     let llmsTxt = `# AI seed data index (generated by supatool)\n`;
     llmsTxt += `# fetched_at: ${now.toISOString()}\n`;
     llmsTxt += `# folder: ${folderName}\n`;
     llmsTxt += `# Schema catalog: ../schemas/llms.txt\n`;
-    for (const basename of seedFiles) {
-        const file = path_1.default.join(outDir, basename);
-        const content = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
-        // Table comment (empty if none)
+    for (const { schema, table, fileName, rowCount } of processedFiles) {
         let tableComment = '';
         try {
-            const [schema, table] = content.table.split('.');
             const commentRes = await getTableComment(options.connectionString, schema, table);
             if (commentRes)
                 tableComment = commentRes;
         }
         catch { }
-        llmsTxt += `${content.table}: ${basename} (${Array.isArray(content.rows) ? content.rows.length : 0} rows)`;
+        llmsTxt += `${schema}.${table}: ${schema}/${fileName} (${rowCount} rows)`;
         if (tableComment)
             llmsTxt += ` # ${tableComment}`;
         llmsTxt += `\n`;
     }
     const llmsPath = path_1.default.join(options.outputDir, 'llms.txt');
     fs_1.default.writeFileSync(llmsPath, llmsTxt, 'utf8');
-    // Output summary in English
-    console.log(`Seed export completed. Processed tables: ${processedCount}`);
+    console.log(`Seed export completed. Processed tables: ${processedFiles.length}`);
     console.log(`llms.txt index written to: ${llmsPath}`);
 }
 /** Utility to get table comment */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supatool",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "CLI for Supabase: extract schema (tables, views, RLS, RPC) to files + llms.txt for LLM, deploy local schema, seed export. CRUD code gen deprecated.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",