supatool 0.4.3 → 0.6.0

package/dist/sync/sync.js

@@ -1,14 +1,63 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.syncAllTables = syncAllTables;
+const path = __importStar(require("path"));
 const parseLocalSchemas_1 = require("./parseLocalSchemas");
 const fetchRemoteSchemas_1 = require("./fetchRemoteSchemas");
 const writeSchema_1 = require("./writeSchema");
+const fs = __importStar(require("fs"));
 const generateMigration_1 = require("./generateMigration");
 const diff_1 = require("diff");
 const utils_1 = require("./utils");
 // Global approval state (shared with writeSchema.ts)
 let globalApproveAll = false;
+/**
+ * Extract column names from a CREATE TABLE DDL string.
+ */
+function extractColumnNames(ddl) {
+    const match = ddl.match(/CREATE TABLE[^(]*\(([\s\S]*)\)/i);
+    if (!match)
+        return [];
+    return match[1]
+        .split(',')
+        .map(line => line.trim())
+        .filter(line => !line.match(/^(PRIMARY|CONSTRAINT|UNIQUE|FOREIGN|CHECK)/i))
+        .map(line => { const m = line.match(/^([a-zA-Z_]\w*)/); return m ? m[1] : ''; })
+        .filter(Boolean);
+}
 /**
  * Normalize DDL string (unify spaces, newlines, tabs)
  */
@@ -37,7 +86,7 @@ function formatSQL(sql) {
 /**
  * Synchronize all table schemas
  */
-async function syncAllTables({ connectionString, schemaDir, tablePattern = '*', force = false, dryRun = false, generateOnly = false, requireConfirmation = false }) {
+async function syncAllTables({ connectionString, schemaDir, tablePattern = '*', force = false, dryRun = false, generateOnly = false, requireConfirmation = false, migrationConfig, rlsMode = 'skip' }) {
     // Reset approval state
     (0, writeSchema_1.resetApprovalState)();
     const localSchemas = await (0, parseLocalSchemas_1.parseLocalSchemas)(schemaDir);
@@ -53,6 +102,34 @@ async function syncAllTables({ connectionString, schemaDir, tablePattern = '*',
     }
     // Fetch only the remote schemas for target tables
     const remoteSchemas = await (0, fetchRemoteSchemas_1.fetchRemoteSchemas)(connectionString, targetLocalTables);
+    // --- Table rename detection ---
+    // Tables that exist locally but not remotely (potential new name)
+    const localOnly = targetLocalTables.filter(t => !remoteSchemas[t]);
+    // Tables that exist remotely but not locally (potential old name)
+    const remoteOnly = Object.keys(remoteSchemas).filter(t => !localSchemas[t]);
+    for (const newName of localOnly) {
+        const localDdl = localSchemas[newName]?.ddl ?? '';
+        const localCols = extractColumnNames(localDdl);
+        if (localCols.length === 0)
+            continue;
+        for (const oldName of remoteOnly) {
+            const remoteDdl = remoteSchemas[oldName]?.ddl ?? '';
+            const remoteCols = extractColumnNames(remoteDdl);
+            if (remoteCols.length === 0)
+                continue;
+            const shared = localCols.filter(c => remoteCols.includes(c)).length;
+            const similarity = shared / Math.max(localCols.length, remoteCols.length);
+            if (similarity >= 0.7) {
+                console.warn(`⚠️  Possible table rename detected: "${oldName}" → "${newName}" ` +
+                    `(${Math.round(similarity * 100)}% column match). ` +
+                    `Generating rename migration — review before applying.`);
+                // Infer schema from CREATE TABLE <schema>.<table> in DDL (default public)
+                const schemaMatch = localDdl.match(/CREATE TABLE\s+(\w+)\.\w+/i);
+                const schema = schemaMatch ? schemaMatch[1] : 'public';
+                await (0, generateMigration_1.generateRenameTableMigrationFile)(schema, oldName, newName, process.cwd(), migrationConfig);
+            }
+        }
+    }
     for (const tableName of targetLocalTables) {
         const local = localSchemas[tableName];
         const remote = remoteSchemas[tableName];
@@ -129,7 +206,7 @@ async function syncAllTables({ connectionString, schemaDir, tablePattern = '*',
                     // Generate migration file (local → remote diff)
                     const migrationPath = await (0, generateMigration_1.generateMigrationFile)(tableName, normalizedRemote, // from (current remote state)
                     normalizedLocal, // to (local target state)
-                    process.cwd());
+                    process.cwd(), migrationConfig);
                     if (migrationPath) {
                         console.log(`[${tableName}] 📝 UPDATE migration generated: ${migrationPath}`);
                     }
@@ -140,4 +217,197 @@ async function syncAllTables({ connectionString, schemaDir, tablePattern = '*',
             }
         }
     }
+    // --- Function diff: scan local rpc/*.sql vs remote ---
+    await syncFunctions(connectionString, schemaDir, migrationConfig);
+    // --- RLS diff ---
+    if (rlsMode === 'rewrite') {
+        await syncRls(connectionString, schemaDir, migrationConfig);
+    }
+}
+/**
+ * Scan local <schemaDir>/<schema>/rpc/*.sql, compare with remote pg_get_functiondef,
+ * and generate CREATE OR REPLACE migrations for any changed functions.
+ */
+async function syncFunctions(connectionString, schemaDir, migrationConfig) {
+    const { Client } = await Promise.resolve().then(() => __importStar(require('pg')));
+    // Collect all local rpc sql files: { schema, funcName, localDdl }
+    const entries = [];
+    if (!fs.existsSync(schemaDir))
+        return;
+    for (const schemaEntry of fs.readdirSync(schemaDir, { withFileTypes: true })) {
+        if (!schemaEntry.isDirectory())
+            continue;
+        const rpcDir = path.join(schemaDir, schemaEntry.name, 'rpc');
+        if (!fs.existsSync(rpcDir))
+            continue;
+        for (const file of fs.readdirSync(rpcDir)) {
+            if (!file.endsWith('.sql'))
+                continue;
+            const funcName = file.replace(/\.sql$/, '');
+            const localDdl = fs.readFileSync(path.join(rpcDir, file), 'utf-8');
+            entries.push({ schema: schemaEntry.name, funcName, localDdl });
+        }
+    }
+    if (entries.length === 0)
+        return;
+    const client = new Client({ connectionString });
+    await client.connect();
+    let changed = 0;
+    try {
+        for (const { schema, funcName, localDdl } of entries) {
+            const result = await client.query(`SELECT pg_get_functiondef(p.oid) as definition
+         FROM pg_proc p
+         JOIN pg_namespace n ON p.pronamespace = n.oid
+         WHERE n.nspname = $1 AND p.proname = $2
+         LIMIT 1`, [schema, funcName]);
+            if (result.rows.length === 0) {
+                // Function not in remote yet — generate migration to create it
+                const migrationPath = await (0, generateMigration_1.generateFunctionMigrationFile)(schema, funcName, localDdl, '', process.cwd(), migrationConfig);
+                if (migrationPath) {
+                    console.log(`[${schema}.${funcName}] 📝 NEW function migration generated: ${migrationPath}`);
+                    changed++;
+                }
+                continue;
+            }
+            const remoteDdl = result.rows[0].definition;
+            const migrationPath = await (0, generateMigration_1.generateFunctionMigrationFile)(schema, funcName, localDdl, remoteDdl, process.cwd(), migrationConfig);
+            if (migrationPath) {
+                console.log(`[${schema}.${funcName}] 📝 UPDATE function migration generated: ${migrationPath}`);
+                changed++;
+            }
+        }
+    }
+    finally {
+        await client.end();
+    }
+    if (changed === 0) {
+        console.log('Functions: no differences found');
+    }
+    else {
+        console.log(`Functions: ${changed} migration(s) generated`);
+    }
+}
+/**
+ * Fetch remote RLS policies, compare with local <schemaDir>/<schema>/rls/*.sql,
+ * and generate DROP + CREATE migrations for changed/new/deleted policies.
+ */
+async function syncRls(connectionString, schemaDir, migrationConfig) {
+    const { Client } = await Promise.resolve().then(() => __importStar(require('pg')));
+    const client = new Client({ connectionString });
+    await client.connect();
+    try {
+        // Fetch all policies from remote
+        const result = await client.query(`
+      SELECT schemaname, tablename, policyname, cmd,
+             array_to_string(roles, ',') as roles,
+             qual, with_check,
+             permissive
+      FROM pg_policies
+      ORDER BY schemaname, tablename, policyname
+    `);
+        // Build remote policy map: key = "schema.table.policyname"
+        const remoteMap = new Map();
+        for (const row of result.rows) {
+            const tableQualified = row.schemaname === 'public'
+                ? row.tablename
+                : `${row.schemaname}.${row.tablename}`;
+            const key = `${row.schemaname}.${row.tablename}.${row.policyname}`;
+            remoteMap.set(key, {
+                policyName: row.policyname,
+                tableName: tableQualified,
+                cmd: row.cmd ?? 'ALL',
+                roles: row.roles ?? 'public',
+                qual: row.qual ?? null,
+                withCheck: row.with_check ?? null,
+                permissive: row.permissive !== 'RESTRICTIVE'
+            });
+        }
+        // Build local policy map from rls/*.sql files
+        const localMap = new Map(); // key → raw SQL
+        if (fs.existsSync(schemaDir)) {
+            for (const schemaEntry of fs.readdirSync(schemaDir, { withFileTypes: true })) {
+                if (!schemaEntry.isDirectory())
+                    continue;
+                const rlsDir = path.join(schemaDir, schemaEntry.name, 'rls');
+                if (!fs.existsSync(rlsDir))
+                    continue;
+                for (const file of fs.readdirSync(rlsDir)) {
+                    if (!file.endsWith('.sql'))
+                        continue;
+                    // filename: tablename__policyname.sql
+                    const baseName = file.replace(/\.sql$/, '');
+                    const key = `${schemaEntry.name}.${baseName.replace('__', '.')}`;
+                    localMap.set(key, fs.readFileSync(path.join(rlsDir, file), 'utf-8'));
+                }
+            }
+        }
+        // Detect changes: remote policies not matching local
+        const changed = [];
+        const dropped = [];
+        // Policies in remote that differ from local (or absent in local → drop)
+        for (const [key, remotePolicy] of remoteMap) {
+            if (!localMap.has(key)) {
+                // Remote has policy but local doesn't — local wins: drop it
+                dropped.push({ policyName: remotePolicy.policyName, tableName: remotePolicy.tableName });
+            }
+            // If local has it, we trust local as SSoT — will re-create from local below
+        }
+        // Policies in local but not in remote, or that differ → re-create
+        for (const [key, localSql] of localMap) {
+            const remotePolicy = remoteMap.get(key);
+            const normalizedLocal = localSql.replace(/\s+/g, ' ').trim();
+            if (!remotePolicy) {
+                // New policy in local
+                changed.push(parsePolicySql(localSql, key));
+            }
+            else {
+                // Compare: rebuild remote SQL and compare normalized
+                const remoteSql = buildPolicySql(remotePolicy);
+                if (normalizedLocal !== remoteSql.replace(/\s+/g, ' ').trim()) {
+                    changed.push(parsePolicySql(localSql, key));
+                }
+            }
+        }
+        const migrationPath = await (0, generateMigration_1.generateRlsMigrationFile)(changed, dropped, process.cwd(), migrationConfig);
+        if (!migrationPath) {
+            console.log('RLS: no differences found');
+        }
+        else {
+            console.log(`RLS: ${changed.length} changed, ${dropped.length} dropped`);
+        }
+    }
+    finally {
+        await client.end();
+    }
+}
+function buildPolicySql(p) {
+    const permissive = p.permissive ? 'PERMISSIVE' : 'RESTRICTIVE';
+    let sql = `CREATE POLICY "${p.policyName}" ON ${p.tableName} AS ${permissive} FOR ${p.cmd} TO ${p.roles}`;
+    if (p.qual)
+        sql += ` USING (${p.qual})`;
+    if (p.withCheck)
+        sql += ` WITH CHECK (${p.withCheck})`;
+    return sql + ';';
+}
+function parsePolicySql(sql, key) {
+    // Best-effort parse of CREATE POLICY DDL to RlsPolicy struct
+    const tableMatch = sql.match(/ON\s+(\S+)/i);
+    const policyMatch = sql.match(/CREATE POLICY\s+"?([^"\s]+)"?/i);
+    const cmdMatch = sql.match(/FOR\s+(SELECT|INSERT|UPDATE|DELETE|ALL)/i);
+    const rolesMatch = sql.match(/TO\s+([^\n]+?)(?:\s+USING|\s+WITH CHECK|;|$)/i);
+    const usingMatch = sql.match(/USING\s*\(([^)]+)\)/i);
+    const withCheckMatch = sql.match(/WITH CHECK\s*\(([^)]+)\)/i);
+    const permissive = !/RESTRICTIVE/i.test(sql);
+    const parts = key.split('.');
+    const policyName = policyMatch?.[1] ?? parts[parts.length - 1];
+    const tableName = tableMatch?.[1] ?? `${parts[0]}.${parts[1]}`;
+    return {
+        policyName,
+        tableName,
+        cmd: cmdMatch?.[1] ?? 'ALL',
+        roles: rolesMatch?.[1]?.trim() ?? 'public',
+        qual: usingMatch?.[1] ?? null,
+        withCheck: withCheckMatch?.[1] ?? null,
+        permissive
+    };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "supatool",
-  "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.",
+  "version": "0.6.0",
+  "description": "CLI for PostgreSQL (Cloud SQL / Supabase): extract schema to files, deploy schema diffs, apply migrations, seed export.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -9,6 +9,7 @@
   },
 "scripts": {
   "build": "tsc",
+  "test": "npm run build && node test/smoke.js",
   "start": "tsx src/bin/supatool.ts",
   "local": "tsx src/bin/supatool.ts"
 },
@@ -17,18 +18,18 @@
     "bin"
   ],
   "keywords": [
+    "postgresql",
+    "cloud-sql",
     "supabase",
-    "crud",
     "cli",
     "typescript",
-    "React",
     "postgres",
-    "database"
+    "database",
+    "migration"
   ],
   "author": "IdeaGarage",
   "license": "MIT",
   "dependencies": {
-    "@supabase/supabase-js": "^2.49.4",
     "commander": "^13.1.0",
     "diff": "^5.2.0",
     "dotenv": "^16.5.0",

package/dist/integrations/supabase/crud-autogen/tasks.js

@@ -1,220 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTasksByFilters = getTasksByFilters;
-exports.getTasksSingleByFilters = getTasksSingleByFilters;
-exports.getTasksById = getTasksById;
-exports.createTasks = createTasks;
-exports.updateTasks = updateTasks;
-exports.deleteTasks = deleteTasks;
-exports.queryTasks = queryTasks;
-// Supabase CRUD operations for tasks
-// This file is automatically generated. Do not edit it directly.
-const client_1 = require("../client");
-// Function to apply filters to a query
-function applyFilters(query, filters) {
-    for (const [key, value] of Object.entries(filters)) {
-        if (Array.isArray(value)) {
-            query = query.in(key, value); // Use 'in' for array values
-        }
-        else if (typeof value === 'object' && value !== null) {
-            for (const [operator, val] of Object.entries(value)) {
-                switch (operator) {
-                    case 'eq':
-                        query = query.eq(key, val);
-                        break;
-                    case 'neq':
-                        query = query.neq(key, val);
-                        break;
-                    case 'like':
-                        query = query.like(key, val);
-                        break;
-                    case 'ilike':
-                        query = query.ilike(key, val);
-                        break;
-                    case 'lt':
-                        query = query.lt(key, val);
-                        break;
-                    case 'lte':
-                        query = query.lte(key, val);
-                        break;
-                    case 'gte':
-                        query = query.gte(key, val);
-                        break;
-                    case 'gt':
-                        query = query.gt(key, val);
-                        break;
-                    case 'contains':
-                        query = query.contains(key, val);
-                        break;
-                    case 'contains_any':
-                        query = query.contains_any(key, val);
-                        break;
-                    case 'contains_all':
-                        query = query.contains_all(key, val);
-                        break;
-                    // Add more operators as needed
-                    default:
-                        throw new Error('Unsupported operator: ' + operator);
-                }
-            }
-        }
-        else {
-            query = query.eq(key, value); // Default to 'eq' for simple values
-        }
-    }
-    return query;
-}
-// Read multiple rows with dynamic filters
-async function getTasksByFilters({ filters }) {
-    try {
-        let query = client_1.supabase.from('tasks').select('*');
-        query = applyFilters(query, filters);
-        const result = await query;
-        if (result.error) {
-            throw new Error(`Failed to fetch tasks: ${result.error.message}`);
-        }
-        return result.data || [];
-    }
-    catch (error) {
-        console.error('Error in getTasksByFilters:', error);
-        throw error;
-    }
-}
-// Read a single row with dynamic filters
-async function getTasksSingleByFilters({ filters }) {
-    try {
-        let query = client_1.supabase.from('tasks').select('*');
-        query = applyFilters(query, filters).single();
-        const result = await query;
-        if (result.error) {
-            if (result.error.code === 'PGRST116') {
-                return null;
-            }
-            throw new Error(`Failed to fetch tasks: ${result.error.message}`);
-        }
-        return result.data;
-    }
-    catch (error) {
-        console.error('Error in getTasksSingleByFilters:', error);
-        throw error;
-    }
-}
-// Read single row using id
-async function getTasksById({ id }) {
-    if (!id) {
-        throw new Error('ID is required');
-    }
-    try {
-        const result = await client_1.supabase
-            .from('tasks')
-            .select('*')
-            .eq('id', id)
-            .single();
-        if (result.error) {
-            if (result.error.code === 'PGRST116') {
-                return null;
-            }
-            throw new Error(`Failed to fetch tasks: ${result.error.message}`);
-        }
-        return result.data;
-    }
-    catch (error) {
-        console.error('Error in getTasksById:', error);
-        throw error;
-    }
-}
-// Create Function
-async function createTasks({ data }) {
-    if (!data) {
-        throw new Error('Data is required for creation');
-    }
-    try {
-        const result = await client_1.supabase
-            .from('tasks')
-            .insert([data])
-            .select()
-            .single();
-        if (result.error) {
-            throw new Error(`Failed to create tasks: ${result.error.message}`);
-        }
-        if (!result.data) {
-            throw new Error('No data returned after creation');
-        }
-        return result.data;
-    }
-    catch (error) {
-        console.error('Error in createTasks:', error);
-        throw error;
-    }
-}
-// Update Function
-async function updateTasks({ id, data }) {
-    if (!id) {
-        throw new Error('ID is required for update');
-    }
-    if (!data || Object.keys(data).length === 0) {
-        throw new Error('Update data is required');
-    }
-    try {
-        const result = await client_1.supabase
-            .from('tasks')
-            .update(data)
-            .eq('id', id)
-            .select()
-            .single();
-        if (result.error) {
-            if (result.error.code === 'PGRST116') {
-                throw new Error(`tasks with ID ${id} not found`);
-            }
-            throw new Error(`Failed to update tasks: ${result.error.message}`);
-        }
-        if (!result.data) {
-            throw new Error(`tasks with ID ${id} not found`);
-        }
-        return result.data;
-    }
-    catch (error) {
-        console.error('Error in updateTasks:', error);
-        throw error;
-    }
-}
-// Delete Function
-async function deleteTasks({ id }) {
-    if (!id) {
-        throw new Error('ID is required for deletion');
-    }
-    try {
-        const result = await client_1.supabase
-            .from('tasks')
-            .delete()
-            .eq('id', id);
-        if (result.error) {
-            throw new Error(`Failed to delete tasks: ${result.error.message}`);
-        }
-        return true;
-    }
-    catch (error) {
-        console.error('Error in deleteTasks:', error);
-        throw error;
-    }
-}
-// Custom query function
-async function queryTasks({ query }) {
-    if (!query) {
-        throw new Error('Query is required');
-    }
-    try {
-        const result = await client_1.supabase
-            .from('tasks')
-            .select(query);
-        if (result.error) {
-            throw new Error(`Failed to execute query: ${result.error.message}`);
-        }
-        return result.data || [];
-    }
-    catch (error) {
-        console.error('Error in queryTasks:', error);
-        throw error;
-    }
-}
-// All functions are exported individually above