@zintrust/d1-migrator 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * D1 Migrator Package
+ * Migrate any database to Cloudflare D1 with resumable operations
+ */
+import type { CommandOptions } from '@zintrust/core/cli';
+import type { Command } from 'commander';
+import { CheckpointManager } from './utils/CheckpointManager';
+import { DataValidator } from './utils/DataValidator';
+import { DataMigrator } from './cli/DataMigrator';
+import { ProgressTracker } from './cli/ProgressTracker';
+import { SchemaAnalyzer } from './cli/SchemaAnalyzer';
+import { SchemaBuilder } from './schema/SchemaBuilder';
+import { TypeConverter } from './schema/TypeConverter';
+import { SchemaValidator } from './schema/Validator';
+type D1MigratorCommand = {
+    [x: string]: unknown;
+    name: string;
+    description: string;
+    verbose?: boolean;
+    getCommand(): Command;
+    addOptions?: (command: Command) => void;
+    execute(options: CommandOptions): void | Promise<void>;
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    debug(message: unknown): void;
+};
+/**
+ * D1 Migrator - Sealed namespace for database migration operations
+ * Provides comprehensive migration from MySQL, PostgreSQL, SQLite, SQL Server to D1/D1Remote
+ */
+type D1MigratorNamespace = Readonly<{
+    MigrateToD1Command: D1MigratorCommand;
+    CheckpointManager: typeof CheckpointManager;
+    DataValidator: typeof DataValidator;
+    SchemaAnalyzer: typeof SchemaAnalyzer;
+    DataMigrator: typeof DataMigrator;
+    ProgressTracker: typeof ProgressTracker;
+    TypeConverter: typeof TypeConverter;
+    SchemaBuilder: typeof SchemaBuilder;
+    SchemaValidator: typeof SchemaValidator;
+}>;
+export declare const D1Migrator: D1MigratorNamespace;
+export type { CheckpointData, ColumnSchema, DataValidationResult, IndexSchema, MigrationConfig, MigrationProgress, MigrationState, TableSchema, } from './types';
+export default D1Migrator;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAGtD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGtD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,KAAK,iBAAiB,GAAG;IACvB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,IAAI,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CAC/B,CAAC;AAEF;;;GAGG;AACH,KAAK,mBAAmB,GAAG,QAAQ,CAAC;IAClC,kBAAkB,EAAE,iBAAiB,CAAC;IACtC,iBAAiB,EAAE,OAAO,iBAAiB,CAAC;IAC5C,aAAa,EAAE,OAAO,aAAa,CAAC;IACpC,cAAc,EAAE,OAAO,cAAc,CAAC;IACtC,YAAY,EAAE,OAAO,YAAY,CAAC;IAClC,eAAe,EAAE,OAAO,eAAe,CAAC;IACxC,aAAa,EAAE,OAAO,aAAa,CAAC;IACpC,aAAa,EAAE,OAAO,aAAa,CAAC;IACpC,eAAe,EAAE,OAAO,eAAe,CAAC;CACzC,CAAC,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,mBAevB,CAAC;AAGH,YAAY,EACV,cAAc,EACd,YAAY,EACZ,oBAAoB,EACpB,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,WAAW,GACZ,MAAM,SAAS,CAAC;AAEjB,eAAe,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,32 @@
+/**
+ * D1 Migrator Package
+ * Migrate any database to Cloudflare D1 with resumable operations
+ */
+// CLI Commands
+import { MigrateToD1Command } from './cli/MigrateToD1Command';
+// Utilities
+import { CheckpointManager } from './utils/CheckpointManager';
+import { DataValidator } from './utils/DataValidator';
+// CLI Components
+import { DataMigrator } from './cli/DataMigrator';
+import { ProgressTracker } from './cli/ProgressTracker';
+import { SchemaAnalyzer } from './cli/SchemaAnalyzer';
+// Schema Components
+import { SchemaBuilder } from './schema/SchemaBuilder';
+import { TypeConverter } from './schema/TypeConverter';
+import { SchemaValidator } from './schema/Validator';
+export const D1Migrator = Object.freeze({
+    // CLI Commands
+    MigrateToD1Command,
+    // Core Components
+    CheckpointManager,
+    DataValidator,
+    SchemaAnalyzer,
+    DataMigrator,
+    ProgressTracker,
+    // Schema Components
+    TypeConverter,
+    SchemaBuilder,
+    SchemaValidator,
+});
+export default D1Migrator;

