@dxos/echo-query 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo-query",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "ECHO queries.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -19,7 +19,12 @@
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "default": "./dist/lib/neutral/index.mjs"
+      "import": "./dist/lib/index.mjs"
+    },
+    "./sandbox": {
+      "source": "./src/sandbox/index.ts",
+      "types": "./dist/types/src/sandbox/index.d.ts",
+      "import": "./dist/lib/sandbox.mjs"
     },
     "./api.d.ts": "./dist/query-lite/index.d.ts"
   },
@@ -31,20 +36,20 @@
   "dependencies": {
     "@lezer/common": "^1.5.2",
     "@lezer/lr": "^1.4.10",
-    "@dxos/context": "0.10.0",
-    "@dxos/echo": "0.10.0",
-    "@dxos/echo-protocol": "0.10.0",
-    "@dxos/node-std": "0.10.0",
-    "@dxos/vendor-quickjs": "0.10.0",
-    "@dxos/util": "0.10.0",
-    "@dxos/invariant": "0.10.0"
+    "@dxos/context": "0.11.0",
+    "@dxos/echo": "0.11.0",
+    "@dxos/echo-protocol": "0.11.0",
+    "@dxos/node-std": "0.11.0",
+    "@dxos/util": "0.11.0",
+    "@dxos/vendor-quickjs": "0.11.0",
+    "@dxos/invariant": "0.11.0"
   },
   "devDependencies": {
     "@lezer/generator": "^1.8.0",
     "tsdown": "^0.16.7",
     "typescript": "^6.0.3",
-    "@dxos/echo-generator": "0.10.0",
-    "@dxos/random": "0.10.0"
+    "@dxos/echo-generator": "0.11.0",
+    "@dxos/random": "0.11.0"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -3,4 +3,7 @@
 //
 
 export * from './parser';
-export * from './sandbox';
+
+// NOTE: `./sandbox` (QuerySandbox) is intentionally NOT re-exported here. It runtime-imports the
+// vendored QuickJS wasm runtime (`@dxos/vendor-quickjs`), which every barrel consumer would then
+// pull into its bundle even though only sandbox users need it. Import it from `@dxos/echo-query/sandbox`.

package/src/query-lite/query-lite.ts

@@ -4,7 +4,15 @@
 
 import type * as Schema from 'effect/Schema';
 
-import type { Ref, Filter as Filter$, Obj as Obj$, Order as Order$, Query as Query$, Type as Type$ } from '@dxos/echo';
+import type {
+  Ref,
+  Aggregate as Aggregate$,
+  Filter as Filter$,
+  Obj as Obj$,
+  Order as Order$,
+  Query as Query$,
+  Type as Type$,
+} from '@dxos/echo';
 import type { ForeignKey, QueryAST } from '@dxos/echo-protocol';
 import { assertArgument } from '@dxos/invariant';
 // `DXN`/`EID` are type-only imports to keep the `query-lite` bundle free of
@@ -17,20 +25,30 @@ import type { DXN, EID, EntityId, URI } from '@dxos/keys';
 
 // TODO(wittjosiah): The `export * as ...` syntax causes tsdown to genereate multiple files which breaks the sandbox.
 
+// The TypeId brand keys mirror the constants in `@dxos/echo`. They are declared locally (typed by the
+// type-only imports) rather than imported as runtime values to keep this sandbox bundle free of the
+// `@dxos/echo` runtime graph.
+const OrderTypeId: Order$.OrderTypeId = '~@dxos/echo/Order';
+const FilterTypeId: Filter$.FilterTypeId = '~@dxos/echo/Filter';
+const QueryTypeId: Query$.QueryTypeId = '~@dxos/echo/Query';
+const ProjectionTypeId: Query$.ProjectionTypeId = '~@dxos/echo/Query.Projection';
+
 class OrderClass implements Order$.Any {
-  private static 'variance': Order$.Any['~Order'] = {} as Order$.Any['~Order'];
+  private static 'variance': Order$.Any[typeof OrderTypeId] = {} as Order$.Any[typeof OrderTypeId];
 
-  static 'is'(value: unknown): value is Order$.Any {
-    return typeof value === 'object' && value !== null && '~Order' in value;
+  static is(value: unknown): value is Order$.Any {
+    return typeof value === 'object' && value !== null && OrderTypeId in value;
   }
 
-  'constructor'(public readonly ast: QueryAST.Order) {}
+  constructor(public readonly ast: QueryAST.Order) {}
 
-  '~Order' = OrderClass.variance;
+  [OrderTypeId] = OrderClass.variance;
 }
 
 namespace Order1 {
-  export const natural: Order$.Any = new OrderClass({ kind: 'natural' });
+  export const OrderTypeId: Order$.OrderTypeId = '~@dxos/echo/Order';
+  export const natural = (direction: QueryAST.OrderDirection = 'asc'): Order$.Order<any> =>
+    new OrderClass({ kind: 'natural', direction });
   export const property = <T>(property: keyof T & string, direction: QueryAST.OrderDirection): Order$.Order<T> =>
     new OrderClass({
       kind: 'property',
@@ -96,6 +114,10 @@ const _filterMatchValueLocal = (filter: QueryAST.Filter, value: unknown): boolea
     }
     case 'in':
       return filter.values.includes(value);
+    case 'in-query':
+      // The QuickJS sandbox has no database access to run a subquery — a semi-join predicate
+      // must be resolved to a literal `in` by the query executor before reaching this matcher.
+      throw new Error('in-query filters are not supported in the sandboxed toPredicate matcher.');
     case 'range':
       return (value as any) >= filter.from && (value as any) <= filter.to;
     case 'not':
@@ -145,17 +167,19 @@ const _filterMatchEntityLocal = (filter: QueryAST.Filter, entity: any): boolean
 };
 
 class FilterClass implements Filter$.Any {
-  private static 'variance': Filter$.Any['~Filter'] = {} as Filter$.Any['~Filter'];
+  static 'FilterTypeId': Filter$.FilterTypeId = FilterTypeId;
+
+  private static 'variance': Filter$.Any[typeof FilterTypeId] = {} as Filter$.Any[typeof FilterTypeId];
 
-  static 'is'(value: unknown): value is Filter$.Any {
-    return typeof value === 'object' && value !== null && '~Filter' in value;
+  static is(value: unknown): value is Filter$.Any {
+    return typeof value === 'object' && value !== null && FilterTypeId in value;
   }
 
-  static 'fromAst'(ast: QueryAST.Filter): Filter$.Any {
+  static fromAst(ast: QueryAST.Filter): Filter$.Any {
     return new FilterClass(ast);
   }
 
-  static 'everything'(): FilterClass {
+  static everything(): FilterClass {
     return new FilterClass({
       type: 'object',
       typename: null,
@@ -163,7 +187,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'nothing'(): FilterClass {
+  static nothing(): FilterClass {
     return new FilterClass({
       type: 'not',
       filter: {
@@ -174,7 +198,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'relation'() {
+  static relation() {
     return new FilterClass({
       type: 'object',
       typename: null,
@@ -182,7 +206,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'id'(...ids: EntityId[]): Filter$.Any {
+  static id(...ids: EntityId[]): Filter$.Any {
     // assertArgument(
     //   ids.every((id) => EntityId.isValid(id)),
     //   'ids',
@@ -201,12 +225,12 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'type'<T extends Type$.AnyEntity>(
+  static type<T extends Type$.AnyEntity>(
     type: T,
     props?: Filter$.Props<Type$.InstanceType<T>>,
   ): Filter$.Filter<Type$.InstanceType<T>>;
-  static 'type'(schema: string, props?: Filter$.Props<unknown>): Filter$.Filter<any>;
-  static 'type'(schema: Type$.AnyEntity | string, props?: Filter$.Props<unknown>): Filter$.Filter<unknown> {
+  static type(schema: string, props?: Filter$.Props<unknown>): Filter$.Filter<any>;
+  static type(schema: Type$.AnyEntity | string, props?: Filter$.Props<unknown>): Filter$.Filter<unknown> {
     if (typeof schema !== 'string') {
       throw new TypeError('expected typename as the first paramter');
     }
@@ -217,7 +241,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'typename'(typename: string): Filter$.Any {
+  static typename(typename: string): Filter$.Any {
     return new FilterClass({
       type: 'object',
       typename: makeTypeDxn(typename),
@@ -225,7 +249,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'typeURI'(uri: URI.URI): Filter$.Any {
+  static typeURI(uri: URI.URI): Filter$.Any {
     return new FilterClass({
       type: 'object',
       typename: uri,
@@ -233,14 +257,14 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'tag'(tag: string): Filter$.Any {
+  static tag(tag: string): Filter$.Any {
     return new FilterClass({
       type: 'tag',
       tag,
     });
   }
 
-  static 'key'(key: string, options?: Filter$.KeyFilterOptions): Filter$.Any {
+  static key(key: string, options?: Filter$.KeyFilterOptions): Filter$.Any {
     return new FilterClass({
       type: 'object',
       typename: null,
@@ -250,7 +274,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'props'<T>(props: Filter$.Props<T>): Filter$.Filter<T> {
+  static props<T>(props: Filter$.Props<T>): Filter$.Filter<T> {
     return new FilterClass({
       type: 'object',
       typename: null,
@@ -258,7 +282,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'text'(text: string, options?: Filter$.TextSearchOptions): Filter$.Any {
+  static text(text: string, options?: Filter$.TextSearchOptions): Filter$.Any {
     return new FilterClass({
       type: 'text-search',
       text,
@@ -266,7 +290,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'foreignKeys'<S extends Type$.AnyEntity | string>(
+  static foreignKeys<S extends Type$.AnyEntity | string>(
     schema: S,
     keys: ForeignKey[],
   ): Filter$.Filter<S extends Type$.AnyEntity ? Type$.InstanceType<S> : unknown> {
@@ -280,7 +304,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'eq'<T>(value: T): Filter$.Filter<T | undefined> {
+  static eq<T>(value: T): Filter$.Filter<T | undefined> {
     if (!isRef(value) && typeof value === 'object' && value !== null) {
       throw new TypeError('Cannot use object as a value for eq filter');
     }
@@ -292,7 +316,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'neq'<T>(value: T): Filter$.Filter<T | undefined> {
+  static neq<T>(value: T): Filter$.Filter<T | undefined> {
     return new FilterClass({
       type: 'compare',
       operator: 'neq',
@@ -300,7 +324,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'gt'<T>(value: T): Filter$.Filter<T | undefined> {
+  static gt<T>(value: T): Filter$.Filter<T | undefined> {
     return new FilterClass({
       type: 'compare',
       operator: 'gt',
@@ -308,7 +332,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'gte'<T>(value: T): Filter$.Filter<T | undefined> {
+  static gte<T>(value: T): Filter$.Filter<T | undefined> {
     return new FilterClass({
       type: 'compare',
       operator: 'gte',
@@ -316,7 +340,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'lt'<T>(value: T): Filter$.Filter<T | undefined> {
+  static lt<T>(value: T): Filter$.Filter<T | undefined> {
     return new FilterClass({
       type: 'compare',
       operator: 'lt',
@@ -324,7 +348,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'lte'<T>(value: T): Filter$.Filter<T | undefined> {
+  static lte<T>(value: T): Filter$.Filter<T | undefined> {
     return new FilterClass({
       type: 'compare',
       operator: 'lte',
@@ -332,21 +356,21 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'in'<T>(...values: T[]): Filter$.Filter<T> {
+  static in<T>(...values: T[]): Filter$.Filter<T> {
     return new FilterClass({
       type: 'in',
       values,
     });
   }
 
-  static 'contains'<T>(value: T): Filter$.Filter<readonly T[] | undefined> {
+  static contains<T>(value: T): Filter$.Filter<readonly T[] | undefined> {
     return new FilterClass({
       type: 'contains',
       value,
     });
   }
 
-  static 'between'<T>(from: T, to: T): Filter$.Filter<T> {
+  static between<T>(from: T, to: T): Filter$.Filter<T> {
     return new FilterClass({
       type: 'range',
       from,
@@ -354,15 +378,15 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static 'updated'(range: { after?: Date | number; before?: Date | number }): Filter$.Any {
+  static updated(range: { after?: Date | number; before?: Date | number }): Filter$.Any {
     return FilterClass._timeRangeFilter('updatedAt', range);
   }
 
-  static 'created'(range: { after?: Date | number; before?: Date | number }): Filter$.Any {
+  static created(range: { after?: Date | number; before?: Date | number }): Filter$.Any {
     return FilterClass._timeRangeFilter('createdAt', range);
   }
 
-  static 'childOf'(parents: unknown | unknown[], options?: { transitive?: boolean }): Filter$.Any {
+  static childOf(parents: unknown | unknown[], options?: { transitive?: boolean }): Filter$.Any {
     const items = Array.isArray(parents) ? parents : [parents];
     const dxns = items.map((item) => {
       if (isEchoUriLike(item)) {
@@ -377,7 +401,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  private static '_timeRangeFilter'(
+  private static _timeRangeFilter(
     field: 'updatedAt' | 'createdAt',
     range: { after?: Date | number; before?: Date | number },
   ): Filter$.Any {
@@ -395,33 +419,33 @@ class FilterClass implements Filter$.Any {
     return filters.length === 1 ? filters[0] : FilterClass.and(...filters);
   }
 
-  static 'not'<F extends Filter$.Any>(filter: F): Filter$.Filter<Filter$.Type<F>> {
+  static not<F extends Filter$.Any>(filter: F): Filter$.Filter<Filter$.Type<F>> {
     return new FilterClass({
       type: 'not',
       filter: filter.ast,
     });
   }
 
-  static 'and'<Filters extends readonly Filter$.Any[]>(
+  static and<Filters extends readonly Filter$.Any[]>(
     ...filters: Filters
   ): Filter$.Filter<Filter$.Type<Filters[number]>> {
     return new FilterClass({
       type: 'and',
-      filters: filters.map((f) => f.ast),
+      filters: filters.map((filter) => filter.ast),
     });
   }
 
-  static 'or'<Filters extends readonly Filter$.Any[]>(
+  static or<Filters extends readonly Filter$.Any[]>(
     ...filters: Filters
   ): Filter$.Filter<Filter$.Type<Filters[number]>> {
     return new FilterClass({
       type: 'or',
-      filters: filters.map((f) => f.ast),
+      filters: filters.map((filter) => filter.ast),
     });
   }
 
   /** Returns a human-readable string representation of a Filter AST. */
-  static 'pretty'(filter: Filter$.Any): string {
+  static pretty(filter: Filter$.Any): string {
     return prettyFilter(filter.ast);
   }
 
@@ -435,9 +459,9 @@ class FilterClass implements Filter$.Any {
     return _filterMatchEntityLocal(filter.ast, entityOrFilter);
   }) as typeof Filter$.toPredicate;
 
-  private 'constructor'(public readonly ast: QueryAST.Filter) {}
+  private constructor(public readonly ast: QueryAST.Filter) {}
 
-  '~Filter' = FilterClass.variance;
+  [FilterTypeId] = FilterClass.variance;
 }
 
 export const Filter1: typeof Filter$ = FilterClass;
@@ -495,24 +519,29 @@ const processPredicate = (predicate: any): QueryAST.Filter => {
 };
 
 class QueryClass implements Query$.Any {
-  private static 'variance': Query$.Any['~Query'] = {} as Query$.Any['~Query'];
+  static 'QueryTypeId': Query$.QueryTypeId = QueryTypeId;
+
+  private static 'variance': Query$.Any[typeof QueryTypeId] = {} as Query$.Any[typeof QueryTypeId];
 
-  static 'is'(value: unknown): value is Query$.Any {
-    return typeof value === 'object' && value !== null && '~Query' in value;
+  private static 'projectionVariance': Query$.Projection<any>[typeof ProjectionTypeId] =
+    {} as Query$.Projection<any>[typeof ProjectionTypeId];
+
+  static is(value: unknown): value is Query$.Any {
+    return typeof value === 'object' && value !== null && QueryTypeId in value;
   }
 
-  static 'fromAst'(ast: QueryAST.Query): Query$.Any {
+  static fromAst(ast: QueryAST.Query): Query$.Any {
     return new QueryClass(ast);
   }
 
-  static 'select'<F extends Filter$.Any>(filter: F): Query$.Query<Filter$.Type<F>> {
+  static select<F extends Filter$.Any>(filter: F): Query$.Query<Filter$.Type<F>> {
     return new QueryClass({
       type: 'select',
       filter: filter.ast,
     });
   }
 
-  'select'(filter: Filter$.Any | Filter$.Props<any>): Query$.Any {
+  select(filter: Filter$.Any | Filter$.Props<any>): Query$.Any {
     if (FilterClass.is(filter)) {
       return new QueryClass({
         type: 'filter',
@@ -528,13 +557,17 @@ class QueryClass implements Query$.Any {
     }
   }
 
-  static 'type'<S extends Schema.Schema.All>(
+  project(property: string): Query$.Projection<any> {
+    return { [ProjectionTypeId]: QueryClass.projectionVariance, query: this.ast, property };
+  }
+
+  static type<S extends Schema.Schema.All>(
     schema: S,
     predicates?: Filter$.Props<Schema.Schema.Type<S>>,
   ): Query$.Query<Schema.Schema.Type<S>>;
-  static 'type'(type: Type$.Type, predicates?: Filter$.Props<Obj$.Unknown>): Query$.Query<Obj$.Unknown>;
-  static 'type'(schema: string, predicates?: Filter$.Props<unknown>): Query$.Query<any>;
-  static 'type'(schema: Schema.Schema.All | Type$.Type | string, predicates?: Filter$.Props<unknown>): Query$.Any {
+  static type(type: Type$.Type, predicates?: Filter$.Props<Obj$.Unknown>): Query$.Query<Obj$.Unknown>;
+  static type(schema: string, predicates?: Filter$.Props<unknown>): Query$.Query<any>;
+  static type(schema: Schema.Schema.All | Type$.Type | string, predicates?: Filter$.Props<unknown>): Query$.Any {
     if (typeof schema !== 'string') {
       throw new TypeError('expected typename as the first paramter');
     }
@@ -544,7 +577,7 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  static 'all'(...queries: Query$.Any[]): Query$.Any {
+  static all(...queries: Query$.Any[]): Query$.Any {
     if (queries.length === 0) {
       throw new TypeError(
         'Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())',
@@ -556,7 +589,7 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  static 'without'<T>(source: Query$.Query<T>, exclude: Query$.Query<T>): Query$.Query<T> {
+  static without<T>(source: Query$.Query<T>, exclude: Query$.Query<T>): Query$.Query<T> {
     return new QueryClass({
       type: 'set-difference',
       source: source.ast,
@@ -564,7 +597,11 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  static 'from'(...args: any[]): Query$.Any {
+  static project(query: Query$.Any, property: string): Query$.Projection<any> {
+    return { [ProjectionTypeId]: QueryClass.projectionVariance, query: query.ast, property };
+  }
+
+  static from(...args: any[]): Query$.Any {
     const baseQuery: QueryAST.Query = {
       type: 'select',
       filter: FilterClass.everything().ast,
@@ -573,7 +610,7 @@ class QueryClass implements Query$.Any {
     return (wrapper.from as (...args: any[]) => Query$.Any)(...args);
   }
 
-  'from'(...args: any[]): Query$.Any {
+  from(...args: any[]): Query$.Any {
     // Variadic raw scopes: `.from(Scope.space(), Scope.registry())`.
     if (args.length > 1 && args.every((arg) => _isScopeLike(arg))) {
       return new QueryClass({
@@ -604,15 +641,15 @@ class QueryClass implements Query$.Any {
   }
 
   /** Returns a human-readable string representation of a Query AST. */
-  static 'pretty'(query: Query$.Any): string {
+  static pretty(query: Query$.Any): string {
     return prettyQuery(query.ast);
   }
 
-  'constructor'(public readonly ast: QueryAST.Query) {}
+  constructor(public readonly ast: QueryAST.Query) {}
 
-  '~Query' = QueryClass.variance;
+  [QueryTypeId] = QueryClass.variance;
 
-  'reference'(key: string): Query$.Any {
+  reference(key: string): Query$.Any {
     return new QueryClass({
       type: 'reference-traversal',
       anchor: this.ast,
@@ -620,7 +657,7 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  'referencedBy'(target?: Type$.AnyEntity | string, key?: string): Query$.Any {
+  referencedBy(target?: Type$.AnyEntity | string, key?: string): Query$.Any {
     if (target !== undefined && typeof target !== 'string') {
       throw new TypeError('referencedBy requires a typename string in query-lite');
     }
@@ -633,7 +670,7 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  'sourceOf'(
+  sourceOf(
     relation?: Type$.Relation<any, any, any, any> | string,
     predicates?: Filter$.Props<unknown> | undefined,
   ): Query$.Any {
@@ -650,7 +687,7 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  'targetOf'(
+  targetOf(
     relation?: Type$.Relation<any, any, any, any> | string,
     predicates?: Filter$.Props<unknown> | undefined,
   ): Query$.Any {
@@ -667,7 +704,7 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  'source'(): Query$.Any {
+  source(): Query$.Any {
     return new QueryClass({
       type: 'relation-traversal',
       anchor: this.ast,
@@ -675,7 +712,7 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  'target'(): Query$.Any {
+  target(): Query$.Any {
     return new QueryClass({
       type: 'relation-traversal',
       anchor: this.ast,
@@ -683,7 +720,7 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  'parent'(): Query$.Any {
+  parent(): Query$.Any {
     return new QueryClass({
       type: 'hierarchy-traversal',
       anchor: this.ast,
@@ -691,7 +728,7 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  'children'(): Query$.Any {
+  children(): Query$.Any {
     return new QueryClass({
       type: 'hierarchy-traversal',
       anchor: this.ast,
@@ -699,15 +736,15 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  'orderBy'(...order: Order$.Any[]): Query$.Any {
+  orderBy(...order: Order$.Any[]): Query$.Any {
     return new QueryClass({
       type: 'order',
       query: this.ast,
-      order: order.map((o) => o.ast),
+      order: order.map((orderItem) => orderItem.ast),
     });
   }
 
-  'limit'(limit: number): Query$.Any {
+  limit(limit: number): Query$.Any {
     return new QueryClass({
       type: 'limit',
       query: this.ast,
@@ -715,7 +752,23 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  'options'(options: QueryAST.QueryOptions): Query$.Any {
+  skip(skip: number): Query$.Any {
+    return new QueryClass({
+      type: 'skip',
+      query: this.ast,
+      skip,
+    });
+  }
+
+  aggregate(aggregates: Record<string, Aggregate$.Any>): Query$.Any {
+    return new QueryClass({
+      type: 'aggregate',
+      query: this.ast,
+      aggregates: Object.entries(aggregates).map(([name, aggregate]) => ({ name, ...aggregate.spec })),
+    });
+  }
+
+  options(options: QueryAST.QueryOptions): Query$.Any {
     return new QueryClass({
       type: 'options',
       query: this.ast,
@@ -723,7 +776,7 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  'debugLabel'(label: string): Query$.Any {
+  debugLabel(label: string): Query$.Any {
     if (this.ast.type === 'options') {
       return new QueryClass({
         type: 'options',
@@ -821,6 +874,8 @@ const prettyFilter = (filter: QueryAST.Filter): string => {
       return `Filter.${filter.operator}(${JSON.stringify(filter.value)})`;
     case 'in':
       return `Filter.in(${filter.values.map((v) => JSON.stringify(v)).join(', ')})`;
+    case 'in-query':
+      return `Filter.in(${prettyQuery(filter.subquery)}.project(${JSON.stringify(filter.property)}))`;
     case 'contains':
       return `Filter.contains(${JSON.stringify(filter.value)})`;
     case 'range':
@@ -879,7 +934,7 @@ const prettyQuery = (query: QueryAST.Query): string => {
     case 'order': {
       const orders = query.order.map((o) => {
         if (o.kind === 'natural') {
-          return 'Order.natural';
+          return `Order.natural(${JSON.stringify(o.direction)})`;
         }
         if (o.kind === 'rank') {
           return `Order.rank(${JSON.stringify(o.direction)})`;
@@ -924,5 +979,21 @@ const prettyQuery = (query: QueryAST.Query): string => {
     }
     case 'limit':
       return `${prettyQuery(query.query)}.limit(${query.limit})`;
+    case 'skip':
+      return `${prettyQuery(query.query)}.skip(${query.skip})`;
+    case 'aggregate': {
+      const aggregates = query.aggregates.map((aggregate) => {
+        const arg =
+          aggregate.kind === 'items'
+            ? aggregate.limit !== undefined
+              ? `{ limit: ${aggregate.limit} }`
+              : ''
+            : aggregate.kind === 'count'
+              ? ''
+              : JSON.stringify(aggregate.property);
+        return `${JSON.stringify(aggregate.name)}: Aggregate.${aggregate.kind}(${arg})`;
+      });
+      return `${prettyQuery(query.query)}.aggregate({ ${aggregates.join(', ')} })`;
+    }
   }
 };