admindb 2.5.0 → 2.6.2

package/dist/modules/search/search.service.js

@@ -0,0 +1,458 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchService = void 0;
+const generator_1 = require("../../sql/generator");
+class SearchService {
+    static getCommands(dbId, basePath = '', isReadOnly = false) {
+        const encDb = encodeURIComponent(dbId);
+        const commands = [
+            {
+                id: 'cmd-query',
+                title: 'New SQL Query',
+                description: 'Open the SQL query editor to run queries and scripts',
+                icon: 'query',
+                url: `${basePath}/query/${encDb}`,
+                keywords: ['sql', 'query', 'editor', 'execute', 'run', 'select', 'terminal'],
+            },
+            {
+                id: 'cmd-erd',
+                title: 'Entity Relationship Diagram',
+                description: 'Visualize database tables, relationships, and schema graph',
+                icon: 'diagram',
+                url: `${basePath}/erd/${encDb}`,
+                keywords: ['erd', 'diagram', 'graph', 'schema', 'relations', 'visualize', 'foreign keys'],
+            },
+            {
+                id: 'cmd-seed',
+                title: 'Seed Data Generator',
+                description: 'Generate relational mock and seed data with intelligent heuristics',
+                icon: 'seed',
+                url: `${basePath}/seed/${encDb}`,
+                keywords: ['seed', 'mock', 'fake data', 'generator', 'faker', 'synthetic data'],
+            },
+            {
+                id: 'cmd-diff',
+                title: 'Diff & Replicate Database',
+                description: 'Compare schemas, generate migration patches, or clone data',
+                icon: 'diff',
+                url: `${basePath}/diff/${encDb}`,
+                keywords: ['diff', 'sync', 'replicate', 'migrate', 'migration', 'patch', 'clone', 'compare'],
+            },
+            {
+                id: 'cmd-info',
+                title: 'Database Info & Settings',
+                description: 'View database pragma, engine configuration, and metadata',
+                icon: 'settings',
+                url: `${basePath}/info/${encDb}`,
+                keywords: ['info', 'settings', 'config', 'pragma', 'driver', 'version', 'database info'],
+            },
+            {
+                id: 'cmd-export',
+                title: 'Export Database (SQL Dump)',
+                description: 'Download full database schema and data as an SQL script',
+                icon: 'export',
+                url: `${basePath}/export/${encDb}`,
+                keywords: ['export', 'dump', 'backup', 'download', 'sql dump', 'save'],
+            },
+            {
+                id: 'cmd-home',
+                title: 'Database Dashboard',
+                description: 'Overview of all tables, total rows, and statistics',
+                icon: 'home',
+                url: `${basePath}/home/${encDb}`,
+                keywords: ['home', 'dashboard', 'overview', 'tables', 'stats'],
+            },
+        ];
+        if (!isReadOnly) {
+            commands.push({
+                id: 'cmd-designer',
+                title: 'Create New Table',
+                description: 'Design and create a new database table with custom columns and keys',
+                icon: 'plus',
+                url: `${basePath}/designer/${encDb}`,
+                keywords: ['create table', 'designer', 'new table', 'add table', 'schema designer'],
+            });
+        }
+        return commands;
+    }
+    static async getMetadataIndex(ctx, basePath = '') {
+        const listRes = await ctx.db.listTables();
+        const tableItems = listRes.success && listRes.data ? listRes.data : [];
+        const tables = [];
+        const columns = [];
+        const indexes = [];
+        const foreignKeys = [];
+        await Promise.all(tableItems.map(async (t) => {
+            const tableName = t.name;
+            try {
+                const infoRes = await ctx.db.getTableInfo(tableName);
+                if (!infoRes.success || !infoRes.data)
+                    return;
+                const info = infoRes.data;
+                tables.push({
+                    name: tableName,
+                    columnsCount: info.columns.length,
+                    primaryKey: info.primaryKey || [],
+                });
+                for (const col of info.columns) {
+                    const fk = (info.foreignKeys || []).find((f) => f.from === col.name);
+                    columns.push({
+                        table: tableName,
+                        name: col.name,
+                        type: col.type || 'TEXT',
+                        isPk: Boolean(col.pk),
+                        isFk: Boolean(fk),
+                        fkTarget: fk ? `${fk.table}.${fk.to || 'id'}` : null,
+                        notnull: Boolean(col.notnull),
+                        dflt_value: col.dflt_value,
+                    });
+                }
+                for (const idx of info.indexes || []) {
+                    indexes.push({
+                        table: tableName,
+                        name: idx.name,
+                        unique: Boolean(idx.unique),
+                        columns: idx.columns || [],
+                    });
+                }
+                for (const fk of info.foreignKeys || []) {
+                    foreignKeys.push({
+                        fromTable: tableName,
+                        fromColumn: fk.from,
+                        toTable: fk.table,
+                        toColumn: fk.to || null,
+                        onUpdate: fk.on_update || 'NO ACTION',
+                        onDelete: fk.on_delete || 'NO ACTION',
+                    });
+                }
+            }
+            catch {
+            }
+        }));
+        const commands = this.getCommands(ctx.name, basePath, ctx.isReadOnly || ctx.db.isReadOnly);
+        return {
+            tables,
+            columns,
+            indexes,
+            foreignKeys,
+            commands,
+        };
+    }
+    static calculateScore(target, query) {
+        if (!target || !query)
+            return 0;
+        const t = target.toLowerCase();
+        const q = query.toLowerCase();
+        if (t === q)
+            return 100;
+        if (t.startsWith(q))
+            return 85;
+        if (t.includes(`_${q}`) || t.includes(`-${q}`) || t.includes(`.${q}`) || t.includes(` ${q}`))
+            return 75;
+        if (t.includes(q))
+            return 50;
+        let qIdx = 0;
+        for (let i = 0; i < t.length && qIdx < q.length; i++) {
+            if (t[i] === q[qIdx])
+                qIdx++;
+        }
+        if (qIdx === q.length)
+            return 25;
+        return 0;
+    }
+    static async search(ctx, rawQuery, options = {}) {
+        const q = String(rawQuery ?? '').trim();
+        const basePath = options.basePath ?? '';
+        const type = options.type ? options.type.toLowerCase() : 'all';
+        const limit = options.limit && options.limit > 0 ? options.limit : 50;
+        const includeRows = options.includeRows !== false;
+        const encDb = encodeURIComponent(ctx.name);
+        const metadata = await this.getMetadataIndex(ctx, basePath);
+        const results = [];
+        const shouldSearch = (category) => {
+            if (type === 'all')
+                return true;
+            if (type === 'tables' || type === 'table')
+                return category === 'table';
+            if (type === 'columns' || type === 'column')
+                return category === 'column';
+            if (type === 'indexes' || type === 'index')
+                return category === 'index';
+            if (type === 'relations' || type === 'relation' || type === 'foreignkeys')
+                return category === 'relation';
+            if (type === 'commands' || type === 'command')
+                return category === 'command';
+            if (type === 'rows' || type === 'row' || type === 'data')
+                return category === 'row';
+            return false;
+        };
+        if (shouldSearch('table')) {
+            for (const table of metadata.tables) {
+                const score = q ? this.calculateScore(table.name, q) : 50;
+                if (score > 0 || !q) {
+                    const encTable = encodeURIComponent(table.name);
+                    results.push({
+                        id: `tbl-${table.name}`,
+                        category: 'table',
+                        title: table.name,
+                        subtitle: `Table · ${table.columnsCount} columns${table.primaryKey.length ? ` · PK (${table.primaryKey.join(', ')})` : ''}`,
+                        icon: 'table',
+                        url: `${basePath}/tables/${encDb}/${encTable}`,
+                        score: score + 15,
+                        badge: 'Table',
+                        badgeType: 'primary',
+                        actions: [
+                            { label: 'Browse', url: `${basePath}/tables/${encDb}/${encTable}`, primary: true },
+                            { label: 'Schema', url: `${basePath}/schema/${encDb}/${encTable}` },
+                            { label: 'Query', url: `${basePath}/query/${encDb}?sql=${encodeURIComponent(`SELECT * FROM ${table.name} LIMIT 100;`)}` },
+                        ],
+                        metadata: {
+                            table: table.name,
+                            columnsCount: table.columnsCount,
+                            primaryKey: table.primaryKey,
+                        },
+                    });
+                }
+            }
+        }
+        if (shouldSearch('column')) {
+            for (const col of metadata.columns) {
+                let score = 0;
+                if (q) {
+                    const nameScore = this.calculateScore(col.name, q);
+                    const fullScore = this.calculateScore(`${col.table}.${col.name}`, q);
+                    const typeScore = this.calculateScore(col.type, q) > 70 ? 40 : 0;
+                    score = Math.max(nameScore, fullScore, typeScore);
+                }
+                else {
+                    score = 30;
+                }
+                if (score > 0 || !q) {
+                    const encTable = encodeURIComponent(col.table);
+                    const pkTag = col.isPk ? ' · Primary Key' : '';
+                    const fkTag = col.isFk ? ` · FK → ${col.fkTarget}` : '';
+                    const nullTag = col.notnull ? ' · NOT NULL' : '';
+                    const dfltTag = col.dflt_value ? ` · default ${col.dflt_value}` : '';
+                    results.push({
+                        id: `col-${col.table}-${col.name}`,
+                        category: 'column',
+                        title: col.name,
+                        subtitle: `${col.table} · ${col.type}${pkTag}${fkTag}${nullTag}${dfltTag}`,
+                        icon: 'columns',
+                        url: `${basePath}/tables/${encDb}/${encTable}`,
+                        score: score + 10,
+                        badge: col.isPk ? 'PK' : col.isFk ? 'FK' : col.type,
+                        badgeType: col.isPk ? 'accent' : col.isFk ? 'info' : 'neutral',
+                        actions: [
+                            { label: 'Browse Table', url: `${basePath}/tables/${encDb}/${encTable}`, primary: true },
+                            { label: 'View Schema', url: `${basePath}/schema/${encDb}/${encTable}` },
+                        ],
+                        metadata: {
+                            table: col.table,
+                            column: col.name,
+                            type: col.type,
+                            isPk: col.isPk,
+                            isFk: col.isFk,
+                            fkTarget: col.fkTarget,
+                        },
+                    });
+                }
+            }
+        }
+        if (shouldSearch('index')) {
+            for (const idx of metadata.indexes) {
+                let score = 0;
+                if (q) {
+                    const nameScore = this.calculateScore(idx.name, q);
+                    const colsScore = idx.columns.some((c) => this.calculateScore(c, q) > 60) ? 60 : 0;
+                    score = Math.max(nameScore, colsScore);
+                }
+                else {
+                    score = 25;
+                }
+                if (score > 0 || !q) {
+                    const encTable = encodeURIComponent(idx.table);
+                    results.push({
+                        id: `idx-${idx.table}-${idx.name}`,
+                        category: 'index',
+                        title: idx.name,
+                        subtitle: `${idx.table} (${idx.columns.join(', ')}) · ${idx.unique ? 'UNIQUE ' : ''}Index`,
+                        icon: 'key',
+                        url: `${basePath}/schema/${encDb}/${encTable}`,
+                        score,
+                        badge: idx.unique ? 'Unique Index' : 'Index',
+                        badgeType: idx.unique ? 'warning' : 'neutral',
+                        actions: [
+                            { label: 'View in Schema', url: `${basePath}/schema/${encDb}/${encTable}`, primary: true },
+                            { label: 'Browse Table', url: `${basePath}/tables/${encDb}/${encTable}` },
+                        ],
+                        metadata: {
+                            table: idx.table,
+                            index: idx.name,
+                            unique: idx.unique,
+                            columns: idx.columns,
+                        },
+                    });
+                }
+            }
+        }
+        if (shouldSearch('relation')) {
+            for (const fk of metadata.foreignKeys) {
+                let score = 0;
+                if (q) {
+                    const fromScore = this.calculateScore(`${fk.fromTable}.${fk.fromColumn}`, q);
+                    const toScore = this.calculateScore(`${fk.toTable}.${fk.toColumn || 'id'}`, q);
+                    score = Math.max(fromScore, toScore);
+                }
+                else {
+                    score = 25;
+                }
+                if (score > 0 || !q) {
+                    const fromEnc = encodeURIComponent(fk.fromTable);
+                    results.push({
+                        id: `fk-${fk.fromTable}-${fk.fromColumn}-${fk.toTable}`,
+                        category: 'relation',
+                        title: `${fk.fromTable}.${fk.fromColumn} → ${fk.toTable}.${fk.toColumn || 'id'}`,
+                        subtitle: `Foreign Key · ON UPDATE ${fk.onUpdate}, ON DELETE ${fk.onDelete}`,
+                        icon: 'diagram',
+                        url: `${basePath}/erd/${encDb}`,
+                        score,
+                        badge: 'Relation',
+                        badgeType: 'info',
+                        actions: [
+                            { label: 'View ERD', url: `${basePath}/erd/${encDb}`, primary: true },
+                            { label: `Browse ${fk.fromTable}`, url: `${basePath}/tables/${encDb}/${fromEnc}` },
+                        ],
+                        metadata: {
+                            fromTable: fk.fromTable,
+                            fromColumn: fk.fromColumn,
+                            toTable: fk.toTable,
+                            toColumn: fk.toColumn,
+                        },
+                    });
+                }
+            }
+        }
+        if (shouldSearch('command')) {
+            for (const cmd of metadata.commands) {
+                let score = 0;
+                if (q) {
+                    const titleScore = this.calculateScore(cmd.title, q);
+                    const descScore = this.calculateScore(cmd.description, q) > 70 ? 40 : 0;
+                    const kwScore = cmd.keywords.some((k) => this.calculateScore(k, q) > 70) ? 70 : 0;
+                    score = Math.max(titleScore, descScore, kwScore);
+                }
+                else {
+                    score = 45;
+                }
+                if (score > 0 || !q) {
+                    results.push({
+                        id: cmd.id,
+                        category: 'command',
+                        title: cmd.title,
+                        subtitle: cmd.description,
+                        icon: cmd.icon,
+                        url: cmd.url,
+                        score: score + 5,
+                        badge: 'Command',
+                        badgeType: 'secondary',
+                        actions: [{ label: 'Execute', url: cmd.url, primary: true }],
+                        metadata: {
+                            keywords: cmd.keywords,
+                        },
+                    });
+                }
+            }
+        }
+        if (q.length >= 2 && includeRows && shouldSearch('row')) {
+            try {
+                const rowResults = await this.searchRowData(ctx, q, metadata.tables, metadata.columns, basePath, limit);
+                results.push(...rowResults);
+            }
+            catch {
+            }
+        }
+        results.sort((a, b) => b.score - a.score);
+        const categoryCounts = {
+            table: 0,
+            column: 0,
+            index: 0,
+            relation: 0,
+            command: 0,
+            row: 0,
+        };
+        for (const r of results) {
+            categoryCounts[r.category] = (categoryCounts[r.category] || 0) + 1;
+        }
+        const slicedResults = results.slice(0, limit);
+        return {
+            query: q,
+            total: results.length,
+            categories: categoryCounts,
+            results: slicedResults,
+        };
+    }
+    static async searchRowData(ctx, query, tables, columns, basePath, limit) {
+        const rowResults = [];
+        const encDb = encodeURIComponent(ctx.name);
+        const maxTablesToSearch = 12;
+        const maxRowsPerTable = 3;
+        const searchableTables = tables.slice(0, maxTablesToSearch);
+        for (const table of searchableTables) {
+            if (rowResults.length >= limit)
+                break;
+            const textCols = columns.filter((c) => c.table === table.name &&
+                /(text|char|varchar|nvarchar|string|clob|json|blob)/i.test(c.type || 'TEXT'));
+            if (textCols.length === 0)
+                continue;
+            const colNames = textCols.map((c) => c.name);
+            const whereClauses = colNames.map((c) => `${(0, generator_1.quoteIdentifier)(c)} LIKE ?`).join(' OR ');
+            const params = colNames.map(() => `%${query}%`);
+            const selectSql = `SELECT rowid AS _rowid_, * FROM ${(0, generator_1.quoteIdentifier)(table.name)} WHERE ${whereClauses} LIMIT ${maxRowsPerTable}`;
+            try {
+                const res = await ctx.db.all(selectSql, params);
+                if (res.success && Array.isArray(res.data)) {
+                    for (const row of res.data) {
+                        let matchedCol = colNames[0];
+                        let matchedVal = '';
+                        for (const colName of colNames) {
+                            const val = String(row[colName] ?? '');
+                            if (val.toLowerCase().includes(query.toLowerCase())) {
+                                matchedCol = colName;
+                                matchedVal = val;
+                                break;
+                            }
+                        }
+                        const snippet = matchedVal.length > 80 ? `${matchedVal.slice(0, 80)}…` : matchedVal;
+                        const rowId = row._rowid_ ?? row.id ?? row[table.primaryKey[0]] ?? '';
+                        const encTable = encodeURIComponent(table.name);
+                        rowResults.push({
+                            id: `row-${table.name}-${rowId}-${matchedCol}`,
+                            category: 'row',
+                            title: `${table.name}${rowId ? ` #${rowId}` : ''}: ${matchedCol} = "${snippet}"`,
+                            subtitle: `Row data match in ${table.name}.${matchedCol}`,
+                            icon: 'inspect',
+                            url: `${basePath}/tables/${encDb}/${encTable}`,
+                            score: 35,
+                            badge: 'Row Data',
+                            badgeType: 'neutral',
+                            actions: [
+                                { label: 'Browse Table', url: `${basePath}/tables/${encDb}/${encTable}`, primary: true },
+                            ],
+                            metadata: {
+                                table: table.name,
+                                column: matchedCol,
+                                value: snippet,
+                                row,
+                            },
+                        });
+                    }
+                }
+            }
+            catch {
+            }
+        }
+        return rowResults;
+    }
+}
+exports.SearchService = SearchService;

