fix: path resolvement

Author: Marcus Pousette

dist-tests/import-name.spec.js

@@ -0,0 +1,51 @@
+import { test } from 'node:test';
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+test('consumer import by package name works', async () => {
+  // Create temp project with node_modules alias to this repo
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sqlite3-vec-import-'));
+  const nm = path.join(tmp, 'node_modules', '@dao-xyz');
+  fs.mkdirSync(nm, { recursive: true });
+  const linkTarget = process.cwd();
+  const pkgPath = path.join(nm, 'sqlite3-vec');
+  try {
+    fs.symlinkSync(linkTarget, pkgPath, 'dir');
+  } catch (e) {
+    // Fallback: copy if symlink not permitted
+    fs.cpSync(linkTarget, pkgPath, { recursive: true, dereference: true });
+  }
+
+  // Write an ESM script which imports the package by name
+  const runner = path.join(tmp, 'runner.mjs');
+  fs.writeFileSync(
+    runner,
+    `import { createDatabase, resolveNativeExtensionPath } from '@dao-xyz/sqlite3-vec';
+     const db = await createDatabase({});
+     await db.open();
+     const s = await db.prepare('select sqlite_version() as v');
+     const row = s.get?.([]);
+     if (!row || !(row.v || row[0])) throw new Error('no sqlite_version');
+     // Not asserting ext presence; just ensure the API is callable
+     void resolveNativeExtensionPath();
+     await db.close();
+     console.log('ok');
+    `,
+  );
+
+  const res = spawnSync(process.execPath, [runner], {
+    cwd: tmp,
+    stdio: 'pipe',
+    env: { ...process.env, NODE_ENV: 'test' },
+    encoding: 'utf8',
+  });
+  if (res.status !== 0) {
+    console.error('[import-name] stderr:', res.stderr);
+    console.error('[import-name] stdout:', res.stdout);
+  }
+  assert.equal(res.status, 0);
+  assert.match(res.stdout || '', /ok/);
+});

dist-tests/simple.spec.js

@@ -3,13 +3,13 @@ import * as assert from 'node:assert/strict';
 // Import the built unified Node entry to test Node usage without bundlers.
 import { createDatabase } from '../dist/unified-node.js';
 test('unified import and factory availability', async () => {
-  assert.equal(typeof createDatabase, 'function');
+    assert.equal(typeof createDatabase, 'function');
 });
 test('unified createDatabase (native mode) basic usage', async () => {
-  const db = await createDatabase({});
-  await db.open();
-  const s = await db.prepare('SELECT sqlite_version() as v');
-  const row = s.get?.([]);
-  assert.ok(row && (typeof row.v === 'string' || row[0]));
-  await db.close();
+    const db = await createDatabase({});
+    await db.open();
+    const s = await db.prepare('SELECT sqlite_version() as v');
+    const row = s.get?.([]);
+    assert.ok(row && (typeof row.v === 'string' || row[0]));
+    await db.close();
 });

dist-tests/vec.spec.js

@@ -1,19 +1,16 @@
 import { test } from 'node:test';
 import * as assert from 'node:assert/strict';
-import {
-  createDatabase,
-  resolveNativeExtensionPath,
-} from '../dist/unified-node.js';
+import { createDatabase, resolveNativeExtensionPath, } from '../dist/unified-node.js';
 test('vec extension provides vec_version() when present', async () => {
-  const extPath = resolveNativeExtensionPath();
-  if (!extPath) {
-    // No prebuilt/native extension present in this environment; skip.
-    return;
-  }
-  const db = await createDatabase({});
-  await db.open();
-  const stmt = await db.prepare('select vec_version() as v');
-  const row = stmt.get?.([]);
-  assert.ok(row && typeof (row.v ?? row[0]) === 'string');
-  await db.close();
+    const extPath = resolveNativeExtensionPath();
+    if (!extPath) {
+        // No prebuilt/native extension present in this environment; skip.
+        return;
+    }
+    const db = await createDatabase({});
+    await db.open();
+    const stmt = await db.prepare('select vec_version() as v');
+    const row = stmt.get?.([]);
+    assert.ok(row && typeof (row.v ?? row[0]) === 'string');
+    await db.close();
 });

