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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo-solid",
-  "version": "0.8.4-main.d05539e30a",
+  "version": "0.8.4-main.d9fc60f731",
   "description": "Solid.js integration for ECHO.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -25,18 +25,18 @@
     "src"
   ],
   "dependencies": {
-    "@effect-atom/atom": "^0.5.1",
+    "@effect-atom/atom": "^0.5.3",
     "@solid-primitives/utils": "^6.3.2",
-    "@dxos/echo-atom": "0.8.4-main.d05539e30a",
-    "@dxos/echo": "0.8.4-main.d05539e30a",
-    "@dxos/effect-atom-solid": "0.8.4-main.d05539e30a"
+    "@dxos/echo": "0.8.4-main.d9fc60f731",
+    "@dxos/echo-atom": "0.8.4-main.d9fc60f731",
+    "@dxos/effect-atom-solid": "0.8.4-main.d9fc60f731"
   },
   "devDependencies": {
     "@solidjs/testing-library": "^0.8.10",
     "solid-js": "^1.9.11",
     "vite-plugin-solid": "^2.11.12",
-    "vitest": "4.1.6",
-    "@dxos/echo-db": "0.8.4-main.d05539e30a"
+    "vitest": "4.1.7",
+    "@dxos/echo-db": "0.8.4-main.d9fc60f731"
   },
   "peerDependencies": {
     "solid-js": "^1.9.11"

package/src/index.ts

@@ -4,4 +4,4 @@
 
 export * from './useObject';
 export * from './useQuery';
-export * from './useSchema';
+export * from './useType';

package/src/useObject.ts

@@ -302,7 +302,7 @@ export const useObjects = <T extends Obj.Unknown>(refs: MaybeAccessor<readonly R
     const subscribeToTarget = (ref: Ref.Ref<T>) => {
       const target = ref.target;
       if (target) {
-        const key = ref.dxn.toString();
+        const key = ref.uri;
         if (!targetUnsubscribes.has(key)) {
           targetUnsubscribes.set(key, Obj.subscribe(target, triggerUpdate));
         }

package/src/useQuery.test.tsx

@@ -148,7 +148,7 @@ describe('useQuery', () => {
 
   test('accepts Filter directly', async () => {
     // Register schema first
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const obj = Obj.make(TestSchema.Person, { name: 'Test', username: 'test', email: 'test@example.com' });
     db.add(obj);
@@ -233,7 +233,7 @@ describe('useQuery', () => {
 
   test('accepts reactive query accessor', async () => {
     // Register schema first
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const obj1 = Obj.make(TestSchema.Expando, { name: 'Test1' });
     const obj2 = Obj.make(TestSchema.Person, { name: 'Test2', username: 'test', email: 'test@example.com' });

package/src/{useSchema.test.tsx → useType.test.tsx}

@@ -10,9 +10,9 @@ import { Type } from '@dxos/echo';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
 import { TestSchema } from '@dxos/echo/testing';
 
-import { useSchema } from './useSchema';
+import { useType } from './useType';
 
-describe('useSchema', () => {
+describe('useType', () => {
   let testBuilder: EchoTestBuilder;
   let db: any;
 
@@ -30,7 +30,7 @@ describe('useSchema', () => {
     let result: any;
 
     render(() => {
-      const schema = useSchema(undefined, 'dxos.test.Person');
+      const schema = useType(undefined, 'dxos.test.Person');
       result = schema();
       return (<div>test</div>) as JSX.Element;
     });
@@ -42,7 +42,7 @@ describe('useSchema', () => {
     let result: any;
 
     render(() => {
-      const schema = useSchema(db, undefined);
+      const schema = useType(db, undefined);
       result = schema();
       return (<div>test</div>) as JSX.Element;
     });
@@ -54,7 +54,7 @@ describe('useSchema', () => {
     let result: any;
 
     render(() => {
-      const schema = useSchema(db, 'dxos.test.NonExistent');
+      const schema = useType(db, 'dxos.test.NonExistent');
       result = schema();
       return (<div>test</div>) as JSX.Element;
     });
@@ -66,13 +66,13 @@ describe('useSchema', () => {
 
   test('returns schema when it exists', async () => {
     // Register a schema to the database
-    const [registeredSchema] = await db.schemaRegistry.register([TestSchema.Person]);
+    const registeredSchema = await db.addType(TestSchema.Person);
     await db.flush({ indexes: true });
 
     let schemaAccessor: (() => any) | undefined;
 
     function TestComponent() {
-      const schema = useSchema(db, registeredSchema.typename);
+      const schema = useType(db, Type.getTypename(registeredSchema)!);
       schemaAccessor = schema;
       const t = createMemo(() => {
         const s = schema();
@@ -84,26 +84,24 @@ describe('useSchema', () => {
     const { getByTestId } = render(() => <TestComponent />);
 
     await waitFor(() => {
-      expect(getByTestId('typename').textContent).toBe(registeredSchema.typename);
+      expect(getByTestId('typename').textContent).toBe(Type.getTypename(registeredSchema)!);
     });
 
     // Get the actual result from the accessor
     const result = schemaAccessor?.();
     expect(result).toBeDefined();
-    expect(result?.typename).toBe(registeredSchema.typename);
+    expect(Type.getTypename(result!)).toBe(Type.getTypename(registeredSchema)!);
   });
 
   test.skip('updates when schema is added', async () => {
     // TODO: This test is skipped because runtime schema registry is not reactive to newly registered schemas.
-    // The query reads from db.graph.schemaRegistry.schemas (runtime registry), but when a schema is registered
-    // via db.schemaRegistry.register(), it's added to the database registry, not the runtime registry.
-    // The runtime registry query subscription doesn't fire when schemas are registered.
-    // See: packages/core/echo/echo-db/src/proxy-db/runtime-schema-registry.ts:57
+    // The query reads from db.graph.registry.types (shared registry), but when a schema is added
+    // via db.add(), the runtime registry query subscription doesn't fire reactively.
     let schemaAccessor: (() => any) | undefined;
     const typename = 'com.example.type.person';
 
     function TestComponent() {
-      const schema = useSchema(db, typename);
+      const schema = useType(db, typename);
       schemaAccessor = schema;
       const t = createMemo(() => {
         const s = schema();
@@ -119,29 +117,29 @@ describe('useSchema', () => {
     });
 
     // Register the schema
-    const [registeredSchema] = await db.schemaRegistry.register([TestSchema.Person]);
+    const registeredSchema = await db.addType(TestSchema.Person);
     await db.flush({ indexes: true });
 
     // The schema registry query should pick up the new schema
-    // It reads from db.graph.schemaRegistry.schemas which should include the newly registered schema
+    // db.graph.registry.types should include the newly registered schema
     await waitFor(() => {
-      expect(getByTestId('typename').textContent).toBe(registeredSchema.typename);
+      expect(getByTestId('typename').textContent).toBe(Type.getTypename(registeredSchema)!);
     });
 
     // Get the actual result from the accessor
     const result = schemaAccessor?.();
     expect(result).toBeDefined();
-    expect(result?.typename).toBe(registeredSchema.typename);
+    expect(Type.getTypename(result!)).toBe(Type.getTypename(registeredSchema)!);
   });
 
   test('accepts reactive database accessor', async () => {
-    const [registeredSchema] = await db.schemaRegistry.register([TestSchema.Person]);
+    const registeredSchema = await db.addType(TestSchema.Person);
 
     let schemaAccessor: (() => any) | undefined;
     let dbAccessor: any = db;
 
     function TestComponent() {
-      const schema = useSchema(() => dbAccessor, registeredSchema.typename);
+      const schema = useType(() => dbAccessor, Type.getTypename(registeredSchema)!);
       schemaAccessor = schema;
       const t = createMemo(() => {
         const s = schema();
@@ -153,7 +151,7 @@ describe('useSchema', () => {
     const { getByTestId } = render(() => <TestComponent />);
 
     await waitFor(() => {
-      expect(getByTestId('typename').textContent).toBe(registeredSchema.typename);
+      expect(getByTestId('typename').textContent).toBe(Type.getTypename(registeredSchema)!);
     });
 
     // Get the actual result from the accessor
@@ -169,13 +167,13 @@ describe('useSchema', () => {
   });
 
   test('accepts reactive typename accessor', async () => {
-    const [registeredSchema] = await db.schemaRegistry.register([TestSchema.Person]);
+    const registeredSchema = await db.addType(TestSchema.Person);
 
     let schemaAccessor: (() => any) | undefined;
-    let typename: string | undefined = registeredSchema.typename;
+    let typename: string | undefined = Type.getTypename(registeredSchema)!;
 
     function TestComponent() {
-      const schema = useSchema(db, () => typename);
+      const schema = useType(db, () => typename);
       schemaAccessor = schema;
       const t = createMemo(() => {
         const s = schema();
@@ -187,20 +185,20 @@ describe('useSchema', () => {
     const { getByTestId } = render(() => <TestComponent />);
 
     await waitFor(() => {
-      expect(getByTestId('typename').textContent).toBe(registeredSchema.typename);
+      expect(getByTestId('typename').textContent).toBe(Type.getTypename(registeredSchema)!);
     });
 
     // Get the actual result from the accessor
     let result = schemaAccessor?.();
     expect(result).toBeDefined();
-    expect(result?.typename).toBe(registeredSchema.typename);
+    expect(Type.getTypename(result!)).toBe(Type.getTypename(registeredSchema)!);
 
     // Change typename
     typename = undefined;
 
     await waitFor(() => {
       // Should keep previous value when typename becomes undefined
-      expect(getByTestId('typename').textContent).toBe(registeredSchema.typename);
+      expect(getByTestId('typename').textContent).toBe(Type.getTypename(registeredSchema)!);
     });
     result = schemaAccessor?.();
     expect(result).toBeDefined();

package/src/useType.ts

@@ -0,0 +1,61 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Accessor, createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
+
+import { type Database, Filter, Query, Scope, Type } from '@dxos/echo';
+
+type MaybeAccessor<T> = T | Accessor<T>;
+
+/**
+ * Subscribe to and retrieve a type by typename from a space.
+ * Accepts either values or accessors for db and typename.
+ *
+ * Fans across the owning space db (persisted custom types) and the shared
+ * registry (static/runtime plugin types). Persisted types live only in the db,
+ * so a registry-only lookup misses them.
+ *
+ * @param db - The database instance (can be reactive)
+ * @param typename - The typename to query (can be reactive)
+ * @returns An accessor that returns the current type or undefined
+ */
+export const useType = (
+  db?: MaybeAccessor<Database.Database | undefined>,
+  typename?: MaybeAccessor<string | undefined>,
+): Accessor<Type.AnyEntity | undefined> => {
+  // Derive resolved values reactively.
+  const resolved = createMemo(() => {
+    const resolvedDb = typeof db === 'function' ? db() : db;
+    const resolvedTypename = typeof typename === 'function' ? typename() : typename;
+    if (!resolvedTypename || !resolvedDb) {
+      return undefined;
+    }
+    return { db: resolvedDb, typename: resolvedTypename };
+  });
+
+  // Store the current type in a signal.
+  const [type, setType] = createSignal<Type.AnyEntity | undefined>(undefined);
+
+  // Subscribe to registry changes.
+  createEffect(() => {
+    const r = resolved();
+    if (!r) {
+      // Keep previous value during transitions to prevent flickering.
+      return;
+    }
+
+    const { db: resolvedDb, typename: resolvedTypename } = r;
+
+    const queryResult = resolvedDb.query(Query.select(Filter.type(Type.Type)).from(Scope.space(), Scope.registry()));
+    const update = () => setType(() => queryResult.results.find((type) => Type.getTypename(type) === resolvedTypename));
+
+    // Subscribe before reading `.results` — the query requires at least one subscriber.
+    const unsubscribe = queryResult.subscribe(update);
+    update();
+
+    onCleanup(unsubscribe);
+  });
+
+  return type;
+};

package/dist/types/src/useSchema.d.ts

@@ -1,14 +0,0 @@
-import { type Accessor } from 'solid-js';
-import { type Database, type Type } from '@dxos/echo';
-type MaybeAccessor<T> = T | Accessor<T>;
-/**
- * Subscribe to and retrieve schema changes from a database's schema registry.
- * Accepts either values or accessors for db and typename.
- *
- * @param db - The database instance (can be reactive)
- * @param typename - The schema typename to query (can be reactive)
- * @returns An accessor that returns the current schema or undefined
- */
-export declare const useSchema: <T extends Type.AnyEntity = Type.AnyEntity>(db?: MaybeAccessor<Database.Database | undefined>, typename?: MaybeAccessor<string | undefined>) => Accessor<T | undefined>;
-export {};
-//# sourceMappingURL=useSchema.d.ts.map

package/dist/types/src/useSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useSchema.d.ts","sourceRoot":"","sources":["../../../src/useSchema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,QAAQ,EAAqD,MAAM,UAAU,CAAC;AAE5F,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAEtD,KAAK,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAExC;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,OAC5D,aAAa,CAAC,QAAQ,CAAC,QAAQ,GAAG,SAAS,CAAC,aACtC,aAAa,CAAC,MAAM,GAAG,SAAS,CAAC,KAC3C,QAAQ,CAAC,CAAC,GAAG,SAAS,CAqCxB,CAAC"}

package/dist/types/src/useSchema.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=useSchema.test.d.ts.map

package/dist/types/src/useSchema.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useSchema.test.d.ts","sourceRoot":"","sources":["../../../src/useSchema.test.tsx"],"names":[],"mappings":""}

package/src/useSchema.ts

@@ -1,59 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type Accessor, createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
-
-import { type Database, type Type } from '@dxos/echo';
-
-type MaybeAccessor<T> = T | Accessor<T>;
-
-/**
- * Subscribe to and retrieve schema changes from a database's schema registry.
- * Accepts either values or accessors for db and typename.
- *
- * @param db - The database instance (can be reactive)
- * @param typename - The schema typename to query (can be reactive)
- * @returns An accessor that returns the current schema or undefined
- */
-export const useSchema = <T extends Type.AnyEntity = Type.AnyEntity>(
-  db?: MaybeAccessor<Database.Database | undefined>,
-  typename?: MaybeAccessor<string | undefined>,
-): Accessor<T | undefined> => {
-  // Derive the schema query reactively
-  const query = createMemo(() => {
-    const resolvedDb = typeof db === 'function' ? db() : db;
-    const resolvedTypename = typeof typename === 'function' ? typename() : typename;
-    if (!resolvedTypename || !resolvedDb) {
-      return undefined;
-    }
-    return resolvedDb.schemaRegistry.query({ typename: resolvedTypename, location: ['database', 'runtime'] });
-  });
-
-  // Store the current schema in a signal
-  const [schema, setSchema] = createSignal<T | undefined>(undefined);
-
-  // Subscribe to query changes
-  createEffect(() => {
-    const q = query();
-    if (!q) {
-      // Keep previous value during transitions to prevent flickering
-      return;
-    }
-
-    // Subscribe to updates with immediate fire to get initial result and track changes
-    // The subscription will automatically start the reactive query
-    const unsubscribe = q.subscribe(
-      () => {
-        // Access results inside the callback to ensure query is running
-        const results = q.results;
-        setSchema(() => results[0] as T | undefined);
-      },
-      { fire: true },
-    );
-
-    onCleanup(unsubscribe);
-  });
-
-  return schema;
-};