@developer-ayushanand/dbgit 0.1.0-beta.1

package/dist/core/generator.js

@@ -0,0 +1,104 @@
+import { ChangeType } from '../types/changes.js';
+export function generateForwardSQL(changeset) {
+    return changeset.changes.flatMap(change => generateChangeSQL(change, false));
+}
+export function generateInverseSQL(changeset) {
+    // To generate inverse, we process changes in reverse order
+    // and flip the operations.
+    return [...changeset.changes]
+        .reverse()
+        .flatMap(change => generateChangeSQL(change, true));
+}
+function generateChangeSQL(change, inverse) {
+    const type = inverse ? flipType(change.type) : change.type;
+    switch (type) {
+        case ChangeType.ADD_TABLE: {
+            const table = (inverse ? change.before : change.after);
+            const columnsSql = table.columns.map(renderColumn).join(', ');
+            let sql = `CREATE TABLE ${table.name} (${columnsSql})`;
+            return [sql];
+        }
+        case ChangeType.DROP_TABLE:
+            return [`DROP TABLE ${change.table}`];
+        case ChangeType.ADD_COLUMN: {
+            const col = (inverse ? change.before : change.after);
+            return [`ALTER TABLE ${change.table} ADD COLUMN ${renderColumn(col)}`];
+        }
+        case ChangeType.DROP_COLUMN:
+            return [`ALTER TABLE ${change.table} DROP COLUMN ${change.objectName}`];
+        case ChangeType.MODIFY_COLUMN: {
+            const col = (inverse ? change.before : change.after);
+            const statements = [];
+            statements.push(`ALTER TABLE ${change.table} ALTER COLUMN ${change.objectName} TYPE ${col.type} USING ${change.objectName}::${col.type}`);
+            if (col.nullable) {
+                statements.push(`ALTER TABLE ${change.table} ALTER COLUMN ${change.objectName} DROP NOT NULL`);
+            }
+            else {
+                statements.push(`ALTER TABLE ${change.table} ALTER COLUMN ${change.objectName} SET NOT NULL`);
+            }
+            if (col.default) {
+                statements.push(`ALTER TABLE ${change.table} ALTER COLUMN ${change.objectName} SET DEFAULT ${col.default}`);
+            }
+            else {
+                statements.push(`ALTER TABLE ${change.table} ALTER COLUMN ${change.objectName} DROP DEFAULT`);
+            }
+            return statements;
+        }
+        case ChangeType.ADD_INDEX: {
+            const idx = (inverse ? change.before : change.after);
+            const unique = idx.unique ? 'UNIQUE ' : '';
+            return [`CREATE ${unique}INDEX ${idx.name} ON ${idx.table} (${idx.columns.join(', ')})`];
+        }
+        case ChangeType.DROP_INDEX:
+            return [`DROP INDEX ${change.objectName}`];
+        case ChangeType.ADD_CONSTRAINT: {
+            const con = (inverse ? change.before : change.after);
+            // Note: definition is expected to be something like "CHECK (price > 0)"
+            let typeClause = con.type;
+            if (con.type === 'PRIMARY KEY') {
+                const table = (inverse ? change.beforeTable : change.afterTable);
+                const pkCols = table?.columns.filter(c => c.isPrimaryKey).map(c => c.name).join(', ');
+                if (pkCols) {
+                    return [`ALTER TABLE ${change.table} ADD CONSTRAINT ${con.name} PRIMARY KEY (${pkCols})`];
+                }
+            }
+            return [`ALTER TABLE ${change.table} ADD CONSTRAINT ${con.name} ${typeClause} ${con.definition}`];
+        }
+        case ChangeType.DROP_CONSTRAINT:
+            return [`ALTER TABLE ${change.table} DROP CONSTRAINT ${change.objectName}`];
+        case ChangeType.ADD_FOREIGN_KEY: {
+            const fk = (inverse ? change.before : change.after);
+            return [`ALTER TABLE ${change.table} ADD CONSTRAINT ${fk.name} FOREIGN KEY (${fk.sourceColumn}) REFERENCES ${fk.targetTable}(${fk.targetColumn}) ON DELETE ${fk.onDelete} ON UPDATE ${fk.onUpdate}`];
+        }
+        case ChangeType.DROP_FOREIGN_KEY:
+            return [`ALTER TABLE ${change.table} DROP CONSTRAINT ${change.objectName}`];
+        default:
+            return [];
+    }
+}
+function renderColumn(col) {
+    let sql = `${col.name} ${col.type}`;
+    if (!col.nullable)
+        sql += ' NOT NULL';
+    if (col.default)
+        sql += ` DEFAULT ${col.default}`;
+    if (col.isPrimaryKey)
+        sql += ' PRIMARY KEY';
+    return sql;
+}
+function flipType(type) {
+    switch (type) {
+        case ChangeType.ADD_TABLE: return ChangeType.DROP_TABLE;
+        case ChangeType.DROP_TABLE: return ChangeType.ADD_TABLE;
+        case ChangeType.ADD_COLUMN: return ChangeType.DROP_COLUMN;
+        case ChangeType.DROP_COLUMN: return ChangeType.ADD_COLUMN;
+        case ChangeType.ADD_INDEX: return ChangeType.DROP_INDEX;
+        case ChangeType.DROP_INDEX: return ChangeType.ADD_INDEX;
+        case ChangeType.ADD_CONSTRAINT: return ChangeType.DROP_CONSTRAINT;
+        case ChangeType.DROP_CONSTRAINT: return ChangeType.ADD_CONSTRAINT;
+        case ChangeType.ADD_FOREIGN_KEY: return ChangeType.DROP_FOREIGN_KEY;
+        case ChangeType.DROP_FOREIGN_KEY: return ChangeType.ADD_FOREIGN_KEY;
+        case ChangeType.MODIFY_COLUMN: return ChangeType.MODIFY_COLUMN;
+        default: return type;
+    }
+}

