@zintrust/d1-migrator 0.4.0

package/dist/cli/DataMigrator.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Data Migrator
+ * Handles the actual data migration between databases
+ */
+import type { MigrationConfig, MigrationProgress } from '../types';
+/**
+ * Database connection types
+ */
+export interface SourceConnection {
+    driver: MigrationConfig['sourceDriver'];
+    connectionString: string;
+    connected: boolean;
+    adapter?: DatabaseAdapter;
+}
+export interface TargetConnection {
+    type: 'd1' | 'd1-remote';
+    database: string;
+    connected: boolean;
+    adapter?: DatabaseAdapter;
+}
+export interface TableInfo {
+    name: string;
+    rowCount?: number;
+}
+type AdapterQueryResult = {
+    rows: Record<string, unknown>[];
+    rowCount?: number;
+};
+type DatabaseAdapter = {
+    connect(): Promise<void>;
+    disconnect?(): Promise<void>;
+    query(sql: string, parameters: unknown[]): Promise<AdapterQueryResult>;
+};
+type MigrationVerificationError = {
+    table: string;
+    offset: number;
+    expectedRows: number;
+    insertedRows: number;
+};
+/**
+ * DataMigrator - Sealed namespace for data migration
+ * Provides chunked data migration with progress tracking
+ */
+export declare const DataMigrator: Readonly<{
+    /**
+     * Migrate data from source to target
+     */
+    migrateData(config: MigrationConfig): Promise<MigrationProgress>;
+    /**
+     * Connect to source database
+     */
+    connectToSource(config: MigrationConfig): Promise<SourceConnection>;
+    /**
+     * Connect to target D1 database
+     */
+    connectToTarget(config: MigrationConfig): Promise<TargetConnection>;
+    /**
+     * Prepare target schema using source structure
+     */
+    prepareTargetSchema(sourceConnection: SourceConnection, targetConnection: TargetConnection, config: MigrationConfig): Promise<void>;
+    /**
+     * Get schema information from source database
+     */
+    getSchemaInfo(_connection: SourceConnection): Promise<{
+        tables: TableInfo[];
+    }>;
+    /**
+     * Migrate single table
+     */
+    migrateTable(table: TableInfo, sourceConnection: SourceConnection, targetConnection: TargetConnection, config: MigrationConfig): Promise<{
+        rowsMigrated: number;
+        errors: string[];
+    }>;
+    /**
+     * Read data chunk from source database
+     */
+    readDataChunk(sourceConnection: SourceConnection, tableName: string, offset: number, batchSize: number): Promise<Record<string, unknown>[]>;
+    /**
+     * Transform data for D1 compatibility
+     */
+    transformData(chunk: Record<string, unknown>[], tableName: string): Promise<Record<string, unknown>[]>;
+    /**
+     * Insert data into target database
+     */
+    insertData(targetConnection: TargetConnection, tableName: string, data: Record<string, unknown>[]): Promise<number>;
+    /**
+     * Build chunked SELECT SQL by source driver
+     */
+    buildSelectChunkSQL(driver: MigrationConfig["sourceDriver"], tableName: string): string;
+    /**
+     * Build chunk verification error object
+     */
+    createChunkVerificationError(table: string, offset: number, expectedRows: number, insertedRows: number): MigrationVerificationError;
+    /**
+     * Create migration progress tracker
+     */
+    createProgress(migrationId: string): MigrationProgress;
+    /**
+     * Update migration progress
+     */
+    updateProgress(progress: MigrationProgress, updates: Partial<MigrationProgress>): MigrationProgress;
+}>;
+export {};
+//# sourceMappingURL=DataMigrator.d.ts.map

