@coldge.com/gitbase 1.0.2

package/dist/schema/extractor.js

@@ -0,0 +1,113 @@
+import { runQuery } from '../api/supabase.js';
+import * as Queries from './queries.js';
+export async function extractSchema(projectRef) {
+    const tables = await extractTables(projectRef);
+    const functions = await extractFunctions(projectRef);
+    const views = await extractViews(projectRef);
+    const triggers = await extractTriggers(projectRef);
+    const policies = await extractPolicies(projectRef);
+    const types = await extractTypes(projectRef);
+    return { tables, functions, views, triggers, policies, types };
+}
+async function extractTables(projectRef) {
+    const tableList = await runQuery(projectRef, Queries.LIST_TABLES);
+    if (!Array.isArray(tableList))
+        return {};
+    const tables = {};
+    for (const row of tableList) {
+        const tableName = row.table_name;
+        const rlsEnabled = row.rls_enabled;
+        const columns = await runQuery(projectRef, Queries.GET_COLUMNS(tableName));
+        let sql = `CREATE TABLE public."${tableName}" (\n`;
+        const colDefs = columns.map(c => {
+            let line = `    "${c.column_name}" ${c.data_type}`;
+            if (c.is_nullable === 'NO')
+                line += ' NOT NULL';
+            if (c.column_default)
+                line += ` DEFAULT ${c.column_default}`;
+            return line;
+        });
+        sql += colDefs.join(',\n');
+        sql += '\n);';
+        if (rlsEnabled) {
+            sql += `\nALTER TABLE public."${tableName}" ENABLE ROW LEVEL SECURITY;`;
+        }
+        tables[tableName] = sql;
+    }
+    return tables;
+}
+async function extractFunctions(projectRef) {
+    const funcs = await runQuery(projectRef, Queries.LIST_FUNCTIONS);
+    if (!Array.isArray(funcs))
+        return {};
+    const result = {};
+    for (const f of funcs) {
+        result[f.name] = f.definition;
+    }
+    return result;
+}
+async function extractViews(projectRef) {
+    const views = await runQuery(projectRef, Queries.LIST_VIEWS);
+    if (!Array.isArray(views))
+        return {};
+    const result = {};
+    for (const v of views) {
+        result[v.name] = `CREATE OR REPLACE VIEW public."${v.name}" AS\n${v.definition}`;
+    }
+    return result;
+}
+async function extractTriggers(projectRef) {
+    const triggers = await runQuery(projectRef, Queries.LIST_TRIGGERS);
+    if (!Array.isArray(triggers))
+        return {};
+    const result = {};
+    for (const t of triggers) {
+        result[t.name] = t.definition;
+    }
+    return result;
+}
+async function extractPolicies(projectRef) {
+    const policies = await runQuery(projectRef, Queries.LIST_POLICIES);
+    if (!Array.isArray(policies))
+        return {};
+    const result = {};
+    for (const p of policies) {
+        let sql = `CREATE POLICY "${p.name}"\nON public."${p.tablename}"\nFOR ${p.cmd}`;
+        // Handle roles
+        let roles = p.roles;
+        if (Array.isArray(roles)) {
+            roles = roles.join(', ');
+        }
+        else if (typeof roles === 'string' && roles.startsWith('{')) {
+            roles = roles.replace(/^\{|\}$/g, '').split(',').join(', ');
+        }
+        if (roles) {
+            sql += `\nTO ${roles}`;
+        }
+        if (p.qual)
+            sql += `\nUSING (${p.qual})`;
+        if (p.with_check)
+            sql += `\nWITH CHECK (${p.with_check})`;
+        sql += ';';
+        result[`${p.tablename}_${p.name}`] = sql;
+    }
+    return result;
+}
+async function extractTypes(projectRef) {
+    const types = await runQuery(projectRef, Queries.LIST_TYPES);
+    if (!Array.isArray(types))
+        return {};
+    const result = {};
+    // Group by type name since list returns rows of (name, label) for enums
+    const grouped = {};
+    for (const t of types) {
+        if (!grouped[t.name])
+            grouped[t.name] = [];
+        grouped[t.name].push(t.label);
+    }
+    for (const [name, labels] of Object.entries(grouped)) {
+        const labelsStr = labels.map(l => `'${l}'`).join(', ');
+        result[name] = `CREATE TYPE public."${name}" AS ENUM (${labelsStr});`;
+    }
+    return result;
+}

package/dist/schema/queries.js

