admindb 2.4.1 → 2.6.0

package/dist/modules/seed/seed.routes.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSeedRoutes = registerSeedRoutes;
+const router_1 = require("../../core/router");
+const tables_service_1 = require("../tables/tables.service");
+const rows_service_1 = require("../rows/rows.service");
+const index_1 = require("../../data/index");
+const seed_service_1 = require("./seed.service");
+function registerSeedRoutes(router, ctx) {
+    router.get('/seed/:db', async (req, res, next) => {
+        try {
+            const db = ctx.getContext(req);
+            const dbId = req.params.db;
+            res.locals.dbId = dbId;
+            const tablesList = await tables_service_1.TableService.listTables(db);
+            const allNames = tablesList.map((t) => t.name);
+            const { tables: tableNames } = (0, router_1.initPageLocals)(res, db, dbId, allNames);
+            if (tableNames.length === 0) {
+                return res.render('pages/seed-select', {
+                    title: 'Seed Data Generator',
+                    dbId,
+                    tables: tableNames,
+                    seedTables: [],
+                    hasTables: false,
+                    dialect: db.dialect.name,
+                });
+            }
+            const tableStats = await Promise.all(tableNames.map(async (name) => {
+                const [info, rowCount] = await Promise.all([
+                    tables_service_1.TableService.getTableInfo(db, name),
+                    rows_service_1.RowsService.getRowCount(db, name),
+                ]);
+                const cols = info ? info.columns.length : 0;
+                const fks = info ? info.foreignKeys.length : 0;
+                return {
+                    name,
+                    cols,
+                    fks,
+                    rowCount,
+                };
+            }));
+            const defaultTable = req.query.table ? String(req.query.table) : tableStats[0]?.name;
+            const defaultMode = req.query.mode === 'chain' ? 'chain' : 'single';
+            res.render('pages/seed-select', {
+                title: 'Seed Data Generator · Choose Table & Mode',
+                dbId,
+                tables: tableNames,
+                seedTables: tableStats,
+                hasTables: true,
+                defaultTable,
+                defaultMode,
+                dialect: db.dialect.name,
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.get('/seed/:db/:table', async (req, res, next) => {
+        try {
+            const db = ctx.getContext(req);
+            const dbId = req.params.db;
+            const table = req.params.table;
+            res.locals.dbId = dbId;
+            const tablesList = await tables_service_1.TableService.listTables(db);
+            const allNames = tablesList.map((t) => t.name);
+            const { tables: allTables } = (0, router_1.initPageLocals)(res, db, dbId, allNames);
+            const initialMode = req.query.mode === 'chain' ? 'chain' : 'single';
+            const [info, rowCount] = await Promise.all([
+                tables_service_1.TableService.getTableInfo(db, table),
+                rows_service_1.RowsService.getRowCount(db, table),
+            ]);
+            if (!info) {
+                return (0, router_1.notFound)(res, `Table "${table}" does not exist.`);
+            }
+            const columns = (0, index_1.buildColumnConfigs)(info);
+            res.locals.currentTable = table;
+            res.render('pages/seed', {
+                title: `Seed data · ${table}`,
+                dbId,
+                table,
+                allTables,
+                mode: initialMode,
+                isChainMode: initialMode === 'chain',
+                rowCount,
+                colCount: info.columns.length,
+                maxRows: index_1.MAX_SEED_ROWS,
+                quickCounts: [10, 50, 100, 500, 1000, index_1.MAX_SEED_ROWS],
+                seedConfig: { dbId, table, columns, rowCount, maxRows: index_1.MAX_SEED_ROWS, mode: initialMode },
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.post('/api/seed/:db/validate', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        (0, router_1.ok)(res, await seed_service_1.SeedService.validatePlan(db, (0, seed_service_1.parseUnifiedGenerationPlan)(req.body)));
+    }));
+    router.post('/api/seed/:db/preview', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        (0, router_1.ok)(res, await seed_service_1.SeedService.previewPlan(db, (0, seed_service_1.parseUnifiedGenerationPlan)(req.body)));
+    }));
+    router.post('/api/seed/:db/generate', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        (0, router_1.ok)(res, await seed_service_1.SeedService.generatePlan(db, (0, seed_service_1.parseUnifiedGenerationPlan)(req.body)));
+    }));
+    router.post('/api/seed/:db/execute', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const plan = (0, seed_service_1.parseUnifiedGenerationPlan)(req.body);
+        const truncate = Boolean(req.body?.truncate || plan.options?.truncateAll);
+        const result = await seed_service_1.SeedService.executePlan(db, plan, truncate);
+        (0, router_1.ok)(res, result, 201);
+    }));
+    const getSeedConfigHandler = (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const info = await tables_service_1.TableService.getTableInfo(db, req.params.table);
+        if (!info)
+            return (0, router_1.fail)(res, `Table "${req.params.table}" does not exist.`, 404);
+        (0, router_1.ok)(res, seed_service_1.SeedService.getSingleTableSeedConfig(info));
+    });
+    router.get('/api/tables/:db/:table/seed/config', getSeedConfigHandler);
+    router.get('/api/tables/:db/:table/seed/plan', getSeedConfigHandler);
+    router.post('/api/tables/:db/:table/seed/generate', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const info = await tables_service_1.TableService.getTableInfo(db, req.params.table);
+        if (!info)
+            return (0, router_1.fail)(res, `Table "${req.params.table}" does not exist.`, 404);
+        const { count, plan } = (0, seed_service_1.parseSeedRequest)(req.body);
+        (0, router_1.ok)(res, await seed_service_1.SeedService.generateSingleTable(db, info, count, plan));
+    }));
+    router.post('/api/tables/:db/:table/seed/preview', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const info = await tables_service_1.TableService.getTableInfo(db, req.params.table);
+        if (!info)
+            return (0, router_1.fail)(res, `Table "${req.params.table}" does not exist.`, 404);
+        const { count, plan } = (0, seed_service_1.parseSeedRequest)(req.body);
+        (0, router_1.ok)(res, await seed_service_1.SeedService.previewSingleTable(db, info, count, plan));
+    }));
+    router.post('/api/tables/:db/:table/seed', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const info = await tables_service_1.TableService.getTableInfo(db, req.params.table);
+        if (!info)
+            return (0, router_1.fail)(res, `Table "${req.params.table}" does not exist.`, 404);
+        const { count, plan, truncate } = (0, seed_service_1.parseSeedRequest)(req.body);
+        try {
+            const result = await seed_service_1.SeedService.seedSingleTable(db, req.params.table, info, count, plan, truncate);
+            (0, router_1.ok)(res, result, 201);
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Seed failed.', 400);
+        }
+    }));
+    router.get('/api/tables/:db/:table/seed/chain', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const info = await tables_service_1.TableService.getTableInfo(db, req.params.table);
+        if (!info)
+            return (0, router_1.fail)(res, `Table "${req.params.table}" does not exist.`, 404);
+        const rawScope = String(req.query.scope ?? 'chain');
+        const scope = rawScope === 'ancestors' || rawScope === 'descendants' || rawScope === 'all' || rawScope === 'single'
+            ? rawScope
+            : 'chain';
+        (0, router_1.ok)(res, await seed_service_1.SeedService.getChainConfig(db, req.params.table, scope));
+    }));
+    router.post('/api/tables/:db/:table/seed/chain/preview', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const info = await tables_service_1.TableService.getTableInfo(db, req.params.table);
+        if (!info)
+            return (0, router_1.fail)(res, `Table "${req.params.table}" does not exist.`, 404);
+        const { scope, counts, plans, modes, seed } = (0, seed_service_1.parseChainSeedRequest)(req.body);
+        (0, router_1.ok)(res, await seed_service_1.SeedService.previewChain(db, req.params.table, scope, counts, plans, modes, seed));
+    }));
+    router.post('/api/tables/:db/:table/seed/chain/generate', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const info = await tables_service_1.TableService.getTableInfo(db, req.params.table);
+        if (!info)
+            return (0, router_1.fail)(res, `Table "${req.params.table}" does not exist.`, 404);
+        const { scope, counts, plans, modes, seed } = (0, seed_service_1.parseChainSeedRequest)(req.body);
+        (0, router_1.ok)(res, await seed_service_1.SeedService.generateChain(db, req.params.table, scope, counts, plans, modes, seed));
+    }));
+    router.post('/api/tables/:db/:table/seed/chain', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const info = await tables_service_1.TableService.getTableInfo(db, req.params.table);
+        if (!info)
+            return (0, router_1.fail)(res, `Table "${req.params.table}" does not exist.`, 404);
+        const { scope, counts, plans, truncate, modes, seed } = (0, seed_service_1.parseChainSeedRequest)(req.body);
+        const result = await seed_service_1.SeedService.executeChain(db, req.params.table, scope, counts, plans, truncate, modes, seed);
+        (0, router_1.ok)(res, result, 201);
+    }));
+    router.get('/api/seed/:db/chain', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const rawRoot = String(req.query.table ?? '');
+        const rawScope = String(req.query.scope ?? (rawRoot ? 'chain' : 'all'));
+        const scope = rawScope === 'ancestors' || rawScope === 'descendants' || rawScope === 'all' || rawScope === 'single'
+            ? rawScope
+            : 'all';
+        const rootTable = rawRoot || (await db.db.listTables()).data?.[0]?.name || '';
+        if (!rootTable)
+            return (0, router_1.fail)(res, 'No tables found in database.', 404);
+        (0, router_1.ok)(res, await seed_service_1.SeedService.getChainConfig(db, rootTable, scope));
+    }));
+    router.post('/api/seed/:db/chain', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const { scope, counts, plans, truncate, modes, seed } = (0, seed_service_1.parseChainSeedRequest)(req.body);
+        const rawRoot = String(req.body?.rootTable ?? '');
+        const rootTable = rawRoot || (await db.db.listTables()).data?.[0]?.name || '';
+        if (!rootTable)
+            return (0, router_1.fail)(res, 'No tables found in database.', 404);
+        const result = await seed_service_1.SeedService.executeChain(db, rootTable, scope, counts, plans, truncate, modes, seed);
+        (0, router_1.ok)(res, result, 201);
+    }));
+}