package/dist/core/ignore.d.ts

@@ -0,0 +1,3 @@
+export declare function loadIgnoreList(): string[];
+export declare function shouldIgnore(tableName: string, patterns: string[]): boolean;
+export declare function isSoftDeleted(name: string): boolean;

package/dist/core/ignore.js

@@ -0,0 +1,20 @@
+import fs from 'fs';
+import path from 'path';
+import { minimatch } from 'minimatch';
+export function loadIgnoreList() {
+    const ignoreFile = path.join(process.cwd(), '.dbgitignore');
+    if (!fs.existsSync(ignoreFile))
+        return [];
+    return fs.readFileSync(ignoreFile, 'utf-8')
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line && !line.startsWith('#'));
+}
+export function shouldIgnore(tableName, patterns) {
+    if (tableName.startsWith('_dbgit_deleted_'))
+        return true;
+    return patterns.some(pattern => minimatch(tableName, pattern));
+}
+export function isSoftDeleted(name) {
+    return name.startsWith('_dbgit_deleted_');
+}

package/dist/core/schemaLock.d.ts

@@ -0,0 +1,3 @@
+import pg from 'pg';
+export declare function acquireLock(pool: pg.Pool): Promise<void>;
+export declare function releaseLock(pool: pg.Pool): Promise<void>;

package/dist/core/schemaLock.js

@@ -0,0 +1,18 @@
+import { query } from './connector.js';
+// Simple hash function for the lock key
+function hashCode(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return Math.abs(hash);
+}
+const LOCK_ID = hashCode('dbgit');
+export async function acquireLock(pool) {
+    await query(pool, 'SELECT pg_advisory_lock($1)', [LOCK_ID]);
+}
+export async function releaseLock(pool) {
+    await query(pool, 'SELECT pg_advisory_unlock($1)', [LOCK_ID]);
+}

package/dist/core/snapshot.d.ts

@@ -0,0 +1,4 @@
+import pg from 'pg';
+import { SchemaSnapshot } from '../types/schema.js';
+export declare function captureSnapshot(pool: pg.Pool, ignoreList: string[]): Promise<SchemaSnapshot>;
+export declare function hashSnapshot(snapshot: SchemaSnapshot): string;

package/dist/core/snapshot.js

