@pineliner/odb-client 1.0.0 → 1.0.2

package/dist/service/service-client.d.ts

@@ -86,10 +86,10 @@ export declare class ServiceClient {
      * Create a new database
      *
      * @param name - Database name (should be unique)
-     * @param nodeId - ID of the node to host the database
+     * @param nodeId - ID of the node to host the database (optional - server will select if null)
      * @returns Created database object with hash
      */
-    createDatabase(name: string, nodeId: string): Promise<ODBLiteDatabase>;
+    createDatabase(name: string, nodeId?: string | null): Promise<ODBLiteDatabase>;
     /**
      * Get database details by hash
      *
@@ -97,6 +97,13 @@ export declare class ServiceClient {
      * @returns Database object
      */
     getDatabase(hash: string): Promise<ODBLiteDatabase>;
+    /**
+     * Get database details by name
+     *
+     * @param name - Database name
+     * @returns Database object or null if not found
+     */
+    getDatabaseByName(name: string): Promise<ODBLiteDatabase | null>;
     /**
      * Delete a database
      *

package/dist/service/service-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-client.d.ts","sourceRoot":"","sources":["../../src/service/service-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,aAAa,CAAsB;gBAE/B,MAAM,EAAE,mBAAmB;IAMvC;;;;;;;;;;;;;;;;;;OAkBG;IACG,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAkDhF;;;;;;OAMG;IACG,aAAa,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAejD;;;;;;OAMG;IACG,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAkB5E;;;;;OAKG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAezD;;;;OAIG;IACG,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBjD;;;;OAIG;IACG,SAAS,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAezC;;;;;;;;;;;OAWG;IACG,KAAK,CAAC,CAAC,GAAG,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,GAAG,EAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IAkBvF;;;;OAIG;IACH,UAAU,IAAI,IAAI;IAIlB;;;;;;OAMG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKnE;;;;;;;;;OASG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CAIpE"}
+{"version":3,"file":"service-client.d.ts","sourceRoot":"","sources":["../../src/service/service-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,aAAa,CAAsB;gBAE/B,MAAM,EAAE,mBAAmB;IAMvC;;;;;;;;;;;;;;;;;;OAkBG;IACG,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAiDhF;;;;;;OAMG;IACG,aAAa,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAejD;;;;;;OAMG;IACG,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,eAAe,CAAC;IAuBpF;;;;;OAKG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAezD;;;;;OAKG;IACG,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAmBtE;;;;OAIG;IACG,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBjD;;;;OAIG;IACG,SAAS,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAezC;;;;;;;;;;;OAWG;IACG,KAAK,CAAC,CAAC,GAAG,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,GAAG,EAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IAkBvF;;;;OAIG;IACH,UAAU,IAAI,IAAI;IAIlB;;;;;;OAMG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKnE;;;;;;;;;OASG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CAIpE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pineliner/odb-client",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Isomorphic client for ODB-Lite with postgres.js-like template string SQL support",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -14,11 +14,12 @@
     "deploy": "bun run build && npm publish --access public"
   },
   "dependencies": {
-    "@libsql/client": "^0.15.15"
+    "@libsql/client": "^0.15.15",
+    "node-sql-parser": "^5.3.12"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "@rslib/core": "^0.0.14",
+    "@rslib/core": "0.15.0",
     "typescript": "^5.9.2"
   },
   "exports": {

package/src/database/adapters/bun-sqlite.ts

@@ -0,0 +1,170 @@
+import { Database } from 'bun:sqlite'
+import type {
+  DatabaseAdapter,
+  Connection,
+  QueryResult,
+  PreparedStatement,
+  BunSQLiteConfig,
+} from '../types'
+
+/**
+ * Bun SQLite adapter for DatabaseManager
+ * Wraps bun:sqlite with Connection interface
+ */
+export class BunSQLiteAdapter implements DatabaseAdapter {
+  readonly type = 'bun-sqlite' as const
+  private config: BunSQLiteConfig
+
+  constructor(config: BunSQLiteConfig) {
+    this.config = config
+  }
+
+  async connect(config: BunSQLiteConfig): Promise<Connection> {
+    const db = new Database(config.databasePath, {
+      readonly: config.readonly,
+      create: config.create ?? true,
+    })
+
+    return new BunSQLiteConnection(db)
+  }
+
+  async disconnect(tenantId?: string): Promise<void> {
+    // bun:sqlite doesn't require explicit disconnection
+    // File handles are cleaned up by GC
+  }
+
+  async isHealthy(): Promise<boolean> {
+    try {
+      const db = new Database(this.config.databasePath, {
+        readonly: true,
+        create: false,
+      })
+      db.query('SELECT 1').get()
+      db.close()
+      return true
+    } catch {
+      return false
+    }
+  }
+}
+
+/**
+ * Connection implementation for Bun SQLite
+ */
+class BunSQLiteConnection implements Connection {
+  private db: Database
+  private inTransaction = false
+
+  constructor(db: Database) {
+    this.db = db
+  }
+
+  /**
+   * Template tag query (postgres.js-like)
+   */
+  async query<T = any>(
+    strings: TemplateStringsArray,
+    ...values: any[]
+  ): Promise<QueryResult<T>> {
+    // Build SQL from template
+    const sql = strings.reduce((acc, str, i) => {
+      return acc + str + (i < values.length ? '?' : '')
+    }, '')
+
+    return this.execute(sql, values)
+  }
+
+  /**
+   * Execute SQL with parameters
+   */
+  async execute(sql: string, params: any[] = []): Promise<QueryResult> {
+    try {
+      const stmt = this.db.query(sql)
+      const isSelect = sql.trim().toUpperCase().startsWith('SELECT')
+
+      if (isSelect) {
+        const rows = stmt.all(...params)
+        return {
+          rows: rows as any[],
+          rowsAffected: 0,
+        }
+      } else {
+        const result = stmt.run(...params)
+        return {
+          rows: [],
+          rowsAffected: result.changes || 0,
+          lastInsertRowid: result.lastInsertRowid,
+        }
+      }
+    } catch (error: any) {
+      throw new Error(`SQL execution failed: ${error.message}`)
+    }
+  }
+
+  /**
+   * Prepare statement for repeated execution
+   */
+  prepare(sql: string): PreparedStatement {
+    const stmt = this.db.query(sql)
+
+    return {
+      execute: async (params: any[] = []) => {
+        const isSelect = sql.trim().toUpperCase().startsWith('SELECT')
+
+        if (isSelect) {
+          const rows = stmt.all(...params)
+          return {
+            rows: rows as any[],
+            rowsAffected: 0,
+          }
+        } else {
+          const result = stmt.run(...params)
+          return {
+            rows: [],
+            rowsAffected: result.changes || 0,
+            lastInsertRowid: result.lastInsertRowid,
+          }
+        }
+      },
+
+      all: async (params: any[] = []) => {
+        return stmt.all(...params) as any[]
+      },
+
+      get: async (params: any[] = []) => {
+        return stmt.get(...params) as any
+      },
+    }
+  }
+
+  /**
+   * Execute function in transaction
+   */
+  async transaction<T>(fn: (tx: Connection) => Promise<T>): Promise<T> {
+    if (this.inTransaction) {
+      // Nested transaction - just execute the function
+      return fn(this)
+    }
+
+    this.inTransaction = true
+
+    try {
+      await this.execute('BEGIN')
+      const result = await fn(this)
+      await this.execute('COMMIT')
+      return result
+    } catch (error) {
+      await this.execute('ROLLBACK')
+      throw error
+    } finally {
+      this.inTransaction = false
+    }
+  }
+
+  /**
+   * Close connection
+   */
+  async close(): Promise<void> {
+    this.db.close()
+  }
+}

package/src/database/adapters/libsql.ts

@@ -0,0 +1,156 @@
+import { createClient, Client, Transaction as LibSQLTransaction } from '@libsql/client'
+import type {
+  DatabaseAdapter,
+  Connection,
+  QueryResult,
+  PreparedStatement,
+  LibSQLConfig,
+} from '../types'
+
+/**
+ * LibSQL adapter for DatabaseManager
+ * Wraps @libsql/client with Connection interface
+ */
+export class LibSQLAdapter implements DatabaseAdapter {
+  readonly type = 'libsql' as const
+  private config: LibSQLConfig
+
+  constructor(config: LibSQLConfig) {
+    this.config = config
+  }
+
+  async connect(config: LibSQLConfig): Promise<Connection> {
+    const client = createClient({
+      url: config.url,
+      authToken: config.authToken,
+      encryptionKey: config.encryptionKey,
+    })
+
+    return new LibSQLConnection(client)
+  }
+
+  async disconnect(tenantId?: string): Promise<void> {
+    // LibSQL clients don't require explicit disconnection
+    // Connections are pooled internally
+  }
+
+  async isHealthy(): Promise<boolean> {
+    try {
+      const client = createClient({
+        url: this.config.url,
+        authToken: this.config.authToken,
+      })
+      await client.execute('SELECT 1')
+      return true
+    } catch {
+      return false
+    }
+  }
+}
+
+/**
+ * Connection implementation for LibSQL
+ */
+class LibSQLConnection implements Connection {
+  private client: Client
+  private txClient?: LibSQLTransaction
+
+  constructor(client: Client) {
+    this.client = client
+  }
+
+  /**
+   * Template tag query (postgres.js-like)
+   */
+  async query<T = any>(
+    strings: TemplateStringsArray,
+    ...values: any[]
+  ): Promise<QueryResult<T>> {
+    // Build SQL from template
+    const sql = strings.reduce((acc, str, i) => {
+      return acc + str + (i < values.length ? '?' : '')
+    }, '')
+
+    return this.execute(sql, values)
+  }
+
+  /**
+   * Execute SQL with parameters
+   * Supports both formats: execute(sql, params) and execute({sql, args})
+   */
+  async execute(sql: string | { sql: string; args?: any[] }, params: any[] = []): Promise<QueryResult> {
+    try {
+      const target = this.txClient || this.client
+
+      // Support both execute(sql, params) and execute({sql, args}) formats
+      let query: { sql: string; args: any[] }
+      if (typeof sql === 'string') {
+        query = { sql, args: params }
+      } else {
+        query = { sql: sql.sql, args: sql.args || [] }
+      }
+
+      const result = await target.execute(query)
+
+      return {
+        rows: result.rows as any[],
+        rowsAffected: Number(result.rowsAffected),
+        lastInsertRowid: result.lastInsertRowid
+          ? BigInt(result.lastInsertRowid.toString())
+          : undefined,
+      }
+    } catch (error: any) {
+      throw new Error(`SQL execution failed: ${error.message}`)
+    }
+  }
+
+  /**
+   * Prepare statement for repeated execution
+   */
+  prepare(sql: string): PreparedStatement {
+    return {
+      execute: async (params: any[] = []) => {
+        return this.execute(sql, params)
+      },
+
+      all: async (params: any[] = []) => {
+        const result = await this.execute(sql, params)
+        return result.rows
+      },
+
+      get: async (params: any[] = []) => {
+        const result = await this.execute(sql, params)
+        return result.rows[0] || null
+      },
+    }
+  }
+
+  /**
+   * Execute function in transaction
+   */
+  async transaction<T>(fn: (tx: Connection) => Promise<T>): Promise<T> {
+    if (this.txClient) {
+      // Nested transaction - just execute the function
+      return fn(this)
+    }
+
+    // Use manual BEGIN/COMMIT/ROLLBACK for simplicity
+    try {
+      await this.execute('BEGIN')
+      const result = await fn(this)
+      await this.execute('COMMIT')
+      return result
+    } catch (error) {
+      await this.execute('ROLLBACK')
+      throw error
+    }
+  }
+
+  /**
+   * Close connection
+   */
+  async close(): Promise<void> {
+    // LibSQL client.close() if available in future versions
+    // For now, connections are managed by the client pool
+  }
+}

package/src/database/adapters/odblite.ts

@@ -0,0 +1,181 @@
+import { ServiceClient } from '../../service/service-client'
+import { ODBLiteClient } from '../../core/client'
+import type {
+  DatabaseAdapter,
+  Connection,
+  QueryResult,
+  PreparedStatement,
+  ODBLiteConfig,
+} from '../types'
+
+/**
+ * ODB-Lite adapter for DatabaseManager
+ * Wraps ServiceClient and ODBLiteClient with Connection interface
+ */
+export class ODBLiteAdapter implements DatabaseAdapter {
+  readonly type = 'odblite' as const
+  private config: ODBLiteConfig
+  private serviceClient: ServiceClient
+
+  constructor(config: ODBLiteConfig) {
+    this.config = config
+    this.serviceClient = new ServiceClient({
+      baseUrl: config.serviceUrl,
+      apiKey: config.apiKey,
+    })
+  }
+
+  async connect(config: any): Promise<Connection> {
+    const databaseName = config.databaseName || 'default'
+
+    // Ensure database exists
+    const dbInfo = await this.serviceClient.getDatabaseByName(databaseName)
+
+    if (!dbInfo) {
+      // Create database - pass nodeId from config if provided, otherwise server selects
+      await this.serviceClient.createDatabase(databaseName, this.config.nodeId)
+    }
+
+    // Get fresh database info
+    const db = await this.serviceClient.getDatabaseByName(databaseName)
+    if (!db) {
+      throw new Error(`Database ${databaseName} not found after creation`)
+    }
+
+    // Create ODBLiteClient for this database
+    const client = new ODBLiteClient({
+      baseUrl: this.config.serviceUrl,
+      apiKey: this.config.apiKey,
+      databaseId: db.hash,
+    })
+
+    return new ODBLiteConnection(client, this.serviceClient, databaseName)
+  }
+
+  async disconnect(tenantId?: string): Promise<void> {
+    if (tenantId) {
+      const prefix = 'pipeline_tenant_' // TODO: make configurable
+      const databaseName = `${prefix}${tenantId}`
+
+      try {
+        await this.serviceClient.deleteDatabase(databaseName)
+      } catch (error: any) {
+        console.warn(`Failed to delete database ${databaseName}:`, error.message)
+      }
+    }
+  }
+
+  async isHealthy(): Promise<boolean> {
+    try {
+      await this.serviceClient.listDatabases()
+      return true
+    } catch {
+      return false
+    }
+  }
+}
+
+/**
+ * Connection implementation for ODB-Lite
+ */
+class ODBLiteConnection implements Connection {
+  private client: ODBLiteClient
+  private serviceClient: ServiceClient
+  private databaseName: string
+  private inTransaction = false
+
+  constructor(
+    client: ODBLiteClient,
+    serviceClient: ServiceClient,
+    databaseName: string
+  ) {
+    this.client = client
+    this.serviceClient = serviceClient
+    this.databaseName = databaseName
+  }
+
+  /**
+   * Template tag query (postgres.js-like)
+   */
+  async query<T = any>(
+    strings: TemplateStringsArray,
+    ...values: any[]
+  ): Promise<QueryResult<T>> {
+    // ODBLiteClient.sql is a function that returns a Promise
+    const result = await this.client.sql(strings, ...values)
+
+    return {
+      rows: result.rows as T[],
+      rowsAffected: result.rowsAffected || 0,
+    }
+  }
+
+  /**
+   * Execute SQL with parameters
+   */
+  async execute(sql: string, params: any[] = []): Promise<QueryResult> {
+    try {
+      const result = await this.client.sql.execute(sql, params)
+
+      return {
+        rows: result.rows,
+        rowsAffected: result.rowsAffected || 0,
+      }
+    } catch (error: any) {
+      throw new Error(`SQL execution failed: ${error.message}`)
+    }
+  }
+
+  /**
+   * Prepare statement for repeated execution
+   */
+  prepare(sql: string): PreparedStatement {
+    return {
+      execute: async (params: any[] = []) => {
+        return this.execute(sql, params)
+      },
+
+      all: async (params: any[] = []) => {
+        const result = await this.execute(sql, params)
+        return result.rows
+      },
+
+      get: async (params: any[] = []) => {
+        const result = await this.execute(sql, params)
+        return result.rows[0] || null
+      },
+    }
+  }
+
+  /**
+   * Execute function in transaction
+   */
+  async transaction<T>(fn: (tx: Connection) => Promise<T>): Promise<T> {
+    if (this.inTransaction) {
+      // Nested transaction - just execute the function
+      return fn(this)
+    }
+
+    this.inTransaction = true
+
+    try {
+      await this.execute('BEGIN')
+      const result = await fn(this)
+      await this.execute('COMMIT')
+      return result
+    } catch (error) {
+      await this.execute('ROLLBACK')
+      throw error
+    } finally {
+      this.inTransaction = false
+    }
+  }
+
+  /**
+   * Close connection
+   */
+  async close(): Promise<void> {
+    // ODBLiteClient connections are stateless HTTP requests
+    // No explicit close needed
+  }
+}

package/src/database/index.ts

@@ -0,0 +1,32 @@
+// Database Manager - Unified database abstraction for all systems
+export { DatabaseManager } from './manager'
+
+// SQL Parser utilities
+export { parseSQL, splitSQLStatements } from './sql-parser'
+export type { ParsedStatements, SQLParserOptions } from './sql-parser'
+
+// Backend adapters
+export { BunSQLiteAdapter } from './adapters/bun-sqlite'
+export { LibSQLAdapter } from './adapters/libsql'
+export { ODBLiteAdapter } from './adapters/odblite'
+
+// Export all types
+export type {
+  // Core types
+  TenancyMode,
+  BackendType,
+  QueryResult,
+  Connection,
+  DatabaseAdapter,
+  PreparedStatement,
+
+  // Configuration types
+  DatabaseManagerConfig,
+  MigrationConfig,
+  BunSQLiteConfig,
+  LibSQLConfig,
+  ODBLiteConfig,
+
+  // Tenant management
+  TenantInfo,
+} from './types'