package/dist/schema/SchemaBuilder.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Schema Builder
+ * Builds D1/SQLite compatible schemas from source schemas
+ */
+import type { ColumnSchema, TableSchema } from '../types';
+/**
+ * SchemaBuilder - Sealed namespace for schema building
+ * Provides D1 schema generation from source schemas
+ */
+export declare const SchemaBuilder: Readonly<{
+    /**
+     * Build D1 schema from source schema
+     */
+    buildD1Schema(sourceSchema: TableSchema[], sourceDriver: string): TableSchema[];
+    /**
+     * Build D1 table from source table
+     */
+    buildD1Table(sourceTable: TableSchema, sourceDriver: string): TableSchema;
+    /**
+     * Build D1 column from source column
+     */
+    buildD1Column(sourceColumn: ColumnSchema, sourceDriver: string): ColumnSchema;
+    /**
+     * Generate CREATE TABLE SQL
+     */
+    generateCreateTableSQL(table: TableSchema): string;
+    /**
+     * Generate column definition
+     */
+    generateColumnDefinition(column: ColumnSchema): string;
+    /**
+     * Format default value for SQL
+     */
+    formatDefaultValue(value: unknown): string;
+    /**
+     * Generate index statements
+     */
+    generateIndexSQL(table: TableSchema): string[];
+    /**
+     * Generate complete schema SQL
+     */
+    generateSchemaSQL(tables: TableSchema[]): string;
+    /**
+     * Validate built schema
+     */
+    validateSchema(tables: TableSchema[]): {
+        valid: boolean;
+        errors: string[];
+    };
+}>;
+//# sourceMappingURL=SchemaBuilder.d.ts.map

package/dist/schema/SchemaBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaBuilder.d.ts","sourceRoot":"","sources":["../../src/schema/SchemaBuilder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAI1D;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;gCACyB,WAAW,EAAE,gBAAgB,MAAM,GAAG,WAAW,EAAE;IAM/E;;OAEG;8BACuB,WAAW,gBAAgB,MAAM,GAAG,WAAW;IAkBzE;;OAEG;gCACyB,YAAY,gBAAgB,MAAM,GAAG,YAAY;IAmB7E;;OAEG;kCAC2B,WAAW,GAAG,MAAM;IAmBlD;;OAEG;qCAC8B,YAAY,GAAG,MAAM;IActD;;OAEG;8BACuB,OAAO,GAAG,MAAM;IAgB1C;;OAEG;4BACqB,WAAW,GAAG,MAAM,EAAE;IAqB9C;;OAEG;8BACuB,WAAW,EAAE,GAAG,MAAM;IAqBhD;;OAEG;2BACoB,WAAW,EAAE,GAAG;QACrC,KAAK,EAAE,OAAO,CAAC;QACf,MAAM,EAAE,MAAM,EAAE,CAAC;KAClB;EAmCD,CAAC"}

package/dist/schema/SchemaBuilder.js

