relq 1.0.0

package/dist/cjs/cli/utils/schema-hash.cjs

@@ -0,0 +1,108 @@
+"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.normalizeSchema = normalizeSchema;
+exports.generateSchemaHash = generateSchemaHash;
+exports.generateShortHash = generateShortHash;
+exports.schemasMatch = schemasMatch;
+const crypto = __importStar(require("crypto"));
+function normalizeSchema(schema) {
+    const userTables = schema.tables.filter(t => !t.name.startsWith('_relq') &&
+        !t.name.startsWith('relq_'));
+    const tables = userTables
+        .map(normalizeTable)
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const extensions = [...schema.extensions].sort();
+    return { tables, extensions };
+}
+function normalizeTable(table) {
+    const columns = table.columns
+        .map(normalizeColumn)
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const indexes = (table.indexes || [])
+        .map(normalizeIndex)
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const constraints = (table.constraints || [])
+        .map(normalizeConstraint)
+        .sort((a, b) => a.name.localeCompare(b.name));
+    return {
+        name: table.name,
+        columns,
+        indexes,
+        constraints,
+        partitionType: table.partitionType,
+        partitionKey: table.partitionKey?.sort(),
+    };
+}
+function normalizeColumn(col) {
+    return {
+        name: col.name,
+        type: col.dataType.toUpperCase(),
+        nullable: col.isNullable,
+        defaultValue: col.defaultValue || undefined,
+        isPrimaryKey: col.isPrimaryKey,
+        isUnique: col.isUnique,
+        length: col.maxLength || undefined,
+    };
+}
+function normalizeIndex(idx) {
+    return {
+        name: idx.name,
+        columns: [...idx.columns].sort(),
+        unique: idx.isUnique,
+        type: idx.type?.toUpperCase(),
+    };
+}
+function normalizeConstraint(con) {
+    return {
+        name: con.name,
+        type: con.type.toUpperCase(),
+        definition: con.definition || undefined,
+    };
+}
+function generateSchemaHash(schema) {
+    const normalized = normalizeSchema(schema);
+    const json = JSON.stringify(normalized, null, 0);
+    return crypto
+        .createHash('sha1')
+        .update(json, 'utf8')
+        .digest('hex');
+}
+function generateShortHash(schema) {
+    return generateSchemaHash(schema).substring(0, 7);
+}
+function schemasMatch(schema1, schema2) {
+    return generateSchemaHash(schema1) === generateSchemaHash(schema2);
+}

package/dist/cjs/cli/utils/schema-introspect.cjs

