@dxos/echo 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/src/Order.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import { type QueryAST } from '@dxos/echo-protocol';
 
 export interface Order<T> {
@@ -14,7 +16,7 @@ export interface Order<T> {
 export type Any = Order<any>;
 
 class OrderClass implements Order<any> {
-  private static variance: Order<any>['~Order'] = {} as Order<any>['~Order'];
+  private static 'variance': Order<any>['~Order'] = {} as Order<any>['~Order'];
 
   static is(value: unknown): value is Order<any> {
     return typeof value === 'object' && value !== null && '~Order' in value;

package/src/Query.test.ts

@@ -6,9 +6,11 @@ import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
 import { QueryAST } from '@dxos/echo-protocol';
-import { DXN } from '@dxos/keys';
+import { DXN, ObjectId, SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
+import * as Dataset from './Dataset';
+import * as Feed from './Feed';
 import * as Filter from './Filter';
 import * as Obj from './Obj';
 import * as Order from './Order';
@@ -96,7 +98,7 @@ describe('query api', () => {
       expect(ObjectsReferencingFred.ast).toMatchObject({
         type: 'incoming-references',
         property: null,
-        typename: 'dxn:type:example.com/type/Task:0.1.0',
+        typename: 'dxn:type:com.example.type.task:0.1.0',
       });
     });
 
@@ -135,6 +137,72 @@ describe('query api', () => {
       log('PeopleOrOrganizations', { ast: PeopleOrOrganizations.ast });
     });
 
+    test('Filter.query(Dataset.Dataset) (union of schemas)', () => {
+      const AllDatasets = Query.select(Filter.type(Dataset.Dataset));
+
+      log('query', { ast: AllDatasets.ast });
+      Schema.validateSync(QueryAST.Query)(AllDatasets.ast);
+      log('AllDatasets', { ast: AllDatasets.ast });
+      expect(AllDatasets.ast).toMatchInlineSnapshot(`
+        {
+          "filter": {
+            "filters": [
+              {
+                "props": {},
+                "type": "object",
+                "typename": "dxn:type:org.dxos.type.feed:0.1.0",
+              },
+              {
+                "props": {},
+                "type": "object",
+                "typename": "dxn:type:org.dxos.type.collection:0.1.0",
+              },
+              {
+                "props": {},
+                "type": "object",
+                "typename": "dxn:type:org.dxos.type.view:0.1.0",
+              },
+            ],
+            "type": "or",
+          },
+          "type": "select",
+        }
+      `);
+    });
+
+    test('Query.type(Dataset.Dataset) (union of schemas)', () => {
+      const AllDatasets = Query.type(Dataset.Dataset);
+
+      log('query', { ast: AllDatasets.ast });
+      Schema.validateSync(QueryAST.Query)(AllDatasets.ast);
+      log('AllDatasets', { ast: AllDatasets.ast });
+      expect(AllDatasets.ast).toMatchInlineSnapshot(`
+        {
+          "filter": {
+            "filters": [
+              {
+                "props": {},
+                "type": "object",
+                "typename": "dxn:type:org.dxos.type.feed:0.1.0",
+              },
+              {
+                "props": {},
+                "type": "object",
+                "typename": "dxn:type:org.dxos.type.collection:0.1.0",
+              },
+              {
+                "props": {},
+                "type": "object",
+                "typename": "dxn:type:org.dxos.type.view:0.1.0",
+              },
+            ],
+            "type": "or",
+          },
+          "type": "select",
+        }
+      `);
+    });
+
     test('get all people not in orgs', () => {
       const PeopleNotInOrganizations = Query.without(
         Query.select(Filter.type(TestSchema.Person)),
@@ -190,7 +258,7 @@ describe('query api', () => {
             "id": undefined,
             "props": {},
             "type": "object",
-            "typename": "dxn:type:example.com/type/Person:0.1.0",
+            "typename": "dxn:type:com.example.type.person:0.1.0",
           },
           "type": "select",
         },
@@ -213,7 +281,7 @@ describe('query api', () => {
           },
         },
         type: 'object',
-        typename: 'dxn:type:example.com/type/Task:0.1.0',
+        typename: 'dxn:type:com.example.type.task:0.1.0',
       });
       log('tasksByFred', { ast: tasksByFred.ast });
     });
@@ -232,13 +300,13 @@ describe('query api', () => {
               "id": undefined,
               "props": {},
               "type": "object",
-              "typename": "dxn:type:example.com/type/Organization:0.1.0",
+              "typename": "dxn:type:com.example.type.organization:0.1.0",
             },
             {
               "id": undefined,
               "props": {},
               "type": "object",
-              "typename": "dxn:type:example.com/type/Person:0.1.0",
+              "typename": "dxn:type:com.example.type.person:0.1.0",
             },
           ],
           "type": "or",
@@ -263,13 +331,13 @@ describe('query api', () => {
                 "id": undefined,
                 "props": {},
                 "type": "object",
-                "typename": "dxn:type:example.com/type/Organization:0.1.0",
+                "typename": "dxn:type:com.example.type.organization:0.1.0",
               },
               {
                 "id": undefined,
                 "props": {},
                 "type": "object",
-                "typename": "dxn:type:example.com/type/Person:0.1.0",
+                "typename": "dxn:type:com.example.type.person:0.1.0",
               },
             ],
             "type": "or",
@@ -297,7 +365,7 @@ describe('query api', () => {
             "id": undefined,
             "props": {},
             "type": "object",
-            "typename": "dxn:type:example.com/type/Task:0.1.0",
+            "typename": "dxn:type:com.example.type.task:0.1.0",
           },
           "type": "select",
         },
@@ -320,7 +388,7 @@ describe('query api', () => {
               "id": undefined,
               "props": {},
               "type": "object",
-              "typename": "dxn:type:example.com/type/Task:0.1.0",
+              "typename": "dxn:type:com.example.type.task:0.1.0",
             },
             "type": "select",
           },
@@ -340,7 +408,7 @@ describe('query api', () => {
               "id": undefined,
               "props": {},
               "type": "object",
-              "typename": "dxn:type:example.com/type/Task:0.1.0",
+              "typename": "dxn:type:com.example.type.task:0.1.0",
             },
             "type": "select",
           },
@@ -368,7 +436,7 @@ describe('query api', () => {
                 "id": undefined,
                 "props": {},
                 "type": "object",
-                "typename": "dxn:type:example.com/type/Task:0.1.0",
+                "typename": "dxn:type:com.example.type.task:0.1.0",
               },
               "type": "select",
             },
@@ -395,7 +463,7 @@ describe('query api', () => {
                   "id": undefined,
                   "props": {},
                   "type": "object",
-                  "typename": "dxn:type:example.com/type/Person:0.1.0",
+                  "typename": "dxn:type:com.example.type.person:0.1.0",
                 },
                 "type": "select",
               },
@@ -408,7 +476,7 @@ describe('query api', () => {
                   "id": undefined,
                   "props": {},
                   "type": "object",
-                  "typename": "dxn:type:example.com/type/Organization:0.1.0",
+                  "typename": "dxn:type:com.example.type.organization:0.1.0",
                 },
                 "type": "select",
               },
@@ -420,6 +488,151 @@ describe('query api', () => {
       `);
     });
 
+    test('from all accessible spaces', () => {
+      const query = Query.select(Filter.type(TestSchema.Person)).from('all-accessible-spaces');
+
+      Schema.validateSync(QueryAST.Query)(query.ast);
+      expect(query.ast).toMatchInlineSnapshot(`
+        {
+          "from": {
+            "_tag": "scope",
+            "scope": {},
+          },
+          "query": {
+            "filter": {
+              "id": undefined,
+              "props": {},
+              "type": "object",
+              "typename": "dxn:type:com.example.type.person:0.1.0",
+            },
+            "type": "select",
+          },
+          "type": "from",
+        }
+      `);
+    });
+
+    test('from all accessible spaces with feeds', () => {
+      const query = Query.select(Filter.type(TestSchema.Person)).from('all-accessible-spaces', {
+        includeFeeds: true,
+      });
+
+      Schema.validateSync(QueryAST.Query)(query.ast);
+      expect(query.ast).toMatchInlineSnapshot(`
+        {
+          "from": {
+            "_tag": "scope",
+            "scope": {
+              "allQueuesFromSpaces": true,
+            },
+          },
+          "query": {
+            "filter": {
+              "id": undefined,
+              "props": {},
+              "type": "object",
+              "typename": "dxn:type:com.example.type.person:0.1.0",
+            },
+            "type": "select",
+          },
+          "type": "from",
+        }
+      `);
+    });
+
+    test('from all accessible spaces with ordering and limit', () => {
+      const query = Query.select(Filter.type(TestSchema.Person))
+        .orderBy(Order.property('name', 'asc'))
+        .limit(10)
+        .from('all-accessible-spaces');
+
+      Schema.validateSync(QueryAST.Query)(query.ast);
+      expect(query.ast).toMatchObject({
+        type: 'from',
+        from: { _tag: 'scope', scope: {} },
+        query: {
+          type: 'limit',
+          limit: 10,
+          query: {
+            type: 'order',
+          },
+        },
+      });
+    });
+
+    test('Query.type(...).from(feed) sets queue scope', async () => {
+      const spaceId = SpaceId.random();
+      const feedId = ObjectId.random();
+      const feedDxn = DXN.parse(`dxn:echo:${spaceId}:${feedId}`);
+      const feed = (await Obj.fromJSON(
+        {
+          '@type': 'dxn:type:org.dxos.type.feed:0.1.0',
+          id: feedId,
+          name: 'test-feed',
+        },
+        { dxn: feedDxn },
+      )) as Feed.Feed;
+
+      const expectedQueueDxn = new DXN(DXN.kind.QUEUE, ['data', spaceId, feedId]);
+
+      const query = Query.type(TestSchema.Person).from(feed);
+      Schema.validateSync(QueryAST.Query)(query.ast);
+      expect(query.ast).toMatchObject({
+        type: 'from',
+        from: {
+          _tag: 'scope',
+          scope: {
+            queues: [expectedQueueDxn.toString()],
+          },
+        },
+        query: {
+          type: 'select',
+          filter: {
+            type: 'object',
+            typename: 'dxn:type:com.example.type.person:0.1.0',
+          },
+        },
+      });
+    });
+
+    test('Query.from(non-feed) throws TypeError', () => {
+      const person = Obj.make(TestSchema.Person, { name: 'Fred' });
+      expect(() => Query.select(Filter.type(TestSchema.Person)).from(person as any)).toThrow(TypeError);
+      expect(() => Query.select(Filter.type(TestSchema.Person)).from(person as any)).toThrow(
+        /Query\.from\(\) expects Feed objects/,
+      );
+    });
+
+    test('Query.from(undefined) throws TypeError', () => {
+      expect(() => Query.select(Filter.type(TestSchema.Person)).from(undefined as any)).toThrow(TypeError);
+      expect(() => Query.select(Filter.type(TestSchema.Person)).from(undefined as any)).toThrow(
+        /Query\.from\(\) requires a valid data source argument/,
+      );
+    });
+
+    test('Query.from(null) throws TypeError', () => {
+      expect(() => Query.select(Filter.type(TestSchema.Person)).from(null as any)).toThrow(TypeError);
+      expect(() => Query.select(Filter.type(TestSchema.Person)).from(null as any)).toThrow(
+        /Query\.from\(\) requires a valid data source argument/,
+      );
+    });
+
+    test('Query.pretty returns human-readable query string', () => {
+      const query = Query.select(Filter.type(TestSchema.Person, { name: 'Fred' }));
+      const pretty = Query.pretty(query);
+      expect(pretty).toContain('Query.select');
+      expect(pretty).toContain('Filter.type');
+      expect(pretty).toContain('com.example.type.person');
+    });
+
+    test('Query.pretty handles complex queries', () => {
+      const query = Query.select(Filter.and(Filter.type(TestSchema.Person), Filter.id(ObjectId.random()))).limit(10);
+      const pretty = Query.pretty(query);
+      expect(pretty).toContain('Query.select');
+      expect(pretty).toContain('Filter.and');
+      expect(pretty).toContain('limit(10)');
+    });
+
     test.skip('chain', () => {
       // NOTE: Can't support props without type since they can't be inferred.
       // const f1: Filter<Person> = Filter.props({ name: 'Fred' });
@@ -455,11 +668,122 @@ describe('query api', () => {
     });
   });
 
+  describe('Filter.childOf', () => {
+    test('childOf with DXN', () => {
+      const parentDxn = DXN.fromSpaceAndObjectId(SpaceId.random(), ObjectId.random());
+      const filter = Filter.childOf(parentDxn);
+
+      expect(filter.ast).toMatchObject({
+        type: 'child-of',
+        parents: [parentDxn.toString()],
+        transitive: true,
+      });
+      Schema.validateSync(QueryAST.Filter)(filter.ast);
+    });
+
+    test('childOf with object', () => {
+      const parent = Obj.make(TestSchema.Person, { name: 'Parent' });
+      const filter = Filter.childOf(parent);
+
+      expect(filter.ast).toMatchObject({
+        type: 'child-of',
+        transitive: true,
+      });
+      expect(filter.ast.type === 'child-of' && filter.ast.parents.length).toBe(1);
+      Schema.validateSync(QueryAST.Filter)(filter.ast);
+    });
+
+    test('childOf with array of DXNs', () => {
+      const dxn1 = DXN.fromSpaceAndObjectId(SpaceId.random(), ObjectId.random());
+      const dxn2 = DXN.fromSpaceAndObjectId(SpaceId.random(), ObjectId.random());
+      const filter = Filter.childOf([dxn1, dxn2]);
+
+      expect(filter.ast).toMatchObject({
+        type: 'child-of',
+        parents: [dxn1.toString(), dxn2.toString()],
+        transitive: true,
+      });
+      Schema.validateSync(QueryAST.Filter)(filter.ast);
+    });
+
+    test('childOf with transitive=false', () => {
+      const parentDxn = DXN.fromSpaceAndObjectId(SpaceId.random(), ObjectId.random());
+      const filter = Filter.childOf(parentDxn, { transitive: false });
+
+      expect(filter.ast).toMatchObject({
+        type: 'child-of',
+        parents: [parentDxn.toString()],
+        transitive: false,
+      });
+      Schema.validateSync(QueryAST.Filter)(filter.ast);
+    });
+
+    test('childOf in select query', () => {
+      const parentDxn = DXN.fromSpaceAndObjectId(SpaceId.random(), ObjectId.random());
+      const query = Query.select(Filter.childOf(parentDxn));
+
+      expect(query.ast).toMatchObject({
+        type: 'select',
+        filter: {
+          type: 'child-of',
+          parents: [parentDxn.toString()],
+          transitive: true,
+        },
+      });
+      Schema.validateSync(QueryAST.Query)(query.ast);
+    });
+
+    test('childOf combined with type filter', () => {
+      const parentDxn = DXN.fromSpaceAndObjectId(SpaceId.random(), ObjectId.random());
+      const query = Query.select(Filter.and(Filter.type(TestSchema.Person), Filter.childOf(parentDxn)));
+
+      Schema.validateSync(QueryAST.Query)(query.ast);
+      expect(query.ast).toMatchObject({
+        type: 'select',
+        filter: {
+          type: 'and',
+          filters: [
+            { type: 'object', typename: 'dxn:type:com.example.type.person:0.1.0' },
+            { type: 'child-of', parents: [parentDxn.toString()], transitive: true },
+          ],
+        },
+      });
+    });
+
+    test('childOf pretty-prints correctly', () => {
+      const parentDxn = DXN.fromSpaceAndObjectId(SpaceId.random(), ObjectId.random());
+      const filter = Filter.childOf(parentDxn);
+      const pretty = Filter.pretty(filter);
+      expect(pretty).toContain('Filter.childOf');
+      expect(pretty).toContain('transitive: true');
+    });
+  });
+
   describe('Filter', () => {
     test('Filter.or(Filter.typename(...))', () => {
-      const filter = Filter.or(Filter.typename('example.com/type/Person'));
+      const filter = Filter.or(Filter.typename('com.example.type.person'));
       // TODO(dmaretskyi): Give vitest type-tests a try.
       const _isAssignable: Obj.Unknown = null as any as Filter.Type<typeof filter>;
     });
+
+    test('Filter.pretty returns human-readable filter string', () => {
+      const filter = Filter.type(TestSchema.Person, { name: 'Fred' });
+      const pretty = Filter.pretty(filter);
+      expect(pretty).toContain('Filter.type');
+      expect(pretty).toContain('com.example.type.person');
+    });
+
+    test('Filter.pretty handles complex filters', () => {
+      const filter = Filter.and(Filter.type(TestSchema.Person), Filter.id(ObjectId.random()));
+      const pretty = Filter.pretty(filter);
+      expect(pretty).toContain('Filter.and');
+      expect(pretty).toContain('Filter.type');
+    });
+
+    test('Filter.pretty handles or filters', () => {
+      const filter = Filter.or(Filter.type(TestSchema.Person), Filter.type(TestSchema.Organization));
+      const pretty = Filter.pretty(filter);
+      expect(pretty).toContain('Filter.or');
+    });
   });
 });