admindb 2.2.1 → 2.3.1

package/dist/data/engine.js

@@ -1,33 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRows = generateRows;
+exports.SeedEngine = void 0;
 exports.buildSeedInsertSql = buildSeedInsertSql;
+exports.buildChainInsertSql = buildChainInsertSql;
+exports.generateRows = generateRows;
 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)}`;
-}
+const prng_1 = require("./prng");
+const registry_1 = require("./registry");
+const schema_graph_1 = require("./schema-graph");
+const templates_1 = require("./templates");
+const types_1 = require("./types");
+const validator_1 = require("./validator");
+const stringifyKey = (v) => v instanceof Uint8Array || Buffer.isBuffer(v) ? `buf:${Buffer.from(v).toString('hex')}` : `${typeof v}:${String(v)}`;
 function orderedValue(value, base, dir, orEqual) {
     const v = value;
     const b = base;
@@ -68,23 +53,19 @@ function fitStringLength(val, len) {
     if (!len || typeof val !== 'string')
         return val;
     let v = val;
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
     if (len.exact != null) {
         if (v.length > len.exact)
             v = v.slice(0, len.exact);
-        const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
-        while (v.length < len.exact) {
+        while (v.length < len.exact)
             v += chars[Math.floor(Math.random() * chars.length)];
-        }
         return v;
     }
-    if (len.max != null && v.length > len.max) {
+    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) {
+        while (v.length < len.min)
             v += chars[Math.floor(Math.random() * chars.length)];
-        }
     }
     return v;
 }
@@ -108,132 +89,441 @@ function applyOrdering(fields, ordering) {
         }
     }
 }
-async function generateRows(db, info, configs, count, plan = {}, truncate = false) {
-    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 checkInfo = (0, detector_1.parseChecks)(info.sql ?? null);
-    const warnings = [];
-    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 = plan[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];
+async function sampleColumnValues(db, table, column, limit = 1000) {
+    try {
+        const r = await db.all(`SELECT DISTINCT ${(0, generator_1.quoteIdentifier)(column)} AS v FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${(0, generator_1.quoteIdentifier)(column)} IS NOT NULL LIMIT ${limit}`);
+        return (r.data ?? []).map((row) => row.v).filter((v) => v != null);
+    }
+    catch {
+        return [];
+    }
+}
+class SeedEngine {
+    static async executePlan(db, plan, optionsOverride) {
+        const options = {
+            seed: plan.options?.seed ?? null,
+            transaction: plan.options?.transaction ?? true,
+            rollbackOnError: plan.options?.rollbackOnError ?? true,
+            truncateAll: plan.options?.truncateAll ?? false,
+            batchSize: plan.options?.batchSize ?? 500,
+            previewLimit: plan.options?.previewLimit ?? 50,
+            ...optionsOverride,
+        };
+        const prng = (0, prng_1.createPrng)(options.seed);
+        const warnings = [];
+        const tableListRes = await db.listTables();
+        const tableNames = (tableListRes.data ?? [])
+            .map((t) => t.name)
+            .filter((name) => !name.startsWith('sqlite_') && name !== '_saved_queries');
+        const tableInfos = new Map();
+        const allTableData = [];
+        for (const name of tableNames) {
+            const info = await db.getTableInfo(name);
+            if (info.success && info.data) {
+                tableInfos.set(name, info.data);
+                allTableData.push(info.data);
             }
         }
-        if (!cfg || !cfg.strategies.some((s) => s.id === p.strategy)) {
-            throw new Error(`Unsupported generator strategy "${p.strategy}" for column "${col.name}".`);
+        const validation = await (0, validator_1.validateGenerationPlan)(db, plan, tableInfos);
+        for (const issue of validation.issues) {
+            if (issue.type === 'warning')
+                warnings.push(`[${issue.table || 'Plan'}] ${issue.message}`);
         }
-        if (p.strategy === 'list' && !(p.values ?? []).some((v) => String(v).trim() !== '')) {
-            warnings.push(`Column "${col.name}": the list is empty, so it will be skipped (DB default applies).`);
+        const graph = (0, schema_graph_1.buildSchemaGraph)(allTableData);
+        if (plan.scope && plan.scope !== 'single' && plan.rootTable) {
+            const scopeNodes = (0, schema_graph_1.resolveScopeTables)(graph, plan.rootTable, plan.scope);
+            for (const node of scopeNodes) {
+                if (!plan.tables[node.name]) {
+                    const colConfigs = (0, detector_1.buildColumnConfigs)(node.info);
+                    const columns = {};
+                    colConfigs.forEach((c) => {
+                        columns[c.name] = c.defaultPlan;
+                    });
+                    plan.tables[node.name] = {
+                        mode: 'generate',
+                        rows: node.depth === 0 ? 5 : node.depth === 1 ? 15 : 25,
+                        columns,
+                        truncate: options.truncateAll,
+                    };
+                }
+            }
         }
-        if ((p.strategy === 'skip' || p.strategy === 'null') && !col.pk && col.notnull && col.dflt_value == null) {
-            warnings.push(`Column "${col.name}" is NOT NULL without a default — "${p.strategy}" rows may fail to insert.`);
+        if (plan.scope && plan.scope !== 'single') {
+            let expanded = true;
+            while (expanded) {
+                expanded = false;
+                const currentPlanTables = Object.keys(plan.tables);
+                for (const tName of currentPlanTables) {
+                    const spec = plan.tables[tName];
+                    if (spec && spec.mode === 'skip')
+                        continue;
+                    const info = tableInfos.get(tName);
+                    if (!info)
+                        continue;
+                    for (const fk of info.foreignKeys) {
+                        if (fk.table && fk.table !== tName && !plan.tables[fk.table] && tableInfos.has(fk.table)) {
+                            const countRes = await db.getRowCount(fk.table);
+                            const curCount = countRes.success && typeof countRes.data === 'number' ? countRes.data : 0;
+                            if (curCount === 0) {
+                                const pInfo = tableInfos.get(fk.table);
+                                const pColConfigs = (0, detector_1.buildColumnConfigs)(pInfo);
+                                const pColumns = {};
+                                pColConfigs.forEach((c) => {
+                                    pColumns[c.name] = c.defaultPlan;
+                                });
+                                plan.tables[fk.table] = {
+                                    mode: 'generate',
+                                    rows: 10,
+                                    columns: pColumns,
+                                    truncate: options.truncateAll,
+                                };
+                                expanded = true;
+                            }
+                        }
+                    }
+                }
+            }
         }
-        if (p.strategy === 'fk') {
-            const pool = await sampleFkValues(db, fkByColumn.get(col.name) ?? null);
-            fkPools.set(col.name, pool);
-            const refTable = fkByColumn.get(col.name)?.table ?? '?';
-            if (!pool.length) {
-                if (col.notnull && !col.pk) {
-                    fkOmit.add(col.name);
-                    warnings.push(`Column "${col.name}" is a NOT NULL foreign key to "${refTable}", which has no rows. It is omitted from generated rows — seed "${refTable}" first so the insert can reference real values.`);
+        const planTableNames = Object.keys(plan.tables);
+        const planNodes = planTableNames.map((t) => graph.nodes.get(t)).filter((n) => n != null);
+        const { sorted } = (0, schema_graph_1.sortTopologically)(planNodes.length ? planNodes : Array.from(graph.nodes.values()));
+        const executionOrder = sorted.map((s) => s.name).filter((name) => plan.tables[name] !== undefined);
+        const relationalPool = new Map();
+        const tableResults = {};
+        let totalRows = 0;
+        for (const tableName of executionOrder) {
+            const spec = plan.tables[tableName];
+            const info = tableInfos.get(tableName);
+            if (!info)
+                continue;
+            let mode = spec.mode || 'generate';
+            if (mode === 'generate_if_empty') {
+                try {
+                    const countRes = await db.getRowCount(tableName);
+                    const curCount = countRes.success && typeof countRes.data === 'number' ? countRes.data : 0;
+                    mode = curCount === 0 ? 'generate' : 'use_existing';
                 }
-                else {
-                    warnings.push(`Column "${col.name}": "${refTable}" is empty, so NULL will be inserted.`);
+                catch {
+                    mode = 'generate';
                 }
             }
-        }
-        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)(info.table)} 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 { }
-        }
-    }
-    for (let i = 0; i < count; i++) {
-        const fields = [];
-        const previewRow = {};
-        let rowValid = true;
-        let attempt = 0;
-        while (attempt < 100 && rowValid) {
-            fields.length = 0;
-            let allColsValid = true;
-            for (const { col, plan: p } of prepared) {
-                if (p.strategy === 'fk' && fkOmit.has(col.name)) {
-                    previewRow[col.name] = null;
-                    continue;
-                }
-                let v = (0, strategies_1.generateOne)(col, p, fkPools.get(col.name), i + attempt * count);
-                if (v === types_1.SKIP) {
-                    previewRow[col.name] = '(default)';
-                    continue;
-                }
-                if (uniqueCols.has(col.name)) {
-                    const seen = uniqueSeen.get(col.name) ?? new Set();
-                    let singleAtt = 0;
-                    while (seen.has(stringifyKey(v)) && singleAtt < 100) {
-                        v = (0, strategies_1.generateOne)(col, p, fkPools.get(col.name), i + attempt * count + singleAtt * 100);
-                        singleAtt += 1;
+            if (mode === 'skip') {
+                tableResults[tableName] = { count: 0, rows: [], previewRows: [], warnings: [] };
+                continue;
+            }
+            const pkColName = info.primaryKey[0] || info.columns[0]?.name || 'id';
+            if (mode === 'use_existing') {
+                for (const col of info.columns) {
+                    const pool = await sampleColumnValues(db, tableName, col.name, 1000);
+                    if (pool.length)
+                        relationalPool.set(`${tableName}.${col.name}`, pool);
+                }
+                tableResults[tableName] = { count: 0, rows: [], previewRows: [], warnings: [] };
+                continue;
+            }
+            let requestedCount = Math.max(1, Math.min(types_1.MAX_SEED_ROWS, spec.rows ?? 10));
+            const checkInfo = (0, detector_1.parseChecks)(info.sql ?? null);
+            const fkByColumn = new Map(info.foreignKeys.map((fk) => [fk.from, fk]));
+            const uniqueCols = new Set();
+            const compositeUniques = [];
+            for (const col of info.columns) {
+                if (spec.columns[col.name]?.unique)
+                    uniqueCols.add(col.name);
+            }
+            for (const ix of info.indexes ?? []) {
+                if (ix.unique) {
+                    if (ix.columns.length === 1 && ix.columns[0])
+                        uniqueCols.add(ix.columns[0]);
+                    else if (ix.columns.length > 1)
+                        compositeUniques.push(ix.columns);
+                }
+            }
+            if (info.primaryKey.length > 1 && !compositeUniques.some((cu) => cu.join(',') === info.primaryKey.join(','))) {
+                compositeUniques.push(info.primaryKey);
+            }
+            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 fkPools = new Map();
+            const samplePools = new Map();
+            const fkOmit = new Set();
+            for (const col of info.columns) {
+                const p = spec.columns[col.name] || { strategy: 'skip' };
+                if (p.strategy === 'sampleExisting') {
+                    const refT = p.refTable || tableName;
+                    const refC = p.refColumn || col.name;
+                    samplePools.set(col.name, await sampleColumnValues(db, refT, refC, 1000));
+                }
+                if (p.strategy === 'fk' || p.strategy === 'sequentialFk') {
+                    const fk = fkByColumn.get(col.name);
+                    const refTable = p.refTable || fk?.table || '';
+                    let refCol = p.refColumn || fk?.to || (refTable ? tableInfos.get(refTable)?.primaryKey[0] : 'id') || '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) {
+                        for (const [k, v] of relationalPool.entries()) {
+                            const [tName] = k.split('.');
+                            if (tName && tName.toLowerCase() === refTable.toLowerCase() && v.length) {
+                                pool = v;
+                                break;
+                            }
+                        }
+                    }
+                    if (!pool.length && refTable) {
+                        pool = await sampleColumnValues(db, refTable, refCol, 1000);
                     }
-                    if (seen.has(stringifyKey(v))) {
-                        allColsValid = false;
-                        break;
+                    if (!pool.length) {
+                        const isSelfFk = fkByColumn.get(col.name)?.table === tableName;
+                        if (isSelfFk) {
+                        }
+                        else if (col.notnull || (col.pk ?? 0) > 0) {
+                            if (col.dflt_value != null) {
+                                fkOmit.add(col.name);
+                            }
+                            else {
+                                pool = [1];
+                                warnings.push(`Table "${tableName}" Column "${col.name}" is a NOT NULL foreign key to "${refTable}". Parent table had no records; fallback ID 1 was used.`);
+                            }
+                        }
+                        else {
+                            warnings.push(`Table "${tableName}" Column "${col.name}": "${refTable}" has no rows; NULL will be used.`);
+                        }
+                    }
+                    fkPools.set(col.name, pool);
+                }
+            }
+            const uniqueSeen = new Map();
+            const compositeSeen = new Map();
+            for (const cu of compositeUniques)
+                compositeSeen.set(cu.join('::'), new Set());
+            if (!spec.truncate && !options.truncateAll) {
+                for (const col of uniqueCols) {
+                    try {
+                        const existing = await sampleColumnValues(db, tableName, col, 10000);
+                        uniqueSeen.set(col, new Set(existing.map(stringifyKey)));
                     }
+                    catch { }
                 }
-                v = fitStringLength(v, (0, detector_1.findInMap)(checkInfo.columnLength, col.name));
-                fields.push({ column: col.name, value: v });
-                previewRow[col.name] = v;
             }
-            if (allColsValid) {
-                break;
+            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 { }
+                }
             }
-            attempt += 1;
-        }
-        if (attempt >= 100) {
-            warnings.push(`Stopped generating rows early at row ${i} because unique generator exhausted possible values without collision.`);
-            break;
-        }
-        for (const f of fields) {
-            if (uniqueCols.has(f.column)) {
-                const seen = uniqueSeen.get(f.column) ?? new Set();
-                seen.add(stringifyKey(f.value));
-                uniqueSeen.set(f.column, seen);
+            const allColNames = info.columns.map((c) => c.name);
+            const { orderedColumns } = (0, templates_1.orderColumnDependencies)(allColNames, spec.columns);
+            const colMap = new Map(info.columns.map((c) => [c.name, c]));
+            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 colName of orderedColumns) {
+                const p = spec.columns[colName];
+                const col = colMap.get(colName);
+                if (col && p && p.strategy === 'fk' && ((info.primaryKey.length === 1 && col.pk) || isUniqueCol(col.name))) {
+                    const pool = fkPools.get(col.name);
+                    if (pool && pool.length > 0 && pool.length < requestedCount)
+                        requestedCount = pool.length;
+                }
             }
+            if (compositeUniques.length > 0) {
+                for (const cu of compositeUniques) {
+                    const isAllFk = cu.every((cName) => {
+                        const p = spec.columns[cName];
+                        return p && (p.strategy === 'fk' || p.strategy === 'sequentialFk');
+                    });
+                    if (isAllFk) {
+                        const maxCombos = cu.reduce((acc, cName) => acc * Math.max(1, (fkPools.get(cName) ?? []).length), 1);
+                        if (maxCombos > 0 && maxCombos < requestedCount)
+                            requestedCount = maxCombos;
+                    }
+                }
+            }
+            const rows = [];
+            const previewRows = [];
+            const tableGeneratedPkVals = {};
+            for (let i = 0; i < requestedCount; i++) {
+                let fields = [];
+                let previewRow = {};
+                let rowValid = false;
+                let attempt = 0;
+                while (!rowValid && attempt < 35) {
+                    fields = [];
+                    previewRow = {};
+                    const rowValues = {};
+                    for (const colName of orderedColumns) {
+                        const col = colMap.get(colName);
+                        const p = spec.columns[colName] || { strategy: 'skip' };
+                        if ((p.strategy === 'fk' || p.strategy === 'sequentialFk') && fkOmit.has(col.name)) {
+                            previewRow[col.name] = null;
+                            rowValues[col.name] = null;
+                            continue;
+                        }
+                        const isSelfFk = fkByColumn.get(col.name)?.table === tableName;
+                        let pool = fkPools.get(col.name);
+                        if (isSelfFk) {
+                            const selfIds = tableGeneratedPkVals[fkByColumn.get(col.name)?.to || pkColName] ?? [];
+                            pool = (i === 0 || selfIds.length === 0 || (prng.chance(35) && !col.notnull)) ? [] : selfIds;
+                        }
+                        let v = p.strategy === 'template' && p.template
+                            ? (0, templates_1.evaluateTemplate)(p.template, rowValues, prng, i + attempt * 50)
+                            : (0, registry_1.generateColumnValue)(col, p, prng, i + attempt * 50, rowValues, pool, samplePools.get(col.name));
+                        if (v === types_1.SKIP && col.pk) {
+                            const isInt = (col.type || '').toUpperCase().includes('INT') || (col.type || '').toUpperCase().includes('SERIAL') || col.type === '' || col.type === 'NUMBER';
+                            if (isInt)
+                                v = pkStartOffset + i + 1;
+                        }
+                        if ((col.notnull || (col.pk ?? 0) > 0) && col.dflt_value == null && (v == null || v === types_1.SKIP)) {
+                            if (p.strategy === 'fk' || p.strategy === 'sequentialFk') {
+                                v = pool && pool.length > 0 ? pool[0] : 1;
+                            }
+                            else if (col.pk) {
+                                v = pkStartOffset + i + 1;
+                            }
+                            else {
+                                const fbPlan = registry_1.GeneratorRegistry.get('words') ? { strategy: 'words', minLen: 1, maxLen: 3 } : { strategy: 'skip' };
+                                v = (0, registry_1.generateColumnValue)(col, fbPlan, prng, i + attempt * 50, rowValues);
+                                if (v == null || v === types_1.SKIP) {
+                                    v = (col.type || '').toUpperCase().includes('INT') ? i + 1 : `val_${i + 1}`;
+                                }
+                            }
+                        }
+                        if (v === types_1.SKIP) {
+                            previewRow[col.name] = '(default)';
+                            rowValues[col.name] = null;
+                            continue;
+                        }
+                        if (isUniqueCol(col.name)) {
+                            const seen = uniqueSeen.get(col.name) ?? new Set();
+                            if (p.strategy === 'fk' || p.strategy === 'sequentialFk') {
+                                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 < 50) {
+                                    v = (0, registry_1.generateColumnValue)(col, p, prng, i + attempt * 50 + singleAtt * 100, rowValues, pool, samplePools.get(col.name));
+                                    singleAtt++;
+                                }
+                                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;
+                        rowValues[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((cName) => stringifyKey(fieldMap.get(cName))).join('|');
+                            const seenSet = compositeSeen.get(key) ?? new Set();
+                            if (seenSet.has(compositeVal)) {
+                                compositeCollision = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (!compositeCollision && fields.length > 0) {
+                        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((cName) => stringifyKey(fieldMap.get(cName))).join('|');
+                                const seenSet = compositeSeen.get(key) ?? new Set();
+                                seenSet.add(compositeVal);
+                                compositeSeen.set(key, seenSet);
+                            }
+                        }
+                    }
+                    attempt++;
+                }
+                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 < (options.previewLimit ?? 50)) {
+                    previewRows.push(previewRow);
+                }
+            }
+            tableResults[tableName] = {
+                count: rows.length,
+                rows,
+                previewRows,
+                warnings: [],
+            };
+            totalRows += rows.length;
         }
-        applyOrdering(fields, checkInfo.ordering);
-        for (const f of fields) {
-            previewRow[f.column] = f.value;
-        }
-        rows.push(fields);
-        if (previewRows.length < 50) {
-            previewRows.push(previewRow);
-        }
+        const sql = buildChainInsertSql(executionOrder, tableResults);
+        return {
+            rootTable: plan.rootTable,
+            scope: plan.scope,
+            executionOrder,
+            tableResults,
+            totalRows,
+            sql,
+            warnings,
+            validation,
+        };
     }
-    return { rows, previewRows, warnings };
 }
+exports.SeedEngine = SeedEngine;
 function buildSeedInsertSql(table, rows) {
     return rows
         .map((fields) => {
@@ -243,3 +533,54 @@ function buildSeedInsertSql(table, rows) {
     })
         .join('\n');
 }
+function buildChainInsertSql(executionOrder, tableResults) {
+    const sqlParts = [
+        '-- AdminDB Relational 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 generateRows(db, info, configs, count, plan = {}, truncate = false) {
+    const tableSpec = {
+        mode: 'generate',
+        rows: count,
+        columns: {},
+        truncate,
+    };
+    for (const col of info.columns) {
+        const raw = plan[col.name];
+        const cfg = configs.find((c) => c.name === col.name);
+        tableSpec.columns[col.name] = raw && raw.strategy ? raw : (cfg?.defaultPlan ?? { strategy: 'skip' });
+    }
+    const generationPlan = {
+        rootTable: info.table,
+        scope: 'single',
+        tables: { [info.table]: tableSpec },
+        options: { truncateAll: truncate },
+    };
+    const res = await SeedEngine.executePlan(db, generationPlan);
+    const tableRes = res.tableResults[info.table] || { rows: [], previewRows: [], warnings: [] };
+    return {
+        rows: tableRes.rows,
+        previewRows: tableRes.previewRows,
+        warnings: [...res.warnings, ...tableRes.warnings],
+    };
+}