admindb 2.5.0 → 2.6.2

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Muhammad Bin Khalid
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2025 Muhammad Bin Khalid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/dist/app.js

@@ -142,7 +142,19 @@ function createRouter(options = {}) {
             logger,
         };
     };
-    (0, index_1.registerModules)(app, { getContext, logger });
+    const getNamedContext = (dbId, readonlyOverride) => {
+        if (manager) {
+            if (!manager.has(dbId)) {
+                const err = new Error(`Database "${dbId}" does not exist.`);
+                err.status = 404;
+                throw err;
+            }
+            const effectiveRo = globalReadonly ? true : manager.isDbReadOnly(dbId);
+            return manager.getContext(dbId, readonlyOverride !== undefined ? readonlyOverride : effectiveRo);
+        }
+        return getContext({ params: { db: defaultDbId } });
+    };
+    (0, index_1.registerModules)(app, { getContext, getNamedContext, manager, logger });
     addErrorHandlers(app, logger);
     return app;
 }

package/dist/core/diff/data-differ.d.ts

@@ -0,0 +1 @@
+import type {IDatabase} from '../../db/types';export interface RowValueChange{column:string;sourceValue:unknown;targetValue:unknown;}export interface RowDiffItem{key:string;action:'added'|'removed'|'modified';sourceRow?:Record<string,unknown>;targetRow?:Record<string,unknown>;changes?:RowValueChange[];}export interface TableDataDiffResult{table:string;primaryKeys:string[];sourceRowCount:number;targetRowCount:number;addedCount:number;removedCount:number;modifiedCount:number;identicalCount:number;rows:RowDiffItem[];unifiedDiff:string;}export declare function areValuesEqual(a:unknown,b:unknown):boolean;export declare function compareTableData(sourceDb:IDatabase,targetDb:IDatabase,table:string,limit?:number):Promise<TableDataDiffResult>;

