@sqldoc/atlas 0.0.1

package/src/wasi-host.ts

@@ -0,0 +1,175 @@
+/**
+ * WASI module instantiation with custom atlas_sql host function import.
+ *
+ * Includes workarounds for Bun's WASI bugs:
+ *   1. FD_MAP ignores stdin/stdout/stderr constructor options
+ *   2. random_get returns byte count instead of errno 0
+ *   3. proc_exit calls process.exit() instead of throwing
+ */
+
+import * as crypto from 'node:crypto'
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { WASI } from 'node:wasi'
+
+const isBun = typeof (globalThis as any).Bun !== 'undefined'
+
+/** Sentinel thrown by Bun proc_exit workaround */
+class WASIExitError {
+  code: number
+  constructor(code: number) {
+    this.code = code
+  }
+}
+
+/**
+ * Get WASI imports compatible with both Node.js and Bun.
+ */
+export function getWasiImports(wasi: WASI): Record<string, any> {
+  if (typeof (wasi as any).getImportObject === 'function') {
+    return (wasi as any).getImportObject()
+  }
+  if ((wasi as any).wasiImport) {
+    return { wasi_snapshot_preview1: (wasi as any).wasiImport }
+  }
+  throw new Error('Cannot get WASI imports: neither getImportObject() nor wasiImport available')
+}
+
+export interface WasiRunOptions {
+  stdinData: string
+  wasmPath: string
+  compiledModule?: WebAssembly.Module
+  atlasSqlFn: (reqPtr: number, reqLen: number, respPtr: number, respCap: number) => bigint | number
+  onInstance?: (instance: WebAssembly.Instance) => void
+}
+
+export interface WasiRunResult {
+  stdout: string
+  module: WebAssembly.Module
+}
+
+export async function runWasi(options: WasiRunOptions): Promise<WasiRunResult> {
+  const { stdinData, wasmPath, atlasSqlFn, onInstance } = options
+  const uid = crypto.randomUUID()
+  const tmpDir = os.tmpdir()
+  const stdinPath = path.join(tmpDir, `atlas-stdin-${uid}.json`)
+  const stdoutPath = path.join(tmpDir, `atlas-stdout-${uid}.json`)
+
+  let stdinFd: number | undefined
+  let stdoutFd: number | undefined
+
+  try {
+    fs.writeFileSync(stdinPath, stdinData)
+    fs.writeFileSync(stdoutPath, '')
+
+    stdinFd = fs.openSync(stdinPath, 'r')
+    stdoutFd = fs.openSync(stdoutPath, 'w')
+
+    const wasi = new WASI({
+      version: 'preview1',
+      stdin: stdinFd,
+      stdout: stdoutFd,
+      returnOnExit: true,
+    })
+
+    // Bun bug #1: FD_MAP ignores constructor options
+    if (isBun) {
+      const fdMap: Map<number, any> = (wasi as any).FD_MAP
+      if (fdMap) {
+        const fd0 = fdMap.get(0)
+        if (fd0) fd0.real = stdinFd
+        const fd1 = fdMap.get(1)
+        if (fd1) fd1.real = stdoutFd
+        const fd2 = fdMap.get(2)
+        if (fd2) fd2.real = 2
+      }
+    }
+
+    // Compile module (or reuse cached)
+    let wasmModule = options.compiledModule
+    if (!wasmModule) {
+      const wasmBytes = fs.readFileSync(wasmPath)
+      wasmModule = await WebAssembly.compile(wasmBytes)
+    }
+
+    // Build imports
+    const wasiImports = getWasiImports(wasi)
+    let instanceRef: WebAssembly.Instance | undefined
+
+    if (isBun && wasiImports.wasi_snapshot_preview1) {
+      // Bun bug #2: random_get returns byte count instead of errno 0
+      wasiImports.wasi_snapshot_preview1.random_get = (bufPtr: number, bufLen: number) => {
+        if (instanceRef) {
+          const mem = instanceRef.exports.memory as WebAssembly.Memory
+          const view = new Uint8Array(mem.buffer, bufPtr, bufLen)
+          crypto.getRandomValues(view)
+        }
+        return 0
+      }
+
+      // Bun bug #3: proc_exit calls process.exit()
+      wasiImports.wasi_snapshot_preview1.proc_exit = (code: number) => {
+        throw new WASIExitError(code)
+      }
+    }
+
+    const imports = {
+      ...wasiImports,
+      env: { atlas_sql: atlasSqlFn },
+    }
+
+    // Instantiate
+    const instance = await WebAssembly.instantiate(wasmModule, imports)
+    instanceRef = instance
+
+    if (isBun && typeof (wasi as any).setMemory === 'function') {
+      ;(wasi as any).setMemory(instance.exports.memory)
+    }
+
+    if (onInstance) {
+      onInstance(instance)
+    }
+
+    // Run
+    try {
+      if (isBun) {
+        ;(instance.exports._start as Function)()
+      } else {
+        wasi.start(instance)
+      }
+    } catch (err: unknown) {
+      if (err instanceof WASIExitError) {
+        // Bun sentinel — non-zero exit is fine, we read stdout for error JSON
+      } else {
+        // Node: returnOnExit throws on non-zero exit code
+        const isExitError = err instanceof Error && ('code' in err || err.message.includes('exit'))
+        if (!isExitError) throw err
+      }
+    }
+
+    // Close fds before reading stdout
+    fs.closeSync(stdinFd)
+    stdinFd = undefined
+    fs.closeSync(stdoutFd)
+    stdoutFd = undefined
+
+    const stdout = fs.readFileSync(stdoutPath, 'utf-8')
+    return { stdout, module: wasmModule }
+  } finally {
+    if (stdinFd !== undefined)
+      try {
+        fs.closeSync(stdinFd)
+      } catch {}
+    if (stdoutFd !== undefined)
+      try {
+        fs.closeSync(stdoutFd)
+      } catch {}
+    try {
+      fs.unlinkSync(stdinPath)
+    } catch {}
+    try {
+      fs.unlinkSync(stdoutPath)
+    } catch {}
+  }
+}