package/dist/modules/search/search.types.d.ts

@@ -0,0 +1 @@
+export type SearchCategory='table'|'column'|'index'|'relation'|'command'|'row';export interface SearchAction{label:string;url:string;icon?:string;primary?:boolean;}export interface SearchItem{id:string;category:SearchCategory;title:string;subtitle:string;icon:string;url:string;score:number;badge?:string;badgeType?:'primary'|'secondary'|'accent'|'info'|'success'|'warning'|'error'|'neutral';actions?:SearchAction[];metadata?:Record<string,unknown>;}export interface SearchResponse{query:string;total:number;categories:Record<SearchCategory,number>;results:SearchItem[];}export interface SearchOptions{query?:string;type?:string;limit?:number;includeRows?:boolean;basePath?:string;}export interface TableSummary{name:string;columnsCount:number;rowCount?:number;primaryKey:string[];}export interface ColumnSummary{table:string;name:string;type:string;isPk:boolean;isFk:boolean;fkTarget?:string|null;notnull:boolean;dflt_value:string|null;}export interface IndexSummary{table:string;name:string;unique:boolean;columns:string[];}export interface ForeignKeySummary{fromTable:string;fromColumn:string;toTable:string;toColumn:string|null;onUpdate:string;onDelete:string;}export interface CommandItem{id:string;title:string;description:string;icon:string;url:string;keywords:string[];shortcut?:string;}export interface SearchMetadataIndex{tables:TableSummary[];columns:ColumnSummary[];indexes:IndexSummary[];foreignKeys:ForeignKeySummary[];commands:CommandItem[];}

package/dist/modules/search/search.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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;