package/dist/cli/DataMigrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataMigrator.d.ts","sourceRoot":"","sources":["../../src/cli/DataMigrator.ts"],"names":[],"mappings":"AACA;;;GAGG;AAWH,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAEnE;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,eAAe,CAAC,cAAc,CAAC,CAAC;IACxC,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,IAAI,GAAG,WAAW,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,UAAU,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;CACxE,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAiEF;;;GAGG;AACH,eAAO,MAAM,YAAY;IACvB;;OAEG;wBACuB,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAqFtE;;OAEG;4BAC2B,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAoEzE;;OAEG;4BAC2B,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAyBzE;;OAEG;0CAEiB,gBAAgB,oBAChB,gBAAgB,UAC1B,eAAe,GACtB,OAAO,CAAC,IAAI,CAAC;IAmChB;;OAEG;+BAC8B,gBAAgB,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,SAAS,EAAE,CAAA;KAAE,CAAC;IAiBpF;;OAEG;wBAEM,SAAS,oBACE,gBAAgB,oBAChB,gBAAgB,UAC1B,eAAe,GACtB,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAyEtD;;OAEG;oCAEiB,gBAAgB,aACvB,MAAM,UACT,MAAM,aACH,MAAM,GAChB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAkBrC;;OAEG;yBAEM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,aACrB,MAAM,GAChB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IA4CrC;;OAEG;iCAEiB,gBAAgB,aACvB,MAAM,QACX,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAC9B,OAAO,CAAC,MAAM,CAAC;IAkClB;;OAEG;gCACyB,eAAe,CAAC,cAAc,CAAC,aAAa,MAAM,GAAG,MAAM;IAavF;;OAEG;wCAEM,MAAM,UACL,MAAM,gBACA,MAAM,gBACN,MAAM,GACnB,0BAA0B;IAS7B;;OAEG;gCACyB,MAAM,GAAG,iBAAiB;IAetD;;OAEG;6BAES,iBAAiB,WAClB,OAAO,CAAC,iBAAiB,CAAC,GAClC,iBAAiB;EAGpB,CAAC"}

package/dist/cli/DataMigrator.js

