import { FlightSqlClient } from "@qualithm/arrow-flight-sql-js"

// Create a client
const client = new FlightSqlClient({
  host: "localhost",
  port: 31337,
  tls: true,
  auth: { type: "bearer", token: "your-bearer-token" }
})

// Connect to the server
await client.connect()

// Execute a query
const result = await client.query("SELECT * FROM my_table LIMIT 100")

// Process Arrow record batches
for await (const batch of result.stream()) {
  console.log(`Received ${batch.numRows} rows`)
  // batch is an Arrow RecordBatch
}

// Or collect all results into a table
const table = await result.collect()
console.log(`Total rows: ${table.numRows}`)

// Clean up
client.close()

import { FlightSqlPool } from "@qualithm/arrow-flight-sql-js"

// Create a pool with client and pool configuration
const pool = new FlightSqlPool(
  // Client options
  {
    host: "localhost",
    port: 31337,
    tls: false,
    auth: { type: "basic", username: "admin", password: "secret" }
  },
  // Pool options
  {
    minConnections: 2,
    maxConnections: 10,
    idleTimeoutMs: 30_000
  }
)

// Initialize the pool (creates minConnections)
await pool.initialize()

// Acquire a client from the pool
const client = await pool.acquire()
try {
  const result = await client.query("SELECT 1")
  const table = await result.collect()
  // ... process results
} finally {
  // Return to pool
  pool.release(client)
}

// Or use the convenience method (handles acquire/release automatically)
await pool.withConnection(async (client) => {
  const result = await client.query("SELECT * FROM users")
  return result.collect()
})

// Graceful shutdown
await pool.close()

import { FlightSqlClient, SubscriptionMode } from "@qualithm/arrow-flight-sql-js"

const client = new FlightSqlClient({
  host: "localhost",
  port: 31337,
  tls: true,
  auth: { type: "bearer", token: "your-bearer-token" }
})

await client.connect()

// Subscribe to real-time updates
const subscription = client.subscribe("SELECT * FROM events WHERE status = 'pending'", {
  mode: SubscriptionMode.ChangesOnly, // Full | ChangesOnly | Tail
  heartbeatMs: 30_000 // Server heartbeat interval
})

// Consume batches as they arrive
for await (const batch of subscription) {
  console.log(`Received ${batch.numRows} rows`)
}

// Or with cancellation
const controller = new AbortController()
const cancelableSubscription = client.subscribe(query, {
  signal: controller.signal,
  autoReconnect: true,
  maxReconnectAttempts: 10
})

// Later: cancel the subscription
controller.abort()

// Or manually unsubscribe
await cancelableSubscription.unsubscribe()

const exchange = client.doExchange({
  type: DescriptorType.CMD,
  cmd: new TextEncoder().encode("CUSTOM_COMMAND")
})

// Send data to server
await exchange.send({
  dataHeader: new Uint8Array(),
  dataBody: new Uint8Array(),
  appMetadata: new TextEncoder().encode(JSON.stringify({ action: "subscribe" }))
})

// Receive data from server
for await (const data of exchange) {
  console.log("Received:", data)
}

// Half-close (signal end of client stream)
await exchange.end()

import {
  FlightSqlClient,
  ConsoleMetricsHandler,
  InMemoryMetricsHandler,
  MetricNames,
  type MetricsHandler
} from "@qualithm/arrow-flight-sql-js"

// Console handler for development
const client = new FlightSqlClient({
  host: "localhost",
  port: 31337,
  tls: false,
  auth: { type: "none" },
  metrics: new ConsoleMetricsHandler()
})
// Output: [FlightSQL Metrics] ✓ query success (42ms)

// In-memory handler for testing
const metricsHandler = new InMemoryMetricsHandler()
const testClient = new FlightSqlClient({
  host: "localhost",
  port: 31337,
  tls: false,
  auth: { type: "none" },
  metrics: metricsHandler
})

// Query metrics after operations
await testClient.connect()
const result = await testClient.query("SELECT 1")
await result.collect()
console.log(metricsHandler.getAverageDuration("query"))
console.log(metricsHandler.getErrorRate("query"))
console.log(metricsHandler.getSummary())

// Custom handler for OpenTelemetry, Prometheus, etc.
class OpenTelemetryHandler implements MetricsHandler {
  recordOperation(event) {
    // Record to your tracing/metrics backend
    tracer.startSpan(event.operation).end()
    histogram.record(event.durationMs, { operation: event.operation })
  }
  recordGauge(event) {
    /* ... */
  }
  recordCounter(event) {
    /* ... */
  }
}