package/src/worker.ts

@@ -0,0 +1,106 @@
+/**
+ * Worker thread entry point for Atlas WASI execution.
+ *
+ * This file runs inside a node:worker_threads Worker. It:
+ * 1. Receives initialization data via workerData
+ * 2. Creates the atlas_sql callback using SharedArrayBuffer + Atomics
+ * 3. Runs the WASI module with the stdin data
+ * 4. Posts the stdout result back to the parent
+ *
+ * The atlas_sql callback bridges synchronous WASM calls to the main thread's
+ * async database adapter using Atomics.wait (blocking on the worker thread).
+ */
+
+import { parentPort, workerData } from 'node:worker_threads'
+import { type BridgeBuffers, bridgeRequest, SIGNAL_DONE } from './bridge.ts'
+import { runWasi } from './wasi-host.ts'
+
+interface WorkerInit {
+  wasmPath: string
+  controlBuffer: SharedArrayBuffer
+  dataBuffer: SharedArrayBuffer
+  stdinData: string
+}
+
+const { wasmPath, controlBuffer, dataBuffer, stdinData } = workerData as WorkerInit
+
+const buffers: BridgeBuffers = {
+  control: controlBuffer,
+  data: dataBuffer,
+}
+
+// WASM instance memory -- set via onInstance before wasi.start()
+let wasmMemory: WebAssembly.Memory | null = null
+
+/**
+ * The atlas_sql host function that bridges sync WASM calls
+ * to the main thread via SharedArrayBuffer + Atomics.
+ *
+ * Signature matches Go's //go:wasmimport env atlas_sql:
+ *   (reqPtr, reqLen, respPtr, respCap) => int64
+ *
+ * Negative return = buffer too small (abs value = needed size).
+ * Positive return = actual response length written.
+ */
+function atlasSql(reqPtr: number, reqLen: number, respPtr: number, respCap: number): bigint {
+  if (!wasmMemory) {
+    throw new Error('WASM memory not yet available in atlas_sql callback')
+  }
+
+  // 1. Read request JSON from WASM memory
+  const reqBytes = new Uint8Array(wasmMemory.buffer, reqPtr, reqLen)
+  const requestJson = new TextDecoder().decode(reqBytes.slice())
+
+  // 2. Send request to main thread via bridge and block until response
+  const responseJson = bridgeRequest(buffers, requestJson)
+
+  // 3. Encode response and check capacity
+  const respEncoded = new TextEncoder().encode(responseJson)
+
+  if (respEncoded.byteLength > respCap) {
+    return BigInt(-respEncoded.byteLength)
+  }
+
+  // 4. Copy response into WASM memory
+  const wasmResp = new Uint8Array(wasmMemory.buffer, respPtr, respCap)
+  wasmResp.set(respEncoded)
+
+  return BigInt(respEncoded.byteLength)
+}
+
+async function main(): Promise<void> {
+  if (!parentPort) {
+    throw new Error('worker.ts must run inside a worker thread')
+  }
+
+  try {
+    const result = await runWasi({
+      stdinData,
+      wasmPath,
+      atlasSqlFn: atlasSql,
+      onInstance(instance) {
+        // Capture WASM memory before execution starts.
+        // atlas_sql will use this to read requests from / write responses to WASM memory.
+        wasmMemory = instance.exports.memory as WebAssembly.Memory
+      },
+    })
+
+    // Signal main thread that WASI execution is done
+    const control = new Int32Array(buffers.control)
+    Atomics.store(control, 0, SIGNAL_DONE)
+    Atomics.notify(control, 0)
+
+    // Post result back
+    parentPort.postMessage({ type: 'result', stdout: result.stdout })
+  } catch (err: unknown) {
+    // Signal done even on error
+    const control = new Int32Array(buffers.control)
+    Atomics.store(control, 0, SIGNAL_DONE)
+    Atomics.notify(control, 0)
+
+    const message = err instanceof Error ? err.message : String(err)
+    parentPort.postMessage({ type: 'error', error: message })
+  }
+}
+
+main()