relq 1.0.0

package/dist/cjs/cli/utils/snapshot-manager.cjs

@@ -0,0 +1,223 @@
+"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.loadSnapshot = loadSnapshot;
+exports.saveSnapshot = saveSnapshot;
+exports.databaseSchemaToSnapshot = databaseSchemaToSnapshot;
+exports.snapshotToDatabaseSchema = snapshotToDatabaseSchema;
+exports.createBackup = createBackup;
+exports.listBackups = listBackups;
+exports.restoreBackup = restoreBackup;
+exports.addMigrationToSnapshot = addMigrationToSnapshot;
+exports.getAppliedMigrations = getAppliedMigrations;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SNAPSHOT_VERSION = 1;
+const DEFAULT_SNAPSHOT_PATH = '.relq/snapshot.json';
+function loadSnapshot(snapshotPath) {
+    const filePath = snapshotPath || DEFAULT_SNAPSHOT_PATH;
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const snapshot = JSON.parse(content);
+        if (snapshot.version !== SNAPSHOT_VERSION) {
+            console.warn(`Snapshot version mismatch: expected ${SNAPSHOT_VERSION}, got ${snapshot.version}`);
+        }
+        return snapshot;
+    }
+    catch (error) {
+        console.error('Failed to load snapshot:', error);
+        return null;
+    }
+}
+function saveSnapshot(schema, snapshotPath, database) {
+    const filePath = snapshotPath || DEFAULT_SNAPSHOT_PATH;
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const snapshot = databaseSchemaToSnapshot(schema, database);
+    fs.writeFileSync(filePath, JSON.stringify(snapshot, null, 2), 'utf-8');
+}
+function databaseSchemaToSnapshot(schema, database) {
+    const tables = {};
+    for (const table of schema.tables) {
+        tables[table.name] = tableToSnapshot(table);
+    }
+    return {
+        version: SNAPSHOT_VERSION,
+        generatedAt: new Date().toISOString(),
+        database,
+        tables,
+        appliedMigrations: [],
+        extensions: schema.extensions || [],
+    };
+}
+function tableToSnapshot(table) {
+    const columns = {};
+    const indexes = {};
+    const constraints = {};
+    for (const col of table.columns) {
+        columns[col.name] = {
+            name: col.name,
+            dataType: col.dataType,
+            isNullable: col.isNullable,
+            defaultValue: col.defaultValue,
+            isPrimaryKey: col.isPrimaryKey,
+            isUnique: col.isUnique,
+            maxLength: col.maxLength,
+            precision: col.precision,
+            scale: col.scale,
+            references: col.references,
+        };
+    }
+    for (const idx of table.indexes || []) {
+        indexes[idx.name] = {
+            name: idx.name,
+            columns: Array.isArray(idx.columns) ? idx.columns : [idx.columns],
+            isUnique: idx.isUnique,
+            isPrimary: idx.isPrimary,
+            type: idx.type,
+        };
+    }
+    for (const con of table.constraints || []) {
+        constraints[con.name] = {
+            name: con.name,
+            type: con.type,
+            columns: con.columns || [],
+            definition: con.definition,
+            referencedTable: con.referencedTable,
+        };
+    }
+    return {
+        name: table.name,
+        schema: table.schema,
+        columns,
+        indexes,
+        constraints,
+        isPartitioned: table.isPartitioned,
+        partitionType: table.partitionType,
+        partitionKey: table.partitionKey,
+    };
+}
+function snapshotToDatabaseSchema(snapshot) {
+    const tables = [];
+    for (const [, tableSnapshot] of Object.entries(snapshot.tables)) {
+        tables.push(snapshotToTable(tableSnapshot));
+    }
+    return {
+        tables,
+        enums: [],
+        domains: [],
+        compositeTypes: [],
+        sequences: [],
+        functions: [],
+        triggers: [],
+        policies: [],
+        partitions: [],
+        foreignServers: [],
+        foreignTables: [],
+        extensions: snapshot.extensions,
+    };
+}
+function snapshotToTable(snapshot) {
+    const columns = Object.values(snapshot.columns);
+    const indexes = Object.values(snapshot.indexes);
+    const constraints = Object.values(snapshot.constraints).map(c => ({
+        ...c,
+        type: c.type,
+    }));
+    return {
+        name: snapshot.name,
+        schema: snapshot.schema,
+        columns,
+        indexes,
+        constraints,
+        rowCount: 0,
+        isPartitioned: snapshot.isPartitioned || false,
+        partitionType: snapshot.partitionType,
+        partitionKey: snapshot.partitionKey,
+    };
+}
+function createBackup(filePath, backupDir) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    const dir = backupDir || '.relq/backups';
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const fileName = path.basename(filePath);
+    const backupPath = path.join(dir, `${fileName}.${timestamp}.bak`);
+    fs.copyFileSync(filePath, backupPath);
+    return backupPath;
+}
+function listBackups(filePath, backupDir) {
+    const dir = backupDir || '.relq/backups';
+    if (!fs.existsSync(dir)) {
+        return [];
+    }
+    const fileName = path.basename(filePath);
+    const files = fs.readdirSync(dir);
+    return files
+        .filter(f => f.startsWith(fileName) && f.endsWith('.bak'))
+        .map(f => path.join(dir, f))
+        .sort()
+        .reverse();
+}
+function restoreBackup(backupPath, targetPath) {
+    if (!fs.existsSync(backupPath)) {
+        throw new Error(`Backup not found: ${backupPath}`);
+    }
+    fs.copyFileSync(backupPath, targetPath);
+}
+function addMigrationToSnapshot(snapshotPath, migrationName) {
+    const snapshot = loadSnapshot(snapshotPath);
+    if (!snapshot) {
+        console.warn('No snapshot found, creating new one');
+        return;
+    }
+    if (!snapshot.appliedMigrations.includes(migrationName)) {
+        snapshot.appliedMigrations.push(migrationName);
+        fs.writeFileSync(snapshotPath || DEFAULT_SNAPSHOT_PATH, JSON.stringify(snapshot, null, 2), 'utf-8');
+    }
+}
+function getAppliedMigrations(snapshotPath) {
+    const snapshot = loadSnapshot(snapshotPath);
+    return snapshot?.appliedMigrations || [];
+}