package/dist/modules/seed/seed.service.d.ts

@@ -0,0 +1 @@
+import type {TableInfoData} from '../../db/index';import type {DatabaseContext} from '../../core/context';import{type ColumnPlan,type ErChainScope,type GenerationPlan,type TableGenerationMode} from '../../data/index';export declare function parseSeedRequest(body:unknown):{count:number;plan:Record<string,ColumnPlan>;truncate:boolean;seed?:number|null;};export declare function parseChainSeedRequest(body:unknown):{scope:ErChainScope;counts:Record<string,number>;plans:Record<string,Record<string,ColumnPlan>>;truncate:boolean;modes?:Record<string,TableGenerationMode>;seed?:number|null;};export declare function parseUnifiedGenerationPlan(body:unknown):GenerationPlan;export declare class SeedService{static validatePlan(ctx:DatabaseContext,plan:GenerationPlan):Promise<import("../../data/types").ValidationReport>;static previewPlan(ctx:DatabaseContext,plan:GenerationPlan):Promise<import("../../data/types").ErChainResult>;static generatePlan(ctx:DatabaseContext,plan:GenerationPlan):Promise<import("../../data/types").ErChainResult>;static executePlan(ctx:DatabaseContext,plan:GenerationPlan,truncate?:boolean):Promise<{message:string;inserted:Record<string,number>;totalInserted:number;elapsedMs:number;warnings:string[];}>;static getSingleTableSeedConfig(info:TableInfoData):{table:string;columns:import("../../data/types").ColumnGeneratorConfig[];maxRows:number;};static previewSingleTable(ctx:DatabaseContext,info:TableInfoData,count:number,plan:Record<string,ColumnPlan>):Promise<{table:string;previewRows:Record<string,unknown>[];warnings:string[];}>;static generateSingleTable(ctx:DatabaseContext,info:TableInfoData,count:number,plan:Record<string,ColumnPlan>):Promise<{table:string;count:number;sql:string;previewRows:Record<string,unknown>[];warnings:string[];}>;static seedSingleTable(ctx:DatabaseContext,table:string,info:TableInfoData,count:number,plan:Record<string,ColumnPlan>,truncate:boolean):Promise<{message:string;inserted:number;skipped:number;warnings:string[];elapsedMs:number;}>;static getChainConfig(ctx:DatabaseContext,table:string,scope:ErChainScope):Promise<import("../../data/types").ErChainConfig>;static previewChain(ctx:DatabaseContext,table:string,scope:ErChainScope,counts:Record<string,number>,plans:Record<string,Record<string,ColumnPlan>>,modes?:Record<string,TableGenerationMode>,seed?:number|null):Promise<import("../../data/types").ErChainResult>;static generateChain(ctx:DatabaseContext,table:string,scope:ErChainScope,counts:Record<string,number>,plans:Record<string,Record<string,ColumnPlan>>,modes?:Record<string,TableGenerationMode>,seed?:number|null):Promise<import("../../data/types").ErChainResult>;static executeChain(ctx:DatabaseContext,table:string,scope:ErChainScope,counts:Record<string,number>,plans:Record<string,Record<string,ColumnPlan>>,truncate:boolean,modes?:Record<string,TableGenerationMode>,seed?:number|null):Promise<{message:string;inserted:Record<string,number>;totalInserted:number;elapsedMs:number;warnings:string[];}>;}

