@zintrust/d1-migrator 1.9.2 → 1.9.5

package/dist/cli/DataMigrator.d.ts

@@ -13,17 +13,34 @@ export interface SourceConnection {
     sourceSsl?: boolean;
     connected: boolean;
     adapter?: DatabaseAdapter;
+    sourceBatchTuning?: SourceBatchTuning;
 }
+type SourceBatchHistoryEntry = {
+    rowsRead: number;
+    durationMs: number;
+    timePerRow: number;
+};
+type SourceBatchTuning = {
+    readBatchSize: number;
+    readBatchHistory: SourceBatchHistoryEntry[];
+};
 export interface TargetConnection {
     type: 'd1' | 'd1-remote';
     database: string;
     connected: boolean;
     adapter?: DatabaseAdapter;
+    remoteBatchTuning?: RemoteBatchTuning;
 }
 export interface TableInfo {
     name: string;
     rowCount?: number;
+    dependsOn?: string[];
 }
+type RemoteBatchTuning = {
+    rowsPerStatement: number;
+    maxStatementSqlLength: number;
+    maxExecutionSqlLength: number;
+};
 type AdapterQueryResult = {
     rows: Record<string, unknown>[];
     rowCount?: number;
@@ -77,6 +94,7 @@ export declare const DataMigrator: Readonly<{
         rowsMigrated: number;
         errors: string[];
     }>;
+    processTableChunks(table: TableInfo, sourceConnection: SourceConnection, targetConnection: TargetConnection, totalRows: number, batchSize: number, startOffset: number, errors: string[]): Promise<number>;
     /**
      * Read data chunk from source database
      */
@@ -84,7 +102,7 @@ export declare const DataMigrator: Readonly<{
     /**
      * Transform data for D1 compatibility
      */
-    transformData(chunk: Record<string, unknown>[], tableName: string): Promise<Record<string, unknown>[]>;
+    transformData(chunk: Record<string, unknown>[], _tableName: string): Promise<Record<string, unknown>[]>;
     /**
      * Insert data into target database
      */

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

@@ -1 +1 @@
-{"version":3,"file":"DataMigrator.d.ts","sourceRoot":"","sources":["../../src/cli/DataMigrator.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"DataMigrator.d.ts","sourceRoot":"","sources":["../../src/cli/DataMigrator.ts"],"names":[],"mappings":"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"}

package/dist/cli/DataMigrator.js

@@ -22,6 +22,35 @@ const extractWranglerJson = (output) => {
         return null;
     }
 };
+const normalizeWranglerTableValue = (value) => {
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return '';
+    }
+    const normalized = trimmed.toLowerCase();
+    if (normalized === 'null') {
+        return null;
+    }
+    if (normalized === 'true') {
+        return true;
+    }
+    if (normalized === 'false') {
+        return false;
+    }
+    if (/^-?\d+$/.test(trimmed)) {
+        const parsed = Number.parseInt(trimmed, 10);
+        if (Number.isSafeInteger(parsed)) {
+            return parsed;
+        }
+    }
+    if (/^-?(?:\d+\.\d+|\d+\.\d*|\.\d+)$/.test(trimmed)) {
+        const parsed = Number.parseFloat(trimmed);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return trimmed;
+};
 const parseWranglerTable = (output) => {
     const lines = output.split('\n').map((line) => line.trim());
     const dataLines = lines.filter((line) => line.startsWith('│') && line.endsWith('│'));
@@ -49,6 +78,15 @@ const parseWranglerTable = (output) => {
     }
     return rows;
 };
+const parseWranglerTableRows = (output) => {
+    return parseWranglerTable(output).map((row) => {
+        const normalizedRow = {};
+        for (const [key, value] of Object.entries(row)) {
+            normalizedRow[key] = normalizeWranglerTableValue(value);
+        }
+        return normalizedRow;
+    });
+};
 const toHex = (value) => {
     return Array.from(value)
         .map((byte) => byte.toString(16).padStart(2, '0'))
@@ -59,10 +97,10 @@ const toSqlLiteral = (value) => {
         return 'NULL';
     }
     if (value instanceof Date) {
-        return `'${value.toISOString().replace(/'/g, "''")}'`;
+        return `'${value.toISOString().replaceAll("'", "''")}'`;
     }
     if (typeof value === 'string') {
-        return `'${value.replace(/'/g, "''")}'`;
+        return `'${value.replaceAll("'", "''")}'`;
     }
     if (typeof value === 'number') {
         if (!Number.isFinite(value)) {
@@ -81,11 +119,11 @@ const toSqlLiteral = (value) => {
         const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
         return `X'${toHex(bytes)}'`;
     }
-    return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+    return `'${JSON.stringify(value).replaceAll("'", "''")}'`;
 };
 const bindSqlParameters = (sql, parameters) => {
     let index = 0;
-    return sql.replace(/\?/g, () => {
+    return sql.replaceAll('?', () => {
         if (index >= parameters.length) {
             throw ErrorFactory.createValidationError('Remote D1 SQL parameter count mismatch');
         }
@@ -94,6 +132,460 @@ const bindSqlParameters = (sql, parameters) => {
         return rendered;
     });
 };
+const REMOTE_INSERT_ROWS_PER_STATEMENT = 1000;
+const LOCAL_INSERT_ROWS_PER_STATEMENT = 500;
+const MAX_REMOTE_INSERT_SQL_LENGTH = 300000;
+const MAX_REMOTE_EXECUTION_SQL_LENGTH = 800000;
+const MIN_REMOTE_INSERT_ROWS_PER_STATEMENT = 100;
+const MAX_REMOTE_INSERT_ROWS_PER_STATEMENT = 3000;
+const DEFAULT_REMOTE_TABLE_PARALLELISM = 8;
+const DEFAULT_SOURCE_READ_BATCH_SIZE = 250;
+const MIN_SOURCE_READ_BATCH_SIZE = 50;
+const MAX_SOURCE_READ_BATCH_SIZE = 1500;
+const SOURCE_READ_TARGET_TIME_MS = 5000;
+const SOURCE_CONNECT_RETRY_ATTEMPTS = 3;
+const SOURCE_CONNECT_RETRY_BASE_DELAY_MS = 500;
+const formatDuration = (durationMs) => {
+    if (durationMs < 1000) {
+        return `${durationMs}ms`;
+    }
+    return `${(durationMs / 1000).toFixed(durationMs < 10000 ? 2 : 1)}s`;
+};
+const formatRowsPerSecond = (rows, durationMs) => {
+    if (rows <= 0 || durationMs <= 0) {
+        return 'n/a';
+    }
+    const rate = rows / (durationMs / 1000);
+    return `${rate >= 100 ? rate.toFixed(0) : rate.toFixed(2)} rows/s`;
+};
+const waitMs = async (durationMs) => {
+    await new Promise((resolve) => {
+        const start = Date.now();
+        const poll = () => {
+            if (Date.now() - start >= durationMs) {
+                resolve();
+                return;
+            }
+            globalThis.queueMicrotask(poll);
+        };
+        poll();
+    });
+};
+const calculateOptimalBatchSize = (measuredTimePerRowMs, targetTimePerBatchMs = 5000, minBatchSize = 100, maxBatchSize = 3000) => {
+    if (measuredTimePerRowMs <= 0) {
+        return minBatchSize;
+    }
+    const calculatedSize = Math.floor(targetTimePerBatchMs / measuredTimePerRowMs);
+    return Math.max(minBatchSize, Math.min(maxBatchSize, calculatedSize));
+};
+const getSourceBatchTuning = (connection, initialBatchSize) => {
+    if (connection.sourceBatchTuning !== undefined) {
+        return connection.sourceBatchTuning;
+    }
+    const startingBatchSize = Math.max(MIN_SOURCE_READ_BATCH_SIZE, Math.min(DEFAULT_SOURCE_READ_BATCH_SIZE, initialBatchSize));
+    connection.sourceBatchTuning = {
+        readBatchSize: startingBatchSize,
+        readBatchHistory: [],
+    };
+    return connection.sourceBatchTuning;
+};
+const isRetryableConnectionError = (error) => {
+    const message = getErrorMessage(error).toLowerCase();
+    return (message.includes('etimedout') ||
+        message.includes('timed out') ||
+        message.includes('timeout') ||
+        message.includes('econnreset') ||
+        message.includes('connection lost') ||
+        message.includes('server has gone away') ||
+        message.includes('read timeout') ||
+        message.includes('write timeout') ||
+        message.includes('wait_timeout'));
+};
+const connectWithRetry = async (adapter, label) => {
+    let lastError;
+    for (let attempt = 0; attempt < SOURCE_CONNECT_RETRY_ATTEMPTS; attempt += 1) {
+        try {
+            await adapter.connect();
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            const retryable = isRetryableConnectionError(error);
+            const isLastAttempt = attempt >= SOURCE_CONNECT_RETRY_ATTEMPTS - 1;
+            if (!retryable || isLastAttempt) {
+                throw error;
+            }
+            const delayMs = SOURCE_CONNECT_RETRY_BASE_DELAY_MS * 2 ** attempt;
+            Logger.warn(`[DataMigrator] ${label} connect failed on attempt ${attempt + 1}/${SOURCE_CONNECT_RETRY_ATTEMPTS}, retrying in ${delayMs}ms: ${getErrorMessage(error)}`);
+            await waitMs(delayMs);
+        }
+    }
+    throw lastError;
+};
+const updateSourceBatchTuningAfterSuccess = (connection, rowsRead, durationMs, batchSize) => {
+    const tuning = getSourceBatchTuning(connection, batchSize);
+    const timePerRow = rowsRead > 0 ? durationMs / rowsRead : durationMs;
+    tuning.readBatchHistory.push({ rowsRead, durationMs, timePerRow });
+    if (tuning.readBatchHistory.length > 10) {
+        tuning.readBatchHistory.shift();
+    }
+    const avgTimePerRow = tuning.readBatchHistory.reduce((sum, entry) => sum + entry.timePerRow, 0) /
+        tuning.readBatchHistory.length;
+    const targetTimePerBatchMs = Math.max(1000, Math.min(SOURCE_READ_TARGET_TIME_MS, Math.floor(batchSize * 5)));
+    const optimalSize = calculateOptimalBatchSize(avgTimePerRow, targetTimePerBatchMs, MIN_SOURCE_READ_BATCH_SIZE, MAX_SOURCE_READ_BATCH_SIZE);
+    if (Math.abs(optimalSize - tuning.readBatchSize) >= 50) {
+        tuning.readBatchSize = optimalSize;
+        Logger.info(`[DataMigrator] Adaptive source batching: adjusted to ${optimalSize} rows (avg ${avgTimePerRow.toFixed(2)}ms/row)`);
+    }
+};
+const reduceSourceBatchSizeAfterTimeout = (connection, batchSize) => {
+    const tuning = getSourceBatchTuning(connection, batchSize);
+    const reducedSize = Math.max(MIN_SOURCE_READ_BATCH_SIZE, Math.floor(Math.min(tuning.readBatchSize, batchSize) / 2));
+    if (reducedSize < tuning.readBatchSize) {
+        tuning.readBatchSize = reducedSize;
+        Logger.warn(`[DataMigrator] Adaptive source batching: reduced to ${reducedSize} rows after timeout-like failure`);
+    }
+    return reducedSize;
+};
+const getRemoteBatchTuning = (connection) => {
+    if (connection.remoteBatchTuning !== undefined) {
+        return connection.remoteBatchTuning;
+    }
+    connection.remoteBatchTuning = {
+        rowsPerStatement: REMOTE_INSERT_ROWS_PER_STATEMENT,
+        maxStatementSqlLength: MAX_REMOTE_INSERT_SQL_LENGTH,
+        maxExecutionSqlLength: MAX_REMOTE_EXECUTION_SQL_LENGTH,
+    };
+    return connection.remoteBatchTuning;
+};
+const getInsertBatchSettings = (connection) => {
+    if (connection.type === 'd1-remote') {
+        const tuning = getRemoteBatchTuning(connection);
+        return {
+            rowsPerStatement: tuning.rowsPerStatement,
+            maxStatementSqlLength: tuning.maxStatementSqlLength,
+            maxExecutionSqlLength: tuning.maxExecutionSqlLength,
+        };
+    }
+    return {
+        rowsPerStatement: LOCAL_INSERT_ROWS_PER_STATEMENT,
+        maxStatementSqlLength: Number.POSITIVE_INFINITY,
+        maxExecutionSqlLength: Number.POSITIVE_INFINITY,
+    };
+};
+const adjustRemoteBatchTuning = (connection, executedRows, durationMs, sqlLength) => {
+    if (connection.type !== 'd1-remote' || executedRows <= 0) {
+        return;
+    }
+    const tuning = getRemoteBatchTuning(connection);
+    const previousRowsPerStatement = tuning.rowsPerStatement;
+    const nearSqlLimit = sqlLength >= Math.floor(tuning.maxExecutionSqlLength * 0.9);
+    if (durationMs <= 2500 &&
+        executedRows >= Math.floor(previousRowsPerStatement * 0.8) &&
+        !nearSqlLimit) {
+        tuning.rowsPerStatement = Math.min(MAX_REMOTE_INSERT_ROWS_PER_STATEMENT, Math.max(previousRowsPerStatement + 50, Math.floor(previousRowsPerStatement * 1.3)));
+    }
+    else if (durationMs >= 10000 || nearSqlLimit) {
+        tuning.rowsPerStatement = Math.max(MIN_REMOTE_INSERT_ROWS_PER_STATEMENT, Math.min(previousRowsPerStatement - 50, Math.floor(previousRowsPerStatement * 0.8)));
+    }
+    if (tuning.rowsPerStatement !== previousRowsPerStatement) {
+        Logger.info(`[DataMigrator] Adaptive remote batching: rows_per_statement ${previousRowsPerStatement} -> ${tuning.rowsPerStatement} after ${executedRows} rows in ${formatDuration(durationMs)}`);
+    }
+};
+const reduceRemoteBatchTuningAfterFailure = (connection, sqlLength) => {
+    if (connection.type !== 'd1-remote') {
+        return;
+    }
+    const tuning = getRemoteBatchTuning(connection);
+    const previousRowsPerStatement = tuning.rowsPerStatement;
+    const nearSqlLimit = sqlLength >= Math.floor(tuning.maxExecutionSqlLength * 0.8);
+    if (!nearSqlLimit && previousRowsPerStatement <= MIN_REMOTE_INSERT_ROWS_PER_STATEMENT) {
+        return;
+    }
+    tuning.rowsPerStatement = Math.max(MIN_REMOTE_INSERT_ROWS_PER_STATEMENT, Math.min(previousRowsPerStatement - 50, Math.floor(previousRowsPerStatement * 0.5)));
+    if (tuning.rowsPerStatement !== previousRowsPerStatement) {
+        Logger.warn(`[DataMigrator] Adaptive remote batching: rows_per_statement ${previousRowsPerStatement} -> ${tuning.rowsPerStatement} after failed remote insert`);
+    }
+};
+const logTableMigrationProgress = (table, rowsMigrated, totalRows, batchSize) => {
+    if (totalRows <= 10000 || rowsMigrated % (batchSize * 10) !== 0) {
+        return;
+    }
+    const normalizedTotalRows = Math.max(totalRows, rowsMigrated);
+    const percentage = Math.round((rowsMigrated / normalizedTotalRows) * 100);
+    Logger.info(`Table ${table.name}: ${rowsMigrated}/${normalizedTotalRows} (${percentage}%)`);
+};
+const getTableChunkBatchSize = (sourceConnection, retryBatchSize) => {
+    if (sourceConnection.driver !== 'mysql') {
+        return retryBatchSize;
+    }
+    return getSourceBatchTuning(sourceConnection, retryBatchSize).readBatchSize;
+};
+const applyTableChunkResult = (state, result, initialBatchSize, table, totalRows) => {
+    const nextState = {
+        rowsMigrated: state.rowsMigrated + result.rowsMigrated,
+        offset: result.nextOffset,
+        currentBatchSize: result.nextBatchSize,
+        retryBatchSize: result.nextBatchSize,
+    };
+    logTableMigrationProgress(table, nextState.rowsMigrated, totalRows, nextState.currentBatchSize);
+    if (!result.continueProcessing &&
+        result.rowsMigrated === 0 &&
+        result.nextBatchSize < initialBatchSize) {
+        return nextState;
+    }
+    return nextState;
+};
+const verifyChunkInsertCount = (tableName, offset, expectedRows, insertedRows) => {
+    if (insertedRows === expectedRows) {
+        return;
+    }
+    const verificationError = DataMigrator.createChunkVerificationError(tableName, offset, expectedRows, insertedRows);
+    throw ErrorFactory.createValidationError(`Chunk insert mismatch on ${tableName}`, verificationError);
+};
+const logChunkProcessingSuccess = (tableName, offset, insertedRows, chunkDurationMs) => {
+    Logger.info(`[DataMigrator] Chunk ${tableName} offset=${offset} rows=${insertedRows} duration=${formatDuration(chunkDurationMs)} rate=${formatRowsPerSecond(insertedRows, chunkDurationMs)}`);
+};
+const executeChunkRows = async (context) => {
+    const chunk = await DataMigrator.readDataChunk(context.sourceConnection, context.table.name, context.offset, context.batchSize);
+    if (chunk.length === 0) {
+        return null;
+    }
+    const transformedChunk = await DataMigrator.transformData(chunk, context.table.name);
+    const insertedRows = await DataMigrator.insertData(context.targetConnection, context.table.name, transformedChunk);
+    verifyChunkInsertCount(context.table.name, context.offset, chunk.length, insertedRows);
+    return {
+        chunkLength: chunk.length,
+        insertedRows,
+    };
+};
+const createEmptyChunkResult = (offset, batchSize) => {
+    return {
+        rowsMigrated: 0,
+        nextOffset: offset,
+        nextBatchSize: batchSize,
+        continueProcessing: false,
+    };
+};
+const buildChunkProcessingSuccessResult = async (table, sourceConnection, targetConnection, offset, batchSize) => {
+    const chunkStartTime = Date.now();
+    const executionResult = await executeChunkRows({
+        table,
+        sourceConnection,
+        targetConnection,
+        offset,
+        batchSize,
+    });
+    if (executionResult === null) {
+        return createEmptyChunkResult(offset, batchSize);
+    }
+    const { chunkLength, insertedRows } = executionResult;
+    const chunkDurationMs = Date.now() - chunkStartTime;
+    if (sourceConnection.driver === 'mysql') {
+        updateSourceBatchTuningAfterSuccess(sourceConnection, insertedRows, chunkDurationMs, batchSize);
+    }
+    logChunkProcessingSuccess(table.name, offset, insertedRows, chunkDurationMs);
+    if (chunkLength < batchSize) {
+        return {
+            rowsMigrated: insertedRows,
+            nextOffset: offset + chunkLength,
+            nextBatchSize: batchSize,
+            continueProcessing: false,
+        };
+    }
+    return {
+        rowsMigrated: insertedRows,
+        nextOffset: offset + batchSize,
+        nextBatchSize: batchSize,
+        continueProcessing: true,
+    };
+};
+const buildChunkProcessingFailureResult = (sourceConnection, offset, batchSize, error, errors) => {
+    const errorMessage = getErrorMessage(error);
+    const errorMsg = `Chunk processing failed at offset ${offset}: ${errorMessage}`;
+    Logger.warn(errorMsg);
+    errors.push(errorMsg);
+    if (sourceConnection.driver === 'mysql' && isRetryableConnectionError(error)) {
+        const reducedBatchSize = reduceSourceBatchSizeAfterTimeout(sourceConnection, batchSize);
+        return {
+            rowsMigrated: 0,
+            nextOffset: offset,
+            nextBatchSize: reducedBatchSize,
+            continueProcessing: reducedBatchSize >= batchSize,
+        };
+    }
+    return {
+        rowsMigrated: 0,
+        nextOffset: offset + batchSize,
+        nextBatchSize: batchSize,
+        continueProcessing: true,
+    };
+};
+const processTableChunk = async (table, sourceConnection, targetConnection, offset, batchSize, errors) => {
+    try {
+        return await buildChunkProcessingSuccessResult(table, sourceConnection, targetConnection, offset, batchSize);
+    }
+    catch (error) {
+        return buildChunkProcessingFailureResult(sourceConnection, offset, batchSize, error, errors);
+    }
+};
+const getTableDependencies = (table) => {
+    if (!Array.isArray(table.dependsOn)) {
+        return [];
+    }
+    return [...new Set(table.dependsOn.filter((dependency) => dependency.trim() !== ''))];
+};
+const buildTableMigrationLevels = (tables) => {
+    const tablesByName = new Map();
+    for (const table of tables) {
+        tablesByName.set(table.name, table);
+    }
+    const unresolved = new Set(tables.map((table) => table.name));
+    const dependenciesByTable = new Map();
+    for (const table of tables) {
+        dependenciesByTable.set(table.name, new Set(getTableDependencies(table).filter((dependency) => dependency !== table.name && tablesByName.has(dependency))));
+    }
+    const levels = [];
+    while (unresolved.size > 0) {
+        const readyNames = tables
+            .map((table) => table.name)
+            .filter((name) => unresolved.has(name) && (dependenciesByTable.get(name)?.size ?? 0) === 0);
+        if (readyNames.length === 0) {
+            const cyclicTables = tables.filter((table) => unresolved.has(table.name));
+            if (cyclicTables.length > 0) {
+                Logger.warn(`[DataMigrator] Table dependency cycle or unresolved reference detected. Falling back to sequential execution for: ${cyclicTables.map((table) => table.name).join(', ')}`);
+                levels.push(...cyclicTables.map((table) => [table]));
+            }
+            break;
+        }
+        const levelTables = readyNames
+            .map((name) => tablesByName.get(name))
+            .filter((table) => table !== undefined);
+        levels.push(levelTables);
+        for (const readyName of readyNames) {
+            unresolved.delete(readyName);
+        }
+        for (const name of unresolved) {
+            const dependencies = dependenciesByTable.get(name);
+            for (const readyName of readyNames) {
+                dependencies?.delete(readyName);
+            }
+        }
+    }
+    return levels;
+};
+const getTableParallelism = (config, targetConnection) => {
+    if (targetConnection.type !== 'd1-remote') {
+        return 1;
+    }
+    if (config.sourceDriver === 'sqlite') {
+        return 1;
+    }
+    return DEFAULT_REMOTE_TABLE_PARALLELISM;
+};
+const executeWithConcurrency = async (items, concurrency, worker) => {
+    if (items.length === 0) {
+        return [];
+    }
+    const effectiveConcurrency = Math.max(1, Math.min(concurrency, items.length));
+    const results = new Array(items.length);
+    let index = 0;
+    const runWorker = async () => {
+        while (index < items.length) {
+            const currentIndex = index;
+            index += 1;
+            results[currentIndex] = await worker(items[currentIndex]);
+        }
+    };
+    await Promise.all(Array.from({ length: effectiveConcurrency }, () => runWorker()));
+    return results;
+};
+const estimateRemoteRowSqlLength = (keys, row) => {
+    const delimitersLength = keys.length > 0 ? (keys.length - 1) * 2 : 0;
+    const valuesLength = keys.reduce((total, key) => {
+        return total + toSqlLiteral(row[key]).length;
+    }, 0);
+    return valuesLength + delimitersLength + 2;
+};
+const createInsertStatements = (targetType, settings, tableName, data) => {
+    if (data.length === 0) {
+        return [];
+    }
+    const keys = Object.keys(data[0]);
+    const columnList = keys.map((key) => `\`${key}\``).join(', ');
+    const rowPlaceholder = `(${keys.map(() => '?').join(', ')})`;
+    const prefix = `INSERT INTO \`${tableName}\` (${columnList}) VALUES `;
+    const rowLimit = settings.rowsPerStatement;
+    const maxSqlLength = settings.maxStatementSqlLength;
+    const statements = [];
+    let batchRows = [];
+    let batchParameters = [];
+    let batchSqlLength = prefix.length;
+    const flushBatch = () => {
+        if (batchRows.length === 0) {
+            return;
+        }
+        statements.push({
+            sql: `${prefix}${batchRows.map(() => rowPlaceholder).join(', ')}`,
+            parameters: batchParameters,
+            rowCount: batchRows.length,
+        });
+        batchRows = [];
+        batchParameters = [];
+        batchSqlLength = prefix.length;
+    };
+    for (const row of data) {
+        const rowParameters = keys.map((key) => row[key]);
+        const rowSqlLength = targetType === 'd1-remote' ? estimateRemoteRowSqlLength(keys, row) : rowPlaceholder.length;
+        const separatorLength = batchRows.length > 0 ? 2 : 0;
+        const nextSqlLength = batchSqlLength + separatorLength + rowSqlLength;
+        if (batchRows.length > 0 && (batchRows.length >= rowLimit || nextSqlLength > maxSqlLength)) {
+            flushBatch();
+        }
+        batchRows.push(row);
+        batchParameters.push(...rowParameters);
+        batchSqlLength += (batchRows.length > 1 ? 2 : 0) + rowSqlLength;
+    }
+    flushBatch();
+    return statements;
+};
+const createRemoteExecutionBatchesWithLimit = (statements, maxExecutionSqlLength) => {
+    if (statements.length <= 1) {
+        return statements;
+    }
+    const batches = [];
+    let sqlParts = [];
+    let parameters = [];
+    let rowCount = 0;
+    let currentLength = 0;
+    const flushBatch = () => {
+        if (sqlParts.length === 0) {
+            return;
+        }
+        batches.push({
+            sql: sqlParts.join(';\n'),
+            parameters,
+            rowCount,
+        });
+        sqlParts = [];
+        parameters = [];
+        rowCount = 0;
+        currentLength = 0;
+    };
+    for (const statement of statements) {
+        const separatorLength = sqlParts.length > 0 ? 2 : 0;
+        const nextLength = currentLength + separatorLength + statement.sql.length;
+        if (sqlParts.length > 0 && nextLength > maxExecutionSqlLength) {
+            flushBatch();
+        }
+        sqlParts.push(statement.sql);
+        parameters.push(...statement.parameters);
+        rowCount += statement.rowCount;
+        currentLength += (sqlParts.length > 1 ? 2 : 0) + statement.sql.length;
+    }
+    flushBatch();
+    return batches;
+};
 const createRemoteD1Adapter = (database) => {
     return {
         async connect() {
@@ -107,38 +599,22 @@ const createRemoteD1Adapter = (database) => {
             const output = WranglerD1.executeSql({ dbName: database, isLocal: false, sql: renderedSql });
             const payload = extractWranglerJson(output);
             if (payload === null || payload.length === 0) {
-                const rows = parseWranglerTable(output).map((row) => row);
+                const rows = parseWranglerTableRows(output);
                 return { rows, rowCount: rows.length };
             }
-            const last = payload[payload.length - 1];
+            const last = payload.at(-1);
+            if (last === undefined) {
+                return { rows: [], rowCount: 0 };
+            }
             const rows = Array.isArray(last.results) ? last.results : [];
-            const changes = last.meta?.changes;
-            const rowCount = typeof changes === 'number' ? changes : rows.length;
+            const totalChanges = payload.reduce((count, statement) => {
+                return count + (typeof statement.meta?.changes === 'number' ? statement.meta.changes : 0);
+            }, 0);
+            const rowCount = totalChanges > 0 ? totalChanges : rows.length;
             return { rows, rowCount };
         },
     };
 };
-const redactConnectionString = (connectionString) => {
-    try {
-        const parsed = new URL(connectionString);
-        if (parsed.password.trim() !== '') {
-            parsed.password = '***';
-        }
-        return parsed.toString();
-    }
-    catch {
-        return connectionString;
-    }
-};
-const getUrlPasswordForm = (connectionString) => {
-    try {
-        const parsed = new URL(connectionString);
-        return parsed.password || '';
-    }
-    catch {
-        return undefined;
-    }
-};
 const getErrorCause = (error) => {
     if (error === null || typeof error !== 'object') {
         return undefined;
@@ -182,19 +658,11 @@ const logDetailedError = (label, error) => {
     if (driverDetails !== undefined) {
         Logger.error(`${label} driver details: ${driverDetails}`);
     }
-    if (error instanceof Error && typeof error.stack === 'string' && error.stack.trim() !== '') {
-        Logger.error(`${label} stack: ${error.stack}`);
-    }
     const cause = getErrorCause(error);
     if (cause !== undefined) {
         logDetailedError(`${label} cause`, cause);
     }
 };
-const describePasswordForLog = (password) => {
-    const hasSpecialCharacters = /[^a-zA-Z0-9]/.test(password);
-    const containsBang = password.includes('!');
-    return `len=${password.length}, special_chars=${hasSpecialCharacters}, contains_bang=${containsBang}`;
-};
 const normalizeNullLikeValue = (value) => {
     if (typeof value !== 'string')
         return value;
@@ -240,11 +708,6 @@ const createSourceAdapter = (config) => {
     switch (config.sourceDriver) {
         case 'mysql': {
             const connectionDetails = parseConnectionDetails(config.sourceConnection, 3306, 'mysql', 'root');
-            const urlPasswordForm = getUrlPasswordForm(config.sourceConnection);
-            Logger.info(`[DataMigrator] Source password diagnostics: ${describePasswordForLog(connectionDetails.password)}`);
-            if (urlPasswordForm !== undefined) {
-                Logger.info(`[DataMigrator] MySQL password handoff: url_form(${describePasswordForLog(urlPasswordForm)}), final_auth(${describePasswordForLog(connectionDetails.password)}), matches=${urlPasswordForm === connectionDetails.password}`);
-            }
             return MySQLAdapter.create({
                 driver: 'mysql',
                 host: connectionDetails.host,
@@ -253,6 +716,14 @@ const createSourceAdapter = (config) => {
                 username: connectionDetails.username,
                 password: connectionDetails.password,
                 ssl: config.sourceSsl,
+                socketTimeoutMs: config.sourceSocketTimeoutMs,
+                connectTimeoutMs: Math.max(config.sourceSocketTimeoutMs ?? 30000, 60000),
+                acquireTimeoutMs: Math.max(config.sourceSocketTimeoutMs ?? 30000, 60000),
+                enableKeepAlive: true,
+                keepAliveInitialDelayMs: 0,
+                waitTimeoutSeconds: config.sourceWaitTimeoutSeconds,
+                netReadTimeoutSeconds: config.sourceNetReadTimeoutSeconds,
+                netWriteTimeoutSeconds: config.sourceNetWriteTimeoutSeconds,
             });
         }
         case 'postgresql': {
@@ -335,14 +806,20 @@ export const DataMigrator = Object.freeze({
             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) {
-                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('; ');
+            const tableLevels = buildTableMigrationLevels(schema.tables);
+            const tableParallelism = getTableParallelism(config, targetConnection);
+            for (const [levelIndex, tables] of tableLevels.entries()) {
+                Logger.info(`[DataMigrator] Starting table level ${levelIndex + 1}/${tableLevels.length}: ${tables.map((table) => table.name).join(', ')}`);
+                const levelResults = await executeWithConcurrency(tables, tableParallelism, async (table) => {
+                    return DataMigrator.migrateTable(table, sourceConnection, targetConnection, config);
+                });
+                for (const [resultIndex, result] of levelResults.entries()) {
+                    const table = tables[resultIndex];
+                    progress.processedRows += result.rowsMigrated;
+                    if (result.errors.length > 0 && table !== undefined) {
+                        progress.errors[table.name] = result.errors.join('; ');
+                    }
                 }
             }
             progress.totalRows = Math.max(progress.totalRows, progress.processedRows);
@@ -359,7 +836,6 @@ export const DataMigrator = Object.freeze({
             const errorChain = getErrorChainMessages(error);
             Logger.error(`Data migration failed: ${errorChain.join(' -> ')}`);
             logDetailedError('Data migration failure', error);
-            Logger.error('Data migration failure details:', error);
             throw error;
         }
         finally {
@@ -372,16 +848,14 @@ export const DataMigrator = Object.freeze({
      */
     async connectToSource(config) {
         Logger.info(`Connecting to ${config.sourceDriver} database...`);
-        Logger.info(`[DataMigrator] Source connection (redacted): ${redactConnectionString(config.sourceConnection)}`);
         const adapter = createSourceAdapter(config);
         try {
-            await adapter.connect();
+            await connectWithRetry(adapter, config.sourceDriver);
         }
         catch (error) {
             const errorChain = getErrorChainMessages(error);
             Logger.error(`Source database connection failed: ${errorChain.join(' -> ')}`);
             logDetailedError('Source database connection failure', error);
-            Logger.error('Source database connection failure details:', error);
             throw error;
         }
         const sourceConnection = {
@@ -393,6 +867,9 @@ export const DataMigrator = Object.freeze({
             adapter,
         };
         Logger.info('✓ Source database connected');
+        if (config.sourceDriver === 'mysql') {
+            sourceConnection.sourceBatchTuning = getSourceBatchTuning(sourceConnection, config.batchSize ?? DEFAULT_SOURCE_READ_BATCH_SIZE);
+        }
         return sourceConnection;
     },
     /**
@@ -438,6 +915,7 @@ export const DataMigrator = Object.freeze({
         if (!targetConnection.adapter) {
             throw ErrorFactory.createConnectionError('No target adapter available for D1 schema preparation');
         }
+        const adapter = targetConnection.adapter;
         Logger.info('Preparing target D1 schema...');
         const sourceSchema = await SchemaAnalyzer.analyzeSchema({
             driver: sourceConnection.driver,
@@ -447,16 +925,42 @@ export const DataMigrator = Object.freeze({
         });
         const d1Schema = SchemaBuilder.buildD1Schema(sourceSchema.tables, config.sourceDriver);
         SchemaBuilder.assertValidSchema(d1Schema);
+        const schemaStatements = [];
+        const maxBatchSqlLength = targetConnection.type === 'd1-remote'
+            ? Math.max(0, MAX_REMOTE_EXECUTION_SQL_LENGTH - 2000)
+            : Number.POSITIVE_INFINITY;
+        const executeSchemaBatch = async () => {
+            if (schemaStatements.length === 0) {
+                return;
+            }
+            const batchSql = `${schemaStatements.join(';\n')};`;
+            await adapter.query(batchSql, []);
+            schemaStatements.length = 0;
+        };
+        const pushSchemaStatement = async (sql) => {
+            const trimmedSql = sql.trim();
+            const nextLength = schemaStatements.length === 0
+                ? trimmedSql.length
+                : schemaStatements.join(';\n').length + 2 + trimmedSql.length;
+            if (targetConnection.type === 'd1-remote' && nextLength > maxBatchSqlLength) {
+                await executeSchemaBatch();
+            }
+            schemaStatements.push(trimmedSql);
+        };
         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, []);
+            await pushSchemaStatement(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, []);
+                await pushSchemaStatement(sql);
+            }
+            if (targetConnection.type !== 'd1-remote') {
+                await executeSchemaBatch();
             }
         }
+        await executeSchemaBatch();
         Logger.info(`✓ Target schema prepared for ${d1Schema.length} tables`);
     },
     /**
@@ -473,6 +977,7 @@ export const DataMigrator = Object.freeze({
         const tables = sourceSchema.tables.map((table) => ({
             name: table.name,
             rowCount: table.rowCount || 0,
+            dependsOn: table.foreignKeys.map((foreignKey) => foreignKey.referencedTable),
         }));
         Logger.info(`Found ${tables.length} tables`);
         return { tables };
@@ -500,10 +1005,10 @@ export const DataMigrator = Object.freeze({
         Logger.info(`Migrating table: ${table.name}`);
         const errors = [];
         let rowsMigrated = 0;
+        const tableStartTime = Date.now();
         try {
             const totalRows = table.rowCount || 0;
             const batchSize = config.batchSize || 1000;
-            // Check if table is already synced for resumability
             const targetRowCount = await DataMigrator.getTargetRowCount(targetConnection, table.name);
             if (targetRowCount >= totalRows) {
                 Logger.info(`Table ${table.name} already synced: ${targetRowCount}/${totalRows} rows, skipping`);
@@ -515,69 +1020,65 @@ export const DataMigrator = Object.freeze({
             else {
                 Logger.info(`Processing ${totalRows} rows in batches of ${batchSize}`);
             }
-            // Process data in chunks sequentially for data integrity
-            // Start from the last synced offset for resumability
-            const startOffset = targetRowCount;
-            for (let offset = startOffset; 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 normalizedTotalRows = Math.max(totalRows, rowsMigrated);
-                        const percentage = Math.round((rowsMigrated / normalizedTotalRows) * 100);
-                        Logger.info(`Table ${table.name}: ${rowsMigrated}/${normalizedTotalRows} (${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`);
+            rowsMigrated = await DataMigrator.processTableChunks(table, sourceConnection, targetConnection, totalRows, batchSize, targetRowCount, errors);
+            const tableDurationMs = Date.now() - tableStartTime;
+            Logger.info(`[DataMigrator] Table ${table.name} completed rows=${rowsMigrated}/${totalRows} duration=${formatDuration(tableDurationMs)} rate=${formatRowsPerSecond(rowsMigrated, tableDurationMs)}`);
+            return { rowsMigrated, errors };
         }
         catch (error) {
-            const errorMsg = `Failed to migrate table ${table.name}: ${error}`;
+            const errorMsg = `Table migration failed for ${table.name}: ${error}`;
             Logger.error(errorMsg);
             errors.push(errorMsg);
+            return { rowsMigrated, errors };
+        }
+    },
+    async processTableChunks(table, sourceConnection, targetConnection, totalRows, batchSize, startOffset, errors) {
+        let state = {
+            rowsMigrated: 0,
+            offset: startOffset,
+            currentBatchSize: batchSize,
+            retryBatchSize: batchSize,
+        };
+        while (state.offset < totalRows) {
+            state.currentBatchSize = getTableChunkBatchSize(sourceConnection, state.retryBatchSize);
+            const result = await processTableChunk(table, sourceConnection, targetConnection, state.offset, state.currentBatchSize, errors);
+            state = applyTableChunkResult(state, result, batchSize, table, totalRows);
+            if (!result.continueProcessing &&
+                !(result.rowsMigrated === 0 && result.nextBatchSize < batchSize)) {
+                break;
+            }
         }
-        return { rowsMigrated, errors };
+        return state.rowsMigrated;
     },
     /**
      * 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 startTime = Date.now();
             const result = await sourceConnection.adapter.query(`${selectSql} LIMIT ${batchSize} OFFSET ${offset}`, []);
+            const durationMs = Date.now() - startTime;
+            if (sourceConnection.driver === 'mysql') {
+                updateSourceBatchTuningAfterSuccess(sourceConnection, result.rows.length, durationMs, batchSize);
+            }
             return result.rows || [];
         }
         catch (error) {
-            Logger.error(`Chunk read failed ${error}`);
-            return [];
+            const errorMessage = getErrorMessage(error);
+            if (sourceConnection.driver === 'mysql' && isRetryableConnectionError(error)) {
+                reduceSourceBatchSizeAfterTimeout(sourceConnection, batchSize);
+            }
+            Logger.warn(`Chunk read failed: ${errorMessage}`);
+            throw error;
         }
     },
     /**
      * Transform data for D1 compatibility
      */
-    async transformData(chunk, tableName) {
-        Logger.debug(`Transforming ${chunk.length} rows for table ${tableName}`);
+    async transformData(chunk, _tableName) {
         return chunk.map((row) => {
             const transformed = {};
             for (const [key, rawValue] of Object.entries(row)) {
@@ -612,27 +1113,36 @@ export const DataMigrator = Object.freeze({
      * 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})`;
+        const batchSettings = getInsertBatchSettings(targetConnection);
+        const statements = createInsertStatements(targetConnection.type, batchSettings, tableName, data);
+        const executableStatements = targetConnection.type === 'd1-remote'
+            ? createRemoteExecutionBatchesWithLimit(statements, batchSettings.maxExecutionSqlLength)
+            : statements;
         let insertedRows = 0;
-        for (const row of data) {
-            const values = keys.map((key) => row[key]);
+        for (const statement of executableStatements) {
             try {
-                await targetConnection.adapter.query(sql, values);
-                insertedRows += 1;
+                const executionStartTime = Date.now();
+                const result = await targetConnection.adapter.query(statement.sql, statement.parameters);
+                const executionDurationMs = Date.now() - executionStartTime;
+                const affectedRows = typeof result.rowCount === 'number' ? result.rowCount : statement.rowCount;
+                insertedRows += affectedRows;
+                adjustRemoteBatchTuning(targetConnection, affectedRows, executionDurationMs, statement.sql.length);
             }
             catch (error) {
+                if (targetConnection.type === 'd1-remote' && data.length > 1 && statement.rowCount > 1) {
+                    reduceRemoteBatchTuningAfterFailure(targetConnection, statement.sql.length);
+                    const midpoint = Math.max(1, Math.floor(data.length / 2));
+                    const left = await DataMigrator.insertData(targetConnection, tableName, data.slice(0, midpoint));
+                    const right = await DataMigrator.insertData(targetConnection, tableName, data.slice(midpoint));
+                    return left + right;
+                }
                 throw ErrorFactory.createValidationError(`Insert failed for table ${tableName}`, {
-                    sql,
-                    row,
+                    rowCount: statement.rowCount,
                     cause: error,
                 });
             }

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

@@ -1 +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,EAA0B,MAAM,UAAU,CAAC;AAOxE,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;AAoyBF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,iBAiH/B,CAAC;AAEH;;GAEG;AACH,iBAAe,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAetE;AAED;;GAEG;AACH,iBAAe,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAmGxE;AAED;;GAEG;AACH,iBAAe,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAkGtE;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"}
+{"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,EAA0B,MAAM,UAAU,CAAC;AAOxE,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;AAouBF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,iBA0G/B,CAAC;AAEH;;GAEG;AACH,iBAAe,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAetE;AAED;;GAEG;AACH,iBAAe,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAmGxE;AAED;;GAEG;AACH,iBAAe,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAkGtE;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"}

package/dist/cli/MigrateToD1Command.js

@@ -229,35 +229,6 @@ const normalizeSourceConnectionString = (sourceConnection, sourceDriver, origin)
     }
     return buildNetworkConnectionString(details);
 };
-const redactConnectionString = (sourceConnection) => {
-    try {
-        const parsed = new URL(sourceConnection);
-        if (parsed.password.trim() !== '') {
-            parsed.password = '***';
-        }
-        return parsed.toString();
-    }
-    catch {
-        return sourceConnection;
-    }
-};
-const getPasswordForDiagnostics = (sourceConnection, sourceDriver, origin) => {
-    if (origin === 'db-env') {
-        return parseNetworkConnectionDetails(sourceConnection, sourceDriver)?.password;
-    }
-    try {
-        const parsed = new URL(sourceConnection);
-        return parsed.password;
-    }
-    catch {
-        return undefined;
-    }
-};
-const describePasswordForLog = (password) => {
-    const hasSpecialCharacters = /[^a-zA-Z0-9]/.test(password);
-    const containsBang = password.includes('!');
-    return `len=${password.length}, special_chars=${hasSpecialCharacters}, contains_bang=${containsBang}`;
-};
 const getErrorCause = (error) => {
     if (error === null || typeof error !== 'object') {
         return undefined;
@@ -309,18 +280,6 @@ const logDetailedError = (label, error) => {
         logDetailedError(`${label} cause`, cause);
     }
 };
-const logSourceConnectionDiagnostics = (sourceDriver, sourceConnection, origin, originalValue) => {
-    Logger.info(`[d1-migrator] Source connection origin: ${origin}`);
-    Logger.info(`[d1-migrator] Source connection driver: ${sourceDriver}`);
-    Logger.info(`[d1-migrator] Source connection (redacted): ${redactConnectionString(sourceConnection)}`);
-    const originalPassword = getPasswordForDiagnostics(originalValue, sourceDriver, origin);
-    const finalPassword = getPasswordForDiagnostics(sourceConnection, sourceDriver, origin);
-    if (originalPassword === undefined || finalPassword === undefined) {
-        Logger.info('[d1-migrator] Source connection diagnostics: non-network source or unable to parse URL');
-        return;
-    }
-    Logger.info(`[d1-migrator] Source password diagnostics: provided(${describePasswordForLog(originalPassword)}), final(${describePasswordForLog(finalPassword)}), matches=${originalPassword === finalPassword}`);
-};
 const normalizeSourceDriver = (value) => {
     if (value === undefined) {
         return undefined;
@@ -578,8 +537,7 @@ export const MigrateToD1Command = BaseCommand.create({
     execute: async (options) => {
         try {
             Logger.info('Starting D1 migration process...');
-            const { config, schemaOnly, sourceConnectionOrigin, originalSourceConnection } = resolveMigrationConfig(options);
-            logSourceConnectionDiagnostics(config.sourceDriver, config.sourceConnection, sourceConnectionOrigin, originalSourceConnection);
+            const { config, schemaOnly } = resolveMigrationConfig(options);
             const configValidation = validateConfig(config);
             if (!configValidation.valid) {
                 throw ErrorFactory.createValidationError(`Invalid migration configuration: ${configValidation.errors.join(', ')}`);

package/dist/types.d.ts

@@ -17,6 +17,10 @@ export interface MigrationConfig {
     dryRun?: boolean;
     interactive?: boolean;
     migrationId?: string;
+    sourceSocketTimeoutMs?: number;
+    sourceWaitTimeoutSeconds?: number;
+    sourceNetReadTimeoutSeconds?: number;
+    sourceNetWriteTimeoutSeconds?: number;
 }
 export interface MigrationState {
     id: string;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG,YAAY,GAAG,QAAQ,GAAG,WAAW,CAAC;AAEnF,MAAM,MAAM,sBAAsB,GAAG,QAAQ,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEjE,MAAM,WAAW,eAAe;IAC9B,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,oBAAoB,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,IAAI,GAAG,WAAW,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,4BAA4B,CAAC,EAAE,MAAM,CAAC;CACvC;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,CAAC;IAClE,SAAS,EAAE,IAAI,CAAC;IAChB,cAAc,CAAC,EAAE,IAAI,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,MAAM,EAAE,eAAe,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,QAAQ,EAAE,aAAa,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,aAAa,EAAE,iBAAiB,EAAE,CAAC;IACnC,WAAW,EAAE,eAAe,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,YAAY,GAAG,aAAa,GAAG,cAAc,CAAC;CACrD;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,aAAa,GAAG,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,UAAU,CAAC;IACtE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC;IAC/C,QAAQ,CAAC,EAAE,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC;CAChD;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,kBAAkB,GAAG,iBAAiB,GAAG,yBAAyB,CAAC;IACzE,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,gBAAgB,GAAG,oBAAoB,GAAG,eAAe,CAAC;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,QAAQ,CAAC;IAC1D,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,EAAE,MAAM,OAAO,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAC9D,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,kBAAkB,EAAE,kBAAkB,CAAC;CACxC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/d1-migrator",
-  "version": "1.9.2",
+  "version": "1.9.5",
   "description": "Resumable database migration toolkit for moving data to Cloudflare D1 with ZinTrust.",
   "private": false,
   "type": "module",
@@ -41,7 +41,7 @@
   },
   "dependencies": {
     "@zintrust/db-d1": "^1.8.0",
-    "@zintrust/db-mysql": "^1.8.9",
+    "@zintrust/db-mysql": "^2.0.1",
     "@zintrust/db-postgres": "^1.8.0",
     "@zintrust/db-sqlite": "^1.8.0",
     "@zintrust/db-sqlserver": "^1.8.0"