@dxos/echo-atom 0.0.0 → 0.8.4-main.03d5cd7b56

package/src/batching.test.ts

@@ -6,13 +6,13 @@ import * as Registry from '@effect-atom/atom/Registry';
 import { describe, expect, test } from 'vitest';
 
 import { Obj } from '@dxos/echo';
-import { TestSchema } from '@dxos/echo/testing';
 import { createObject } from '@dxos/echo-db';
+import { TestSchema } from '@dxos/echo/testing';
 
 import * as AtomObj from './atom';
 
 describe('Echo Atom - Batch Updates', () => {
-  test('multiple updates to same object atom in single Obj.change fire single update', () => {
+  test('multiple updates to same object atom in single Obj.update fire single update', () => {
     const obj = createObject(
       Obj.make(TestSchema.Person, { name: 'Test', username: 'test', email: 'test@example.com' }),
     );
@@ -33,14 +33,14 @@ describe('Echo Atom - Batch Updates', () => {
     const initialCount = updateCount;
     expect(initialCount).toBe(1); // Verify immediate update fired.
 
-    // Make multiple updates to the same object in a single Obj.change call.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated1';
-      o.email = 'updated@example.com';
-      o.username = 'updated';
+    // Make multiple updates to the same object in a single Obj.update call.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated1';
+      obj.email = 'updated@example.com';
+      obj.username = 'updated';
     });
 
-    // Should have fired once for initial + once for the Obj.change (not once per property update).
+    // Should have fired once for initial + once for the Obj.update (not once per property update).
     expect(updateCount).toBe(2);
 
     // Verify final state.
@@ -50,7 +50,7 @@ describe('Echo Atom - Batch Updates', () => {
     expect(finalValue.username).toBe('updated');
   });
 
-  test('multiple separate Obj.change calls fire separate updates', () => {
+  test('multiple separate Obj.update calls fire separate updates', () => {
     const obj = createObject(
       Obj.make(TestSchema.Person, { name: 'Test', username: 'test', email: 'test@example.com' }),
     );
@@ -71,18 +71,18 @@ describe('Echo Atom - Batch Updates', () => {
     const initialCount = updateCount;
     expect(initialCount).toBe(1);
 
-    // Make multiple separate Obj.change calls.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated1';
+    // Make multiple separate Obj.update calls.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated1';
     });
-    Obj.change(obj, (o) => {
-      o.email = 'updated@example.com';
+    Obj.update(obj, (obj) => {
+      obj.email = 'updated@example.com';
     });
-    Obj.change(obj, (o) => {
-      o.username = 'updated';
+    Obj.update(obj, (obj) => {
+      obj.username = 'updated';
     });
 
-    // Should have fired once for initial + once per Obj.change call.
+    // Should have fired once for initial + once per Obj.update call.
     expect(updateCount).toBe(4);
 
     // Verify final state.
@@ -92,7 +92,7 @@ describe('Echo Atom - Batch Updates', () => {
     expect(finalValue.username).toBe('updated');
   });
 
-  test('multiple updates to same property atom in single Obj.change fire single update', () => {
+  test('multiple updates to same property atom in single Obj.update fire single update', () => {
     const obj = createObject(
       Obj.make(TestSchema.Person, { name: 'Test', username: 'test', email: 'test@example.com' }),
     );
@@ -113,14 +113,14 @@ describe('Echo Atom - Batch Updates', () => {
     const initialCount = updateCount;
     expect(initialCount).toBe(1);
 
-    // Make multiple updates to the same property in a single Obj.change call.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated1';
-      o.name = 'Updated2';
-      o.name = 'Updated3';
+    // Make multiple updates to the same property in a single Obj.update call.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated1';
+      obj.name = 'Updated2';
+      obj.name = 'Updated3';
     });
 
-    // Should have fired once for initial + once for the Obj.change (not once per assignment).
+    // Should have fired once for initial + once for the Obj.update (not once per assignment).
     expect(updateCount).toBe(2);
 
     // Verify final state.

package/src/query-atom.test.ts

@@ -6,9 +6,13 @@ import * as Registry from '@effect-atom/atom/Registry';
 import * as Schema from 'effect/Schema';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
+import { sleep } from '@dxos/async';
 import { Obj, type QueryResult, Type } from '@dxos/echo';
-import { type EchoDatabase, Filter, Query } from '@dxos/echo-db';
+import { Filter, Query } from '@dxos/echo';
+import { type EchoDatabase, RuntimeSchemaRegistry } from '@dxos/echo-db';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { TestSchema } from '@dxos/echo/testing';
+import { SpaceId } from '@dxos/keys';
 
 import * as AtomQuery from './query-atom';
 
@@ -19,8 +23,8 @@ const TestItem = Schema.Struct({
   name: Schema.String,
   value: Schema.Number,
 }).pipe(
-  Type.Obj({
-    typename: 'example.com/type/TestItem',
+  Type.object({
+    typename: 'com.example.type.test-item',
     version: '0.1.0',
   }),
 );
@@ -45,7 +49,7 @@ describe('AtomQuery', () => {
   test('creates atom with initial results', async () => {
     db.add(Obj.make(TestItem, { name: 'Object 1', value: 100 }));
     db.add(Obj.make(TestItem, { name: 'Object 2', value: 100 }));
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const queryResult: QueryResult.QueryResult<TestItem> = db.query(
       Query.select(Filter.type(TestItem, { value: 100 })),
@@ -61,7 +65,7 @@ describe('AtomQuery', () => {
 
   test('registry.subscribe fires on QueryResult changes', async () => {
     db.add(Obj.make(TestItem, { name: 'Initial', value: 200 }));
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const queryResult: QueryResult.QueryResult<TestItem> = db.query(
       Query.select(Filter.type(TestItem, { value: 200 })),
@@ -84,7 +88,7 @@ describe('AtomQuery', () => {
 
     // Add a new object that matches the query.
     db.add(Obj.make(TestItem, { name: 'New Object', value: 200 }));
-    await db.flush({ indexes: true, updates: true });
+    await db.flush({ updates: true });
 
     // Subscription should have fired.
     expect(updateCount).toBeGreaterThan(0);
@@ -94,7 +98,7 @@ describe('AtomQuery', () => {
   test('registry.subscribe fires when objects are removed', async () => {
     const obj1 = db.add(Obj.make(TestItem, { name: 'Object 1', value: 300 }));
     db.add(Obj.make(TestItem, { name: 'Object 2', value: 300 }));
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const queryResult: QueryResult.QueryResult<TestItem> = db.query(
       Query.select(Filter.type(TestItem, { value: 300 })),
@@ -117,7 +121,7 @@ describe('AtomQuery', () => {
 
     // Remove an object.
     db.remove(obj1);
-    await db.flush({ indexes: true, updates: true });
+    await db.flush({ updates: true });
 
     // Subscription should have fired.
     expect(updateCount).toBeGreaterThan(0);
@@ -127,7 +131,7 @@ describe('AtomQuery', () => {
 
   test('unsubscribing from registry stops receiving updates', async () => {
     db.add(Obj.make(TestItem, { name: 'Initial', value: 400 }));
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const queryResult: QueryResult.QueryResult<TestItem> = db.query(
       Query.select(Filter.type(TestItem, { value: 400 })),
@@ -148,7 +152,7 @@ describe('AtomQuery', () => {
 
     // Add object and verify subscription fires.
     db.add(Obj.make(TestItem, { name: 'Object 2', value: 400 }));
-    await db.flush({ indexes: true, updates: true });
+    await db.flush({ updates: true });
     const countAfterFirstAdd = updateCount;
     expect(countAfterFirstAdd).toBeGreaterThan(0);
 
@@ -157,7 +161,7 @@ describe('AtomQuery', () => {
 
     // Add another object.
     db.add(Obj.make(TestItem, { name: 'Object 3', value: 400 }));
-    await db.flush({ indexes: true, updates: true });
+    await db.flush({ updates: true });
 
     // Update count should not have changed after unsubscribe.
     expect(updateCount).toBe(countAfterFirstAdd);
@@ -177,7 +181,7 @@ describe('AtomQuery', () => {
 
   test('multiple atoms from same query share underlying subscription', async () => {
     db.add(Obj.make(TestItem, { name: 'Object', value: 500 }));
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const queryResult: QueryResult.QueryResult<TestItem> = db.query(
       Query.select(Filter.type(TestItem, { value: 500 })),
@@ -198,3 +202,187 @@ describe('AtomQuery', () => {
     expect(results2[0].name).toBe('Object');
   });
 });
+
+describe('AtomQuery with queues', () => {
+  let testBuilder: EchoTestBuilder;
+  let registry: Registry.Registry;
+
+  beforeEach(async () => {
+    testBuilder = await new EchoTestBuilder().open();
+    registry = Registry.make();
+  });
+
+  afterEach(async () => {
+    await testBuilder.close();
+  });
+
+  test('AtomQuery.make with Filter.type on queue', async () => {
+    const peer = await testBuilder.createPeer({ types: [TestSchema.Person] });
+    const spaceId = SpaceId.random();
+    const queues = peer.client.constructQueueFactory(spaceId);
+    const queue = queues.create();
+
+    const john = Obj.make(TestSchema.Person, { name: 'john' });
+    const jane = Obj.make(TestSchema.Person, { name: 'jane' });
+    await queue.append([john, jane]);
+
+    // Verify queue.query works directly (sanity check).
+    const directResult = await queue.query(Query.select(Filter.type(TestSchema.Person))).run();
+    expect(directResult).toHaveLength(2);
+
+    // Now test AtomQuery.make.
+    const atom = AtomQuery.make<TestSchema.Person>(queue, Filter.type(TestSchema.Person));
+    const results = registry.get(atom);
+
+    expect(results).toHaveLength(2);
+    expect(results.map((r) => r.name).sort()).toEqual(['jane', 'john']);
+  });
+
+  test('AtomQuery.make with Filter.id on queue', async () => {
+    const peer = await testBuilder.createPeer({ types: [TestSchema.Person] });
+    const spaceId = SpaceId.random();
+    const queues = peer.client.constructQueueFactory(spaceId);
+    const queue = queues.create();
+
+    const john = Obj.make(TestSchema.Person, { name: 'john' });
+    const jane = Obj.make(TestSchema.Person, { name: 'jane' });
+    const alice = Obj.make(TestSchema.Person, { name: 'alice' });
+    await queue.append([john, jane, alice]);
+
+    // Verify queue.query works directly (sanity check).
+    const directResult = await queue.query(Query.select(Filter.id(jane.id))).run();
+    expect(directResult).toHaveLength(1);
+
+    // Use AtomQuery.make with Filter.id - this is what app-graph-builder uses.
+    const atom = AtomQuery.make<TestSchema.Person>(queue, Filter.id(jane.id));
+    const results = registry.get(atom);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].id).toEqual(jane.id);
+    expect(results[0].name).toEqual('jane');
+  });
+});
+
+const SchemaA = Schema.Struct({
+  name: Schema.String,
+}).pipe(
+  Type.object({
+    typename: 'com.example.type.a',
+    version: '0.1.0',
+  }),
+);
+
+const SchemaB = Schema.Struct({
+  value: Schema.Number,
+}).pipe(
+  Type.object({
+    typename: 'com.example.type.b',
+    version: '0.1.0',
+  }),
+);
+
+describe('AtomQuery.fromQuery with schema registry', () => {
+  let schemaRegistry: RuntimeSchemaRegistry;
+  let registry: Registry.Registry;
+
+  beforeEach(() => {
+    schemaRegistry = new RuntimeSchemaRegistry([]);
+    registry = Registry.make();
+  });
+
+  test('creates atom with initial results from schema query', async ({ expect }) => {
+    await schemaRegistry.register([SchemaA]);
+
+    const queryResult = schemaRegistry.query();
+    const atom = AtomQuery.fromQuery(queryResult);
+    const results = registry.get(atom);
+
+    expect(results).toHaveLength(1);
+    expect(Type.getTypename(results[0])).toBe('com.example.type.a');
+  });
+
+  test('atom updates when new schemas are registered', async ({ expect }) => {
+    await schemaRegistry.register([SchemaA]);
+
+    const queryResult = schemaRegistry.query();
+    const atom = AtomQuery.fromQuery(queryResult);
+
+    // Get initial results and subscribe.
+    const initialResults = registry.get(atom);
+    expect(initialResults).toHaveLength(1);
+
+    let updateCount = 0;
+    let latestResults: Type.AnyEntity[] = [];
+    registry.subscribe(atom, () => {
+      updateCount++;
+      latestResults = registry.get(atom);
+    });
+
+    // Allow reactive query to start (deferred via queueMicrotask).
+    await sleep(10);
+
+    // Register a new schema.
+    await schemaRegistry.register([SchemaB]);
+
+    expect(updateCount).toBeGreaterThan(0);
+    expect(latestResults).toHaveLength(2);
+    expect(latestResults.map(Type.getTypename).sort()).toEqual(['com.example.type.a', 'com.example.type.b']);
+  });
+
+  test('atom works with empty initial results', ({ expect }) => {
+    const queryResult = schemaRegistry.query();
+    const atom = AtomQuery.fromQuery(queryResult);
+    const results = registry.get(atom);
+
+    expect(results).toHaveLength(0);
+  });
+
+  test('atom with filtered query only reflects matching schemas', async ({ expect }) => {
+    const queryResult = schemaRegistry.query({ typename: 'com.example.type.a' });
+    const atom = AtomQuery.fromQuery(queryResult);
+
+    // Get initial (empty) results and subscribe.
+    const initialResults = registry.get(atom);
+    expect(initialResults).toHaveLength(0);
+
+    let latestResults: Type.AnyEntity[] = [];
+    registry.subscribe(atom, () => {
+      latestResults = registry.get(atom);
+    });
+
+    await sleep(10);
+
+    // Register non-matching schema.
+    await schemaRegistry.register([SchemaB]);
+    // Results updated but still empty for this filter.
+    expect(latestResults).toHaveLength(0);
+
+    // Register matching schema.
+    await schemaRegistry.register([SchemaA]);
+    expect(latestResults).toHaveLength(1);
+    expect(Type.getTypename(latestResults[0])).toBe('com.example.type.a');
+  });
+
+  test('unsubscribing from atom stops updates', async ({ expect }) => {
+    const queryResult = schemaRegistry.query();
+    const atom = AtomQuery.fromQuery(queryResult);
+
+    registry.get(atom);
+
+    let updateCount = 0;
+    const unsubscribe = registry.subscribe(atom, () => {
+      updateCount++;
+    });
+
+    await sleep(10);
+
+    await schemaRegistry.register([SchemaA]);
+    const countAfterFirst = updateCount;
+    expect(countAfterFirst).toBeGreaterThan(0);
+
+    unsubscribe();
+
+    await schemaRegistry.register([SchemaB]);
+    expect(updateCount).toBe(countAfterFirst);
+  });
+});

package/src/query-atom.ts

@@ -8,7 +8,7 @@ import { DXN, Database, type Entity, type Filter, Query, type QueryResult } from
 import { WeakDictionary } from '@dxos/util';
 
 /**
- * Create a self-updating atom from an existing QueryResult.
+ * Create a self-updating atom from any QueryResult (e.g. schema registry queries).
  * Internally subscribes to queryResult and uses get.setSelf to update.
  * Cleanup is handled via get.addFinalizer.
  *
@@ -17,27 +17,25 @@ import { WeakDictionary } from '@dxos/util';
  * @param queryResult - The QueryResult to wrap.
  * @returns An atom that automatically updates when query results change.
  */
-export const fromQuery = <T extends Entity.Unknown>(queryResult: QueryResult.QueryResult<T>): Atom.Atom<T[]> =>
+export const fromQuery = <T>(queryResult: QueryResult.QueryResult<T>): Atom.Atom<T[]> =>
   Atom.make((get) => {
-    // TODO(wittjosiah): Consider subscribing to individual objects here as well, and grabbing their snapshots.
-    // Subscribe to QueryResult changes.
     const unsubscribe = queryResult.subscribe(() => {
-      get.setSelf(queryResult.results);
+      get.setSelf(queryResult.runSync());
     });
-
-    // Register cleanup for when atom is no longer used.
     get.addFinalizer(unsubscribe);
-
-    return queryResult.results;
+    return queryResult.runSync();
   });
 
 // Registry: key → Queryable (WeakRef with auto-cleanup when GC'd).
 const queryableRegistry = new WeakDictionary<string, Database.Queryable>();
 
-// Atom.family keyed by "identifier:serializedAST".
+// Key separator that won't appear in identifiers (DXN strings use colons).
+const KEY_SEPARATOR = '~';
+
+// Atom.family keyed by "identifier~serializedAST".
 const queryFamily = Atom.family((key: string) => {
   // Parse key outside Atom.make - runs once per key.
-  const separatorIndex = key.indexOf(':');
+  const separatorIndex = key.indexOf(KEY_SEPARATOR);
   const identifier = key.slice(0, separatorIndex);
   const serializedAst = key.slice(separatorIndex + 1);
 
@@ -114,8 +112,8 @@ const fromQueryable = <T extends Entity.Unknown>(
     ? queryOrFilter
     : Query.select(queryOrFilter as Filter.Filter<T>);
 
-  // Build key: identifier:serializedAST.
-  const key = `${identifier}:${JSON.stringify(normalizedQuery.ast)}`;
+  // Build key: identifier\0serializedAST (using null char as separator to avoid DXN colon conflicts).
+  const key = `${identifier}${KEY_SEPARATOR}${JSON.stringify(normalizedQuery.ast)}`;
 
   return queryFamily(key) as Atom.Atom<T[]>;
 };

package/src/reactivity.test.ts

@@ -6,8 +6,9 @@ import * as Registry from '@effect-atom/atom/Registry';
 import { describe, expect, test } from 'vitest';
 
 import { Obj } from '@dxos/echo';
-import { TestSchema } from '@dxos/echo/testing';
 import { createObject } from '@dxos/echo-db';
+import { TestSchema } from '@dxos/echo/testing';
+import { arrayMove } from '@dxos/util';
 
 import * as AtomObj from './atom';
 
@@ -27,9 +28,9 @@ describe('Echo Atom - Reactivity', () => {
     // Subscribe to enable reactivity.
     registry.subscribe(atom, () => {});
 
-    // Update the object via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    // Update the object via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
 
     const updatedSnapshot = registry.get(atom);
@@ -49,9 +50,9 @@ describe('Echo Atom - Reactivity', () => {
     // Subscribe to enable reactivity.
     registry.subscribe(atom, () => {});
 
-    // Update the property via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    // Update the property via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
 
     expect(registry.get(atom)).toBe('Updated');
@@ -81,9 +82,9 @@ describe('Echo Atom - Reactivity', () => {
       emailUpdateCount++;
     });
 
-    // Update only email property via Obj.change.
-    Obj.change(obj, (o) => {
-      o.email = 'updated@example.com';
+    // Update only email property via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.email = 'updated@example.com';
     });
 
     // Name atom should NOT have changed.
@@ -108,10 +109,10 @@ describe('Echo Atom - Reactivity', () => {
     registry.subscribe(nameAtom, () => {});
     registry.subscribe(emailAtom, () => {});
 
-    // Update multiple properties via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
-      o.email = 'updated@example.com';
+    // Update multiple properties via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
+      obj.email = 'updated@example.com';
     });
 
     expect(registry.get(nameAtom)).toBe('Updated');
@@ -139,15 +140,15 @@ describe('Echo Atom - Reactivity', () => {
     const initialCount = updateCount;
     expect(initialCount).toBe(1);
 
-    // Update object via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    // Update object via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
-    Obj.change(obj, (o) => {
-      o.email = 'updated@example.com';
+    Obj.update(obj, (obj) => {
+      obj.email = 'updated@example.com';
     });
 
-    // Updates fire through Obj.subscribe (one per Obj.change call).
+    // Updates fire through Obj.subscribe (one per Obj.update call).
     expect(updateCount).toBe(initialCount + 2);
 
     // Verify final state - returns snapshot (plain object).
@@ -155,4 +156,78 @@ describe('Echo Atom - Reactivity', () => {
     expect(finalSnapshot.name).toBe('Updated');
     expect(finalSnapshot.email).toBe('updated@example.com');
   });
+
+  test('property mutation on standalone Obj.make object is synchronous', () => {
+    // Test objects created with just Obj.make() - no createObject/database.
+    const obj = Obj.make(TestSchema.Person, { name: 'Test', username: 'test', email: 'test@example.com' });
+
+    const actions: string[] = [];
+    const unsubscribe = Obj.subscribe(obj, () => {
+      actions.push('update');
+    });
+
+    actions.push('before');
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
+    });
+    actions.push('after');
+
+    // Updates must be synchronous: before -> update -> after.
+    expect(actions).toEqual(['before', 'update', 'after']);
+
+    // Verify the property was modified.
+    expect(obj.name).toBe('Updated');
+
+    unsubscribe();
+  });
+
+  test('array splice on standalone Obj.make object is synchronous', () => {
+    // Test objects created with just Obj.make() - no createObject/database.
+    const obj = Obj.make(TestSchema.Example, { stringArray: ['a', 'b', 'c', 'd'] });
+
+    const actions: string[] = [];
+    const unsubscribe = Obj.subscribe(obj, () => {
+      actions.push('update');
+    });
+
+    actions.push('before');
+    Obj.update(obj, (obj) => {
+      obj.stringArray!.splice(1, 1);
+    });
+    actions.push('after');
+
+    // Updates must be synchronous: before -> update -> after.
+    expect(actions).toEqual(['before', 'update', 'after']);
+
+    // Verify the array was modified.
+    expect(obj.stringArray).toEqual(['a', 'c', 'd']);
+
+    unsubscribe();
+  });
+
+  test('property atom for array property updates when array is reordered in place', () => {
+    // Verifies that makeProperty(obj, 'columns')-style atoms subscribe to in-place
+    // array mutations (e.g. arrayMove), so UI stays in sync after column reorder.
+    const obj = createObject(Obj.make(TestSchema.Example, { stringArray: ['a', 'b', 'c'] }));
+
+    const registry = Registry.make();
+    const atom = AtomObj.makeProperty(obj, 'stringArray');
+
+    const initial = registry.get(atom);
+    expect(initial).toEqual(['a', 'b', 'c']);
+
+    let updateCount = 0;
+    registry.subscribe(atom, () => {
+      updateCount++;
+    });
+
+    // Reorder in place (e.g. move first to last).
+    Obj.update(obj, (obj) => {
+      arrayMove(obj.stringArray!, 0, 2);
+    });
+
+    expect(updateCount).toBe(1);
+    const afterReorder = registry.get(atom);
+    expect(afterReorder).toEqual(['b', 'c', 'a']);
+  });
 });