admindb 2.5.0 → 2.6.0

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;