@pineliner/odb-client 1.0.0

package/src/core/http-client.ts

@@ -0,0 +1,200 @@
+import type { ODBLiteConfig, ODBLiteResponse, QueryResult } from '../types.ts'
+import { ConnectionError, QueryError } from '../types.ts'
+
+/**
+ * HTTP client for communicating with ODBLite service
+ */
+export class HTTPClient {
+  private config: ODBLiteConfig
+
+  constructor(config: ODBLiteConfig) {
+    this.config = {
+      timeout: 30000,
+      retries: 3,
+      ...config
+    }
+
+    // Ensure baseUrl doesn't end with slash
+    if (typeof this.config.baseUrl === 'string') {
+      this.config.baseUrl = this.config.baseUrl.replace(/\/$/, '')
+    }
+  }
+
+  /**
+   * Execute a query against the ODBLite service
+   */
+  async query<T = any>(sql: string, params: any[] = []): Promise<QueryResult<T>> {
+    if (!this.config.databaseId) {
+      throw new ConnectionError('No database ID configured. Use setDatabase() first.')
+    }
+
+    const url = `${this.config.baseUrl}/query/${this.config.databaseId}`
+    const body = {
+      sql,
+      params
+    }
+
+    try {
+      const response = await this.makeRequest(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify(body)
+      })
+
+      const data: ODBLiteResponse<T> = await response.json()
+
+      if (!data.success) {
+        throw new QueryError(data.error || 'Query failed', sql, params)
+      }
+
+      // Handle nested data structure: { success: true, data: { rows: [...] } }
+      let rows: T[] = []
+      if (data.data && typeof data.data === 'object' && 'rows' in data.data) {
+        rows = (data.data as any).rows
+      } else if (Array.isArray(data.data)) {
+        rows = data.data
+      } else if (Array.isArray(data.rows)) {
+        rows = data.rows
+      }
+
+      return {
+        rows: rows,
+        rowsAffected: data.rowsAffected || (data.data as any)?.rowsAffected || 0,
+        executionTime: data.executionTime || (data.data as any)?.executionTime || 0,
+        databaseName: data.databaseName || (data.data as any)?.databaseName
+      }
+    } catch (error) {
+      if (error instanceof QueryError || error instanceof ConnectionError) {
+        throw error
+      }
+
+      throw new QueryError(error instanceof Error ? error.message : 'Unknown error occurred', sql, params, error instanceof Error ? error : undefined)
+    }
+  }
+
+  /**
+   * Check database health
+   */
+  async ping(): Promise<boolean> {
+    if (!this.config.databaseId) {
+      return false
+    }
+
+    try {
+      const url = `${this.config.baseUrl}/api/db/${this.config.databaseId}/health`
+      const response = await this.makeRequest(url, {
+        method: 'GET',
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`
+        }
+      })
+
+      const data = await response.json()
+      return data.status === 'healthy'
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Get database information
+   */
+  async getDatabaseInfo(): Promise<any> {
+    if (!this.config.databaseId) {
+      throw new ConnectionError('No database ID configured')
+    }
+
+    const url = `${this.config.baseUrl}/query/${this.config.databaseId}`
+    const response = await this.makeRequest(url, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`
+      }
+    })
+
+    const data = await response.json()
+    if (!data.success) {
+      throw new ConnectionError(data.error || 'Failed to get database info')
+    }
+
+    return data
+  }
+
+  /**
+   * Set the database ID for subsequent queries
+   */
+  setDatabase(databaseId: string): void {
+    this.config.databaseId = databaseId
+  }
+
+  /**
+   * Make HTTP request with retry logic
+   */
+  private async makeRequest(url: string, options: RequestInit): Promise<Response> {
+    let lastError: Error | undefined
+
+    for (let attempt = 1; attempt <= (this.config.retries || 3); attempt++) {
+      try {
+        const controller = new AbortController()
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout)
+
+        const response = await fetch(url, {
+          ...options,
+          signal: controller.signal
+        })
+
+        clearTimeout(timeoutId)
+
+        if (!response.ok) {
+          const errorText = await response.text()
+          let errorData
+
+          try {
+            errorData = JSON.parse(errorText)
+          } catch {
+            errorData = { error: errorText }
+          }
+
+          throw new ConnectionError(`HTTP ${response.status}: ${errorData.error || response.statusText}`)
+        }
+
+        return response
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error('Unknown error')
+
+        // Don't retry on client errors (4xx)
+        if (error instanceof ConnectionError && error.message.includes('HTTP 4')) {
+          throw error
+        }
+
+        // Wait before retry (exponential backoff)
+        if (attempt < (this.config.retries || 3)) {
+          const delay = Math.min(1000 * 2 ** (attempt - 1), 10000)
+          await new Promise((resolve) => setTimeout(resolve, delay))
+        }
+      }
+    }
+
+    throw new ConnectionError(`Failed after ${this.config.retries} attempts: ${lastError?.message}`, lastError)
+  }
+
+  /**
+   * Create a new HTTPClient with updated config
+   */
+  configure(updates: Partial<ODBLiteConfig>): HTTPClient {
+    return new HTTPClient({
+      ...this.config,
+      ...updates
+    })
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig(): Readonly<ODBLiteConfig> {
+    return { ...this.config }
+  }
+}