@@ -0,0 +1,165 @@
+/**
+ * Schema Builder
+ * Builds D1/SQLite compatible schemas from source schemas
+ */
+import { Logger } from '@zintrust/core';
+import { DataValidator } from '../utils/DataValidator';
+import { TypeConverter } from './TypeConverter';
+/**
+ * SchemaBuilder - Sealed namespace for schema building
+ * Provides D1 schema generation from source schemas
+ */
+export const SchemaBuilder = Object.freeze({
+    /**
+     * Build D1 schema from source schema
+     */
+    buildD1Schema(sourceSchema, sourceDriver) {
+        Logger.info('Building D1 schema...');
+        return sourceSchema.map((table) => SchemaBuilder.buildD1Table(table, sourceDriver));
+    },
+    /**
+     * Build D1 table from source table
+     */
+    buildD1Table(sourceTable, sourceDriver) {
+        const sanitizedTableName = DataValidator.sanitizeTableName(sourceTable.name);
+        const d1Table = {
+            name: sanitizedTableName,
+            columns: sourceTable.columns.map((column) => SchemaBuilder.buildD1Column(column, sourceDriver)),
+            primaryKey: sourceTable.primaryKeys?.[0] || '',
+            indexes: sourceTable.indexes || [],
+            primaryKeys: sourceTable.primaryKeys || [],
+            foreignKeys: sourceTable.foreignKeys || [],
+        };
+        Logger.info(`Converted table: ${sourceTable.name} -> ${sanitizedTableName}`);
+        return d1Table;
+    },
+    /**
+     * Build D1 column from source column
+     */
+    buildD1Column(sourceColumn, sourceDriver) {
+        const d1Type = TypeConverter.convertToD1Type(sourceColumn.type, sourceDriver);
+        const warnings = TypeConverter.getConversionWarnings(sourceColumn.type, d1Type);
+        // Log conversion warnings
+        warnings.forEach((warning) => {
+            Logger.warn(`Column conversion warning: ${sourceColumn.name} - ${warning}`);
+        });
+        const d1Column = {
+            name: sourceColumn.name,
+            type: d1Type,
+            nullable: sourceColumn.nullable,
+            defaultValue: sourceColumn.defaultValue,
+        };
+        return d1Column;
+    },
+    /**
+     * Generate CREATE TABLE SQL
+     */
+    generateCreateTableSQL(table) {
+        let sql = `CREATE TABLE \`${table.name}\` (\n`;
+        const columnDefinitions = table.columns.map((column) => SchemaBuilder.generateColumnDefinition(column));
+        sql += columnDefinitions.join(',\n');
+        if (table.primaryKey) {
+            const keyList = table.primaryKey;
+            sql += `,\n  PRIMARY KEY (${keyList})`;
+        }
+        sql += '\n);';
+        return sql;
+    },
+    /**
+     * Generate column definition
+     */
+    generateColumnDefinition(column) {
+        let definition = `  \`${column.name}\` ${column.type}`;
+        if (!column.nullable) {
+            definition += ' NOT NULL';
+        }
+        if (column.defaultValue !== undefined) {
+            definition += ` DEFAULT ${SchemaBuilder.formatDefaultValue(column.defaultValue)}`;
+        }
+        return definition;
+    },
+    /**
+     * Format default value for SQL
+     */
+    formatDefaultValue(value) {
+        if (value === null) {
+            return 'NULL';
+        }
+        if (typeof value === 'string') {
+            return `'${value.replaceAll("'", "''")}'`;
+        }
+        if (typeof value === 'boolean') {
+            return value ? '1' : '0';
+        }
+        return String(value);
+    },
+    /**
+     * Generate index statements
+     */
+    generateIndexSQL(table) {
+        const indexes = [];
+        if (table.indexes) {
+            table.indexes.forEach((index) => {
+                const indexName = `idx_${table.name}_${index.columns.join('_')}`;
+                const columns = index.columns.map((col) => `\`${col}\``).join(', ');
+                let sql = `CREATE`;
+                if (index.unique) {
+                    sql += ' UNIQUE';
+                }
+                sql += ` INDEX \`${indexName}\` ON \`${table.name}\` (${columns});`;
+                indexes.push(sql);
+            });
+        }
+        return indexes;
+    },
+    /**
+     * Generate complete schema SQL
+     */
+    generateSchemaSQL(tables) {
+        let sql = '-- D1 Schema Migration\n';
+        sql += '-- Generated by ZinTrust D1 Migrator\n\n';
+        tables.forEach((table) => {
+            sql += SchemaBuilder.generateCreateTableSQL(table);
+            sql += '\n\n';
+            const indexes = SchemaBuilder.generateIndexSQL(table);
+            indexes.forEach((indexSql) => {
+                sql += indexSql + '\n';
+            });
+            if (indexes.length > 0) {
+                sql += '\n';
+            }
+        });
+        return sql;
+    },
+    /**
+     * Validate built schema
+     */
+    validateSchema(tables) {
+        const errors = [];
+        tables.forEach((table) => {
+            // Check table name
+            if (!DataValidator.sanitizeTableName(table.name)) {
+                errors.push(`Invalid table name: ${table.name}`);
+            }
+            // Check columns
+            table.columns.forEach((column) => {
+                if (!column.name || column.name.trim() === '') {
+                    errors.push(`Empty column name in table: ${table.name}`);
+                }
+                if (!column.type || column.type.trim() === '') {
+                    errors.push(`Empty column type: ${table.name}.${column.name}`);
+                }
+            });
+            if (table.primaryKey) {
+                const hasPrimaryKeyColumn = table.columns.some((column) => column.name === table.primaryKey);
+                if (!hasPrimaryKeyColumn) {
+                    errors.push(`Primary key column '${table.primaryKey}' not found in table: ${table.name}`);
+                }
+            }
+        });
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    },
+});

