@coldge.com/gitbase 1.0.2

package/dist/commands/diff.js

@@ -0,0 +1,125 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import * as diffLib from 'diff';
+import { readCommit, readTree, readObject } from '../storage/git.js';
+import { extractSchema } from '../schema/extractor.js';
+import { canonicalize } from '../utils/hashing.js';
+const GITBASE_DIR = '.gitbase';
+const CONFIG_FILE = path.join(GITBASE_DIR, 'config');
+export async function diff(argv) {
+    // 1. Check Config
+    try {
+        await fs.access(CONFIG_FILE);
+    }
+    catch {
+        console.error(chalk.red('Not initialized. Run `gitb init` first.'));
+        return;
+    }
+    const config = JSON.parse(await fs.readFile(CONFIG_FILE, 'utf-8'));
+    // Support new config format (branches)
+    const currentBranch = config.branches ? config.branches[config.currentBranch] : null;
+    const projectRef = currentBranch ? currentBranch.projectRef : config.projectRef;
+    if (!projectRef) {
+        console.error(chalk.red('Project Ref not found in config.'));
+        return;
+    }
+    console.log(chalk.blue(`Fetching current database state...`));
+    const liveSchema = await extractSchema(projectRef);
+    let targetSchema = { tables: {}, functions: {}, views: {}, triggers: {}, policies: {}, types: {} };
+    let targetLabel = '';
+    // Filter files if provided
+    const filterFiles = argv.files || [];
+    // 2. Load Target Schema (Commit or Local Files)
+    const commitHash = argv.commit;
+    if (commitHash) {
+        // Compare with specific commit
+        targetLabel = `Commit ${commitHash.substring(0, 7)}`;
+        try {
+            const commit = await readCommit(commitHash);
+            const tree = await readTree(commit.tree);
+            for (const [relPath, hash] of Object.entries(tree)) {
+                const parts = relPath.split('/');
+                const type = parts[0];
+                const name = path.basename(relPath, '.sql');
+                const content = await readObject(hash);
+                if (targetSchema[type])
+                    targetSchema[type][name] = content;
+            }
+        }
+        catch {
+            console.error(chalk.red(`Commit ${commitHash} not found.`));
+            return;
+        }
+    }
+    else {
+        // Compare with Local Files (equivalent to git diff)
+        targetLabel = 'Local Files';
+        const types = ['tables', 'functions', 'views', 'triggers', 'policies', 'types'];
+        for (const type of types) {
+            const dir = path.join('supabase', type);
+            try {
+                const files = await fs.readdir(dir);
+                for (const file of files) {
+                    if (!file.endsWith('.sql'))
+                        continue;
+                    const name = path.basename(file, '.sql');
+                    // Un-sanitize name if needed? 
+                    // In our extractor, we replace '/' with '_' for local files.
+                    // But for functions and tables they don't usually have '/'.
+                    const content = await fs.readFile(path.join(dir, file), 'utf-8');
+                    targetSchema[type][name] = content;
+                }
+            }
+            catch (e) {
+                // Directory doesn't exist, ignore
+            }
+        }
+    }
+    // 4. Compare and Print Diff
+    let hasDifferences = false;
+    const types = ['tables', 'functions', 'views', 'triggers', 'policies', 'types'];
+    for (const type of types) {
+        const keys = Array.from(new Set([
+            ...Object.keys(liveSchema[type]),
+            ...Object.keys(targetSchema[type])
+        ])).sort();
+        for (const key of keys) {
+            const filePath = `${type}/${key}.sql`;
+            if (filterFiles.length > 0 && !filterFiles.includes(filePath))
+                continue;
+            const liveSql = liveSchema[type][key] || '';
+            const targetSql = targetSchema[type][key] || '';
+            if (canonicalize(liveSql) !== canonicalize(targetSql)) {
+                hasDifferences = true;
+                console.log(chalk.bold(`\ndiff --git a/${type}/${key}.sql b/${type}/${key}.sql`));
+                const patch = diffLib.createTwoFilesPatch(`a/${type}/${key}.sql`, `b/${type}/${key}.sql`, targetSql, liveSql, targetLabel, 'Live Database');
+                // Colorize patch output, skipping the first 4 header lines usually
+                const lines = patch.split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                    const line = lines[i];
+                    if (i < 4) {
+                        // Print headers in default or bold
+                        console.log(chalk.white(line));
+                        continue;
+                    }
+                    if (line.startsWith('+') && !line.startsWith('+++')) {
+                        console.log(chalk.green(line));
+                    }
+                    else if (line.startsWith('-') && !line.startsWith('---')) {
+                        console.log(chalk.red(line));
+                    }
+                    else if (line.startsWith('@@')) {
+                        console.log(chalk.cyan(line));
+                    }
+                    else {
+                        console.log(line);
+                    }
+                }
+            }
+        }
+    }
+    if (!hasDifferences) {
+        console.log(chalk.green(`\nNo differences found. Live database matches ${targetLabel} exactly.`));
+    }
+}

