@gzl10/baserow 1.2.0

package/src/contexts/DatabaseContext.ts

@@ -0,0 +1,870 @@
+import { Logger, Database, BaserowNotFoundError } from '../types'
+import { TableContext } from './TableContext'
+import { WorkspaceService } from '../services/WorkspaceService'
+import { DatabaseService } from '../services/DatabaseService'
+import { TableService } from '../services/TableService'
+import { FieldService } from '../services/FieldService'
+import { RowService } from '../services/RowService'
+import { SchemaControlService } from '../services/SchemaControlService'
+import { validateRequired } from '../utils/validation'
+import { validateDatabaseSchema, validateLoadSchemaOptions } from '../validators/schema'
+import type {
+  DatabaseSchema,
+  LoadSchemaOptions,
+  LoadSchemaResult,
+  FieldSchema,
+  SchemaChange,
+  LoadSchemaStats,
+  TableSchema,
+  RelationshipSchema,
+  LoadSchemaMode,
+  SchemaControl,
+  Table
+} from '../types/schema'
+
+/**
+ * Context para operaciones en una database específica
+ *
+ * Proporciona una API jerárquica fluida para operaciones administrativas
+ * dentro de una database específica. Permite el acceso encadenado
+ * database → table → field/rows y operaciones CRUD completas.
+ *
+ * **Características principales:**
+ * - Resolución automática de database por nombre o ID (lazy loading)
+ * - API fluida para operaciones de tables: list, find, create, update, delete
+ * - Acceso directo a table contexts específicos
+ * - Operaciones CRUD completas de la database
+ * - Cache interno para evitar resoluciones repetidas
+ * - Logging opcional de todas las operaciones
+ * - Validación automática de permisos y scope
+ *
+ * **Patrón de API Jerárquica:**
+ * ```
+ * database.tables.findMany()              // Operaciones masivas
+ * database.table('name')              // Context específico
+ * database.update({ name: 'nuevo' })  // Actualizar database
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Operaciones básicas de database
+ * const tables = await database.tables.findMany()
+ * const newTable = await database.tables.create({ name: 'Nueva Tabla' })
+ * const found = await database.tables.find('Existente')
+ *
+ * // Acceso jerárquico a tabla
+ * const tableContext = database.table('Mi Tabla')
+ * const fields = await tableContext.field.list()
+ * const textField = await tableContext.field.createText('nombre')
+ *
+ * // Gestión de la database
+ * await database.update({ name: 'Nuevo Nombre' })
+ * await database.delete()
+ * ```
+ *
+ * @since 1.0.0
+ */
+export class DatabaseContext {
+  private databaseIdentifier: string | number
+  private resolvedDatabase?: Database
+  private logger?: Logger
+  private schemaControlService?: SchemaControlService
+
+  /**
+   * Crea un nuevo context de database
+   *
+   * @param workspaceService - Servicio para operaciones de workspace
+   * @param workspaceIdentifier - Identificador del workspace padre (opcional)
+   * @param databaseIdentifier - Nombre o ID de la database
+   * @param databaseService - Servicio para operaciones de database
+   * @param tableService - Servicio para operaciones de tabla
+   * @param fieldService - Servicio para operaciones de campos
+   * @param rowService - Servicio para operaciones de filas
+   * @param logger - Logger opcional para debug y trazabilidad
+   *
+   * @since 1.0.0
+   */
+  constructor(
+    private workspaceService: WorkspaceService,
+    private workspaceIdentifier: string | number | undefined,
+    databaseIdentifier: string | number,
+    private databaseService: DatabaseService,
+    private tableService: TableService,
+    private fieldService: FieldService,
+    private rowService: RowService,
+    logger?: Logger
+  ) {
+    this.databaseIdentifier = databaseIdentifier
+    this.logger = logger
+  }
+
+  /**
+   * Acceder a una tabla específica en esta database
+   *
+   * Crea un context para operaciones específicas en una tabla.
+   * Permite acceso jerárquico a campos y filas de la tabla.
+   * El identificador puede ser nombre (string) o ID (number).
+   *
+   * @param tableIdentifier - Nombre o ID numérico de la tabla
+   * @returns Context de tabla para operaciones específicas
+   *
+   * @example
+   * ```typescript
+   * // Acceso por nombre
+   * const tableContext = database.table('Mi Tabla')
+   *
+   * // Acceso por ID
+   * const tableContext2 = database.table(456)
+   *
+   * // Operaciones jerárquicas
+   * const fields = await tableContext.field.list()
+   * const textField = await tableContext.field.createText('nombre')
+   * const rows = await tableContext.rows.list()
+   * ```
+   *
+   * @since 1.0.0
+   */
+  table(tableIdentifier: string | number): TableContext {
+    return new TableContext(
+      this.workspaceService,
+      this.workspaceIdentifier,
+      this.databaseIdentifier,
+      tableIdentifier,
+      this.databaseService,
+      this.tableService,
+      this.fieldService,
+      this.rowService,
+      this.logger
+    )
+  }
+
+  /**
+   * Operaciones masivas de tables en esta database
+   *
+   * Proporciona métodos para gestionar tables de forma masiva:
+   * listar todas, buscar por nombre, crear, actualizar y eliminar.
+   * Todas las operaciones están restringidas a la database actual.
+   *
+   * @returns Objeto con métodos para operaciones de tables
+   *
+   * @example
+   * ```typescript
+   * // Listar todas las tables de la database
+   * const tables = await database.tables.findMany()
+   *
+   * // Buscar table específica
+   * const table = await database.tables.findUnique('Mi Tabla')
+   *
+   * // Crear nueva table
+   * const newTable = await database.tables.create({
+   *   name: 'Nueva Tabla',
+   *   first_row_header: true
+   * })
+   *
+   * // Operaciones específicas (usando API jerárquica)
+   * await database.table(123).update({ name: 'Nuevo Nombre' })
+   * await database.table(123).delete()
+   * ```
+   *
+   * @since 1.0.0
+   */
+  get tables() {
+    return {
+      /**
+       * Listar todas las tables de la database
+       *
+       * Obtiene todas las tables que pertenecen a esta database.
+       * Incluye metadatos completos de cada tabla.
+       *
+       * @returns Promise con array de tables de la database
+       *
+       * @example
+       * ```typescript
+       * const tables = await database.tables.findMany()
+       * console.log(`Encontradas ${tables.length} tables`)
+       * tables.forEach(table => {
+       *   console.log(`${table.name} (ID: ${table.id})`)
+       * })
+       * ```
+       *
+       * @since 1.0.0
+       */
+      findMany: async () => {
+        const database = await this.get()
+        return await this.tableService.findMany(database.id)
+      },
+
+      /**
+       * Buscar table por ID o nombre en esta database
+       *
+       * Busca una table específica por su ID o nombre dentro de la database.
+       * Útil para operaciones donde se conoce el identificador pero no se sabe si es ID o nombre.
+       *
+       * @param identifier - ID numérico o nombre de la table a buscar
+       * @returns Promise con la table encontrada o null si no existe
+       *
+       * @example
+       * ```typescript
+       * const table = await database.tables.findUnique('Usuarios')
+       * if (table) {
+       *   console.log(`Table encontrada: ${table.id}`)
+       * } else {
+       *   console.log('Table no encontrada')
+       * }
+       * ```
+       *
+       * @since 1.0.0
+       */
+      findUnique: async (identifier: string | number) => {
+        const database = await this.get()
+        return await this.tableService.findUnique(database.id, identifier)
+      },
+
+      // NOTA: get() no está en tables - usar database.table(id).get() para operaciones individuales
+
+      /**
+       * Crear nueva table en esta database
+       *
+       * Crea una nueva table vacía en esta database.
+       * La table se crea garantizando 0 campos y 0 filas.
+       *
+       * @param data - Datos de la nueva table
+       * @param data.name - Nombre de la table
+       * @param data.data - Datos iniciales (opcional)
+       * @param data.first_row_header - Si la primera fila son headers (opcional)
+       * @param data.skipDefaultCleanup - Saltarse limpieza automática del contenido por defecto de Baserow (opcional)
+       * @returns Promise con la table creada
+       *
+       * @throws {BaserowValidationError} Si los datos son inválidos
+       *
+       * @example
+       * ```typescript
+       * const newTable = await database.tables.create({
+       *   name: 'Usuarios',
+       *   first_row_header: true
+       * })
+       * console.log(`Table creada: ${newTable.id} - ${newTable.name}`)
+       * ```
+       *
+       * @since 1.0.0
+       */
+      create: async (data: { name: string; data?: any; first_row_header?: boolean; skipDefaultCleanup?: boolean }) => {
+        const database = await this.get()
+        return await this.tableService.create(database.id, data)
+      }
+    }
+  }
+
+  /**
+   * Actualizar esta database
+   *
+   * Actualiza los datos de la database. Solo actualiza los campos
+   * proporcionados (actualización parcial). Actualiza el cache interno
+   * si el nombre cambia.
+   *
+   * @param data - Datos a actualizar
+   * @param data.name - Nuevo nombre de la database (opcional)
+   * @param data.workspace_id - Nuevo workspace ID (opcional)
+   * @returns Promise con la database actualizada
+   *
+   * @throws {BaserowNotFoundError} Si la database no existe
+   * @throws {BaserowValidationError} Si los datos son inválidos
+   *
+   * @example
+   * ```typescript
+   * const updated = await database.update({
+   *   name: 'Nuevo Nombre CRM'
+   * })
+   * console.log(`Database actualizada: ${updated.name}`)
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async update(data: { name?: string; workspace_id?: number }): Promise<Database> {
+    const database = await this.get()
+    const contextAccess = (this.databaseService as any)[Symbol.for('databaseContext')]
+    const updatedDatabase = await contextAccess.updateDatabase(database.id, data)
+
+    // Actualizar cache si el nombre cambió
+    if (data.name && data.name !== database.name) {
+      this.resolvedDatabase = updatedDatabase
+      if (this.logger) {
+        this.logger.info(`Database updated: "${data.name}" (ID: ${updatedDatabase.id})`)
+      }
+    }
+
+    return updatedDatabase
+  }
+
+  /**
+   * Eliminar esta database
+   *
+   * Elimina permanentemente la database y todas sus tablas, campos y datos.
+   * Esta operación no se puede deshacer. Limpia el cache interno.
+   *
+   * @returns Promise que resuelve cuando la database es eliminada
+   *
+   * @throws {BaserowNotFoundError} Si la database no existe
+   *
+   * @example
+   * ```typescript
+   * await database.delete()
+   * console.log('Database eliminada exitosamente')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async delete(): Promise<void> {
+    const database = await this.get()
+    const contextAccess = (this.databaseService as any)[Symbol.for('databaseContext')]
+    await contextAccess.deleteDatabase(database.id)
+
+    if (this.logger) {
+      this.logger.info(`Database deleted: "${database.name}" (ID: ${database.id})`)
+    }
+
+    // Limpiar cache
+    this.resolvedDatabase = undefined
+  }
+
+  /**
+   * Obtener esta database completa
+   *
+   * Recupera la database con todos sus datos y metadatos.
+   * Utiliza lazy loading con cache para evitar resoluciones repetidas.
+   * Soporta identificación por nombre o ID de la database.
+   *
+   * @returns Promise con la database completa
+   *
+   * @throws {BaserowNotFoundError} Si la database no existe
+   * @throws {BaserowValidationError} Si el identificador es inválido
+   *
+   * @example Obtener por nombre
+   * ```typescript
+   * const database = await admin.workspace('Mi WS').database('Mi DB').get()
+   * console.log(`Database: ${database.name} (ID: ${database.id})`)
+   * console.log(`Tablas: ${database.tables?.length || 0}`)
+   * ```
+   *
+   * @example Obtener por ID
+   * ```typescript
+   * const database = await admin.workspace('Mi WS').database(123).get()
+   * console.log(`Nombre: ${database.name}`)
+   * console.log(`Workspace ID: ${database.workspace_id}`)
+   * ```
+   *
+   */
+  async get(): Promise<Database> {
+    if (this.resolvedDatabase) {
+      return this.resolvedDatabase
+    }
+
+    if (typeof this.databaseIdentifier === 'number') {
+      // Es un ID numérico
+      const database = await this.databaseService.findUnique(this.databaseIdentifier)
+      if (!database) {
+        throw new BaserowNotFoundError('Database', this.databaseIdentifier)
+      }
+      this.resolvedDatabase = database
+    } else {
+      // Es un nombre string
+      validateRequired(this.databaseIdentifier, 'database name')
+      const database = await this.databaseService.findUnique(this.databaseIdentifier)
+
+      if (!database) {
+        throw new BaserowNotFoundError('Database', this.databaseIdentifier)
+      }
+
+      this.resolvedDatabase = database
+    }
+
+    if (this.logger) {
+      this.logger.info(`Retrieved database: "${this.resolvedDatabase.name}" (ID: ${this.resolvedDatabase.id})`)
+    }
+
+    return this.resolvedDatabase
+  }
+
+  /**
+   * Cargar un schema completo de base de datos de forma declarativa
+   *
+   * Permite definir y aplicar esquemas completos de base de datos usando
+   * un formato JSON/TypeScript que incluye tablas, campos y relaciones.
+   * Proporciona control de versiones, detección de cambios y operaciones
+   * idempotentes para facilitar migraciones y setup automatizado.
+   *
+   * @param schema - Schema de la base de datos a cargar
+   * @param options - Opciones de carga (modo, versión, etc.)
+   * @returns Promise con resultado detallado de la operación
+   *
+   * @example Cargar schema básico
+   * ```typescript
+   * const ecommerceSchema: DatabaseSchema = {
+   *   tables: [
+   *     {
+   *       name: "clientes",
+   *       fields: [
+   *         { name: "nombre", type: "text" },
+   *         { name: "email", type: "email" },
+   *         {
+   *           name: "categoria",
+   *           type: "single_select",
+   *           config: {
+   *             options: [
+   *               { value: "Premium", color: "blue" },
+   *               { value: "Estándar", color: "green" }
+   *             ]
+   *           }
+   *         }
+   *       ]
+   *     }
+   *   ]
+   * }
+   *
+   * const result = await admin.database("mi-db").loadSchema(ecommerceSchema)
+   * console.log(`Creadas ${result.tables.length} tablas`)
+   * ```
+   *
+   * @example Con control de versiones
+   * ```typescript
+   * const result = await admin.database("mi-db").loadSchema(schema, {
+   *   mode: 'update',
+   *   version: '2.0.0',
+   *   force: false
+   * })
+   *
+   * if (result.changes.length > 0) {
+   *   console.log('Cambios aplicados:', result.changes)
+   * } else {
+   *   console.log('No hay cambios - schema actualizado')
+   * }
+   * ```
+   */
+  async loadSchema(schema: DatabaseSchema, options: LoadSchemaOptions = {}): Promise<LoadSchemaResult> {
+    const startTime = Date.now()
+    const stats: LoadSchemaStats = {
+      duration: 0,
+      tablesProcessed: 0,
+      fieldsProcessed: 0,
+      relationshipsProcessed: 0,
+      errors: 0,
+      warnings: 0
+    }
+
+    try {
+      // 1. Validar schema y opciones
+      const validatedSchema = validateDatabaseSchema(schema)
+      const validatedOptions = validateLoadSchemaOptions(options)
+
+      this.logger?.info?.(`Loading schema for database with ${validatedSchema.tables.length} tables`)
+
+      // 2. Asegurar que la database existe
+      const database = await this.get()
+
+      // 3. Inicializar control de schema
+      const schemaControl = await this.getSchemaControlService(database.id)
+      await schemaControl.initialize()
+
+      // 4. Verificar si hay cambios (a menos que sea force)
+      if (!validatedOptions.force) {
+        const hasChanges = await schemaControl.hasSchemaChanged(validatedSchema)
+        if (!hasChanges) {
+          this.logger?.info?.('No schema changes detected, skipping load')
+          const currentControl = await schemaControl.getCurrentControl()
+          return {
+            tables: [],
+            tablesByName: {},
+            schemaControl: currentControl!,
+            changes: [],
+            stats: { ...stats, duration: Date.now() - startTime }
+          }
+        }
+      }
+
+      // 5. Aplicar schema según el modo
+      const result = await this.applySchemaChanges(validatedSchema, validatedOptions, database.id, stats)
+
+      // 6. Actualizar control de schema
+      const tablesCreated = result.tables.map(t => t.name)
+      const finalControl = await schemaControl.createControl(validatedSchema, validatedOptions, tablesCreated)
+
+      const duration = Date.now() - startTime
+      this.logger?.info?.(`Schema loaded successfully in ${duration}ms`)
+
+      return {
+        ...result,
+        schemaControl: finalControl,
+        stats: { ...stats, duration }
+      }
+    } catch (error) {
+      stats.errors++
+      this.logger?.error?.('Failed to load schema:', error)
+      throw new Error(`Failed to load schema: ${(error as Error).message}`)
+    }
+  }
+
+  /**
+   * Aplicar cambios de schema según el modo especificado
+   */
+  private async applySchemaChanges(
+    schema: DatabaseSchema,
+    options: LoadSchemaOptions,
+    databaseId: number,
+    stats: LoadSchemaStats
+  ): Promise<Omit<LoadSchemaResult, 'schemaControl' | 'stats'>> {
+    // Aplicar defaults para opciones opcionales
+    const mode = options.mode || 'create-only'
+    // TODO: Implementar force y cleanup cuando se necesiten
+    // const force = options.force || false
+    // const cleanup = options.cleanup || false
+
+    const tables: Table[] = []
+    const tablesByName: Record<string, Table> = {}
+    const changes: SchemaChange[] = []
+    const tableNameToId = new Map<string, number>()
+
+    // Fase 1: Crear/actualizar tablas y campos básicos
+    for (const tableSchema of schema.tables) {
+      try {
+        const table = await this.processTable(tableSchema, mode, changes)
+        tables.push(table)
+        tablesByName[table.name] = table
+        tableNameToId.set(tableSchema.name.toLowerCase(), table.id)
+        stats.tablesProcessed++
+        stats.fieldsProcessed += tableSchema.fields.length
+
+        this.logger?.debug?.(`Processed table: ${table.name} (${tableSchema.fields.length} fields)`)
+      } catch (error) {
+        stats.errors++
+        this.logger?.error?.(`Failed to process table ${tableSchema.name}:`, error)
+        throw error
+      }
+    }
+
+    // Fase 2: Crear relaciones (después de que todas las tablas existan)
+    if (schema.relationships) {
+      for (const relationshipSchema of schema.relationships) {
+        try {
+          await this.processRelationship(relationshipSchema, tableNameToId, changes)
+          stats.relationshipsProcessed++
+
+          this.logger?.debug?.(`Created relationship: ${relationshipSchema.name}`)
+        } catch (error) {
+          stats.errors++
+          this.logger?.error?.(`Failed to create relationship ${relationshipSchema.name}:`, error)
+          throw error
+        }
+      }
+    }
+
+    return { tables, tablesByName, changes }
+  }
+
+  /**
+   * Procesar una tabla individual del schema
+   */
+  private async processTable(tableSchema: TableSchema, mode: LoadSchemaMode, changes: SchemaChange[]): Promise<Table> {
+    // Verificar si la tabla ya existe
+    const existingTable = await this.tableService.findUnique((await this.get()).id, tableSchema.name)
+
+    let table: Table
+
+    if (existingTable) {
+      if (mode === 'recreate') {
+        // TODO: Implementar delete cuando esté disponible públicamente
+        throw new Error('Recreate mode not yet implemented - delete method not available')
+      } else {
+        // Actualizar tabla existente
+        table = existingTable
+        await this.updateTableFields(table.id, tableSchema.fields, mode, changes)
+        changes.push({
+          type: 'table_updated',
+          target: tableSchema.name,
+          description: `Updated table fields`
+        })
+      }
+    } else {
+      // Crear nueva tabla
+      table = await this.createTableWithFields(tableSchema)
+      changes.push({
+        type: 'table_created',
+        target: tableSchema.name,
+        description: `Created new table with ${tableSchema.fields.length} fields`
+      })
+    }
+
+    return table
+  }
+
+  /**
+   * Crear tabla con todos sus campos
+   */
+  private async createTableWithFields(tableSchema: TableSchema): Promise<Table> {
+    // Crear tabla vacía
+    const table = await this.tables.create({
+      name: tableSchema.name,
+      data: [['temp']],
+      first_row_header: false
+    })
+
+    // TODO: Eliminar campo temporal cuando delete esté disponible
+    // const tempFields = await this.fieldService.findMany(table.id)
+    // if (tempFields.length > 0) {
+    //   await this.fieldService.delete(tempFields[0].id)
+    // }
+
+    // Crear todos los campos
+    for (const fieldSchema of tableSchema.fields) {
+      await this.createFieldFromSchema(table.id, fieldSchema)
+    }
+
+    return table
+  }
+
+  /**
+   * Actualizar campos de una tabla existente
+   */
+  private async updateTableFields(
+    tableId: number,
+    fieldSchemas: FieldSchema[],
+    mode: LoadSchemaMode,
+    changes: SchemaChange[]
+  ): Promise<void> {
+    const existingFields = await this.fieldService.findMany(tableId)
+    const existingFieldsByName = new Map(existingFields.map(f => [f.name.toLowerCase(), f]))
+
+    for (const fieldSchema of fieldSchemas) {
+      const existingField = existingFieldsByName.get(fieldSchema.name.toLowerCase())
+
+      if (existingField) {
+        if (mode === 'update') {
+          // Actualizar campo existente si es necesario
+          // Por simplicidad, no implementamos actualización de campos en esta versión
+          changes.push({
+            type: 'field_updated',
+            target: `${tableId}.${fieldSchema.name}`,
+            description: `Field exists, no update implemented yet`
+          })
+        }
+      } else {
+        // Crear campo nuevo
+        await this.createFieldFromSchema(tableId, fieldSchema)
+        changes.push({
+          type: 'field_created',
+          target: `${tableId}.${fieldSchema.name}`,
+          description: `Created new field: ${fieldSchema.type}`
+        })
+      }
+    }
+  }
+
+  /**
+   * Crear campo usando el factory method
+   */
+  private async createFieldFromSchema(tableId: number, fieldSchema: FieldSchema): Promise<void> {
+    const tableContext = this.table(tableId)
+
+    switch (fieldSchema.type) {
+      case 'text':
+        await tableContext.fields.createText(
+          fieldSchema.name,
+          '', // default value (removed dynamic access)
+          fieldSchema.description
+        )
+        break
+
+      case 'long_text':
+        await tableContext.fields.createLongText(fieldSchema.name, fieldSchema.description)
+        break
+
+      case 'email':
+        await tableContext.fields.createEmail(fieldSchema.name, fieldSchema.description)
+        break
+
+      case 'url':
+        await tableContext.fields.createUrl(fieldSchema.name, fieldSchema.description)
+        break
+
+      case 'phone_number':
+        await tableContext.fields.createPhoneNumber(fieldSchema.name, fieldSchema.description)
+        break
+
+      case 'number':
+        const numberConfig = fieldSchema.config as any
+        await tableContext.fields.createNumber(
+          fieldSchema.name,
+          numberConfig?.decimals || 0,
+          false, // negative allowed
+          0, // default value (removed dynamic access)
+          numberConfig?.prefix || '',
+          numberConfig?.suffix || '',
+          numberConfig?.separators || 'COMMA_PERIOD',
+          fieldSchema.description
+        )
+        break
+
+      case 'rating':
+        await tableContext.fields.createRating(
+          fieldSchema.name,
+          5, // max value
+          'yellow', // color
+          'star', // style
+          fieldSchema.description
+        )
+        break
+
+      case 'boolean':
+        const boolConfig = fieldSchema.config as any
+        await tableContext.fields.createBoolean(fieldSchema.name, boolConfig?.default || false, fieldSchema.description)
+        break
+
+      case 'date':
+        const dateConfig = fieldSchema.config as any
+        await tableContext.fields.createDate(
+          fieldSchema.name,
+          dateConfig?.includeTime || false,
+          dateConfig?.format || 'ISO',
+          dateConfig?.timeFormat || '24',
+          false, // force timezone
+          dateConfig?.timezone,
+          dateConfig?.default,
+          fieldSchema.description
+        )
+        break
+
+      case 'single_select':
+        const selectConfig = fieldSchema.config as any
+        if (!selectConfig?.options) {
+          throw new Error(`single_select field ${fieldSchema.name} requires options in config`)
+        }
+        await tableContext.fields.createSelect(fieldSchema.name, selectConfig.options, fieldSchema.description)
+        break
+
+      case 'multiple_select':
+        const multiSelectConfig = fieldSchema.config as any
+        if (!multiSelectConfig?.options) {
+          throw new Error(`multiple_select field ${fieldSchema.name} requires options in config`)
+        }
+        await tableContext.fields.createMultiSelect(
+          fieldSchema.name,
+          multiSelectConfig.options,
+          fieldSchema.description
+        )
+        break
+
+      case 'file':
+        await tableContext.fields.createFile(fieldSchema.name, fieldSchema.description)
+        break
+
+      case 'autonumber':
+        await tableContext.fields.createAutonumber(fieldSchema.name, fieldSchema.description)
+        break
+
+      // Los campos de relación se manejan en la fase 2
+      case 'link_row':
+        // Skip - se procesa en processRelationship
+        break
+
+      default:
+        throw new Error(`Unsupported field type: ${fieldSchema.type}`)
+    }
+  }
+
+  /**
+   * Procesar una relación entre tablas
+   */
+  private async processRelationship(
+    relationshipSchema: RelationshipSchema,
+    tableNameToId: Map<string, number>,
+    changes: SchemaChange[]
+  ): Promise<void> {
+    const sourceTableId = tableNameToId.get(relationshipSchema.sourceTable.toLowerCase())
+    const targetTableId = tableNameToId.get(relationshipSchema.targetTable.toLowerCase())
+
+    if (!sourceTableId || !targetTableId) {
+      throw new Error(
+        `Cannot create relationship ${relationshipSchema.name}: ` +
+          `source table ${relationshipSchema.sourceTable} or target table ${relationshipSchema.targetTable} not found`
+      )
+    }
+
+    const sourceTableContext = this.table(sourceTableId)
+    await sourceTableContext.fields.createLink(relationshipSchema.name, targetTableId, relationshipSchema.description)
+
+    changes.push({
+      type: 'relationship_created',
+      target: relationshipSchema.name,
+      description: `Created link from ${relationshipSchema.sourceTable} to ${relationshipSchema.targetTable}`
+    })
+  }
+
+  /**
+   * Obtener o crear el servicio de control de schema
+   */
+  private async getSchemaControlService(databaseId: number): Promise<SchemaControlService> {
+    if (!this.schemaControlService) {
+      this.schemaControlService = new SchemaControlService(
+        databaseId,
+        this.tableService,
+        this.fieldService,
+        this.rowService,
+        this.logger
+      )
+    }
+    return this.schemaControlService
+  }
+
+  /**
+   * Obtener el control de schema actual de la database
+   */
+  async getSchemaControl(): Promise<SchemaControl | null> {
+    const database = await this.get()
+    const schemaControl = await this.getSchemaControlService(database.id)
+    await schemaControl.initialize()
+    return await schemaControl.getCurrentControl()
+  }
+
+  /**
+   * Verificar si esta database existe
+   *
+   * Método de utilidad para verificar la existencia de la database
+   * sin cargar todos sus datos. Útil para validaciones previas.
+   *
+   * @returns Promise con true si existe, false si no
+   *
+   * @example Verificar existencia por nombre
+   * ```typescript
+   * const exists = await admin.workspace('Mi WS').database('Mi DB').exists()
+   * if (exists) {
+   *   console.log('La database existe')
+   * } else {
+   *   console.log('La database no fue encontrada')
+   * }
+   * ```
+   *
+   * @example Verificar antes de crear
+   * ```typescript
+   * const databaseName = 'Nueva Database'
+   * const exists = await admin.workspace('Mi WS').database(databaseName).exists()
+   *
+   * if (!exists) {
+   *   await admin.workspace('Mi WS').databases.create(databaseName)
+   *   console.log('Database creada exitosamente')
+   * } else {
+   *   console.log('La database ya existe')
+   * }
+   * ```
+   *
+   */
+  async exists(): Promise<boolean> {
+    try {
+      await this.get()
+      return true
+    } catch (error) {
+      if ((error as any).name === 'BaserowNotFoundError') {
+        return false
+      }
+      throw error
+    }
+  }
+}