package/dist/schema/TypeConverter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Type Converter
+ * Converts database types between different database systems
+ */
+/**
+ * TypeConverter - Sealed namespace for type conversion
+ * Provides database type conversion utilities
+ */
+export declare const TypeConverter: Readonly<{
+    /**
+     * Convert column type to D1/SQLite compatible type
+     */
+    convertToD1Type(sourceType: string, sourceDriver: string): string;
+    /**
+     * Convert MySQL types to D1
+     */
+    convertMySQLType(type: string): string;
+    /**
+     * Convert PostgreSQL types to D1
+     */
+    convertPostgreSQLType(type: string): string;
+    /**
+     * Convert SQL Server types to D1
+     */
+    convertSQLServerType(type: string): string;
+    /**
+     * Convert data value for D1 compatibility
+     */
+    convertValue(value: unknown, targetType: string): unknown;
+    /**
+     * Get type conversion warnings
+     */
+    getConversionWarnings(sourceType: string, targetType: string): string[];
+}>;
+//# sourceMappingURL=TypeConverter.d.ts.map

package/dist/schema/TypeConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeConverter.d.ts","sourceRoot":"","sources":["../../src/schema/TypeConverter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;gCACyB,MAAM,gBAAgB,MAAM,GAAG,MAAM;IA4BjE;;OAEG;2BACoB,MAAM,GAAG,MAAM;IAmCtC;;OAEG;gCACyB,MAAM,GAAG,MAAM;IAoC3C;;OAEG;+BACwB,MAAM,GAAG,MAAM;IAgC1C;;OAEG;wBACiB,OAAO,cAAc,MAAM,GAAG,OAAO;IAuBzD;;OAEG;sCAC+B,MAAM,cAAc,MAAM,GAAG,MAAM,EAAE;EA2BvE,CAAC"}

package/dist/schema/TypeConverter.js