@@ -0,0 +1,121 @@
+import crypto from 'crypto';
+import { query } from './connector.js';
+import { shouldIgnore } from './ignore.js';
+export async function captureSnapshot(pool, ignoreList) {
+    const tables = {};
+    const tableRows = await query(pool, `
+    SELECT table_name FROM information_schema.tables
+    WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+  `);
+    for (const tableRow of tableRows) {
+        const tableName = tableRow.table_name;
+        if (shouldIgnore(tableName, ignoreList))
+            continue;
+        const columns = await query(pool, `
+      SELECT column_name, data_type, character_maximum_length,
+             is_nullable, column_default, udt_name
+      FROM information_schema.columns
+      WHERE table_schema = 'public' AND table_name = $1
+      ORDER BY ordinal_position
+    `, [tableName]);
+        const primaryKeys = await query(pool, `
+      SELECT kcu.column_name
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      WHERE tc.constraint_type = 'PRIMARY KEY'
+        AND tc.table_schema = 'public'
+        AND tc.table_name = $1
+    `, [tableName]);
+        const pkColumns = new Set(primaryKeys.map(pk => pk.column_name));
+        const indexes = await query(pool, `
+      SELECT indexname, indexdef
+      FROM pg_indexes
+      WHERE schemaname = 'public' AND tablename = $1
+    `, [tableName]);
+        const constraints = await query(pool, `
+      SELECT tc.constraint_name, tc.constraint_type, cc.check_clause
+      FROM information_schema.table_constraints tc
+      LEFT JOIN information_schema.check_constraints cc
+        ON tc.constraint_name = cc.constraint_name
+      WHERE tc.table_schema = 'public' AND tc.table_name = $1
+      AND tc.constraint_type IN ('PRIMARY KEY', 'UNIQUE', 'CHECK')
+    `, [tableName]);
+        const foreignKeys = await query(pool, `
+      SELECT
+        kcu.constraint_name,
+        kcu.column_name as source_column,
+        ccu.table_name as target_table,
+        ccu.column_name as target_column,
+        rc.delete_rule as on_delete,
+        rc.update_rule as on_update
+      FROM information_schema.key_column_usage kcu
+      JOIN information_schema.referential_constraints rc
+        ON kcu.constraint_name = rc.constraint_name
+      JOIN information_schema.constraint_column_usage ccu
+        ON rc.unique_constraint_name = ccu.constraint_name
+      WHERE kcu.table_schema = 'public' AND kcu.table_name = $1
+    `, [tableName]);
+        tables[tableName] = {
+            name: tableName,
+            columns: columns
+                .filter((c) => !c.column_name.startsWith('_dbgit_deleted_'))
+                .map((c) => ({
+                name: c.column_name,
+                type: c.character_maximum_length ? `${c.data_type}(${c.character_maximum_length})` : c.data_type,
+                nullable: c.is_nullable === 'YES',
+                default: c.column_default,
+                isPrimaryKey: pkColumns.has(c.column_name)
+            })),
+            indexes: indexes.map((i) => {
+                // Extract columns from indexdef: "CREATE UNIQUE INDEX idx_name ON table USING btree (col1, col2)"
+                const match = i.indexdef.match(/\((.*)\)/);
+                const cols = match ? match[1].split(',').map((s) => s.trim()) : [];
+                return {
+                    name: i.indexname,
+                    table: tableName,
+                    columns: cols,
+                    unique: i.indexdef.includes('UNIQUE')
+                };
+            }),
+            constraints: constraints.map((c) => ({
+                name: c.constraint_name,
+                table: tableName,
+                type: c.constraint_type,
+                definition: c.check_clause || '' // Simplification, standard definition is harder to get exactly
+            })),
+            foreignKeys: foreignKeys.map((fk) => ({
+                name: fk.constraint_name,
+                sourceTable: tableName,
+                sourceColumn: fk.source_column,
+                targetTable: fk.target_table,
+                targetColumn: fk.target_column,
+                onDelete: fk.on_delete,
+                onUpdate: fk.on_update
+            }))
+        };
+    }
+    const snapshot = {
+        tables,
+        capturedAt: new Date().toISOString(),
+        schemaHash: ''
+    };
+    snapshot.schemaHash = hashSnapshot(snapshot);
+    return snapshot;
+}
+export function hashSnapshot(snapshot) {
+    const sortedTables = Object.keys(snapshot.tables).sort().reduce((acc, key) => {
+        const table = snapshot.tables[key];
+        acc[key] = {
+            ...table,
+            columns: [...table.columns].sort((a, b) => a.name.localeCompare(b.name)),
+            indexes: [...table.indexes].sort((a, b) => a.name.localeCompare(b.name)),
+            constraints: [...table.constraints].sort((a, b) => a.name.localeCompare(b.name)),
+            foreignKeys: [...table.foreignKeys].sort((a, b) => a.name.localeCompare(b.name)),
+        };
+        return acc;
+    }, {});
+    const data = JSON.stringify(sortedTables);
+    return crypto.createHash('sha256').update(data).digest('hex');
+}

