@rip-lang/db 1.0.1 → 1.0.2

package/db.rip

@@ -6,30 +6,38 @@
 # Fully compatible with the official DuckDB UI!
 #
 # Usage:
-#   rip db.rip <database.duckdb> [--port 4000]
-#   rip db.rip :memory: --port 4000
+#   rip db.rip <database.duckdb> [--port 4213]
+#   rip db.rip :memory: --port 4213
 #
-# Then open http://localhost:4000/ for the official DuckDB UI!
+# Then open http://localhost:4213/ for the official DuckDB UI!
 # (UI assets are proxied from ui.duckdb.org)
 #
-# Endpoints:
-#   GET  /        - Official DuckDB UI (proxied from ui.duckdb.org)
-#   POST /sql     - Execute SQL (JSON API)
-#   POST /ddb/run - DuckDB UI binary protocol
-#   GET  /health  - Health check
-#   GET  /status  - Database info
-#   GET  /tables  - List tables
-#   GET  /schema/:table - Table schema
+# Architecture:
+#   - Pure Bun FFI to DuckDB library (no npm package, no Zig)
+#   - Binary serialization in Rip for DuckDB UI protocol
+#   - Simple, clean, fast
 #
 # ==============================================================================
 
 import { get, post, read, start, use } from '@rip-lang/api'
 import { cors } from '@rip-lang/api/middleware'
-import { open, queryBinary, tokenize, emptyResult, errorResult } from './lib/duckdb.mjs'
-
-VERSION = '1.0.0'
-
-# Enable CORS for duck-ui and other clients
+import { version as VERSION } from './package.json'
+
+# Database access via pure Bun FFI
+duckdb = await import('./lib/duckdb.mjs')
+open = duckdb.open
+duckdbVersion = duckdb.version
+
+# Binary serialization for DuckDB UI protocol
+{
+  serializeSuccessResult
+  serializeErrorResult
+  serializeEmptyResult
+  serializeTokenizeResult
+  tokenizeSQL
+} = await import('./lib/duckdb-binary.rip')
+
+# Enable CORS for DuckDB UI and other clients
 use cors preflight: true
 
 # Log all requests
@@ -50,7 +58,7 @@ args = process.argv.slice(2)
 # Handle --help and --version
 if '--help' in args or '-h' in args
   console.log """
-    rip-db v#{VERSION} — DuckDB Server (Bun-native)
+    rip-db v#{VERSION} — DuckDB Server (Pure Bun FFI)
 
     Usage: rip db.rip [database] [options]
 
@@ -62,24 +70,17 @@ if '--help' in args or '-h' in args
       --help      Show this help
       --version   Show version
 
-    Environment variables (for rip-server):
-      DB_PATH     Path to DuckDB file
-      DB_PORT     Port to listen on
-
     Endpoints:
-      POST /sql         Execute SQL query or statement
-      GET  /health      Health check (always ok)
-      GET  /status      Database info and table list
-      GET  /tables      List all tables
-      GET  /schema/:t   Get schema for table t
+      GET  /           Official DuckDB UI
+      POST /sql        Execute SQL (JSON API)
+      POST /ddb/run    DuckDB UI binary protocol
+      GET  /health     Health check
+      GET  /tables     List all tables
 
     Examples:
       rip db.rip                    # In-memory database on port 4213
       rip db.rip mydb.duckdb        # File-based database
       rip db.rip :memory: --port=8080
-
-      # With rip-server (hot-reloading):
-      DB_PATH=mydb.duckdb rip-server http db.rip
   """
   process.exit(0)
 
@@ -87,283 +88,277 @@ if '--version' in args or '-v' in args
   console.log "rip-db v#{VERSION}"
   process.exit(0)
 
-# Support both env vars (for rip-server) and CLI args (for rip db.rip)
+# Database and port configuration
 path = process.env.DB_PATH or args.find((a) -> not a.startsWith('-')) or ':memory:'
