admindb 2.1.1 → 2.3.0

package/dist/data/engine.js

@@ -1 +1,586 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.generateRows=async function(db,info,configs,count,plan={}){const fkByColumn=new Map;for(const fk of info.foreignKeys)fkByColumn.set(fk.from,fk);const uniqueCols=new Set;for(const cfg of configs)cfg.unique&&uniqueCols.add(cfg.name);const checkInfo=(0,detector_1.parseChecks)(info.sql??null),warnings=[],prepared=[],fkPools=new Map,fkOmit=new Set;for(const col of info.columns){const cfg=configs.find(c=>c.name===col.name),raw=plan[col.name],p=raw&&raw.strategy?raw:cfg?.defaultPlan??{strategy:"skip"};if(!("list"!==p.strategy||p.values&&p.values.length)){const allowed=(0,detector_1.findInMap)(checkInfo.columnAllowed,col.name);allowed&&allowed.length&&(p.values=[...allowed])}if(!cfg||!cfg.strategies.some(s=>s.id===p.strategy))throw new Error(`Unsupported generator strategy "${p.strategy}" for column "${col.name}".`);if("list"!==p.strategy||(p.values??[]).some(v=>""!==String(v).trim())||warnings.push(`Column "${col.name}": the list is empty, so it will be skipped (DB default applies).`),"skip"!==p.strategy&&"null"!==p.strategy||col.pk||!col.notnull||null!=col.dflt_value||warnings.push(`Column "${col.name}" is NOT NULL without a default — "${p.strategy}" rows may fail to insert.`),"fk"===p.strategy){const pool=await sampleFkValues(db,fkByColumn.get(col.name)??null);fkPools.set(col.name,pool);const refTable=fkByColumn.get(col.name)?.table??"?";pool.length||(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.`)):warnings.push(`Column "${col.name}": "${refTable}" is empty, so NULL will be inserted.`))}prepared.push({col:col,plan:p})}const rows=[],previewRows=[],uniqueSeen=new Map;for(let i=0;i<count;i++){const fields=[],previewRow={};for(const{col:col,plan:p}of prepared){if("fk"===p.strategy&&fkOmit.has(col.name)){previewRow[col.name]=null;continue}let v=(0,strategies_1.generateOne)(col,p,fkPools.get(col.name),i);if(v!==types_1.SKIP){if(uniqueCols.has(col.name)){const seen=uniqueSeen.get(col.name)??new Set;let attempts=0;for(;seen.has(stringifyKey(v))&&attempts<20;)v=(0,strategies_1.generateOne)(col,p,fkPools.get(col.name),i),attempts+=1;seen.has(stringifyKey(v))&&(warnings.push(`Column "${col.name}" is UNIQUE but the generator kept colliding — appended a suffix to keep rows insertable.`),v=uniqueSuffix(v,seen)),seen.add(stringifyKey(v)),uniqueSeen.set(col.name,seen)}fields.push({column:col.name,value:v}),previewRow[col.name]=v}else previewRow[col.name]="(default)"}applyOrdering(fields,checkInfo.ordering);for(const f of fields)previewRow[f.column]=f.value;rows.push(fields),previewRows.length<50&&previewRows.push(previewRow)}return{rows:rows,previewRows:previewRows,warnings:warnings}},exports.buildSeedInsertSql=function(table,rows){return rows.map(fields=>{const cols=fields.map(f=>(0,generator_1.quoteIdentifier)(f.column)),vals=fields.map(f=>(0,generator_1.sqlValue)(f.value));return`INSERT INTO ${(0,generator_1.quoteIdentifier)(table)} (${cols.join(", ")}) VALUES (${vals.join(", ")});`}).join("\n")};const generator_1=require("../sql/generator"),types_1=require("./types"),detector_1=require("./detector"),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[];return((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`)).data??[]).map(row=>row.v).filter(v=>null!=v)}catch{return[]}}function stringifyKey(v){return v instanceof Uint8Array||Buffer.isBuffer(v)?`buf:${Buffer.from(v).toString("hex")}`:`${typeof v}:${String(v)}`}function uniqueSuffix(base,seen){if("number"==typeof base&&Number.isFinite(base)){let n=Number(base);for(;seen.has(stringifyKey(n));)n+=1;return n}let i=1,cand=`${String(base)}-${i}`;for(;seen.has(stringifyKey(cand));)i+=1,cand=`${String(base)}-${i}`;return cand}function orderedValue(value,base,dir,orEqual){const v=value,b=base;if("string"==typeof v&&"string"==typeof b){const tv=Date.parse(v),tb=Date.parse(b);if(Number.isFinite(tv)&&Number.isFinite(tb)){if("after"===dir){if(orEqual?tv<tb:tv<=tb)return new Date(tb+1e3).toISOString()}else if(orEqual?tv>tb:tv>=tb)return new Date(tb-1e3).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`),db=Date.parse(`${b}T00:00:00Z`);if("after"===dir){if(orEqual?dv<db:dv<=db)return new Date(db+864e5).toISOString().slice(0,10)}else if(orEqual?dv>db:dv>=db)return new Date(db-864e5).toISOString().slice(0,10);return v}}return"number"==typeof v&&"number"==typeof b?"after"===dir?orEqual?Math.max(v,b):Math.max(v,b+1):orEqual?Math.min(v,b):Math.min(v,b-1):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){if(rel.after&&null!=f.value){const other=byCol.get(rel.after.column);other&&null!=other.value&&(f.value=orderedValue(f.value,other.value,"after",rel.after.orEqual))}if(rel.before&&null!=f.value){const other=byCol.get(rel.before.column);other&&null!=other.value&&(f.value=orderedValue(f.value,other.value,"before",rel.before.orEqual))}}}}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeedEngine = void 0;
+exports.buildSeedInsertSql = buildSeedInsertSql;
+exports.buildChainInsertSql = buildChainInsertSql;
+exports.generateRows = generateRows;
+const generator_1 = require("../sql/generator");
+const detector_1 = require("./detector");
+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;
+    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;
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    if (len.exact != null) {
+        if (v.length > len.exact)
+            v = v.slice(0, 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)
+        v = v.slice(0, len.max);
+    if (len.min != null && v.length < len.min) {
+        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);
+        }
+    }
+}
+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);
+            }
+        }
+        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}`);
+        }
+        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 (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;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        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';
+                }
+                catch {
+                    mode = 'generate';
+                }
+            }
+            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 (!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 { }
+                }
+            }
+            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 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;
+        }
+        const sql = buildChainInsertSql(executionOrder, tableResults);
+        return {
+            rootTable: plan.rootTable,
+            scope: plan.scope,
+            executionOrder,
+            tableResults,
+            totalRows,
+            sql,
+            warnings,
+            validation,
+        };
+    }
+}
+exports.SeedEngine = SeedEngine;
+function buildSeedInsertSql(table, rows) {
+    return rows
+        .map((fields) => {
+        const cols = fields.map((f) => (0, generator_1.quoteIdentifier)(f.column));
+        const vals = fields.map((f) => (0, generator_1.sqlValue)(f.value));
+        return `INSERT INTO ${(0, generator_1.quoteIdentifier)(table)} (${cols.join(', ')}) VALUES (${vals.join(', ')});`;
+    })
+        .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],
+    };
+}