package/dist/core/diff/data-differ.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areValuesEqual = areValuesEqual;
+exports.compareTableData = compareTableData;
+function areValuesEqual(a, b) {
+    if (a === b)
+        return true;
+    if ((a === null || a === undefined) && (b === null || b === undefined))
+        return true;
+    if (a === null || a === undefined || b === null || b === undefined)
+        return false;
+    const isBoolLikeA = typeof a === 'boolean' || a === 0 || a === 1 || a === '0' || a === '1' || a === 'true' || a === 'false';
+    const isBoolLikeB = typeof b === 'boolean' || b === 0 || b === 1 || b === '0' || b === '1' || b === 'true' || b === 'false';
+    if ((typeof a === 'boolean' || typeof b === 'boolean') && isBoolLikeA && isBoolLikeB) {
+        const boolA = a === true || a === 1 || a === '1' || a === 'true';
+        const boolB = b === true || b === 1 || b === '1' || b === 'true';
+        return boolA === boolB;
+    }
+    if (typeof a === 'number' && typeof b === 'number') {
+        return Math.abs(a - b) < 0.000001;
+    }
+    if ((typeof a === 'number' || typeof a === 'bigint') && typeof b === 'string') {
+        if (b.trim() !== '' && !isNaN(Number(b)) && Number(a) === Number(b))
+            return true;
+    }
+    if ((typeof b === 'number' || typeof b === 'bigint') && typeof a === 'string') {
+        if (a.trim() !== '' && !isNaN(Number(a)) && Number(a) === Number(b))
+            return true;
+    }
+    const isDateA = a instanceof Date;
+    const isDateB = b instanceof Date;
+    if (isDateA || isDateB) {
+        const timeA = isDateA ? a.getTime() : new Date(String(a)).getTime();
+        const timeB = isDateB ? b.getTime() : new Date(String(b)).getTime();
+        if (!isNaN(timeA) && !isNaN(timeB))
+            return timeA === timeB;
+    }
+    if (typeof a === 'string' && typeof b === 'string') {
+        if (a.length >= 10 && b.length >= 10 && /^\d{4}-\d{2}-\d{2}/.test(a) && /^\d{4}-\d{2}-\d{2}/.test(b)) {
+            const timeA = new Date(a).getTime();
+            const timeB = new Date(b).getTime();
+            if (!isNaN(timeA) && !isNaN(timeB))
+                return timeA === timeB;
+        }
+    }
+    if (typeof a === 'object' || typeof b === 'object') {
+        if (Buffer.isBuffer(a) || a instanceof Uint8Array || Buffer.isBuffer(b) || b instanceof Uint8Array) {
+            const bufA = Buffer.isBuffer(a) ? a : Buffer.from(a);
+            const bufB = Buffer.isBuffer(b) ? b : Buffer.from(b);
+            return bufA.equals(bufB);
+        }
+        try {
+            const strA = typeof a === 'string' ? a : JSON.stringify(a);
+            const strB = typeof b === 'string' ? b : JSON.stringify(b);
+            return JSON.stringify(JSON.parse(strA)) === JSON.stringify(JSON.parse(strB));
+        }
+        catch {
+        }
+    }
+    return String(a).trim() === String(b).trim();
+}
+async function compareTableData(sourceDb, targetDb, table, limit = 200) {
+    const [srcInfoRes, tgtInfoRes] = await Promise.all([
+        sourceDb.getTableInfo(table),
+        targetDb.getTableInfo(table),
+    ]);
+    const srcInfo = srcInfoRes.success && srcInfoRes.data ? srcInfoRes.data : null;
+    const tgtInfo = tgtInfoRes.success && tgtInfoRes.data ? tgtInfoRes.data : null;
+    if (!srcInfo && !tgtInfo) {
+        throw new Error(`Table "${table}" does not exist in either source or target database.`);
+    }
+    if (srcInfo && (!tgtInfo || tgtInfo.columns.length === 0)) {
+        const srcCountRes = await sourceDb.getRowCount(table);
+        const srcRowCount = srcCountRes.data || 0;
+        const srcRowsRes = await sourceDb.getRows(table, { limit });
+        const srcRows = srcRowsRes.data || [];
+        const pks = srcInfo.primaryKey.length > 0 ? srcInfo.primaryKey : ['id'];
+        const rows = srcRows.map((r, idx) => ({
+            key: pks.map((k) => String(r[k] ?? '')).join('::') || `row_${idx + 1}`,
+            action: 'added',
+            sourceRow: r,
+        }));
+        const lines = [
+            `diff --git a/${table}/data b/${table}/data`,
+            `@@ Table: ${table} (MISSING IN TARGET DATABASE) @@`,
+            ` Target table "${table}" does not exist. All ${srcRowCount} rows are newly added.`,
+        ];
+        for (const r of rows.slice(0, 100)) {
+            lines.push(`+ [PK: ${r.key}] ${JSON.stringify(r.sourceRow)}`);
+        }
+        return {
+            table,
+            primaryKeys: pks,
+            sourceRowCount: srcRowCount,
+            targetRowCount: 0,
+            addedCount: rows.length,
+            removedCount: 0,
+            modifiedCount: 0,
+            identicalCount: 0,
+            rows,
+            unifiedDiff: lines.join('\n'),
+        };
+    }
+    if (!srcInfo && tgtInfo) {
+        const tgtCountRes = await targetDb.getRowCount(table);
+        const tgtRowCount = tgtCountRes.data || 0;
+        const tgtRowsRes = await targetDb.getRows(table, { limit });
+        const tgtRows = tgtRowsRes.data || [];
+        const pks = tgtInfo.primaryKey.length > 0 ? tgtInfo.primaryKey : ['id'];
+        const rows = tgtRows.map((r, idx) => ({
+            key: pks.map((k) => String(r[k] ?? '')).join('::') || `row_${idx + 1}`,
+            action: 'removed',
+            targetRow: r,
+        }));
+        const lines = [
+            `diff --git a/${table}/data b/${table}/data`,
+            `@@ Table: ${table} (MISSING IN SOURCE DATABASE) @@`,
+            ` Source table "${table}" does not exist. All ${tgtRowCount} target rows would be removed.`,
+        ];
+        for (const r of rows.slice(0, 100)) {
+            lines.push(`- [PK: ${r.key}] ${JSON.stringify(r.targetRow)}`);
+        }
+        return {
+            table,
+            primaryKeys: pks,
+            sourceRowCount: 0,
+            targetRowCount: tgtRowCount,
+            addedCount: 0,
+            removedCount: rows.length,
+            modifiedCount: 0,
+            identicalCount: 0,
+            rows,
+            unifiedDiff: lines.join('\n'),
+        };
+    }
+    const srcColNames = srcInfo.columns.map((c) => c.name);
+    const tgtColNames = tgtInfo.columns.map((c) => c.name);
+    let pks = srcInfo.primaryKey.length > 0 ? srcInfo.primaryKey : tgtInfo.primaryKey;
+    if (!pks || pks.length === 0) {
+        const hasId = srcColNames.some((c) => c.toLowerCase() === 'id');
+        if (hasId) {
+            pks = ['id'];
+        }
+        else if (srcColNames.length > 0) {
+            pks = srcColNames;
+        }
+        else {
+            pks = ['row_idx'];
+        }
+    }
+    const orderCol = pks[0] && srcColNames.includes(pks[0]) && tgtColNames.includes(pks[0]) ? pks[0] : undefined;
+    const [srcCountRes, tgtCountRes, srcRowsRes, tgtRowsRes] = await Promise.all([
+        sourceDb.getRowCount(table),
+        targetDb.getRowCount(table),
+        sourceDb.getRows(table, { limit, orderBy: orderCol, orderDir: 'asc' }),
+        targetDb.getRows(table, { limit, orderBy: orderCol, orderDir: 'asc' }),
+    ]);
+    const srcRows = srcRowsRes.data || [];
+    const tgtRows = tgtRowsRes.data || [];
+    const makeKey = (row, fallbackIdx) => {
+        const keyParts = pks.map((k) => {
+            const v = row[k];
+            return v === null || v === undefined ? '' : String(v);
+        });
+        const key = keyParts.join('::');
+        return key.trim() ? key : `row_${fallbackIdx}`;
+    };
+    const srcMap = new Map();
+    srcRows.forEach((r, idx) => srcMap.set(makeKey(r, idx + 1), r));
+    const tgtMap = new Map();
+    tgtRows.forEach((r, idx) => tgtMap.set(makeKey(r, idx + 1), r));
+    const allKeys = Array.from(new Set([...srcMap.keys(), ...tgtMap.keys()]));
+    const diffItems = [];
+    let addedCount = 0;
+    let removedCount = 0;
+    let modifiedCount = 0;
+    let identicalCount = 0;
+    for (const key of allKeys) {
+        const sr = srcMap.get(key);
+        const tr = tgtMap.get(key);
+        if (sr && !tr) {
+            addedCount++;
+            diffItems.push({ key, action: 'added', sourceRow: sr });
+            continue;
+        }
+        if (!sr && tr) {
+            removedCount++;
+            diffItems.push({ key, action: 'removed', targetRow: tr });
+            continue;
+        }
+        if (sr && tr) {
+            const changes = [];
+            const cols = Array.from(new Set([...Object.keys(sr), ...Object.keys(tr)]));
+            for (const col of cols) {
+                const sv = sr[col];
+                const tv = tr[col];
+                if (!areValuesEqual(sv, tv)) {
+                    changes.push({ column: col, sourceValue: sv, targetValue: tv });
+                }
+            }
+            if (changes.length > 0) {
+                modifiedCount++;
+                diffItems.push({ key, action: 'modified', sourceRow: sr, targetRow: tr, changes });
+            }
+            else {
+                identicalCount++;
+            }
+        }
+    }
+    const lines = [
+        `diff --git a/${table}/data b/${table}/data`,
+        `@@ Data Diff for Table: ${table} (Key: ${pks.join(', ')}) @@`,
+    ];
+    for (const item of diffItems.slice(0, 100)) {
+        if (item.action === 'added') {
+            lines.push(`+ [PK: ${item.key}] ${JSON.stringify(item.sourceRow)}`);
+        }
+        else if (item.action === 'removed') {
+            lines.push(`- [PK: ${item.key}] ${JSON.stringify(item.targetRow)}`);
+        }
+        else if (item.action === 'modified') {
+            const changesStr = (item.changes || [])
+                .map((c) => `${c.column}: ${JSON.stringify(c.targetValue)} -> ${JSON.stringify(c.sourceValue)}`)
+                .join(', ');
+            lines.push(`~ [PK: ${item.key}] ${changesStr}`);
+        }
+    }
+    if (diffItems.length === 0) {
+        lines.push(' Rows are identical (up to preview limit).');
+    }
+    return {
+        table,
+        primaryKeys: pks,
+        sourceRowCount: srcCountRes.data || 0,
+        targetRowCount: tgtCountRes.data || 0,
+        addedCount,
+        removedCount,
+        modifiedCount,
+        identicalCount,
+        rows: diffItems,
+        unifiedDiff: lines.join('\n'),
+    };
+}