@@ -0,0 +1,431 @@
+/* eslint-disable no-await-in-loop */
+/**
+ * Data Migrator
+ * Handles the actual data migration between databases
+ */
+import { ErrorFactory, Logger } from '@zintrust/core';
+import { MySQLAdapter } from '@zintrust/db-mysql';
+import { PostgreSQLAdapter } from '@zintrust/db-postgres';
+import { SQLiteAdapter } from '@zintrust/db-sqlite';
+import { SQLServerAdapter } from '@zintrust/db-sqlserver';
+import { SchemaBuilder } from '../schema/SchemaBuilder';
+import { SchemaAnalyzer } from './SchemaAnalyzer';
+const parseConnectionDetails = (connectionString, defaultPort, defaultDatabase, defaultUsername) => {
+    try {
+        const parsed = new URL(connectionString);
+        const databaseName = decodeURIComponent(parsed.pathname.replace(/^\/+/, ''));
+        return {
+            host: parsed.hostname || 'localhost',
+            port: parsed.port ? Number.parseInt(parsed.port, 10) : defaultPort,
+            database: databaseName || defaultDatabase,
+            username: parsed.username ? decodeURIComponent(parsed.username) : defaultUsername,
+            password: parsed.password ? decodeURIComponent(parsed.password) : '',
+        };
+    }
+    catch (error) {
+        throw ErrorFactory.createValidationError('Invalid source connection string format', error);
+    }
+};
+const parseSqliteDatabasePath = (connectionString) => {
+    const trimmed = connectionString.trim();
+    if (trimmed.length === 0) {
+        return ':memory:';
+    }
+    if (!trimmed.includes('://')) {
+        return trimmed;
+    }
+    try {
+        const parsed = new URL(trimmed);
+        if (parsed.protocol !== 'sqlite:') {
+            return trimmed;
+        }
+        const pathName = decodeURIComponent(parsed.pathname);
+        return pathName.length > 0 ? pathName : ':memory:';
+    }
+    catch {
+        return trimmed;
+    }
+};
+const safelyDisconnect = async (label, connection) => {
+    try {
+        await connection?.adapter?.disconnect?.();
+    }
+    catch (error) {
+        Logger.warn(`Failed to close ${label} adapter: ${error}`);
+    }
+};
+/**
+ * DataMigrator - Sealed namespace for data migration
+ * Provides chunked data migration with progress tracking
+ */
+export const DataMigrator = Object.freeze({
+    /**
+     * Migrate data from source to target
+     */
+    async migrateData(config) {
+        Logger.info('Starting data migration...');
+        let sourceConnection = null;
+        let targetConnection = null;
+        try {
+            // Initialize progress tracking
+            const progress = {
+                migrationId: config.migrationId || 'unknown',
+                startTime: new Date(),
+                currentTable: '',
+                table: '',
+                totalTables: 0,
+                processedRows: 0,
+                totalRows: 0,
+                percentage: 0,
+                errors: {},
+                status: 'processing',
+            };
+            // Connect to source database
+            Logger.info('Connecting to source database...');
+            sourceConnection = await DataMigrator.connectToSource(config);
+            // Connect to target D1 database
+            Logger.info('Connecting to target D1 database...');
+            targetConnection = await DataMigrator.connectToTarget(config);
+            // Get schema information
+            const schema = await DataMigrator.getSchemaInfo(sourceConnection);
+            progress.totalTables = schema.tables.length;
+            // Calculate total rows for progress tracking
+            progress.totalRows = schema.tables.reduce((total, table) => total + (table.rowCount || 0), 0);
+            Logger.info(`Migrating ${progress.totalTables} tables with ${progress.totalRows} total rows`);
+            if (targetConnection.adapter) {
+                await DataMigrator.prepareTargetSchema(sourceConnection, targetConnection, config);
+            }
+            // Migrate each table sequentially for reliable D1/SQLite writes
+            Logger.info('Starting table migration...');
+            for (const table of schema.tables) {
+                Logger.info(`Migrating table: ${table.name}`);
+                const result = await DataMigrator.migrateTable(table, sourceConnection, targetConnection, config);
+                progress.processedRows += result.rowsMigrated;
+                // Add any errors to progress
+                if (result.errors.length > 0) {
+                    progress.errors[table.name] = result.errors.join('; ');
+                }
+                Logger.info(`Table ${table.name} completed: ${result.rowsMigrated} rows migrated`);
+            }
+            // Update final percentage
+            progress.percentage =
+                progress.totalRows > 0
+                    ? Math.round((progress.processedRows / progress.totalRows) * 100)
+                    : 0;
+            progress.status = Object.keys(progress.errors).length > 0 ? 'failed' : 'completed';
+            Logger.info(`Migration completed: ${progress.processedRows}/${progress.totalRows} rows migrated`);
+            return progress;
+        }
+        catch (error) {
+            Logger.error('Data migration failed:', error);
+            throw error;
+        }
+        finally {
+            await safelyDisconnect('source', sourceConnection);
+            await safelyDisconnect('target', targetConnection);
+        }
+    },
+    /**
+     * Connect to source database
+     */
+    async connectToSource(config) {
+        Logger.info(`Connecting to ${config.sourceDriver} database: ${config.sourceConnection}`);
+        let adapter;
+        switch (config.sourceDriver) {
+            case 'mysql':
+                adapter = MySQLAdapter.create({
+                    driver: 'mysql',
+                    connectionString: config.sourceConnection,
+                });
+                break;
+            case 'postgresql': {
+                const connectionDetails = parseConnectionDetails(config.sourceConnection, 5432, 'postgres', 'postgres');
+                adapter = PostgreSQLAdapter.create({
+                    driver: 'postgresql',
+                    host: connectionDetails.host,
+                    port: connectionDetails.port,
+                    database: connectionDetails.database,
+                    username: connectionDetails.username,
+                    password: connectionDetails.password,
+                });
+                break;
+            }
+            case 'sqlite':
+                adapter = SQLiteAdapter.create({
+                    driver: 'sqlite',
+                    database: parseSqliteDatabasePath(config.sourceConnection),
+                });
+                break;
+            case 'sqlserver': {
+                const connectionDetails = parseConnectionDetails(config.sourceConnection, 1433, 'master', 'sa');
+                adapter = SQLServerAdapter.create({
+                    driver: 'sqlserver',
+                    host: connectionDetails.host,
+                    port: connectionDetails.port,
+                    database: connectionDetails.database,
+                    username: connectionDetails.username,
+                    password: connectionDetails.password,
+                });
+                break;
+            }
+            default:
+                throw ErrorFactory.createValidationError(`Unsupported driver: ${config.sourceDriver}`);
+        }
+        await adapter.connect();
+        const connection = {
+            driver: config.sourceDriver,
+            connectionString: config.sourceConnection || '',
+            connected: true,
+            adapter,
+        };
+        Logger.info('✓ Source database connected');
+        return connection;
+    },
+    /**
+     * Connect to target D1 database
+     */
+    async connectToTarget(config) {
+        Logger.info(`Connecting to target D1 database: ${config.targetDatabase}`);
+        const connection = {
+            type: config.targetType,
+            database: config.targetDatabase,
+            connected: true,
+        };
+        if (config.targetType === 'd1') {
+            const d1LocalPath = `.wrangler/state/v3/d1/${config.targetDatabase}/db.sqlite`;
+            const d1Local = SQLiteAdapter.create({ driver: 'sqlite', database: d1LocalPath });
+            try {
+                await d1Local.connect();
+                connection.adapter = d1Local;
+            }
+            catch (error) {
+                Logger.warn(`Unable to connect local D1 path ${d1LocalPath}: ${error}`);
+            }
+        }
+        Logger.info('✓ Target D1 database connected');
+        return connection;
+    },
+    /**
+     * Prepare target schema using source structure
+     */
+    async prepareTargetSchema(sourceConnection, targetConnection, config) {
+        if (!targetConnection.adapter) {
+            Logger.warn('No target adapter available; skipping schema preparation');
+            return;
+        }
+        Logger.info('Preparing target D1 schema...');
+        const sourceSchema = await SchemaAnalyzer.analyzeSchema({
+            driver: sourceConnection.driver,
+            connectionString: sourceConnection.connectionString,
+        });
+        const d1Schema = SchemaBuilder.buildD1Schema(sourceSchema.tables, config.sourceDriver);
+        for (const table of d1Schema) {
+            const createSQL = SchemaBuilder.generateCreateTableSQL(table).replace(/^CREATE TABLE\s+/i, 'CREATE TABLE IF NOT EXISTS ');
+            await targetConnection.adapter.query(createSQL, []);
+            const indexSQL = SchemaBuilder.generateIndexSQL(table).map((sql) => sql
+                .replace(/^CREATE\s+UNIQUE\s+INDEX\s+/i, 'CREATE UNIQUE INDEX IF NOT EXISTS ')
+                .replace(/^CREATE\s+INDEX\s+/i, 'CREATE INDEX IF NOT EXISTS '));
+            for (const sql of indexSQL) {
+                await targetConnection.adapter.query(sql, []);
+            }
+        }
+        Logger.info(`✓ Target schema prepared for ${d1Schema.length} tables`);
+    },
+    /**
+     * Get schema information from source database
+     */
+    async getSchemaInfo(_connection) {
+        Logger.info('Retrieving schema information...');
+        const sourceSchema = await SchemaAnalyzer.analyzeSchema({
+            driver: _connection.driver,
+            connectionString: _connection.connectionString,
+        });
+        const tables = sourceSchema.tables.map((table) => ({
+            name: table.name,
+            rowCount: table.rowCount || 0,
+        }));
+        Logger.info(`Found ${tables.length} tables`);
+        return { tables };
+    },
+    /**
+     * Migrate single table
+     */
+    async migrateTable(table, sourceConnection, targetConnection, config) {
+        Logger.info(`Migrating table: ${table.name}`);
+        const errors = [];
+        let rowsMigrated = 0;
+        try {
+            const totalRows = table.rowCount || 0;
+            const batchSize = config.batchSize || 1000;
+            Logger.info(`Processing ${totalRows} rows in batches of ${batchSize}`);
+            // Process data in chunks sequentially for data integrity
+            for (let offset = 0; offset < totalRows; offset += batchSize) {
+                try {
+                    const chunk = await DataMigrator.readDataChunk(sourceConnection, table.name, offset, batchSize);
+                    if (chunk.length === 0)
+                        break;
+                    // Transform data for D1 compatibility
+                    const transformedChunk = await DataMigrator.transformData(chunk, table.name);
+                    // Insert data into target
+                    const insertedRows = await DataMigrator.insertData(targetConnection, table.name, transformedChunk);
+                    if (insertedRows !== chunk.length) {
+                        const verificationError = DataMigrator.createChunkVerificationError(table.name, offset, chunk.length, insertedRows);
+                        throw ErrorFactory.createValidationError(`Chunk insert mismatch on ${table.name}`, verificationError);
+                    }
+                    rowsMigrated += insertedRows;
+                    // Log progress for large tables
+                    if (totalRows > 10000 && rowsMigrated % (batchSize * 10) === 0) {
+                        const percentage = Math.round((rowsMigrated / totalRows) * 100);
+                        Logger.info(`Table ${table.name}: ${rowsMigrated}/${totalRows} (${percentage}%)`);
+                    }
+                }
+                catch (error) {
+                    const errorMsg = `Chunk processing failed at offset ${offset}: ${error}`;
+                    Logger.error(errorMsg);
+                    errors.push(errorMsg);
+                    // Continue with next chunk instead of failing completely
+                    continue;
+                }
+            }
+            Logger.info(`Table ${table.name} completed: ${rowsMigrated} rows migrated`);
+        }
+        catch (error) {
+            const errorMsg = `Failed to migrate table ${table.name}: ${error}`;
+            Logger.error(errorMsg);
+            errors.push(errorMsg);
+        }
+        return { rowsMigrated, errors };
+    },
+    /**
+     * Read data chunk from source database
+     */
+    async readDataChunk(sourceConnection, tableName, offset, batchSize) {
+        Logger.debug(`Reading chunk from ${tableName}: offset ${offset}, size ${batchSize}`);
+        if (!sourceConnection.adapter)
+            return [];
+        try {
+            const selectSql = DataMigrator.buildSelectChunkSQL(sourceConnection.driver, tableName);
+            const result = await sourceConnection.adapter.query(`${selectSql} LIMIT ${batchSize} OFFSET ${offset}`, []);
+            return result.rows || [];
+        }
+        catch (error) {
+            Logger.error(`Chunk read failed ${error}`);
+            return [];
+        }
+    },
+    /**
+     * Transform data for D1 compatibility
+     */
+    async transformData(chunk, tableName) {
+        Logger.debug(`Transforming ${chunk.length} rows for table ${tableName}`);
+        return chunk.map((row) => {
+            const transformed = {};
+            for (const [key, rawValue] of Object.entries(row)) {
+                const value = rawValue;
+                if (value === undefined) {
+                    transformed[key] = null;
+                    continue;
+                }
+                if (value instanceof Date) {
+                    transformed[key] = value.toISOString();
+                    continue;
+                }
+                if (typeof value === 'bigint') {
+                    transformed[key] = value.toString();
+                    continue;
+                }
+                if (typeof value === 'object' && value !== null) {
+                    const globalBuffer = globalThis;
+                    if (globalBuffer.Buffer?.isBuffer(value) === true || value instanceof Uint8Array) {
+                        transformed[key] = value;
+                        continue;
+                    }
+                    transformed[key] = JSON.stringify(value);
+                    continue;
+                }
+                transformed[key] = value;
+            }
+            return transformed;
+        });
+    },
+    /**
+     * Insert data into target database
+     */
+    async insertData(targetConnection, tableName, data) {
+        Logger.debug(`Inserting ${data.length} rows into ${tableName}`);
+        if (data.length === 0)
+            return 0;
+        if (!targetConnection.adapter) {
+            throw ErrorFactory.createValidationError(`No target adapter configured for ${targetConnection.database}`);
+        }
+        const keys = Object.keys(data[0]);
+        const columnList = keys.map((key) => `\`${key}\``).join(', ');
+        const placeholders = keys.map(() => '?').join(', ');
+        const sql = `INSERT INTO \`${tableName}\` (${columnList}) VALUES (${placeholders})`;
+        let insertedRows = 0;
+        for (const row of data) {
+            const values = keys.map((key) => row[key]);
+            try {
+                await targetConnection.adapter.query(sql, values);
+                insertedRows += 1;
+            }
+            catch (error) {
+                throw ErrorFactory.createValidationError(`Insert failed for table ${tableName}`, {
+                    sql,
+                    row,
+                    cause: error,
+                });
+            }
+        }
+        return insertedRows;
+    },
+    /**
+     * Build chunked SELECT SQL by source driver
+     */
+    buildSelectChunkSQL(driver, tableName) {
+        switch (driver) {
+            case 'postgresql':
+                return `SELECT * FROM "${tableName}"`;
+            case 'sqlserver':
+                return `SELECT * FROM [${tableName}]`;
+            case 'sqlite':
+            case 'mysql':
+            default:
+                return `SELECT * FROM \`${tableName}\``;
+        }
+    },
+    /**
+     * Build chunk verification error object
+     */
+    createChunkVerificationError(table, offset, expectedRows, insertedRows) {
+        return {
+            table,
+            offset,
+            expectedRows,
+            insertedRows,
+        };
+    },
+    /**
+     * Create migration progress tracker
+     */
+    createProgress(migrationId) {
+        return {
+            migrationId,
+            startTime: new Date(),
+            currentTable: '',
+            table: '',
+            totalTables: 0,
+            totalRows: 0,
+            processedRows: 0,
+            percentage: 0,
+            errors: {},
+            status: 'pending',
+        };
+    },
+    /**
+     * Update migration progress
+     */
+    updateProgress(progress, updates) {
+        return { ...progress, ...updates };
+    },
+});

