@gzl10/baserow 1.2.0

package/src/services/SchemaControlService.ts

@@ -0,0 +1,420 @@
+/**
+ * Servicio para gestión de control de schemas
+ *
+ * Maneja la tabla especial __schema_control que almacena metadatos
+ * sobre los schemas cargados en cada base de datos, permitiendo
+ * detección de cambios, versionado y operaciones idempotentes.
+ *
+ */
+
+import { createHash } from 'crypto'
+import type { Logger } from '../types'
+import type { DatabaseSchema, SchemaControl, LoadSchemaOptions, SchemaControlStatus } from '../types/schema'
+import { TableService } from './TableService'
+import { FieldService } from './FieldService'
+import { RowService } from './RowService'
+import { BaserowValidationError } from '../types/errors'
+
+/**
+ * Nombre de la tabla de control de schemas
+ */
+const SCHEMA_CONTROL_TABLE_NAME = '__schema_control'
+
+/**
+ * Estructura de la tabla de control
+ */
+interface SchemaControlRow {
+  id?: number
+  version: string
+  schema_hash: string
+  loaded_at: string
+  tables_created: string // JSON array
+  status: SchemaControlStatus
+  load_options: string // JSON object
+}
+
+/**
+ * Servicio para gestión de control de schemas
+ */
+export class SchemaControlService {
+  private controlTableId?: number
+  private controlTableName = SCHEMA_CONTROL_TABLE_NAME
+
+  constructor(
+    private databaseId: number,
+    private tableService: TableService,
+    private fieldService: FieldService,
+    private rowService: RowService,
+    private logger?: Logger
+  ) {}
+
+  /**
+   * Inicializar la tabla de control si no existe
+   */
+  async initialize(): Promise<void> {
+    this.logger?.debug?.(`Initializing schema control for database ${this.databaseId}`)
+
+    try {
+      // Intentar encontrar la tabla de control existente
+      const existingTable = await this.tableService.findUnique(this.databaseId, this.controlTableName)
+
+      if (existingTable) {
+        this.controlTableId = existingTable.id
+        this.logger?.debug?.(`Found existing schema control table: ${this.controlTableId}`)
+        return
+      }
+
+      // Crear la tabla de control
+      await this.createControlTable()
+    } catch (error) {
+      this.logger?.error?.('Failed to initialize schema control:', error)
+      throw new Error(`Failed to initialize schema control: ${(error as Error).message}`)
+    }
+  }
+
+  /**
+   * Crear la tabla de control de schemas
+   */
+  private async createControlTable(): Promise<void> {
+    this.logger?.debug?.('Creating schema control table')
+
+    // Crear la tabla vacía
+    const table = await this.tableService.create(this.databaseId, {
+      name: this.controlTableName
+    })
+
+    this.controlTableId = table.id
+    this.logger?.debug?.(`Created schema control table: ${this.controlTableId}`)
+
+    // Crear los campos con los tipos correctos desde el inicio
+    await this.createControlTableFields()
+  }
+
+  /**
+   * Crear los campos de la tabla de control con los tipos correctos
+   */
+  private async createControlTableFields(): Promise<void> {
+    if (!this.controlTableId) {
+      throw new Error('Schema control table not initialized')
+    }
+
+    // Crear campos uno por uno con los tipos correctos
+    await this.fieldService.createTextField(this.controlTableId, 'version', undefined, 'Versión del schema cargado')
+    await this.fieldService.createTextField(
+      this.controlTableId,
+      'schema_hash',
+      undefined,
+      'Hash del schema para detectar cambios'
+    )
+    await this.fieldService.createDateField(
+      this.controlTableId,
+      'loaded_at',
+      true,
+      'ISO',
+      '24',
+      false,
+      undefined,
+      undefined,
+      'Fecha y hora de carga del schema'
+    )
+    await this.fieldService.createLongTextField(
+      this.controlTableId,
+      'tables_created',
+      'JSON array con nombres de tablas creadas'
+    )
+    await this.fieldService.createSelectField(
+      this.controlTableId,
+      'status',
+      [
+        { value: 'active', color: 'green' },
+        { value: 'outdated', color: 'yellow' },
+        { value: 'error', color: 'red' },
+        { value: 'loading', color: 'blue' }
+      ],
+      'Estado del schema cargado'
+    )
+    await this.fieldService.createLongTextField(
+      this.controlTableId,
+      'load_options',
+      'JSON con opciones usadas para cargar el schema'
+    )
+
+    this.logger?.debug?.('Schema control table fields created')
+  }
+
+  /**
+   * Obtener el control de schema actual
+   */
+  async getCurrentControl(): Promise<SchemaControl | null> {
+    await this.ensureInitialized()
+
+    try {
+      const rows = await this.rowService.list(this.controlTableId!, {
+        order_by: '-loaded_at',
+        size: 1
+      })
+
+      if (rows.rows.length === 0) {
+        return null
+      }
+
+      const row = rows.rows[0] as any as SchemaControlRow
+      return this.mapRowToControl(row)
+    } catch (error) {
+      this.logger?.error?.('Failed to get current schema control:', error)
+      return null
+    }
+  }
+
+  /**
+   * Crear nuevo control de schema
+   */
+  async createControl(
+    schema: DatabaseSchema,
+    options: LoadSchemaOptions,
+    tablesCreated: string[]
+  ): Promise<SchemaControl> {
+    await this.ensureInitialized()
+
+    const schemaHash = this.generateSchemaHash(schema)
+    const control: SchemaControl = {
+      id: `${Date.now()}`,
+      version: options.version || schema.version || '1.0.0',
+      schemaHash,
+      loadedAt: new Date(),
+      tablesCreated,
+      status: 'loading',
+      loadOptions: options
+    }
+
+    try {
+      // Marcar controles anteriores como outdated
+      await this.markPreviousControlsAsOutdated()
+
+      // Crear nuevo control
+      const rowData = this.mapControlToRow(control)
+      const createdRow = await this.rowService.createRow(this.controlTableId!, rowData)
+
+      control.id = (createdRow as any).id?.toString() || control.id
+      control.status = 'active'
+
+      // Actualizar el estado a active
+      await this.updateControlStatus(control.id, 'active')
+
+      this.logger?.debug?.(`Created schema control: ${control.id}`)
+      return control
+    } catch (error) {
+      this.logger?.error?.('Failed to create schema control:', error)
+      throw new Error(`Failed to create schema control: ${(error as Error).message}`)
+    }
+  }
+
+  /**
+   * Actualizar el estado de un control
+   */
+  async updateControlStatus(controlId: string, status: SchemaControlStatus): Promise<void> {
+    await this.ensureInitialized()
+
+    try {
+      const numericId = parseInt(controlId, 10)
+      if (isNaN(numericId)) {
+        throw new Error(`Invalid control ID: ${controlId}`)
+      }
+
+      await this.rowService.updateRow(this.controlTableId!, numericId, {
+        status: status
+      })
+
+      this.logger?.debug?.(`Updated schema control ${controlId} status to ${status}`)
+    } catch (error) {
+      this.logger?.error?.(`Failed to update control status:`, error)
+      throw new Error(`Failed to update control status: ${(error as Error).message}`)
+    }
+  }
+
+  /**
+   * Verificar si un schema ha cambiado
+   */
+  async hasSchemaChanged(schema: DatabaseSchema): Promise<boolean> {
+    const currentControl = await this.getCurrentControl()
+    if (!currentControl) {
+      return true // No hay control previo, se considera cambio
+    }
+
+    const newHash = this.generateSchemaHash(schema)
+    return currentControl.schemaHash !== newHash
+  }
+
+  /**
+   * Generar hash único para un schema
+   */
+  generateSchemaHash(schema: DatabaseSchema): string {
+    // Crear una representación normalizada del schema
+    const normalized = {
+      tables: schema.tables
+        .map(table => ({
+          name: table.name.toLowerCase(),
+          fields: table.fields
+            .map(field => ({
+              name: field.name.toLowerCase(),
+              type: field.type,
+              config: field.config || null
+            }))
+            .sort((a, b) => a.name.localeCompare(b.name))
+        }))
+        .sort((a, b) => a.name.localeCompare(b.name)),
+      relationships: (schema.relationships || [])
+        .map(rel => ({
+          name: rel.name.toLowerCase(),
+          sourceTable: rel.sourceTable.toLowerCase(),
+          targetTable: rel.targetTable.toLowerCase()
+        }))
+        .sort((a, b) => a.name.localeCompare(b.name))
+    }
+
+    const schemaString = JSON.stringify(normalized)
+    return createHash('sha256').update(schemaString).digest('hex').substring(0, 16)
+  }
+
+  /**
+   * Marcar controles anteriores como desactualizados
+   */
+  private async markPreviousControlsAsOutdated(): Promise<void> {
+    try {
+      const rows = await this.rowService.list(this.controlTableId!, {
+        filters: { status: 'active' }
+      })
+
+      for (const row of rows.rows) {
+        await this.rowService.updateRow(this.controlTableId!, (row as any).id, {
+          status: 'outdated'
+        })
+      }
+    } catch (error) {
+      this.logger?.warn?.('Failed to mark previous controls as outdated:', error)
+      // No es crítico, continuar
+    }
+  }
+
+  /**
+   * Mapear fila de base de datos a objeto SchemaControl
+   */
+  private mapRowToControl(row: SchemaControlRow): SchemaControl {
+    try {
+      // El status puede venir como string o como objeto de single_select
+      const status = typeof row.status === 'string' ? row.status : (row.status as any)?.value || 'unknown'
+
+      return {
+        id: row.id?.toString() || 'unknown',
+        version: row.version,
+        schemaHash: row.schema_hash,
+        loadedAt: new Date(row.loaded_at),
+        tablesCreated: JSON.parse(row.tables_created || '[]'),
+        status,
+        loadOptions: JSON.parse(row.load_options || '{}')
+      }
+    } catch (error) {
+      this.logger?.error?.('Failed to parse schema control row:', error)
+      throw new BaserowValidationError('Invalid schema control data', { row: ['Failed to parse schema control row'] })
+    }
+  }
+
+  /**
+   * Mapear objeto SchemaControl a fila de base de datos
+   */
+  private mapControlToRow(control: SchemaControl): Record<string, any> {
+    return {
+      version: control.version,
+      schema_hash: control.schemaHash,
+      loaded_at: control.loadedAt.toISOString(),
+      tables_created: JSON.stringify(control.tablesCreated),
+      status: control.status,
+      load_options: JSON.stringify(control.loadOptions)
+    }
+  }
+
+  /**
+   * Asegurar que el servicio esté inicializado
+   */
+  private async ensureInitialized(): Promise<void> {
+    if (!this.controlTableId) {
+      await this.initialize()
+    }
+  }
+
+  /**
+   * Limpiar controles antiguos (mantener solo los últimos N)
+   */
+  async cleanupOldControls(keepLast: number = 10): Promise<void> {
+    await this.ensureInitialized()
+
+    try {
+      const rows = await this.rowService.list(this.controlTableId!, {
+        order_by: '-loaded_at'
+      })
+
+      if (rows.rows.length <= keepLast) {
+        return // No hay suficientes para limpiar
+      }
+
+      const toDelete = rows.rows.slice(keepLast)
+      const idsToDelete = toDelete.map((row: any) => row.id).filter(id => id)
+
+      if (idsToDelete.length > 0) {
+        await this.rowService.deleteBulk(this.controlTableId!, idsToDelete)
+        this.logger?.debug?.(`Cleaned up ${idsToDelete.length} old schema controls`)
+      }
+    } catch (error) {
+      this.logger?.warn?.('Failed to cleanup old controls:', error)
+      // No es crítico, continuar
+    }
+  }
+
+  /**
+   * Obtener estadísticas del control de schemas
+   */
+  async getControlStats(): Promise<{
+    totalControls: number
+    activeControls: number
+    outdatedControls: number
+    errorControls: number
+  }> {
+    await this.ensureInitialized()
+
+    try {
+      const rows = await this.rowService.list(this.controlTableId!)
+
+      const stats = {
+        totalControls: rows.rows.length,
+        activeControls: 0,
+        outdatedControls: 0,
+        errorControls: 0
+      }
+
+      for (const row of rows.rows) {
+        const status = (row as any).status
+        switch (status) {
+          case 'active':
+            stats.activeControls++
+            break
+          case 'outdated':
+            stats.outdatedControls++
+            break
+          case 'error':
+            stats.errorControls++
+            break
+        }
+      }
+
+      return stats
+    } catch (error) {
+      this.logger?.error?.('Failed to get control stats:', error)
+      return {
+        totalControls: 0,
+        activeControls: 0,
+        outdatedControls: 0,
+        errorControls: 0
+      }
+    }
+  }
+}