package/dist/cjs/cli/utils/spinner.cjs

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = void 0;
+exports.createSpinner = createSpinner;
+exports.progressBar = progressBar;
+exports.formatBytes = formatBytes;
+exports.formatDuration = formatDuration;
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SPINNER_INTERVAL = 80;
+function createSpinner() {
+    let intervalId = null;
+    let frameIndex = 0;
+    let currentMessage = '';
+    let isSpinning = false;
+    const clearLine = () => {
+        process.stdout.write('\r\x1b[K');
+    };
+    const render = () => {
+        if (!isSpinning)
+            return;
+        clearLine();
+        const frame = SPINNER_FRAMES[frameIndex];
+        process.stdout.write(`\x1b[36m${frame}\x1b[0m ${currentMessage}`);
+        frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+    };
+    return {
+        start(message) {
+            if (isSpinning)
+                this.stop();
+            currentMessage = message;
+            isSpinning = true;
+            frameIndex = 0;
+            intervalId = setInterval(render, SPINNER_INTERVAL);
+            render();
+        },
+        update(message) {
+            currentMessage = message;
+        },
+        succeed(message) {
+            this.stop();
+            console.log(`\x1b[32m✓\x1b[0m ${message || currentMessage}`);
+        },
+        fail(message) {
+            this.stop();
+            console.log(`\x1b[31m✗\x1b[0m ${message || currentMessage}`);
+        },
+        info(message) {
+            this.stop();
+            console.log(`\x1b[34mℹ\x1b[0m ${message || currentMessage}`);
+        },
+        warn(message) {
+            this.stop();
+            console.log(`\x1b[33m⚠\x1b[0m ${message || currentMessage}`);
+        },
+        stop() {
+            if (intervalId) {
+                clearInterval(intervalId);
+                intervalId = null;
+            }
+            if (isSpinning) {
+                clearLine();
+                isSpinning = false;
+            }
+        }
+    };
+}
+exports.colors = {
+    reset: '\x1b[0m',
+    bold: (text) => `\x1b[1m${text}\x1b[0m`,
+    dim: (text) => `\x1b[2m${text}\x1b[0m`,
+    red: (text) => `\x1b[31m${text}\x1b[0m`,
+    green: (text) => `\x1b[32m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[33m${text}\x1b[0m`,
+    blue: (text) => `\x1b[34m${text}\x1b[0m`,
+    magenta: (text) => `\x1b[35m${text}\x1b[0m`,
+    cyan: (text) => `\x1b[36m${text}\x1b[0m`,
+    gray: (text) => `\x1b[90m${text}\x1b[0m`,
+    white: (text) => `\x1b[37m${text}\x1b[0m`,
+    success: (text) => `\x1b[32m${text}\x1b[0m`,
+    error: (text) => `\x1b[31m${text}\x1b[0m`,
+    warning: (text) => `\x1b[33m${text}\x1b[0m`,
+    info: (text) => `\x1b[34m${text}\x1b[0m`,
+    muted: (text) => `\x1b[90m${text}\x1b[0m`,
+};
+function progressBar(current, total, width = 30) {
+    const percentage = Math.min(100, Math.round((current / total) * 100));
+    const filled = Math.round((percentage / 100) * width);
+    const empty = width - filled;
+    const bar = '█'.repeat(filled) + '░'.repeat(empty);
+    return `\x1b[36m${bar}\x1b[0m ${percentage}%`;
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.round((ms % 60000) / 1000);
+    return `${minutes}m ${seconds}s`;
+}