package/dist/{routes/api/helpers.js → modules/seed/seed.service.js}

@@ -1,74 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_BULK_ROWS = exports.wrap = exports.fail = exports.ok = void 0;
-exports.requireTable = requireTable;
-exports.buildFields = buildFields;
-exports.buildUpdateFields = buildUpdateFields;
-exports.pkWhere = pkWhere;
+exports.SeedService = void 0;
 exports.parseSeedRequest = parseSeedRequest;
 exports.parseChainSeedRequest = parseChainSeedRequest;
 exports.parseUnifiedGenerationPlan = parseUnifiedGenerationPlan;
-exports.resolvePkRows = resolvePkRows;
-exports.computeBulkImpact = computeBulkImpact;
-const common_1 = require("../../utils/common");
-const index_1 = require("../../data/index");
 const generator_1 = require("../../sql/generator");
-const ok = (res, data, status = 200) => res.status(status).json({ success: true, data });
-exports.ok = ok;
-const fail = (res, error, status = 400, details) => res.status(status).json({ success: false, error, ...(details ? { details } : {}) });
-exports.fail = fail;
-const wrap = (fn) => async (req, res) => {
-    try {
-        await fn(req, res);
-    }
-    catch (err) {
-        (0, exports.fail)(res, (0, common_1.errorMessage)(err), 500);
-    }
-};
-exports.wrap = wrap;
-async function requireTable(db, table) {
-    const info = await db.getTableInfo(table);
-    return info.success && info.data?.columns?.length ? info.data : null;
-}
-function buildFields(info, values, opts = {}) {
-    const typeMap = new Map(info.columns.map((c) => [c.name, c.type]));
-    const pkSet = new Set(info.primaryKey);
-    const fields = [];
-    for (const [col, raw] of Object.entries(values ?? {})) {
-        if (!typeMap.has(col) || (opts.excludePk && pkSet.has(col)))
-            continue;
-        const val = (0, common_1.coerceFormValue)(raw, typeMap.get(col));
-        if (val !== null)
-            fields.push({ column: col, value: val });
-    }
-    return fields;
-}
-function buildUpdateFields(info, values, nulls) {
-    const fields = buildFields(info, values, { excludePk: true });
-    const typeMap = new Map(info.columns.map((c) => [c.name, c.type]));
-    const pkSet = new Set(info.primaryKey);
-    for (const col of nulls) {
-        if (!pkSet.has(col) && typeMap.has(col) && !fields.some((f) => f.column === col)) {
-            fields.push({ column: col, value: null });
-        }
-    }
-    return fields;
-}
-function pkWhere(info, encodedId) {
-    const vals = (0, common_1.decodePk)(encodedId);
-    if (!info.primaryKey.length) {
-        if (vals.length === 1 && vals[0] !== '') {
-            const num = Number(vals[0]);
-            return [{ column: '_rowid_', value: Number.isFinite(num) ? num : vals[0] }];
-        }
-        return null;
-    }
-    if (vals.length !== info.primaryKey.length)
-        return null;
-    const typeMap = new Map(info.columns.map((c) => [c.name, c.type]));
-    return info.primaryKey.map((col, i) => ({ column: col, value: (0, common_1.coerceFormValue)(vals[i], typeMap.get(col)) }));
-}
-exports.MAX_BULK_ROWS = 1000;
+const index_1 = require("../../data/index");
 function parseSeedRequest(body) {
     const b = (body ?? {});
     const count = Math.max(1, Math.min(index_1.MAX_SEED_ROWS, Number.parseInt(String(b.count ?? '10'), 10) || 10));
@@ -144,12 +81,7 @@ function parseUnifiedGenerationPlan(body) {
                         columns[colName] = sanitized;
                 }
             }
