admindb 2.4.1 → 2.6.0

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/errors.d.ts

@@ -0,0 +1 @@
+export declare class AppError extends Error{readonly status:number;readonly details?:Record<string,unknown>;constructor(message:string,status?:number,details?:Record<string,unknown>);}export declare class NotFoundError extends AppError{constructor(message?:string,details?:Record<string,unknown>);}export declare class BadRequestError extends AppError{constructor(message:string,details?:Record<string,unknown>);}export declare class ForbiddenError extends AppError{constructor(message?:string,details?:Record<string,unknown>);}export declare class ConflictError extends AppError{constructor(message:string,details?:Record<string,unknown>);}

package/dist/core/errors.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictError = exports.ForbiddenError = exports.BadRequestError = exports.NotFoundError = exports.AppError = void 0;
+class AppError extends Error {
+    status;
+    details;
+    constructor(message, status = 500, details) {
+        super(message);
+        this.name = this.constructor.name;
+        this.status = status;
+        this.details = details;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.AppError = AppError;
+class NotFoundError extends AppError {
+    constructor(message = 'Resource not found.', details) {
+        super(message, 404, details);
+    }
+}
+exports.NotFoundError = NotFoundError;
+class BadRequestError extends AppError {
+    constructor(message, details) {
+        super(message, 400, details);
+    }
+}
+exports.BadRequestError = BadRequestError;
+class ForbiddenError extends AppError {
+    constructor(message = 'Database is open in read-only mode — write operations are disabled.', details) {
+        super(message, 403, details);
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+class ConflictError extends AppError {
+    constructor(message, details) {
+        super(message, 409, details);
+    }
+}
+exports.ConflictError = ConflictError;

package/dist/core/index.d.ts

@@ -0,0 +1 @@
+export * from './result';export * from './errors';export * from './context';export * from './router';

package/dist/core/index.js

@@ -0,0 +1,20 @@
+"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("./result"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./router"), exports);

package/dist/core/result.d.ts

@@ -0,0 +1 @@
+export type SQLInputValue=null|number|bigint|string|boolean|Uint8Array|Buffer|Date;export interface Result<T=unknown>{success:boolean;data?:T;error?:string;}export interface MutationResult{changes?:number;lastInsertRowid?:number|null;}export declare function okResult<T>(data?:T):Result<T>;export declare function errResult<T=never>(error:string):Result<T>;

package/dist/core/result.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.okResult = okResult;
+exports.errResult = errResult;
+function okResult(data) {
+    return { success: true, ...(data !== undefined ? { data } : {}) };
+}
+function errResult(error) {
+    return { success: false, error };
+}

package/dist/core/router.d.ts

@@ -0,0 +1 @@
+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/router.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrap = exports.notFound = exports.fail = exports.ok = void 0;
+exports.initPageLocals = initPageLocals;
+const common_1 = require("../utils/common");
+const ok = (res, data, status = 200) => res.status(status).json({ success: true, data });
+exports.ok = ok;
+const fail = (res, error, status = 400, details) => res.status(status).json({ success: false, error, ...(details ? { details } : {}) });
+exports.fail = fail;
+const notFound = (res, message) => {
+    res.status(404).render('pages/error', { title: 'Not found', status: 404, error: message });
+};
+exports.notFound = notFound;
+const wrap = (fn) => async (req, res, next) => {
+    try {
+        await fn(req, res, next);
+    }
+    catch (err) {
+        (0, exports.fail)(res, (0, common_1.errorMessage)(err), 500);
+    }
+};
+exports.wrap = wrap;
+function initPageLocals(res, dbOrCtx, dbId, allNames) {
+    const dialectName = typeof dbOrCtx.dialect === 'string' ? dbOrCtx.dialect : dbOrCtx.dialect.name;
+    const isPostgres = dialectName === 'postgres';
+    const isSqlite = dialectName === 'sqlite';
+    res.locals.dbId = dbId;
+    res.locals.dbPath = dbOrCtx.path;
+    res.locals.tables = allNames;
+    res.locals.dialect = dialectName;
+    res.locals.isPostgres = isPostgres;
+    res.locals.isSqlite = isSqlite;
+    res.locals.dialectName = isPostgres ? 'PostgreSQL' : 'SQLite';
+    res.locals.readonly = dbOrCtx.isReadOnly;
+    res.locals.databasesMode = false;
+    return { tables: allNames };
+}

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;

package/dist/core/transfer/dialect-mapper.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.categorizeType = categorizeType;
+exports.mapColumnToDialect = mapColumnToDialect;
+exports.normalizeTableInfo = normalizeTableInfo;
+exports.convertValueForDialect = convertValueForDialect;
+exports.mapDefaultValueForDialect = mapDefaultValueForDialect;
+exports.generateCreateTableForDialect = generateCreateTableForDialect;
+function categorizeType(rawType) {
+    const t = (rawType || '').toLowerCase().trim();
+    if (t.includes('int') || t.includes('serial') || t === 'smallint' || t === 'bigint')
+        return 'integer';
+    if (t.includes('bool'))
+        return 'boolean';
+    if (t.includes('float') || t.includes('double') || t.includes('real') || t.includes('numeric') || t.includes('decimal'))
+        return 'real';
+    if (t.includes('blob') || t.includes('bytea') || t.includes('binary'))
+        return 'blob';
+    if (t.includes('date') || t.includes('time'))
+        return 'datetime';
+    if (t.includes('json'))
+        return 'json';
+    return 'text';
+}
+function mapColumnToDialect(col, targetDialect) {
+    if (targetDialect === 'postgres') {
+        if (col.autoIncrement) {
+            return col.type.toLowerCase().includes('big') ? 'BIGSERIAL' : 'SERIAL';
+        }
+        switch (col.genericType) {
+            case 'integer':
+                return col.type.toLowerCase().includes('big') ? 'BIGINT' : 'INTEGER';
+            case 'boolean':
+                return 'BOOLEAN';
+            case 'real':
+                return 'DOUBLE PRECISION';
+            case 'blob':
+                return 'BYTEA';
+            case 'datetime':
+                return 'TIMESTAMP WITH TIME ZONE';
+            case 'json':
+                return 'JSONB';
+            case 'text':
+            default:
+                return 'TEXT';
+        }
+    }
+    if (col.primaryKey && col.autoIncrement) {
+        return 'INTEGER PRIMARY KEY AUTOINCREMENT';
+    }
+    switch (col.genericType) {
+        case 'integer':
+            return 'INTEGER';
+        case 'boolean':
+            return 'INTEGER';
+        case 'real':
+            return 'REAL';
+        case 'blob':
+            return 'BLOB';
+        case 'datetime':
+        case 'json':
+        case 'text':
+        default:
+            return 'TEXT';
+    }
+}
+function normalizeTableInfo(info, dialect) {
+    const uniqueCols = new Set();
+    const pks = new Set(info.primaryKey || []);
+    for (const idx of info.indexes || []) {
+        const cols = Array.isArray(idx.columns) ? idx.columns.filter(Boolean) : [];
+        if (idx.unique && cols.length === 1 && !pks.has(cols[0])) {
+            uniqueCols.add(cols[0]);
+        }
+    }
+    const columns = (info.columns || []).map((col) => {
+        const isPk = col.pk > 0 || pks.has(col.name);
+        const rawType = (col.type || '').toUpperCase();
+        const genericType = categorizeType(rawType);
+        const isAutoIncrement = (isPk && genericType === 'integer' && dialect === 'sqlite' && Boolean(info.sql?.toLowerCase().includes('autoincrement'))) ||
+            rawType.includes('SERIAL') ||
+            Boolean(col.dflt_value?.includes('nextval(')) ||
+            Boolean(info.sql?.toLowerCase().includes('generated always as identity'));
+        const fk = (info.foreignKeys || []).find((f) => f.from === col.name);
+        return {
+            name: col.name,
+            type: col.type,
+            genericType,
+            primaryKey: isPk,
+            autoIncrement: isAutoIncrement,
+            notNull: Boolean(col.notnull),
+            defaultValue: col.dflt_value,
+            unique: uniqueCols.has(col.name),
+            foreignKey: fk
+                ? {
+                    table: fk.table,
+                    column: fk.to || '',
+                    onDelete: fk.on_delete,
+                    onUpdate: fk.on_update,
+                }
+                : null,
+        };
+    });
+    const indexes = (info.indexes || [])
+        .filter((ix) => !ix.name?.startsWith('sqlite_') && ix.origin !== 'pk' && (!ix.name?.endsWith('_pkey') || !ix.unique))
+        .map((ix) => {
+        let cols = [];
+        if (Array.isArray(ix.columns)) {
+            cols = ix.columns.filter((c) => typeof c === 'string' && c.trim().length > 0);
+        }
+        else if (typeof ix.columns === 'string') {
+            cols = [ix.columns];
+        }
+        return {
+            name: ix.name || `idx_${info.table}_${cols.join('_') || 'col'}`,
+            unique: Boolean(ix.unique),
+            columns: cols,
+        };
+    })
+        .filter((ix) => ix.columns.length > 0);
+    return {
+        name: info.table,
+        columns,
+        primaryKeys: info.primaryKey || [],
+        foreignKeys: info.foreignKeys || [],
+        indexes,
+    };
+}
+function convertValueForDialect(value, genericType, targetDialect) {
+    if (value === null || value === undefined)
+        return null;
+    if (targetDialect === 'postgres') {
+        if (genericType === 'boolean') {
+            if (typeof value === 'boolean')
+                return value;
+            if (typeof value === 'number')
+                return value !== 0;
+            if (typeof value === 'string')
+                return value === '1' || value.toLowerCase() === 'true';
+            return Boolean(value);
+        }
+        if (genericType === 'json') {
+            if (typeof value === 'object')
+                return JSON.stringify(value);
+            return String(value);
+        }
+        if (genericType === 'blob') {
+            if (Buffer.isBuffer(value))
+                return value;
+            if (value instanceof Uint8Array)
+                return Buffer.from(value);
+            return Buffer.from(String(value));
+        }
+        return value;
+    }
+    if (genericType === 'boolean') {
+        if (typeof value === 'boolean')
+            return value ? 1 : 0;
+        if (typeof value === 'number')
+            return value ? 1 : 0;
+        if (typeof value === 'string')
+            return value === 'true' || value === '1' ? 1 : 0;
+        return value ? 1 : 0;
+    }
+    if (genericType === 'json') {
+        if (typeof value === 'object')
+            return JSON.stringify(value);
+        return String(value);
+    }
+    if (genericType === 'datetime') {
+        if (value instanceof Date)
+            return value.toISOString();
+        return String(value);
+    }
+    if (genericType === 'blob') {
+        if (Buffer.isBuffer(value))
+            return value;
+        if (value instanceof Uint8Array)
+            return Buffer.from(value);
+    }
+    return value;
+}
+function mapDefaultValueForDialect(defaultValue, genericType, targetDialect) {
+    if (defaultValue === null || defaultValue === undefined)
+        return null;
+    let def = String(defaultValue).trim();
+    if (!def)
+        return null;
+    if (targetDialect === 'sqlite') {
+        def = def.replace(/::[a-zA-Z0-9_ "]+(\[\])?/g, '').trim();
+        if (/nextval\(.*?\)/i.test(def)) {
+            return null;
+        }
+        if (/^(now\(\)|current_timestamp|current_timestamp\(\)|clock_timestamp\(\)|statement_timestamp\(\)|transaction_timestamp\(\)|\('now'.*?\))$/i.test(def)) {
+            return 'CURRENT_TIMESTAMP';
+        }
+        if (/^(gen_random_uuid\(\)|uuid_generate_v\d\(\)|random\(\)|uuid\(\))$/i.test(def)) {
+            return null;
+        }
+        if (/^true$/i.test(def))
+            return '1';
+        if (/^false$/i.test(def))
+            return '0';
+        while (def.startsWith('(') && def.endsWith(')')) {
+            const inner = def.slice(1, -1).trim();
+            let depth = 0;
+            let okToStrip = true;
+            for (let i = 0; i < inner.length; i++) {
+                if (inner[i] === '(')
+                    depth++;
+                else if (inner[i] === ')') {
+                    depth--;
+                    if (depth < 0) {
+                        okToStrip = false;
+                        break;
+                    }
+                }
+            }
+            if (okToStrip && depth === 0) {
+                def = inner;
+            }
+            else {
+                break;
+            }
+        }
+        if (/^(now\(\)|current_timestamp|current_timestamp\(\)|clock_timestamp\(\)|\('now'.*?\))$/i.test(def)) {
+            return 'CURRENT_TIMESTAMP';
+        }
+        if (/^true$/i.test(def))
+            return '1';
+        if (/^false$/i.test(def))
+            return '0';
+        if (/nextval\(.*?\)/i.test(def))
+            return null;
+        if (/^(gen_random_uuid\(\)|uuid_generate_v\d\(\))$/i.test(def))
+            return null;
+        if (/^[a-zA-Z0-9_]+\(.*\)$/.test(def) && !/^(current_timestamp|current_date|current_time)$/i.test(def)) {
+            return null;
+        }
+        return def;
+    }
+    if (targetDialect === 'postgres') {
+        if (genericType === 'boolean') {
+            if (def === '1' || def === "'1'")
+                return 'TRUE';
+            if (def === '0' || def === "'0'")
+                return 'FALSE';
+        }
+        if (/nextval\(.*?\)/i.test(def)) {
+            return null;
+        }
+        return def;
+    }
+    return def;
+}
+function generateCreateTableForDialect(table, targetDialect) {
+    const lines = [];
+    const q = targetDialect === 'postgres' ? (s) => `"${s}"` : (s) => `\`${s}\``;
+    const singleAutoPk = targetDialect === 'sqlite' &&
+        table.columns.filter((c) => c.primaryKey).length === 1 &&
+        table.columns.find((c) => c.primaryKey)?.autoIncrement;
+    for (const col of table.columns) {
+        let colSql = `${q(col.name)} ${mapColumnToDialect(col, targetDialect)}`;
+        const isPgSerial = targetDialect === 'postgres' && col.autoIncrement;
+        if (singleAutoPk && col.primaryKey) {
+        }
+        else if (isPgSerial) {
+            if (col.unique && !col.primaryKey)
+                colSql += ' UNIQUE';
+        }
+        else {
+            if (col.notNull)
+                colSql += ' NOT NULL';
+            if (col.unique && !col.primaryKey)
+                colSql += ' UNIQUE';
+            const mappedDefault = mapDefaultValueForDialect(col.defaultValue, col.genericType, targetDialect);
+            if (mappedDefault !== null && mappedDefault !== undefined) {
+                colSql += ` DEFAULT ${mappedDefault}`;
+            }
+        }
+        lines.push(colSql);
+    }
+    if (!singleAutoPk && table.primaryKeys.length > 0) {
+        const validPks = table.primaryKeys.filter((pk) => table.columns.some((c) => c.name === pk));
+        if (validPks.length > 0) {
+            lines.push(`PRIMARY KEY (${validPks.map(q).join(', ')})`);
+        }
+    }
+    if (targetDialect === 'sqlite') {
+        for (const fk of table.foreignKeys) {
+            if (fk.from && fk.to && fk.table) {
+                const targetTable = fk.table.includes('.') ? fk.table.split('.').pop() : fk.table;
+                let fkSql = `FOREIGN KEY (${q(fk.from)}) REFERENCES ${q(targetTable)} (${q(fk.to)})`;
+                if (fk.on_delete && fk.on_delete !== 'NO ACTION')
+                    fkSql += ` ON DELETE ${fk.on_delete}`;
+                if (fk.on_update && fk.on_update !== 'NO ACTION')
+                    fkSql += ` ON UPDATE ${fk.on_update}`;
+                lines.push(fkSql);
+            }
+        }
+    }
+    return `CREATE TABLE ${q(table.name)} (\n  ${lines.join(',\n  ')}\n);`;
+}

package/dist/core/transfer/masking.d.ts

@@ -0,0 +1 @@
+export interface MaskingRule{columnPattern:string;strategy:'email'|'password'|'phone'|'name'|'redact'|'hash';customValue?:string;}export declare const DEFAULT_MASKING_RULES:MaskingRule[];export declare function maskRowData(row:Record<string,unknown>,rules?:MaskingRule[],rowIndex?:number):Record<string,unknown>;