Switched to node:test

Author: ankane

package.json

@@ -90,20 +90,13 @@
   },
   "scripts": {
     "build": "tsc",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest"
-  },
-  "jest": {
-    "testMatch": [
-      "**/*.test.mjs"
-    ],
-    "transform": {}
+    "test": "node --test"
   },
   "devDependencies": {
     "@mikro-orm/core": "^6.1.1",
     "@mikro-orm/postgresql": "^6.1.1",
     "@prisma/client": "^5.7.0",
     "drizzle-orm": "^0.31.0",
-    "jest": "^29.5.0",
     "knex": "^3.1.0",
     "kysely": "^0.27.3",
     "objection": "^3.1.3",

tests/drizzle-orm/index.test.mjs

@@ -1,3 +1,5 @@
+import assert from 'node:assert';
+import test from 'node:test';
 import { sql, l2Distance, innerProduct, cosineDistance, l1Distance, hammingDistance, jaccardDistance } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/postgres-js';
 import { pgTable, serial, vector, halfvec, bit, sparsevec } from 'drizzle-orm/pg-core';
@@ -33,59 +35,59 @@ test('example', async () => {
     .from(items)
     .orderBy(l2Distance(items.embedding, [1, 1, 1]))
     .limit(5);
-  expect(allItems.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
-  expect(allItems[0].embedding).toStrictEqual([1, 1, 1]);
-  expect(allItems[1].embedding).toStrictEqual([1, 1, 2]);
-  expect(allItems[2].embedding).toStrictEqual([2, 2, 2]);
+  assert.deepEqual(allItems.map(v => v.id), [1, 3, 2, 4]);
+  assert.deepEqual(allItems[0].embedding, [1, 1, 1]);
+  assert.deepEqual(allItems[1].embedding, [1, 1, 2]);
+  assert.deepEqual(allItems[2].embedding, [2, 2, 2]);
 
   // L2 distance - halfvec
   allItems = await db.select()
     .from(items)
     .orderBy(l2Distance(items.halfEmbedding, [1, 1, 1]))
     .limit(5);
-  expect(allItems.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(allItems.map(v => v.id), [1, 3, 2, 4]);
 
   // L2 distance - sparsevec
   allItems = await db.select()
     .from(items)
     .orderBy(l2Distance(items.sparseEmbedding, new SparseVector([1, 1, 1])))
     .limit(5);
-  expect(allItems.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(allItems.map(v => v.id), [1, 3, 2, 4]);
 
   // max inner product
   allItems = await db.select()
     .from(items)
     .orderBy(innerProduct(items.embedding, [1, 1, 1]))
     .limit(5);
-  expect(allItems.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(allItems.map(v => v.id), [2, 3, 1, 4]);
 
   // cosine distance
   allItems = await db.select()
     .from(items)
     .orderBy(cosineDistance(items.embedding, [1, 1, 1]))
     .limit(5);
-  expect(allItems.map(v => v.id).slice(2)).toStrictEqual([3, 4]);
+  assert.deepEqual(allItems.map(v => v.id).slice(2), [3, 4]);
 
   // L1 distance
   allItems = await db.select()
     .from(items)
     .orderBy(l1Distance(items.embedding, [1, 1, 1]))
     .limit(5);
-  expect(allItems.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(allItems.map(v => v.id), [1, 3, 2, 4]);
 
   // Hamming distance
   allItems = await db.select()
     .from(items)
     .orderBy(hammingDistance(items.binaryEmbedding, '101'))
     .limit(5);
-  expect(allItems.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(allItems.map(v => v.id), [2, 3, 1, 4]);
 
   // Jaccard distance
   allItems = await db.select()
     .from(items)
     .orderBy(jaccardDistance(items.binaryEmbedding, '101'))
     .limit(5);
-  expect(allItems.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(allItems.map(v => v.id), [2, 3, 1, 4]);
 
   await client.end();
 });

tests/knex/index.test.mjs

@@ -1,3 +1,5 @@
+import assert from 'node:assert';
+import test from 'node:test';
 import Knex from 'knex';
 import pgvector from 'pgvector/knex';
 import { SparseVector } from 'pgvector';
@@ -30,52 +32,52 @@ test('example', async () => {
   let items = await knex('knex_items')
     .orderBy(knex.l2Distance('embedding', [1, 1, 1]))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
-  expect(pgvector.fromSql(items[0].embedding)).toStrictEqual([1, 1, 1]);
-  expect(pgvector.fromSql(items[1].embedding)).toStrictEqual([1, 1, 2]);
-  expect(pgvector.fromSql(items[2].embedding)).toStrictEqual([2, 2, 2]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
+  assert.deepEqual(pgvector.fromSql(items[0].embedding), [1, 1, 1]);
+  assert.deepEqual(pgvector.fromSql(items[1].embedding), [1, 1, 2]);
+  assert.deepEqual(pgvector.fromSql(items[2].embedding), [2, 2, 2]);
 
   // L2 distance - halfvec
   items = await knex('knex_items')
     .orderBy(knex.l2Distance('half_embedding', [1, 1, 1]))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
 
   // L2 distance - sparsevec
   items = await knex('knex_items')
     .orderBy(knex.l2Distance('sparse_embedding', new SparseVector([1, 1, 1])))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
 
   // max inner product
   items = await knex('knex_items')
     .orderBy(knex.maxInnerProduct('embedding', [1, 1, 1]))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(items.map(v => v.id), [2, 3, 1, 4]);
 
   // cosine distance
   items = await knex('knex_items')
     .orderBy(knex.cosineDistance('embedding', [1, 1, 1]))
     .limit(5);
-  expect(items.map(v => v.id).slice(2)).toStrictEqual([3, 4]);
+  assert.deepEqual(items.map(v => v.id).slice(2), [3, 4]);
 
   // L1 distance
   items = await knex('knex_items')
     .orderBy(knex.l1Distance('embedding', [1, 1, 1]))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
 
   // Hamming distance
   items = await knex('knex_items')
     .orderBy(knex.hammingDistance('binary_embedding', '101'))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(items.map(v => v.id), [2, 3, 1, 4]);
 
   // Jaccard distance
   items = await knex('knex_items')
     .orderBy(knex.jaccardDistance('binary_embedding', '101'))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(items.map(v => v.id), [2, 3, 1, 4]);
 
   await knex.schema.alterTable('knex_items', function (table) {
     table.index(knex.raw('embedding vector_l2_ops'), 'knex_items_embedding_idx', 'hnsw');

tests/kysely/index.test.mjs

@@ -1,3 +1,5 @@
+import assert from 'node:assert';
+import test from 'node:test';
 import pg from 'pg';
 import { Kysely, PostgresDialect, sql } from 'kysely';
 import pgvector from 'pgvector/kysely';
@@ -45,66 +47,66 @@ test('example', async () => {
     .orderBy(l2Distance('embedding', [1, 1, 1]))
     .limit(5)
     .execute();
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
-  expect(pgvector.fromSql(items[0].embedding)).toStrictEqual([1, 1, 1]);
-  expect(pgvector.fromSql(items[1].embedding)).toStrictEqual([1, 1, 2]);
-  expect(pgvector.fromSql(items[2].embedding)).toStrictEqual([2, 2, 2]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
+  assert.deepEqual(pgvector.fromSql(items[0].embedding), [1, 1, 1]);
+  assert.deepEqual(pgvector.fromSql(items[1].embedding), [1, 1, 2]);
+  assert.deepEqual(pgvector.fromSql(items[2].embedding), [2, 2, 2]);
 
   // L2 distance - halfvec
   items = await db.selectFrom('kysely_items')
     .selectAll()
     .orderBy(l2Distance('half_embedding', [1, 1, 1]))
     .limit(5)
     .execute();
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
 
   // L2 distance - sparsevec
   items = await db.selectFrom('kysely_items')
     .selectAll()
     .orderBy(l2Distance('sparse_embedding', new SparseVector([1, 1, 1])))
     .limit(5)
     .execute();
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
 
   // max inner product
   items = await db.selectFrom('kysely_items')
     .selectAll()
     .orderBy(maxInnerProduct('embedding', [1, 1, 1]))
     .limit(5)
     .execute();
-  expect(items.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(items.map(v => v.id), [2, 3, 1, 4]);
 
   // cosine distance
   items = await db.selectFrom('kysely_items')
     .selectAll()
     .orderBy(cosineDistance('embedding', [1, 1, 1]))
     .limit(5)
     .execute();
-  expect(items.map(v => v.id).slice(2)).toStrictEqual([3, 4]);
+  assert.deepEqual(items.map(v => v.id).slice(2), [3, 4]);
 
   // L1 distance
   items = await db.selectFrom('kysely_items')
     .selectAll()
     .orderBy(l1Distance('embedding', [1, 1, 1]))
     .limit(5)
     .execute();
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
 
   // Hamming distance
   items = await db.selectFrom('kysely_items')
     .selectAll()
     .orderBy(hammingDistance('binary_embedding', '101'))
     .limit(5)
     .execute();
-  expect(items.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(items.map(v => v.id), [2, 3, 1, 4]);
 
   // Jaccard distance
   items = await db.selectFrom('kysely_items')
     .selectAll()
     .orderBy(jaccardDistance('binary_embedding', '101'))
     .limit(5)
     .execute();
-  expect(items.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(items.map(v => v.id), [2, 3, 1, 4]);
 
   await db.schema.createIndex('kysely_items_embedding_idx')
     .on('kysely_items')

tests/mikro-orm/index.test.mjs

@@ -1,3 +1,5 @@
+import assert from 'node:assert';
+import test from 'node:test';
 import { MikroORM, EntityManager, EntitySchema } from '@mikro-orm/postgresql';
 import { VectorType, HalfvecType, BitType, SparsevecType, l2Distance, maxInnerProduct, cosineDistance, l1Distance, hammingDistance, jaccardDistance } from 'pgvector/mikro-orm';
 import { SparseVector } from 'pgvector';
@@ -37,59 +39,59 @@ test('example', async () => {
     .orderBy({[l2Distance('embedding', [1, 1, 1])]: 'ASC'})
     .limit(5)
     .getResult();
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
-  expect(items[0].embedding).toStrictEqual([1, 1, 1]);
-  expect(items[1].embedding).toStrictEqual([1, 1, 2]);
-  expect(items[2].embedding).toStrictEqual([2, 2, 2]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
+  assert.deepEqual(items[0].embedding, [1, 1, 1]);
+  assert.deepEqual(items[1].embedding, [1, 1, 2]);
+  assert.deepEqual(items[2].embedding, [2, 2, 2]);
 
   // L2 distance - halfvec
   items = await em.createQueryBuilder(Item)
     .orderBy({[l2Distance('half_embedding', [1, 1, 1])]: 'ASC'})
     .limit(5)
     .getResult();
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
 
   // L2 distance - sparsevec
   items = await em.createQueryBuilder(Item)
     .orderBy({[l2Distance('sparse_embedding', new SparseVector([1, 1, 1]))]: 'ASC'})
     .limit(5)
     .getResult();
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
 
   // max inner product
   items = await em.createQueryBuilder(Item)
     .orderBy({[maxInnerProduct('embedding', [1, 1, 1])]: 'ASC'})
     .limit(5)
     .getResult();
-  expect(items.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(items.map(v => v.id), [2, 3, 1, 4]);
 
   // cosine distance
   items = await em.createQueryBuilder(Item)
     .orderBy({[cosineDistance('embedding', [1, 1, 1])]: 'ASC'})
     .limit(5)
     .getResult();
-  expect(items.map(v => v.id).slice(2)).toStrictEqual([3, 4]);
+  assert.deepEqual(items.map(v => v.id).slice(2), [3, 4]);
 
   // L1 distance
   items = await em.createQueryBuilder(Item)
     .orderBy({[l1Distance('embedding', [1, 1, 1])]: 'ASC'})
     .limit(5)
     .getResult();
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
 
   // Hamming distance
   items = await em.createQueryBuilder(Item)
     .orderBy({[hammingDistance('binary_embedding', '101')]: 'ASC'})
     .limit(5)
     .getResult();
-  expect(items.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(items.map(v => v.id), [2, 3, 1, 4]);
 
   // Jaccard distance
   items = await em.createQueryBuilder(Item)
     .orderBy({[jaccardDistance('binary_embedding', '101')]: 'ASC'})
     .limit(5)
     .getResult();
-  expect(items.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(items.map(v => v.id), [2, 3, 1, 4]);
 
   orm.close();
 });

tests/objection/index.test.mjs

@@ -1,3 +1,5 @@
+import assert from 'node:assert';
+import test from 'node:test';
 import Knex from 'knex';
 import { Model } from 'objection';
 import pgvector from 'pgvector/objection';
@@ -40,52 +42,52 @@ test('example', async () => {
   let items = await Item.query()
     .orderBy(l2Distance('embedding', [1, 1, 1]))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
-  expect(pgvector.fromSql(items[0].embedding)).toStrictEqual([1, 1, 1]);
-  expect(pgvector.fromSql(items[1].embedding)).toStrictEqual([1, 1, 2]);
-  expect(pgvector.fromSql(items[2].embedding)).toStrictEqual([2, 2, 2]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
+  assert.deepEqual(pgvector.fromSql(items[0].embedding), [1, 1, 1]);
+  assert.deepEqual(pgvector.fromSql(items[1].embedding), [1, 1, 2]);
+  assert.deepEqual(pgvector.fromSql(items[2].embedding), [2, 2, 2]);
 
   // L2 distance - halfvec
   items = await Item.query()
     .orderBy(l2Distance('half_embedding', [1, 1, 1]))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
 
   // L2 distance - sparsevec
   items = await Item.query()
     .orderBy(l2Distance('sparse_embedding', new SparseVector([1, 1, 1])))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
 
   // max inner product
   items = await Item.query()
     .orderBy(maxInnerProduct('embedding', [1, 1, 1]))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(items.map(v => v.id), [2, 3, 1, 4]);
 
   // cosine distance
   items = await Item.query()
     .orderBy(cosineDistance('embedding', [1, 1, 1]))
     .limit(5);
-  expect(items.map(v => v.id).slice(2)).toStrictEqual([3, 4]);
+  assert.deepEqual(items.map(v => v.id).slice(2), [3, 4]);
 
   // L1 distance
   items = await Item.query()
     .orderBy(l1Distance('embedding', [1, 1, 1]))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([1, 3, 2, 4]);
+  assert.deepEqual(items.map(v => v.id), [1, 3, 2, 4]);
 
   // Hamming distance
   items = await Item.query()
     .orderBy(hammingDistance('binary_embedding', '101'))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(items.map(v => v.id), [2, 3, 1, 4]);
 
   // Jaccard distance
   items = await Item.query()
     .orderBy(jaccardDistance('binary_embedding', '101'))
     .limit(5);
-  expect(items.map(v => v.id)).toStrictEqual([2, 3, 1, 4]);
+  assert.deepEqual(items.map(v => v.id), [2, 3, 1, 4]);
 
   await knex.schema.alterTable('objection_items', function (table) {
     table.index(knex.raw('embedding vector_l2_ops'), 'objection_items_embedding_idx', 'hnsw');