@dxos/echo-solid 0.0.0 → 0.8.4-main.1c7ec43d41

package/src/useQuery.test.tsx

@@ -6,9 +6,9 @@ import { render, waitFor } from '@solidjs/testing-library';
 import { type JSX, createSignal } from 'solid-js';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
-import { Filter, Obj, Query, Type } from '@dxos/echo';
-import { TestSchema } from '@dxos/echo/testing';
+import { Filter, Obj, Query } from '@dxos/echo';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { TestSchema } from '@dxos/echo/testing';
 
 import { useQuery } from './useQuery';
 
@@ -30,7 +30,7 @@ describe('useQuery', () => {
     let result: any[] | undefined;
 
     render(() => {
-      const objects = useQuery(undefined, Filter.type(Type.Expando));
+      const objects = useQuery(undefined, Filter.type(TestSchema.Expando));
       result = objects();
       return (<div>test</div>) as JSX.Element;
     });
@@ -42,7 +42,7 @@ describe('useQuery', () => {
     let result: any[] | undefined;
 
     render(() => {
-      const objects = useQuery(db, Filter.type(Type.Expando));
+      const objects = useQuery(db, Filter.type(TestSchema.Expando));
       result = objects();
       return (<div>test</div>) as JSX.Element;
     });
@@ -54,8 +54,8 @@ describe('useQuery', () => {
 
   test('returns matching objects', async () => {
     // Add some objects to the database
-    const obj1 = Obj.make(Type.Expando, { name: 'Alice' });
-    const obj2 = Obj.make(Type.Expando, { name: 'Bob' });
+    const obj1 = Obj.make(TestSchema.Expando, { name: 'Alice' });
+    const obj2 = Obj.make(TestSchema.Expando, { name: 'Bob' });
     db.add(obj1);
     db.add(obj2);
     await db.flush({ indexes: true });
@@ -63,7 +63,7 @@ describe('useQuery', () => {
     let objectsAccessor: (() => any[]) | undefined;
 
     function TestComponent() {
-      const objects = useQuery(db, Filter.type(Type.Expando));
+      const objects = useQuery(db, Filter.type(TestSchema.Expando));
       objectsAccessor = objects;
       return (<div data-testid='count'>{objects().length}</div>) as JSX.Element;
     }
@@ -84,7 +84,7 @@ describe('useQuery', () => {
     let objectsAccessor: (() => any[]) | undefined;
 
     function TestComponent() {
-      const objects = useQuery(db, Filter.type(Type.Expando));
+      const objects = useQuery(db, Filter.type(TestSchema.Expando));
       objectsAccessor = objects;
       return (<div data-testid='count'>{objects().length}</div>) as JSX.Element;
     }
@@ -96,7 +96,7 @@ describe('useQuery', () => {
     });
 
     // Add an object
-    const obj = Obj.make(Type.Expando, { name: 'Charlie' });
+    const obj = Obj.make(TestSchema.Expando, { name: 'Charlie' });
     db.add(obj);
     await db.flush({ indexes: true });
 
@@ -112,8 +112,8 @@ describe('useQuery', () => {
 
   test('updates when objects are removed', async () => {
     // Add objects first
-    const obj1 = Obj.make(Type.Expando, { name: 'Alice' });
-    const obj2 = Obj.make(Type.Expando, { name: 'Bob' });
+    const obj1 = Obj.make(TestSchema.Expando, { name: 'Alice' });
+    const obj2 = Obj.make(TestSchema.Expando, { name: 'Bob' });
     db.add(obj1);
     db.add(obj2);
     await db.flush({ indexes: true });
@@ -121,7 +121,7 @@ describe('useQuery', () => {
     let objectsAccessor: (() => any[]) | undefined;
 
     function TestComponent() {
-      const objects = useQuery(db, Filter.type(Type.Expando));
+      const objects = useQuery(db, Filter.type(TestSchema.Expando));
       objectsAccessor = objects;
       return (<div data-testid='count'>{objects().length}</div>) as JSX.Element;
     }
@@ -175,14 +175,14 @@ describe('useQuery', () => {
   });
 
   test('accepts Query directly', async () => {
-    const obj = Obj.make(Type.Expando, { name: 'Test' });
+    const obj = Obj.make(TestSchema.Expando, { name: 'Test' });
     db.add(obj);
     await db.flush({ indexes: true });
 
     let objectsAccessor: (() => any[]) | undefined;
 
     function TestComponent() {
-      const objects = useQuery(db, Query.select(Filter.type(Type.Expando)));
+      const objects = useQuery(db, Query.select(Filter.type(TestSchema.Expando)));
       objectsAccessor = objects;
       return (<div data-testid='count'>{objects().length}</div>) as JSX.Element;
     }
@@ -200,7 +200,7 @@ describe('useQuery', () => {
   });
 
   test('accepts reactive database accessor', async () => {
-    const obj = Obj.make(Type.Expando, { name: 'Test' });
+    const obj = Obj.make(TestSchema.Expando, { name: 'Test' });
     db.add(obj);
     await db.flush({ indexes: true });
 
@@ -208,7 +208,7 @@ describe('useQuery', () => {
     let dbAccessor: any = db;
 
     function TestComponent() {
-      const objects = useQuery(() => dbAccessor, Filter.type(Type.Expando));
+      const objects = useQuery(() => dbAccessor, Filter.type(TestSchema.Expando));
       objectsAccessor = objects;
       return (<div data-testid='count'>{objects().length}</div>) as JSX.Element;
     }
@@ -235,7 +235,7 @@ describe('useQuery', () => {
     // Register schema first
     await db.graph.schemaRegistry.register([TestSchema.Person]);
 
-    const obj1 = Obj.make(Type.Expando, { name: 'Test1' });
+    const obj1 = Obj.make(TestSchema.Expando, { name: 'Test1' });
     const obj2 = Obj.make(TestSchema.Person, { name: 'Test2', username: 'test', email: 'test@example.com' });
     db.add(obj1);
     db.add(obj2);
@@ -246,7 +246,7 @@ describe('useQuery', () => {
 
     function TestComponent() {
       const objects = useQuery(db, () =>
-        usePersonFilter() ? Filter.type(TestSchema.Person) : Filter.type(Type.Expando),
+        usePersonFilter() ? Filter.type(TestSchema.Person) : Filter.type(TestSchema.Expando),
       );
       objectsAccessor = objects;
       return (<div data-testid='count'>{objects().length}</div>) as JSX.Element;

package/src/useSchema.test.tsx

@@ -7,8 +7,8 @@ import { type JSX, createMemo } from 'solid-js';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
 import { Type } from '@dxos/echo';
-import { TestSchema } from '@dxos/echo/testing';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { TestSchema } from '@dxos/echo/testing';
 
 import { useSchema } from './useSchema';
 
@@ -100,7 +100,7 @@ describe('useSchema', () => {
     // 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
     let schemaAccessor: (() => any) | undefined;
-    const typename = 'example.com/type/Person';
+    const typename = 'com.example.type.person';
 
     function TestComponent() {
       const schema = useSchema(db, typename);

package/src/useSchema.ts

@@ -16,7 +16,7 @@ type MaybeAccessor<T> = T | Accessor<T>;
  * @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.Entity.Any = Type.Entity.Any>(
+export const useSchema = <T extends Type.AnyEntity = Type.AnyEntity>(
   db?: MaybeAccessor<Database.Database | undefined>,
   typename?: MaybeAccessor<string | undefined>,
 ): Accessor<T | undefined> => {

package/src/useRef.test.tsx

@@ -1,247 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { render, waitFor } from '@solidjs/testing-library';
-import { type JSX, createSignal } from 'solid-js';
-import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-
-import { Obj, Ref, Type } from '@dxos/echo';
-import { TestSchema } from '@dxos/echo/testing';
-import { EchoTestBuilder } from '@dxos/echo-db/testing';
-import { Registry, RegistryProvider } from '@dxos/effect-atom-solid';
-
-import { useRef } from './useRef';
-
-const createWrapper = (registry: Registry.Registry) => {
-  return (props: { children: JSX.Element }) => {
-    return <RegistryProvider registry={registry}>{props.children}</RegistryProvider>;
-  };
-};
-
-describe('useRef', () => {
-  let testBuilder: EchoTestBuilder;
-  let db: any;
-  let registry: Registry.Registry;
-
-  beforeEach(async () => {
-    testBuilder = await new EchoTestBuilder().open();
-    const { db: database } = await testBuilder.createDatabase();
-    db = database;
-    registry = Registry.make();
-  });
-
-  afterEach(async () => {
-    await testBuilder.close();
-  });
-
-  test('returns undefined when ref is undefined', () => {
-    const Wrapper = createWrapper(registry);
-
-    let result: any;
-
-    render(
-      () => {
-        const target = useRef(undefined);
-        result = target();
-        return (<div>test</div>) as JSX.Element;
-      },
-      { wrapper: Wrapper },
-    );
-
-    expect(result).toBeUndefined();
-  });
-
-  test('returns undefined when ref target is not loaded and loads it', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
-
-    // Create objects with a ref
-    const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
-    db.add(targetObj);
-    await db.flush({ indexes: true });
-
-    // Create a ref - target should be available since object is in memory
-    const ref = Ref.make(targetObj);
-
-    // Initially target should be available since object is in memory
-    expect(ref.target).toBeDefined();
-
-    const Wrapper = createWrapper(registry);
-
-    let targetAccessor: (() => any) | undefined;
-
-    function TestComponent() {
-      const target = useRef(ref);
-      targetAccessor = target;
-      return (<div data-testid='name'>{target()?.name || 'undefined'}</div>) as JSX.Element;
-    }
-
-    const { getByTestId } = render(() => <TestComponent />, { wrapper: Wrapper });
-
-    // Should load since target is available
-    await waitFor(() => {
-      expect(getByTestId('name').textContent).toBe('Target');
-    });
-
-    // Get the actual result from the accessor
-    const result = targetAccessor?.();
-    expect(result?.name).toBe('Target');
-  });
-
-  test('returns target when ref is loaded', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
-
-    const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
-    db.add(targetObj);
-    await db.flush({ indexes: true });
-
-    const ref = Ref.make(targetObj);
-    const Wrapper = createWrapper(registry);
-
-    let targetAccessor: (() => any) | undefined;
-
-    function TestComponent() {
-      const target = useRef(ref);
-      targetAccessor = target;
-      return (<div data-testid='name'>{target()?.name || 'undefined'}</div>) as JSX.Element;
-    }
-
-    const { getByTestId } = render(() => <TestComponent />, { wrapper: Wrapper });
-
-    await waitFor(() => {
-      expect(getByTestId('name').textContent).toBe('Target');
-    });
-
-    // Get the actual result from the accessor
-    const result = targetAccessor?.();
-    expect(result?.name).toBe('Target');
-    expect(result?.username).toBe('target');
-  });
-
-  test('handles ref to Expando object', async () => {
-    const targetObj = Obj.make(Type.Expando, { name: 'Expando Target', value: 42 });
-    db.add(targetObj);
-    await db.flush({ indexes: true });
-
-    const ref = Ref.make(targetObj);
-    const Wrapper = createWrapper(registry);
-
-    let targetAccessor: (() => any) | undefined;
-
-    function TestComponent() {
-      const target = useRef(ref);
-      targetAccessor = target;
-      return (<div data-testid='name'>{target()?.name || 'undefined'}</div>) as JSX.Element;
-    }
-
-    const { getByTestId } = render(() => <TestComponent />, { wrapper: Wrapper });
-
-    await waitFor(() => {
-      expect(getByTestId('name').textContent).toBe('Expando Target');
-    });
-
-    // Get the actual result from the accessor
-    const result = targetAccessor?.();
-    expect(result?.name).toBe('Expando Target');
-    expect(result?.value).toBe(42);
-  });
-
-  test('works with accessor function', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
-
-    const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
-    db.add(targetObj);
-    await db.flush({ indexes: true });
-
-    const ref = Ref.make(targetObj);
-    const Wrapper = createWrapper(registry);
-
-    let targetAccessor: (() => any) | undefined;
-
-    function TestComponent() {
-      const target = useRef(() => ref);
-      targetAccessor = target;
-      return (<div data-testid='name'>{target()?.name || 'undefined'}</div>) as JSX.Element;
-    }
-
-    const { getByTestId } = render(() => <TestComponent />, { wrapper: Wrapper });
-
-    await waitFor(() => {
-      expect(getByTestId('name').textContent).toBe('Target');
-    });
-
-    // Get the actual result from the accessor
-    const result = targetAccessor?.();
-    expect(result?.name).toBe('Target');
-  });
-
-  test('reactively tracks changes when accessor returns different ref', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
-
-    const targetObj1 = Obj.make(TestSchema.Person, {
-      name: 'Target1',
-      username: 'target1',
-      email: 'target1@example.com',
-    });
-    const targetObj2 = Obj.make(TestSchema.Person, {
-      name: 'Target2',
-      username: 'target2',
-      email: 'target2@example.com',
-    });
-    db.add(targetObj1);
-    db.add(targetObj2);
-    await db.flush({ indexes: true });
-
-    const ref1 = Ref.make(targetObj1);
-    const ref2 = Ref.make(targetObj2);
-    const [refSignal, setRefSignal] = createSignal<Ref.Ref<any> | undefined>(ref1);
-    const Wrapper = createWrapper(registry);
-
-    let targetAccessor: (() => any) | undefined;
-
-    function TestComponent() {
-      const target = useRef(refSignal);
-      targetAccessor = target;
-      return (<div data-testid='name'>{target()?.name || 'undefined'}</div>) as JSX.Element;
-    }
-
-    const { getByTestId } = render(() => <TestComponent />, { wrapper: Wrapper });
-
-    await waitFor(() => {
-      expect(getByTestId('name').textContent).toBe('Target1');
-    });
-
-    // Get the actual result from the accessor
-    let result = targetAccessor?.();
-    expect(result?.name).toBe('Target1');
-
-    // Change the ref via signal
-    setRefSignal(() => ref2);
-
-    await waitFor(() => {
-      expect(getByTestId('name').textContent).toBe('Target2');
-    });
-
-    // Get the actual result from the accessor
-    result = targetAccessor?.();
-    expect(result?.name).toBe('Target2');
-  });
-
-  test('handles undefined when accessor returns undefined', () => {
-    const [refSignal] = createSignal<Ref.Ref<any> | undefined>(undefined);
-    const Wrapper = createWrapper(registry);
-
-    let targetAccessor: (() => any) | undefined;
-
-    function TestComponent() {
-      const target = useRef(refSignal);
-      targetAccessor = target;
-      return (<div data-testid='name'>{target()?.name || 'undefined'}</div>) as JSX.Element;
-    }
-
-    const { getByTestId } = render(() => <TestComponent />, { wrapper: Wrapper });
-
-    expect(getByTestId('name').textContent).toBe('undefined');
-    expect(targetAccessor?.()).toBeUndefined();
-  });
-});

package/src/useRef.ts

@@ -1,48 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type MaybeAccessor, access } from '@solid-primitives/utils';
-import { type Accessor, createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
-
-import { type Entity, type Ref } from '@dxos/echo';
-import { AtomRef } from '@dxos/echo-atom';
-import { useRegistry } from '@dxos/effect-atom-solid';
-
-/**
- * Subscribe to a reference target object.
- * Returns undefined if the reference hasn't loaded yet, and automatically updates when the target loads or changes.
- *
- * @param ref - The reference to subscribe to (can be reactive).
- * @returns An accessor that returns the current target object or undefined if not loaded.
- */
-export function useRef<T extends Entity.Unknown>(ref: MaybeAccessor<Ref.Ref<T> | undefined>): Accessor<T | undefined> {
-  const registry = useRegistry();
-
-  // Memoize the ref to track changes.
-  const memoizedRef = createMemo(() => access(ref));
-
-  // Store the current target in a signal.
-  const [target, setTarget] = createSignal<T | undefined>(undefined);
-
-  // Subscribe to ref target changes.
-  createEffect(() => {
-    const currentRef = memoizedRef();
-
-    const atom = AtomRef.make(currentRef);
-    const currentValue = registry.get(atom);
-    setTarget(() => currentValue);
-
-    const unsubscribe = registry.subscribe(
-      atom,
-      () => {
-        setTarget(() => registry.get(atom));
-      },
-      { immediate: true },
-    );
-
-    onCleanup(unsubscribe);
-  });
-
-  return target;
-}