package/dist/cli/MigrateToD1Command.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Migrate to D1 Command
+ * CLI command for migrating databases to Cloudflare D1
+ */
+import { type CommandOptions } from '@zintrust/core/cli';
+import type { Command } from 'commander';
+import type { MigrationConfig } from '../types';
+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;
+};
+/**
+ * MigrateToD1Command - CLI command for D1 migration
+ * Uses BaseCommand factory following ZinTrust patterns
+ */
+export declare const MigrateToD1Command: D1MigratorCommand;
+/**
+ * Execute migration process
+ */
+declare function executeMigration(config: MigrationConfig): Promise<void>;
+/**
+ * Run in interactive mode
+ */
+declare function runInteractiveMode(config: MigrationConfig): Promise<void>;
+/**
+ * Run in automated mode
+ */
+declare function runAutomatedMode(config: MigrationConfig): Promise<void>;
+/**
+ * Validate migration configuration
+ */
+declare function validateConfig(config: MigrationConfig): {
+    valid: boolean;
+    errors: string[];
+};
+export declare const MigrationExecutor: Readonly<{
+    executeMigration: typeof executeMigration;
+    runInteractiveMode: typeof runInteractiveMode;
+    runAutomatedMode: typeof runAutomatedMode;
+    validateConfig: typeof validateConfig;
+}>;
+export {};
+//# sourceMappingURL=MigrateToD1Command.d.ts.map

package/dist/cli/MigrateToD1Command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrateToD1Command.d.ts","sourceRoot":"","sources":["../../src/cli/MigrateToD1Command.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAe,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAOhD,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;AAubF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,iBAgG/B,CAAC;AAEH;;GAEG;AACH,iBAAe,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CActE;AAED;;GAEG;AACH,iBAAe,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAkGxE;AAED;;GAEG;AACH,iBAAe,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAiGtE;AAED;;GAEG;AACH,iBAAS,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CA2BrF;AAGD,eAAO,MAAM,iBAAiB;;;;;EAK5B,CAAC"}