package/dist/commands/fetch.js

@@ -0,0 +1,49 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import { getConfig, listStorageObjects, downloadFromStorage } from '../api/supabase.js';
+const GITBASE_DIR = '.gitbase';
+const OBJECTS_DIR = path.join(GITBASE_DIR, 'objects');
+const BUCKET_NAME = 'gitbase-remotes';
+export async function fetch() {
+    const config = await getConfig();
+    if (!config) {
+        console.error(chalk.red('Not initialized.'));
+        return;
+    }
+    const currentBranch = config.currentBranch;
+    const projectRef = config.branches[currentBranch].projectRef;
+    console.log(chalk.blue(`Fetching remote objects from Supabase for branch '${currentBranch}'...`));
+    try {
+        // List all objects in the bucket
+        const objects = await listStorageObjects(projectRef, BUCKET_NAME, 'objects/');
+        let downloadCount = 0;
+        for (const obj of objects) {
+            const hash = obj.name;
+            const localPath = path.join(OBJECTS_DIR, hash);
+            // Check if we already have this object
+            try {
+                await fs.access(localPath);
+            }
+            catch {
+                // Download missing object
+                const content = await downloadFromStorage(projectRef, BUCKET_NAME, `objects/${hash}`);
+                await fs.mkdir(OBJECTS_DIR, { recursive: true });
+                await fs.writeFile(localPath, content, 'utf-8');
+                downloadCount++;
+            }
+        }
+        // Update branch HEAD from bucket if possible?
+        // For now, let's keep config.json as the local source.
+        // A real "git fetch" also updates remote tracking branches.
+        if (downloadCount === 0) {
+            console.log(chalk.green('Local history is up to date.'));
+        }
+        else {
+            console.log(chalk.green(`Fetched ${downloadCount} new object(s) from remote.`));
+        }
+    }
+    catch (e) {
+        console.error(chalk.red(`Fetch failed: ${e.message}`));
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,90 @@
+import fs from 'fs/promises';
+import path from 'path';
+import readline from 'readline';
+import chalk from 'chalk';
+const GITBASE_DIR = '.gitbase';
+const CONFIG_FILE = path.join(GITBASE_DIR, 'config');
+export async function init(argv = {}) {
+    try {
+        await fs.mkdir(GITBASE_DIR);
+        console.log(chalk.green('Initialized empty GitBase repository in .gitbase/'));
+    }
+    catch (error) {
+        if (error.code === 'EEXIST') {
+            // console.log(chalk.yellow('GitBase repository already exists.'));
+        }
+        else {
+            console.error(chalk.red('Failed to initialize repository:', error));
+            return;
+        }
+    }
+    // Check if config exists
+    try {
+        await fs.access(CONFIG_FILE);
+        if (!argv.force) {
+            console.log(chalk.yellow('Project is already linked. Use --force to re-initialize.'));
+            return;
+        }
+    }
+    catch {
+        // Continue
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+    console.log(chalk.blue('Please enter your Supabase Project Reference ID:'));
+    const ref = await ask('Project Ref (e.g., mxyzptlk): ');
+    if (!ref) {
+        console.log(chalk.red('Project Ref is required.'));
+        rl.close();
+        return;
+    }
+    console.log(chalk.blue('\nPlease enter your Full Database Connection URI:'));
+    console.log(chalk.gray('(Click the "Connect" button in the top header of your Supabase dashboard)'));
+    console.log(chalk.yellow('IMPORTANT: In case the connection fails later, change the connection type to "Session Pooler" in the dropdown and try again!'));
+    console.log(chalk.gray('Make sure to replace [YOUR-PASSWORD] with your actual password!'));
+    console.log(chalk.gray('Example: postgresql://postgres.mxyzptlk:mypassword@aws-0-us-east-1.pooler.supabase.com:5432/postgres'));
+    const connString = await ask('\nConnection URI: ');
+    if (!connString) {
+        console.log(chalk.red('Connection URI is required to execute SQL.'));
+        rl.close();
+        return;
+    }
+    const config = {
+        currentBranch: 'production',
+        branches: {
+            production: {
+                projectRef: ref.trim(),
+                connectionString: connString.trim(),
+                head: null
+            }
+        }
+    };
+    await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
+    console.log(chalk.green(`\nLinked to project: ${ref.trim()} (Branch: production)`));
+    // Create supabase directory structure
+    await fs.mkdir('supabase/tables', { recursive: true });
+    await fs.mkdir('supabase/functions', { recursive: true });
+    await fs.mkdir('supabase/views', { recursive: true });
+    await fs.mkdir('supabase/types', { recursive: true });
+    await fs.mkdir('supabase/triggers', { recursive: true });
+    await fs.mkdir('supabase/policies', { recursive: true });
+    // Auto-ignore .gitbase
+    try {
+        const gitignorePath = '.gitignore';
+        let gitignoreContent = '';
+        try {
+            gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
+        }
+        catch (e) { }
+        if (!gitignoreContent.includes(GITBASE_DIR)) {
+            const entry = `\n# GitBase history & config\n${GITBASE_DIR}/\n`;
+            await fs.appendFile(gitignorePath, entry);
+            console.log(chalk.gray('Added .gitbase/ to .gitignore for security.'));
+        }
+    }
+    catch (e) { }
+    rl.close();
+}

package/dist/commands/log.js

@@ -0,0 +1,30 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import { readCommit } from '../storage/git.js';
+const GITBASE_DIR = '.gitbase';
+const HEAD_FILE = path.join(GITBASE_DIR, 'HEAD');
+export async function log() {
+    let currentHash;
+    try {
+        currentHash = await fs.readFile(HEAD_FILE, 'utf-8');
+    }
+    catch {
+        console.log(chalk.red('No commits yet.'));
+        return;
+    }
+    console.log(chalk.cyan('Commit History:'));
+    while (currentHash) {
+        try {
+            const commit = await readCommit(currentHash);
+            console.log(chalk.yellow(`commit ${currentHash}`));
+            console.log(`Author: ${commit.author}`);
+            console.log(`Date:   ${commit.timestamp}`);
+            console.log(`\n    ${commit.message}\n`);
+            currentHash = commit.parent;
+        }
+        catch (e) {
+            break;
+        }
+    }
+}

package/dist/commands/login.js

@@ -0,0 +1,29 @@
+import { saveToken } from '../utils/config.js';
+import readline from 'readline';
+import chalk from 'chalk';
+export async function login() {
+    console.log(chalk.blue('Please enter your Supabase Access Token (https://supabase.com/dashboard/account/tokens):'));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        rl.question('Token: ', async (token) => {
+            if (!token) {
+                console.log(chalk.red('Token is required.'));
+                rl.close();
+                resolve();
+                return;
+            }
+            try {
+                await saveToken(token.trim());
+                console.log(chalk.green('Token saved successfully!'));
+            }
+            catch (error) {
+                console.error(chalk.red('Failed to save token:', error));
+            }
+            rl.close();
+            resolve();
+        });
+    });
+}

package/dist/commands/merge.js

@@ -0,0 +1,59 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import { readCommit, readTree, readObject } from '../storage/git.js';
+const GITBASE_DIR = '.gitbase';
+export async function merge(argv) {
+    const sourceBranch = argv.name;
+    if (!sourceBranch) {
+        console.error(chalk.red('Source branch name required.'));
+        return;
+    }
+    const configContent = await fs.readFile(path.join(GITBASE_DIR, 'config'), 'utf-8');
+    const config = JSON.parse(configContent);
+    if (!config.branches[sourceBranch]) {
+        console.error(chalk.red(`Branch '${sourceBranch}' does not exist.`));
+        return;
+    }
+    if (sourceBranch === config.currentBranch) {
+        console.error(chalk.red('Cannot merge a branch into itself.'));
+        return;
+    }
+    const sourceHead = config.branches[sourceBranch].head;
+    if (!sourceHead) {
+        console.error(chalk.red(`Branch '${sourceBranch}' has no commits to merge.`));
+        return;
+    }
+    const currentBranch = config.currentBranch;
+    const projectRef = config.branches[currentBranch].projectRef;
+    // RBAC: Production Protection
+    if (currentBranch === 'production') {
+        const { isProductionAdmin } = await import('../api/supabase.js');
+        console.log(chalk.blue('Verifying production permissions...'));
+        const isAdmin = await isProductionAdmin(projectRef);
+        if (!isAdmin) {
+            console.error(chalk.red('\n🔥 ACCESS DENIED: Only Owners or Administrators can merge into the production branch.'));
+            return;
+        }
+        console.log(chalk.green('Permission verified.'));
+    }
+    console.log(chalk.blue(`Merging files from '${sourceBranch}' into '${currentBranch}'...`));
+    // 1. Load source tree
+    const commit = await readCommit(sourceHead);
+    const tree = await readTree(commit.tree);
+    // 2. Clear current supabase dir and copy files
+    // In a real merge, we would do a 3-way merge. 
+    // For MVP, we just overwrite local files with the source branch's files.
+    try {
+        await fs.rm('supabase', { recursive: true, force: true });
+    }
+    catch (e) { }
+    for (const [relPath, hash] of Object.entries(tree)) {
+        const fullPath = path.join('supabase', relPath);
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        const content = await readObject(hash);
+        await fs.writeFile(fullPath, content, 'utf-8');
+    }
+    console.log(chalk.green(`\nSuccessfully merged branch '${sourceBranch}' into your local files.`));
+    console.log(chalk.yellow(`Run 'gitb push' to apply these changes to the live '${config.currentBranch}' database.`));
+}

package/dist/commands/push.js

@@ -0,0 +1,176 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import readline from 'readline';
+import { getConfig, runQuery } from '../api/supabase.js';
+import { extractSchema } from '../schema/extractor.js';
+import { canonicalize } from '../utils/hashing.js';
+import toposort from 'toposort';
+const GITBASE_DIR = '.gitbase';
+export async function push(argv) {
+    const config = await getConfig();
+    if (!config) {
+        console.error(chalk.red('Not initialized. Run `gitb init` first.'));
+        return;
+    }
+    const currentBranch = config.currentBranch;
+    const projectRef = config.branches[currentBranch].projectRef;
+    // RBAC: Production Protection
+    if (currentBranch === 'production') {
+        const { isProductionAdmin } = await import('../api/supabase.js');
+        console.log(chalk.blue('Verifying production permissions...'));
+        const isAdmin = await isProductionAdmin(projectRef);
+        if (!isAdmin) {
+            console.error(chalk.red('\n🔥 ACCESS DENIED: Only Owners or Administrators can push to the production branch.'));
+            console.error(chalk.yellow('Please work on a feature branch and request an administrator to sync your changes.'));
+            return;
+        }
+        console.log(chalk.green('Permission verified.'));
+    }
+    const filterFiles = argv.files || [];
+    console.log(chalk.blue(`Pushing local files to branch '${currentBranch}' (${projectRef})...`));
+    // 1. Fetch current live state to make smart decisions
+    console.log(chalk.blue(`Checking current database state...`));
+    const liveSchema = await extractSchema(projectRef);
+    // 2. Load Local Files as the "Target Schema"
+    const localSchema = { tables: {}, functions: {}, views: {}, triggers: {}, policies: {}, types: {} };
+    const types = ['tables', 'functions', 'views', 'triggers', 'policies', 'types'];
+    for (const type of types) {
+        const dir = path.join('supabase', type);
+        try {
+            const files = await fs.readdir(dir);
+            for (const file of files) {
+                if (!file.endsWith('.sql'))
+                    continue;
+                const name = path.basename(file, '.sql');
+                const content = await fs.readFile(path.join(dir, file), 'utf-8');
+                localSchema[type][name] = content;
+            }
+        }
+        catch (e) { }
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+    let madeDbChanges = false;
+    // 3. Execution Plan (Same logic as revert, but local files are the truth)
+    // TYPES
+    for (const [name, sql] of Object.entries(localSchema.types)) {
+        if (filterFiles.length > 0 && !filterFiles.includes(`types/${name}.sql`))
+            continue;
+        if (liveSchema.types[name] && canonicalize(sql) === canonicalize(liveSchema.types[name]))
+            continue;
+        madeDbChanges = true;
+        console.log(chalk.cyan(`Pushing Type: ${name}`));
+        await runQuery(projectRef, `DROP TYPE IF EXISTS public."${name}" CASCADE;`);
+        await runQuery(projectRef, sql);
+    }
+    // TABLES (Topological Sort)
+    const tableEdges = [];
+    const tables = localSchema.tables;
+    const tableNames = Object.keys(tables);
+    for (const [name, sql] of Object.entries(tables)) {
+        const content = sql;
+        const regex = /REFERENCES\s+(?:public\.)?(\w+)/gi;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const target = match[1];
+            if (target !== name && tables[target])
+                tableEdges.push([target, name]);
+        }
+    }
+    let sortedTables = tableNames;
+    try {
+        sortedTables = toposort.array(tableNames, tableEdges);
+    }
+    catch (e) {
+        sortedTables = tableNames.sort();
+    }
+    for (const name of sortedTables) {
+        const sql = tables[name];
+        if (filterFiles.length > 0 && !filterFiles.includes(`tables/${name}.sql`))
+            continue;
+        if (liveSchema.tables[name] && canonicalize(sql) === canonicalize(liveSchema.tables[name]))
+            continue;
+        madeDbChanges = true;
+        console.log(chalk.yellow(`\nPushing Table: ${name}`));
+        if (liveSchema.tables[name]) {
+            const answer = await ask(chalk.white(`? Table '${name}' schema changed. Keep existing as backup? (Y/n) > `));
+            if (answer.toLowerCase() !== 'n') {
+                const timestamp = Math.floor(Date.now() / 1000);
+                const backupName = `${name}_backup_${timestamp}`;
+                await runQuery(projectRef, `ALTER TABLE public."${name}" RENAME TO "${backupName}";`);
+                console.log(chalk.green('Backup successful.'));
+            }
+            else {
+                await runQuery(projectRef, `DROP TABLE IF EXISTS public."${name}" CASCADE;`);
+            }
+        }
+        await runQuery(projectRef, sql);
+    }
+    // VIEWS
+    for (const [name, sql] of Object.entries(localSchema.views)) {
+        if (filterFiles.length > 0 && !filterFiles.includes(`views/${name}.sql`))
+            continue;
+        if (liveSchema.views[name] && canonicalize(sql) === canonicalize(liveSchema.views[name]))
+            continue;
+        madeDbChanges = true;
+        console.log(chalk.cyan(`Pushing View: ${name}`));
+        await runQuery(projectRef, `DROP VIEW IF EXISTS public."${name}" CASCADE;`);
+        await runQuery(projectRef, sql);
+    }
+    // FUNCTIONS
+    for (const [name, sql] of Object.entries(localSchema.functions)) {
+        if (filterFiles.length > 0 && !filterFiles.includes(`functions/${name}.sql`))
+            continue;
+        if (liveSchema.functions[name] && canonicalize(sql) === canonicalize(liveSchema.functions[name]))
+            continue;
+        madeDbChanges = true;
+        console.log(chalk.cyan(`Pushing Function: ${name}`));
+        await runQuery(projectRef, sql);
+    }
+    // TRIGGERS
+    for (const [name, sql] of Object.entries(localSchema.triggers)) {
+        if (filterFiles.length > 0 && !filterFiles.includes(`triggers/${name}.sql`))
+            continue;
+        if (liveSchema.triggers[name] && canonicalize(sql) === canonicalize(liveSchema.triggers[name]))
+            continue;
+        madeDbChanges = true;
+        console.log(chalk.cyan(`Pushing Trigger: ${name}`));
+        const match = sql.match(/ON\s+(public\.)?("?\w+"?)/i);
+        if (match) {
+            const tableName = match[2].replace(/"/g, '');
+            await runQuery(projectRef, `DROP TRIGGER IF EXISTS "${name}" ON public."${tableName}";`);
+        }
+        await runQuery(projectRef, sql);
+    }
+    // POLICIES
+    for (const [key, sql] of Object.entries(localSchema.policies)) {
+        if (filterFiles.length > 0 && !filterFiles.includes(`policies/${key}.sql`))
+            continue;
+        if (liveSchema.policies[key] && canonicalize(sql) === canonicalize(liveSchema.policies[key]))
+            continue;
+        madeDbChanges = true;
+        const match = sql.match(/CREATE POLICY "([^"]+)"\s+ON\s+(public\.)?("?\w+"?)/i);
+        if (match) {
+            const policyName = match[1];
+            const tableName = match[3].replace(/"/g, '');
+            console.log(chalk.cyan(`Pushing Policy: ${policyName} on ${tableName}`));
+            try {
+                await runQuery(projectRef, `ALTER TABLE public."${tableName}" ENABLE ROW LEVEL SECURITY;`);
+            }
+            catch (e) { }
+            await runQuery(projectRef, `DROP POLICY IF EXISTS "${policyName}" ON public."${tableName}";`);
+            await runQuery(projectRef, sql);
+        }
+    }
+    rl.close();
+    if (!madeDbChanges) {
+        console.log(chalk.green('\nEverything is already up to date. No push required.'));
+    }
+    else {
+        console.log(chalk.green('\nPush complete! Live database updated.'));
+    }
+}