@gzl10/baserow 1.2.0

package/src/contexts/TableClientContext.ts

@@ -0,0 +1,291 @@
+import { Logger, Table, Row, PrismaLikeQueryOptions } from '../types'
+import { TableService } from '../services/TableService'
+import { FieldService } from '../services/FieldService'
+import { RowService } from '../services/RowService'
+import { PrismaBaserowMapper } from '../utils/prisma-mapper'
+import { FieldCache } from '../utils/field-cache'
+
+/**
+ * Context para operaciones en una tabla específica con BaserowClient
+ * Proporciona API jerárquica para Database Token operations a nivel table
+ */
+export class TableClientContext {
+  private databaseId: number
+  private tableId: number
+  private resolvedTable?: Table
+  private logger?: Logger
+  private fieldCache: FieldCache
+
+  constructor(
+    databaseId: number,
+    tableId: number,
+    private tableService: TableService,
+    private fieldService: FieldService,
+    private rowService: RowService,
+    logger?: Logger
+  ) {
+    this.databaseId = databaseId
+    this.tableId = tableId
+    this.logger = logger
+    this.fieldCache = new FieldCache(logger)
+  }
+
+  /**
+   * Obtener metadata completa de campos con cache
+   *
+   * @private
+   * @returns FieldMetadata con tipos y opciones select
+   */
+  private async getFieldMetadata() {
+    return await this.fieldCache.getFieldMetadata(this.fieldService, this.tableId)
+  }
+
+  /**
+   * Operaciones de rows en esta table (API Prisma-like)
+   */
+  get rows() {
+    return {
+      // === MÉTODOS ESTILO PRISMA ===
+
+      /**
+       * Buscar múltiples filas con opciones avanzadas estilo Prisma
+       *
+       * Equivalente a Prisma findMany(), proporciona filtrado avanzado,
+       * ordenamiento, paginación y selección de campos con sintaxis familiar.
+       *
+       * @param options - Opciones de consulta estilo Prisma
+       * @returns Promise con array de filas que cumplen los criterios
+       *
+       * @example
+       * ```typescript
+       * const users = await table.rows.findMany({
+       *   where: {
+       *     status: 'active',
+       *     age: { gte: 18 }
+       *   },
+       *   select: {
+       *     id: true,
+       *     name: true,
+       *     email: true
+       *   },
+       *   orderBy: { created_at: 'desc' },
+       *   take: 20
+       * })
+       * ```
+       */
+      findMany: async <T = Row>(options?: PrismaLikeQueryOptions<T>): Promise<T[]> => {
+        const fieldMetadata = await this.getFieldMetadata()
+        const baserowOptions = PrismaBaserowMapper.transformPrismaToBaserow(options, fieldMetadata)
+        const response = await this.rowService.list(this.tableId, baserowOptions)
+        return response.rows as T[]
+      },
+
+      /**
+       * Buscar TODAS las filas de la tabla con paginación automática
+       *
+       * Similar a findMany() pero sin límites de paginación. Descarga
+       * automáticamente todas las filas de la tabla aplicando los filtros
+       * especificados. Ideal para operaciones de exportación o análisis completo.
+       *
+       * @param options - Opciones de consulta (sin take/skip ya que obtiene todas)
+       * @returns Promise con TODAS las filas que cumplen los criterios
+       *
+       * @example
+       * ```typescript
+       * // Descargar tabla completa
+       * const allUsers = await client.table(123).rows.findAll()
+       *
+       * // Con filtros aplicados
+       * const allActiveUsers = await client.table(123).rows.findAll({
+       *   where: { status: 'active' },
+       *   orderBy: { created_at: 'desc' }
+       * })
+       * ```
+       *
+       * @since 1.1.0
+       */
+      findAll: async <T = Row>(options?: Omit<PrismaLikeQueryOptions<T>, 'take' | 'skip'>): Promise<T[]> => {
+        const fieldMetadata = await this.getFieldMetadata()
+        const baserowOptions = PrismaBaserowMapper.transformPrismaToBaserow(options, fieldMetadata)
+        return (await this.rowService.listAll(this.tableId, baserowOptions)) as T[]
+      },
+
+      /**
+       * Buscar la primera fila que cumpla los criterios
+       *
+       * @param options - Opciones de consulta estilo Prisma
+       * @returns Promise con la primera fila encontrada o null
+       */
+      findFirst: async <T = Row>(options?: PrismaLikeQueryOptions<T>): Promise<T | null> => {
+        const fieldMetadata = await this.getFieldMetadata()
+        const baserowOptions = PrismaBaserowMapper.transformPrismaToBaserow({ ...options, take: 1 }, fieldMetadata)
+        const response = await this.rowService.list(this.tableId, baserowOptions)
+        return response.rows.length > 0 ? (response.rows[0] as T) : null
+      },
+
+      /**
+       * Buscar fila específica por ID o criterios únicos
+       *
+       * @param idOrOptions - ID de la fila o opciones de búsqueda
+       * @returns Promise con la fila encontrada o null
+       */
+      findUnique: async <T = Row>(idOrOptions: number | PrismaLikeQueryOptions<T>): Promise<T | null> => {
+        if (typeof idOrOptions === 'number') {
+          try {
+            const row = await this.rowService.get(this.tableId, idOrOptions)
+            return row as T
+          } catch {
+            return null
+          }
+        } else {
+          const fieldMetadata = await this.getFieldMetadata()
+          const baserowOptions = PrismaBaserowMapper.transformPrismaToBaserow(
+            { ...idOrOptions, take: 1 },
+            fieldMetadata
+          )
+          const response = await this.rowService.list(this.tableId, baserowOptions)
+          return response.rows.length > 0 ? (response.rows[0] as T) : null
+        }
+      },
+
+      /**
+       * Crear una fila individual
+       *
+       * @param data - Datos para crear la fila
+       * @returns Promise con la fila creada
+       */
+      create: async <T = Row>(data: Partial<T> | Record<string, any>): Promise<T> => {
+        return (await this.rowService.createRow(this.tableId, data as Record<string, any>)) as T
+      },
+
+      /**
+       * Crear múltiples filas
+       *
+       * @param data - Array de datos para crear filas
+       * @param options - Opciones de creación
+       * @returns Promise con las filas creadas
+       */
+      createMany: async <T = Row>(data: Partial<T>[] | Record<string, any>[], options?: any): Promise<T[]> => {
+        return (await this.rowService.createBulk(this.tableId, data as Record<string, any>[], options)) as T[]
+      },
+
+      /**
+       * Actualizar múltiples filas
+       *
+       * @param updates - Array de actualizaciones con ID
+       * @param options - Opciones de actualización
+       * @returns Promise con las filas actualizadas
+       */
+      updateMany: async <T = Row>(
+        updates: Array<{ id: number } & Partial<T>> | Array<{ id: number } & Record<string, any>>,
+        options?: any
+      ): Promise<T[]> => {
+        return (await this.rowService.updateBulk(
+          this.tableId,
+          updates as Array<{ id: number } & Record<string, any>>,
+          options
+        )) as T[]
+      },
+
+      /**
+       * Eliminar múltiples filas
+       *
+       * @param ids - Array de IDs a eliminar
+       * @param options - Opciones de eliminación
+       * @returns Promise que resuelve cuando se completa
+       */
+      deleteMany: async (ids: number[], options?: any): Promise<void> => {
+        await this.rowService.deleteBulk(this.tableId, ids, options)
+      },
+
+      // === MÉTODOS ESPECÍFICOS (sin equivalente Prisma directo) ===
+
+      /**
+       * Buscar rows por texto
+       */
+      search: async (query: string, options?: any) => {
+        return await this.rowService.search(this.tableId, query, options)
+      },
+
+      /**
+       * Contar rows con filtros opcionales (sintaxis Prisma)
+       */
+      count: async (options?: { where?: Record<string, any> }): Promise<number> => {
+        const fieldMetadata = await this.getFieldMetadata()
+        const filters = PrismaBaserowMapper.transformWhereToFilters(options?.where, fieldMetadata)
+        return await this.rowService.count(this.tableId, filters)
+      },
+
+      /**
+       * Listar todas las rows de la tabla (con paginación automática)
+       */
+      listAll: async (options?: any) => {
+        return await this.rowService.listAll(this.tableId, options)
+      }
+    }
+  }
+
+  /**
+   * Acceder a una fila específica en esta table
+   */
+  row(rowId: number) {
+    return {
+      /**
+       * Obtener fila por ID
+       */
+      get: async (options?: any) => {
+        return await this.rowService.get(this.tableId, rowId, options)
+      },
+
+      /**
+       * Actualizar fila
+       */
+      update: async (data: Record<string, any>) => {
+        return await this.rowService.updateRow(this.tableId, rowId, data)
+      },
+
+      /**
+       * Eliminar fila
+       */
+      delete: async () => {
+        return await this.rowService.delete(this.tableId, rowId)
+      },
+
+      /**
+       * Verificar si fila existe
+       */
+      exists: async () => {
+        return await this.rowService.exists(this.tableId, rowId)
+      }
+    }
+  }
+
+  /**
+   * Obtener información de la table (lazy loading)
+   */
+  async get(): Promise<Table> {
+    if (this.resolvedTable) {
+      return this.resolvedTable
+    }
+
+    this.resolvedTable = await this.tableService.get(this.tableId)
+
+    if (this.logger) {
+      this.logger.debug?.(`Resolved table: "${this.resolvedTable.name}" (ID: ${this.resolvedTable.id})`)
+    }
+
+    return this.resolvedTable
+  }
+
+  /**
+   * Verificar si la table existe
+   */
+  async exists(): Promise<boolean> {
+    try {
+      await this.get()
+      return true
+    } catch {
+      return false
+    }
+  }
+}