@dxos/echo 0.8.2-main.5ca3450 → 0.8.2-main.600d381

package/src/query/ast.ts

@@ -6,144 +6,174 @@ import { Schema } from 'effect';
 
 import { DXN } from '@dxos/echo-schema';
 
-export const Predicate = Schema.Union(
-  Schema.Struct({
-    type: Schema.Literal('eq'),
-    value: Schema.Any,
-  }),
-  Schema.Struct({
-    type: Schema.Literal('neq'),
-    value: Schema.Any,
-  }),
-  Schema.Struct({
-    type: Schema.Literal('gt'),
-    value: Schema.Any,
-  }),
-  Schema.Struct({
-    type: Schema.Literal('gte'),
-    value: Schema.Any,
-  }),
-  Schema.Struct({
-    type: Schema.Literal('lt'),
-    value: Schema.Any,
-  }),
-  Schema.Struct({
-    type: Schema.Literal('lte'),
-    value: Schema.Any,
-  }),
-  Schema.Struct({
-    type: Schema.Literal('in'),
-    values: Schema.Array(Schema.Any),
-  }),
-  Schema.Struct({
-    type: Schema.Literal('range'),
-    from: Schema.Any,
-    to: Schema.Any,
+const TypenameSpecifier = Schema.Union(DXN, Schema.Null).annotations({
+  description: 'DXN or null. Null means any type will match',
+});
+
+// NOTE: This pattern with 3 definitions per schema is need to make the types opaque, and circular references in AST to not cause compiler errors.
+
+const FilterObject_ = Schema.Struct({
+  type: Schema.Literal('object'),
+  typename: TypenameSpecifier,
+  props: Schema.Record({
+    key: Schema.String.annotations({ description: 'Property name' }),
+    value: Schema.suspend(() => Filter),
   }),
-);
+});
+interface FilterObject extends Schema.Schema.Type<typeof FilterObject_> {}
+const FilterObject: Schema.Schema<FilterObject> = FilterObject_;
 
-export type Predicate = Schema.Schema.Type<typeof Predicate>;
+const FilterCompare_ = Schema.Struct({
+  type: Schema.Literal('compare'),
+  operator: Schema.Literal('eq', 'neq', 'gt', 'gte', 'lt', 'lte'),
+  value: Schema.Unknown,
+});
+interface FilterCompare extends Schema.Schema.Type<typeof FilterCompare_> {}
+const FilterCompare: Schema.Schema<FilterCompare> = FilterCompare_;
 
-export const PredicateSet = Schema.Record({
-  key: Schema.String.annotations({ description: 'Property name' }),
-  value: Predicate,
+const FilterIn_ = Schema.Struct({
+  type: Schema.Literal('in'),
+  values: Schema.Array(Schema.Any),
 });
+interface FilterIn extends Schema.Schema.Type<typeof FilterIn_> {}
+const FilterIn: Schema.Schema<FilterIn> = FilterIn_;
 
-export type PredicateSet = Schema.Schema.Type<typeof PredicateSet>;
+const FilterRange_ = Schema.Struct({
+  type: Schema.Literal('range'),
+  from: Schema.Any,
+  to: Schema.Any,
+});
+interface FilterRange extends Schema.Schema.Type<typeof FilterRange_> {}
+const FilterRange: Schema.Schema<FilterRange> = FilterRange_;
 
-const TypenameSpecifier = Schema.Union(DXN, Schema.Null).annotations({
-  description: 'DXN or null. Null means any type will match',
+const FilterTextSearch_ = Schema.Struct({
+  type: Schema.Literal('text-search'),
+  typename: TypenameSpecifier,
+  text: Schema.String,
+  searchKind: Schema.optional(Schema.Literal('full-text', 'vector')),
 });
+interface FilterTextSearch extends Schema.Schema.Type<typeof FilterTextSearch_> {}
+const FilterTextSearch: Schema.Schema<FilterTextSearch> = FilterTextSearch_;
 
-// NOTE: This pattern with 3 definitions per schema is need to make the types opaque, and circular references in AST to not cause compiler errors.
+const FilterNot_ = Schema.Struct({
+  type: Schema.Literal('not'),
+  filter: Schema.suspend(() => Filter),
+});
+interface FilterNot extends Schema.Schema.Type<typeof FilterNot_> {}
+const FilterNot: Schema.Schema<FilterNot> = FilterNot_;
+
+const FilterAnd_ = Schema.Struct({
+  type: Schema.Literal('and'),
+  filters: Schema.Array(Schema.suspend(() => Filter)),
+});
+interface FilterAnd extends Schema.Schema.Type<typeof FilterAnd_> {}
+const FilterAnd: Schema.Schema<FilterAnd> = FilterAnd_;
+
+const FilterOr_ = Schema.Struct({
+  type: Schema.Literal('or'),
+  filters: Schema.Array(Schema.suspend(() => Filter)),
+});
+interface FilterOr extends Schema.Schema.Type<typeof FilterOr_> {}
+const FilterOr: Schema.Schema<FilterOr> = FilterOr_;
+
+export const Filter = Schema.Union(
+  FilterObject,
+  FilterTextSearch,
+  FilterCompare,
+  FilterIn,
+  FilterRange,
+  FilterNot,
+  FilterAnd,
+  FilterOr,
+);
+export type Filter = Schema.Schema.Type<typeof Filter>;
 
 /**
  * Query objects by type, id, and/or predicates.
  */
-const ASTTypeClause_ = Schema.Struct({
-  type: Schema.Literal('type'),
-  typename: TypenameSpecifier,
-  id: Schema.optional(Schema.String),
-  predicates: Schema.optional(PredicateSet),
+const QuerySelectClause_ = Schema.Struct({
+  type: Schema.Literal('select'),
+  filter: Schema.suspend(() => Filter),
 });
-interface ASTTypeClause extends Schema.Schema.Type<typeof ASTTypeClause_> {}
-const ASTTypeClause: Schema.Schema<ASTTypeClause> = ASTTypeClause_;
+interface QuerySelectClause extends Schema.Schema.Type<typeof QuerySelectClause_> {}
+const QuerySelectClause: Schema.Schema<QuerySelectClause> = QuerySelectClause_;
 
-const ASTTextSearchClause_ = Schema.Struct({
-  type: Schema.Literal('text-search'),
-  typename: TypenameSpecifier,
-  text: Schema.String,
-  searchKind: Schema.optional(Schema.Literal('full-text', 'vector')),
+/**
+ * Filter objects from selection.
+ */
+const QueryFilterClause_ = Schema.Struct({
+  type: Schema.Literal('filter'),
+  selection: Schema.suspend(() => Query),
+  filter: Schema.suspend(() => Filter),
 });
-interface ASTTextSearchClause extends Schema.Schema.Type<typeof ASTTextSearchClause_> {}
-const ASTTextSearchClause: Schema.Schema<ASTTextSearchClause> = ASTTextSearchClause_;
+interface QueryFilterClause extends Schema.Schema.Type<typeof QueryFilterClause_> {}
+const QueryFilterClause: Schema.Schema<QueryFilterClause> = QueryFilterClause_;
 
 /**
  * Traverse references from an anchor object.
  */
-const ASTReferenceTraversalClause_ = Schema.Struct({
+const QueryReferenceTraversalClause_ = Schema.Struct({
   type: Schema.Literal('reference-traversal'),
-  anchor: Schema.suspend(() => AST),
+  anchor: Schema.suspend(() => Query),
   property: Schema.String,
 });
-interface ASTReferenceTraversalClause extends Schema.Schema.Type<typeof ASTReferenceTraversalClause_> {}
-const ASTReferenceTraversalClause: Schema.Schema<ASTReferenceTraversalClause> = ASTReferenceTraversalClause_;
+interface QueryReferenceTraversalClause extends Schema.Schema.Type<typeof QueryReferenceTraversalClause_> {}
+const QueryReferenceTraversalClause: Schema.Schema<QueryReferenceTraversalClause> = QueryReferenceTraversalClause_;
 
 /**
  * Traverse incoming references to an anchor object.
  */
-const ASTIncomingReferencesClause_ = Schema.Struct({
+const QueryIncomingReferencesClause_ = Schema.Struct({
   type: Schema.Literal('incoming-references'),
-  anchor: Schema.suspend(() => AST),
+  anchor: Schema.suspend(() => Query),
   property: Schema.String,
   typename: TypenameSpecifier,
 });
-interface ASTIncomingReferencesClause extends Schema.Schema.Type<typeof ASTIncomingReferencesClause_> {}
-const ASTIncomingReferencesClause: Schema.Schema<ASTIncomingReferencesClause> = ASTIncomingReferencesClause_;
+interface QueryIncomingReferencesClause extends Schema.Schema.Type<typeof QueryIncomingReferencesClause_> {}
+const QueryIncomingReferencesClause: Schema.Schema<QueryIncomingReferencesClause> = QueryIncomingReferencesClause_;
 
 /**
  * Traverse relations connecting to an anchor object.
  */
-const ASTRelationClause_ = Schema.Struct({
+const QueryRelationClause_ = Schema.Struct({
   type: Schema.Literal('relation'),
-  anchor: Schema.suspend(() => AST),
+  anchor: Schema.suspend(() => Query),
   direction: Schema.Literal('outgoing', 'incoming', 'both'),
-  typename: TypenameSpecifier,
-  predicates: Schema.optional(PredicateSet),
+  filter: Schema.optional(Schema.suspend(() => Filter)),
 });
-interface ASTRelationClause extends Schema.Schema.Type<typeof ASTRelationClause_> {}
-const ASTRelationClause: Schema.Schema<ASTRelationClause> = ASTRelationClause_;
+interface QueryRelationClause extends Schema.Schema.Type<typeof QueryRelationClause_> {}
+const QueryRelationClause: Schema.Schema<QueryRelationClause> = QueryRelationClause_;
 
 /**
  * Traverse into the source or target of a relation.
  */
-const ASTRelationTraversalClause_ = Schema.Struct({
+const QueryRelationTraversalClause_ = Schema.Struct({
   type: Schema.Literal('relation-traversal'),
-  anchor: Schema.suspend(() => AST),
+  anchor: Schema.suspend(() => Query),
   direction: Schema.Literal('source', 'target', 'both'),
 });
-interface ASTRelationTraversalClause extends Schema.Schema.Type<typeof ASTRelationTraversalClause_> {}
-const ASTRelationTraversalClause: Schema.Schema<ASTRelationTraversalClause> = ASTRelationTraversalClause_;
+interface QueryRelationTraversalClause extends Schema.Schema.Type<typeof QueryRelationTraversalClause_> {}
+const QueryRelationTraversalClause: Schema.Schema<QueryRelationTraversalClause> = QueryRelationTraversalClause_;
 
 /**
  * Union of multiple queries.
  */
-const ASTUnionClause_ = Schema.Struct({
+const QueryUnionClause_ = Schema.Struct({
   type: Schema.Literal('union'),
-  queries: Schema.Array(Schema.suspend(() => AST)),
-});
-interface ASTUnionClause extends Schema.Schema.Type<typeof ASTUnionClause_> {}
-const ASTUnionClause: Schema.Schema<ASTUnionClause> = ASTUnionClause_;
-
-const AST_ = Schema.Union(
-  ASTTypeClause,
-  ASTTextSearchClause,
-  ASTReferenceTraversalClause,
-  ASTIncomingReferencesClause,
-  ASTRelationClause,
-  ASTRelationTraversalClause,
-  ASTUnionClause,
+  queries: Schema.Array(Schema.suspend(() => Query)),
+});
+interface QueryUnionClause extends Schema.Schema.Type<typeof QueryUnionClause_> {}
+const QueryUnionClause: Schema.Schema<QueryUnionClause> = QueryUnionClause_;
+
+const Query_ = Schema.Union(
+  QuerySelectClause,
+  QueryFilterClause,
+  QueryReferenceTraversalClause,
+  QueryIncomingReferencesClause,
+  QueryRelationClause,
+  QueryRelationTraversalClause,
+  QueryUnionClause,
 );
 
-export type AST = Schema.Schema.Type<typeof AST_>;
-export const AST: Schema.Schema<AST> = AST_;
+export type Query = Schema.Schema.Type<typeof Query_>;
+export const Query: Schema.Schema<Query> = Query_;

package/src/query/query.test.ts

@@ -8,7 +8,8 @@ import { describe, test } from 'vitest';
 import { create } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 
-import { Query } from './api';
+import { Filter, Query } from './api';
+import * as QueryAST from './ast';
 import { Type, Relation } from '..';
 
 //
@@ -18,6 +19,7 @@ import { Type, Relation } from '..';
 const Person = Schema.Struct({
   name: Schema.String,
   email: Schema.optional(Schema.String),
+  age: Schema.optional(Schema.Number),
 }).pipe(Type.def({ typename: 'dxos.org/type/Person', version: '0.1.0' }));
 interface Person extends Schema.Schema.Type<typeof Person> {}
 
@@ -48,88 +50,97 @@ describe('query api', () => {
     const getAllPeople = Query.type(Person);
 
     log.info('query', { ast: getAllPeople.ast });
+    Schema.validateSync(QueryAST.Query)(getAllPeople.ast);
   });
 
   test('get all people named Fred', () => {
     // Query<Person>
-    const getAllPeopleNamedFred = Query.type(Person, { name: 'Fred' });
+    const getAllPeopleNamedFred = Query.select(Filter.type(Person, { name: 'Fred' }));
 
     log.info('query', { ast: getAllPeopleNamedFred.ast });
+    Schema.validateSync(QueryAST.Query)(getAllPeopleNamedFred.ast);
   });
 
   test('get all orgs Fred worked for since 2020', () => {
     // Query<Org>
     const fred = create(Person, { name: 'Fred' });
-    const getAllOrgsFredWorkedForSince2020 = Query.type(Person, { id: fred.id })
-      .sourceOf(WorksFor, { since: Query.gt('2020') })
+    const getAllOrgsFredWorkedForSince2020 = Query.select(Filter.type(Person, { id: fred.id }))
+      .sourceOf(WorksFor, { since: Filter.gt('2020') })
       .target();
 
     log.info('query', { ast: getAllOrgsFredWorkedForSince2020.ast });
+    Schema.validateSync(QueryAST.Query)(getAllOrgsFredWorkedForSince2020.ast);
   });
 
   test('get all tasks for Fred', () => {
     // Query<Task>
     const fred = create(Person, { name: 'Fred' });
-    const getAllTasksForFred = Query.type(Person, { id: fred.id }).referencedBy(Task, 'assignee');
+    const getAllTasksForFred = Query.select(Filter.type(Person, { id: fred.id })).referencedBy(Task, 'assignee');
 
     log.info('query', { ast: getAllTasksForFred.ast });
+    Schema.validateSync(QueryAST.Query)(getAllTasksForFred.ast);
   });
 
   test('get all tasks for employees of Cyberdyne', () => {
     // Query<Task>
-    const allTasksForEmployeesOfCyberdyne = Query.type(Org, { name: 'Cyberdyne' })
+    const allTasksForEmployeesOfCyberdyne = Query.select(Filter.type(Org, { name: 'Cyberdyne' }))
       .targetOf(WorksFor)
       .source()
       .referencedBy(Task, 'assignee');
 
     log.info('query', { ast: allTasksForEmployeesOfCyberdyne.ast });
+    Schema.validateSync(QueryAST.Query)(allTasksForEmployeesOfCyberdyne.ast);
   });
 
   test('get all people or orgs', () => {
     // Query<Person | Org>
-    const allPeopleOrOrgs = Query.all(Query.type(Person), Query.type(Org));
+    const allPeopleOrOrgs = Query.all(Query.select(Filter.type(Person)), Query.select(Filter.type(Org)));
 
     log.info('query', { ast: allPeopleOrOrgs.ast });
+    Schema.validateSync(QueryAST.Query)(allPeopleOrOrgs.ast);
   });
 
   test('get assignees of all tasks created after 2020', () => {
     // Query<Person>
-    const assigneesOfAllTasksCreatedAfter2020 = Query.type(Task, { createdAt: Query.gt('2020') }).reference('assignee');
+    const assigneesOfAllTasksCreatedAfter2020 = Query.select(
+      Filter.type(Task, { createdAt: Filter.gt('2020') }),
+    ).reference('assignee');
 
     log.info('query', { ast: assigneesOfAllTasksCreatedAfter2020.ast });
+    Schema.validateSync(QueryAST.Query)(assigneesOfAllTasksCreatedAfter2020.ast);
   });
 
   test('contact full-text search', () => {
     // Query<Person>
-    const contactFullTextSearch = Query.text(Person, 'Bill');
+    const contactFullTextSearch = Query.select(Filter.text(Person, 'Bill'));
 
     log.info('query', { ast: contactFullTextSearch.ast });
+    Schema.validateSync(QueryAST.Query)(contactFullTextSearch.ast);
   });
 
-  // TODO(burdon): Experimental.
   test.skip('chain', () => {
-    const db: any = null;
-    const Query: any = null;
-    const Filter: any = null;
+    // NOTE: Can't support props without type since they can't be inferred.
+    // const f1: Filter<Person> = Filter.props({ name: 'Fred' });
 
-    const x = db.exec(Query.select({ id: '123' })).first();
-    const y = db.exec(Query.select(Filter.type(Person)).first());
+    // const x = Query.select(Filter.props({ id: '123' }));
+    const y = Query.select(Filter.type(Person));
+
+    const fOr = Filter.or(Filter.type(Person, { id: Filter.in('1', '2', '3') }), Filter.type(Org));
+
+    const fAnd = Filter.and(
+      Filter.type(Person, { id: Filter.in('1', '2', '3') }),
+      Filter.type(Person, { name: 'Fred' }),
+    );
 
     const q = Query
       //
-      .selectAll()
-      .select({ id: '123' })
       // NOTE: Can't support functions since they can't be serialized (to server).
       // .filter((object) => Math.random() > 0.5)
       .select(Filter.type(Person))
-      .select(Filter.props({ name: 'Fred' }))
-      .select({ age: Filter.gt(40) })
-      .select({ date: Filter.between(Date.now(), Date.now() + 1000 * 60 * 60 * 24) })
-      .select({ id: Filter.in(['1', '2', '3']) })
-      .select(Filter.and(Filter.type(Person), Filter.props({ id: Filter.in(['1', '2', '3']) })))
-      .target()
-      .select();
-
-    log.info('stuff', { x, y, q });
+      .select(Filter.type(Person, { name: 'Fred' }))
+      .select({ age: Filter.between(20, 40) })
+      .select(Filter.and(Filter.type(Person), Filter.type(Person, { name: Filter.in('bob', 'bill') })));
+
+    log.info('stuff', { fOr, fAnd, q, y });
   });
 });

package/src/type/Type.test.ts

@@ -37,14 +37,25 @@ namespace Testing {
 
   export interface Person extends Schema.Schema.Type<typeof Person> {}
 
-  export const Message = Schema.Struct({
-    // TODO(burdon): Support S.Date; Custom Timestamp (with defaults).
-    // TODO(burdon): Support defaults (update create and create).
-    timestamp: Schema.String.pipe(
-      Schema.propertySignature,
-      Schema.withConstructorDefault(() => new Date().toISOString()),
-    ),
-  });
+  // export const WorksFor = S.Struct({
+  //   id: Type.ObjectId,
+  //   since: S.String,
+  //   jobTitle: S.String,
+  //   ...Range({ from, to }),
+  //   ...Provenance({ source: 'duckduckgo.com', confidence: 0.9 }), // keys
+  //   ...Relation.make({ source: Contact, target: Organization }),
+  // }).pipe(
+  //   Relation.def({
+  //     typename: 'example.com/relation/WorksFor',
+  //     version: '0.1.0',
+  //   }),
+  // );
+
+  // {
+  //   const contact = db.add(create(Contact, { name: 'Test' }));
+  //   const organization = db.add(create(Organization, { name: 'DXOS' }));
+  //   db.add(create(WorksFor, { source: contact, target: organization }));
+  // }
 
   export const WorksFor = Schema.Struct({
     // id: Type.ObjectId,
@@ -61,13 +72,23 @@ namespace Testing {
 
   export interface WorksFor extends Schema.Schema.Type<typeof WorksFor> {}
 
-  // TODO(burdon): Fix (Type.def currently removes TypeLiteral that implements the `make` function)..
-  // }).pipe(
-  //   Type.def({
-  //     typename: 'example.com/type/Message',
-  //     version: '0.1.0',
-  //   }),
-  // );
+  // TODO(burdon): Fix (Type.def currently removes TypeLiteral that implements the `make` function).
+  //  Property 'make' does not exist on type 'EchoObjectSchema<Struct<{ timestamp: PropertySignature<":", string, never, ":", string, true, never>; }>>'.ts(2339)
+  export const MessageStruct = Schema.Struct({
+    // TODO(burdon): Support S.Date; Custom Timestamp (with defaults).
+    // TODO(burdon): Support defaults (update create and create).
+    timestamp: Schema.String.pipe(
+      Schema.propertySignature,
+      Schema.withConstructorDefault(() => new Date().toISOString()),
+    ),
+  });
+
+  export const Message = MessageStruct.pipe(
+    Type.def({
+      typename: 'example.com/type/Message',
+      version: '0.1.0',
+    }),
+  );
 
   export interface Message extends Schema.Schema.Type<typeof Message> {}
 }
@@ -98,9 +119,7 @@ describe('Experimental API review', () => {
   });
 
   test('default props', ({ expect }) => {
-    // TODO(burdon): Doesn't work after pipe(Type.def).
-    // Property 'make' does not exist on type 'EchoObjectSchema<Struct<{ timestamp: PropertySignature<":", string, never, ":", string, true, never>; }>>'.ts(2339)
-    const message = Type.create(Testing.Message, Testing.Message.make({}));
+    const message = Type.create(Testing.Message, Testing.MessageStruct.make({}));
     expect(message.timestamp).to.exist;
   });
 });