@gzl10/baserow 1.2.0

package/src/ClientWithToken.ts

@@ -0,0 +1,171 @@
+import { BaserowConfig, TableFromAllTables } from './types'
+import { createHttpClient } from './utils/httpFactory'
+import { validateConfig } from './utils/validation'
+import { PerformanceManager } from './utils/performance'
+import { TableService } from './services/TableService'
+import { FieldService } from './services/FieldService'
+import { RowService } from './services/RowService'
+import { TableOnlyContext } from './contexts/TableOnlyContext'
+import { BaseClient } from './services/core/BaseClient'
+
+/**
+ * Cliente interno para operaciones CRUD de datos con Database Token
+ *
+ * ⚠️ **USO INTERNO**: Esta clase no debe usarse directamente.
+ * Usar `BaserowClient.create()` en su lugar.
+ *
+ * Proporciona acceso de solo lectura/escritura a datos de Baserow sin capacidades administrativas.
+ * Ideal para aplicaciones cliente que necesitan acceder a datos específicos de una base de datos.
+ *
+ * **Características:**
+ * - Autenticación mediante Database Token (no requiere credenciales de usuario)
+ * - API directa: `client.tables.findMany()` y `client.table(id).rows.list()`
+ * - Solo operaciones de datos: CRUD de filas, lectura de esquemas
+ * - Sin capacidades administrativas: no puede crear/modificar estructura
+ * - Rate limiting automático y retry logic integrado
+ *
+ * @internal
+ * @since 1.0.0
+ */
+export class ClientWithToken extends BaseClient<BaserowConfig> {
+  // Servicios para operaciones directas de tablas
+  private tableService: TableService
+  private fieldService: FieldService
+  private rowService: RowService
+
+  // API pública de tables (acceso directo para Database Token)
+  public tables: {
+    findMany(): Promise<TableFromAllTables[]>
+    findUnique(id: number): Promise<TableFromAllTables | null>
+  }
+
+  /**
+   * Crear una nueva instancia de ClientWithToken
+   *
+   * ⚠️ **USO INTERNO**: Usar `BaserowClient.create()` en su lugar.
+   *
+   * @param config - Configuración del cliente
+   * @param config.url - URL del servidor Baserow
+   * @param config.token - Database Token para autenticación
+   * @param config.logger - Logger opcional para debugging
+   *
+   * @example
+   * ```typescript
+   * // ❌ No usar directamente
+   * const client = new ClientWithToken(config)
+   *
+   * // ✅ Usar la API unificada
+   * const client = await BaserowClient.create({
+   *   url: 'https://baserow.example.com',
+   *   token: process.env.BASEROW_DB_TOKEN
+   * })
+   *
+   * // Nueva API simplificada para Database Tokens
+   * const tables = await client.tables.findMany()
+   * const rows = await client.table(123).rows.findMany()
+   * ```
+   *
+   * @internal
+   * @since 1.0.0
+   */
+  constructor(config: BaserowConfig) {
+    validateConfig(config)
+
+    // Procesar performance con defaults antes de guardar
+    const processedConfig = {
+      ...config,
+      performance: PerformanceManager.merge(config.performance)
+    }
+
+    const http = createHttpClient({
+      url: processedConfig.url,
+      token: processedConfig.token,
+      logger: processedConfig.logger,
+      performance: processedConfig.performance
+    })
+
+    super(processedConfig, http, processedConfig.logger)
+
+    // Inicializar servicios para operaciones directas de tablas
+    this.tableService = new TableService(this.http, this.logger)
+    this.fieldService = new FieldService(this.http, this.logger)
+    this.rowService = new RowService(this.http, this.logger)
+
+    // Inicializar API de tables (acceso directo para Database Token)
+    this.tables = {
+      /**
+       * Listar todas las tablas accesibles por el Database Token
+       * Usa el endpoint /database/tables/all-tables/ específico para tokens
+       */
+      findMany: async (): Promise<TableFromAllTables[]> => {
+        return await this.tableService.findAllTablesWithToken()
+      },
+
+      /**
+       * Buscar tabla específica por ID
+       * Busca en las tablas accesibles al Database Token
+       */
+      findUnique: async (id: number): Promise<TableFromAllTables | null> => {
+        const tables = await this.tableService.findAllTablesWithToken()
+        return tables.find(table => table.id === id) || null
+      }
+    }
+  }
+
+  /**
+   * Campos que deben excluirse por defecto para cliente con token
+   * Para ClientWithToken no hay campos sensibles a excluir
+   */
+  protected getDefaultExcludeKeys(): string[] {
+    return []
+  }
+
+  /**
+   * Acceder a una tabla específica (API directa)
+   *
+   * Crea un contexto de tabla que permite operaciones en filas y campos.
+   * El Database Token debe tener permisos para la tabla especificada.
+   *
+   * @param tableId - ID numérico de la tabla
+   * @returns Contexto de tabla con acceso a filas y campos
+   *
+   * @example
+   * ```typescript
+   * // Acceso directo a operaciones de tabla
+   * const table = await client.table(456).get()
+   * const rows = await client.table(456).rows.findMany()
+   * const newRow = await client.table(456).rows.createMany([{
+   *   name: 'John',
+   *   active: true
+   * }])
+   *
+   * // Acceso a información de campos
+   * const fields = await client.table(456).fields.findMany()
+   * ```
+   *
+   * @since 1.0.0
+   */
+  table(tableId: number): TableOnlyContext {
+    return new TableOnlyContext(tableId, this.tableService, this.fieldService, this.rowService, this.logger)
+  }
+
+  /**
+   * Obtener la configuración actual del cliente
+   *
+   * Retorna una copia de solo lectura de la configuración para prevenir modificaciones accidentales.
+   *
+   * @returns Configuración actual del cliente (solo lectura)
+   *
+   * @example
+   * ```typescript
+   * const config = client.getConfig()
+   * console.log('URL servidor:', config.url)
+   * console.log('Token:', config.token.substring(0, 10) + '...')
+   * ```
+   *
+   * @since 1.0.0
+   */
+  getConfig(): Readonly<BaserowConfig> {
+    return this.getConfigBase()
+  }
+}

