admindb 2.5.0 → 2.6.2

package/dist/core/transfer/dialect-mapper.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.categorizeType = categorizeType;
+exports.mapColumnToDialect = mapColumnToDialect;
+exports.normalizeTableInfo = normalizeTableInfo;
+exports.convertValueForDialect = convertValueForDialect;
+exports.mapDefaultValueForDialect = mapDefaultValueForDialect;
+exports.generateCreateTableForDialect = generateCreateTableForDialect;
+function categorizeType(rawType) {
+    const t = (rawType || '').toLowerCase().trim();
+    if (t.includes('int') || t.includes('serial') || t === 'smallint' || t === 'bigint')
+        return 'integer';
+    if (t.includes('bool'))
+        return 'boolean';
+    if (t.includes('float') || t.includes('double') || t.includes('real') || t.includes('numeric') || t.includes('decimal'))
+        return 'real';
+    if (t.includes('blob') || t.includes('bytea') || t.includes('binary'))
+        return 'blob';
+    if (t.includes('date') || t.includes('time'))
+        return 'datetime';
+    if (t.includes('json'))
+        return 'json';
+    return 'text';
+}
+function mapColumnToDialect(col, targetDialect) {
+    if (targetDialect === 'postgres') {
+        if (col.autoIncrement) {
+            return col.type.toLowerCase().includes('big') ? 'BIGSERIAL' : 'SERIAL';
+        }
+        switch (col.genericType) {
+            case 'integer':
+                return col.type.toLowerCase().includes('big') ? 'BIGINT' : 'INTEGER';
+            case 'boolean':
+                return 'BOOLEAN';
+            case 'real':
+                return 'DOUBLE PRECISION';
+            case 'blob':
+                return 'BYTEA';
+            case 'datetime':
+                return 'TIMESTAMP WITH TIME ZONE';
+            case 'json':
+                return 'JSONB';
+            case 'text':
+            default:
+                return 'TEXT';
+        }
+    }
+    if (col.primaryKey && col.autoIncrement) {
+        return 'INTEGER PRIMARY KEY AUTOINCREMENT';
+    }
+    switch (col.genericType) {
+        case 'integer':
+            return 'INTEGER';
+        case 'boolean':
+            return 'INTEGER';
+        case 'real':
+            return 'REAL';
+        case 'blob':
+            return 'BLOB';
+        case 'datetime':
+        case 'json':
+        case 'text':
+        default:
+            return 'TEXT';
+    }
+}
+function normalizeTableInfo(info, dialect) {
+    const uniqueCols = new Set();
+    const pks = new Set(info.primaryKey || []);
+    for (const idx of info.indexes || []) {
+        const cols = Array.isArray(idx.columns) ? idx.columns.filter(Boolean) : [];
+        if (idx.unique && cols.length === 1 && !pks.has(cols[0])) {
+            uniqueCols.add(cols[0]);
+        }
+    }
+    const columns = (info.columns || []).map((col) => {
+        const isPk = col.pk > 0 || pks.has(col.name);
+        const rawType = (col.type || '').toUpperCase();
+        const genericType = categorizeType(rawType);
+        const isAutoIncrement = (isPk && genericType === 'integer' && dialect === 'sqlite' && Boolean(info.sql?.toLowerCase().includes('autoincrement'))) ||
+            rawType.includes('SERIAL') ||
+            Boolean(col.dflt_value?.includes('nextval(')) ||
+            Boolean(info.sql?.toLowerCase().includes('generated always as identity'));
+        const fk = (info.foreignKeys || []).find((f) => f.from === col.name);
+        return {
+            name: col.name,
+            type: col.type,
+            genericType,
+            primaryKey: isPk,
+            autoIncrement: isAutoIncrement,
+            notNull: Boolean(col.notnull),
+            defaultValue: col.dflt_value,
+            unique: uniqueCols.has(col.name),
+            foreignKey: fk
+                ? {
+                    table: fk.table,
+                    column: fk.to || '',
+                    onDelete: fk.on_delete,
+                    onUpdate: fk.on_update,
+                }
+                : null,
+        };
+    });
+    const indexes = (info.indexes || [])
+        .filter((ix) => !ix.name?.startsWith('sqlite_') && ix.origin !== 'pk' && (!ix.name?.endsWith('_pkey') || !ix.unique))
+        .map((ix) => {
+        let cols = [];
+        if (Array.isArray(ix.columns)) {
+            cols = ix.columns.filter((c) => typeof c === 'string' && c.trim().length > 0);
+        }
+        else if (typeof ix.columns === 'string') {
+            cols = [ix.columns];
+        }
+        return {
+            name: ix.name || `idx_${info.table}_${cols.join('_') || 'col'}`,
+            unique: Boolean(ix.unique),
+            columns: cols,
+        };
+    })
+        .filter((ix) => ix.columns.length > 0);
+    return {
+        name: info.table,
+        columns,
+        primaryKeys: info.primaryKey || [],
+        foreignKeys: info.foreignKeys || [],
+        indexes,
+    };
+}
+function convertValueForDialect(value, genericType, targetDialect) {
+    if (value === null || value === undefined)
+        return null;
+    if (targetDialect === 'postgres') {
+        if (genericType === 'boolean') {
+            if (typeof value === 'boolean')
+                return value;
+            if (typeof value === 'number')
+                return value !== 0;
+            if (typeof value === 'string')
+                return value === '1' || value.toLowerCase() === 'true';
+            return Boolean(value);
+        }
+        if (genericType === 'json') {
+            if (typeof value === 'object')
+                return JSON.stringify(value);
+            return String(value);
+        }
+        if (genericType === 'blob') {
+            if (Buffer.isBuffer(value))
+                return value;
+            if (value instanceof Uint8Array)
+                return Buffer.from(value);
+            return Buffer.from(String(value));
+        }
+        return value;
+    }
+    if (genericType === 'boolean') {
+        if (typeof value === 'boolean')
+            return value ? 1 : 0;
+        if (typeof value === 'number')
+            return value ? 1 : 0;
+        if (typeof value === 'string')
+            return value === 'true' || value === '1' ? 1 : 0;
+        return value ? 1 : 0;
+    }
+    if (genericType === 'json') {
+        if (typeof value === 'object')
+            return JSON.stringify(value);
+        return String(value);
+    }
+    if (genericType === 'datetime') {
+        if (value instanceof Date)
+            return value.toISOString();
+        return String(value);
+    }
+    if (genericType === 'blob') {
+        if (Buffer.isBuffer(value))
+            return value;
+        if (value instanceof Uint8Array)
+            return Buffer.from(value);
+    }
+    return value;
+}
+function mapDefaultValueForDialect(defaultValue, genericType, targetDialect) {
+    if (defaultValue === null || defaultValue === undefined)
+        return null;
+    let def = String(defaultValue).trim();
+    if (!def)
+        return null;
+    if (targetDialect === 'sqlite') {
+        def = def.replace(/::[a-zA-Z0-9_ "]+(\[\])?/g, '').trim();
+        if (/nextval\(.*?\)/i.test(def)) {
+            return null;
+        }
+        if (/^(now\(\)|current_timestamp|current_timestamp\(\)|clock_timestamp\(\)|statement_timestamp\(\)|transaction_timestamp\(\)|\('now'.*?\))$/i.test(def)) {
+            return 'CURRENT_TIMESTAMP';
+        }
+        if (/^(gen_random_uuid\(\)|uuid_generate_v\d\(\)|random\(\)|uuid\(\))$/i.test(def)) {
+            return null;
+        }
+        if (/^true$/i.test(def))
+            return '1';
+        if (/^false$/i.test(def))
+            return '0';
+        while (def.startsWith('(') && def.endsWith(')')) {
+            const inner = def.slice(1, -1).trim();
+            let depth = 0;
+            let okToStrip = true;
+            for (let i = 0; i < inner.length; i++) {
+                if (inner[i] === '(')
+                    depth++;
+                else if (inner[i] === ')') {
+                    depth--;
+                    if (depth < 0) {
+                        okToStrip = false;
+                        break;
+                    }
+                }
+            }
+            if (okToStrip && depth === 0) {
+                def = inner;
+            }
+            else {
+                break;
+            }
+        }
+        if (/^(now\(\)|current_timestamp|current_timestamp\(\)|clock_timestamp\(\)|\('now'.*?\))$/i.test(def)) {
+            return 'CURRENT_TIMESTAMP';
+        }
+        if (/^true$/i.test(def))
+            return '1';
+        if (/^false$/i.test(def))
+            return '0';
+        if (/nextval\(.*?\)/i.test(def))
+            return null;
+        if (/^(gen_random_uuid\(\)|uuid_generate_v\d\(\))$/i.test(def))
+            return null;
+        if (/^[a-zA-Z0-9_]+\(.*\)$/.test(def) && !/^(current_timestamp|current_date|current_time)$/i.test(def)) {
+            return null;
+        }
+        return def;
+    }
+    if (targetDialect === 'postgres') {
+        if (genericType === 'boolean') {
+            if (def === '1' || def === "'1'")
+                return 'TRUE';
+            if (def === '0' || def === "'0'")
+                return 'FALSE';
+        }
+        if (/nextval\(.*?\)/i.test(def)) {
+            return null;
+        }
+        return def;
+    }
+    return def;
+}
+function generateCreateTableForDialect(table, targetDialect) {
+    const lines = [];
+    const q = targetDialect === 'postgres' ? (s) => `"${s}"` : (s) => `\`${s}\``;
+    const singleAutoPk = targetDialect === 'sqlite' &&
+        table.columns.filter((c) => c.primaryKey).length === 1 &&
+        table.columns.find((c) => c.primaryKey)?.autoIncrement;
+    for (const col of table.columns) {
+        let colSql = `${q(col.name)} ${mapColumnToDialect(col, targetDialect)}`;
+        const isPgSerial = targetDialect === 'postgres' && col.autoIncrement;
+        if (singleAutoPk && col.primaryKey) {
+        }
+        else if (isPgSerial) {
+            if (col.unique && !col.primaryKey)
+                colSql += ' UNIQUE';
+        }
+        else {
+            if (col.notNull)
+                colSql += ' NOT NULL';
+            if (col.unique && !col.primaryKey)
+                colSql += ' UNIQUE';
+            const mappedDefault = mapDefaultValueForDialect(col.defaultValue, col.genericType, targetDialect);
+            if (mappedDefault !== null && mappedDefault !== undefined) {
+                colSql += ` DEFAULT ${mappedDefault}`;
+            }
+        }
+        lines.push(colSql);
+    }
+    if (!singleAutoPk && table.primaryKeys.length > 0) {
+        const validPks = table.primaryKeys.filter((pk) => table.columns.some((c) => c.name === pk));
+        if (validPks.length > 0) {
+            lines.push(`PRIMARY KEY (${validPks.map(q).join(', ')})`);
+        }
+    }
+    if (targetDialect === 'sqlite') {
+        for (const fk of table.foreignKeys) {
+            if (fk.from && fk.to && fk.table) {
+                const targetTable = fk.table.includes('.') ? fk.table.split('.').pop() : fk.table;
+                let fkSql = `FOREIGN KEY (${q(fk.from)}) REFERENCES ${q(targetTable)} (${q(fk.to)})`;
+                if (fk.on_delete && fk.on_delete !== 'NO ACTION')
+                    fkSql += ` ON DELETE ${fk.on_delete}`;
+                if (fk.on_update && fk.on_update !== 'NO ACTION')
+                    fkSql += ` ON UPDATE ${fk.on_update}`;
+                lines.push(fkSql);
+            }
+        }
+    }
+    return `CREATE TABLE ${q(table.name)} (\n  ${lines.join(',\n  ')}\n);`;
+}

package/dist/core/transfer/masking.d.ts

@@ -0,0 +1 @@
+export interface MaskingRule{columnPattern:string;strategy:'email'|'password'|'phone'|'name'|'redact'|'hash';customValue?:string;}export declare const DEFAULT_MASKING_RULES:MaskingRule[];export declare function maskRowData(row:Record<string,unknown>,rules?:MaskingRule[],rowIndex?:number):Record<string,unknown>;

package/dist/core/transfer/masking.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MASKING_RULES = void 0;
+exports.maskRowData = maskRowData;
+exports.DEFAULT_MASKING_RULES = [
+    { columnPattern: 'email|e_mail|mail', strategy: 'email' },
+    { columnPattern: 'pass|password|passwd|pwd|secret|token|api_key|auth', strategy: 'password' },
+    { columnPattern: 'phone|mobile|cell|telephone', strategy: 'phone' },
+    { columnPattern: 'first_name|last_name|full_name|username|user_name', strategy: 'name' },
+];
+function maskRowData(row, rules = exports.DEFAULT_MASKING_RULES, rowIndex = 1) {
+    const masked = { ...row };
+    for (const [colName, val] of Object.entries(row)) {
+        if (val === null || val === undefined)
+            continue;
+        for (const rule of rules) {
+            const regex = new RegExp(rule.columnPattern, 'i');
+            if (regex.test(colName)) {
+                switch (rule.strategy) {
+                    case 'email':
+                        masked[colName] = `user${rowIndex}@masked.test`;
+                        break;
+                    case 'password':
+                        if (/token|secret|key|auth/i.test(colName) && !/pass|pwd/i.test(colName)) {
+                            masked[colName] = `masked_${rowIndex}_${Math.random().toString(36).substring(2, 10)}${Math.random().toString(36).substring(2, 10)}`;
+                        }
+                        else {
+                            masked[colName] = `$2b$10$maskedpwdhash${String(rowIndex).padStart(6, '0')}${Math.random().toString(36).substring(2, 14)}`;
+                        }
+                        break;
+                    case 'phone':
+                        masked[colName] = `+1555000${String(rowIndex).padStart(4, '0')}`;
+                        break;
+                    case 'name':
+                        masked[colName] = `Test User ${rowIndex}`;
+                        break;
+                    case 'redact':
+                        masked[colName] = `[REDACTED_${rowIndex}]`;
+                        break;
+                    case 'hash':
+                        masked[colName] = `hash_${rowIndex}_${Math.random().toString(36).substring(2, 8)}`;
+                        break;
+                }
+                break;
+            }
+        }
+    }
+    return masked;
+}

package/dist/core/transfer/sync-engine.d.ts

@@ -0,0 +1 @@
+import type {IDatabase} from '../../db/types';import{type MaskingRule} from './masking';export type SyncMode='full'|'schema_only'|'data_only_replace'|'data_only_upsert';export interface SyncOptions{tables?:string[];mode?:SyncMode;maskData?:boolean;maskRules?:MaskingRule[];batchSize?:number;dryRun?:boolean;}export interface SyncTableProgress{table:string;rowsCopied:number;totalRows:number;status:'pending'|'in_progress'|'completed'|'skipped'|'failed';error?:string;}export interface SyncResult{success:boolean;dryRun:boolean;sourceDbId:string;targetDbId:string;mode:SyncMode;tablesProcessed:SyncTableProgress[];totalRowsTransferred:number;executionTimeMs:number;error?:string;summary:string;}export declare function executeSync(sourceDb:IDatabase,sourceDbId:string,targetDb:IDatabase,targetDbId:string,options?:SyncOptions):Promise<SyncResult>;

package/dist/core/transfer/sync-engine.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeSync = executeSync;
+const dialect_mapper_1 = require("./dialect-mapper");
+const topological_sort_1 = require("./topological-sort");
+const masking_1 = require("./masking");
+async function executeSync(sourceDb, sourceDbId, targetDb, targetDbId, options = {}) {
+    const startTime = Date.now();
+    const mode = options.mode || 'full';
+    const batchSize = Math.max(50, options.batchSize || 500);
+    const dryRun = Boolean(options.dryRun);
+    const maskData = Boolean(options.maskData);
+    const sourceDialect = sourceDb.dialect === 'postgres' ? 'postgres' : 'sqlite';
+    const targetDialect = targetDb.dialect === 'postgres' ? 'postgres' : 'sqlite';
+    const srcTableListRes = await sourceDb.listTables();
+    if (!srcTableListRes.success)
+        throw new Error(srcTableListRes.error || 'Failed to list source tables');
+    let tablesToSync = (srcTableListRes.data || [])
+        .map((t) => t.name)
+        .filter((n) => !n.startsWith('sqlite_') && !n.startsWith('_admindb_'));
+    if (options.tables && options.tables.length > 0) {
+        const selected = new Set(options.tables);
+        tablesToSync = tablesToSync.filter((n) => selected.has(n));
+    }
+    const sourceTableInfos = [];
+    for (const name of tablesToSync) {
+        const infoRes = await sourceDb.getTableInfo(name);
+        if (infoRes.success && infoRes.data) {
+            sourceTableInfos.push(infoRes.data);
+        }
+    }
+    const deps = sourceTableInfos.map((i) => ({
+        name: i.table,
+        foreignKeys: i.foreignKeys || [],
+    }));
+    const insertionOrder = (0, topological_sort_1.sortTablesTopologically)(deps);
+    const deletionOrder = (0, topological_sort_1.sortTablesForDeletion)(deps);
+    const normalizedTables = new Map();
+    for (const info of sourceTableInfos) {
+        normalizedTables.set(info.table, (0, dialect_mapper_1.normalizeTableInfo)(info, sourceDialect));
+    }
+    const progressList = insertionOrder.map((name) => ({
+        table: name,
+        rowsCopied: 0,
+        totalRows: 0,
+        status: 'pending',
+    }));
+    if (dryRun) {
+        let totalEstimatedRows = 0;
+        for (const p of progressList) {
+            const countRes = await sourceDb.getRowCount(p.table);
+            p.totalRows = countRes.data || 0;
+            p.rowsCopied = mode === 'schema_only' ? 0 : p.totalRows;
+            p.status = 'completed';
+            totalEstimatedRows += p.rowsCopied;
+        }
+        return {
+            success: true,
+            dryRun: true,
+            sourceDbId,
+            targetDbId,
+            mode,
+            tablesProcessed: progressList,
+            totalRowsTransferred: totalEstimatedRows,
+            executionTimeMs: Date.now() - startTime,
+            summary: `Dry Run: Ready to sync ${progressList.length} tables (${totalEstimatedRows} estimated rows) from "${sourceDbId}" to "${targetDbId}".`,
+        };
+    }
+    let totalRowsTransferred = 0;
+    try {
+        if (targetDialect === 'sqlite') {
+            await targetDb.execResult('PRAGMA foreign_keys = OFF;');
+        }
+        else {
+            try {
+                await targetDb.execResult('SET CONSTRAINTS ALL DEFERRED;');
+            }
+            catch { }
+        }
+    }
+    catch { }
+    try {
+        if (mode === 'full') {
+            for (const tableName of deletionOrder) {
+                try {
+                    await targetDb.execResult(targetDialect === 'postgres'
+                        ? `DROP TABLE IF EXISTS "${tableName}" CASCADE;`
+                        : `DROP TABLE IF EXISTS \`${tableName}\`;`);
+                }
+                catch { }
+            }
+            for (const tableName of insertionOrder) {
+                const norm = normalizedTables.get(tableName);
+                if (!norm)
+                    continue;
+                const ddl = (0, dialect_mapper_1.generateCreateTableForDialect)(norm, targetDialect);
+                const createRes = await targetDb.execResult(ddl);
+                if (!createRes.success) {
+                    throw new Error(`Failed to create table "${tableName}": ${createRes.error}`);
+                }
+                for (const idx of norm.indexes || []) {
+                    if (idx.name?.startsWith('sqlite_'))
+                        continue;
+                    const colsArr = Array.isArray(idx?.columns) ? idx.columns.filter(Boolean) : [];
+                    if (colsArr.length === 0)
+                        continue;
+                    const uq = idx.unique ? 'UNIQUE ' : '';
+                    const q = targetDialect === 'postgres' ? (s) => `"${s}"` : (s) => `\`${s}\``;
+                    const cols = colsArr.map(q).join(', ');
+                    try {
+                        await targetDb.execResult(`CREATE ${uq}INDEX IF NOT EXISTS ${q(idx.name)} ON ${q(tableName)} (${cols});`);
+                    }
+                    catch { }
+                }
+            }
+        }
+        else if (mode === 'schema_only') {
+            for (const tableName of insertionOrder) {
+                const norm = normalizedTables.get(tableName);
+                if (!norm)
+                    continue;
+                const targetInfo = await targetDb.getTableInfo(tableName);
+                if (!targetInfo.success || !targetInfo.data || targetInfo.data.columns.length === 0) {
+                    const ddl = (0, dialect_mapper_1.generateCreateTableForDialect)(norm, targetDialect);
+                    const createRes = await targetDb.execResult(ddl);
+                    if (!createRes.success) {
+                        throw new Error(`Failed to create table "${tableName}": ${createRes.error}`);
+                    }
+                }
+            }
+        }
+        else if (mode === 'data_only_replace') {
+            for (const tableName of deletionOrder) {
+                try {
+                    await targetDb.execResult(targetDialect === 'postgres' ? `TRUNCATE TABLE "${tableName}" CASCADE;` : `DELETE FROM \`${tableName}\`;`);
+                }
+                catch { }
+            }
+        }
+        if (mode !== 'schema_only') {
+            for (const p of progressList) {
+                const tableName = p.table;
+                p.status = 'in_progress';
+                const norm = normalizedTables.get(tableName);
+                if (!norm)
+                    continue;
+                const countRes = await sourceDb.getRowCount(tableName);
+                p.totalRows = countRes.data || 0;
+                let offset = 0;
+                let tableRowsCopied = 0;
+                while (offset < p.totalRows || (offset === 0 && p.totalRows === 0)) {
+                    if (p.totalRows === 0)
+                        break;
+                    const rowsRes = await sourceDb.getRows(tableName, { page: Math.floor(offset / batchSize) + 1, limit: batchSize });
+                    const rows = rowsRes.data || [];
+                    if (rows.length === 0)
+                        break;
+                    const targetRows = [];
+                    for (let i = 0; i < rows.length; i++) {
+                        let row = rows[i];
+                        if (maskData) {
+                            row = (0, masking_1.maskRowData)(row, options.maskRules, offset + i + 1);
+                        }
+                        const fields = [];
+                        for (const col of norm.columns) {
+                            const rawVal = row[col.name];
+                            const convertedVal = (0, dialect_mapper_1.convertValueForDialect)(rawVal, col.genericType, targetDialect);
+                            fields.push({ column: col.name, value: convertedVal });
+                        }
+                        targetRows.push(fields);
+                    }
+                    const insertRes = await targetDb.insertRows(tableName, targetRows);
+                    if (!insertRes.success) {
+                        throw new Error(`Failed to insert batch into "${tableName}": ${insertRes.error}`);
+                    }
+                    tableRowsCopied += targetRows.length;
+                    offset += rows.length;
+                }
+                if (targetDialect === 'postgres') {
+                    for (const col of norm.columns) {
+                        if (col.primaryKey && col.autoIncrement) {
+                            try {
+                                await targetDb.all(`SELECT setval(pg_get_serial_sequence('"${tableName}"', '${col.name}'), COALESCE(MAX("${col.name}"), 1)) FROM "${tableName}";`);
+                            }
+                            catch { }
+                        }
+                    }
+                }
+                p.rowsCopied = tableRowsCopied;
+                totalRowsTransferred += tableRowsCopied;
+                p.status = 'completed';
+            }
+        }
+    }
+    catch (err) {
+        return {
+            success: false,
+            dryRun: false,
+            sourceDbId,
+            targetDbId,
+            mode,
+            tablesProcessed: progressList,
+            totalRowsTransferred,
+            executionTimeMs: Date.now() - startTime,
+            error: err.message || String(err),
+            summary: `Sync failed: ${err.message}`,
+        };
+    }
+    finally {
+        try {
+            if (targetDialect === 'sqlite') {
+                await targetDb.execResult('PRAGMA foreign_keys = ON;');
+            }
+            else {
+                try {
+                    await targetDb.execResult('SET CONSTRAINTS ALL IMMEDIATE;');
+                }
+                catch { }
+            }
+        }
+        catch { }
+    }
+    return {
+        success: true,
+        dryRun: false,
+        sourceDbId,
+        targetDbId,
+        mode,
+        tablesProcessed: progressList,
+        totalRowsTransferred,
+        executionTimeMs: Date.now() - startTime,
+        summary: `Successfully synchronized ${progressList.length} tables (${totalRowsTransferred} rows) from "${sourceDbId}" to "${targetDbId}".`,
+    };
+}

package/dist/core/transfer/topological-sort.d.ts

@@ -0,0 +1 @@
+import type {ForeignKeyInfo} from '../../db/types';export interface TableDependency{name:string;foreignKeys:ForeignKeyInfo[];}export declare function sortTablesTopologically(tables:TableDependency[]):string[];export declare function sortTablesForDeletion(tables:TableDependency[]):string[];

package/dist/core/transfer/topological-sort.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortTablesTopologically = sortTablesTopologically;
+exports.sortTablesForDeletion = sortTablesForDeletion;
+function sortTablesTopologically(tables) {
+    const tableNames = new Set(tables.map((t) => t.name));
+    const adj = new Map();
+    const inDegree = new Map();
+    for (const t of tables) {
+        if (!adj.has(t.name))
+            adj.set(t.name, new Set());
+        if (!inDegree.has(t.name))
+            inDegree.set(t.name, 0);
+    }
+    for (const t of tables) {
+        for (const fk of t.foreignKeys) {
+            const parent = fk.table;
+            if (parent && tableNames.has(parent) && parent !== t.name) {
+                if (!adj.get(parent).has(t.name)) {
+                    adj.get(parent).add(t.name);
+                    inDegree.set(t.name, (inDegree.get(t.name) || 0) + 1);
+                }
+            }
+        }
+    }
+    const queue = [];
+    for (const [name, deg] of inDegree.entries()) {
+        if (deg === 0)
+            queue.push(name);
+    }
+    const result = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        result.push(current);
+        const children = adj.get(current) || new Set();
+        for (const child of children) {
+            const newDeg = (inDegree.get(child) || 0) - 1;
+            inDegree.set(child, newDeg);
+            if (newDeg === 0) {
+                queue.push(child);
+            }
+        }
+    }
+    if (result.length < tables.length) {
+        for (const t of tables) {
+            if (!result.includes(t.name)) {
+                result.push(t.name);
+            }
+        }
+    }
+    return result;
+}
+function sortTablesForDeletion(tables) {
+    return [...sortTablesTopologically(tables)].reverse();
+}