package/dist/core/diff/patch-generator.d.ts

@@ -0,0 +1 @@
+import type {SchemaDiffResult} from './schema-differ';import{type SupportedDialect} from '../transfer/dialect-mapper';export interface GeneratedPatch{upSql:string;downSql:string;}export declare function generateSchemaPatch(diff:SchemaDiffResult,targetDialect:SupportedDialect):GeneratedPatch;

package/dist/core/diff/patch-generator.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemaPatch = generateSchemaPatch;
+const dialect_mapper_1 = require("../transfer/dialect-mapper");
+function generateSchemaPatch(diff, targetDialect) {
+    const upLines = [`-- UP Migration: Align "${diff.targetDbId}" with "${diff.sourceDbId}" (${targetDialect})`];
+    const downLines = [`-- DOWN Rollback: Revert changes on "${diff.targetDbId}"`];
+    const q = targetDialect === 'postgres' ? (s) => `"${s}"` : (s) => `\`${s}\``;
+    for (const table of diff.tables) {
+        if (table.action === 'unchanged')
+            continue;
+        if (table.action === 'added' && table.sourceTable) {
+            const createSql = (0, dialect_mapper_1.generateCreateTableForDialect)(table.sourceTable, targetDialect);
+            upLines.push(`\n-- Create table ${table.name}`);
+            upLines.push(createSql);
+            for (const idx of table.sourceTable.indexes || []) {
+                if (idx.name?.startsWith('sqlite_'))
+                    continue;
+                const colsArr = Array.isArray(idx?.columns) ? idx.columns.filter(Boolean) : [];
+                if (colsArr.length === 0)
+                    continue;
+                const uq = idx.unique ? 'UNIQUE ' : '';
+                const cols = colsArr.map(q).join(', ');
+                upLines.push(`CREATE ${uq}INDEX IF NOT EXISTS ${q(idx.name)} ON ${q(table.name)} (${cols});`);
+            }
+            downLines.push(`\n-- Revert: Drop created table ${table.name}`);
+            downLines.push(`DROP TABLE IF EXISTS ${q(table.name)};`);
+            continue;
+        }
+        if (table.action === 'removed' && table.targetTable) {
+            upLines.push(`\n-- Drop obsolete table ${table.name}`);
+            upLines.push(`DROP TABLE IF EXISTS ${q(table.name)};`);
+            const recreateSql = (0, dialect_mapper_1.generateCreateTableForDialect)(table.targetTable, targetDialect);
+            downLines.push(`\n-- Revert: Re-create dropped table ${table.name}`);
+            downLines.push(recreateSql);
+            continue;
+        }
+        if (table.action === 'modified') {
+            upLines.push(`\n-- Modify table ${table.name}`);
+            for (const col of table.columnDiffs) {
+                if (col.action === 'added' && col.sourceCol) {
+                    const typeStr = (0, dialect_mapper_1.mapColumnToDialect)(col.sourceCol, targetDialect);
+                    const notNullStr = col.sourceCol.notNull ? ' NOT NULL' : '';
+                    const mappedDefault = (0, dialect_mapper_1.mapDefaultValueForDialect)(col.sourceCol.defaultValue, col.sourceCol.genericType, targetDialect);
+                    const dfltStr = mappedDefault !== null && mappedDefault !== undefined ? ` DEFAULT ${mappedDefault}` : '';
+                    upLines.push(`ALTER TABLE ${q(table.name)} ADD COLUMN ${q(col.name)} ${typeStr}${notNullStr}${dfltStr};`);
+                    downLines.push(`ALTER TABLE ${q(table.name)} DROP COLUMN IF EXISTS ${q(col.name)};`);
+                }
+                else if (col.action === 'removed' && col.targetCol) {
+                    upLines.push(`ALTER TABLE ${q(table.name)} DROP COLUMN IF EXISTS ${q(col.name)};`);
+                    const typeStr = (0, dialect_mapper_1.mapColumnToDialect)(col.targetCol, targetDialect);
+                    downLines.push(`ALTER TABLE ${q(table.name)} ADD COLUMN ${q(col.name)} ${typeStr};`);
+                }
+            }
+            for (const idx of table.sourceTable?.indexes || []) {
+                if (idx.name?.startsWith('sqlite_'))
+                    continue;
+                if (table.indexesAdded.includes(idx.name)) {
+                    const colsArr = Array.isArray(idx?.columns) ? idx.columns.filter(Boolean) : [];
+                    if (colsArr.length === 0)
+                        continue;
+                    const uq = idx.unique ? 'UNIQUE ' : '';
+                    const cols = colsArr.map(q).join(', ');
+                    upLines.push(`CREATE ${uq}INDEX IF NOT EXISTS ${q(idx.name)} ON ${q(table.name)} (${cols});`);
+                    downLines.push(`DROP INDEX IF EXISTS ${q(idx.name)};`);
+                }
+            }
+            for (const idxName of table.indexesRemoved) {
+                upLines.push(`DROP INDEX IF EXISTS ${q(idxName)};`);
+            }
+        }
+    }
+    return {
+        upSql: upLines.join('\n'),
+        downSql: downLines.join('\n'),
+    };
+}

