admindb 2.1.0 → 2.2.1

package/dist/data/chain.js

@@ -0,0 +1,707 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildErGraph = buildErGraph;
+exports.resolveErChain = resolveErChain;
+exports.topologicalSort = topologicalSort;
+exports.getErChainConfig = getErChainConfig;
+exports.generateChainRows = generateChainRows;
+exports.buildChainInsertSql = buildChainInsertSql;
+exports.executeChainInsert = executeChainInsert;
+const generator_1 = require("../sql/generator");
+const types_1 = require("./types");
+const detector_1 = require("./detector");
+const strategies_1 = require("./strategies");
+async function sampleFkValues(db, fk) {
+    if (!fk)
+        return [];
+    try {
+        const ref = await db.getTableInfo(fk.table);
+        if (!ref.success || !ref.data || !ref.data.columns.length)
+            return [];
+        const refCol = fk.to || ref.data.primaryKey[0] || ref.data.columns[0].name;
+        if (!refCol)
+            return [];
+        const r = await db.all(`SELECT DISTINCT ${(0, generator_1.quoteIdentifier)(refCol)} AS v FROM ${(0, generator_1.quoteIdentifier)(fk.table)} WHERE ${(0, generator_1.quoteIdentifier)(refCol)} IS NOT NULL LIMIT 1000`);
+        return (r.data ?? []).map((row) => row.v).filter((v) => v != null);
+    }
+    catch {
+        return [];
+    }
+}
+function stringifyKey(v) {
+    if (v instanceof Uint8Array || Buffer.isBuffer(v))
+        return `buf:${Buffer.from(v).toString('hex')}`;
+    return `${typeof v}:${String(v)}`;
+}
+function orderedValue(value, base, dir, orEqual) {
+    const v = value;
+    const b = base;
+    if (typeof v === 'string' && typeof b === 'string') {
+        const tv = Date.parse(v);
+        const tb = Date.parse(b);
+        if (Number.isFinite(tv) && Number.isFinite(tb)) {
+            if (dir === 'after') {
+                if (orEqual ? tv < tb : tv <= tb)
+                    return new Date(tb + 1000).toISOString();
+            }
+            else if (orEqual ? tv > tb : tv >= tb) {
+                return new Date(tb - 1000).toISOString();
+            }
+            return v;
+        }
+        if (/^\d{4}-\d{2}-\d{2}$/.test(v) && /^\d{4}-\d{2}-\d{2}$/.test(b)) {
+            const dv = Date.parse(`${v}T00:00:00Z`);
+            const db = Date.parse(`${b}T00:00:00Z`);
+            if (dir === 'after') {
+                if (orEqual ? dv < db : dv <= db)
+                    return new Date(db + 86400_000).toISOString().slice(0, 10);
+            }
+            else if (orEqual ? dv > db : dv >= db) {
+                return new Date(db - 86400_000).toISOString().slice(0, 10);
+            }
+            return v;
+        }
+    }
+    if (typeof v === 'number' && typeof b === 'number') {
+        if (dir === 'after')
+            return orEqual ? Math.max(v, b) : Math.max(v, b + 1);
+        return orEqual ? Math.min(v, b) : Math.min(v, b - 1);
+    }
+    return v;
+}
+function fitStringLength(val, len) {
+    if (!len || typeof val !== 'string')
+        return val;
+    let v = val;
+    if (len.exact != null) {
+        if (v.length > len.exact)
+            v = v.slice(0, len.exact);
+        const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        while (v.length < len.exact) {
+            v += chars[Math.floor(Math.random() * chars.length)];
+        }
+        return v;
+    }
+    if (len.max != null && v.length > len.max) {
+        v = v.slice(0, len.max);
+    }
+    if (len.min != null && v.length < len.min) {
+        const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        while (v.length < len.min) {
+            v += chars[Math.floor(Math.random() * chars.length)];
+        }
+    }
+    return v;
+}
+function applyOrdering(fields, ordering) {
+    if (!ordering.size)
+        return;
+    const byCol = new Map(fields.map((f) => [f.column, f]));
+    for (const f of fields) {
+        const rel = ordering.get(f.column);
+        if (!rel)
+            continue;
+        if (rel.after && f.value != null) {
+            const other = byCol.get(rel.after.column);
+            if (other && other.value != null)
+                f.value = orderedValue(f.value, other.value, 'after', rel.after.orEqual);
+        }
+        if (rel.before && f.value != null) {
+            const other = byCol.get(rel.before.column);
+            if (other && other.value != null)
+                f.value = orderedValue(f.value, other.value, 'before', rel.before.orEqual);
+        }
+    }
+}
+function buildErGraph(tables) {
+    const graph = new Map();
+    for (const info of tables) {
+        const columns = (0, detector_1.buildColumnConfigs)(info);
+        const colMap = new Map(info.columns.map((c) => [c.name, c]));
+        const parents = [];
+        let hasSelfRef = false;
+        for (const fk of info.foreignKeys) {
+            const toCol = fk.to || (tables.find((t) => t.table === fk.table)?.primaryKey[0] ?? 'id');
+            if (fk.table === info.table) {
+                hasSelfRef = true;
+            }
+            const c = colMap.get(fk.from);
+            const notnull = Boolean(c?.notnull && !c?.pk);
+            parents.push({ table: fk.table, from: fk.from, to: toCol, notnull });
+        }
+        graph.set(info.table, {
+            name: info.table,
+            info,
+            columns,
+            parents,
+            children: [],
+            hasSelfRef,
+            depth: 0,
+        });
+    }
+    for (const node of graph.values()) {
+        for (const p of node.parents) {
+            if (p.table !== node.name && graph.has(p.table)) {
+                graph.get(p.table).children.push({ table: node.name, from: p.from, to: p.to, notnull: p.notnull });
+            }
+        }
+    }
+    return graph;
+}
+function resolveErChain(graph, rootTable, scope = 'chain') {
+    if (scope === 'all') {
+        return Array.from(graph.values());
+    }
+    const root = graph.get(rootTable);
+    if (!root)
+        return [];
+    if (scope === 'single') {
+        return [root];
+    }
+    const selected = new Set();
+    if (scope === 'ancestors') {
+        const queue = [rootTable];
+        selected.add(rootTable);
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const node = graph.get(current);
+            if (!node)
+                continue;
+            for (const p of node.parents) {
+                if (p.table !== current && graph.has(p.table) && !selected.has(p.table)) {
+                    selected.add(p.table);
+                    queue.push(p.table);
+                }
+            }
+        }
+    }
+    else if (scope === 'descendants') {
+        const queue = [rootTable];
+        selected.add(rootTable);
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const node = graph.get(current);
+            if (!node)
+                continue;
+            for (const c of node.children) {
+                if (c.table !== current && graph.has(c.table) && !selected.has(c.table)) {
+                    selected.add(c.table);
+                    queue.push(c.table);
+                }
+            }
+        }
+    }
+    else {
+        const queue = [rootTable];
+        selected.add(rootTable);
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const node = graph.get(current);
+            if (!node)
+                continue;
+            for (const p of node.parents) {
+                if (p.table !== current && graph.has(p.table) && !selected.has(p.table)) {
+                    selected.add(p.table);
+                    queue.push(p.table);
+                }
+            }
+            for (const c of node.children) {
+                if (c.table !== current && graph.has(c.table) && !selected.has(c.table)) {
+                    selected.add(c.table);
+                    queue.push(c.table);
+                }
+            }
+        }
+    }
+    return Array.from(selected).map((name) => graph.get(name));
+}
+function topologicalSort(nodes) {
+    const activeNames = new Set(nodes.map((n) => n.name));
+    const nodeMap = new Map(nodes.map((n) => [n.name, n]));
+    const hardInDegree = new Map();
+    const totalInDegree = new Map();
+    const hardForwardEdges = new Map();
+    const softForwardEdges = new Map();
+    for (const n of nodes) {
+        hardInDegree.set(n.name, 0);
+        totalInDegree.set(n.name, 0);
+        hardForwardEdges.set(n.name, new Set());
+        softForwardEdges.set(n.name, new Set());
+    }
+    for (const n of nodes) {
+        for (const p of n.parents) {
+            if (p.table !== n.name && activeNames.has(p.table)) {
+                if (p.notnull) {
+                    if (!hardForwardEdges.get(p.table).has(n.name)) {
+                        hardForwardEdges.get(p.table).add(n.name);
+                        hardInDegree.set(n.name, (hardInDegree.get(n.name) ?? 0) + 1);
+                    }
+                }
+                else {
+                    if (!softForwardEdges.get(p.table).has(n.name)) {
+                        softForwardEdges.get(p.table).add(n.name);
+                    }
+                }
+                totalInDegree.set(n.name, (totalInDegree.get(n.name) ?? 0) + 1);
+            }
+        }
+    }
+    const queue = [];
+    const visited = new Set();
+    for (const [name, deg] of hardInDegree.entries()) {
+        if (deg === 0) {
+            queue.push(name);
+            visited.add(name);
+        }
+    }
+    const sortedNames = [];
+    const depths = new Map();
+    for (const name of queue)
+        depths.set(name, 0);
+    let cycleDetected = false;
+    const cycleTables = [];
+    while (visited.size < nodes.length) {
+        while (queue.length > 0) {
+            const curr = queue.shift();
+            sortedNames.push(curr);
+            const currDepth = depths.get(curr) ?? 0;
+            for (const child of hardForwardEdges.get(curr) ?? []) {
+                const newDeg = (hardInDegree.get(child) ?? 1) - 1;
+                hardInDegree.set(child, newDeg);
+                depths.set(child, Math.max(depths.get(child) ?? 0, currDepth + 1));
+                if (newDeg === 0 && !visited.has(child)) {
+                    visited.add(child);
+                    queue.push(child);
+                }
+            }
+            for (const child of softForwardEdges.get(curr) ?? []) {
+                depths.set(child, Math.max(depths.get(child) ?? 0, currDepth + 1));
+            }
+        }
+        if (visited.size < nodes.length) {
+            cycleDetected = true;
+            let bestCandidate = '';
+            let lowestDeg = Infinity;
+            for (const n of nodes) {
+                if (!visited.has(n.name)) {
+                    const deg = hardInDegree.get(n.name) ?? 0;
+                    if (deg < lowestDeg) {
+                        lowestDeg = deg;
+                        bestCandidate = n.name;
+                    }
+                }
+            }
+            if (bestCandidate) {
+                cycleTables.push(bestCandidate);
+                visited.add(bestCandidate);
+                depths.set(bestCandidate, (depths.get(bestCandidate) ?? 1) + 1);
+                queue.push(bestCandidate);
+            }
+            else {
+                break;
+            }
+        }
+    }
+    const sorted = sortedNames.map((name) => {
+        const node = { ...nodeMap.get(name) };
+        node.depth = depths.get(name) ?? 0;
+        return node;
+    });
+    return { sorted, cycleDetected, cycleTables };
+}
+async function getErChainConfig(db, rootTable, scope = 'chain') {
+    const tableListRes = await db.listTables();
+    const tableNames = (tableListRes.data ?? [])
+        .map((t) => t.name)
+        .filter((name) => !name.startsWith('sqlite_') && name !== '_saved_queries');
+    const tables = [];
+    for (const name of tableNames) {
+        const info = await db.getTableInfo(name);
+        if (info.success && info.data)
+            tables.push(info.data);
+    }
+    const graph = buildErGraph(tables);
+    const chainNodes = resolveErChain(graph, rootTable, scope);
+    const { sorted, cycleDetected, cycleTables } = topologicalSort(chainNodes);
+    const tableNodes = [];
+    for (let i = 0; i < sorted.length; i++) {
+        const node = sorted[i];
+        let rowCount = 0;
+        try {
+            const countRes = await db.getRowCount(node.name);
+            if (countRes.success && typeof countRes.data === 'number')
+                rowCount = countRes.data;
+        }
+        catch {
+        }
+        let suggestedCount = 10;
+        if (node.depth === 0)
+            suggestedCount = 5;
+        else if (node.depth === 1)
+            suggestedCount = 15;
+        else
+            suggestedCount = 25;
+        tableNodes.push({
+            name: node.name,
+            order: i + 1,
+            depth: node.depth,
+            parents: node.parents.filter((p) => sorted.some((s) => s.name === p.table)),
+            children: node.children.filter((c) => sorted.some((s) => s.name === c.table)),
+            columns: node.columns,
+            suggestedCount,
+            rowCount,
+            isRoot: node.name === rootTable,
+            hasSelfRef: node.hasSelfRef,
+        });
+    }
+    return {
+        rootTable,
+        scope,
+        tables: tableNodes,
+        cycleDetected,
+        cycleTables,
+        maxTotalRows: 10000,
+    };
+}
+async function generateChainRows(db, chainConfig, customPlans = {}, customCounts = {}, truncate = false) {
+    const warnings = [];
+    const executionOrder = chainConfig.tables.map((t) => t.name);
+    const relationalPool = new Map();
+    const tableResults = {};
+    let totalRows = 0;
+    for (const tableNode of chainConfig.tables) {
+        const tableName = tableNode.name;
+        const tableInfoRes = await db.getTableInfo(tableName);
+        if (!tableInfoRes.success || !tableInfoRes.data) {
+            warnings.push(`Could not load table metadata for "${tableName}".`);
+            continue;
+        }
+        const info = tableInfoRes.data;
+        let count = Math.max(1, Math.min(2000, customCounts[tableName] ?? tableNode.suggestedCount ?? 10));
+        const tablePlan = customPlans[tableName] ?? {};
+        const configs = tableNode.columns;
+        const fkByColumn = new Map();
+        for (const fk of info.foreignKeys)
+            fkByColumn.set(fk.from, fk);
+        const uniqueCols = new Set();
+        for (const cfg of configs)
+            if (cfg.unique)
+                uniqueCols.add(cfg.name);
+        const compositeUniques = [];
+        for (const ix of info.indexes ?? []) {
+            if (ix.unique && ix.columns.length === 1 && ix.columns[0])
+                uniqueCols.add(ix.columns[0]);
+            if (ix.unique && ix.columns.length > 1)
+                compositeUniques.push(ix.columns);
+        }
+        if (info.sql) {
+            const uqRe = /UNIQUE\s*\(\s*([^)]+)\s*\)/gi;
+            let uqM;
+            while ((uqM = uqRe.exec(info.sql))) {
+                const rawCols = uqM[1].split(',').map((s) => s.trim().replace(/[`"\[\]]/g, ''));
+                if (rawCols.length === 1 && rawCols[0]) {
+                    uniqueCols.add(rawCols[0]);
+                }
+                else if (rawCols.length > 1 && !compositeUniques.some((cu) => cu.join(',') === rawCols.join(','))) {
+                    compositeUniques.push(rawCols);
+                }
+            }
+        }
+        const compositeSeen = new Map();
+        for (const cu of compositeUniques) {
+            compositeSeen.set(cu.join('::'), new Set());
+        }
+        const checkInfo = (0, detector_1.parseChecks)(info.sql ?? null);
+        const prepared = [];
+        const fkPools = new Map();
+        const fkOmit = new Set();
+        for (const col of info.columns) {
+            const cfg = configs.find((c) => c.name === col.name);
+            const raw = tablePlan[col.name];
+            const p = raw && raw.strategy ? raw : (cfg?.defaultPlan ?? { strategy: 'skip' });
+            if (p.strategy === 'list' && (!p.values || !p.values.length)) {
+                const allowed = (0, detector_1.findInMap)(checkInfo.columnAllowed, col.name);
+                if (allowed && allowed.length)
+                    p.values = [...allowed];
+            }
+            if (p.strategy === 'fk') {
+                const fk = fkByColumn.get(col.name);
+                const refTable = fk?.table ?? '';
+                const refCol = fk?.to || 'id';
+                const poolKey = `${refTable}.${refCol}`;
+                let pool = relationalPool.get(poolKey) ?? [];
+                if (!pool.length) {
+                    for (const [k, v] of relationalPool.entries()) {
+                        if (k.toLowerCase() === poolKey.toLowerCase() && v.length) {
+                            pool = v;
+                            break;
+                        }
+                    }
+                }
+                if (!pool.length) {
+                    pool = await sampleFkValues(db, fk ?? null);
+                }
+                fkPools.set(col.name, pool);
+                if (!pool.length) {
+                    if (col.notnull && !col.pk) {
+                        pool = [1];
+                        fkPools.set(col.name, pool);
+                        warnings.push(`Table "${tableName}" Column "${col.name}" is a NOT NULL foreign key to "${refTable}". Fallback ID 1 was used.`);
+                    }
+                    else {
+                        warnings.push(`Table "${tableName}" Column "${col.name}": "${refTable}" has no rows; NULL will be used.`);
+                    }
+                }
+            }
+            prepared.push({ col, plan: p });
+        }
+        const rows = [];
+        const previewRows = [];
+        const uniqueSeen = new Map();
+        if (!truncate) {
+            for (const col of uniqueCols) {
+                try {
+                    const existing = await db.all(`SELECT ${(0, generator_1.quoteIdentifier)(col)} AS v FROM ${(0, generator_1.quoteIdentifier)(tableName)} WHERE ${(0, generator_1.quoteIdentifier)(col)} IS NOT NULL LIMIT 10000`);
+                    const seen = new Set();
+                    for (const r of (existing.data ?? [])) {
+                        if (r.v != null)
+                            seen.add(stringifyKey(r.v));
+                    }
+                    uniqueSeen.set(col, seen);
+                }
+                catch { }
+            }
+        }
+        const tableGeneratedPkVals = {};
+        let pkStartOffset = 0;
+        for (const col of info.columns) {
+            if (col.pk && (col.type || '').toUpperCase().includes('INT')) {
+                try {
+                    const maxRes = await db.all(`SELECT MAX(${(0, generator_1.quoteIdentifier)(col.name)}) AS mx FROM ${(0, generator_1.quoteIdentifier)(tableName)}`);
+                    const maxVal = (maxRes.data ?? [])[0]?.mx;
+                    if (typeof maxVal === 'number' && Number.isFinite(maxVal))
+                        pkStartOffset = maxVal;
+                }
+                catch {
+                }
+            }
+        }
+        const isUniqueCol = (name) => {
+            const norm = name.toLowerCase().replace(/[`"\[\]]/g, '');
+            for (const u of uniqueCols) {
+                if (u.toLowerCase().replace(/[`"\[\]]/g, '') === norm)
+                    return true;
+            }
+            return false;
+        };
+        for (const { col, plan: p } of prepared) {
+            if (p.strategy === 'fk' && (col.pk || isUniqueCol(col.name))) {
+                const pool = fkPools.get(col.name);
+                if (pool && pool.length > 0 && pool.length < count) {
+                    count = pool.length;
+                }
+            }
+        }
+        if (compositeUniques.length > 0) {
+            for (const cu of compositeUniques) {
+                const isAllFk = cu.every((colName) => prepared.some((p) => (p.col.name === colName || p.col.name.replace(/[`"\[\]]/g, '') === colName.replace(/[`"\[\]]/g, '')) && p.plan.strategy === 'fk'));
+                if (isAllFk) {
+                    const maxCombos = cu.reduce((acc, colName) => {
+                        const pool = fkPools.get(colName) ?? [];
+                        return acc * Math.max(1, pool.length);
+                    }, 1);
+                    if (maxCombos > 0 && maxCombos < count) {
+                        count = maxCombos;
+                    }
+                }
+            }
+        }
+        for (let i = 0; i < count; i++) {
+            let fields = [];
+            let previewRow = {};
+            let rowValid = false;
+            let attempt = 0;
+            while (!rowValid && attempt < 30) {
+                fields = [];
+                previewRow = {};
+                for (const { col, plan: p } of prepared) {
+                    if (p.strategy === 'fk' && fkOmit.has(col.name)) {
+                        previewRow[col.name] = null;
+                        continue;
+                    }
+                    const isSelfFk = fkByColumn.get(col.name)?.table === tableName;
+                    let pool = fkPools.get(col.name);
+                    if (isSelfFk) {
+                        const existingSelfIds = tableGeneratedPkVals[fkByColumn.get(col.name)?.to || info.primaryKey[0] || 'id'] ?? [];
+                        if (i === 0 || existingSelfIds.length === 0 || (Math.random() < 0.35 && !col.notnull)) {
+                            pool = [];
+                        }
+                        else {
+                            pool = existingSelfIds;
+                        }
+                    }
+                    let v = (0, strategies_1.generateOne)(col, p, pool, i + attempt * 50);
+                    if (v === types_1.SKIP && col.pk && (col.type || '').toUpperCase().includes('INT')) {
+                        v = pkStartOffset + i + 1;
+                    }
+                    if (v === types_1.SKIP) {
+                        previewRow[col.name] = '(default)';
+                        continue;
+                    }
+                    if (isUniqueCol(col.name)) {
+                        const seen = uniqueSeen.get(col.name) ?? new Set();
+                        if (p.strategy === 'fk') {
+                            const unused = (pool ?? []).filter((x) => !seen.has(stringifyKey(x)));
+                            if (unused.length > 0) {
+                                v = unused[0];
+                            }
+                            else {
+                                rowValid = false;
+                                break;
+                            }
+                        }
+                        else {
+                            let singleAtt = 0;
+                            while (seen.has(stringifyKey(v)) && singleAtt < 100) {
+                                v = (0, strategies_1.generateOne)(col, p, pool, i + attempt * 50 + singleAtt * 100);
+                                singleAtt += 1;
+                            }
+                            if (seen.has(stringifyKey(v))) {
+                                rowValid = false;
+                                break;
+                            }
+                        }
+                    }
+                    v = fitStringLength(v, (0, detector_1.findInMap)(checkInfo.columnLength, col.name));
+                    fields.push({ column: col.name, value: v });
+                    previewRow[col.name] = v;
+                }
+                applyOrdering(fields, checkInfo.ordering);
+                for (const f of fields) {
+                    previewRow[f.column] = f.value;
+                }
+                let compositeCollision = false;
+                if (compositeUniques.length > 0) {
+                    const fieldMap = new Map(fields.map((f) => [f.column, f.value]));
+                    for (const cu of compositeUniques) {
+                        const key = cu.join('::');
+                        const compositeVal = cu.map((colName) => stringifyKey(fieldMap.get(colName))).join('|');
+                        const seenSet = compositeSeen.get(key) ?? new Set();
+                        if (seenSet.has(compositeVal)) {
+                            compositeCollision = true;
+                            break;
+                        }
+                    }
+                }
+                if (!compositeCollision) {
+                    rowValid = true;
+                    if (compositeUniques.length > 0) {
+                        const fieldMap = new Map(fields.map((f) => [f.column, f.value]));
+                        for (const cu of compositeUniques) {
+                            const key = cu.join('::');
+                            const compositeVal = cu.map((colName) => stringifyKey(fieldMap.get(colName))).join('|');
+                            const seenSet = compositeSeen.get(key) ?? new Set();
+                            seenSet.add(compositeVal);
+                            compositeSeen.set(key, seenSet);
+                        }
+                    }
+                }
+                attempt += 1;
+            }
+            if (!rowValid) {
+                break;
+            }
+            for (const f of fields) {
+                if (isUniqueCol(f.column)) {
+                    const seen = uniqueSeen.get(f.column) ?? new Set();
+                    seen.add(stringifyKey(f.value));
+                    uniqueSeen.set(f.column, seen);
+                }
+                const poolKey = `${tableName}.${f.column}`;
+                const cur = relationalPool.get(poolKey) ?? [];
+                cur.push(f.value);
+                relationalPool.set(poolKey, cur);
+                const selfCur = tableGeneratedPkVals[f.column] ?? [];
+                selfCur.push(f.value);
+                tableGeneratedPkVals[f.column] = selfCur;
+            }
+            rows.push(fields);
+            if (previewRows.length < 50) {
+                previewRows.push(previewRow);
+            }
+        }
+        tableResults[tableName] = {
+            count: rows.length,
+            rows,
+            previewRows,
+            warnings,
+        };
+        totalRows += rows.length;
+    }
+    const sql = buildChainInsertSql(executionOrder, tableResults);
+    return {
+        rootTable: chainConfig.rootTable,
+        scope: chainConfig.scope,
+        executionOrder,
+        tableResults,
+        totalRows,
+        sql,
+        warnings,
+    };
+}
+function buildChainInsertSql(executionOrder, tableResults) {
+    const sqlParts = ['-- AdminDB ER Chain Seed Script', '-- Order of execution: ' + executionOrder.join(' -> '), 'BEGIN TRANSACTION;\n'];
+    for (const table of executionOrder) {
+        const res = tableResults[table];
+        if (!res || !res.rows.length)
+            continue;
+        sqlParts.push(`-- --------------------------------------------------------`);
+        sqlParts.push(`-- Table: ${table} (${res.rows.length} rows)`);
+        sqlParts.push(`-- --------------------------------------------------------`);
+        for (const fields of res.rows) {
+            if (!fields.length)
+                continue;
+            const cols = fields.map((f) => (0, generator_1.quoteIdentifier)(f.column)).join(', ');
+            const vals = fields.map((f) => (0, generator_1.sqlValue)(f.value)).join(', ');
+            sqlParts.push(`INSERT INTO ${(0, generator_1.quoteIdentifier)(table)} (${cols}) VALUES (${vals});`);
+        }
+        sqlParts.push('');
+    }
+    sqlParts.push('COMMIT;');
+    return sqlParts.join('\n');
+}
+async function executeChainInsert(db, chainResult, truncate = false) {
+    const t0 = Date.now();
+    const inserted = {};
+    let totalInserted = 0;
+    if (truncate) {
+        const reverseOrder = [...chainResult.executionOrder].reverse();
+        for (const table of reverseOrder) {
+            const clearRes = await db.run(`DELETE FROM ${(0, generator_1.quoteIdentifier)(table)}`);
+            if (!clearRes.success) {
+                throw new Error(`Failed to truncate table "${table}": ${clearRes.error}`);
+            }
+        }
+    }
+    for (const table of chainResult.executionOrder) {
+        const res = chainResult.tableResults[table];
+        if (!res || !res.rows.length) {
+            inserted[table] = 0;
+            continue;
+        }
+        const insertRes = await db.insertRows(table, res.rows);
+        if (!insertRes.success) {
+            throw new Error(`Failed to insert seed rows into "${table}": ${insertRes.error}`);
+        }
+        const count = insertRes.data?.inserted ?? res.rows.length;
+        inserted[table] = count;
+        totalInserted += count;
+    }
+    const elapsedMs = Date.now() - t0;
+    return {
+        inserted,
+        totalInserted,
+        elapsedMs,
+        warnings: chainResult.warnings,
+    };
+}