admindb 2.2.1 → 2.3.1

package/dist/data/chain.js

@@ -1,314 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildErGraph = buildErGraph;
-exports.resolveErChain = resolveErChain;
-exports.topologicalSort = topologicalSort;
+exports.topologicalSort = exports.resolveErChain = exports.buildErGraph = exports.buildChainInsertSql = void 0;
 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 };
-}
+const engine_1 = require("./engine");
+Object.defineProperty(exports, "buildChainInsertSql", { enumerable: true, get: function () { return engine_1.buildChainInsertSql; } });
+const schema_graph_1 = require("./schema-graph");
+const buildErGraph = (tables) => (0, schema_graph_1.buildSchemaGraph)(tables).nodes;
+exports.buildErGraph = buildErGraph;
+const resolveErChain = (graph, rootTable, scope = 'chain') => (0, schema_graph_1.resolveScopeTables)({ nodes: graph, relationships: [] }, rootTable, scope);
+exports.resolveErChain = resolveErChain;
+const topologicalSort = (nodes) => (0, schema_graph_1.sortTopologically)(nodes);
+exports.topologicalSort = topologicalSort;
 async function getErChainConfig(db, rootTable, scope = 'chain') {
     const tableListRes = await db.listTables();
     const tableNames = (tableListRes.data ?? [])
@@ -320,9 +25,9 @@ async function getErChainConfig(db, rootTable, scope = 'chain') {
         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 graph = (0, schema_graph_1.buildSchemaGraph)(tables);
+    const chainNodes = (0, schema_graph_1.resolveScopeTables)(graph, rootTable, scope);
+    const { sorted, cycleDetected, cycleTables } = (0, schema_graph_1.sortTopologically)(chainNodes);
     const tableNodes = [];
     for (let i = 0; i < sorted.length; i++) {
         const node = sorted[i];
@@ -332,15 +37,8 @@ async function getErChainConfig(db, rootTable, scope = 'chain') {
             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;
+        catch { }
+        const suggestedCount = node.depth === 0 ? 5 : node.depth === 1 ? 15 : 25;
         tableNodes.push({
             name: node.name,
             order: i + 1,
@@ -352,6 +50,8 @@ async function getErChainConfig(db, rootTable, scope = 'chain') {
             rowCount,
             isRoot: node.name === rootTable,
             hasSelfRef: node.hasSelfRef,
+            isJunction: node.isJunction,
+            mode: 'generate',
         });
     }
     return {
@@ -361,314 +61,38 @@ async function getErChainConfig(db, rootTable, scope = 'chain') {
         cycleDetected,
         cycleTables,
         maxTotalRows: 10000,
+        relationships: graph.relationships,
     };
 }
-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;
+async function generateChainRows(db, chainConfig, customPlans = {}, customCounts = {}, truncate = false, modes = {}, seed) {
+    const planTables = {};
     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,
+        const mode = modes[tableName] || 'generate';
+        const rows = customCounts[tableName] ?? tableNode.suggestedCount ?? 10;
+        const columns = {};
+        for (const col of tableNode.columns) {
+            const raw = customPlans[tableName]?.[col.name];
+            columns[col.name] = raw && raw.strategy ? raw : col.defaultPlan;
+        }
+        planTables[tableName] = {
+            mode,
             rows,
-            previewRows,
-            warnings,
+            columns,
+            truncate,
         };
-        totalRows += rows.length;
     }
-    const sql = buildChainInsertSql(executionOrder, tableResults);
-    return {
+    const generationPlan = {
         rootTable: chainConfig.rootTable,
         scope: chainConfig.scope,
-        executionOrder,
-        tableResults,
-        totalRows,
-        sql,
-        warnings,
+        tables: planTables,
+        relationships: chainConfig.relationships,
+        options: {
+            seed: seed ?? null,
+            truncateAll: truncate,
+        },
     };
-}
-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');
+    return engine_1.SeedEngine.executePlan(db, generationPlan);
 }
 async function executeChainInsert(db, chainResult, truncate = false) {
     const t0 = Date.now();
@@ -697,11 +121,10 @@ async function executeChainInsert(db, chainResult, truncate = false) {
         inserted[table] = count;
         totalInserted += count;
     }
-    const elapsedMs = Date.now() - t0;
     return {
         inserted,
         totalInserted,
-        elapsedMs,
+        elapsedMs: Date.now() - t0,
         warnings: chainResult.warnings,
     };
 }