-port = parseInt(process.env.DB_PORT or (args.find((a) -> a.startsWith('--port=')))?.split('=')[1]) or 4213
 
-# Open database and create persistent connection for binary queries
+# Support both --port=N and --port N
+portArg = do ->
+  for a, i in args
+    return a.split('=')[1] if a.startsWith('--port=')
+    return args[i + 1] if a is '--port' and args[i + 1]
+  null
+port = parseInt(process.env.DB_PORT or portArg) or 4213
+
+# Open database and create persistent connection
 db = open(path)
-binaryConn = db.connect()  # Keep one connection for binary protocol queries
-console.log "rip-db: database=#{path} (bun-native)"
+conn = db.connect()
+console.log "rip-db: database=#{path} (bun-ffi)"
+console.log "rip-db: DuckDB version=#{duckdbVersion()}"
 
 # ==============================================================================
 # Helpers
 # ==============================================================================
 
-# Extract column info from result
-getColumnInfo = (rows) ->
-  return { columns: [], types: [] } unless rows?.length
-  first = rows[0]
-  columns = Object.keys(first)
-  types = columns.map (col) ->
-    switch typeof val = first[col]
-      when 'number'  then Number.isInteger(val) ? 'INTEGER' : 'DOUBLE'
-      when 'string'  then 'VARCHAR'
-      when 'boolean' then 'BOOLEAN'
-      when 'bigint'  then 'BIGINT'
-      else val is null ? 'NULL' : 'UNKNOWN'
-  { columns, types }
-
-# Convert row objects to arrays for compact format
-rowsToArrays = (rows, columns) ->
-  rows.map (row) -> columns.map (col) -> row[col]
-
-# Check if SQL is a SELECT-type query
+# Helper for binary responses
+binaryResponse = (data) ->
+  new Response data, headers: { 'Content-Type': 'application/octet-stream' }
+
+# Check if SQL is a query that returns results
 isSelectQuery = (sql) ->
   upper = sql.trim().toUpperCase()
   upper.startsWith('SELECT') or
     upper.startsWith('WITH') or
     upper.startsWith('SHOW') or
     upper.startsWith('DESCRIBE') or
+    upper.startsWith('EXPLAIN') or
     upper.startsWith('PRAGMA')
 
-# Execute SQL and return JSONCompact result
-executeSQL = (sql) ->
+# Log SQL query (truncated if long)
+logSQL = (sql) ->
+  preview = sql.replace(/\s+/g, ' ').trim()
+  preview = "#{preview.slice(0, 100)}..." if preview.length > 100
+  console.log "SQL: #{preview}"
+
+# Execute SQL and return result (uses persistent connection)
+executeSQL = (sql, params = []) ->
+  logSQL sql
   startTime = Date.now()
-  conn = db.connect()
 
   try
-    rows = conn.query(sql)
+    rows = await conn.query(sql, params)
+    columns = rows.columns or []
 
     if isSelectQuery(sql)
-      { columns, types } = getColumnInfo(rows)
-      data = rowsToArrays(rows, columns)
       {
-        meta: columns.map((name, i) -> { name, type: types[i] })
-        data: data
-        rows: data.length
+        meta: columns.map((col) -> { name: col.name, type: col.typeName })
+        data: rows.map((row) -> columns.map((col) -> row[col.name]))
+        rows: rows.length
         time: (Date.now() - startTime) / 1000
       }
     else
       { meta: [], data: [], rows: 0, time: (Date.now() - startTime) / 1000 }
   catch err
     { error: err.message }
-  finally
-    conn.close()
 
 # ==============================================================================
-# Endpoints
+# JSON Endpoints (for custom apps)
 # ==============================================================================
 