@@ -0,0 +1,187 @@
+/**
+ * Type Converter
+ * Converts database types between different database systems
+ */
+import { Logger } from '@zintrust/core';
+/**
+ * TypeConverter - Sealed namespace for type conversion
+ * Provides database type conversion utilities
+ */
+export const TypeConverter = Object.freeze({
+    /**
+     * Convert column type to D1/SQLite compatible type
+     */
+    convertToD1Type(sourceType, sourceDriver) {
+        const normalizedType = sourceType.toLowerCase().trim();
+        // MySQL conversions
+        if (sourceDriver === 'mysql') {
+            return TypeConverter.convertMySQLType(normalizedType);
+        }
+        // PostgreSQL conversions
+        if (sourceDriver === 'postgresql') {
+            return TypeConverter.convertPostgreSQLType(normalizedType);
+        }
+        // SQL Server conversions
+        if (sourceDriver === 'sqlserver') {
+            return TypeConverter.convertSQLServerType(normalizedType);
+        }
+        // SQLite is already compatible
+        if (sourceDriver === 'sqlite') {
+            return normalizedType;
+        }
+        // Default fallback
+        Logger.warn(`Unknown source type: ${normalizedType}, defaulting to TEXT`);
+        return 'TEXT';
+    },
+    /**
+     * Convert MySQL types to D1
+     */
+    convertMySQLType(type) {
+        const conversions = {
+            varchar: 'TEXT',
+            char: 'TEXT',
+            text: 'TEXT',
+            longtext: 'TEXT',
+            mediumtext: 'TEXT',
+            tinytext: 'TEXT',
+            int: 'INTEGER',
+            integer: 'INTEGER',
+            bigint: 'INTEGER',
+            smallint: 'INTEGER',
+            tinyint: 'INTEGER',
+            decimal: 'REAL',
+            numeric: 'REAL',
+            float: 'REAL',
+            double: 'REAL',
+            datetime: 'TEXT',
+            timestamp: 'TEXT',
+            date: 'TEXT',
+            time: 'TEXT',
+            boolean: 'INTEGER',
+            'tinyint(1)': 'INTEGER',
+            json: 'TEXT',
+            enum: 'TEXT',
+            set: 'TEXT',
+            blob: 'BLOB',
+            longblob: 'BLOB',
+            mediumblob: 'BLOB',
+            tinyblob: 'BLOB',
+        };
+        return conversions[type] || 'TEXT';
+    },
+    /**
+     * Convert PostgreSQL types to D1
+     */
+    convertPostgreSQLType(type) {
+        const conversions = {
+            varchar: 'TEXT',
+            'character varying': 'TEXT',
+            char: 'TEXT',
+            character: 'TEXT',
+            text: 'TEXT',
+            integer: 'INTEGER',
+            int: 'INTEGER',
+            int4: 'INTEGER',
+            bigint: 'INTEGER',
+            int8: 'INTEGER',
+            smallint: 'INTEGER',
+            int2: 'INTEGER',
+            decimal: 'REAL',
+            numeric: 'REAL',
+            real: 'REAL',
+            float4: 'REAL',
+            'double precision': 'REAL',
+            float8: 'REAL',
+            timestamp: 'TEXT',
+            timestamptz: 'TEXT',
+            date: 'TEXT',
+            time: 'TEXT',
+            timetz: 'TEXT',
+            boolean: 'INTEGER',
+            bool: 'INTEGER',
+            json: 'TEXT',
+            jsonb: 'TEXT',
+            uuid: 'TEXT',
+            bytea: 'BLOB',
+        };
+        return conversions[type] || 'TEXT';
+    },
+    /**
+     * Convert SQL Server types to D1
+     */
+    convertSQLServerType(type) {
+        const conversions = {
+            varchar: 'TEXT',
+            char: 'TEXT',
+            nvarchar: 'TEXT',
+            nchar: 'TEXT',
+            text: 'TEXT',
+            ntext: 'TEXT',
+            int: 'INTEGER',
+            integer: 'INTEGER',
+            bigint: 'INTEGER',
+            smallint: 'INTEGER',
+            tinyint: 'INTEGER',
+            decimal: 'REAL',
+            numeric: 'REAL',
+            float: 'REAL',
+            real: 'REAL',
+            datetime: 'TEXT',
+            datetime2: 'TEXT',
+            smalldatetime: 'TEXT',
+            date: 'TEXT',
+            time: 'TEXT',
+            bit: 'INTEGER',
+            uniqueidentifier: 'TEXT',
+            varbinary: 'BLOB',
+            binary: 'BLOB',
+            image: 'BLOB',
+        };
+        return conversions[type] || 'TEXT';
+    },
+    /**
+     * Convert data value for D1 compatibility
+     */
+    convertValue(value, targetType) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        // Handle boolean conversion
+        if (targetType === 'INTEGER' && typeof value === 'boolean') {
+            return value ? 1 : 0;
+        }
+        // Handle date/time conversion
+        if (targetType === 'TEXT' && value instanceof Date) {
+            return value.toISOString();
+        }
+        // Handle JSON conversion
+        if (targetType === 'TEXT' && typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+        return value;
+    },
+    /**
+     * Get type conversion warnings
+     */
+    getConversionWarnings(sourceType, targetType) {
+        const warnings = [];
+        const normalizedSourceType = sourceType.toLowerCase();
+        // Precision loss warnings
+        if (normalizedSourceType.includes('decimal') && targetType === 'REAL') {
+            warnings.push('Decimal to REAL conversion may cause precision loss');
+        }
+        // Size limitations
+        if (normalizedSourceType.includes('longtext') && targetType === 'TEXT') {
+            warnings.push('Large text fields may have size limitations in SQLite');
+        }
+        // Boolean conversion
+        if (normalizedSourceType.includes('boolean') && targetType === 'INTEGER') {
+            warnings.push('Boolean values will be converted to 0/1 integers');
+        }
+        // JSON conversion
+        if (normalizedSourceType.includes('json') && targetType === 'TEXT') {
+            warnings.push('JSON fields will be stored as text strings');
+        }
+        return warnings;
+    },
+});