MetricNames.poolTotalConnections // "flight_sql.pool.total_connections"
MetricNames.poolActiveConnections // "flight_sql.pool.active_connections"
MetricNames.queriesExecuted // "flight_sql.queries.executed"
MetricNames.bytesReceived // "flight_sql.bytes.received"
MetricNames.retriesAttempted // "flight_sql.retries.attempted"

import {
  FlightSqlError, // Base error class
  ConnectionError, // Network/connection issues
  AuthenticationError, // Auth failures (401, 403)
  QueryError, // SQL syntax or execution errors
  TimeoutError, // Operation timeouts
  ProtocolError, // Protocol/encoding issues
  NotFoundError, // Resource not found
  CancelledError // Operation cancelled
} from "@qualithm/arrow-flight-sql-js"

try {
  const result = await client.query("SELECT * FROM missing_table")
  await result.collect()
} catch (error) {
  if (error instanceof QueryError) {
    console.error("SQL Error:", error.message)
    console.error("SQL State:", error.sqlState)
  } else if (error instanceof ConnectionError) {
    console.error("Connection lost, will retry...")
  } else if (error instanceof TimeoutError) {
    console.error(`Operation timed out after ${error.timeoutMs}ms`)
  }
}

import { FlightSqlClient, RetryPolicy, retryPolicies } from "@qualithm/arrow-flight-sql-js"

// Use pre-configured policies
const client = new FlightSqlClient({
  host: "localhost",
  port: 31337,
  tls: false,
  auth: { type: "bearer", token: "my-token" },
  retry: retryPolicies.default // 3 retries, exponential backoff
})

// Available policies
retryPolicies.none // No retries
retryPolicies.fast // 3 retries, 50ms initial, 500ms max
retryPolicies.default // 3 retries, 100ms initial, 10s max
retryPolicies.aggressive // 5 retries, 200ms initial, 30s max
retryPolicies.reconnection // 10 retries, 1s initial, 60s max

// Custom retry configuration
const customPolicy = new RetryPolicy({
  maxRetries: 5,
  initialDelayMs: 100,
  maxDelayMs: 5000,
  backoffMultiplier: 2,
  jitter: true, // Adds ±25% variance to prevent thundering herd
  isRetryable: (error) => {
    // Custom logic for which errors to retry
    return error.code === 14 || error.message.includes("timeout")
  }
})

const clientWithCustomRetry = new FlightSqlClient({
  host: "localhost",
  port: 31337,
  tls: false,
  auth: { type: "bearer", token: "my-token" },
  retry: customPolicy
})

// List all catalogs
const catalogs = await client.getCatalogs()
console.log("Catalogs:", catalogs)

// List schemas in a catalog
const schemas = await client.getSchemas("my_catalog", "public%")

// List tables with filtering
const tables = await client.getTables({
  catalog: "my_catalog",
  dbSchemaFilterPattern: "public",
  tableNameFilterPattern: "user%",
  tableTypes: ["TABLE", "VIEW"],
  includeSchema: true // Include Arrow schema for each table
})

// Get table types supported by the server
const tableTypes = await client.getTableTypes()
// ["TABLE", "VIEW", "SYSTEM TABLE", "TEMPORARY TABLE", ...]

// Get primary key information
const primaryKeys = await client.getPrimaryKeys("users", "my_catalog", "public")
for (const pk of primaryKeys) {
  console.log(`Column ${pk.columnName} at position ${pk.keySequence}`)
}

// Get foreign key relationships
const exportedKeys = await client.getExportedKeys("users") // Keys referencing this table
const importedKeys = await client.getImportedKeys("orders") // Keys this table references

// Create a prepared statement
const stmt = await client.prepare("SELECT * FROM users WHERE id = ? AND status = ?")

try {
  // Execute the query (returns a QueryResult)
  const result = await stmt.executeQuery()

  for await (const batch of result.stream()) {
    console.log(`Received ${batch.numRows} rows`)
  }

  // Or collect all results
  const table = await result.collect()
} finally {
  // Always close prepared statements
  await stmt.close()
}

type AuthConfig =
  | { type: "bearer"; token: string }
  | { type: "basic"; username: string; password: string }
  | { type: "none" }

// Browser or Deno
import { FlightSqlClient, createGrpcWebTransport } from "@qualithm/arrow-flight-sql-js"

// Create a gRPC-Web transport explicitly
const transport = createGrpcWebTransport({
  host: "your-grpc-web-proxy.example.com",
  port: 8080,
  tls: true
})

// Create client with custom transport
const client = new FlightSqlClient({
  host: "your-grpc-web-proxy.example.com",
  port: 8080,
  tls: true,
  transport
})

await client.connect()
const result = await client.query("SELECT * FROM my_table")