-# POST / — duck-ui compatible (raw SQL in body)
-post '/' ->
-  sql = read 'body', 'string' or return { error: 'Empty query' }
-  # Log the SQL (truncate long queries)
-  preview = sql.replace(/\s+/g, ' ').trim()
-  preview = "#{preview.slice(0, 120)}..." if preview.length > 120
-  console.log "SQL: #{preview}"
-  executeSQL sql
-
-# POST /sql — JSON body with SQL query
+# POST /sql — Execute SQL with optional parameters
 post '/sql' ->
-  sql = read 'sql', 'string' or return { error: 'Missing required field: sql' }
-  preview = sql.replace(/\s+/g, ' ').trim()
-  preview = "#{preview.slice(0, 120)}..." if preview.length > 120
-  console.log "SQL: #{preview}"
+  contentType = @req.header('content-type') or ''
+  if contentType.includes('application/json')
+    body = read()
+    sql = body?.sql or body
+    params = body?.params or []
+  else
+    sql = read 'body', 'string'
+    params = []
+  return { error: 'Empty query' } unless sql
+  executeSQL sql, params
+
+# POST / — Raw SQL in body (duck-ui compatible)
+post '/' ->
+  sql = read 'body', 'string'
+  return { error: 'Empty query' } unless sql
   executeSQL sql
 
-# GET /health — Simple health check (no DB query)
-get '/health', ->
-  { ok: true }
-
-# GET /status — Database info and table list
-get '/status', ->
-  conn = db.connect()
-  try
-    tables = conn.query("SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'")
-    {
-      ok: true
-      database: path
-      tables: tables.map((t) -> t.table_name)
-      time: new Date().toISOString()
-    }
-  catch err
-    { ok: false, error: err.message }
-  finally
-    conn.close()
+# GET /health — Health check
+get '/health' ->
+  { status: 'ok', version: VERSION }
 
 # GET /tables — List all tables
-get '/tables', ->
-  conn = db.connect()
-  try
-    tables = conn.query("SELECT table_name FROM information_schema.tables WHERE table_schema = 'main' ORDER BY table_name")
-    { ok: true, tables: tables.map((t) -> t.table_name) }
-  catch err
-    { ok: false, error: err.message }
-  finally
-    conn.close()
+get '/tables' ->
+  rows = await conn.query "SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'"
+  { tables: rows.map((r) -> r.table_name) }
 
 # GET /schema/:table — Get table schema
-get '/schema/:table', ->
-  table = read 'table', 'string!'
-  conn = db.connect()
+get '/schema/:table' ->
+  table = @req.params.table.replace(/[^a-zA-Z0-9_]/g, '')  # sanitize
   try
-    columns = conn.query("SELECT column_name, data_type, is_nullable FROM information_schema.columns WHERE table_name = '#{table.replace(/'/g, "''")}' ORDER BY ordinal_position")
-
-    if columns.length is 0
-      { ok: false, error: "Table '#{table}' not found" }
-    else
-      { ok: true, table: table, columns: columns }
+    rows = await conn.query "DESCRIBE \"#{table}\""
+    { schema: rows }
   catch err
-    { ok: false, error: err.message }
-  finally
-    conn.close()
+    { error: err.message }
 
 # ==============================================================================
-# DuckDB UI Protocol — Binary endpoints for official UI compatibility
-# ==============================================================================
-#
-# These endpoints implement the binary protocol used by DuckDB's official UI.
-# This allows you to use the beautiful DuckDB UI with rip-db!
-#
-# The official UI expects these endpoints:
-#   POST /ddb/run      - Execute SQL (binary response)
-#   POST /ddb/interrupt - Cancel running query
-#   POST /ddb/tokenize - Tokenize SQL for syntax highlighting
-#   GET  /info         - Server version info
-#
-# To use the DuckDB UI:
-#   1. Start rip-db: rip-db mydb.duckdb --port 4000
-#   2. Open: http://localhost:4000 (UI proxied from ui.duckdb.org)
-#
+# DuckDB UI Binary Protocol
 # ==============================================================================
 