package/dist/core/diff/schema-differ.d.ts

@@ -0,0 +1 @@
+import type {IDatabase} from '../../db/types';import{type NormalizedColumn,type NormalizedTable,type SupportedDialect} from '../transfer/dialect-mapper';export interface ColumnDiff{name:string;action:'added'|'removed'|'modified';sourceCol?:NormalizedColumn;targetCol?:NormalizedColumn;changes?:string[];}export interface TableDiff{name:string;action:'added'|'removed'|'modified'|'unchanged';sourceTable?:NormalizedTable;targetTable?:NormalizedTable;columnDiffs:ColumnDiff[];pkChanged:boolean;indexesAdded:string[];indexesRemoved:string[];fksAdded:string[];fksRemoved:string[];}export interface SchemaDiffResult{sourceDbId:string;targetDbId:string;sourceDialect:SupportedDialect;targetDialect:SupportedDialect;tables:TableDiff[];stats:{addedTables:number;removedTables:number;modifiedTables:number;identicalTables:number;totalColumnsChanged:number;};unifiedDiff:string;}export declare function compareSchemas(sourceDb:IDatabase,sourceDbId:string,targetDb:IDatabase,targetDbId:string):Promise<SchemaDiffResult>;

package/dist/core/diff/schema-differ.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareSchemas = compareSchemas;
+const dialect_mapper_1 = require("../transfer/dialect-mapper");
+async function compareSchemas(sourceDb, sourceDbId, targetDb, targetDbId) {
+    const [sourceTableListRes, targetTableListRes] = await Promise.all([
+        sourceDb.listTables(),
+        targetDb.listTables(),
+    ]);
+    if (!sourceTableListRes.success)
+        throw new Error(sourceTableListRes.error || 'Failed to list source tables');
+    if (!targetTableListRes.success)
+        throw new Error(targetTableListRes.error || 'Failed to list target tables');
+    const sourceTableNames = (sourceTableListRes.data || []).map((t) => t.name).filter((n) => !n.startsWith('sqlite_') && !n.startsWith('_admindb_'));
+    const targetTableNames = (targetTableListRes.data || []).map((t) => t.name).filter((n) => !n.startsWith('sqlite_') && !n.startsWith('_admindb_'));
+    const [sourceInfos, targetInfos] = await Promise.all([
+        Promise.all(sourceTableNames.map(async (name) => (await sourceDb.getTableInfo(name)).data)),
+        Promise.all(targetTableNames.map(async (name) => (await targetDb.getTableInfo(name)).data)),
+    ]);
+    const sourceDialect = sourceDb.dialect === 'postgres' ? 'postgres' : 'sqlite';
+    const targetDialect = targetDb.dialect === 'postgres' ? 'postgres' : 'sqlite';
+    const sourceMap = new Map();
+    for (const info of sourceInfos) {
+        if (info)
+            sourceMap.set(info.table, (0, dialect_mapper_1.normalizeTableInfo)(info, sourceDialect));
+    }
+    const targetMap = new Map();
+    for (const info of targetInfos) {
+        if (info)
+            targetMap.set(info.table, (0, dialect_mapper_1.normalizeTableInfo)(info, targetDialect));
+    }
+    const allNames = Array.from(new Set([...sourceTableNames, ...targetTableNames])).sort();
+    const tableDiffs = [];
+    let addedTables = 0;
+    let removedTables = 0;
+    let modifiedTables = 0;
+    let identicalTables = 0;
+    let totalColumnsChanged = 0;
+    for (const name of allNames) {
+        const src = sourceMap.get(name);
+        const tgt = targetMap.get(name);
+        if (src && !tgt) {
+            addedTables++;
+            tableDiffs.push({
+                name,
+                action: 'added',
+                sourceTable: src,
+                columnDiffs: src.columns.map((c) => ({ name: c.name, action: 'added', sourceCol: c })),
+                pkChanged: true,
+                indexesAdded: src.indexes.map((i) => i.name),
+                indexesRemoved: [],
+                fksAdded: src.foreignKeys.map((f) => `${f.from} -> ${f.table}.${f.to}`),
+                fksRemoved: [],
+            });
+            continue;
+        }
+        if (!src && tgt) {
+            removedTables++;
+            tableDiffs.push({
+                name,
+                action: 'removed',
+                targetTable: tgt,
+                columnDiffs: tgt.columns.map((c) => ({ name: c.name, action: 'removed', targetCol: c })),
+                pkChanged: true,
+                indexesAdded: [],
+                indexesRemoved: tgt.indexes.map((i) => i.name),
+                fksAdded: [],
+                fksRemoved: tgt.foreignKeys.map((f) => `${f.from} -> ${f.table}.${f.to}`),
+            });
+            continue;
+        }
+        if (src && tgt) {
+            const colDiffs = [];
+            const srcColMap = new Map(src.columns.map((c) => [c.name, c]));
+            const tgtColMap = new Map(tgt.columns.map((c) => [c.name, c]));
+            const colNames = Array.from(new Set([...srcColMap.keys(), ...tgtColMap.keys()]));
+            for (const colName of colNames) {
+                const sc = srcColMap.get(colName);
+                const tc = tgtColMap.get(colName);
+                if (sc && !tc) {
+                    colDiffs.push({ name: colName, action: 'added', sourceCol: sc });
+                    totalColumnsChanged++;
+                }
+                else if (!sc && tc) {
+                    colDiffs.push({ name: colName, action: 'removed', targetCol: tc });
+                    totalColumnsChanged++;
+                }
+                else if (sc && tc) {
+                    const changes = [];
+                    if (sc.genericType !== tc.genericType) {
+                        changes.push(`Type: target "${tc.type}" (${tc.genericType}) -> source "${sc.type}" (${sc.genericType})`);
+                    }
+                    if (sc.notNull !== tc.notNull) {
+                        changes.push(`NotNull: target ${tc.notNull} -> source ${sc.notNull}`);
+                    }
+                    if (sc.primaryKey !== tc.primaryKey) {
+                        changes.push(`PK: target ${tc.primaryKey} -> source ${sc.primaryKey}`);
+                    }
+                    if (sc.defaultValue !== tc.defaultValue) {
+                        changes.push(`Default: target "${tc.defaultValue}" -> source "${sc.defaultValue}"`);
+                    }
+                    if (changes.length > 0) {
+                        colDiffs.push({ name: colName, action: 'modified', sourceCol: sc, targetCol: tc, changes });
+                        totalColumnsChanged++;
+                    }
+                }
+            }
+            const pkChanged = JSON.stringify(src.primaryKeys.sort()) !== JSON.stringify(tgt.primaryKeys.sort());
+            const srcIdxNames = new Set(src.indexes.map((i) => i.name));
+            const tgtIdxNames = new Set(tgt.indexes.map((i) => i.name));
+            const indexesAdded = src.indexes.filter((i) => !tgtIdxNames.has(i.name)).map((i) => i.name);
+            const indexesRemoved = tgt.indexes.filter((i) => !srcIdxNames.has(i.name)).map((i) => i.name);
+            const srcFkDefs = src.foreignKeys.map((f) => `${f.from} -> ${f.table}.${f.to}`);
+            const tgtFkDefs = tgt.foreignKeys.map((f) => `${f.from} -> ${f.table}.${f.to}`);
+            const fksAdded = srcFkDefs.filter((f) => !tgtFkDefs.includes(f));
+            const fksRemoved = tgtFkDefs.filter((f) => !srcFkDefs.includes(f));
+            const isModified = colDiffs.length > 0 ||
+                pkChanged ||
+                indexesAdded.length > 0 ||
+                indexesRemoved.length > 0 ||
+                fksAdded.length > 0 ||
+                fksRemoved.length > 0;
+            if (isModified) {
+                modifiedTables++;
+                tableDiffs.push({
+                    name,
+                    action: 'modified',
+                    sourceTable: src,
+                    targetTable: tgt,
+                    columnDiffs: colDiffs,
+                    pkChanged,
+                    indexesAdded,
+                    indexesRemoved,
+                    fksAdded,
+                    fksRemoved,
+                });
+            }
+            else {
+                identicalTables++;
+                tableDiffs.push({
+                    name,
+                    action: 'unchanged',
+                    sourceTable: src,
+                    targetTable: tgt,
+                    columnDiffs: [],
+                    pkChanged: false,
+                    indexesAdded: [],
+                    indexesRemoved: [],
+                    fksAdded: [],
+                    fksRemoved: [],
+                });
+            }
+        }
+    }
+    const unifiedDiff = generateGitUnifiedDiff(sourceDbId, targetDbId, tableDiffs);
+    return {
+        sourceDbId,
+        targetDbId,
+        sourceDialect,
+        targetDialect,
+        tables: tableDiffs,
+        stats: {
+            addedTables,
+            removedTables,
+            modifiedTables,
+            identicalTables,
+            totalColumnsChanged,
+        },
+        unifiedDiff,
+    };
+}
+function generateGitUnifiedDiff(sourceDbId, targetDbId, diffs) {
+    const lines = [
+        `diff --git a/${targetDbId}/schema.sql b/${sourceDbId}/schema.sql`,
+        `--- a/${targetDbId} (target)`,
+        `+++ b/${sourceDbId} (source)`,
+    ];
+    for (const t of diffs) {
+        if (t.action === 'unchanged')
+            continue;
+        lines.push(`@@ table: ${t.name} (${t.action.toUpperCase()}) @@`);
+        if (t.action === 'added') {
+            lines.push(`+ CREATE TABLE ${t.name}`);
+            for (const col of t.sourceTable?.columns || []) {
+                lines.push(`+   ${col.name}: ${col.type}${col.primaryKey ? ' PRIMARY KEY' : ''}${col.notNull ? ' NOT NULL' : ''}`);
+            }
+            for (const idx of t.indexesAdded) {
+                lines.push(`+   INDEX ${idx}`);
+            }
+            for (const fk of t.fksAdded) {
+                lines.push(`+   FK ${fk}`);
+            }
+            continue;
+        }
+        if (t.action === 'removed') {
+            lines.push(`- DROP TABLE ${t.name}`);
+            for (const col of t.targetTable?.columns || []) {
+                lines.push(`-   ${col.name}: ${col.type}`);
+            }
+            continue;
+        }
+        for (const c of t.columnDiffs) {
+            if (c.action === 'added') {
+                lines.push(`+   column: ${c.name} (${c.sourceCol?.type || 'UNKNOWN'})${c.sourceCol?.notNull ? ' NOT NULL' : ''}`);
+            }
+            else if (c.action === 'removed') {
+                lines.push(`-   column: ${c.name} (${c.targetCol?.type || 'UNKNOWN'})`);
+            }
+            else if (c.action === 'modified') {
+                lines.push(`~   column: ${c.name} [${c.changes?.join('; ')}]`);
+            }
+        }
+        if (t.pkChanged) {
+            lines.push(`~   PK changed: target [${t.targetTable?.primaryKeys.join(', ')}] -> source [${t.sourceTable?.primaryKeys.join(', ')}]`);
+        }
+        for (const idx of t.indexesAdded)
+            lines.push(`+   INDEX ${idx}`);
+        for (const idx of t.indexesRemoved)
+            lines.push(`-   INDEX ${idx}`);
+        for (const fk of t.fksAdded)
+            lines.push(`+   FK ${fk}`);
+        for (const fk of t.fksRemoved)
+            lines.push(`-   FK ${fk}`);
+    }
+    if (lines.length === 3) {
+        lines.push(' Schemas are identical. No differences found.');
+    }
+    return lines.join('\n');
+}