package/dist/data/index.d.ts

@@ -1 +1 @@
-export * from './types';export * from './datasets';export * from './strategies';export * from './detector';export * from './engine';
+export * from './types';export * from './datasets';export * from './prng';export{GeneratorRegistry,generateColumnValue,type GeneratorDefinition,type GeneratorFn,type GeneratorContext} from './registry';export * from './templates';export * from './schema-graph';export * from './validator';export * from './strategies';export * from './detector';export * from './engine';export * from './chain';

package/dist/data/index.js

@@ -1 +1,30 @@
-var __createBinding=this&&this.__createBinding||(Object.create?function(o,m,k,k2){void 0===k2&&(k2=k);var desc=Object.getOwnPropertyDescriptor(m,k);desc&&!("get"in desc?!m.__esModule:desc.writable||desc.configurable)||(desc={enumerable:!0,get:function(){return m[k]}}),Object.defineProperty(o,k2,desc)}:function(o,m,k,k2){void 0===k2&&(k2=k),o[k2]=m[k]}),__exportStar=this&&this.__exportStar||function(m,exports){for(var p in m)"default"===p||Object.prototype.hasOwnProperty.call(exports,p)||__createBinding(exports,m,p)};Object.defineProperty(exports,"__esModule",{value:!0}),__exportStar(require("./types"),exports),__exportStar(require("./datasets"),exports),__exportStar(require("./strategies"),exports),__exportStar(require("./detector"),exports),__exportStar(require("./engine"),exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateColumnValue = exports.GeneratorRegistry = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./datasets"), exports);
+__exportStar(require("./prng"), exports);
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "GeneratorRegistry", { enumerable: true, get: function () { return registry_1.GeneratorRegistry; } });
+Object.defineProperty(exports, "generateColumnValue", { enumerable: true, get: function () { return registry_1.generateColumnValue; } });
+__exportStar(require("./templates"), exports);
+__exportStar(require("./schema-graph"), exports);
+__exportStar(require("./validator"), exports);
+__exportStar(require("./strategies"), exports);
+__exportStar(require("./detector"), exports);
+__exportStar(require("./engine"), exports);
+__exportStar(require("./chain"), exports);

package/dist/data/prng.d.ts

@@ -0,0 +1 @@
+export interface RandomSource{next():number;int(min:number,max:number):number;float(min:number,max:number):number;pick<T>(arr:readonly T[]):T;pickMany<T>(arr:readonly T[],count:number,unique?:boolean):T[];shuffle<T>(arr:T[]):T[];weightedPick<T>(items:readonly T[],weights:readonly number[]):T;chance(pct:number):boolean;}export declare function createPrng(seed?:number|null):RandomSource;