package/src/core/sql-parser.ts

@@ -0,0 +1,330 @@
+import type { SQLFragment, PreparedQuery, QueryParameter } from '../types.ts';
+
+/**
+ * SQL template string parser that converts postgres.js-style template strings
+ * into LibSQL-compatible parameterized queries
+ */
+export class SQLParser {
+  /**
+   * Parse input that can be template strings, objects, or arrays
+   * Context-aware like postgres.js
+   */
+  static parse(sql: TemplateStringsArray | any, values?: any[]): PreparedQuery {
+    // Handle template string arrays (have the raw property or look like template strings)
+    if (Array.isArray(sql) && (('raw' in sql) || (typeof sql[0] === 'string' && values !== undefined))) {
+      return this.parseTemplateString(sql as unknown as TemplateStringsArray, values || []);
+    }
+
+    // Handle direct object/array inputs (context detection)
+    return this.parseContextualInput(sql, values);
+  }
+
+  /**
+   * Parse contextual input (objects, arrays, etc.)
+   * Uses heuristics to detect the intended context
+   */
+  private static parseContextualInput(input: any, values?: any[], context?: string): PreparedQuery {
+    if (Array.isArray(input)) {
+      // Check if this is an array of objects (for INSERT VALUES)
+      if (input.length > 0 && input[0] && typeof input[0] === 'object' && input[0].constructor === Object) {
+        const insertResult = this.insertValues(input);
+        return {
+          sql: insertResult.text,
+          params: insertResult.values
+        };
+      }
+
+      // Array of primitives - assume it's for IN clause
+      const placeholders = input.map(() => '?').join(', ');
+      return {
+        sql: `(${placeholders})`,
+        params: input.map(v => this.convertValue(v))
+      };
+    }
+
+    if (input && typeof input === 'object' && input.constructor === Object) {
+      // Plain object - try to detect context based on structure and usage patterns
+      const entries = Object.entries(input).filter(([, value]) => value !== undefined);
+
+      if (entries.length === 0) {
+        return { sql: '', params: [] };
+      }
+
+      // Analyze the object structure to determine intent
+      const hasNullValues = entries.some(([, value]) => value === null);
+      const hasArrayValues = entries.some(([, value]) => Array.isArray(value));
+      const hasComplexValues = entries.some(([, value]) =>
+        value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value)
+      );
+
+      // Strong indicators for WHERE clauses:
+      // - null values (for IS NULL checks)
+      // - array values (for IN clauses)
+      // - complex nested objects
+      if (hasNullValues || hasArrayValues || hasComplexValues) {
+        const whereResult = this.where(input);
+        return {
+          sql: whereResult.text,
+          params: whereResult.values
+        };
+      }
+
+      // For simple objects with primitive values, we need to guess context
+      // This is inherently ambiguous - could be SET or VALUES
+      // We'll default to a flexible format that works for both
+
+      // If single object, more likely to be SET clause
+      if (entries.length <= 3 && !Array.isArray(input)) {
+        // Return SET format by default
+        return this.buildSetClause(input);
+      }
+
+      // For larger objects or arrays of objects, likely INSERT VALUES
+      const insertResult = this.insertValues(input);
+      return {
+        sql: insertResult.text,
+        params: insertResult.values
+      };
+    }
+
+    // Fallback for other types
+    return {
+      sql: '?',
+      params: [this.convertValue(input)]
+    };
+  }
+
+  /**
+   * Build a SET clause for UPDATE statements
+   */
+  private static buildSetClause(data: Record<string, any>): PreparedQuery {
+    const entries = Object.entries(data).filter(([, value]) => value !== undefined);
+
+    if (entries.length === 0) {
+      return { sql: '', params: [] };
+    }
+
+    const setClauses = entries.map(([key]) => `${this.escapeIdentifier(key)} = ?`).join(', ');
+    const values = entries.map(([, value]) => this.convertValue(value));
+
+    return {
+      sql: setClauses,
+      params: values
+    };
+  }
+
+  /**
+   * Parse template string SQL into LibSQL format
+   */
+  private static parseTemplateString(sql: TemplateStringsArray, values: any[]): PreparedQuery {
+    const fragments: string[] = [...sql];
+    const params: any[] = [];
+
+    let query = '';
+    let paramIndex = 1;
+
+    for (let i = 0; i < fragments.length; i++) {
+      query += fragments[i];
+
+      if (i < values.length) {
+        const value = values[i];
+
+        // Handle different value types using context detection
+        if (Array.isArray(value)) {
+          // Handle IN clauses: sql`SELECT * FROM users WHERE id IN ${[1, 2, 3]}`
+          const placeholders = value.map(() => `?`).join(', ');
+          query += `(${placeholders})`;
+          params.push(...value.map(v => this.convertValue(v)));
+        } else if (value && typeof value === 'object' && value.constructor === Object) {
+          // Use context detection for objects
+          const contextResult = this.parseContextualInput(value);
+          query += contextResult.sql;
+          params.push(...contextResult.params);
+        } else if (typeof value === 'string' && value.startsWith('__RAW__')) {
+          // Handle raw SQL: sql`SELECT * FROM ${raw('users')}`
+          query += value.slice(7); // Remove __RAW__ prefix
+        } else {
+          // Regular parameter
+          query += '?';
+          params.push(this.convertValue(value));
+        }
+      }
+    }
+
+    return {
+      sql: query.trim(),
+      params
+    };
+  }
+
+  /**
+   * Create a raw SQL fragment (not parameterized)
+   */
+  static raw(text: string): string {
+    return `__RAW__${text}`;
+  }
+
+  /**
+   * Create an identifier (table name, column name, etc.)
+   */
+  static identifier(name: string): string {
+    return this.escapeIdentifier(name);
+  }
+
+  /**
+   * Escape SQL identifiers (table names, column names)
+   */
+  private static escapeIdentifier(identifier: string): string {
+    // SQLite uses double quotes for identifiers
+    return `"${identifier.replace(/"/g, '""')}"`;
+  }
+
+  /**
+   * Convert JavaScript values to LibSQL-compatible values
+   */
+  private static convertValue(value: any): any {
+    if (value === null || value === undefined) {
+      return null;
+    }
+
+    if (value instanceof Date) {
+      // Convert Date to ISO string for SQLite
+      return value.toISOString();
+    }
+
+    if (value instanceof Buffer) {
+      // Convert Buffer to Uint8Array for LibSQL
+      return new Uint8Array(value);
+    }
+
+    if (typeof value === 'boolean') {
+      // SQLite uses 0/1 for booleans
+      return value ? 1 : 0;
+    }
+
+    if (typeof value === 'bigint') {
+      // Convert BigInt to string to avoid precision loss
+      return value.toString();
+    }
+
+    if (typeof value === 'object') {
+      // Serialize objects as JSON
+      return JSON.stringify(value);
+    }
+
+    return value;
+  }
+
+  /**
+   * Create a SQL fragment for building complex queries
+   */
+  static fragment(sql: TemplateStringsArray, ...values: any[]): SQLFragment {
+    const parsed = this.parse(sql, values);
+    return {
+      text: parsed.sql,
+      values: parsed.params
+    };
+  }
+
+  /**
+   * Join multiple SQL fragments
+   */
+  static join(fragments: SQLFragment[], separator = ' '): SQLFragment {
+    const text = fragments.map(f => f.text).join(separator);
+    const values = fragments.flatMap(f => f.values);
+
+    return { text, values };
+  }
+
+  /**
+   * Helper for building WHERE clauses from objects
+   */
+  static where(conditions: Record<string, any>): SQLFragment {
+    const entries = Object.entries(conditions).filter(([, value]) => value !== undefined);
+
+    if (entries.length === 0) {
+      return { text: '', values: [] };
+    }
+
+    const clauses = entries.map(([key, value]) => {
+      if (value === null) {
+        return `${this.escapeIdentifier(key)} IS NULL`;
+      }
+      if (Array.isArray(value)) {
+        const placeholders = value.map(() => '?').join(', ');
+        return `${this.escapeIdentifier(key)} IN (${placeholders})`;
+      }
+      return `${this.escapeIdentifier(key)} = ?`;
+    });
+
+    const values = entries.flatMap(([, value]) => {
+      if (value === null) return [];
+      if (Array.isArray(value)) return value.map(v => this.convertValue(v));
+      return [this.convertValue(value)];
+    });
+
+    return {
+      text: clauses.join(' AND '),
+      values
+    };
+  }
+
+  /**
+   * Helper for building INSERT VALUES from objects
+   */
+  static insertValues(data: Record<string, any> | Record<string, any>[]): SQLFragment {
+    const records = Array.isArray(data) ? data : [data];
+
+    if (records.length === 0) {
+      throw new Error('No data provided for insert');
+    }
+
+    const keys = Object.keys(records[0]);
+    const columns = keys.map(key => this.escapeIdentifier(key)).join(', ');
+
+    const valueClauses = records.map(record => {
+      const placeholders = keys.map(() => '?').join(', ');
+      return `(${placeholders})`;
+    }).join(', ');
+
+    const values = records.flatMap(record =>
+      keys.map(key => this.convertValue(record[key]))
+    );
+
+    return {
+      text: `(${columns}) VALUES ${valueClauses}`,
+      values
+    };
+  }
+
+  /**
+   * Helper for building UPDATE SET clauses from objects
+   */
+  static updateSet(data: Record<string, any>): SQLFragment {
+    const entries = Object.entries(data).filter(([, value]) => value !== undefined);
+
+    if (entries.length === 0) {
+      throw new Error('No data provided for update');
+    }
+
+    const setClauses = entries.map(([key]) => `${this.escapeIdentifier(key)} = ?`).join(', ');
+    const values = entries.map(([, value]) => this.convertValue(value));
+
+    return {
+      text: setClauses,
+      values
+    };
+  }
+}
+
+// Export convenience functions
+export const sql = SQLParser.parse.bind(SQLParser);
+export const raw = SQLParser.raw.bind(SQLParser);
+export const identifier = SQLParser.identifier.bind(SQLParser);
+export const fragment = SQLParser.fragment.bind(SQLParser);
+export const join = SQLParser.join.bind(SQLParser);
+export const where = SQLParser.where.bind(SQLParser);
+export const insertValues = SQLParser.insertValues.bind(SQLParser);
+export const updateSet = SQLParser.updateSet.bind(SQLParser);