+# Remote UI URL for proxying assets
+UI_REMOTE_URL = 'https://ui.duckdb.org'
+
+# Helper to extract parameters from DuckDB UI headers (base64 encoded)
+# The official C++ extension passes all params as strings (VARCHAR).
+# DuckDB handles implicit casting to target types.
+getUIParams = (req) ->
+  count = parseInt(req.header('x-duckdb-ui-parameter-count') or '0')
+  return [] if count is 0
+
+  params = []
+  for i in [0...count]
+    encoded = req.header("x-duckdb-ui-parameter-value-#{i}")
+    if encoded
+      try
+        decoded = atob(encoded)
+        # The UI sends literal "null" for NULL values
+        if decoded is 'null'
+          params.push null
+        else
+          params.push decoded
+      catch
+        params.push ''
+    else
+      params.push null
+  params
+
 # POST /ddb/run — Execute SQL and return binary result (DuckDB UI protocol)
 post '/ddb/run' ->
   try
-    sql = read 'body', 'string' or return binaryResponse errorResult 'Empty query'
+    sql = read 'body', 'string'
+    return binaryResponse serializeErrorResult 'Empty query' unless sql
 
-    # Parse row limit from DuckDB UI header
+    logSQL sql
     rowLimit = parseInt(@req.header('x-duckdb-ui-result-row-limit') or '10000')
-    rowLimit = 10000 if isNaN(rowLimit) or rowLimit <= 0
+    params = getUIParams(@req)
 
-    # Execute query and get binary result directly from Zig!
-    # (No JS serialization needed - Zig does it all)
-    result = queryBinary binaryConn.handle, sql, rowLimit
-    binaryResponse result
+    rows = await conn.query sql, params
+    columns = rows.columns or []
+
+    # Build column info for serialization
+    colInfo = columns.map (col) -> { name: col.name, type: col.typeName }
+
+    # Convert rows to arrays (ensure undefined becomes null for serialization)
+    limitedRows = rows.slice(0, rowLimit)
+    arrayRows = limitedRows.map (row) ->
+      columns.map (col) ->
+        val = row[col.name]
+        if val is undefined then null else val
+
+    binaryResponse serializeSuccessResult colInfo, arrayRows
 
   catch err
-    console.error "POST /ddb/run error:", err?.message
-    binaryResponse errorResult err?.message or 'Unknown error'
+    msg = err?.message or 'Unknown error'
+    # Handle _duckdb_ui catalog queries - return empty success instead of error
+    if msg.includes('_duckdb_ui')
+      return binaryResponse serializeSuccessResult [], []
+    console.error "POST /ddb/run error:", msg
+    binaryResponse serializeErrorResult msg
 
 # POST /ddb/interrupt — Cancel running query
-post '/ddb/interrupt', ->
-  # In a real implementation, this would cancel the running query
-  # For now, just return empty result
-  binaryResponse emptyResult()
+post '/ddb/interrupt' ->
+  binaryResponse serializeEmptyResult()
 
 # POST /ddb/tokenize — Tokenize SQL for syntax highlighting
 post '/ddb/tokenize' ->
   sql = read 'body', 'string'
-  binaryResponse tokenize (sql or '')
+  tokens = tokenizeSQL(sql or '')
+  binaryResponse serializeTokenizeResult(tokens)
+
+# ==============================================================================
+# DuckDB UI Compatibility Endpoints
+# (Responses match the official DuckDB UI extension exactly)
+# ==============================================================================
+
+# UI extension version — must match what /config advertises for our DuckDB version
+UI_EXT_VERSION = '150-5582dfaffc'
+
+# Detect platform for DuckDB headers
+PLATFORM = switch "#{process.platform}_#{process.arch}"
+  when 'darwin_arm64' then 'osx_arm64'
+  when 'darwin_x64'   then 'osx_amd64'
+  when 'linux_arm64'  then 'linux_arm64'
+  when 'linux_x64'    then 'linux_amd64'
+  else "#{process.platform}_#{process.arch}"
 
 # GET /version — Tell UI we're running in host/HTTP mode (not WASM)
 get '/version' ->
