@yartsun/chat-widget-types 1.0.2 → 1.0.5

package/src/migration/migrator.ts

@@ -0,0 +1,361 @@
+/**
+ * Основной класс мигратора конфигураций виджета чата
+ */
+
+import {
+  MigrationResult,
+  MigrationContext,
+  MigrationOptions,
+  MigrationReport,
+  MigrationLogger,
+  ConfigVersion
+} from './types'
+import { WidgetConfig } from '../config.types'
+import { getStrategiesForMigration } from './strategies'
+import { DefaultVersionDetector, CommandFactory } from './commands'
+
+/** Дефолтный логгер для миграции */
+export class DefaultMigrationLogger implements MigrationLogger {
+  constructor(private verbose: boolean = false) {}
+
+  info(message: string, context?: any): void {
+    if (this.verbose) {
+      console.log(`[INFO] ${message}`, context ? JSON.stringify(context, null, 2) : '')
+    }
+  }
+
+  warn(message: string, context?: any): void {
+    console.warn(`[WARN] ${message}`, context ? JSON.stringify(context, null, 2) : '')
+  }
+
+  error(message: string, context?: any): void {
+    console.error(`[ERROR] ${message}`, context ? JSON.stringify(context, null, 2) : '')
+  }
+
+  debug(message: string, context?: any): void {
+    if (this.verbose) {
+      console.debug(`[DEBUG] ${message}`, context ? JSON.stringify(context, null, 2) : '')
+    }
+  }
+}
+
+/** Основной класс мигратора */
+export class ConfigMigrator {
+  private logger: MigrationLogger
+  private versionDetector: DefaultVersionDetector
+
+  constructor(logger?: MigrationLogger) {
+    this.logger = logger || new DefaultMigrationLogger()
+    this.versionDetector = new DefaultVersionDetector()
+  }
+
+  /**
+   * Выполнить миграцию конфигурации
+   */
+  async migrate<T = WidgetConfig>(
+    config: any,
+    targetVersion: ConfigVersion,
+    options: MigrationOptions = {}
+  ): Promise<MigrationResult<T>> {
+    const startTime = Date.now()
+    this.logger.info(`Начинаем миграцию к версии ${targetVersion}`)
+
+    try {
+      // Детекция текущей версии
+      const currentVersion = this.versionDetector.detect(config)
+      if (!currentVersion) {
+        return this.createErrorResult('Не удалось определить версию исходной конфигурации', startTime)
+      }
+
+      this.logger.info(`Определена исходная версия: ${currentVersion}`)
+
+      // Проверяем, нужна ли миграция
+      if (currentVersion === targetVersion) {
+        this.logger.info('Конфигурация уже соответствует целевой версии')
+        return this.createSuccessResult(config as T, currentVersion, targetVersion, [], startTime)
+      }
+
+      // Создаем план миграции
+      const migrationPath = this.buildMigrationPath(currentVersion, targetVersion)
+      if (migrationPath.length === 0) {
+        return this.createErrorResult(
+          `Не найден путь миграции с ${currentVersion} на ${targetVersion}`,
+          startTime
+        )
+      }
+
+      this.logger.info(`План миграции: ${migrationPath.map(step => `${step.from} -> ${step.to}`).join(' -> ')}`)
+
+      // Выполняем миграцию по шагам
+      let currentConfig = config
+      const appliedStrategies: string[] = []
+      const allWarnings: string[] = []
+
+      for (const step of migrationPath) {
+        const stepResult = await this.executeStep(currentConfig, step.from, step.to, options)
+        
+        if (!stepResult.success) {
+          return this.createErrorResult(
+            `Ошибка на шаге ${step.from} -> ${step.to}: ${stepResult.errors.join(', ')}`,
+            startTime,
+            stepResult.errors
+          )
+        }
+
+        currentConfig = stepResult.data
+        appliedStrategies.push(...stepResult.appliedStrategies)
+        allWarnings.push(...stepResult.warnings)
+      }
+
+      // Финальная валидация
+      const validateCommand = CommandFactory.createCommand('ValidateConfig')
+      if (validateCommand) {
+        const validationResult = validateCommand.execute(currentConfig, { version: targetVersion })
+        if (!validationResult.success && options.strict) {
+          return this.createErrorResult(
+            `Валидация не прошла: ${validationResult.errors.join(', ')}`,
+            startTime,
+            validationResult.errors
+          )
+        }
+        allWarnings.push(...validationResult.warnings)
+      }
+
+      this.logger.info('Миграция успешно завершена')
+      return this.createSuccessResult(
+        currentConfig as T,
+        currentVersion,
+        targetVersion,
+        appliedStrategies,
+        startTime,
+        allWarnings
+      )
+
+    } catch (error) {
+      this.logger.error('Критическая ошибка при миграции', error)
+      return this.createErrorResult(`Критическая ошибка: ${error}`, startTime)
+    }
+  }
+
+  /**
+   * Получить отчет о возможной миграции без её выполнения
+   */
+  async dryRun(
+    config: any,
+    targetVersion: ConfigVersion,
+    _options: MigrationOptions = {}
+  ): Promise<MigrationReport> {
+    const startTime = Date.now()
+    
+    try {
+      const currentVersion = this.versionDetector.detect(config)
+      if (!currentVersion) {
+        return this.createFailedReport(startTime, 'unknown', targetVersion, 'Не удалось определить версию')
+      }
+
+      const migrationPath = this.buildMigrationPath(currentVersion, targetVersion)
+      const strategies = migrationPath.flatMap(step => 
+        getStrategiesForMigration(step.from, step.to)
+      )
+
+      return {
+        timestamp: new Date(),
+        fromVersion: currentVersion,
+        toVersion: targetVersion,
+        success: true,
+        duration: Date.now() - startTime,
+        appliedStrategies: strategies.map(strategy => ({
+          name: strategy.name,
+          success: true,
+          errors: [],
+          warnings: []
+        })),
+        totalErrors: 0,
+        totalWarnings: 0,
+        summary: `Будет применено ${strategies.length} стратегий для миграции с ${currentVersion} на ${targetVersion}`
+      }
+    } catch (error) {
+      return this.createFailedReport(startTime, 'unknown', targetVersion, `Ошибка: ${error}`)
+    }
+  }
+
+  /**
+   * Выполнить один шаг миграции
+   */
+  private async executeStep(
+    config: any,
+    fromVersion: ConfigVersion,
+    toVersion: ConfigVersion,
+    options: MigrationOptions
+  ): Promise<MigrationResult<any>> {
+    const startTime = Date.now()
+    
+    this.logger.info(`Выполняем шаг: ${fromVersion} -> ${toVersion}`)
+
+    // Получаем стратегии для этого шага
+    let strategies = getStrategiesForMigration(fromVersion, toVersion)
+
+    // Фильтруем стратегии согласно опциям
+    if (options.onlyStrategies?.length) {
+      strategies = strategies.filter(s => options.onlyStrategies!.includes(s.name))
+    }
+    if (options.excludeStrategies?.length) {
+      strategies = strategies.filter(s => !options.excludeStrategies!.includes(s.name))
+    }
+
+    if (strategies.length === 0) {
+      return this.createErrorResult(
+        `Не найдено стратегий для миграции ${fromVersion} -> ${toVersion}`,
+        startTime
+      )
+    }
+
+    const context: MigrationContext = {
+      fromVersion,
+      toVersion,
+      config,
+      options
+    }
+
+    let currentConfig = { ...config }
+    const appliedStrategies: string[] = []
+    const allErrors: string[] = []
+    const allWarnings: string[] = []
+
+    // Применяем каждую стратегию
+    for (const strategy of strategies) {
+      this.logger.debug(`Применяем стратегию: ${strategy.name}`)
+
+      if (!strategy.canApply({ ...context, config: currentConfig })) {
+        this.logger.debug(`Стратегия ${strategy.name} не применима, пропускаем`)
+        continue
+      }
+
+      const result = strategy.apply({ ...context, config: currentConfig })
+      
+      if (!result.success) {
+        this.logger.error(`Стратегия ${strategy.name} завершилась с ошибкой`, result.errors)
+        allErrors.push(...result.errors)
+        
+        if (options.strict) {
+          return this.createErrorResult(
+            `Стратегия ${strategy.name} завершилась с ошибкой: ${result.errors.join(', ')}`,
+            startTime,
+            allErrors
+          )
+        }
+      } else {
+        if (result.modified && result.data) {
+          currentConfig = result.data
+        }
+        appliedStrategies.push(strategy.name)
+        allWarnings.push(...result.warnings)
+        this.logger.debug(`Стратегия ${strategy.name} успешно применена`)
+      }
+    }
+
+    return this.createSuccessResult(
+      currentConfig,
+      fromVersion,
+      toVersion,
+      appliedStrategies,
+      startTime,
+      allWarnings,
+      allErrors
+    )
+  }
+
+  /**
+   * Построить путь миграции между версиями
+   */
+  private buildMigrationPath(from: ConfigVersion, to: ConfigVersion): Array<{from: ConfigVersion, to: ConfigVersion}> {
+    // Простая логика для последовательной миграции
+    // В будущем можно расширить для более сложных сценариев
+    
+    const versions: ConfigVersion[] = ['1.0', '2.0', '3.0']
+    const fromIndex = versions.indexOf(from)
+    const toIndex = versions.indexOf(to)
+
+    if (fromIndex === -1 || toIndex === -1) {
+      return []
+    }
+
+    const path: Array<{from: ConfigVersion, to: ConfigVersion}> = []
+    
+    if (fromIndex < toIndex) {
+      // Прямая миграция (вперед)
+      for (let i = fromIndex; i < toIndex; i++) {
+        path.push({ from: versions[i], to: versions[i + 1] })
+      }
+    } else if (fromIndex > toIndex) {
+      // Обратная миграция (назад) - пока не поддерживается
+      // В будущем можно добавить стратегии downgrade
+      return []
+    }
+
+    return path
+  }
+
+  /**
+   * Создать успешный результат миграции
+   */
+  private createSuccessResult<T>(
+    data: T,
+    fromVersion: ConfigVersion,
+    toVersion: ConfigVersion,
+    appliedStrategies: string[],
+    _startTime: number,
+    warnings: string[] = [],
+    errors: string[] = []
+  ): MigrationResult<T> {
+    return {
+      success: true,
+      data,
+      errors,
+      warnings,
+      fromVersion,
+      toVersion,
+      appliedStrategies
+    }
+  }
+
+  /**
+   * Создать результат с ошибкой
+   */
+  private createErrorResult<T = any>(
+    message: string,
+    _startTime: number,
+    errors: string[] = []
+  ): MigrationResult<T> {
+    return {
+      success: false,
+      errors: [message, ...errors],
+      warnings: [],
+      fromVersion: 'unknown' as any,
+      toVersion: 'unknown' as any,
+      appliedStrategies: []
+    }
+  }
+
+  /**
+   * Создать неудачный отчет
+   */
+  private createFailedReport(
+    _startTime: number,
+    fromVersion: ConfigVersion | 'unknown',
+    toVersion: ConfigVersion,
+    message: string
+  ): MigrationReport {
+    return {
+      timestamp: new Date(),
+      fromVersion: fromVersion as ConfigVersion,
+      toVersion,
+      success: false,
+      duration: Date.now() - _startTime,
+      appliedStrategies: [],
+      totalErrors: 1,
+      totalWarnings: 0,
+      summary: message
+    }
+  }
+}

