@gzl10/baserow 1.2.0

package/src/validators/schema.ts

@@ -0,0 +1,419 @@
+/**
+ * Validadores Zod para el sistema de schemas
+ *
+ * Proporciona validación robusta de schemas antes de aplicarlos,
+ * previniendo errores y asegurando consistencia en los datos.
+ *
+ */
+
+import { z } from 'zod'
+import type {
+  DatabaseSchema,
+  TableSchema,
+  FieldSchema,
+  RelationshipSchema,
+  LoadSchemaOptions,
+  SelectOption
+} from '../types/schema'
+
+/**
+ * Colores válidos para opciones de select
+ */
+const selectOptionColors = [
+  'blue',
+  'green',
+  'red',
+  'yellow',
+  'orange',
+  'purple',
+  'pink',
+  'brown',
+  'gray',
+  'dark_blue',
+  'dark_green',
+  'dark_red',
+  'dark_yellow',
+  'dark_orange',
+  'dark_purple',
+  'dark_pink',
+  'dark_brown',
+  'dark_gray'
+] as const
+
+/**
+ * Tipos de campos válidos de Baserow
+ */
+const fieldTypes = [
+  // Texto
+  'text',
+  'long_text',
+  'url',
+  'email',
+  'phone_number',
+  // Numéricos
+  'number',
+  'rating',
+  // Fecha
+  'date',
+  'last_modified',
+  'created_on',
+  'last_modified_by',
+  'created_by',
+  // Selección
+  'single_select',
+  'multiple_select',
+  // Boolean
+  'boolean',
+  // Relación
+  'link_row',
+  'formula',
+  // Avanzados
+  'file',
+  'autonumber',
+  'count',
+  'rollup',
+  'lookup'
+] as const
+
+/**
+ * Validador para opciones de select
+ */
+export const SelectOptionValidator = z.object({
+  value: z.string().min(1, 'El valor de la opción no puede estar vacío'),
+  color: z.enum(selectOptionColors, {
+    errorMap: () => ({ message: 'Color de opción no válido' })
+  })
+}) satisfies z.ZodType<SelectOption>
+
+/**
+ * Validadores para configuraciones específicas de campos
+ */
+export const FieldConfigValidators = {
+  text: z
+    .object({
+      default: z.string().optional(),
+      placeholder: z.string().optional()
+    })
+    .optional(),
+
+  number: z
+    .object({
+      decimals: z.number().int().min(0).max(10).optional(),
+      min: z.number().optional(),
+      max: z.number().optional(),
+      default: z.number().optional(),
+      prefix: z.string().optional(),
+      suffix: z.string().optional(),
+      separators: z.enum(['COMMA_PERIOD', 'PERIOD_COMMA']).optional()
+    })
+    .optional(),
+
+  date: z
+    .object({
+      includeTime: z.boolean().optional(),
+      format: z.enum(['ISO', 'US', 'EU']).optional(),
+      timeFormat: z.enum(['24', '12']).optional(),
+      default: z.string().optional(),
+      timezone: z.string().optional()
+    })
+    .optional(),
+
+  single_select: z.object({
+    options: z.array(SelectOptionValidator).min(1, 'Debe haber al menos una opción')
+  }),
+
+  multiple_select: z.object({
+    options: z.array(SelectOptionValidator).min(1, 'Debe haber al menos una opción')
+  }),
+
+  boolean: z
+    .object({
+      default: z.boolean().optional()
+    })
+    .optional(),
+
+  link_row: z
+    .object({
+      targetTableId: z.number().int().positive().optional(),
+      targetTableName: z.string().min(1).optional()
+    })
+    .refine(data => data.targetTableId || data.targetTableName, 'Debe especificar targetTableId o targetTableName'),
+
+  formula: z.object({
+    formula: z.string().min(1, 'La fórmula no puede estar vacía')
+  }),
+
+  file: z
+    .object({
+      allowedFileTypes: z.array(z.string()).optional(),
+      maxFileSize: z.number().int().positive().optional()
+    })
+    .optional(),
+
+  count: z
+    .object({
+      targetTableId: z.number().int().positive().optional(),
+      targetTableName: z.string().min(1).optional()
+    })
+    .refine(data => data.targetTableId || data.targetTableName, 'Debe especificar targetTableId o targetTableName'),
+
+  rollup: z
+    .object({
+      targetTableId: z.number().int().positive().optional(),
+      targetTableName: z.string().min(1).optional(),
+      targetFieldId: z.number().int().positive().optional(),
+      targetFieldName: z.string().min(1).optional(),
+      aggregation: z.enum(['sum', 'avg', 'min', 'max', 'count'])
+    })
+    .refine(data => data.targetTableId || data.targetTableName, 'Debe especificar targetTableId o targetTableName')
+    .refine(data => data.targetFieldId || data.targetFieldName, 'Debe especificar targetFieldId o targetFieldName'),
+
+  lookup: z
+    .object({
+      targetTableId: z.number().int().positive().optional(),
+      targetTableName: z.string().min(1).optional(),
+      targetFieldId: z.number().int().positive().optional(),
+      targetFieldName: z.string().min(1).optional()
+    })
+    .refine(data => data.targetTableId || data.targetTableName, 'Debe especificar targetTableId o targetTableName')
+    .refine(data => data.targetFieldId || data.targetFieldName, 'Debe especificar targetFieldId o targetFieldName')
+}
+
+/**
+ * Validador dinámico para configuración de campos
+ * Valida la configuración específica según el tipo de campo
+ */
+function createFieldConfigValidator(fieldType: string) {
+  const validator = FieldConfigValidators[fieldType as keyof typeof FieldConfigValidators]
+  return validator || z.any().optional()
+}
+
+// FieldConfigValidator removido - ahora se usa createFieldConfigValidator para validación tipada
+
+/**
+ * Validador para schema de campo
+ */
+export const FieldSchemaValidator = z
+  .object({
+    name: z
+      .string()
+      .min(1, 'El nombre del campo no puede estar vacío')
+      .max(255, 'El nombre del campo no puede exceder 255 caracteres')
+      .regex(
+        /^[a-zA-Z][a-zA-Z0-9_]*$/,
+        'El nombre del campo debe empezar con letra y contener solo letras, números y guiones bajos'
+      ),
+
+    type: z.enum(fieldTypes, {
+      errorMap: () => ({ message: 'Tipo de campo no válido' })
+    }),
+
+    description: z.string().max(1000, 'La descripción no puede exceder 1000 caracteres').optional(),
+
+    config: z.any().optional()
+  })
+  .refine(
+    field => {
+      // Validar que la configuración sea apropiada para el tipo de campo usando validadores específicos
+      try {
+        if (field.config !== undefined) {
+          const specificValidator = createFieldConfigValidator(field.type)
+          specificValidator.parse(field.config)
+        }
+
+        // Verificar campos que requieren configuración obligatoria
+        const requiredConfigTypes = [
+          'single_select',
+          'multiple_select',
+          'link_row',
+          'formula',
+          'count',
+          'rollup',
+          'lookup'
+        ]
+
+        if (requiredConfigTypes.includes(field.type) && !field.config) {
+          return false
+        }
+
+        return true
+      } catch {
+        // Error de validación específica del tipo de campo
+        return false
+      }
+    },
+    {
+      message: 'La configuración no es válida para este tipo de campo'
+    }
+  ) satisfies z.ZodType<FieldSchema>
+
+/**
+ * Validador para schema de tabla
+ */
+export const TableSchemaValidator = z
+  .object({
+    name: z
+      .string()
+      .min(1, 'El nombre de la tabla no puede estar vacío')
+      .max(255, 'El nombre de la tabla no puede exceder 255 caracteres')
+      .regex(
+        /^[a-zA-Z][a-zA-Z0-9_]*$/,
+        'El nombre de la tabla debe empezar con letra y contener solo letras, números y guiones bajos'
+      ),
+
+    description: z.string().max(1000, 'La descripción no puede exceder 1000 caracteres').optional(),
+
+    fields: z
+      .array(FieldSchemaValidator)
+      .min(1, 'La tabla debe tener al menos un campo')
+      .max(200, 'La tabla no puede tener más de 200 campos')
+  })
+  .refine(
+    table => {
+      // Validar que no haya nombres de campos duplicados
+      const fieldNames = table.fields.map(f => f.name.toLowerCase())
+      const uniqueNames = new Set(fieldNames)
+      return fieldNames.length === uniqueNames.size
+    },
+    {
+      message: 'Los nombres de campos deben ser únicos dentro de la tabla'
+    }
+  ) satisfies z.ZodType<TableSchema>
+
+/**
+ * Validador para schema de relación
+ */
+export const RelationshipSchemaValidator = z
+  .object({
+    name: z
+      .string()
+      .min(1, 'El nombre de la relación no puede estar vacío')
+      .max(255, 'El nombre de la relación no puede exceder 255 caracteres')
+      .regex(
+        /^[a-zA-Z][a-zA-Z0-9_]*$/,
+        'El nombre de la relación debe empezar con letra y contener solo letras, números y guiones bajos'
+      ),
+
+    sourceTable: z.string().min(1, 'El nombre de la tabla origen no puede estar vacío'),
+
+    targetTable: z.string().min(1, 'El nombre de la tabla destino no puede estar vacío'),
+
+    description: z.string().max(1000, 'La descripción no puede exceder 1000 caracteres').optional()
+  })
+  .refine(
+    rel => {
+      // No permitir auto-relaciones por simplicidad
+      return rel.sourceTable !== rel.targetTable
+    },
+    {
+      message: 'Las auto-relaciones no están soportadas'
+    }
+  ) satisfies z.ZodType<RelationshipSchema>
+
+/**
+ * Validador para schema de base de datos completo
+ */
+export const DatabaseSchemaValidator = z
+  .object({
+    version: z.string().optional(),
+
+    description: z.string().max(1000, 'La descripción no puede exceder 1000 caracteres').optional(),
+
+    tables: z
+      .array(TableSchemaValidator)
+      .min(1, 'El schema debe contener al menos una tabla')
+      .max(100, 'El schema no puede contener más de 100 tablas'),
+
+    relationships: z.array(RelationshipSchemaValidator).optional()
+  })
+  .refine(
+    schema => {
+      // Validar que no haya nombres de tablas duplicados
+      const tableNames = schema.tables.map(t => t.name.toLowerCase())
+      const uniqueNames = new Set(tableNames)
+      return tableNames.length === uniqueNames.size
+    },
+    {
+      message: 'Los nombres de tablas deben ser únicos'
+    }
+  )
+  .refine(
+    schema => {
+      // Validar que las relaciones referencien tablas existentes
+      if (!schema.relationships) return true
+
+      const tableNames = new Set(schema.tables.map(t => t.name.toLowerCase()))
+
+      for (const rel of schema.relationships) {
+        if (!tableNames.has(rel.sourceTable.toLowerCase()) || !tableNames.has(rel.targetTable.toLowerCase())) {
+          return false
+        }
+      }
+
+      return true
+    },
+    {
+      message: 'Las relaciones deben referenciar tablas existentes en el schema'
+    }
+  ) satisfies z.ZodType<DatabaseSchema>
+
+/**
+ * Validador para opciones de carga de schema
+ */
+export const LoadSchemaOptionsValidator = z.object({
+  mode: z.enum(['create-only', 'update', 'recreate']).default('create-only'),
+  version: z.string().optional(),
+  force: z.boolean().default(false),
+  cleanup: z.boolean().default(false)
+})
+
+/**
+ * Función helper para validar un schema completo
+ */
+export function validateDatabaseSchema(schema: unknown): DatabaseSchema {
+  try {
+    return DatabaseSchemaValidator.parse(schema)
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const errorMessages = error.errors.map(err => `${err.path.join('.')}: ${err.message}`).join('\n')
+
+      throw new Error(`Schema validation failed:\n${errorMessages}`)
+    }
+    throw error
+  }
+}
+
+/**
+ * Función helper para validar opciones de carga
+ */
+export function validateLoadSchemaOptions(options: unknown): LoadSchemaOptions {
+  return LoadSchemaOptionsValidator.parse(options || {})
+}
+
+/**
+ * Función helper para obtener validador específico de configuración por tipo de campo
+ */
+export function getFieldConfigValidator(fieldType: string) {
+  return createFieldConfigValidator(fieldType)
+}
+
+/**
+ * Validador para nombres de campos y tablas seguros
+ */
+export const SafeNameValidator = z
+  .string()
+  .min(1, 'El nombre no puede estar vacío')
+  .max(255, 'El nombre no puede exceder 255 caracteres')
+  .regex(/^[a-zA-Z][a-zA-Z0-9_]*$/, 'El nombre debe empezar con letra y contener solo letras, números y guiones bajos')
+
+/**
+ * Validar si un nombre es seguro para usar en Baserow
+ */
+export function validateSafeName(name: string): boolean {
+  try {
+    SafeNameValidator.parse(name)
+    return true
+  } catch {
+    return false
+  }
+}