package/dist/schema/Validator.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Schema Validator
+ * Validates schemas and provides detailed error reporting
+ */
+import type { ColumnSchema, TableSchema } from '../types';
+/**
+ * SchemaValidator - Sealed namespace for schema validation
+ * Provides comprehensive schema validation utilities
+ */
+export declare const SchemaValidator: Readonly<{
+    /**
+     * Validate complete schema
+     */
+    validateSchema(tables: TableSchema[]): {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+    /**
+     * Validate single table
+     */
+    validateTable(table: TableSchema): {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+    /**
+     * Validate single column
+     */
+    validateColumn(column: ColumnSchema): {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+    /**
+     * Check for schema compatibility issues
+     */
+    checkCompatibility(issues: {
+        sourceDriver: string;
+        tables: TableSchema[];
+    }): {
+        blocking: string[];
+        warnings: string[];
+    };
+    /**
+     * Check column type compatibility for specific driver
+     */
+    checkColumnTypeCompatibility(type: string, sourceDriver: string, tableName: string, columnName: string): string | null;
+    /**
+     * Check MySQL-specific compatibility
+     */
+    checkMySQLCompatibility(type: string, tableName: string, columnName: string): string | null;
+    /**
+     * Check PostgreSQL-specific compatibility
+     */
+    checkPostgreSQLCompatibility(type: string, tableName: string, columnName: string): string | null;
+    /**
+     * Check SQL Server-specific compatibility
+     */
+    checkSQLServerCompatibility(type: string, tableName: string, columnName: string): string | null;
+    /**
+     * Check general compatibility issues
+     */
+    checkGeneralCompatibility(type: string, tableName: string, columnName: string): string | null;
+    /**
+     * Generate validation report
+     */
+    generateReport(validation: {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    }): string;
+}>;
+//# sourceMappingURL=Validator.d.ts.map

package/dist/schema/Validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Validator.d.ts","sourceRoot":"","sources":["../../src/schema/Validator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B;;OAEG;2BACoB,WAAW,EAAE,GAAG;QACrC,KAAK,EAAE,OAAO,CAAC;QACf,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB;IA8BD;;OAEG;yBACkB,WAAW,GAAG;QACjC,KAAK,EAAE,OAAO,CAAC;QACf,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB;IAyDD;;OAEG;2BACoB,YAAY,GAAG;QACpC,KAAK,EAAE,OAAO,CAAC;QACf,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB;IAoDD;;OAEG;+BACwB;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,EAAE,CAAA;KAAE,GAAG;QAC3E,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB;IAyBD;;OAEG;uCAEK,MAAM,gBACE,MAAM,aACT,MAAM,cACL,MAAM,GACjB,MAAM,GAAG,IAAI;IAahB;;OAEG;kCAC2B,MAAM,aAAa,MAAM,cAAc,MAAM,GAAG,MAAM,GAAG,IAAI;IAU3F;;OAEG;uCACgC,MAAM,aAAa,MAAM,cAAc,MAAM,GAAG,MAAM,GAAG,IAAI;IAUhG;;OAEG;sCAC+B,MAAM,aAAa,MAAM,cAAc,MAAM,GAAG,MAAM,GAAG,IAAI;IAU/F;;OAEG;oCAC6B,MAAM,aAAa,MAAM,cAAc,MAAM,GAAG,MAAM,GAAG,IAAI;IAO7F;;OAEG;+BACwB;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,MAAM;EAqB5F,CAAC"}