@dxos/echo-atom 0.8.4-main.d05539e30a → 0.8.4-main.d9fc60f731

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo-atom",
-  "version": "0.8.4-main.d05539e30a",
+  "version": "0.8.4-main.d9fc60f731",
   "description": "Effect Atom wrappers for ECHO objects with explicit subscriptions.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -25,20 +25,20 @@
     "src"
   ],
   "dependencies": {
-    "@effect-atom/atom": "^0.5.1",
-    "@dxos/invariant": "0.8.4-main.d05539e30a",
-    "@dxos/util": "0.8.4-main.d05539e30a",
-    "@dxos/echo-db": "0.8.4-main.d05539e30a",
-    "@dxos/echo": "0.8.4-main.d05539e30a"
+    "@effect-atom/atom": "^0.5.3",
+    "@dxos/echo-db": "0.8.4-main.d9fc60f731",
+    "@dxos/util": "0.8.4-main.d9fc60f731",
+    "@dxos/invariant": "0.8.4-main.d9fc60f731",
+    "@dxos/echo": "0.8.4-main.d9fc60f731"
   },
   "devDependencies": {
-    "effect": "3.20.0",
-    "@dxos/random": "0.8.4-main.d05539e30a",
-    "@dxos/context": "0.8.4-main.d05539e30a",
-    "@dxos/test-utils": "0.8.4-main.d05539e30a"
+    "effect": "3.21.2",
+    "@dxos/test-utils": "0.8.4-main.d9fc60f731",
+    "@dxos/context": "0.8.4-main.d9fc60f731",
+    "@dxos/random": "0.8.4-main.d9fc60f731"
   },
   "peerDependencies": {
-    "effect": "3.20.0"
+    "effect": "3.21.2"
   },
   "publishConfig": {
     "access": "public"

package/src/atom.ts

@@ -8,7 +8,7 @@ import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
 import * as Option from 'effect/Option';
 
-import { type Entity, Obj, Ref, Relation } from '@dxos/echo';
+import { Entity, Obj, Ref, Relation } from '@dxos/echo';
 import { assertArgument } from '@dxos/invariant';
 
 import { loadRefTarget } from './ref-utils';
@@ -130,7 +130,12 @@ export function make<T extends Entity.Unknown>(
 
   // At this point, objOrRef is definitely T (not a Ref).
   const obj = objOrRef as T;
-  assertArgument(Obj.isObject(obj) || Relation.isRelation(obj), 'obj', 'Object must be a reactive object');
+  // Accept any kind of entity (Obj, Relation, or persisted Type) — the
+  // reactive subscription only needs `[KindId]` to be set; the proxy machinery
+  // is kind-agnostic. Narrowing to Obj/Relation here used to throw for type
+  // entities returned by the schema registry (e.g. persisted RoastLog), which
+  // broke the schema-node connector in plugin-space.
+  assertArgument(Entity.isEntity(obj), 'obj', 'Object must be a reactive object');
 
   // TODO(dmaretskyi): Fix echo types during review.
   return objectFamily(obj as any);

package/src/query-atom.test.ts

@@ -6,9 +6,8 @@ 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 { Filter, Obj, Query, type QueryResult, Type } from '@dxos/echo';
-import { type EchoDatabase, RuntimeSchemaRegistry } from '@dxos/echo-db';
+import { DXN, Filter, Obj, Query, type QueryResult, Type } from '@dxos/echo';
+import { type EchoDatabase, makeRegistry } from '@dxos/echo-db';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
 import { TestSchema } from '@dxos/echo/testing';
 import { SpaceId } from '@dxos/keys';
@@ -21,13 +20,12 @@ import * as AtomQuery from './query-atom';
 const TestItem = Schema.Struct({
   name: Schema.String,
   value: Schema.Number,
-}).pipe(
-  Type.object({
-    typename: 'com.example.type.test-item',
-    version: '0.1.0',
-  }),
-);
-type TestItem = Schema.Schema.Type<typeof TestItem>;
+}).pipe(Type.makeObject(DXN.make('com.example.type.testItem', '0.1.0')));
+type TestItem = Type.InstanceType<typeof TestItem>;
+
+const TestItem2 = Schema.Struct({
+  title: Schema.String,
+}).pipe(Type.makeObject(DXN.make('com.example.type.testItem2', '0.1.0')));
 
 describe('AtomQuery', () => {
   let testBuilder: EchoTestBuilder;
@@ -202,6 +200,55 @@ describe('AtomQuery', () => {
   });
 });
 
