@wovin/core 0.0.0-ciao-mobx-955482e8

package/src/query/query.test.ts

@@ -0,0 +1,536 @@
+/**
+ * Query engine test suite — tests the push-based query system.
+ *
+ * Part 1: Non-reactive (snapshot) tests — verify query correctness without subscriptions
+ * Part 2: Reactive tests — verify subscribe, insert, event propagation, lazy activation
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { sortApplogsByTs } from '../applog/applog-utils.ts'
+import type { Applog, ApplogForInsert } from '../applog/datom-types.ts'
+import { isInitEvent } from '../thread/basic.ts'
+import { ThreadInMemory } from '../thread/writeable.ts'
+import { liveQuery, liveQueryNot, query, queryNot } from './basic.ts'
+import { isArrayInitEvent, type ArrayEvent } from './subscribable.ts'
+import { QueryNode, QueryResult, LiveQueryResult } from './types.ts'
+
+// ─── Test Data ───────────────────────────────────────────────────
+// A small movie database — same schema as note3's test-applogs but
+// with explicit CIDs and a smaller dataset for focused testing.
+
+function makeApplogs(inputs: ApplogForInsert[]): Applog[] {
+	// Cast to Applog[] — ThreadInMemory.fromArray accepts this (CIDs are absent,
+	// same as note3's existing test pattern). Validation is loose for initial data.
+	const logs = inputs.map(input => ({
+		ts: new Date().toISOString(),
+		pv: null,
+		ag: 'testAgent',
+		...input,
+	})) as Applog[]
+	sortApplogsByTs(logs)
+	return logs
+}
+
+// Base dataset
+const baseData: ApplogForInsert[] = [
+	// People
+	{ en: 'p1', at: 'person/name', vl: 'James Cameron', ag: 'testAgent' },
+	{ en: 'p2', at: 'person/name', vl: 'Arnold Schwarzenegger', ag: 'testAgent' },
+	{ en: 'p3', at: 'person/name', vl: 'Linda Hamilton', ag: 'testAgent' },
+	{ en: 'p4', at: 'person/name', vl: 'John McTiernan', ag: 'testAgent' },
+	{ en: 'p5', at: 'person/name', vl: 'Bruce Willis', ag: 'testAgent' },
+
+	// Movies
+	{ en: 'm1', at: 'movie/title', vl: 'The Terminator', ag: 'testAgent' },
+	{ en: 'm1', at: 'movie/year', vl: 1984, ag: 'testAgent' },
+	{ en: 'm1', at: 'movie/director', vl: 'p1', ag: 'testAgent' },
+	{ en: 'm1', at: 'movie/cast', vl: 'p2', ag: 'testAgent' },
+	{ en: 'm1', at: 'movie/cast', vl: 'p3', ag: 'testAgent' },
+
+	{ en: 'm2', at: 'movie/title', vl: 'Predator', ag: 'testAgent' },
+	{ en: 'm2', at: 'movie/year', vl: 1987, ag: 'testAgent' },
+	{ en: 'm2', at: 'movie/director', vl: 'p4', ag: 'testAgent' },
+	{ en: 'm2', at: 'movie/cast', vl: 'p2', ag: 'testAgent' },
+
+	{ en: 'm3', at: 'movie/title', vl: 'Die Hard', ag: 'testAgent' },
+	{ en: 'm3', at: 'movie/year', vl: 1988, ag: 'testAgent' },
+	{ en: 'm3', at: 'movie/director', vl: 'p4', ag: 'testAgent' },
+	{ en: 'm3', at: 'movie/cast', vl: 'p5', ag: 'testAgent' },
+
+	{ en: 'm4', at: 'movie/title', vl: 'T2: Judgment Day', ag: 'testAgent' },
+	{ en: 'm4', at: 'movie/year', vl: 1991, ag: 'testAgent' },
+	{ en: 'm4', at: 'movie/director', vl: 'p1', ag: 'testAgent' },
+	{ en: 'm4', at: 'movie/cast', vl: 'p2', ag: 'testAgent' },
+	{ en: 'm4', at: 'movie/cast', vl: 'p3', ag: 'testAgent' },
+]
+
+// ─── Helpers ─────────────────────────────────────────────────────
+
+let db: ReturnType<typeof ThreadInMemory.fromArray>
+
+beforeEach(() => {
+	db = ThreadInMemory.fromArray(makeApplogs(baseData), 'test-movies')
+})
+
+afterEach(() => {
+	// Fresh db is created in beforeEach — no global state to reset
+})
+
+// ═════════════════════════════════════════════════════════════════
+// PART 1: Non-reactive (snapshot) tests
+// ═════════════════════════════════════════════════════════════════
+
+describe('query engine — non-reactive', () => {
+	describe('single-step query', () => {
+		it('finds all movies by year', () => {
+			const result = query(db, [{ at: 'movie/year', vl: 1987 }])
+			expect(result.nodes).toHaveLength(1)
+			expect(result.nodes[0].variables).toMatchObject({ })
+			expect(result.nodes[0].logsOfThisNode.applogs[0].en).toBe('m2')
+		})
+
+		it('finds all movies with a specific attribute', () => {
+			const result = query(db, [{ at: 'movie/title' }])
+			expect(result.nodes).toHaveLength(4) // 4 movies
+		})
+
+		it('finds by entity and attribute', () => {
+			const result = query(db, [{ en: 'p1', at: 'person/name' }])
+			expect(result.nodes).toHaveLength(1)
+			expect(result.nodes[0].logsOfThisNode.applogs[0].vl).toBe('James Cameron')
+		})
+
+		it('returns empty for no matches', () => {
+			const result = query(db, [{ at: 'movie/year', vl: 2099 }])
+			expect(result.nodes).toHaveLength(0)
+			expect(result.isEmpty).toBe(true)
+			expect(result.size).toBe(0)
+		})
+	})
+
+	describe('multi-step query (variable binding)', () => {
+		it('resolves variable across two steps', () => {
+			// Find directors of 1987 movies
+			const result = query(db, [
+				{ en: '?movieId', at: 'movie/year', vl: 1987 },
+				{ en: '?movieId', at: 'movie/director', vl: '?directorId' },
+			])
+			expect(result.records).toEqual([
+				{ movieId: 'm2', directorId: 'p4' },
+			])
+		})
+
+		it('resolves three-step query (movie → director → name)', () => {
+			// Find names of directors of 1984 movies
+			const result = query(db, [
+				{ en: '?movieId', at: 'movie/year', vl: 1984 },
+				{ en: '?movieId', at: 'movie/director', vl: '?directorId' },
+				{ en: '?directorId', at: 'person/name', vl: '?directorName' },
+			])
+			expect(result.records).toEqual([
+				{ movieId: 'm1', directorId: 'p1', directorName: 'James Cameron' },
+			])
+		})
+
+		it('fan-out: multiple results per step', () => {
+			// Find all cast of 1984 movies
+			const result = query(db, [
+				{ en: '?movieId', at: 'movie/year', vl: 1984 },
+				{ en: '?movieId', at: 'movie/cast', vl: '?actorId' },
+			])
+			expect(result.records).toHaveLength(2) // p2, p3
+			const actorIds = result.records.map(r => r.actorId).sort()
+			expect(actorIds).toEqual(['p2', 'p3'])
+		})
+
+		it('fan-out across multiple input nodes', () => {
+			// Arnold's movies: find movies where p2 is cast, get titles
+			const result = query(db, [
+				{ en: '?movieId', at: 'movie/cast', vl: 'p2' },
+				{ en: '?movieId', at: 'movie/title', vl: '?title' },
+			])
+			const titles = result.records.map(r => r.title).sort()
+			expect(titles).toEqual(['Predator', 'T2: Judgment Day', 'The Terminator'])
+		})
+
+		it('four-step query', () => {
+			// Actor name → movies → director → director name
+			const result = query(db, [
+				{ en: '?actorId', at: 'person/name', vl: 'Arnold Schwarzenegger' },
+				{ en: '?movieId', at: 'movie/cast', vl: '?actorId' },
+				{ en: '?movieId', at: 'movie/director', vl: '?directorId' },
+				{ en: '?directorId', at: 'person/name', vl: '?directorName' },
+			])
+			const directors = result.records.map(r => r.directorName).sort()
+			expect(directors).toEqual(['James Cameron', 'James Cameron', 'John McTiernan'])
+		})
+	})
+
+	describe('QueryResult derived getters', () => {
+		it('.records returns variable maps', () => {
+			const result = query(db, [{ en: '?id', at: 'movie/title', vl: '?title' }])
+			expect(result.records).toHaveLength(4)
+			expect(result.records[0]).toHaveProperty('id')
+			expect(result.records[0]).toHaveProperty('title')
+		})
+
+		it('.size and .isEmpty', () => {
+			const result = query(db, [{ at: 'movie/title' }])
+			expect(result.size).toBe(4)
+			expect(result.isEmpty).toBe(false)
+
+			const empty = query(db, [{ at: 'nonexistent' }])
+			expect(empty.size).toBe(0)
+			expect(empty.isEmpty).toBe(true)
+		})
+
+		it('.leafNodeLogs returns applogs of leaf nodes', () => {
+			const result = query(db, [{ en: 'm1', at: 'movie/title' }])
+			expect(result.leafNodeLogs).toHaveLength(1)
+			expect(result.leafNodeLogs[0].vl).toBe('The Terminator')
+		})
+
+		it.skip('.threadOfAllTrails joins all trail threads (requires CID-bearing applogs)', () => {
+			// Skipped: joinThreads → removeDuplicateAppLogs requires CIDs on applogs.
+			// Our test data omits CIDs (same as note3's test pattern).
+			// This getter delegates to joinThreads which is tested separately.
+		})
+	})
+
+	describe('one-off use (zero overhead)', () => {
+		it('query result is immediately available without subscribe', () => {
+			const result = query(db, [{ at: 'movie/title' }])
+			// No subscribe() call — items are available immediately
+			expect(result.nodes).toHaveLength(4)
+			expect(result.records).toHaveLength(4)
+		})
+
+		it('query returns QueryResult without subscribe/dispose', () => {
+			const result = query(db, [{ at: 'movie/title' }])
+			expect(result).toBeInstanceOf(QueryResult)
+			expect(result).not.toHaveProperty('subscribe')
+			expect(result).not.toHaveProperty('dispose')
+		})
+	})
+})
+
+// ═════════════════════════════════════════════════════════════════
+// PART 2: Reactive tests
+// ═════════════════════════════════════════════════════════════════
+
+describe('liveQuery — reactive', () => {
+	describe('subscribe basics', () => {
+		it('liveQuery returns LiveQueryResult', () => {
+			const result = liveQuery(db, [{ at: 'movie/title' }])
+			expect(result).toBeInstanceOf(LiveQueryResult)
+			expect(result.nodes).toHaveLength(4)
+			result.dispose()
+		})
+
+		it('subscribe does NOT send init event — read .nodes for current state', () => {
+			const result = liveQuery(db, [{ at: 'movie/title' }])
+			const events: ArrayEvent<QueryNode>[] = []
+			const unsub = result.subscribe(e => events.push(e))
+
+			// No init event fired
+			expect(events).toHaveLength(0)
+			// Current state available via .nodes
+			expect(result.nodes).toHaveLength(4)
+			unsub()
+			result.dispose()
+		})
+
+		it('unsubscribe cleans up without error', () => {
+			const result = liveQuery(db, [{ at: 'movie/title' }])
+			const unsub = result.subscribe(() => {})
+			expect(() => unsub()).not.toThrow()
+			result.dispose()
+		})
+	})
+
+	describe('single-step reactive updates', () => {
+		it('receives added event after insert', () => {
+			const result = liveQuery(db, [{ at: 'movie/year', vl: 1987 }])
+			const events: ArrayEvent<QueryNode>[] = []
+			const unsub = result.subscribe(e => events.push(e))
+
+			expect(events).toHaveLength(0)
+			expect(result.nodes).toHaveLength(1)
+
+			db.insert([
+				{ en: 'm5', at: 'movie/year', vl: 1987, ag: 'testAgent' },
+			])
+
+			expect(events.length).toBeGreaterThan(0)
+			const addedEvents = events.filter(e => !isArrayInitEvent(e))
+			expect(addedEvents.length).toBeGreaterThan(0)
+			expect(result.nodes).toHaveLength(2)
+
+			unsub()
+			result.dispose()
+		})
+
+		it('items update live after insert', () => {
+			const result = liveQuery(db, [{ en: '?id', at: 'movie/title', vl: '?title' }])
+
+			const titlesBefore = result.records.map(r => r.title).sort()
+			expect(titlesBefore).toEqual(['Die Hard', 'Predator', 'T2: Judgment Day', 'The Terminator'])
+
+			db.insert([
+				{ en: 'm5', at: 'movie/title', vl: 'Aliens', ag: 'testAgent' },
+			])
+
+			const titlesAfter = result.records.map(r => r.title).sort()
+			expect(titlesAfter).toEqual(['Aliens', 'Die Hard', 'Predator', 'T2: Judgment Day', 'The Terminator'])
+
+			result.dispose()
+		})
+
+		it('does not receive events after unsubscribe', () => {
+			const result = liveQuery(db, [{ at: 'movie/year', vl: 1987 }])
+			const cb = vi.fn()
+			const unsub = result.subscribe(cb)
+
+			expect(cb).toHaveBeenCalledTimes(0)
+			unsub()
+
+			db.insert([
+				{ en: 'm5', at: 'movie/year', vl: 1987, ag: 'testAgent' },
+			])
+
+			// Activation unsub still holds, but user callback is gone
+			expect(cb).toHaveBeenCalledTimes(0)
+			result.dispose()
+		})
+	})
+
+	describe('multi-step reactive updates', () => {
+		it('propagates insert through multi-step query', () => {
+			const result = liveQuery(db, [
+				{ en: '?movieId', at: 'movie/year', vl: 1984 },
+				{ en: '?movieId', at: 'movie/director', vl: '?directorId' },
+				{ en: '?directorId', at: 'person/name', vl: '?directorName' },
+			])
+
+			expect(result.records).toEqual([
+				{ movieId: 'm1', directorId: 'p1', directorName: 'James Cameron' },
+			])
+
+			db.insert([
+				{ en: 'm5', at: 'movie/year', vl: 1984, ag: 'testAgent' },
+				{ en: 'm5', at: 'movie/director', vl: 'p4', ag: 'testAgent' },
+			])
+
+			const directorNames = result.records.map(r => r.directorName).sort()
+			expect(directorNames).toContain('James Cameron')
+			expect(directorNames).toContain('John McTiernan')
+
+			result.dispose()
+		})
+
+		it('new data in step 2 propagates to existing step 1 results', () => {
+			const result = liveQuery(db, [
+				{ en: '?movieId', at: 'movie/director', vl: 'p1' },
+				{ en: '?movieId', at: 'movie/cast', vl: '?actorId' },
+			])
+
+			const actorsBefore = result.records.map(r => r.actorId).sort()
+			expect(actorsBefore).toEqual(['p2', 'p2', 'p3', 'p3'])
+
+			db.insert([
+				{ en: 'm1', at: 'movie/cast', vl: 'p5', ag: 'testAgent' },
+			])
+
+			const actorsAfter = result.records.map(r => r.actorId).sort()
+			expect(actorsAfter).toContain('p5')
+			expect(actorsAfter.length).toBe(5)
+
+			result.dispose()
+		})
+	})
+
+	describe('eagerly activated — always up-to-date', () => {
+		it('nodes update without explicit subscribe', () => {
+			const result = liveQuery(db, [{ at: 'movie/year', vl: 1987 }])
+			expect(result.nodes).toHaveLength(1)
+
+			// Insert — liveQuery is eagerly activated, so it tracks changes
+			db.insert([
+				{ en: 'm5', at: 'movie/year', vl: 1987, ag: 'testAgent' },
+			])
+
+			expect(result.nodes).toHaveLength(2)
+			result.dispose()
+		})
+	})
+
+	describe('dispose', () => {
+		it('dispose tears down subscriptions', () => {
+			const result = liveQuery(db, [{ at: 'movie/title' }])
+			const cb = vi.fn()
+			result.subscribe(cb)
+
+			expect(cb).toHaveBeenCalledTimes(0)
+
+			db.insert([
+				{ en: 'm5', at: 'movie/title', vl: 'Aliens', ag: 'testAgent' },
+			])
+			expect(cb).toHaveBeenCalledTimes(1)
+
+			result.dispose()
+
+			db.insert([
+				{ en: 'm6', at: 'movie/title', vl: 'Alien 3', ag: 'testAgent' },
+			])
+
+			expect(cb).toHaveBeenCalledTimes(1)
+		})
+	})
+
+	describe('event batching', () => {
+		it('multi-step fires single event per upstream change', () => {
+			const result = liveQuery(db, [
+				{ en: '?movieId', at: 'movie/year', vl: 1984 },
+				{ en: '?movieId', at: 'movie/cast', vl: '?actorId' },
+			])
+			const events: ArrayEvent<QueryNode>[] = []
+			const unsub = result.subscribe(e => events.push(e))
+
+			db.insert([
+				{ en: 'm5', at: 'movie/year', vl: 1984, ag: 'testAgent' },
+			])
+			db.insert([
+				{ en: 'm5', at: 'movie/cast', vl: 'p4', ag: 'testAgent' },
+			])
+			db.insert([
+				{ en: 'm5', at: 'movie/cast', vl: 'p5', ag: 'testAgent' },
+			])
+
+			expect(events.length).toBeLessThanOrEqual(6)
+
+			unsub()
+			result.dispose()
+		})
+	})
+
+	describe('memoization', () => {
+		it('same args return same LiveQueryResult instance', () => {
+			const r1 = liveQuery(db, [{ at: 'movie/title' }])
+			const r2 = liveQuery(db, [{ at: 'movie/title' }])
+			expect(r1).toBe(r2)
+			r1.dispose()
+		})
+
+		it('different args return different instances', () => {
+			const r1 = liveQuery(db, [{ at: 'movie/title' }])
+			const r2 = liveQuery(db, [{ at: 'movie/year' }])
+			expect(r1).not.toBe(r2)
+			r1.dispose()
+			r2.dispose()
+		})
+	})
+})
+
+// ═════════════════════════════════════════════════════════════════
+// PART 3: liveQueryNot — incremental NOT-filter
+// ═════════════════════════════════════════════════════════════════
+
+describe('liveQueryNot', () => {
+	// Schema: movies have directors. queryNot finds movies WITHOUT a director.
+	let db: ReturnType<typeof ThreadInMemory.fromArray>
+
+	beforeEach(() => {
+		db = ThreadInMemory.fromArray(makeApplogs([
+			{ en: 'm1', at: 'movie/title', vl: 'The Terminator', ag: 'a' },
+			{ en: 'm2', at: 'movie/title', vl: 'Predator', ag: 'a' },
+			{ en: 'm3', at: 'movie/title', vl: 'Die Hard', ag: 'a' },
+			// m1 and m2 have directors, m3 does not
+			{ en: 'm1', at: 'movie/director', vl: 'James Cameron', ag: 'a' },
+			{ en: 'm2', at: 'movie/director', vl: 'John McTiernan', ag: 'a' },
+		]), 'test-qnot')
+	})
+
+	it('snapshot queryNot: excludes nodes matching the pattern', () => {
+		const movies = query(db, [{ en: '?id', at: 'movie/title' }])
+		const noDirector = queryNot(db, movies, [{ en: '?id', at: 'movie/director' }])
+		expect(noDirector.records.map(r => r.id)).toEqual(['m3'])
+	})
+
+	it('initial state matches snapshot queryNot', () => {
+		const upstream = liveQuery(db, [{ en: '?id', at: 'movie/title' }])
+		const result = liveQueryNot(db, upstream, [{ en: '?id', at: 'movie/director' }])
+
+		expect(result.nodes).toHaveLength(1)
+		expect(result.nodes[0].variables.id).toBe('m3')
+
+		result.dispose()
+		upstream.dispose()
+	})
+
+	it('incrementally removes node when new applog matches NOT pattern', () => {
+		const upstream = liveQuery(db, [{ en: '?id', at: 'movie/title' }])
+		const result = liveQueryNot(db, upstream, [{ en: '?id', at: 'movie/director' }])
+
+		expect(result.nodes).toHaveLength(1) // m3 has no director
+
+		// Give m3 a director — should be excluded now
+		db.insert([{ en: 'm3', at: 'movie/director', vl: 'John McTiernan', ag: 'a' }])
+
+		expect(result.nodes).toHaveLength(0)
+
+		result.dispose()
+		upstream.dispose()
+	})
+
+	it('includes new upstream node that passes NOT filter', () => {
+		const upstream = liveQuery(db, [{ en: '?id', at: 'movie/title' }])
+		const result = liveQueryNot(db, upstream, [{ en: '?id', at: 'movie/director' }])
+
+		expect(result.nodes).toHaveLength(1) // m3
+
+		// Add a new movie WITHOUT a director
+		db.insert([{ en: 'm4', at: 'movie/title', vl: 'Aliens', ag: 'a' }])
+
+		expect(result.nodes).toHaveLength(2)
+		expect(result.records.map(r => r.id).sort()).toEqual(['m3', 'm4'])
+
+		result.dispose()
+		upstream.dispose()
+	})
+
+	it('excludes new upstream node that fails NOT filter', () => {
+		const upstream = liveQuery(db, [{ en: '?id', at: 'movie/title' }])
+		const result = liveQueryNot(db, upstream, [{ en: '?id', at: 'movie/director' }])
+
+		expect(result.nodes).toHaveLength(1)
+
+		// Add a new movie WITH a director (both in same batch)
+		db.insert([
+			{ en: 'm4', at: 'movie/title', vl: 'Aliens', ag: 'a' },
+			{ en: 'm4', at: 'movie/director', vl: 'James Cameron', ag: 'a' },
+		])
+
+		// m4 should NOT appear (has director)
+		expect(result.records.map(r => r.id)).toEqual(['m3'])
+
+		result.dispose()
+		upstream.dispose()
+	})
+
+	it('fires subscribe events on changes', () => {
+		const upstream = liveQuery(db, [{ en: '?id', at: 'movie/title' }])
+		const result = liveQueryNot(db, upstream, [{ en: '?id', at: 'movie/director' }])
+		const events: ArrayEvent<QueryNode>[] = []
+		const unsub = result.subscribe(e => events.push(e))
+
+		expect(events).toHaveLength(0) // no init on subscribe
+
+		// Adding director to m3 removes it
+		db.insert([{ en: 'm3', at: 'movie/director', vl: 'Someone', ag: 'a' }])
+
+		expect(events.length).toBeGreaterThan(0)
+
+		unsub()
+		result.dispose()
+		upstream.dispose()
+	})
+})