package/dist/core/store.d.ts

@@ -0,0 +1,19 @@
+import { Commit, Branch, HEAD } from '../types/commits.js';
+import { SchemaSnapshot } from '../types/schema.js';
+export declare function setRepoRoot(root: string): void;
+export declare function getRepoRoot(): string;
+export declare function initStore(): void;
+export declare function isInitialized(): boolean;
+export declare function saveCommit(commit: Commit): void;
+export declare function loadCommit(hash: string): Commit;
+export declare function saveSnapshot(hash: string, snapshot: SchemaSnapshot): void;
+export declare function loadSnapshot(hash: string): SchemaSnapshot;
+export declare function getHead(): HEAD;
+export declare function setHead(head: HEAD): void;
+export declare function saveBranch(branch: Branch): void;
+export declare function loadBranch(name: string): Branch;
+export declare function listBranches(): string[];
+export declare function listCommits(branchName: string | null, headCommitHash: string | null): Commit[];
+export declare function saveConfig(config: Record<string, string>): void;
+export declare function loadConfig(): Record<string, string>;
+export declare function getBackupsDir(): string;

package/dist/core/store.js

@@ -0,0 +1,102 @@
+import fs from 'fs';
+import path from 'path';
+let repoRoot = process.cwd();
+export function setRepoRoot(root) {
+    repoRoot = root;
+}
+export function getRepoRoot() {
+    return repoRoot;
+}
+const getDbgitDir = () => path.join(getRepoRoot(), '.dbgit');
+const getCommitsDir = () => path.join(getDbgitDir(), 'commits');
+const getSnapshotsDir = () => path.join(getDbgitDir(), 'snapshots');
+const getBranchesDir = () => path.join(getDbgitDir(), 'branches');
+const getBackupsDirInternal = () => path.join(getDbgitDir(), 'backups');
+const getHeadFile = () => path.join(getDbgitDir(), 'HEAD');
+const getConfigFile = () => path.join(getDbgitDir(), 'config');
+export function initStore() {
+    const dbgitDir = getDbgitDir();
+    if (!fs.existsSync(dbgitDir))
+        fs.mkdirSync(dbgitDir, { recursive: true });
+    if (!fs.existsSync(getCommitsDir()))
+        fs.mkdirSync(getCommitsDir(), { recursive: true });
+    if (!fs.existsSync(getSnapshotsDir()))
+        fs.mkdirSync(getSnapshotsDir(), { recursive: true });
+    if (!fs.existsSync(getBranchesDir()))
+        fs.mkdirSync(getBranchesDir(), { recursive: true });
+    if (!fs.existsSync(getBackupsDirInternal()))
+        fs.mkdirSync(getBackupsDirInternal(), { recursive: true });
+}
+export function isInitialized() {
+    return fs.existsSync(getDbgitDir());
+}
+export function saveCommit(commit) {
+    fs.writeFileSync(path.join(getCommitsDir(), `${commit.commitHash}.json`), JSON.stringify(commit, null, 2));
+}
+export function loadCommit(hash) {
+    const filePath = path.join(getCommitsDir(), `${hash}.json`);
+    if (!fs.existsSync(filePath))
+        throw new Error(`Commit ${hash} not found.`);
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+export function saveSnapshot(hash, snapshot) {
+    fs.writeFileSync(path.join(getSnapshotsDir(), `${hash}.json`), JSON.stringify(snapshot, null, 2));
+}
+export function loadSnapshot(hash) {
+    const filePath = path.join(getSnapshotsDir(), `${hash}.json`);
+    if (!fs.existsSync(filePath))
+        throw new Error(`Snapshot ${hash} not found.`);
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+export function getHead() {
+    const headFile = getHeadFile();
+    if (!fs.existsSync(headFile))
+        return { branch: 'main', commit: null };
+    return JSON.parse(fs.readFileSync(headFile, 'utf-8'));
+}
+export function setHead(head) {
+    fs.writeFileSync(getHeadFile(), JSON.stringify(head, null, 2));
+}
+export function saveBranch(branch) {
+    fs.writeFileSync(path.join(getBranchesDir(), `${branch.name}.json`), JSON.stringify(branch, null, 2));
+}
+export function loadBranch(name) {
+    const filePath = path.join(getBranchesDir(), `${name}.json`);
+    if (!fs.existsSync(filePath))
+        throw new Error(`Branch ${name} not found.`);
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+export function listBranches() {
+    return fs.readdirSync(getBranchesDir()).map(f => f.replace('.json', ''));
+}
+export function listCommits(branchName, headCommitHash) {
+    const commits = [];
+    let currentHash = headCommitHash;
+    if (!currentHash && branchName) {
+        try {
+            const branch = loadBranch(branchName);
+            currentHash = branch.headCommit;
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    while (currentHash) {
+        const commit = loadCommit(currentHash);
+        commits.push(commit);
+        currentHash = commit.parent;
+    }
+    return commits;
+}
+export function saveConfig(config) {
+    fs.writeFileSync(getConfigFile(), JSON.stringify(config, null, 2));
+}
+export function loadConfig() {
+    const configFile = getConfigFile();
+    if (!fs.existsSync(configFile))
+        return {};
+    return JSON.parse(fs.readFileSync(configFile, 'utf-8'));
+}
+export function getBackupsDir() {
+    return getBackupsDirInternal();
+}

package/dist/core/transaction.d.ts

@@ -0,0 +1,2 @@
+import pg from 'pg';
+export declare function runInTransaction(pool: pg.Pool, statements: string[]): Promise<void>;

package/dist/core/transaction.js

@@ -0,0 +1,17 @@
+export async function runInTransaction(pool, statements) {
+    const client = await pool.connect();
+    try {
+        await client.query('BEGIN');
+        for (const sql of statements) {
+            await client.query(sql);
+        }
+        await client.query('COMMIT');
+    }
+    catch (e) {
+        await client.query('ROLLBACK');
+        throw new Error(`Transaction failed: ${e.message}`);
+    }
+    finally {
+        client.release();
+    }
+}

package/dist/core/validator.d.ts

@@ -0,0 +1,4 @@
+import pg from 'pg';
+import { Commit } from '../types/commits.js';
+export declare function computeSchemaHash(pool: pg.Pool, ignoreList: string[]): Promise<string>;
+export declare function validateSchemaNotDrifted(pool: pg.Pool, commit: Commit, ignoreList: string[]): Promise<void>;

package/dist/core/validator.js

@@ -0,0 +1,18 @@
+import { captureSnapshot } from './snapshot.js';
+export async function computeSchemaHash(pool, ignoreList) {
+    const snapshot = await captureSnapshot(pool, ignoreList);
+    return snapshot.schemaHash;
+}
+export async function validateSchemaNotDrifted(pool, commit, ignoreList) {
+    const currentHash = await computeSchemaHash(pool, ignoreList);
+    if (currentHash !== commit.schemaHash) {
+        throw new Error(`Schema drift detected.
+Database has been modified outside of DBGit since the last commit.
+HEAD: ${commit.schemaHash.substring(0, 8)}
+Live: ${currentHash.substring(0, 8)}
+
+Rollback aborted for safety.
+If you want to keep live changes, 'dbgit commit' them first.
+If you want to discard them, you may need to manually sync or use --force (not recommended).`);
+    }
+}

package/dist/types/changes.d.ts

@@ -0,0 +1,27 @@
+export declare enum ChangeType {
+    ADD_TABLE = "ADD_TABLE",
+    DROP_TABLE = "DROP_TABLE",
+    ADD_COLUMN = "ADD_COLUMN",
+    DROP_COLUMN = "DROP_COLUMN",
+    MODIFY_COLUMN = "MODIFY_COLUMN",
+    ADD_INDEX = "ADD_INDEX",
+    DROP_INDEX = "DROP_INDEX",
+    ADD_CONSTRAINT = "ADD_CONSTRAINT",
+    DROP_CONSTRAINT = "DROP_CONSTRAINT",
+    ADD_FOREIGN_KEY = "ADD_FOREIGN_KEY",
+    DROP_FOREIGN_KEY = "DROP_FOREIGN_KEY"
+}
+export interface Change {
+    type: ChangeType;
+    table: string;
+    objectName?: string;
+    before?: unknown;
+    after?: unknown;
+    beforeTable?: unknown;
+    afterTable?: unknown;
+    isDestructive: boolean;
+}
+export interface ChangeSet {
+    changes: Change[];
+    hasDestructive: boolean;
+}

package/dist/types/changes.js

@@ -0,0 +1,14 @@
+export var ChangeType;
+(function (ChangeType) {
+    ChangeType["ADD_TABLE"] = "ADD_TABLE";
+    ChangeType["DROP_TABLE"] = "DROP_TABLE";
+    ChangeType["ADD_COLUMN"] = "ADD_COLUMN";
+    ChangeType["DROP_COLUMN"] = "DROP_COLUMN";
+    ChangeType["MODIFY_COLUMN"] = "MODIFY_COLUMN";
+    ChangeType["ADD_INDEX"] = "ADD_INDEX";
+    ChangeType["DROP_INDEX"] = "DROP_INDEX";
+    ChangeType["ADD_CONSTRAINT"] = "ADD_CONSTRAINT";
+    ChangeType["DROP_CONSTRAINT"] = "DROP_CONSTRAINT";
+    ChangeType["ADD_FOREIGN_KEY"] = "ADD_FOREIGN_KEY";
+    ChangeType["DROP_FOREIGN_KEY"] = "DROP_FOREIGN_KEY";
+})(ChangeType || (ChangeType = {}));

package/dist/types/commits.d.ts

@@ -0,0 +1,21 @@
+export interface Commit {
+    commitHash: string;
+    snapshotHash: string;
+    parent: string | null;
+    timestamp: string;
+    message: string;
+    branch: string | null;
+    schemaHash: string;
+    type?: 'commit' | 'rollback';
+    targetCommit?: string;
+}
+export interface Branch {
+    name: string;
+    headCommit: string;
+    createdAt: string;
+    basedOn: string | null;
+}
+export interface HEAD {
+    branch: string | null;
+    commit: string | null;
+}

package/dist/types/commits.js

@@ -0,0 +1 @@
+export {};

package/dist/types/schema.d.ts

@@ -0,0 +1,40 @@
+export interface Column {
+    name: string;
+    type: string;
+    nullable: boolean;
+    default: string | null;
+    isPrimaryKey: boolean;
+}
+export interface Index {
+    name: string;
+    table: string;
+    columns: string[];
+    unique: boolean;
+}
+export interface Constraint {
+    name: string;
+    table: string;
+    type: 'PRIMARY KEY' | 'UNIQUE' | 'CHECK' | 'FOREIGN KEY';
+    definition: string;
+}
+export interface ForeignKey {
+    name: string;
+    sourceTable: string;
+    sourceColumn: string;
+    targetTable: string;
+    targetColumn: string;
+    onDelete: string;
+    onUpdate: string;
+}
+export interface TableSchema {
+    name: string;
+    columns: Column[];
+    indexes: Index[];
+    constraints: Constraint[];
+    foreignKeys: ForeignKey[];
+}
+export interface SchemaSnapshot {
+    tables: Record<string, TableSchema>;
+    capturedAt: string;
+    schemaHash: string;
+}

package/dist/types/schema.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@developer-ayushanand/dbgit",
+  "version": "0.1.0-beta.1",
+  "description": "Git for your database schema — branch, diff, commit, rollback.",
+  "bin": {
+    "dbgit": "./dist/cli.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/**/*.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "boxen": "^8.0.1",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "minimatch": "^9.0.3",
+    "ora": "^7.0.1",
+    "pg": "^8.11.3",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@electric-sql/pglite": "^0.5.1",
+    "@types/node": "^20.11.16",
+    "@types/pg": "^8.20.0",
+    "@types/prompts": "^2.4.9",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "eslint": "^8.56.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.2"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}