dist-tests/vec0-native.spec.js

@@ -0,0 +1,28 @@
+import { test } from 'node:test';
+import * as assert from 'node:assert/strict';
+import {
+  createDatabase,
+  resolveNativeExtensionPath,
+} from '../dist/unified-node.js';
+
+test('vec0 create/insert/query works (native ext present)', async () => {
+  const extPath = resolveNativeExtensionPath();
+  if (!extPath) return; // skip if no native ext available
+
+  const db = await createDatabase({});
+  await db.open();
+  await db.exec('CREATE VIRTUAL TABLE IF NOT EXISTS v USING vec0(vector float[3])');
+
+  const toVec = () => new Float32Array([Math.random(), Math.random(), Math.random()]);
+  const ins = await db.prepare('INSERT INTO v(rowid,vector) VALUES(?1,?2)');
+  for (let i = 1; i <= 4; i++) ins.run([i, toVec().buffer]);
+
+  const probe = toVec();
+  const q = await db.prepare(
+    'SELECT rowid, vec_distance_l2(vector, ?1) AS d FROM v ORDER BY d LIMIT 2',
+  );
+  const rows = q.all([probe.buffer]);
+  assert.ok(Array.isArray(rows) && rows.length === 2);
+  assert.ok(typeof rows[0].d === 'number');
+  await db.close();
+});

src/unified-node.ts

@@ -2,6 +2,7 @@
 import type { Database, Statement } from './unified';
 import * as fs from 'fs';
 import * as path from 'path';
+import { fileURLToPath } from 'url';
 
 function detectLibc(): 'gnu' | 'musl' {
   try {
@@ -28,9 +29,14 @@ function libExt(): string {
       : 'so';
 }
 
+function packageRootDir(): string {
+  // dist/unified-node.js -> package root
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..');
+}
+
 function findLocalPrebuilt(): string | undefined {
-  const root = process.cwd();
-  const outDir = path.join(root, 'dist', 'native');
+  const outDir = path.join(packageRootDir(), 'dist', 'native');
   if (!fs.existsSync(outDir)) return undefined;
   const ext = libExt();
   const triple = platformTriple();
@@ -107,6 +113,21 @@ export async function createDatabase(
     }
   };
 
+  const toBuffer = (v: any): any => {
+    if (!v) return v;
+    // Convert ArrayBuffer/TypedArray/DataView to Node Buffer for better-sqlite3 BLOB binding
+    if (typeof ArrayBuffer !== 'undefined') {
+      if (v instanceof ArrayBuffer) return Buffer.from(new Uint8Array(v));
+      if (ArrayBuffer.isView?.(v)) {
+        const u8 = new Uint8Array(v.buffer, v.byteOffset, v.byteLength);
+        return Buffer.from(u8);
+      }
+    }
+    return v;
+  };
+  const normVals = (values?: any[] | undefined): any[] | undefined =>
+    values ? values.map((x) => toBuffer(x)) : values;
+
   const wrapStmt = (stmt: any): Statement => {
     let bound: any[] | undefined = undefined;
     return {
@@ -116,17 +137,17 @@ export async function createDatabase(
       },
       finalize() {},
       get(values?: any[]) {
-        return stmt.get(values ?? bound);
+        return stmt.get(normVals(values ?? bound));
       },
       run(values: any[]) {
-        stmt.run(values ?? bound);
+        stmt.run(normVals(values ?? bound));
         bound = undefined;
       },
       async reset() {
         return this;
       },
       all(values: any[]) {
-        return stmt.all(values ?? bound);
+        return stmt.all(normVals(values ?? bound));
       },
       step() {
         return false;