-            tables[tableName] = {
-                mode,
-                rows,
-                columns,
-                truncate: Boolean(spec.truncate),
-            };
+            tables[tableName] = { mode, rows, columns, truncate: Boolean(spec.truncate) };
         }
     }
     const rawSeed = b.seed !== undefined ? b.seed : rawPlan.options?.seed;
@@ -170,44 +102,89 @@ function parseUnifiedGenerationPlan(body) {
         },
     };
 }
-function resolvePkRows(info, ids) {
-    const list = Array.isArray(ids) ? ids : ids == null ? [] : [ids];
-    const out = [];
-    for (const id of list) {
-        const where = pkWhere(info, String(id));
-        if (where)
-            out.push(where);
-    }
-    return out.length ? out : null;
-}
-async function computeBulkImpact(db, info, wheres) {
-    const [rowsR, refInfoR] = await Promise.all([
-        db.getRowsByPks(info.table, wheres),
-        db.getReferencingTables(info.table),
-    ]);
-    const rows = (rowsR.data ?? []);
-    const referencing = refInfoR.data ?? [];
-    if (!rows.length || !referencing.length)
-        return { references: [], total: 0 };
-    const queries = referencing.flatMap((item) => item.refs.map(async (ref) => {
-        const targetCol = ref.to || info.primaryKey[0];
-        if (!targetCol)
-            return null;
-        const values = Array.from(new Set(rows.map((r) => r[targetCol]).filter((v) => v != null)));
-        if (!values.length)
-            return null;
-        try {
-            const placeholders = values.map(() => '?').join(', ');
-            const sql = `SELECT COUNT(*) AS c FROM ${(0, generator_1.quoteIdentifier)(item.table)} WHERE ${(0, generator_1.quoteIdentifier)(ref.from)} IN (${placeholders})`;
-            const countR = await db.all(sql, values);
-            const count = countR.success && countR.data?.[0] ? Number(countR.data[0].c ?? 0) : 0;
-            return count > 0 ? { table: item.table, from: ref.from, to: targetCol, count } : null;
+class SeedService {
+    static async validatePlan(ctx, plan) {
+        return (0, index_1.validateGenerationPlan)(ctx.db, plan);
+    }
+    static async previewPlan(ctx, plan) {
+        return index_1.SeedEngine.executePlan(ctx.db, plan, { previewLimit: 50 });
+    }
+    static async generatePlan(ctx, plan) {
+        return index_1.SeedEngine.executePlan(ctx.db, plan);
+    }
+    static async executePlan(ctx, plan, truncate = false) {
+        const gen = await index_1.SeedEngine.executePlan(ctx.db, plan, { truncateAll: truncate });
+        const exec = await (0, index_1.executeChainInsert)(ctx.db, gen, truncate);
+        return {
+            message: `${truncate ? 'Cleared tables and seeded' : 'Seeded'} ${exec.totalInserted} row(s) across ${Object.keys(exec.inserted).length} table(s) in ${exec.elapsedMs}ms.`,
+            inserted: exec.inserted,
+            totalInserted: exec.totalInserted,
+            elapsedMs: exec.elapsedMs,
+            warnings: exec.warnings,
+        };
+    }
+    static getSingleTableSeedConfig(info) {
+        return { table: info.table, columns: (0, index_1.buildColumnConfigs)(info), maxRows: index_1.MAX_SEED_ROWS };
+    }
+    static async previewSingleTable(ctx, info, count, plan) {
+        const configs = (0, index_1.buildColumnConfigs)(info);
+        const gen = await (0, index_1.generateRows)(ctx.db, info, configs, Math.min(50, count), plan);
+        return { table: info.table, previewRows: gen.previewRows, warnings: gen.warnings };
+    }
+    static async generateSingleTable(ctx, info, count, plan) {
+        const configs = (0, index_1.buildColumnConfigs)(info);
+        const gen = await (0, index_1.generateRows)(ctx.db, info, configs, count, plan);
+        return { table: info.table, count: gen.rows.length, sql: (0, index_1.buildSeedInsertSql)(info.table, gen.rows), previewRows: gen.previewRows, warnings: gen.warnings };
+    }
+    static async seedSingleTable(ctx, table, info, count, plan, truncate) {
+        const { db } = ctx;
+        const configs = (0, index_1.buildColumnConfigs)(info);
+        const t0 = Date.now();
+        if (truncate) {
+            const clearRes = await db.run(`DELETE FROM ${(0, generator_1.quoteIdentifier)(table)}`);
+            if (!clearRes.success) {
+                throw new Error(clearRes.error ?? 'Failed to clear table before seeding.');
+            }
         }
-        catch {
-            return null;
+        const gen = await (0, index_1.generateRows)(db, info, configs, count, plan, truncate);
+        const result = await db.insertRows(table, gen.rows);
+        if (!result.success)
+            throw new Error(result.error ?? 'Seed failed.');
+        const elapsedMs = Date.now() - t0;
+        return {
+            message: `${truncate ? 'Cleared table and inserted' : 'Inserted'} ${result.data?.inserted ?? 0} row(s) in ${elapsedMs}ms.`,
+            inserted: result.data?.inserted ?? 0,
+            skipped: result.data?.skipped ?? 0,
+            warnings: gen.warnings,
+            elapsedMs,
+        };
+    }
+    static async getChainConfig(ctx, table, scope) {
+        return (0, index_1.getErChainConfig)(ctx.db, table, scope);
+    }
+    static async previewChain(ctx, table, scope, counts, plans, modes, seed) {
+        const config = await (0, index_1.getErChainConfig)(ctx.db, table, scope);
+        const previewCounts = {};
+        for (const t of config.tables) {
+            previewCounts[t.name] = Math.min(50, counts[t.name] ?? t.suggestedCount ?? 10);
         }
-    }));
-    const results = (await Promise.all(queries)).filter((r) => r !== null);
-    const total = results.reduce((acc, r) => acc + r.count, 0);
-    return { references: results, total };
+        return (0, index_1.generateChainRows)(ctx.db, config, plans, previewCounts, false, modes, seed);
+    }
+    static async generateChain(ctx, table, scope, counts, plans, modes, seed) {
+        const config = await (0, index_1.getErChainConfig)(ctx.db, table, scope);
+        return (0, index_1.generateChainRows)(ctx.db, config, plans, counts, false, modes, seed);
+    }
+    static async executeChain(ctx, table, scope, counts, plans, truncate, modes, seed) {
+        const config = await (0, index_1.getErChainConfig)(ctx.db, table, scope);
+        const gen = await (0, index_1.generateChainRows)(ctx.db, config, plans, counts, truncate, modes, seed);
+        const exec = await (0, index_1.executeChainInsert)(ctx.db, gen, truncate);
+        return {
+            message: `${truncate ? 'Cleared tables in reverse order and seeded' : 'Seeded'} ${exec.totalInserted} row(s) across ${Object.keys(exec.inserted).length} table(s) in ${exec.elapsedMs}ms.`,
+            inserted: exec.inserted,
+            totalInserted: exec.totalInserted,
+            elapsedMs: exec.elapsedMs,
+            warnings: exec.warnings,
+        };
+    }
 }
+exports.SeedService = SeedService;

package/dist/modules/sync/index.d.ts

@@ -0,0 +1 @@
+export * from './sync.service';export * from './sync.routes';

package/dist/modules/sync/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./sync.service"), exports);
+__exportStar(require("./sync.routes"), exports);

package/dist/modules/sync/sync.routes.d.ts

@@ -0,0 +1 @@
+import type {Router} from 'express';import{type RouteContext} from '../../core/router';export declare function registerSyncRoutes(router:Router,ctx:RouteContext):void;

package/dist/modules/sync/sync.routes.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSyncRoutes = registerSyncRoutes;
+const router_1 = require("../../core/router");
+const tables_service_1 = require("../tables/tables.service");
+const sync_service_1 = require("./sync.service");
+function registerSyncRoutes(router, ctx) {
+    const getDb = (dbId, readonly = false) => {
+        if (ctx.getNamedContext) {
+            return ctx.getNamedContext(dbId, readonly);
+        }
+        return ctx.getContext({ params: { db: dbId } });
+    };
+    const renderSyncPage = async (req, res, next) => {
+        try {
+            const activeDbId = req.params.db || res.locals.dbId || '';
+            let currentCtx = null;
+            let allNames = [];
+            try {
+                if (activeDbId) {
+                    currentCtx = getDb(activeDbId);
+                    const tablesList = await tables_service_1.TableService.listTables(currentCtx);
+                    allNames = tablesList.map((t) => t.name);
+                    (0, router_1.initPageLocals)(res, currentCtx, activeDbId, allNames);
+                }
+            }
+            catch { }
+            const databases = sync_service_1.SyncService.listAvailableDatabases(ctx.manager, currentCtx
+                ? {
+                    id: currentCtx.id,
+                    name: currentCtx.name,
+                    dialect: currentCtx.dialect.name,
+                    path: currentCtx.path,
+                    readonly: currentCtx.isReadOnly,
+                }
+                : undefined);
+            res.render('pages/sync', {
+                title: 'Diff & Replication Studio',
+                dbId: activeDbId,
+                databases,
+                tables: allNames,
+                isSqlite: currentCtx?.dialect.name === 'sqlite',
+                isPostgres: currentCtx?.dialect.name === 'postgres',
+                readonly: currentCtx ? currentCtx.isReadOnly : false,
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    };
+    router.get('/diff', renderSyncPage);
+    router.get('/diff/:db', renderSyncPage);
+    router.get('/sync', renderSyncPage);
+    router.get('/sync/:db', renderSyncPage);
+    router.get('/api/sync/databases', (0, router_1.wrap)(async (_req, res) => {
+        const databases = sync_service_1.SyncService.listAvailableDatabases(ctx.manager);
+        (0, router_1.ok)(res, databases);
+    }));
+    router.post('/api/sync/diff/schema', (0, router_1.wrap)(async (req, res) => {
+        const { sourceDbId, targetDbId } = req.body || {};
+        if (!sourceDbId || !targetDbId) {
+            return (0, router_1.fail)(res, 'Both sourceDbId and targetDbId are required.');
+        }
+        const srcCtx = getDb(sourceDbId, true);
+        const tgtCtx = getDb(targetDbId, true);
+        const diff = await sync_service_1.SyncService.diffSchema(srcCtx.db, sourceDbId, tgtCtx.db, targetDbId);
+        (0, router_1.ok)(res, diff);
+    }));
+    router.post('/api/sync/diff/data', (0, router_1.wrap)(async (req, res) => {
+        const { sourceDbId, targetDbId, table, limit } = req.body || {};
+        if (!sourceDbId || !targetDbId || !table) {
+            return (0, router_1.fail)(res, 'sourceDbId, targetDbId, and table are required.');
+        }
+        const srcCtx = getDb(sourceDbId, true);
+        const tgtCtx = getDb(targetDbId, true);
+        const rowLimit = typeof limit === 'number' && limit > 0 ? Math.min(limit, 500) : 100;
+        const diff = await sync_service_1.SyncService.diffTableData(srcCtx.db, tgtCtx.db, table, rowLimit);
+        (0, router_1.ok)(res, diff);
+    }));
+    router.post('/api/sync/patch', (0, router_1.wrap)(async (req, res) => {
+        const { sourceDbId, targetDbId } = req.body || {};
+        if (!sourceDbId || !targetDbId) {
+            return (0, router_1.fail)(res, 'Both sourceDbId and targetDbId are required.');
+        }
+        const srcCtx = getDb(sourceDbId, true);
+        const tgtCtx = getDb(targetDbId, true);
+        const diff = await sync_service_1.SyncService.diffSchema(srcCtx.db, sourceDbId, tgtCtx.db, targetDbId);
+        const targetDialect = tgtCtx.dialect.name === 'postgres' ? 'postgres' : 'sqlite';
+        const patch = sync_service_1.SyncService.generatePatch(diff, targetDialect);
+        (0, router_1.ok)(res, patch);
+    }));
+    router.post('/api/sync/dry-run', (0, router_1.wrap)(async (req, res) => {
+        const { sourceDbId, targetDbId, mode, tables, maskData } = req.body || {};
+        if (!sourceDbId || !targetDbId) {
+            return (0, router_1.fail)(res, 'Both sourceDbId and targetDbId are required.');
+        }
+        const srcCtx = getDb(sourceDbId, true);
+        const tgtCtx = getDb(targetDbId, true);
+        const result = await sync_service_1.SyncService.replicate(srcCtx.db, sourceDbId, tgtCtx.db, targetDbId, {
+            mode,
+            tables,
+            maskData,
+            dryRun: true,
+        });
+        (0, router_1.ok)(res, result);
+    }));
+    router.post('/api/sync/execute', (0, router_1.wrap)(async (req, res) => {
+        const { sourceDbId, targetDbId, mode, tables, maskData, confirmTargetName } = req.body || {};
+        if (!sourceDbId || !targetDbId) {
+            return (0, router_1.fail)(res, 'Both sourceDbId and targetDbId are required.');
+        }
+        if (sourceDbId === targetDbId) {
+            return (0, router_1.fail)(res, 'Source and target database cannot be the same.');
+        }
+        const srcCtx = getDb(sourceDbId, true);
+        const tgtCtx = getDb(targetDbId, false);
+        if (tgtCtx.isReadOnly) {
+            return (0, router_1.fail)(res, `Target database "${targetDbId}" is in read-only mode and cannot be modified.`);
+        }
+        const isTargetProd = targetDbId.toLowerCase().includes('prod') || targetDbId.toLowerCase().includes('production');
+        if (isTargetProd && confirmTargetName !== targetDbId) {
+            return (0, router_1.fail)(res, `Target database appears to be PRODUCTION (${targetDbId}). You must type the target database name to confirm.`, 400, { requiresConfirmation: true, targetDbId });
+        }
+        const result = await sync_service_1.SyncService.replicate(srcCtx.db, sourceDbId, tgtCtx.db, targetDbId, {
+            mode,
+            tables,
+            maskData,
+            dryRun: false,
+        });
+        if (!result.success) {
+            return (0, router_1.fail)(res, result.error || 'Replication failed.', 500, { result });
+        }
+        (0, router_1.ok)(res, result);
+    }));
+}

package/dist/modules/sync/sync.service.d.ts

@@ -0,0 +1 @@
+import type {IDatabase} from '../../db/types';import type {DbManager,DatabaseEntry} from '../../db/manager';import{type SchemaDiffResult} from '../../core/diff/schema-differ';import{type TableDataDiffResult} from '../../core/diff/data-differ';import{type GeneratedPatch} from '../../core/diff/patch-generator';import{type SyncOptions,type SyncResult} from '../../core/transfer/sync-engine';import type {SupportedDialect} from '../../core/transfer/dialect-mapper';export declare class SyncService{static listAvailableDatabases(manager?:DbManager,defaultDb?:{id:string;name:string;dialect:string;path:string;readonly :boolean;}):DatabaseEntry[];static diffSchema(sourceDb:IDatabase,sourceDbId:string,targetDb:IDatabase,targetDbId:string):Promise<SchemaDiffResult>;static diffTableData(sourceDb:IDatabase,targetDb:IDatabase,table:string,limit?:number):Promise<TableDataDiffResult>;static generatePatch(diff:SchemaDiffResult,targetDialect:SupportedDialect):GeneratedPatch;static replicate(sourceDb:IDatabase,sourceDbId:string,targetDb:IDatabase,targetDbId:string,options:SyncOptions):Promise<SyncResult>;}

package/dist/modules/sync/sync.service.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncService = void 0;
+const schema_differ_1 = require("../../core/diff/schema-differ");
+const data_differ_1 = require("../../core/diff/data-differ");
+const patch_generator_1 = require("../../core/diff/patch-generator");
+const sync_engine_1 = require("../../core/transfer/sync-engine");
+class SyncService {
+    static listAvailableDatabases(manager, defaultDb) {
+        if (manager) {
+            return manager.list();
+        }
+        if (defaultDb) {
+            return [
+                {
+                    id: defaultDb.id,
+                    name: defaultDb.name,
+                    path: defaultDb.path,
+                    dialect: defaultDb.dialect === 'postgres' ? 'postgres' : 'sqlite',
+                    size: 0,
+                    modified: '',
+                    readonly: defaultDb.readonly,
+                },
+            ];
+        }
+        return [];
+    }
+    static async diffSchema(sourceDb, sourceDbId, targetDb, targetDbId) {
+        return (0, schema_differ_1.compareSchemas)(sourceDb, sourceDbId, targetDb, targetDbId);
+    }
+    static async diffTableData(sourceDb, targetDb, table, limit = 200) {
+        return (0, data_differ_1.compareTableData)(sourceDb, targetDb, table, limit);
+    }
+    static generatePatch(diff, targetDialect) {
+        return (0, patch_generator_1.generateSchemaPatch)(diff, targetDialect);
+    }
+    static async replicate(sourceDb, sourceDbId, targetDb, targetDbId, options) {
+        return (0, sync_engine_1.executeSync)(sourceDb, sourceDbId, targetDb, targetDbId, options);
+    }
+}
+exports.SyncService = SyncService;

package/dist/modules/tables/index.d.ts

@@ -0,0 +1 @@
+export * from './tables.service';export * from './tables.routes';