package/dist/core/router.d.ts

@@ -1 +1 @@
-import type {Request,Response,NextFunction} from 'express';import type {DatabaseContext} from './context';import type {Logger} from '../utils/logger';export interface RouteContext{getContext:(req:Request)=>DatabaseContext;logger:Logger;}export declare const ok:(res:Response,data:unknown,status?:number)=>Response;export declare const fail:(res:Response,error:string,status?:number,details?:Record<string,unknown>|null)=>Response;export declare const notFound:(res:Response,message:string)=>void;export declare const wrap:(fn:(req:Request,res:Response,next?:NextFunction)=>unknown)=>(req:Request,res:Response,next?:NextFunction)=>Promise<void>;export declare function initPageLocals(res:Response,dbOrCtx:{dialect:string|{name:string;};path:string;isReadOnly:boolean;},dbId:string,allNames:string[]):{tables:string[];};
+import type {Request,Response,NextFunction} from 'express';import type {DatabaseContext} from './context';import type {Logger} from '../utils/logger';import type {DbManager} from '../db/manager';export type RequestParams=Record<string,string>;export interface RouteContext{getContext:(req:Request<any>)=>DatabaseContext;getNamedContext?:(id:string,readonlyOverride?:boolean)=>DatabaseContext;manager?:DbManager;logger:Logger;}export declare const ok:(res:Response,data:unknown,status?:number)=>Response;export declare const fail:(res:Response,error:string,status?:number,details?:Record<string,unknown>|null)=>Response;export declare const notFound:(res:Response,message:string)=>void;export declare const wrap:<P=RequestParams>(fn:(req:Request<P>,res:Response,next?:NextFunction)=>unknown)=>(req:Request<P>,res:Response,next?:NextFunction)=>Promise<void>;export declare function initPageLocals(res:Response,dbOrCtx:{dialect:string|{name:string;};path:string;isReadOnly:boolean;},dbId:string,allNames:string[]):{tables:string[];};

