@gzl10/baserow 1.2.0

package/src/services/FieldService.ts

@@ -0,0 +1,1543 @@
+import { HttpService } from './core/HttpService'
+import { ValidationService } from './core/ValidationService'
+import {
+  Field,
+  CreateFieldRequest,
+  UpdateFieldRequest,
+  SelectOption,
+  NumberSeparator,
+  RatingStyle,
+  RatingColor,
+  FieldConstraint,
+  FieldAdvancedOptions,
+  ConstraintType,
+  BaserowResponse,
+  BaserowNotFoundError,
+  BaserowValidationError,
+  Logger
+} from '../types/index'
+import { sanitizeFieldName, validateFieldType } from '../utils/validation'
+
+/**
+ * Servicio para operaciones CRUD de campos de Baserow
+ *
+ * Proporciona operaciones completas de campos incluyendo CRUD básico,
+ * métodos de creación fluidos para todos los tipos de campo soportados,
+ * y operaciones de gestión avanzadas como duplicación y reordenamiento.
+ *
+ * **Cobertura de Tipos de Campo (21/22 - 95%):**
+ * - **Texto (5)**: text, long_text, url, email, phone_number
+ * - **Numéricos (3)**: number, boolean, rating
+ * - **Fecha/Auditoría (5)**: date, last_modified, last_modified_by, created_on, created_by
+ * - **Selección (2)**: single_select, multiple_select
+ * - **Relacionales (2)**: link_row, formula
+ * - **Avanzados (5)**: file, autonumber, count, rollup, lookup
+ *
+ * **Características:**
+ * - API fluida para cada tipo de campo con parámetros específicos
+ * - Validación automática de tipos y configuraciones
+ * - Sanitización de nombres de campo
+ * - Operaciones avanzadas: duplicar, reordenar
+ * - Búsqueda de campos por nombre
+ * - **Soporte v1.35+**: Índices para performance y constraints para integridad
+ *
+ * @example
+ * ```typescript
+ * // Operaciones básicas
+ * const fields = await fieldService.findMany(tableId)
+ * const field = await fieldService.get(fieldId)
+ * const found = await fieldService.findUnique(tableId, 'email')
+ *
+ * // API fluida por tipo de campo (MANTENER - Sin cambios)
+ * const textField = await fieldService.createTextField(tableId, 'nombre', 'default')
+ * const numberField = await fieldService.createNumberField(tableId, 'precio', 2, true)
+ * const selectField = await fieldService.createSelectField(tableId, 'estado', [
+ *   { value: 'active', color: 'blue' },
+ *   { value: 'inactive', color: 'red' }
+ * ])
+ *
+ * // Campos avanzados (MANTENER - Sin cambios)
+ * const linkField = await fieldService.createLinkField(tableId, 'relacionado', targetTableId)
+ * const formulaField = await fieldService.createFormulaField(tableId, 'total', 'field("precio") * field("cantidad")')
+ *
+ * // Campos con índices y constraints (v1.35+)
+ * const emailField = await fieldService.createEmailField(tableId, 'email', undefined, {
+ *   index: true,
+ *   constraints: [{ type: 'unique_with_empty', active: true }]
+ * })
+ *
+ * // Gestión de índices y constraints
+ * await fieldService.setFieldIndex(fieldId, true)
+ * await fieldService.addFieldConstraint(fieldId, { type: 'unique', active: true })
+ * ```
+ *
+ * @since 1.0.0
+ */
+export class FieldService extends HttpService {
+  private validationService: ValidationService
+
+  constructor(http: any, logger?: Logger) {
+    super(http, logger)
+    this.validationService = new ValidationService(http, logger)
+  }
+
+  // ===== PUBLIC API (Prisma-style) =====
+
+  /**
+   * Listar todos los campos de una tabla
+   *
+   * Obtiene todos los campos de una tabla específica con sus definiciones
+   * completas incluyendo tipo, configuración y metadatos.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @returns Promise con array de campos de la tabla
+   *
+   * @throws {BaserowValidationError} Si el tableId es inválido
+   *
+   * @example
+   * ```typescript
+   * const fields = await fieldService.findMany(123)
+   * fields.forEach(field => {
+   *   console.log(`${field.name} (${field.type}): ${field.id}`)
+   * })
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async findMany(tableId: number): Promise<Field[]> {
+    this.validationService.validateId(tableId, 'table ID')
+
+    try {
+      const response = await this.http.get<BaserowResponse<Field> | Field[]>(`/database/fields/table/${tableId}/`)
+
+      // La API puede devolver array directo o {results: []}
+      const fields = Array.isArray(response) ? response : response.results || []
+      this.logSuccess('find many fields', tableId, { count: fields.length })
+      return fields
+    } catch (error) {
+      this.handleHttpError(error, 'find many fields', tableId)
+    }
+  }
+
+  /**
+   * Obtener campo por ID
+   *
+   * Recupera un campo específico por su ID con toda su configuración
+   * y metadatos. Útil para inspeccionar configuraciones detalladas.
+   *
+   * @param fieldId - ID numérico del campo
+   * @returns Promise con datos completos del campo
+   *
+   * @throws {BaserowNotFoundError} Si el campo no existe
+   * @throws {BaserowValidationError} Si el fieldId es inválido
+   *
+   * @example
+   * ```typescript
+   * const field = await fieldService.get(456)
+   * console.log(`Campo: ${field.name} - Tipo: ${field.type}`)
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async get(fieldId: number): Promise<Field> {
+    this.validationService.validateId(fieldId, 'field ID')
+    return this.getById<Field>('/database/fields', fieldId)
+  }
+
+  /**
+   * Buscar campo por ID o nombre en una tabla
+   *
+   * Busca un campo específico por su ID o nombre dentro de una tabla.
+   * Útil para operaciones dinámicas donde se conoce el identificador pero no se sabe si es ID o nombre.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param identifier - ID numérico o nombre del campo a buscar
+   * @returns Promise con el campo encontrado o null si no existe
+   *
+   * @throws {BaserowValidationError} Si los parámetros son inválidos
+   *
+   * @example
+   * ```typescript
+   * const field = await fieldService.findUnique(123, 'email')
+   * if (field) {
+   *   console.log(`Campo encontrado: ${field.id}`)
+   * } else {
+   *   console.log('Campo no encontrado')
+   * }
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async findUnique(tableId: number, identifier: string | number): Promise<Field | null> {
+    this.validationService.validateId(tableId, 'table ID')
+
+    if (typeof identifier === 'number') {
+      // Buscar por ID
+      try {
+        return await this.get(identifier)
+      } catch (error) {
+        if (error instanceof BaserowNotFoundError) {
+          return null
+        }
+        throw error
+      }
+    } else {
+      // Buscar por nombre
+      this.validationService.validateResourceName(identifier, 'field')
+      const fields = await this.findMany(tableId)
+      const found = fields.find(field => field.name === identifier) || null
+
+      if (found) {
+        this.logSuccess(`find field by name "${identifier}"`, found.id)
+      } else {
+        this.logDebug(`No field found with name "${identifier}" in table ${tableId}`)
+      }
+
+      return found
+    }
+  }
+
+  /**
+   * Crear nuevo campo - API pública
+   *
+   * Crea un nuevo campo en la tabla especificada. Este es el método base
+   * que usan todos los métodos de creación específicos por tipo.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param data - Configuración completa del campo
+   * @returns Promise con el campo creado
+   *
+   * @throws {BaserowValidationError} Si los datos son inválidos
+   *
+   * @example
+   * ```typescript
+   * const field = await fieldService.create(123, {
+   *   name: 'Mi Campo',
+   *   type: 'text',
+   *   text_default: 'Valor por defecto',
+   *   description: 'Descripción del campo'
+   * })
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async create(tableId: number, data: CreateFieldRequest): Promise<Field> {
+    return this.createFieldInternal(tableId, data)
+  }
+
+  // ===== PRIVATE METHODS =====
+
+  /**
+   * Crear nuevo campo (método interno)
+   * @private - Solo para uso interno del servicio
+   */
+  private async createFieldInternal(tableId: number, data: CreateFieldRequest): Promise<Field> {
+    this.validationService.validateId(tableId, 'table ID')
+    data.name = sanitizeFieldName(data.name)
+    this.validationService.validateResourceName(data.name, 'field')
+    validateFieldType(data.type, 'type')
+
+    const payload = {
+      table_id: tableId,
+      ...data
+    }
+
+    try {
+      this.logDebug(`Creating field "${data.name}" of type ${data.type} in table ${tableId}`, payload)
+      const response = await this.http.post<Field>(`/database/fields/table/${tableId}/`, payload)
+      this.logSuccess('create field', response.id, { name: data.name, type: data.type })
+      return response
+    } catch (error) {
+      this.handleHttpError(error, 'create field', tableId)
+    }
+  }
+
+  /**
+   * Actualizar campo (método interno)
+   * @private - Solo para uso por FieldContext
+   */
+  private async updateFieldInternal(fieldId: number, data: UpdateFieldRequest): Promise<Field> {
+    this.validationService.validateId(fieldId, 'field ID')
+
+    if (data.name !== undefined) {
+      data.name = sanitizeFieldName(data.name)
+      this.validationService.validateResourceName(data.name, 'field')
+    }
+
+    try {
+      this.logDebug(`Updating field ${fieldId}`, data)
+      const response = await this.http.patch<Field>(`/database/fields/${fieldId}/`, data)
+      this.logSuccess('update field', fieldId)
+      return response
+    } catch (error) {
+      if ((error as any).status === 404) {
+        throw new BaserowNotFoundError('Field', fieldId)
+      }
+      this.handleHttpError(error, 'update field', fieldId)
+    }
+  }
+
+  /**
+   * Eliminar campo (método interno)
+   * @private - Solo para uso por FieldContext
+   */
+  private async deleteFieldInternal(fieldId: number): Promise<void> {
+    this.validationService.validateId(fieldId, 'field ID')
+    return this.deleteById('/database/fields', fieldId)
+  }
+
+  /**
+   * Duplicar campo
+   *
+   * Crea una copia exacta de un campo existente con un nuevo nombre.
+   * Mantiene toda la configuración del campo original.
+   *
+   * @param fieldId - ID numérico del campo a duplicar
+   * @param newName - Nombre para el campo duplicado (opcional)
+   * @returns Promise con el campo duplicado
+   *
+   * @throws {BaserowValidationError} Si los parámetros son inválidos
+   *
+   * @example
+   * ```typescript
+   * const duplicated = await fieldService.duplicate(456, 'Copia del campo')
+   * console.log(`Campo duplicado: ${duplicated.id}`)
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async duplicate(fieldId: number, newName?: string): Promise<Field> {
+    this.validationService.validateId(fieldId, 'field ID')
+
+    const originalField = await this.get(fieldId)
+    const name = newName ? sanitizeFieldName(newName) : `${originalField.name} (copy)`
+
+    if (newName) {
+      this.validationService.validateResourceName(name, 'field')
+    }
+
+    try {
+      this.logDebug(`Duplicating field ${fieldId} with name "${name}"`, { originalName: originalField.name })
+      const response = await this.http.post<Field>(`/database/fields/${fieldId}/duplicate/`, { name })
+      this.logSuccess('duplicate field', response.id, { originalId: fieldId, newName: name })
+      return response
+    } catch (error) {
+      this.handleHttpError(error, 'duplicate field', fieldId)
+    }
+  }
+
+  /**
+   * Reordenar campos de una tabla
+   *
+   * Cambia el orden de visualización de los campos en una tabla.
+   * El orden se define por la secuencia de IDs proporcionada.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param fieldIds - Array de IDs de campos en el nuevo orden deseado
+   * @returns Promise que resuelve cuando el reordenamiento se completa
+   *
+   * @throws {BaserowValidationError} Si los parámetros son inválidos
+   *
+   * @example
+   * ```typescript
+   * // Reordenar campos: primero ID 3, luego 1, luego 2
+   * await fieldService.reorder(123, [3, 1, 2])
+   * console.log('Campos reordenados exitosamente')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async reorder(tableId: number, fieldIds: number[]): Promise<void> {
+    this.validationService.validateId(tableId, 'table ID')
+
+    if (!Array.isArray(fieldIds) || fieldIds.length === 0) {
+      throw new Error('fieldIds must be a non-empty array')
+    }
+
+    fieldIds.forEach(id => this.validationService.validateId(id, 'field ID'))
+
+    try {
+      this.logDebug(`Reordering ${fieldIds.length} fields in table ${tableId}`, { fieldIds })
+      await this.http.patch(`/database/tables/${tableId}/order-fields/`, {
+        field_ids: fieldIds
+      })
+      this.logSuccess('reorder fields', tableId, { fieldCount: fieldIds.length })
+    } catch (error) {
+      this.handleHttpError(error, 'reorder fields', tableId)
+    }
+  }
+
+  // ===== HELPERS PARA TIPOS ESPECÍFICOS =====
+
+  /**
+   * Crear campo de texto
+   *
+   * Crea un campo de texto simple con valor por defecto opcional.
+   * El tipo de campo más básico para almacenar cadenas de texto cortas.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param defaultValue - Valor por defecto (opcional)
+   * @param description - Descripción del campo (opcional)
+   * @param advancedOptions - Opciones avanzadas: índice y constraints (v1.35+)
+   * @returns Promise con el campo de texto creado
+   *
+   * @example
+   * ```typescript
+   * const nameField = await fieldService.createTextField(123, 'nombre', 'Sin nombre')
+   * const titleField = await fieldService.createTextField(123, 'titulo')
+   *
+   * // Con índice y constraint (v1.35+)
+   * const codeField = await fieldService.createTextField(123, 'codigo', undefined, undefined, {
+   *   index: true,
+   *   constraints: [{ type: 'unique_with_empty', active: true }]
+   * })
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createTextField(
+    tableId: number,
+    name: string,
+    defaultValue?: string,
+    description?: string,
+    advancedOptions?: FieldAdvancedOptions
+  ): Promise<Field> {
+    const baseRequest = {
+      name,
+      type: 'text' as const,
+      text_default: defaultValue || '',
+      description
+    }
+
+    return this.create(tableId, this.applyAdvancedOptions(baseRequest, advancedOptions))
+  }
+
+  /**
+   * Crear campo de texto largo
+   *
+   * Crea un campo de texto largo (multilinea) para almacenar texto extenso.
+   * Ideal para descripciones, comentarios o contenido largo.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param defaultValue - Valor por defecto (opcional)
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de texto largo creado
+   *
+   * @example
+   * ```typescript
+   * const descField = await fieldService.createLongTextField(123, 'descripcion')
+   * const notesField = await fieldService.createLongTextField(123, 'notas', 'Sin notas')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createLongTextField(
+    tableId: number,
+    name: string,
+    defaultValue?: string,
+    description?: string
+  ): Promise<Field> {
+    return this.create(tableId, {
+      name,
+      type: 'long_text',
+      text_default: defaultValue || '',
+      description
+    })
+  }
+
+  /**
+   * Crear campo numérico
+   *
+   * Crea un campo numérico con configuración completa de formato y validación.
+   * Soporta decimales, prefijos/sufijos, separadores y valores por defecto.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param decimalPlaces - Número de decimales (0-10, default: 0)
+   * @param allowNegative - Permitir números negativos (default: true)
+   * @param defaultValue - Valor numérico por defecto (opcional)
+   * @param prefix - Prefijo para mostrar (ej: '$', default: undefined)
+   * @param suffix - Sufijo para mostrar (ej: '%', default: undefined)
+   * @param separator - Separador de miles (default: 'COMMA_PERIOD')
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo numérico creado
+   *
+   * @throws {BaserowValidationError} Si decimalPlaces no está entre 0-10
+   *
+   * @example
+   * ```typescript
+   * // Campo de precio con 2 decimales y símbolo $
+   * const priceField = await fieldService.createNumberField(123, 'precio', 2, true, 0, '$')
+   *
+   * // Campo de porcentaje
+   * const percentField = await fieldService.createNumberField(123, 'descuento', 1, false, 0, undefined, '%')
+   *
+   * // Campo entero simple
+   * const ageField = await fieldService.createNumberField(123, 'edad', 0)
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createNumberField(
+    tableId: number,
+    name: string,
+    decimalPlaces = 0,
+    allowNegative = true,
+    defaultValue?: number,
+    prefix?: string,
+    suffix?: string,
+    separator: NumberSeparator = 'COMMA_PERIOD',
+    description?: string
+  ): Promise<Field> {
+    // Validar number_decimal_places (debe estar entre 0-10)
+    if (!Number.isInteger(decimalPlaces) || decimalPlaces < 0 || decimalPlaces > 10) {
+      throw new BaserowValidationError(`Decimal places must be an integer between 0 and 10, got: ${decimalPlaces}`, {
+        number_decimal_places: [`Value must be between 0 and 10, got: ${decimalPlaces}`]
+      })
+    }
+
+    return this.create(tableId, {
+      name,
+      type: 'number',
+      number_decimal_places: decimalPlaces,
+      number_negative: allowNegative,
+      number_default: defaultValue !== undefined ? defaultValue.toFixed(decimalPlaces) : undefined,
+      number_prefix: prefix,
+      number_suffix: suffix,
+      number_separator: separator,
+      description
+    })
+  }
+
+  /**
+   * Crear campo booleano
+   *
+   * Crea un campo booleano (checkbox) para valores verdadero/falso.
+   * Ideal para estados, flags o configuraciones binarias.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param defaultValue - Valor por defecto (default: false)
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo booleano creado
+   *
+   * @example
+   * ```typescript
+   * const activeField = await fieldService.createBooleanField(123, 'activo', true)
+   * const verifiedField = await fieldService.createBooleanField(123, 'verificado')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createBooleanField(tableId: number, name: string, defaultValue = false, description?: string): Promise<Field> {
+    return this.create(tableId, {
+      name,
+      type: 'boolean',
+      boolean_default: defaultValue,
+      description
+    })
+  }
+
+  /**
+   * Crear campo de selección simple
+   *
+   * Crea un campo de selección simple donde solo se puede elegir una opción.
+   * Las opciones incluyen valor y color para visualización.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param options - Array de opciones con value y color
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de selección simple creado
+   *
+   * @throws {Error} Si no se proporcionan opciones
+   *
+   * @example
+   * ```typescript
+   * const statusField = await fieldService.createSelectField(123, 'estado', [
+   *   { value: 'pendiente', color: 'yellow' },
+   *   { value: 'completado', color: 'green' },
+   *   { value: 'cancelado', color: 'red' }
+   * ])
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createSelectField(
+    tableId: number,
+    name: string,
+    options: SelectOption[],
+    description?: string
+  ): Promise<Field> {
+    if (!options || !Array.isArray(options) || options.length === 0) {
+      throw new Error('Select field must have at least one option')
+    }
+
+    if (!Array.isArray(options) || options.length === 0) {
+      throw new Error('Select field must have at least one option')
+    }
+
+    return this.create(tableId, {
+      name,
+      type: 'single_select',
+      select_options: options,
+      description
+    })
+  }
+
+  /**
+   * Crear campo de selección múltiple
+   *
+   * Crea un campo de selección múltiple donde se pueden elegir varias opciones.
+   * Útil para tags, categorías o cualquier clasificación múltiple.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param options - Array de opciones con value y color
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de selección múltiple creado
+   *
+   * @throws {Error} Si no se proporcionan opciones
+   *
+   * @example
+   * ```typescript
+   * const tagsField = await fieldService.createMultiSelectField(123, 'tags', [
+   *   { value: 'importante', color: 'red' },
+   *   { value: 'urgente', color: 'orange' },
+   *   { value: 'revision', color: 'blue' }
+   * ])
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createMultiSelectField(
+    tableId: number,
+    name: string,
+    options: SelectOption[],
+    description?: string
+  ): Promise<Field> {
+    if (!options || !Array.isArray(options) || options.length === 0) {
+      throw new Error('Multi-select field must have at least one option')
+    }
+
+    if (!Array.isArray(options) || options.length === 0) {
+      throw new Error('Multi-select field must have at least one option')
+    }
+
+    return this.create(tableId, {
+      name,
+      type: 'multiple_select',
+      select_options: options,
+      description
+    })
+  }
+
+  /**
+   * Crear campo de fecha
+   *
+   * Crea un campo de fecha con configuración completa de formato y zona horaria.
+   * Soporta fechas simples o fechas con hora, y configuración de timezone.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param includeTime - Incluir hora además de fecha (default: false)
+   * @param dateFormat - Formato de fecha (default: 'ISO')
+   * @param timeFormat - Formato de hora (default: '24')
+   * @param showTzInfo - Mostrar información de timezone (default: false)
+   * @param forceTimezone - Timezone forzado (opcional)
+   * @param forceTimezoneOffset - Offset de timezone forzado (opcional)
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de fecha creado
+   *
+   * @example
+   * ```typescript
+   * // Fecha simple
+   * const birthField = await fieldService.createDateField(123, 'nacimiento')
+   *
+   * // Fecha con hora
+   * const createdField = await fieldService.createDateField(123, 'creado', true, 'ISO', '24')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createDateField(
+    tableId: number,
+    name: string,
+    includeTime = false,
+    dateFormat = 'ISO',
+    timeFormat = '24',
+    showTzInfo = false,
+    forceTimezone?: string,
+    forceTimezoneOffset?: number,
+    description?: string
+  ): Promise<Field> {
+    return this.create(tableId, {
+      name,
+      type: 'date',
+      date_include_time: includeTime,
+      date_format: dateFormat,
+      date_time_format: timeFormat,
+      date_show_tzinfo: showTzInfo,
+      date_force_timezone: forceTimezone,
+      date_force_timezone_offset: forceTimezoneOffset,
+      description
+    })
+  }
+
+  /**
+   * Crear campo de enlace a otra tabla
+   *
+   * Crea un campo de relación que enlaza con otra tabla (foreign key).
+   * Permite crear relaciones entre tablas para modelar datos relacionales.
+   *
+   * @param tableId - ID numérico de la tabla origen
+   * @param name - Nombre del campo
+   * @param targetTableId - ID numérico de la tabla destino
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de enlace creado
+   *
+   * @throws {BaserowValidationError} Si targetTableId es inválido
+   *
+   * @example
+   * ```typescript
+   * // Relacionar tabla de pedidos con tabla de clientes
+   * const customerField = await fieldService.createLinkField(ordersTableId, 'cliente', customersTableId)
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createLinkField(tableId: number, name: string, targetTableId: number, description?: string): Promise<Field> {
+    this.validationService.validateId(targetTableId, 'target table ID')
+
+    return this.create(tableId, {
+      name,
+      type: 'link_row',
+      link_row_table_id: targetTableId,
+      description
+    })
+  }
+
+  /**
+   * Crear campo de fórmula
+   *
+   * Crea un campo calculado que usa una fórmula para derivar su valor
+   * de otros campos de la misma fila. El valor se actualiza automáticamente.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param formula - Fórmula de cálculo (sintaxis de Baserow)
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de fórmula creado
+   *
+   * @throws {Error} Si la fórmula está vacía
+   *
+   * @example
+   * ```typescript
+   * // Campo que calcula el total como precio * cantidad
+   * const totalField = await fieldService.createFormulaField(
+   *   123,
+   *   'total',
+   *   'field("precio") * field("cantidad")'
+   * )
+   *
+   * // Campo que concatena nombre y apellido
+   * const fullNameField = await fieldService.createFormulaField(
+   *   123,
+   *   'nombre_completo',
+   *   'concat(field("nombre"), " ", field("apellido"))'
+   * )
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createFormulaField(tableId: number, name: string, formula: string, description?: string): Promise<Field> {
+    if (!formula || typeof formula !== 'string' || formula.trim() === '') {
+      throw new Error('Formula is required and must be a non-empty string')
+    }
+
+    return this.create(tableId, {
+      name,
+      type: 'formula',
+      formula,
+      description
+    })
+  }
+
+  /**
+   * Crear campo de URL
+   *
+   * Crea un campo especializado para almacenar URLs con validación automática.
+   * Los valores se validan como URLs válidas y se muestran como enlaces.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de URL creado
+   *
+   * @example
+   * ```typescript
+   * const websiteField = await fieldService.createUrlField(123, 'sitio_web')
+   * const linkedinField = await fieldService.createUrlField(123, 'perfil_linkedin')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createUrlField(tableId: number, name: string, description?: string): Promise<Field> {
+    return this.create(tableId, {
+      name,
+      type: 'url',
+      description
+    })
+  }
+
+  /**
+   * Crear campo de email
+   *
+   * Crea un campo especializado para almacenar direcciones de email
+   * con validación automática de formato.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param description - Descripción del campo (opcional)
+   * @param advancedOptions - Opciones avanzadas: índice y constraints (v1.35+)
+   * @returns Promise con el campo de email creado
+   *
+   * @example
+   * ```typescript
+   * const emailField = await fieldService.createEmailField(123, 'email')
+   * const contactField = await fieldService.createEmailField(123, 'email_contacto')
+   *
+   * // Con índice y restricción de unicidad (v1.35+)
+   * const uniqueEmailField = await fieldService.createEmailField(123, 'email', undefined, {
+   *   index: true,
+   *   constraints: [{ type: 'unique', active: true }]
+   * })
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createEmailField(
+    tableId: number,
+    name: string,
+    description?: string,
+    advancedOptions?: FieldAdvancedOptions
+  ): Promise<Field> {
+    const baseRequest = {
+      name,
+      type: 'email' as const,
+      description
+    }
+
+    return this.create(tableId, this.applyAdvancedOptions(baseRequest, advancedOptions))
+  }
+
+  /**
+   * Crear campo de teléfono
+   *
+   * Crea un campo especializado para almacenar números de teléfono
+   * con formateo automático y validación.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de teléfono creado
+   *
+   * @example
+   * ```typescript
+   * const phoneField = await fieldService.createPhoneField(123, 'telefono')
+   * const mobileField = await fieldService.createPhoneField(123, 'movil')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createPhoneField(tableId: number, name: string, description?: string): Promise<Field> {
+    return this.create(tableId, {
+      name,
+      type: 'phone_number',
+      description
+    })
+  }
+
+  /**
+   * Crear campo de rating
+   *
+   * Crea un campo de calificación visual con estrellas, corazones u otros íconos.
+   * Ideal para ratings, puntuaciones o evaluaciones.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param maxValue - Valor máximo (1-10, default: 5)
+   * @param color - Color del rating (default: 'yellow')
+   * @param style - Estilo del ícono (default: 'star')
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de rating creado
+   *
+   * @throws {Error} Si maxValue no está entre 1-10
+   *
+   * @example
+   * ```typescript
+   * // Rating de 5 estrellas amarillas
+   * const ratingField = await fieldService.createRatingField(123, 'calificacion')
+   *
+   * // Rating personalizado de 10 corazones rojos
+   * const loveField = await fieldService.createRatingField(123, 'amor', 10, 'red', 'heart')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createRatingField(
+    tableId: number,
+    name: string,
+    maxValue: number = 5,
+    color: RatingColor = 'yellow',
+    style: RatingStyle = 'star',
+    description?: string
+  ): Promise<Field> {
+    this.validationService.validateId(tableId, 'table ID')
+    this.validationService.validateResourceName(name, 'field')
+
+    if (maxValue < 1 || maxValue > 10) {
+      throw new Error('maxValue must be between 1 and 10')
+    }
+
+    // Validación removida - ahora usamos RatingColor enum que tiene valores válidos
+
+    return this.create(tableId, {
+      name,
+      type: 'rating',
+      max_value: maxValue,
+      color: color,
+      style: style,
+      description
+    })
+  }
+
+  /**
+   * Crear campo de última modificación (fecha)
+   *
+   * Crea un campo de auditoría que se actualiza automáticamente
+   * con la fecha de la última modificación de la fila.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de última modificación creado
+   *
+   * @example
+   * ```typescript
+   * const updatedField = await fieldService.createLastModifiedField(123, 'actualizado')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createLastModifiedField(tableId: number, name: string, description?: string): Promise<Field> {
+    return this.create(tableId, {
+      name,
+      type: 'last_modified',
+      description
+    })
+  }
+
+  /**
+   * Crear campo de última modificación por usuario
+   *
+   * Crea un campo de auditoría que se actualiza automáticamente
+   * con el usuario que realizó la última modificación de la fila.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de última modificación por usuario creado
+   *
+   * @example
+   * ```typescript
+   * const modifiedByField = await fieldService.createLastModifiedByField(123, 'modificado_por')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createLastModifiedByField(tableId: number, name: string, description?: string): Promise<Field> {
+    return this.create(tableId, {
+      name,
+      type: 'last_modified_by',
+      description
+    })
+  }
+
+  /**
+   * Crear campo de fecha de creación
+   *
+   * Crea un campo de auditoría que se establece automáticamente
+   * con la fecha de creación de la fila (no se modifica después).
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de fecha de creación creado
+   *
+   * @example
+   * ```typescript
+   * const createdField = await fieldService.createCreatedOnField(123, 'creado')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createCreatedOnField(tableId: number, name: string, description?: string): Promise<Field> {
+    return this.create(tableId, {
+      name,
+      type: 'created_on',
+      description
+    })
+  }
+
+  /**
+   * Crear campo de usuario creador
+   *
+   * Crea un campo de auditoría que se establece automáticamente
+   * con el usuario que creó la fila (no se modifica después).
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de usuario creador creado
+   *
+   * @example
+   * ```typescript
+   * const createdByField = await fieldService.createCreatedByField(123, 'creado_por')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createCreatedByField(tableId: number, name: string, description?: string): Promise<Field> {
+    return this.create(tableId, {
+      name,
+      type: 'created_by',
+      description
+    })
+  }
+
+  /**
+   * Crear campo de archivo
+   *
+   * Crea un campo para subir y almacenar archivos adjuntos.
+   * Soporta múltiples archivos por fila con previsualización automática.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de archivo creado
+   *
+   * @example
+   * ```typescript
+   * const attachmentField = await fieldService.createFileField(123, 'documentos')
+   * const photoField = await fieldService.createFileField(123, 'fotos')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createFileField(tableId: number, name: string, description?: string): Promise<Field> {
+    return this.create(tableId, {
+      name,
+      type: 'file',
+      description
+    })
+  }
+
+  /**
+   * Crear campo de numeración automática
+   *
+   * Crea un campo que asigna automáticamente números secuenciales únicos
+   * a cada nueva fila. Útil para IDs de tickets, números de orden, etc.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de numeración automática creado
+   *
+   * @example
+   * ```typescript
+   * const ticketField = await fieldService.createAutonumberField(123, 'ticket_id')
+   * const orderField = await fieldService.createAutonumberField(123, 'numero_orden')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createAutonumberField(tableId: number, name: string, description?: string): Promise<Field> {
+    return this.create(tableId, {
+      name,
+      type: 'autonumber',
+      description
+    })
+  }
+
+  /**
+   * Crear campo de conteo
+   *
+   * Crea un campo que cuenta automáticamente el número de registros
+   * relacionados a través de un campo de enlace. Se actualiza automáticamente.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param throughFieldId - ID del campo de enlace a través del cual contar
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de conteo creado
+   *
+   * @throws {BaserowValidationError} Si throughFieldId es inválido
+   *
+   * @example
+   * ```typescript
+   * // Contar número de pedidos por cliente
+   * const orderCountField = await fieldService.createCountField(
+   *   customersTableId,
+   *   'total_pedidos',
+   *   customerLinkFieldId
+   * )
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createCountField(tableId: number, name: string, throughFieldId: number, description?: string): Promise<Field> {
+    this.validationService.validateId(throughFieldId, 'through field ID')
+
+    return this.create(tableId, {
+      name,
+      type: 'count',
+      through_field_id: throughFieldId,
+      description
+    })
+  }
+
+  /**
+   * Crear campo de rollup (agregación)
+   *
+   * Crea un campo que agrega valores de registros relacionados usando
+   * funciones como sum, avg, min, max, etc. Se actualiza automáticamente.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param throughFieldId - ID del campo de enlace para la relación
+   * @param targetFieldId - ID del campo a agregar en la tabla relacionada
+   * @param rollupFunction - Función de agregación (default: 'sum')
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de rollup creado
+   *
+   * @throws {BaserowValidationError} Si los IDs son inválidos
+   *
+   * @example
+   * ```typescript
+   * // Sumar total de ventas por cliente
+   * const totalSalesField = await fieldService.createRollupField(
+   *   customersTableId,
+   *   'ventas_totales',
+   *   customerLinkFieldId,
+   *   orderAmountFieldId,
+   *   'sum'
+   * )
+   *
+   * // Calcular promedio de calificaciones
+   * const avgRatingField = await fieldService.createRollupField(
+   *   productsTableId,
+   *   'rating_promedio',
+   *   productLinkFieldId,
+   *   ratingFieldId,
+   *   'avg'
+   * )
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createRollupField(
+    tableId: number,
+    name: string,
+    throughFieldId: number,
+    targetFieldId: number,
+    rollupFunction: string = 'sum',
+    description?: string
+  ): Promise<Field> {
+    this.validationService.validateId(throughFieldId, 'through field ID')
+    this.validationService.validateId(targetFieldId, 'target field ID')
+
+    return this.create(tableId, {
+      name,
+      type: 'rollup',
+      through_field_id: throughFieldId,
+      target_field_id: targetFieldId,
+      rollup_function: rollupFunction,
+      description
+    })
+  }
+
+  /**
+   * Crear campo de lookup (búsqueda)
+   *
+   * Crea un campo que muestra valores de un campo en registros relacionados.
+   * Similar a un VLOOKUP en spreadsheets. Se actualiza automáticamente.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @param name - Nombre del campo
+   * @param throughFieldId - ID del campo de enlace para la relación
+   * @param targetFieldId - ID del campo a mostrar en la tabla relacionada
+   * @param description - Descripción del campo (opcional)
+   * @returns Promise con el campo de lookup creado
+   *
+   * @throws {BaserowValidationError} Si los IDs son inválidos
+   *
+   * @example
+   * ```typescript
+   * // Mostrar nombre del cliente en tabla de pedidos
+   * const customerNameField = await fieldService.createLookupField(
+   *   ordersTableId,
+   *   'nombre_cliente',
+   *   customerLinkFieldId,
+   *   customerNameFieldId
+   * )
+   *
+   * // Mostrar categoría del producto en pedidos
+   * const productCategoryField = await fieldService.createLookupField(
+   *   ordersTableId,
+   *   'categoria_producto',
+   *   productLinkFieldId,
+   *   categoryFieldId
+   * )
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async createLookupField(
+    tableId: number,
+    name: string,
+    throughFieldId: number,
+    targetFieldId: number,
+    description?: string
+  ): Promise<Field> {
+    this.validationService.validateId(throughFieldId, 'through field ID')
+    this.validationService.validateId(targetFieldId, 'target field ID')
+
+    return this.create(tableId, {
+      name,
+      type: 'lookup',
+      through_field_id: throughFieldId,
+      target_field_id: targetFieldId,
+      description
+    })
+  }
+
+  /**
+   * Verificar si un campo existe
+   *
+   * Verifica la existencia de un campo sin cargar todos sus metadatos.
+   * Útil para validaciones antes de operaciones.
+   *
+   * @param fieldId - ID numérico del campo
+   * @returns Promise que resuelve a true si existe, false si no
+   *
+   * @example
+   * ```typescript
+   * const exists = await fieldService.exists(456)
+   * if (exists) {
+   *   console.log('El campo existe')
+   * } else {
+   *   console.log('El campo no existe')
+   * }
+   * ```
+   *
+   * @since 1.0.0
+   */
+  async exists(fieldId: number): Promise<boolean> {
+    try {
+      await this.get(fieldId)
+      return true
+    } catch (error) {
+      if (error instanceof BaserowNotFoundError) {
+        return false
+      }
+      throw error
+    }
+  }
+
+  // ===== GESTIÓN DE ÍNDICES Y CONSTRAINTS (v1.35+) =====
+
+  /**
+   * Configurar índice en campo para mejorar performance
+   *
+   * Habilita o deshabilita el índice en un campo para acelerar
+   * las operaciones de filtrado hasta 10x más rápido.
+   *
+   * @param fieldId - ID numérico del campo
+   * @param enabled - true para habilitar índice, false para deshabilitar
+   * @returns Promise con el campo actualizado
+   *
+   * @throws {BaserowNotFoundError} Si el campo no existe
+   * @throws {BaserowValidationError} Si el fieldId es inválido
+   *
+   * @example
+   * ```typescript
+   * // Habilitar índice para mejorar filtros en campo email
+   * const field = await fieldService.setFieldIndex(emailFieldId, true)
+   * console.log(`Índice ${field.index ? 'habilitado' : 'deshabilitado'}`)
+   *
+   * // Deshabilitar índice
+   * await fieldService.setFieldIndex(fieldId, false)
+   * ```
+   *
+   * @since 1.1.0
+   */
+  async setFieldIndex(fieldId: number, enabled: boolean): Promise<Field> {
+    this.validationService.validateId(fieldId, 'field ID')
+
+    try {
+      this.logDebug(`${enabled ? 'Enabling' : 'Disabling'} index for field ${fieldId}`)
+      const response = await this.http.patch<Field>(`/database/fields/${fieldId}/`, {
+        index: enabled
+      })
+      this.logSuccess(`set field index`, fieldId, { enabled })
+      return response
+    } catch (error) {
+      if ((error as any).status === 404) {
+        throw new BaserowNotFoundError('Field', fieldId)
+      }
+      this.handleHttpError(error, 'set field index', fieldId)
+    }
+  }
+
+  /**
+   * Agregar restricción de valor a campo
+   *
+   * Agrega una nueva restricción de integridad al campo para
+   * garantizar calidad de datos (ej: valores únicos).
+   *
+   * @param fieldId - ID numérico del campo
+   * @param constraint - Configuración de la restricción
+   * @returns Promise con el campo actualizado
+   *
+   * @throws {BaserowNotFoundError} Si el campo no existe
+   * @throws {BaserowValidationError} Si los parámetros son inválidos
+   *
+   * @example
+   * ```typescript
+   * // Agregar restricción de unicidad (excluyendo vacíos)
+   * const field = await fieldService.addFieldConstraint(emailFieldId, {
+   *   type: 'unique',
+   *   active: true
+   * })
+   *
+   * // Agregar restricción de unicidad (incluyendo vacíos)
+   * await fieldService.addFieldConstraint(codeFieldId, {
+   *   type: 'unique_with_empty',
+   *   active: true
+   * })
+   * ```
+   *
+   * @since 1.1.0
+   */
+  async addFieldConstraint(fieldId: number, constraint: FieldConstraint): Promise<Field> {
+    this.validationService.validateId(fieldId, 'field ID')
+
+    if (!constraint.type || typeof constraint.active !== 'boolean') {
+      throw new BaserowValidationError('Invalid constraint configuration', {
+        constraint: ['type and active are required']
+      })
+    }
+
+    // Obtener constraints existentes
+    const currentField = await this.get(fieldId)
+    const existingConstraints = currentField.constraints || []
+
+    // Verificar si ya existe una constraint del mismo tipo
+    const existingIndex = existingConstraints.findIndex(c => c.type === constraint.type)
+    let updatedConstraints: FieldConstraint[]
+
+    if (existingIndex >= 0) {
+      // Actualizar constraint existente
+      updatedConstraints = [...existingConstraints]
+      updatedConstraints[existingIndex] = constraint
+    } else {
+      // Agregar nueva constraint
+      updatedConstraints = [...existingConstraints, constraint]
+    }
+
+    try {
+      this.logDebug(`Adding constraint ${constraint.type} to field ${fieldId}`, { constraint })
+      const response = await this.http.patch<Field>(`/database/fields/${fieldId}/`, {
+        constraints: updatedConstraints
+      })
+      this.logSuccess('add field constraint', fieldId, { type: constraint.type })
+      return response
+    } catch (error) {
+      if ((error as any).status === 404) {
+        throw new BaserowNotFoundError('Field', fieldId)
+      }
+      this.handleHttpError(error, 'add field constraint', fieldId)
+    }
+  }
+
+  /**
+   * Eliminar restricción de valor de campo
+   *
+   * Elimina una restricción específica del campo por tipo.
+   *
+   * @param fieldId - ID numérico del campo
+   * @param constraintType - Tipo de restricción a eliminar
+   * @returns Promise con el campo actualizado
+   *
+   * @throws {BaserowNotFoundError} Si el campo no existe
+   * @throws {BaserowValidationError} Si el fieldId es inválido
+   *
+   * @example
+   * ```typescript
+   * // Eliminar restricción de unicidad
+   * const field = await fieldService.removeFieldConstraint(emailFieldId, 'unique')
+   * console.log(`Constraints restantes: ${field.constraints?.length || 0}`)
+   * ```
+   *
+   * @since 1.1.0
+   */
+  async removeFieldConstraint(fieldId: number, constraintType: ConstraintType): Promise<Field> {
+    this.validationService.validateId(fieldId, 'field ID')
+
+    // Obtener constraints existentes
+    const currentField = await this.get(fieldId)
+    const existingConstraints = currentField.constraints || []
+
+    // Filtrar constraint a eliminar
+    const updatedConstraints = existingConstraints.filter(c => c.type !== constraintType)
+
+    try {
+      this.logDebug(`Removing constraint ${constraintType} from field ${fieldId}`)
+      const response = await this.http.patch<Field>(`/database/fields/${fieldId}/`, {
+        constraints: updatedConstraints
+      })
+      this.logSuccess('remove field constraint', fieldId, { type: constraintType })
+      return response
+    } catch (error) {
+      if ((error as any).status === 404) {
+        throw new BaserowNotFoundError('Field', fieldId)
+      }
+      this.handleHttpError(error, 'remove field constraint', fieldId)
+    }
+  }
+
+  /**
+   * Obtener restricciones de campo
+   *
+   * Recupera todas las restricciones activas de un campo específico.
+   *
+   * @param fieldId - ID numérico del campo
+   * @returns Promise con array de restricciones del campo
+   *
+   * @throws {BaserowNotFoundError} Si el campo no existe
+   * @throws {BaserowValidationError} Si el fieldId es inválido
+   *
+   * @example
+   * ```typescript
+   * const constraints = await fieldService.getFieldConstraints(emailFieldId)
+   * constraints.forEach(constraint => {
+   *   console.log(`Constraint ${constraint.type}: ${constraint.active ? 'activa' : 'inactiva'}`)
+   * })
+   * ```
+   *
+   * @since 1.1.0
+   */
+  async getFieldConstraints(fieldId: number): Promise<FieldConstraint[]> {
+    this.validationService.validateId(fieldId, 'field ID')
+
+    const field = await this.get(fieldId)
+    return field.constraints || []
+  }
+
+  /**
+   * Eliminar todas las restricciones de un campo
+   *
+   * Remueve completamente todas las constraints configuradas en un campo específico,
+   * dejándolo sin ninguna restricción de integridad. Esta operación es útil para
+   * limpiar campos que han acumulado múltiples constraints o para resetear
+   * la configuración de restricciones.
+   *
+   * @param fieldId - ID del campo del cual eliminar todas las constraints
+   * @returns Promise con el campo actualizado sin constraints
+   *
+   * @throws {BaserowValidationError} Si fieldId es inválido
+   * @throws {BaserowNotFoundError} Si el campo no existe
+   * @throws {BaserowError} Si hay error en la comunicación con la API
+   *
+   * @example
+   * ```typescript
+   * // Eliminar todas las constraints de un campo
+   * const field = await fieldService.removeAllFieldConstraints(emailFieldId)
+   * console.log(`Campo "${field.name}" ahora sin constraints`)
+   *
+   * // Verificar que se eliminaron todas
+   * const remainingConstraints = await fieldService.getFieldConstraints(emailFieldId)
+   * console.log(`Constraints restantes: ${remainingConstraints.length}`) // 0
+   * ```
+   *
+   * @since 1.1.0
+   */
+  async removeAllFieldConstraints(fieldId: number): Promise<Field> {
+    this.validationService.validateId(fieldId, 'field ID')
+
+    try {
+      this.logDebug(`Removing all constraints from field ${fieldId}`)
+
+      const updatedField = await this.updateFieldInternal(fieldId, {
+        constraints: []
+      })
+
+      this.logSuccess('remove all field constraints', fieldId, { removedAll: true })
+      return updatedField
+    } catch (error) {
+      this.handleHttpError(error, 'remove all field constraints', fieldId)
+      throw error
+    }
+  }
+
+  /**
+   * Aplicar opciones avanzadas a solicitud de creación de campo
+   *
+   * Método helper interno que aplica índices y constraints a la configuración
+   * de creación de campo.
+   *
+   * @param baseRequest - Solicitud base de creación
+   * @param advancedOptions - Opciones avanzadas (índice y constraints)
+   * @returns Solicitud enriquecida con opciones avanzadas
+   *
+   * @private
+   * @since 1.1.0
+   */
+  private applyAdvancedOptions(
+    baseRequest: CreateFieldRequest,
+    advancedOptions?: FieldAdvancedOptions
+  ): CreateFieldRequest {
+    if (!advancedOptions) return baseRequest
+
+    const enrichedRequest = { ...baseRequest }
+
+    if (advancedOptions.index !== undefined) {
+      enrichedRequest.index = advancedOptions.index
+    }
+
+    if (advancedOptions.constraints && advancedOptions.constraints.length > 0) {
+      enrichedRequest.constraints = advancedOptions.constraints
+    }
+
+    return enrichedRequest
+  }
+
+  // ===== FRIEND ACCESS PATTERN FOR FIELD CONTEXT =====
+  // Symbol-based access que no aparece en la API pública pero permite acceso interno
+
+  /**
+   * Friend access para FieldContext
+   * No aparece en intellisense normal ni en la API pública
+   * @internal
+   */
+  get [Symbol.for('fieldContext')]() {
+    return {
+      createField: this.createFieldInternal.bind(this),
+      updateField: this.updateFieldInternal.bind(this),
+      deleteField: this.deleteFieldInternal.bind(this)
+    }
+  }
+}