@@ -0,0 +1,47 @@
+export const LIST_TABLES = `
+SELECT c.relname as table_name, c.relrowsecurity as rls_enabled
+FROM pg_class c
+JOIN pg_namespace n ON n.oid = c.relnamespace
+WHERE n.nspname = 'public' 
+AND c.relkind = 'r'
+ORDER BY c.relname;
+`;
+export const GET_COLUMNS = (tableName) => `
+SELECT column_name, data_type, is_nullable, column_default
+FROM information_schema.columns
+WHERE table_schema = 'public' AND table_name = '${tableName}'
+ORDER BY ordinal_position;
+`;
+export const LIST_FUNCTIONS = `
+SELECT proname as name, pg_get_functiondef(oid) as definition
+FROM pg_proc
+WHERE pronamespace = 'public'::regnamespace
+ORDER BY proname;
+`;
+export const LIST_VIEWS = `
+SELECT table_name as name, view_definition as definition
+FROM information_schema.views
+WHERE table_schema = 'public'
+ORDER BY table_name;
+`;
+export const LIST_TRIGGERS = `
+SELECT tgname as name, pg_get_triggerdef(oid) as definition
+FROM pg_trigger
+WHERE tgrelid IN (SELECT oid FROM pg_class WHERE relnamespace = 'public'::regnamespace)
+AND tgisinternal = false
+ORDER BY tgname;
+`;
+export const LIST_POLICIES = `
+SELECT policyname as name, tablename, cmd, roles, qual, with_check
+FROM pg_policies
+WHERE schemaname = 'public'
+ORDER BY tablename, policyname;
+`;
+export const LIST_TYPES = `
+SELECT t.typname as name, e.enumlabel as label
+FROM pg_type t
+JOIN pg_enum e ON t.oid = e.enumtypid
+JOIN pg_namespace n ON n.oid = t.typnamespace
+WHERE n.nspname = 'public'
+ORDER BY t.typname, e.enumsortorder;
+`;

package/dist/storage/git.js

@@ -0,0 +1,15 @@
+import fs from 'fs/promises';
+import path from 'path';
+const GITBASE_DIR = '.gitbase';
+const OBJECTS_DIR = path.join(GITBASE_DIR, 'objects');
+export async function readObject(hash) {
+    return fs.readFile(path.join(OBJECTS_DIR, hash), 'utf-8');
+}
+export async function readTree(treeHash) {
+    const content = await readObject(treeHash);
+    return JSON.parse(content);
+}
+export async function readCommit(commitHash) {
+    const content = await readObject(commitHash);
+    return JSON.parse(content);
+}

package/dist/utils/config.js

@@ -0,0 +1,21 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'gitbase');
+const TOKEN_FILE = path.join(CONFIG_DIR, 'token.json');
+export async function ensureConfigDir() {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+}
+export async function saveToken(token) {
+    await ensureConfigDir();
+    await fs.writeFile(TOKEN_FILE, JSON.stringify({ token }), 'utf-8');
+}
+export async function getToken() {
+    try {
+        const data = await fs.readFile(TOKEN_FILE, 'utf-8');
+        return JSON.parse(data).token;
+    }
+    catch (error) {
+        return null;
+    }
+}

package/dist/utils/hashing.js

@@ -0,0 +1,9 @@
+import crypto from 'crypto';
+export function hashString(content) {
+    return crypto.createHash('sha1').update(content).digest('hex');
+}
+export function canonicalize(sql) {
+    // Basic normalization: trim
+    // In a real implementation, we would parse the SQL and reprint it deterministically.
+    return sql.trim();
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@coldge.com/gitbase",
+  "version": "1.0.2",
+  "description": "The Time Machine for Supabase",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "gitb": "dist/index.js",
+    "gitbase": "dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node --loader ts-node/esm src/index.ts",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "supabase",
+    "git",
+    "version-control",
+    "cli"
+  ],
+  "author": "Coldge",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.13.5",
+    "chalk": "^5.6.2",
+    "diff": "^8.0.3",
+    "dotenv": "^17.3.1",
+    "pg": "^8.19.0",
+    "toposort": "^2.0.2",
+    "yargs": "^17.0.0"
+  },
+  "devDependencies": {
+    "@types/diff": "^7.0.2",
+    "@types/node": "^25.3.2",
+    "@types/pg": "^8.16.0",
+    "@types/toposort": "^2.0.7",
+    "@types/yargs": "^17.0.35",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}