+describe('AtomQuery with registry', () => {
+  let atomRegistry: Registry.Registry;
+
+  beforeEach(() => {
+    atomRegistry = Registry.make();
+  });
+
+  test('AtomQuery.make memoizes per registry instance', () => {
+    const registry = makeRegistry({ initial: [TestItem] });
+
+    // Same registry + filter must yield the same atom instance. Otherwise reactive
+    // connectors re-create the atom on every recompute, which destabilizes the
+    // effect-atom dependency graph and loops synchronously (the type-create freeze).
+    const atom1 = AtomQuery.make(registry, Filter.type(Type.Type));
+    const atom2 = AtomQuery.make(registry, Filter.type(Type.Type));
+    expect(atom1).toBe(atom2);
+
+    // A different registry instance must yield a different atom.
+    const otherRegistry = makeRegistry({ initial: [TestItem] });
+    expect(AtomQuery.make(otherRegistry, Filter.type(Type.Type))).not.toBe(atom1);
+  });
+
+  test('AtomQuery.make queries registry type entities', () => {
+    const registry = makeRegistry({ initial: [TestItem] });
+
+    const atom = AtomQuery.make(registry, Filter.type(Type.Type));
+    const results = atomRegistry.get(atom);
+
+    expect(results.map((type) => Type.getTypename(type))).toContain('com.example.type.testItem');
+  });
+
+  test('AtomQuery.make updates when registry contents change', () => {
+    const registry = makeRegistry({ initial: [TestItem] });
+
+    const atom = AtomQuery.make(registry, Filter.type(Type.Type));
+    expect(atomRegistry.get(atom)).toHaveLength(1);
+
+    let updateCount = 0;
+    atomRegistry.subscribe(atom, () => {
+      updateCount++;
+    });
+
+    registry.add([TestItem2]);
+
+    expect(updateCount).toBeGreaterThan(0);
+    expect(atomRegistry.get(atom)).toHaveLength(2);
+  });
+});
+
 describe('AtomQuery with queues', () => {
   let testBuilder: EchoTestBuilder;
   let registry: Registry.Registry;
@@ -261,127 +308,3 @@ describe('AtomQuery with queues', () => {
     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

@@ -4,7 +4,7 @@
 
 import { Atom } from '@effect-atom/atom';
 
-import { DXN, Database, type Entity, type Filter, Query, type QueryResult } from '@dxos/echo';
+import { Database, type Entity, type Filter, Query, type QueryResult, Registry, URI } from '@dxos/echo';
 import { WeakDictionary } from '@dxos/util';
 
 /**
@@ -68,9 +68,13 @@ const getQueryableIdentifier = (queryable: Database.Queryable): string => {
   if (Database.isDatabase(queryable)) {
     return queryable.spaceId;
   }
-  // Queue or similar: use dxn if it's a DXN instance.
-  if ('dxn' in queryable && queryable.dxn instanceof DXN) {
-    return queryable.dxn.toString();
+  // Registry: use its stable per-instance id.
+  if (Registry.isRegistry(queryable)) {
+    return queryable.id;
+  }
+  // Queue or similar: use uri if it's a URI (EID or DXN).
+  if ('uri' in queryable && URI.isURI(queryable.uri)) {
+    return queryable.uri;
   }
   // Fallback: use id if it's a string.
   if ('id' in queryable && typeof queryable.id === 'string') {

package/src/ref-atom.test.ts

@@ -31,7 +31,7 @@ describe('AtomRef - Basic Functionality', () => {
   });
 
   test('AtomRef.make returns target when ref is loaded', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
@@ -46,7 +46,7 @@ describe('AtomRef - Basic Functionality', () => {
   });
 
   test('AtomRef.make does not subscribe to target changes (use AtomObj for reactive snapshots)', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
@@ -120,7 +120,7 @@ describe('AtomRef - Referential Equality', () => {
   });
 
   test('AtomRef.make returns same atom instance for same ref', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
@@ -136,7 +136,7 @@ describe('AtomRef - Referential Equality', () => {
   });
 
   test('AtomRef.make returns different atom instances for different refs', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const targetObj1 = Obj.make(TestSchema.Person, {
       name: 'Target1',
@@ -163,7 +163,7 @@ describe('AtomRef - Referential Equality', () => {
   });
 
   test('AtomRef.make returns same atom for refs created separately to same target', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
@@ -188,7 +188,7 @@ describe('AtomRef - Referential Equality', () => {
   });
 
   test('cached ref atoms return same instance after multiple retrievals', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);