package/dist/core/transfer/dialect-mapper.d.ts

@@ -0,0 +1 @@
+import type {ForeignKeyInfo,TableInfoData} from '../../db/types';export type SupportedDialect='sqlite'|'postgres';export interface NormalizedColumn{name:string;type:string;genericType:'integer'|'text'|'boolean'|'real'|'blob'|'datetime'|'json';primaryKey:boolean;autoIncrement:boolean;notNull:boolean;defaultValue:string|null;unique:boolean;foreignKey:{table:string;column:string;onDelete?:string;onUpdate?:string;}|null;}export interface NormalizedIndex{name:string;unique:boolean;columns:string[];}export interface NormalizedTable{name:string;columns:NormalizedColumn[];primaryKeys:string[];foreignKeys:ForeignKeyInfo[];indexes:NormalizedIndex[];}export declare function categorizeType(rawType:string):NormalizedColumn['genericType'];export declare function mapColumnToDialect(col:NormalizedColumn,targetDialect:SupportedDialect):string;export declare function normalizeTableInfo(info:TableInfoData,dialect:SupportedDialect):NormalizedTable;export declare function convertValueForDialect(value:unknown,genericType:NormalizedColumn['genericType'],targetDialect:SupportedDialect):unknown;export declare function mapDefaultValueForDialect(defaultValue:string|null|undefined,genericType:NormalizedColumn['genericType'],targetDialect:SupportedDialect):string|null;export declare function generateCreateTableForDialect(table:NormalizedTable,targetDialect:SupportedDialect):string;