-  { origin: 'host', version: '139-944c08a214' }
+  { origin: 'host', version: "main@e6517d259ec5f27ab713e5755a29d775a7750dc5" }
 
-# GET /localToken — Return empty token for local mode (no MotherDuck)
+# GET /localToken — Return 401 to skip MotherDuck auth (matches official)
 get '/localToken' ->
-  new Response '', { status: 200, headers: { 'Content-Type': 'text/plain' } }
+  new Response null, { status: 401 }
 
-# GET /info — Server version info (DuckDB UI checks this)
-# The UI checks X-DuckDB-UI-Extension-Version to decide HTTP vs WASM mode
-# Version format must match desiredDuckDBUIExtensionVersions in /config
+# GET /info — Server version info (headers only, empty body — matches official)
 get '/info' ->
   @body '', 200,
     'Access-Control-Allow-Origin': '*'
-    'X-DuckDB-Version': '1.4.1'
-    'X-DuckDB-Platform': 'rip-db'
-    'X-DuckDB-UI-Extension-Version': '139-944c08a214'
+    'Content-Type': 'text/plain'
+    'X-DuckDB-Version': duckdbVersion()
+    'X-DuckDB-Platform': PLATFORM
+    'X-DuckDB-UI-Extension-Version': UI_EXT_VERSION
 
-# Helper to create binary response
-binaryResponse = (buffer) ->
-  new Response buffer,
-    headers: { 'Content-Type': 'application/octet-stream' }
-
-# ==============================================================================
-# DuckDB UI Proxy — Serve official UI assets from ui.duckdb.org
-# ==============================================================================
-#
-# The official DuckDB UI is a React app hosted at https://ui.duckdb.org
-# We proxy these assets so you can use the beautiful UI with rip-db!
-#
-# The UI makes API requests to relative URLs (/ddb/run, /ddb/tokenize, etc.)
-# which we handle above. This proxy just serves the static UI assets.
-#
-# ==============================================================================
-
-UI_REMOTE_URL = 'https://ui.duckdb.org'
-
-# GET /config — Local mode configuration (prevents MotherDuck redirect)
+# GET /config — Proxy from ui.duckdb.org with DuckDB version headers
+# The UI checks these HEADERS (not just /info) to decide HTTP vs WASM mode
 get '/config' ->
-  # Return minimal config with required fields for local mode
-  config =
-    logging:
-      enabled: false
-    datadog:
-      applicationId: ''
-      clientToken: ''
-      site: ''
-      env: 'local'
-      allowedTracingOrigins: []
-    defaultFeatureValues: {}
-
-  # Headers tell UI this is a local DuckDB instance
-  new Response JSON.stringify(config),
-    headers:
-      'Content-Type': 'application/json'
-      'X-DuckDB-Version': '1.4.1'
-      'X-DuckDB-Platform': 'osx_arm64'
-      'X-DuckDB-UI-Extension-Version': '139-944c08a214'
+  try
+    response = fetch! "#{UI_REMOTE_URL}/config",
+      headers: { 'User-Agent': "rip-db/#{VERSION}" }
+    body = response.text!
+    new Response body,
+      status: response.status
+      headers:
+        'Content-Type': 'application/json'
+        'X-DuckDB-Version': duckdbVersion()
+        'X-DuckDB-Platform': PLATFORM
+        'X-DuckDB-UI-Extension-Version': UI_EXT_VERSION
+  catch
+    new Response JSON.stringify({
+      globalApiUrl: "http://localhost:#{port}"
+      apiUrl: "http://localhost:#{port}"
+      momApiUrl: "http://localhost:#{port}/mom"
+      logging: { enabled: false }
+      datadog: { applicationId: '', clientToken: '', site: '', env: 'local', allowedTracingOrigins: [] }
+      defaultFeatureValues: {}
+      desiredDuckDBUIExtensionVersions: { "#{duckdbVersion()}": UI_EXT_VERSION }
+    }),
+      headers:
+        'Content-Type': 'application/json'
+        'X-DuckDB-Version': duckdbVersion()
+        'X-DuckDB-Platform': PLATFORM
+        'X-DuckDB-UI-Extension-Version': UI_EXT_VERSION
 