package/src/migration/strategies.ts

@@ -0,0 +1,249 @@
+/**
+ * Стратегии миграции конфигураций виджета чата
+ */
+
+import { DEFAULT_CONFIG } from '../config.types'
+import { 
+  MigrationStrategy, 
+  MigrationContext, 
+  MigrationStepResult, 
+  ConfigV1
+} from './types'
+
+/** Базовый класс для стратегий миграции */
+export abstract class BaseMigrationStrategy implements MigrationStrategy {
+  abstract name: string
+  abstract description: string
+  abstract appliesTo: { from: any; to: any }
+
+  canApply(context: MigrationContext): boolean {
+    return context.fromVersion === this.appliesTo.from && 
+           context.toVersion === this.appliesTo.to
+  }
+
+  abstract apply(context: MigrationContext): MigrationStepResult
+
+  rollback?(_context: MigrationContext): MigrationStepResult {
+    return {
+      success: false,
+      errors: [`Rollback not implemented for strategy: ${this.name}`],
+      warnings: [],
+      modified: false
+    }
+  }
+
+  protected createSuccessResult(data: any, warnings: string[] = []): MigrationStepResult {
+    return {
+      success: true,
+      data,
+      errors: [],
+      warnings,
+      modified: true
+    }
+  }
+
+  protected createErrorResult(errors: string[], data?: any): MigrationStepResult {
+    return {
+      success: false,
+      data,
+      errors,
+      warnings: [],
+      modified: false
+    }
+  }
+}
+
+/** Стратегия добавления новых полей в settings для V1->V2 */
+export class AddSettingsFieldsV1toV2Strategy extends BaseMigrationStrategy {
+  name = 'AddSettingsFieldsV1toV2'
+  description = 'Добавляет новые поля loader, buttonStyle, buttonType в settings'
+  appliesTo = { from: '1.0' as const, to: '2.0' as const }
+
+  apply(context: MigrationContext): MigrationStepResult {
+    try {
+      const config = { ...context.config } as ConfigV1
+      const warnings: string[] = []
+
+      // Добавляем новые поля в settings
+      const newSettings = {
+        ...config.settings,
+        loader: DEFAULT_CONFIG.settings.loader, // 'dots'
+      }
+
+      warnings.push(`Добавлены поля loader: '${newSettings.loader}'`)
+
+      return this.createSuccessResult(
+        { ...config, settings: newSettings },
+        warnings
+      )
+    } catch (error) {
+      return this.createErrorResult([`Ошибка при добавлении полей settings: ${error}`])
+    }
+  }
+}
+
+/** Стратегия добавления chipStyle в top.params для V1->V2 */
+export class AddChipStyleV1toV2Strategy extends BaseMigrationStrategy {
+  name = 'AddChipStyleV1toV2'
+  description = 'Добавляет поле chipStyle в sections.top.params'
+  appliesTo = { from: '1.0' as const, to: '2.0' as const }
+
+  apply(context: MigrationContext): MigrationStepResult {
+    try {
+      const config = { ...context.config }
+      const warnings: string[] = []
+
+      // Добавляем chipStyle в top.params
+      config.sections.top.params = {
+        ...config.sections.top.params,
+        chipStyle: DEFAULT_CONFIG.sections.top.params.chipStyle // 'filled'
+      }
+
+      warnings.push(`Добавлено поле chipStyle: '${DEFAULT_CONFIG.sections.top.params.chipStyle}' в sections.top.params`)
+
+      return this.createSuccessResult(config, warnings)
+    } catch (error) {
+      return this.createErrorResult([`Ошибка при добавлении chipStyle: ${error}`])
+    }
+  }
+}
+
+/** Стратегия добавления bgType для сообщений в V1->V2 */
+export class AddMessageBgTypeV1toV2Strategy extends BaseMigrationStrategy {
+  name = 'AddMessageBgTypeV1toV2'
+  description = 'Добавляет поле bgType в messageUser и messageBot'
+  appliesTo = { from: '1.0' as const, to: '2.0' as const }
+
+  apply(context: MigrationContext): MigrationStepResult {
+    try {
+      const config = { ...context.config }
+      const warnings: string[] = []
+
+      // Добавляем bgType в messageUser и messageBot
+      config.sections.inside.messageUser = {
+        ...config.sections.inside.messageUser,
+        bgType: DEFAULT_CONFIG.sections.inside.messageUser.bgType // 'bubble'
+      }
+
+      config.sections.inside.messageBot = {
+        ...config.sections.inside.messageBot,
+        bgType: DEFAULT_CONFIG.sections.inside.messageBot.bgType // 'plain'
+      }
+
+      warnings.push('Добавлены поля bgType для messageUser и messageBot')
+
+      return this.createSuccessResult(config, warnings)
+    } catch (error) {
+      return this.createErrorResult([`Ошибка при добавлении bgType для сообщений: ${error}`])
+    }
+  }
+}
+
+/** Стратегия добавления новых кнопок approve/reject в V1->V2 */
+export class AddActionButtonsV1toV2Strategy extends BaseMigrationStrategy {
+  name = 'AddActionButtonsV1toV2'
+  description = 'Добавляет кнопки aprooveButton и rejectButton в inside секцию'
+  appliesTo = { from: '1.0' as const, to: '2.0' as const }
+
+  apply(context: MigrationContext): MigrationStepResult {
+    try {
+      const config = { ...context.config }
+      const warnings: string[] = []
+
+      // Добавляем новые кнопки
+      config.sections.inside = {
+        ...config.sections.inside
+      }
+
+      warnings.push('Добавлены кнопки aprooveButton и rejectButton')
+
+      return this.createSuccessResult(config, warnings)
+    } catch (error) {
+      return this.createErrorResult([`Ошибка при добавлении кнопок действий: ${error}`])
+    }
+  }
+}
+
+/** Стратегия расширения inputSend для V1->V2 */
+export class EnhanceInputSendV1toV2Strategy extends BaseMigrationStrategy {
+  name = 'EnhanceInputSendV1toV2'
+  description = 'Добавляет borderStyle, inputStyle, bgType в inputSend'
+  appliesTo = { from: '1.0' as const, to: '2.0' as const }
+
+  apply(context: MigrationContext): MigrationStepResult {
+    try {
+      const config = { ...context.config }
+      const warnings: string[] = []
+
+      // Расширяем inputSend
+      config.sections.bottom.inputSend = {
+        ...config.sections.bottom.inputSend,
+        borderStyle: DEFAULT_CONFIG.sections.bottom.inputSend.borderStyle,
+        inputStyle: DEFAULT_CONFIG.sections.bottom.inputSend.inputStyle, // 'inside'
+        bgType: DEFAULT_CONFIG.sections.bottom.inputSend.bgType // 'plain'
+      }
+
+      warnings.push('Расширен inputSend с новыми полями borderStyle, inputStyle, bgType')
+
+      return this.createSuccessResult(config, warnings)
+    } catch (error) {
+      return this.createErrorResult([`Ошибка при расширении inputSend: ${error}`])
+    }
+  }
+}
+
+/** Стратегия добавления warningAlert и disclaimer в V1->V2 */
+export class AddBottomElementsV1toV2Strategy extends BaseMigrationStrategy {
+  name = 'AddBottomElementsV1toV2'
+  description = 'Добавляет warningAlert и disclaimer в bottom секцию'
+  appliesTo = { from: '1.0' as const, to: '2.0' as const }
+
+  apply(context: MigrationContext): MigrationStepResult {
+    try {
+      const config = { ...context.config }
+      const warnings: string[] = []
+
+      // Добавляем новые элементы в bottom
+      config.sections.bottom = {
+        ...config.sections.bottom,
+        warningAlert: DEFAULT_CONFIG.sections.bottom.warningAlert
+      }
+
+      warnings.push('Добавлены warningAlert и disclaimer в bottom секцию')
+
+      return this.createSuccessResult(config, warnings)
+    } catch (error) {
+      return this.createErrorResult([`Ошибка при добавлении элементов bottom: ${error}`])
+    }
+  }
+}
+
+/** Реестр всех стратегий миграции V1->V2 */
+export const V1_TO_V2_STRATEGIES: MigrationStrategy[] = [
+  new AddSettingsFieldsV1toV2Strategy(),
+  new AddChipStyleV1toV2Strategy(),
+  new AddMessageBgTypeV1toV2Strategy(),
+  new AddActionButtonsV1toV2Strategy(),
+  new EnhanceInputSendV1toV2Strategy(),
+  new AddBottomElementsV1toV2Strategy()
+]
+
+/** Получить все стратегии для конкретного перехода версий */
+export function getStrategiesForMigration(from: string, to: string): MigrationStrategy[] {
+  const allStrategies = [
+    ...V1_TO_V2_STRATEGIES
+    // Здесь можно добавить стратегии для других версий: V2_TO_V3_STRATEGIES и т.д.
+  ]
+
+  return allStrategies.filter(strategy => 
+    strategy.appliesTo.from === from && strategy.appliesTo.to === to
+  )
+}
+
+/** Получить все доступные стратегии */
+export function getAllStrategies(): MigrationStrategy[] {
+  return [
+    ...V1_TO_V2_STRATEGIES
+    // Добавляйте сюда новые группы стратегий для других версий
+  ]
+}