admindb 2.4.1 → 2.6.0

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

@@ -10,14 +10,13 @@ const express_handlebars_1 = require("express-handlebars");
 const database_1 = require("./db/database");
 const postgres_1 = require("./db/postgres");
 const logger_1 = require("./utils/logger");
-const pages_1 = require("./routes/pages");
-const index_1 = require("./routes/api/index");
-const databases_1 = require("./routes/databases");
+const index_1 = require("./modules/index");
 const args_1 = require("./cli/args");
 const common_1 = require("./utils/common");
 const icons_1 = require("./utils/icons");
 const serverless_1 = require("./serverless");
 const auth_1 = require("./auth");
+const index_2 = require("./db/dialects/index");
 const APP_VERSION = (0, args_1.getPackageVersion)();
 function createRouter(options = {}) {
     const isServerless = options.serverless !== undefined ? options.serverless : (0, serverless_1.isServerlessEnvironment)();
@@ -60,10 +59,15 @@ function createRouter(options = {}) {
         else {
             singleDb = new database_1.SqliteDatabase(options.dbPath ?? 'admindb.db', logger, { readonly: globalReadonly });
         }
-        if (!defaultDbId) {
+        if (!defaultDbId && singleDb) {
             defaultDbId = singleDb.dialect === 'postgres' ? 'PostgreSQL' : (node_path_1.default.basename(singleDb.path) || 'SQLite');
         }
     }
+    let singleDialect;
+    if (singleDb) {
+        const pgSchema = singleDb.schema || 'public';
+        singleDialect = (0, index_2.getDialect)(singleDb.dialect, singleDb.dialect === 'postgres' ? pgSchema : undefined);
+    }
     const app = (0, express_1.default)();
     app.disable('x-powered-by');
     app.use(express_1.default.static(node_path_1.default.join(__dirname, 'public')));
@@ -88,14 +92,28 @@ function createRouter(options = {}) {
             res.locals.isDefaultPassword = authConfig.isDefaultPassword;
             res.locals.icons = icons_1.ICONS;
             res.locals.tables = [];
-            res.locals.internalTables = [];
             next();
         }
         catch (err) {
             next(err);
         }
     });
-    const getDb = (req) => {
+    if (manager) {
+        (0, index_1.registerDatabasesRoutes)(app, {
+            manager,
+            logger,
+            basePath,
+            readonly: globalReadonly,
+            allowBrowse: isServerless ? false : options.allowBrowse,
+            browseRoot: options.browseRoot,
+        });
+    }
+    else {
+        app.get('/', (_req, res) => {
+            res.redirect(302, `${basePath}/home/${encodeURIComponent(defaultDbId)}`);
+        });
+    }
+    const getContext = (req) => {
         if (manager) {
             const dbId = String(req.params.db || req.params.dbId || req.params.id || '');
             if (!manager.has(dbId)) {
@@ -111,27 +129,32 @@ function createRouter(options = {}) {
                 }
             }
             const effectiveRo = globalReadonly ? true : manager.isDbReadOnly(dbId);
-            return manager.open(dbId, effectiveRo);
+            return manager.getContext(dbId, effectiveRo);
         }
-        return singleDb;
-    };
-    if (manager) {
-        (0, databases_1.registerDatabasesRoutes)(app, {
-            manager,
+        return {
+            id: defaultDbId,
+            name: defaultDbId,
+            path: singleDb.path,
+            db: singleDb,
+            dialect: singleDialect,
+            capabilities: singleDialect.capabilities,
+            isReadOnly: singleDb.isReadOnly,
             logger,
-            basePath,
-            readonly: globalReadonly,
-            allowBrowse: isServerless ? false : options.allowBrowse,
-            browseRoot: options.browseRoot,
-        });
-    }
-    else {
-        app.get('/', (_req, res) => {
-            res.redirect(302, `${basePath}/home/${encodeURIComponent(defaultDbId)}`);
-        });
-    }
-    (0, pages_1.registerPages)(app, { getDb, logger });
-    (0, index_1.registerApi)(app, { getDb, 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/context.d.ts

@@ -0,0 +1 @@
+import type {Logger} from '../utils/logger';import type {IDatabase} from '../db/types';import type {IDialect,DialectCapabilities} from '../db/dialects/types';export interface DatabaseContext{readonly id:string;readonly name:string;readonly path:string;readonly db:IDatabase;readonly dialect:IDialect;readonly capabilities:DialectCapabilities;readonly isReadOnly:boolean;readonly logger:Logger;}

package/dist/core/context.js

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

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>;