-# GET /localEvents — Server-sent events for catalog updates
+# GET /localEvents — SSE stream with keepalive (matches official extension)
+# The official blocks 5s per iteration, sends ":\r\r" keepalive if no events.
 get '/localEvents' ->
-  # SSE endpoint for DuckDB UI - must stay open
-  encoder = new TextEncoder()
-  stream = new ReadableStream
+  keepalive = null
+  new Response new ReadableStream({
     start: (controller) ->
-      # Send initial connected event
-      controller.enqueue encoder.encode "event: ConnectedEvent\ndata: \n\n"
-      # Keep-alive with pings every 5 seconds (Bun has 10s idle timeout)
-      @interval = setInterval =>
+      # Send keepalive every 5 seconds (SSE comment, matches official ":\r\r")
+      keepalive = setInterval ->
         try
-          controller.enqueue encoder.encode ": ping\n\n"
+          controller.enqueue ":\r\r"
         catch
-          clearInterval @interval
+          clearInterval keepalive
       , 5000
     cancel: ->
-      clearInterval @interval if @interval
-
-  new Response stream,
+      clearInterval keepalive if keepalive
+  }),
     headers:
       'Content-Type': 'text/event-stream'
-      'Cache-Control': 'no-cache'
-      'Connection': 'keep-alive'
+
+# GET /mom/* — MotherDuck API stubs (prevent OAuth, return 401)
+get '/mom/*' ->
+  new Response null, { status: 401 }
 
 # GET /* — Proxy UI assets from ui.duckdb.org (catch-all, must be last)
 get '/*' ->
-  path = @req.path
-
-  # Skip if this is one of our API endpoints (shouldn't reach here, but safety)
-  return { error: 'Not found' } if path in ['/health', '/status', '/tables', '/info']
+  reqPath = @req.path
 
   try
-    # Fetch from remote UI server
-    response = fetch! "#{UI_REMOTE_URL}#{path}",
-      headers:
-        'User-Agent': "rip-db/#{VERSION}"
+    response = fetch! "#{UI_REMOTE_URL}#{reqPath}",
+      headers: { 'User-Agent': "rip-db/#{VERSION}" }
 
-    # Get response body and content type
     body = response.arrayBuffer!
     contentType = response.headers.get('Content-Type') or 'application/octet-stream'
 
@@ -371,18 +366,17 @@ get '/*' ->
     headers =
       'Content-Type': contentType
       'Cache-Control': response.headers.get('Cache-Control') or 'public, max-age=3600'
+      # COOP/COEP required for SharedArrayBuffer (DuckDB WASM fallback)
+      'Cross-Origin-Opener-Policy': 'same-origin'
+      'Cross-Origin-Embedder-Policy': 'credentialless'
 
-    # For /config endpoint, add DuckDB version headers (UI uses these to detect mode)
-    if path is '/config'
-      headers['X-DuckDB-Version'] = '1.4.1'
-      headers['X-DuckDB-Platform'] = 'rip-db'
-      headers['X-DuckDB-UI-Extension-Version'] = '139-944c08a214'
-
-    new Response body, { status: response.status, headers }
+    new Response body,
+      status: response.status
+      headers: headers
 
   catch err
-    console.error "Proxy error for #{path}:", err?.message
-    new Response "Failed to fetch UI asset: #{path}", { status: 502 }
+    console.error "Proxy error for #{reqPath}:", err?.message
+    new Response "Failed to fetch UI asset: #{reqPath}", { status: 502 }
 
 # ==============================================================================
 # Start Server