package/src/contexts/DatabaseClientContext.ts

@@ -0,0 +1,114 @@
+import { Logger, Database } from '../types'
+import { TableClientContext } from './TableClientContext'
+import { DatabaseService } from '../services/DatabaseService'
+import { TableService } from '../services/TableService'
+import { FieldService } from '../services/FieldService'
+import { RowService } from '../services/RowService'
+
+/**
+ * Context para operaciones en una base de datos específica con BaserowClient
+ * Proporciona API jerárquica para Database Token operations
+ */
+export class DatabaseClientContext {
+  private databaseId: number
+  private resolvedDatabase?: Database
+  private logger?: Logger
+
+  constructor(
+    databaseId: number,
+    private databaseService: DatabaseService,
+    private tableService: TableService,
+    private fieldService: FieldService,
+    private rowService: RowService,
+    logger?: Logger
+  ) {
+    this.databaseId = databaseId
+    this.logger = logger
+  }
+
+  /**
+   * Acceder a una tabla específica en esta database
+   */
+  table(tableId: number): TableClientContext {
+    return new TableClientContext(
+      this.databaseId,
+      tableId,
+      this.tableService,
+      this.fieldService,
+      this.rowService,
+      this.logger
+    )
+  }
+
+  /**
+   * Operaciones de tables en esta database
+   */
+  get tables() {
+    return {
+      /**
+       * Listar todas las tables de la database
+       */
+      findMany: async () => {
+        return await this.tableService.findMany(this.databaseId)
+      },
+
+      /**
+       * Buscar table por nombre en esta database
+       */
+      findUnique: async (name: string) => {
+        return await this.tableService.findUnique(this.databaseId, name)
+      }
+    }
+  }
+
+  /**
+   * Obtener información de la database (lazy loading)
+   */
+  async get(): Promise<Database> {
+    if (this.resolvedDatabase) {
+      return this.resolvedDatabase
+    }
+
+    const database = await this.databaseService.findUnique(this.databaseId)
+    if (!database) {
+      throw new Error(`Database with ID ${this.databaseId} not found`)
+    }
+    this.resolvedDatabase = database
+
+    if (this.logger) {
+      this.logger.debug?.(`Resolved database: "${this.resolvedDatabase.name}" (ID: ${this.resolvedDatabase.id})`)
+    }
+
+    return this.resolvedDatabase
+  }
+
+  /**
+   * Verificar si la 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
+   * ```typescript
+   * const exists = await client.database(123).exists()
+   * if (exists) {
+   *   const database = await client.database(123).get()
+   *   console.log(`Database: ${database.name}`)
+   * } else {
+   *   console.log('Database no encontrada')
+   * }
+   * ```
+   *
+   * @since 1.1.0
+   */
+  async exists(): Promise<boolean> {
+    try {
+      await this.get()
+      return true
+    } catch {
+      return false
+    }
+  }
+}