@rip-lang/db 0.10.0 → 1.0.2

package/db.rip

@@ -6,45 +6,45 @@
 # 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)
-#   GET  /ui      - Built-in SQL console (simple, no proxy)
-#   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 } from './lib/duckdb.mjs'
 import { version as VERSION } from './package.json'
-import {
+
+# 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
-  inferType
-} from './lib/duckdb-binary.rip'
+} = await import('./lib/duckdb-binary.rip')
 
-# Enable CORS for duck-ui and other clients
+# Enable CORS for DuckDB UI and other clients
 use cors preflight: true
 
 # Log all requests
 use (c, next) ->
-  start = Date.now()
+  t0 = Date.now()
   result = next!
-  ms = Date.now() - start
+  ms = Date.now() - t0
   console.log "#{c.req.method} #{c.req.path} #{ms}ms"
   result
 
@@ -58,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]
 
@@ -70,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)
 
@@ -95,288 +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
+# 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)
-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) ->
-  if not rows?.length > 0
-    return { columns: [], types: [] }
-  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
+# 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 = if params.length > 0
-      stmt = conn.prepare(sql)
-      stmt.query(...params)
-    else
-      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 — Execute SQL with optional parameters
+post '/sql' ->
+  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'
-  if not sql
-    return { error: 'Empty query' }
+  return { error: 'Empty query' } unless sql
   executeSQL sql
 
-# POST /sql — JSON body with optional params
-post '/sql' ->
-  { sql, params } = read()
-  if not sql
-    return { error: 'Missing required field: sql' }
-  executeSQL sql, (params or [])
-
-# 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
-    stmt = conn.prepare("SELECT column_name, data_type, is_nullable FROM information_schema.columns WHERE table_name = ? ORDER BY ordinal_position")
-    columns = stmt.query(table)
-
-    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()
-
-# GET /ui — Built-in SQL console
-get '/ui', -> new Response Bun.file(import.meta.dir + '/db.html')
+    { 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'
-    if not sql
-      return binaryResponse serializeErrorResult 'Empty query'
+    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')
+    params = getUIParams(@req)
 
-    # Execute query
-    conn = db.connect()
-    try
-      rows = conn.query sql
+    rows = await conn.query sql, params
+    columns = rows.columns or []
 
-      # Build column metadata from first row
-      columns = []
-      if rows?.length > 0
-        first = rows[0]
-        for key of first
-          columns.push { name: key, type: inferType first[key] }
+    # Build column info for serialization
+    colInfo = columns.map (col) -> { name: col.name, type: col.typeName }
 
-      # Limit rows and convert to array format
-      limitedRows = rows?.slice(0, rowLimit) or []
-      arrayRows = limitedRows.map (row) ->
-        columns.map (col) -> row[col.name]
+    # 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 columns, arrayRows
-    finally
-      conn.close()
+    binaryResponse serializeSuccessResult colInfo, arrayRows
 
   catch err
-    console.error "POST /ddb/run error:", err?.message
-    binaryResponse serializeErrorResult 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
+post '/ddb/interrupt' ->
   binaryResponse serializeEmptyResult()
 
 # POST /ddb/tokenize — Tokenize SQL for syntax highlighting
 post '/ddb/tokenize' ->
   sql = read 'body', 'string'
-  tokens = tokenizeSQL sql
-  binaryResponse serializeTokenizeResult tokens
+  tokens = tokenizeSQL(sql or '')
+  binaryResponse serializeTokenizeResult(tokens)
+
+# ==============================================================================
+# DuckDB UI Compatibility Endpoints
+# (Responses match the official DuckDB UI extension exactly)
+# ==============================================================================
 
-# GET /version — Tell UI we're running in local/HTTP mode (not WASM)
+# 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: 'local', 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'
-
-# 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'
+    'Content-Type': 'text/plain'
+    'X-DuckDB-Version': duckdbVersion()
+    'X-DuckDB-Platform': PLATFORM
+    'X-DuckDB-UI-Extension-Version': UI_EXT_VERSION
+
+# 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' ->
+  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' ->
-  # Create SSE response with keep-alive
-  encoder = new TextEncoder()
-  intervalId = null
-
-  stream = new ReadableStream
+  keepalive = null
+  new Response new ReadableStream({
     start: (controller) ->
-      # Send initial connection event
-      controller.enqueue encoder.encode "event: connected\ndata: {}\n\n"
-
-      # Keep connection alive with periodic heartbeats
-      intervalId = setInterval ->
+      # Send keepalive every 5 seconds (SSE comment, matches official ":\r\r")
+      keepalive = setInterval ->
         try
-          controller.enqueue encoder.encode ": heartbeat\n\n"
+          controller.enqueue ":\r\r"
         catch
-          clearInterval intervalId
-      , 30000
-
+          clearInterval keepalive
+      , 5000
     cancel: ->
-      clearInterval intervalId if intervalId
-
-  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', '/ui']
+  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'
 
@@ -384,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
@@ -404,5 +385,4 @@ get '/*' ->
 start port: port
 
 console.log "rip-db: listening on http://localhost:#{port}"
-console.log "rip-db: Official DuckDB UI available at http://localhost:#{port}/"
-console.log "rip-db: Built-in console at http://localhost:#{port}/ui"
+console.log "rip-db: DuckDB UI available at http://localhost:#{port}/"