@@ -0,0 +1,455 @@
+"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.introspectDatabase = introspectDatabase;
+exports.tableHasData = tableHasData;
+async function introspectDatabase(connection, onProgress, options) {
+    const { includeFunctions = false, includeTriggers = false } = options || {};
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/pg.js")));
+    onProgress?.('connecting', connection.database);
+    const pool = new Pool({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: connection.database,
+        user: connection.user,
+        password: connection.password,
+        connectionString: connection.url,
+        ssl: connection.ssl,
+    });
+    try {
+        onProgress?.('fetching_tables');
+        const tablesResult = await pool.query(`
+            SELECT 
+                t.table_name,
+                t.table_schema,
+                (SELECT reltuples::bigint FROM pg_class WHERE relname = t.table_name) as row_count
+            FROM information_schema.tables t
+            WHERE t.table_schema = 'public'
+                AND t.table_type = 'BASE TABLE'
+            ORDER BY t.table_name;
+        `);
+        const tables = [];
+        const partitionNamesResult = await pool.query(`
+            SELECT c.relname as name
+            FROM pg_class c
+            JOIN pg_namespace n ON c.relnamespace = n.oid
+            WHERE n.nspname = 'public' AND c.relispartition = true;
+        `);
+        const partitionTableNames = new Set(partitionNamesResult.rows.map((r) => r.name));
+        const nonPartitionTables = tablesResult.rows.filter((r) => !partitionTableNames.has(r.table_name) && !r.table_name.startsWith('_relq'));
+        const totalTables = nonPartitionTables.length;
+        let tableIndex = 0;
+        for (let i = 0; i < tablesResult.rows.length; i++) {
+            const row = tablesResult.rows[i];
+            const tableName = row.table_name;
+            const tableSchema = row.table_schema;
+            const rowCount = parseInt(row.row_count) || 0;
+            const isPartition = partitionTableNames.has(tableName);
+            const isInternal = tableName.startsWith('_relq');
+            if (!isPartition && !isInternal) {
+                tableIndex++;
+                onProgress?.('parsing_table', `${tableName} (${tableIndex}/${totalTables})`);
+            }
+            const columnsResult = await pool.query(`
+                SELECT 
+                    c.column_name,
+                    c.data_type,
+                    c.udt_name,
+                    c.is_nullable,
+                    c.column_default,
+                    c.character_maximum_length,
+                    c.numeric_precision,
+                    c.numeric_scale,
+                    COALESCE(pk.is_pk, false) as is_primary_key,
+                    COALESCE(uq.is_unique, false) as is_unique,
+                    fk.foreign_table,
+                    fk.foreign_column,
+                    col_description(pgc.oid, c.ordinal_position::int) as column_comment
+                FROM information_schema.columns c
+                JOIN pg_class pgc ON pgc.relname = c.table_name
+                JOIN pg_namespace pgn ON pgn.oid = pgc.relnamespace AND pgn.nspname = c.table_schema
+                LEFT JOIN (
+                    SELECT kcu.column_name, true as is_pk
+                    FROM information_schema.table_constraints tc
+                    JOIN information_schema.key_column_usage kcu 
+                        ON tc.constraint_name = kcu.constraint_name
+                    WHERE tc.table_name = $1 AND tc.constraint_type = 'PRIMARY KEY'
+                ) pk ON pk.column_name = c.column_name
+                LEFT JOIN (
+                    SELECT kcu.column_name, true as is_unique
+                    FROM information_schema.table_constraints tc
+                    JOIN information_schema.key_column_usage kcu 
+                        ON tc.constraint_name = kcu.constraint_name
+                    WHERE tc.table_name = $1 AND tc.constraint_type = 'UNIQUE'
+                ) uq ON uq.column_name = c.column_name
+                LEFT JOIN (
+                    SELECT 
+                        kcu.column_name,
+                        ccu.table_name as foreign_table,
+                        ccu.column_name as foreign_column
+                    FROM information_schema.table_constraints tc
+                    JOIN information_schema.key_column_usage kcu 
+                        ON tc.constraint_name = kcu.constraint_name
+                    JOIN information_schema.constraint_column_usage ccu 
+                        ON tc.constraint_name = ccu.constraint_name
+                    WHERE tc.table_name = $1 AND tc.constraint_type = 'FOREIGN KEY'
+                ) fk ON fk.column_name = c.column_name
+                WHERE c.table_name = $1 AND c.table_schema = $2
+                ORDER BY c.ordinal_position;
+            `, [tableName, tableSchema]);
+            const columns = columnsResult.rows.map(col => ({
+                name: col.column_name,
+                dataType: col.udt_name || col.data_type,
+                isNullable: col.is_nullable === 'YES',
+                defaultValue: col.column_default,
+                isPrimaryKey: col.is_primary_key,
+                isUnique: col.is_unique,
+                maxLength: col.character_maximum_length,
+                precision: col.numeric_precision,
+                scale: col.numeric_scale,
+                references: col.foreign_table ? {
+                    table: col.foreign_table,
+                    column: col.foreign_column,
+                } : null,
+                comment: col.column_comment || undefined,
+            }));
+            const indexesResult = await pool.query(`
+                SELECT 
+                    i.relname as index_name,
+                    array_agg(a.attname ORDER BY k.n) as columns,
+                    ix.indisunique as is_unique,
+                    ix.indisprimary as is_primary,
+                    am.amname as index_type
+                FROM pg_index ix
+                JOIN pg_class t ON t.oid = ix.indrelid
+                JOIN pg_class i ON i.oid = ix.indexrelid
+                JOIN pg_am am ON am.oid = i.relam
+                JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, n) ON true
+                JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+                WHERE t.relname = $1
+                GROUP BY i.relname, ix.indisunique, ix.indisprimary, am.amname
+                ORDER BY i.relname;
+            `, [tableName]);
+            const indexes = indexesResult.rows.map(idx => ({
+                name: idx.index_name,
+                columns: idx.columns,
+                isUnique: idx.is_unique,
+                isPrimary: idx.is_primary,
+                type: idx.index_type,
+            }));
+            const constraintsResult = await pool.query(`
+                SELECT 
+                    con.conname as name,
+                    CASE con.contype 
+                        WHEN 'p' THEN 'PRIMARY KEY'
+                        WHEN 'f' THEN 'FOREIGN KEY'
+                        WHEN 'u' THEN 'UNIQUE'
+                        WHEN 'c' THEN 'CHECK'
+                        WHEN 'x' THEN 'EXCLUDE'
+                    END as type,
+                    array_agg(a.attname ORDER BY u.attposition) as columns,
+                    pg_get_constraintdef(con.oid) as definition,
+                    conf.relname as referenced_table
+                FROM pg_constraint con
+                JOIN pg_class c ON c.oid = con.conrelid
+                JOIN pg_namespace n ON n.oid = c.relnamespace
+                LEFT JOIN pg_class conf ON conf.oid = con.confrelid
+                LEFT JOIN unnest(con.conkey) WITH ORDINALITY u(attnum, attposition) ON true
+                LEFT JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = u.attnum
+                WHERE c.relname = $1 AND n.nspname = 'public'
+                GROUP BY con.oid, con.conname, con.contype, conf.relname
+                ORDER BY con.conname;
+            `, [tableName]);
+            const constraints = constraintsResult.rows.map(c => ({
+                name: c.name,
+                type: c.type,
+                columns: c.columns || [],
+                definition: c.definition || '',
+                referencedTable: c.referenced_table,
+            }));
+            const partitionCheckResult = await pool.query(`
+                SELECT 
+                    c.relkind = 'p' as is_partitioned,
+                    CASE pt.partstrat 
+                        WHEN 'r' THEN 'RANGE'
+                        WHEN 'l' THEN 'LIST'
+                        WHEN 'h' THEN 'HASH'
+                    END as partition_type,
+                    array_agg(a.attname) as partition_key
+                FROM pg_class c
+                JOIN pg_namespace n ON n.oid = c.relnamespace
+                LEFT JOIN pg_partitioned_table pt ON pt.partrelid = c.oid
+                LEFT JOIN unnest(pt.partattrs) WITH ORDINALITY pk(attnum, ord) ON true
+                LEFT JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = pk.attnum
+                WHERE c.relname = $1 AND n.nspname = 'public'
+                GROUP BY c.relkind, pt.partstrat;
+            `, [tableName]);
+            const partitionInfo = partitionCheckResult.rows[0] || {};
+            let partitionKey;
+            if (partitionInfo.partition_key) {
+                partitionKey = Array.isArray(partitionInfo.partition_key)
+                    ? partitionInfo.partition_key.filter(Boolean)
+                    : typeof partitionInfo.partition_key === 'string'
+                        ? [partitionInfo.partition_key]
+                        : undefined;
+            }
+            tables.push({
+                name: tableName,
+                schema: tableSchema,
+                columns,
+                indexes,
+                constraints,
+                rowCount,
+                isPartitioned: partitionInfo.is_partitioned || false,
+                partitionType: partitionInfo.partition_type,
+                partitionKey,
+            });
+        }
+        onProgress?.('fetching_extensions');
+        const extensionsResult = await pool.query(`
+            SELECT extname FROM pg_extension WHERE extname != 'plpgsql';
+        `);
+        const extensions = extensionsResult.rows.map(r => r.extname);
+        let functions = [];
+        if (includeFunctions) {
+            onProgress?.('fetching_functions');
+            const functionsResult = await pool.query(`
+                SELECT 
+                    p.proname as name,
+                    n.nspname as schema,
+                    pg_get_function_result(p.oid) as return_type,
+                    pg_get_function_arguments(p.oid) as arg_types,
+                    l.lanname as language,
+                    pg_get_functiondef(p.oid) as definition,
+                    p.prokind = 'a' as is_aggregate,
+                    p.provolatile as volatility
+                FROM pg_proc p
+                JOIN pg_namespace n ON p.pronamespace = n.oid
+                JOIN pg_language l ON p.prolang = l.oid
+                WHERE n.nspname = 'public'
+                    AND p.prokind IN ('f', 'a')
+                ORDER BY p.proname;
+            `);
+            functions = functionsResult.rows.map(f => ({
+                name: f.name,
+                schema: f.schema,
+                returnType: f.return_type,
+                argTypes: f.arg_types ? f.arg_types.split(', ') : [],
+                language: f.language,
+                definition: f.definition || '',
+                isAggregate: f.is_aggregate || false,
+                volatility: f.volatility === 'i' ? 'IMMUTABLE' : f.volatility === 's' ? 'STABLE' : 'VOLATILE',
+            }));
+        }
+        let triggers = [];
+        if (includeTriggers) {
+            const triggersResult = await pool.query(`
+                SELECT 
+                    t.tgname as name,
+                    c.relname as table_name,
+                    CASE 
+                        WHEN t.tgtype & 2 > 0 THEN 'BEFORE'
+                        WHEN t.tgtype & 64 > 0 THEN 'INSTEAD OF'
+                        ELSE 'AFTER'
+                    END as timing,
+                    CASE 
+                        WHEN t.tgtype & 4 > 0 THEN 'INSERT'
+                        WHEN t.tgtype & 8 > 0 THEN 'DELETE'
+                        WHEN t.tgtype & 16 > 0 THEN 'UPDATE'
+                        ELSE 'UNKNOWN'
+                    END as event,
+                    p.proname as function_name,
+                    pg_get_triggerdef(t.oid) as definition,
+                    t.tgenabled != 'D' as is_enabled
+                FROM pg_trigger t
+                JOIN pg_class c ON t.tgrelid = c.oid
+                JOIN pg_namespace n ON c.relnamespace = n.oid
+                JOIN pg_proc p ON t.tgfoid = p.oid
+                WHERE n.nspname = 'public'
+                    AND NOT t.tgisinternal
+                ORDER BY c.relname, t.tgname;
+            `);
+            triggers = triggersResult.rows.map(t => ({
+                name: t.name,
+                tableName: t.table_name,
+                timing: t.timing,
+                event: t.event,
+                functionName: t.function_name,
+                definition: t.definition || '',
+                isEnabled: t.is_enabled,
+            }));
+        }
+        const policiesResult = await pool.query(`
+            SELECT 
+                pol.polname as name,
+                c.relname as table_name,
+                CASE pol.polcmd 
+                    WHEN '*' THEN 'ALL'
+                    WHEN 'r' THEN 'SELECT'
+                    WHEN 'a' THEN 'INSERT'
+                    WHEN 'w' THEN 'UPDATE'
+                    WHEN 'd' THEN 'DELETE'
+                END as command,
+                array_agg(r.rolname) as roles,
+                pg_get_expr(pol.polqual, pol.polrelid) as using_expr,
+                pg_get_expr(pol.polwithcheck, pol.polrelid) as with_check
+            FROM pg_policy pol
+            JOIN pg_class c ON pol.polrelid = c.oid
+            JOIN pg_namespace n ON c.relnamespace = n.oid
+            LEFT JOIN unnest(pol.polroles) WITH ORDINALITY pr(oid, ord) ON true
+            LEFT JOIN pg_roles r ON r.oid = pr.oid
+            WHERE n.nspname = 'public'
+            GROUP BY pol.polname, c.relname, pol.polcmd, pol.polqual, pol.polwithcheck, pol.polrelid
+            ORDER BY c.relname, pol.polname;
+        `);
+        const policies = policiesResult.rows.map(p => ({
+            name: p.name,
+            tableName: p.table_name,
+            command: p.command,
+            roles: p.roles?.filter(Boolean) || [],
+            using: p.using_expr,
+            withCheck: p.with_check,
+        }));
+        const partitionsResult = await pool.query(`
+            SELECT 
+                c.relname as name,
+                parent.relname as parent_table,
+                CASE pt.partstrat 
+                    WHEN 'r' THEN 'RANGE'
+                    WHEN 'l' THEN 'LIST'
+                    WHEN 'h' THEN 'HASH'
+                END as partition_type,
+                pg_get_expr(c.relpartbound, c.oid) as partition_bound
+            FROM pg_class c
+            JOIN pg_inherits i ON c.oid = i.inhrelid
+            JOIN pg_class parent ON parent.oid = i.inhparent
+            JOIN pg_namespace n ON c.relnamespace = n.oid
+            LEFT JOIN pg_partitioned_table pt ON pt.partrelid = parent.oid
+            WHERE n.nspname = 'public'
+                AND c.relispartition
+            ORDER BY parent.relname, c.relname;
+        `);
+        const partitions = partitionsResult.rows.map(p => ({
+            name: p.name,
+            parentTable: p.parent_table,
+            partitionType: p.partition_type || 'RANGE',
+            partitionKey: [],
+            partitionBound: p.partition_bound || '',
+        }));
+        const foreignServersResult = await pool.query(`
+            SELECT 
+                s.srvname as name,
+                f.fdwname as foreign_data_wrapper,
+                s.srvoptions as options
+            FROM pg_foreign_server s
+            JOIN pg_foreign_data_wrapper f ON f.oid = s.srvfdw
+            ORDER BY s.srvname;
+        `);
+        const foreignServers = foreignServersResult.rows.map(s => ({
+            name: s.name,
+            foreignDataWrapper: s.foreign_data_wrapper,
+            options: parseOptions(s.options),
+        }));
+        const foreignTablesResult = await pool.query(`
+            SELECT 
+                c.relname as name,
+                n.nspname as schema,
+                s.srvname as server_name,
+                ft.ftoptions as options
+            FROM pg_foreign_table ft
+            JOIN pg_class c ON c.oid = ft.ftrelid
+            JOIN pg_namespace n ON n.oid = c.relnamespace
+            JOIN pg_foreign_server s ON s.oid = ft.ftserver
+            WHERE n.nspname = 'public'
+            ORDER BY c.relname;
+        `);
+        const foreignTables = foreignTablesResult.rows.map(t => ({
+            name: t.name,
+            schema: t.schema,
+            serverName: t.server_name,
+            columns: [],
+            options: parseOptions(t.options),
+        }));
+        return {
+            tables,
+            enums: [],
+            domains: [],
+            compositeTypes: [],
+            sequences: [],
+            functions,
+            triggers,
+            policies,
+            partitions,
+            foreignServers,
+            foreignTables,
+            extensions
+        };
+    }
+    finally {
+        await pool.end();
+    }
+}
+function parseOptions(options) {
+    if (!options)
+        return {};
+    const result = {};
+    for (const opt of options) {
+        const [key, value] = opt.split('=');
+        if (key)
+            result[key] = value || '';
+    }
+    return result;
+}
+async function tableHasData(connection, tableName) {
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/pg.js")));
+    const pool = new Pool({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: connection.database,
+        user: connection.user,
+        password: connection.password,
+        connectionString: connection.url,
+    });
+    try {
+        const result = await pool.query(`SELECT EXISTS(SELECT 1 FROM "${tableName}" LIMIT 1) as has_data`);
+        return result.rows[0]?.has_data || false;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await pool.end();
+    }
+}