@dxos/echo-query 0.8.4-main.c85a9c8dae → 0.8.4-main.cb12b3f963

package/src/parser/query.test.ts

@@ -3,12 +3,12 @@
 //
 
 import { type Tree } from '@lezer/common';
-import { describe, it } from 'vitest';
+import { describe, it, test } from 'vitest';
 
 import { Filter, Tag } from '@dxos/echo';
 
 import { QueryDSL } from './gen';
-import { type BuildResult, QueryBuilder } from './query-builder';
+import { type BuildResult, QueryBuilder, normalizeInput } from './query-builder';
 
 // TODO(burdon): Ref/Relation traversal.
 
@@ -51,10 +51,10 @@ describe('query', () => {
       },
       // Type
       {
-        input: 'type:dxos.org/type/Person',
+        input: 'type:org.dxos.type.person',
         expected: [
           'Query',
-          // type:dxos.org/type/Person
+          // type:org.dxos.type.person
           'Filter',
           'TypeFilter',
           'TypeKeyword',
@@ -111,10 +111,10 @@ describe('query', () => {
         ],
       },
       {
-        input: 'type:dxos.org/type/Person OR type:dxos.org/type/Organization',
+        input: 'type:org.dxos.type.person OR type:org.dxos.type.organization',
         expected: [
           'Query',
-          // type:dxos.org/type/Person
+          // type:org.dxos.type.person
           'Filter',
           'TypeFilter',
           'TypeKeyword',
@@ -122,7 +122,7 @@ describe('query', () => {
           'Identifier',
           // OR
           'Or',
-          // type:dxos.org/type/Organization
+          // type:org.dxos.type.organization
           'Filter',
           'TypeFilter',
           'TypeKeyword',
@@ -131,11 +131,11 @@ describe('query', () => {
         ],
       },
       {
-        input: '(type:dxos.org/type/Person OR type:dxos.org/type/Organization) AND { name: "DXOS" }',
+        input: '(type:org.dxos.type.person OR type:org.dxos.type.organization) AND { name: "DXOS" }',
         expected: [
           'Query',
           '(',
-          // type:dxos.org/type/Person
+          // type:org.dxos.type.person
           'Filter',
           'TypeFilter',
           'TypeKeyword',
@@ -143,7 +143,7 @@ describe('query', () => {
           'Identifier',
           // OR
           'Or',
-          // type:dxos.org/type/Organization
+          // type:org.dxos.type.organization
           'Filter',
           'TypeFilter',
           'TypeKeyword',
@@ -164,10 +164,10 @@ describe('query', () => {
         ],
       },
       {
-        input: 'type:dxos.org/type/Person -> type:dxos.org/type/Organization',
+        input: 'type:org.dxos.type.person -> type:org.dxos.type.organization',
         expected: [
           'Query',
-          // type:dxos.org/type/Person
+          // type:org.dxos.type.person
           'Filter',
           'TypeFilter',
           'TypeKeyword',
@@ -175,7 +175,7 @@ describe('query', () => {
           'Identifier',
           'Relation',
           'ArrowRight',
-          // type:dxos.org/type/Organization
+          // type:org.dxos.type.organization
           'Filter',
           'TypeFilter',
           'TypeKeyword',
@@ -184,10 +184,10 @@ describe('query', () => {
         ],
       },
       {
-        input: 'type:dxos.org/type/Organization <- type:dxos.org/type/Person',
+        input: 'type:org.dxos.type.organization <- type:org.dxos.type.person',
         expected: [
           'Query',
-          // type:dxos.org/type/Organization
+          // type:org.dxos.type.organization
           'Filter',
           'TypeFilter',
           'TypeKeyword',
@@ -195,7 +195,7 @@ describe('query', () => {
           'Identifier',
           'Relation',
           'ArrowLeft',
-          // type:dxos.org/type/Person
+          // type:org.dxos.type.person
           'Filter',
           'TypeFilter',
           'TypeKeyword',
@@ -206,7 +206,7 @@ describe('query', () => {
       {
         // Persons for Organizations with name "DXOS"
         // TODO(burdon): Filter relations.
-        input: '((type:dxos.org/type/Organization AND { name: "DXOS" }) -> type:dxos.org/type/Person)',
+        input: '((type:org.dxos.type.organization AND { name: "DXOS" }) -> type:org.dxos.type.person)',
         expected: [
           'Query',
           '(',
@@ -238,7 +238,7 @@ describe('query', () => {
         ],
       },
       {
-        input: 'type:dxos.org/type/Person and { name: "DXOS" }',
+        input: 'type:org.dxos.type.person and { name: "DXOS" }',
         expected: [
           'Query',
           'Filter',
@@ -259,7 +259,7 @@ describe('query', () => {
         ],
       },
       {
-        input: 'x = ( type: dxos.org/type/Person )',
+        input: 'x = ( type: org.dxos.type.person )',
         expected: [
           'Query',
           'Assignment',
@@ -305,9 +305,9 @@ describe('query', () => {
     const tests: Test[] = [
       // Types
       {
-        input: 'type:dxos.org/type/Person',
+        input: 'type:org.dxos.type.person',
         expected: {
-          filter: Filter.typename('dxos.org/type/Person'),
+          filter: Filter.typename('org.dxos.type.person'),
         },
       },
       // Tags
@@ -357,32 +357,32 @@ describe('query', () => {
         },
       },
       {
-        input: 'type:dxos.org/type/Person OR type:dxos.org/type/Organization',
+        input: 'type:org.dxos.type.person OR type:org.dxos.type.organization',
         expected: {
-          filter: Filter.or(Filter.typename('dxos.org/type/Person'), Filter.typename('dxos.org/type/Organization')),
+          filter: Filter.or(Filter.typename('org.dxos.type.person'), Filter.typename('org.dxos.type.organization')),
         },
       },
       {
-        input: '(type:dxos.org/type/Person OR type:dxos.org/type/Organization) AND { name: "DXOS" }',
+        input: '(type:org.dxos.type.person OR type:org.dxos.type.organization) AND { name: "DXOS" }',
         expected: {
           filter: Filter.and(
-            Filter.or(Filter.typename('dxos.org/type/Person'), Filter.typename('dxos.org/type/Organization')),
+            Filter.or(Filter.typename('org.dxos.type.person'), Filter.typename('org.dxos.type.organization')),
             Filter.props({ name: 'DXOS' }),
           ),
         },
       },
       {
-        input: 'type:dxos.org/type/Person and { name: "DXOS" }',
+        input: 'type:org.dxos.type.person and { name: "DXOS" }',
         expected: {
-          filter: Filter.and(Filter.typename('dxos.org/type/Person'), Filter.props({ name: 'DXOS' })),
+          filter: Filter.and(Filter.typename('org.dxos.type.person'), Filter.props({ name: 'DXOS' })),
         },
       },
       // Assignment
       {
-        input: 'x = ( type:dxos.org/type/Person )',
+        input: 'x = ( type:org.dxos.type.person )',
         expected: {
           name: 'x',
-          filter: Filter.typename('dxos.org/type/Person'),
+          filter: Filter.typename('org.dxos.type.person'),
         },
       },
       {
@@ -401,9 +401,9 @@ describe('query', () => {
       //
       // {
       //   input: '',
-      //   expected: Query.select(Filter.typename('dxos.org/type/Person', { jobTitle: 'investor' }))
+      //   expected: Query.select(Filter.typename('org.dxos.type.person', { jobTitle: 'investor' }))
       //     .reference('organization')
-      //     .targetOf(Relation.of('dxos.org/relation/HasSubject')) // TODO(burdon): Invert?
+      //     .targetOf(Relation.of('org.dxos.relation.hasSubject')) // TODO(burdon): Invert?
       //     .source(),
       // },
     ];
@@ -413,4 +413,117 @@ describe('query', () => {
       expect(result, JSON.stringify({ input, result, expected }, null, 2)).toEqual(expected);
     });
   });
+
+  test('normalizeInput', ({ expect }) => {
+    type Test = { input: string; expected: string };
+    const tests: Test[] = [
+      { input: 'foo', expected: '"foo"' },
+      { input: 'foo bar', expected: '"foo" "bar"' },
+      { input: 'foo  bar', expected: '"foo"  "bar"' },
+      { input: '"already" bare', expected: '"already" "bare"' },
+      { input: 'from:rich@dxos.org', expected: 'from:"rich@dxos.org"' },
+      { input: 'from:rich@dxos.org urgent', expected: 'from:"rich@dxos.org" "urgent"' },
+      { input: 'name:DXOS', expected: 'name:"DXOS"' },
+      { input: 'count:42', expected: 'count:42' },
+      { input: 'active:true', expected: 'active:true' },
+      { input: 'value:null', expected: 'value:null' },
+      { input: 'name:"DXOS"', expected: 'name:"DXOS"' },
+      { input: 'type:org.dxos.type.person', expected: 'type:org.dxos.type.person' },
+      { input: '#tag', expected: '#tag' },
+      { input: '#tag foo', expected: '#tag "foo"' },
+      { input: 'foo AND bar', expected: '"foo" AND "bar"' },
+      { input: 'foo OR bar', expected: '"foo" OR "bar"' },
+      { input: 'NOT foo', expected: 'NOT "foo"' },
+      { input: '!foo', expected: '!"foo"' },
+      { input: '(foo bar)', expected: '("foo" "bar")' },
+      { input: 'x = ( foo )', expected: 'x = ( "foo" )' },
+      { input: '{ name: "DXOS" }', expected: '{ name: "DXOS" }' },
+      // Apostrophes inside barewords don't open a quoted string.
+      { input: "don't", expected: '"don\'t"' },
+      { input: "O'Connor", expected: '"O\'Connor"' },
+      { input: "don't worry", expected: '"don\'t" "worry"' },
+      // Unmatched closing brace/bracket — passed through, no infinite loop.
+      { input: 'foo}', expected: '"foo"}' },
+      { input: 'foo]bar', expected: '"foo"]"bar"' },
+      // Genuine single-quoted string still works.
+      { input: "'foo bar'", expected: "'foo bar'" },
+      // URLs are searched as text rather than auto-promoted to property filters.
+      { input: 'https://dxos.org', expected: '"https://dxos.org"' },
+      { input: 'http://example.com/foo', expected: '"http://example.com/foo"' },
+      { input: 'mailto:rich@dxos.org', expected: '"mailto:rich@dxos.org"' },
+      // Escapes round-trip: backslashes are escaped in the literal body.
+      { input: 'foo\\bar', expected: '"foo\\\\bar"' },
+    ];
+
+    for (const { input, expected } of tests) {
+      expect(normalizeInput(input), input).toEqual(expected);
+    }
+  });
+
+  test('build with property and text fragments', ({ expect }) => {
+    const queryBuilder = new QueryBuilder({
+      tag_1: Tag.make({ label: 'foo' }),
+    });
+
+    type Test = { input: string; expected: BuildResult };
+    const tests: Test[] = [
+      // Property filter from `key:value` text input.
+      {
+        input: 'from:rich@dxos.org',
+        expected: { filter: Filter.props({ from: 'rich@dxos.org' }) },
+      },
+      {
+        input: 'name:DXOS',
+        expected: { filter: Filter.props({ name: 'DXOS' }) },
+      },
+      // Bare text fragment becomes text search.
+      {
+        input: 'urgent',
+        expected: { filter: Filter.text('urgent') },
+      },
+      // Multiple bare fragments are AND-joined.
+      {
+        input: 'urgent review',
+        expected: { filter: Filter.and(Filter.text('urgent'), Filter.text('review')) },
+      },
+      // Mixed property + text fragment.
+      {
+        input: 'from:rich@dxos.org urgent',
+        expected: {
+          filter: Filter.and(Filter.props({ from: 'rich@dxos.org' }), Filter.text('urgent')),
+        },
+      },
+      // Tag + text fragment.
+      {
+        input: '#foo bar',
+        expected: { filter: Filter.and(Filter.tag('tag_1'), Filter.text('bar')) },
+      },
+      // Three fragments AND-joined.
+      {
+        input: 'a b c',
+        expected: {
+          filter: Filter.and(Filter.text('a'), Filter.text('b'), Filter.text('c')),
+        },
+      },
+      // URLs are text-searched, not promoted to property filters.
+      {
+        input: 'https://dxos.org',
+        expected: { filter: Filter.text('https://dxos.org') },
+      },
+      {
+        input: 'mailto:rich@dxos.org',
+        expected: { filter: Filter.text('mailto:rich@dxos.org') },
+      },
+      // Escapes decode back to the original input.
+      {
+        input: 'foo\\bar',
+        expected: { filter: Filter.text('foo\\bar') },
+      },
+    ];
+
+    tests.forEach(({ input, expected }) => {
+      const result = queryBuilder.build(input);
+      expect(result, JSON.stringify({ input, result, expected }, null, 2)).toEqual(expected);
+    });
+  });
 });

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

@@ -221,7 +221,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static in<T>(...values: T[]): Filter$.Filter<T | undefined> {
+  static in<T>(...values: T[]): Filter$.Filter<T> {
     return new FilterClass({
       type: 'in',
       values,
@@ -235,7 +235,7 @@ class FilterClass implements Filter$.Any {
     });
   }
 
-  static between<T>(from: T, to: T): Filter$.Filter<unknown> {
+  static between<T>(from: T, to: T): Filter$.Filter<T> {
     return new FilterClass({
       type: 'range',
       from,
@@ -243,6 +243,47 @@ class FilterClass implements 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 {
+    return FilterClass._timeRangeFilter('createdAt', range);
+  }
+
+  static childOf(parents: unknown | DXN | (unknown | DXN)[], options?: { transitive?: boolean }): Filter$.Any {
+    const items = Array.isArray(parents) ? parents : [parents];
+    const dxns = items.map((item) => {
+      if (isDxnLike(item)) {
+        return item.toString();
+      }
+      throw new TypeError('childOf requires DXN values in query-lite');
+    });
+    return new FilterClass({
+      type: 'child-of',
+      parents: dxns,
+      transitive: options?.transitive ?? true,
+    });
+  }
+
+  private static _timeRangeFilter(
+    field: 'updatedAt' | 'createdAt',
+    range: { after?: Date | number; before?: Date | number },
+  ): Filter$.Any {
+    const toMs = (d: Date | number) => (typeof d === 'number' ? d : d.getTime());
+    const filters: Filter$.Any[] = [];
+    if (range.after != null) {
+      filters.push(new FilterClass({ type: 'timestamp', field, operator: 'gte', value: toMs(range.after) }));
+    }
+    if (range.before != null) {
+      filters.push(new FilterClass({ type: 'timestamp', field, operator: 'lte', value: toMs(range.before) }));
+    }
+    if (filters.length === 0) {
+      return FilterClass.everything();
+    }
+    return filters.length === 1 ? filters[0] : FilterClass.and(...filters);
+  }
+
   static not<F extends Filter$.Any>(filter: F): Filter$.Filter<Filter$.Type<F>> {
     return new FilterClass({
       type: 'not',
@@ -268,6 +309,11 @@ class FilterClass implements Filter$.Any {
     });
   }
 
+  /** Returns a human-readable string representation of a Filter AST. */
+  static pretty(filter: Filter$.Any): string {
+    return prettyFilter(filter.ast);
+  }
+
   private constructor(public readonly ast: QueryAST.Filter) {}
 
   '~Filter' = FilterClass.variance;
@@ -345,6 +391,22 @@ class QueryClass implements Query$.Any {
     });
   }
 
+  select(filter: Filter$.Any | Filter$.Props<any>): Query$.Any {
+    if (FilterClass.is(filter)) {
+      return new QueryClass({
+        type: 'filter',
+        selection: this.ast,
+        filter: filter.ast,
+      });
+    } else {
+      return new QueryClass({
+        type: 'filter',
+        selection: this.ast,
+        filter: FilterClass.props(filter).ast,
+      });
+    }
+  }
+
   static type(schema: Schema.Schema.All | string, predicates?: Filter$.Props<unknown>): Query$.Any {
     return new QueryClass({
       type: 'select',
@@ -381,26 +443,40 @@ class QueryClass implements Query$.Any {
     return wrapper.from(source, options);
   }
 
-  constructor(public readonly ast: QueryAST.Query) {}
-
-  '~Query' = QueryClass.variance;
-
-  select(filter: Filter$.Any | Filter$.Props<any>): Query$.Any {
-    if (FilterClass.is(filter)) {
+  from(arg: any, options?: { includeFeeds?: boolean }): Query$.Any {
+    if (arg === 'all-accessible-spaces') {
       return new QueryClass({
-        type: 'filter',
-        selection: this.ast,
-        filter: filter.ast,
+        type: 'from',
+        query: this.ast,
+        from: {
+          _tag: 'scope',
+          scope: {
+            ...(options?.includeFeeds ? { allQueuesFromSpaces: true } : {}),
+          },
+        },
       });
-    } else {
+    }
+
+    if (_isScopeLike(arg)) {
       return new QueryClass({
-        type: 'filter',
-        selection: this.ast,
-        filter: FilterClass.props(filter).ast,
+        type: 'from',
+        query: this.ast,
+        from: { _tag: 'scope', scope: arg },
       });
     }
+
+    throw new TypeError('Database and Feed objects are not supported in query-lite sandbox');
+  }
+
+  /** Returns a human-readable string representation of a Query AST. */
+  static pretty(query: Query$.Any): string {
+    return prettyQuery(query.ast);
   }
 
+  constructor(public readonly ast: QueryAST.Query) {}
+
+  '~Query' = QueryClass.variance;
+
   reference(key: string): Query$.Any {
     return new QueryClass({
       type: 'reference-traversal',
@@ -490,36 +566,26 @@ class QueryClass implements Query$.Any {
     });
   }
 
-  from(arg: any, options?: { includeFeeds?: boolean }): Query$.Any {
-    if (arg === 'all-accessible-spaces') {
-      return new QueryClass({
-        type: 'from',
-        query: this.ast,
-        from: {
-          _tag: 'scope',
-          scope: {
-            ...(options?.includeFeeds ? { allQueuesFromSpaces: true } : {}),
-          },
-        },
-      });
-    }
+  options(options: QueryAST.QueryOptions): Query$.Any {
+    return new QueryClass({
+      type: 'options',
+      query: this.ast,
+      options,
+    });
+  }
 
-    if (_isScopeLike(arg)) {
+  debugLabel(label: string): Query$.Any {
+    if (this.ast.type === 'options') {
       return new QueryClass({
-        type: 'from',
-        query: this.ast,
-        from: { _tag: 'scope', scope: arg },
+        type: 'options',
+        query: this.ast.query,
+        options: { ...this.ast.options, debugLabel: label },
       });
     }
-
-    throw new TypeError('Database and Feed objects are not supported in query-lite sandbox');
-  }
-
-  options(options: QueryAST.QueryOptions): Query$.Any {
     return new QueryClass({
       type: 'options',
       query: this.ast,
-      options,
+      options: { debugLabel: label },
     });
   }
 }
@@ -538,6 +604,16 @@ const makeTypeDxn = (typename: string) => {
   return `dxn:type:${typename}`;
 };
 
+const isDxnLike = (value: unknown): value is DXN => {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'toString' in value &&
+    typeof value.toString === 'function' &&
+    value.toString().startsWith('dxn:')
+  );
+};
+
 const SCOPE_KEYS = new Set(['spaceIds', 'queues', 'allQueuesFromSpaces']);
 
 const _isScopeLike = (value: unknown): value is QueryAST.Scope => {
@@ -546,3 +622,123 @@ const _isScopeLike = (value: unknown): value is QueryAST.Scope => {
   }
   return Object.keys(value).every((key) => SCOPE_KEYS.has(key));
 };
+
+const prettyFilter = (filter: QueryAST.Filter): string => {
+  switch (filter.type) {
+    case 'object': {
+      const parts: string[] = [];
+      if (filter.typename !== null) {
+        parts.push(JSON.stringify(filter.typename));
+      }
+      const propEntries = Object.entries(filter.props);
+      if (propEntries.length > 0) {
+        const propsStr = propEntries.map(([k, v]) => `${k}: ${prettyFilter(v)}`).join(', ');
+        parts.push(`{ ${propsStr} }`);
+      }
+      if (filter.id !== undefined) {
+        parts.push(`id: [${filter.id.join(', ')}]`);
+      }
+      return parts.length > 0 ? `Filter.type(${parts.join(', ')})` : 'Filter.everything()';
+    }
+    case 'compare':
+      return `Filter.${filter.operator}(${JSON.stringify(filter.value)})`;
+    case 'in':
+      return `Filter.in(${filter.values.map((v) => JSON.stringify(v)).join(', ')})`;
+    case 'contains':
+      return `Filter.contains(${JSON.stringify(filter.value)})`;
+    case 'range':
+      return `Filter.between(${JSON.stringify(filter.from)}, ${JSON.stringify(filter.to)})`;
+    case 'text-search':
+      return `Filter.text(${JSON.stringify(filter.text)})`;
+    case 'tag':
+      return `Filter.tag(${JSON.stringify(filter.tag)})`;
+    case 'child-of':
+      return `Filter.childOf([${filter.parents.map((parent) => JSON.stringify(parent)).join(', ')}], { transitive: ${filter.transitive} })`;
+    case 'timestamp':
+      return `Filter.${filter.field}.${filter.operator}(${filter.value})`;
+    case 'not':
+      return `Filter.not(${prettyFilter(filter.filter)})`;
+    case 'and':
+      return `Filter.and(${filter.filters.map(prettyFilter).join(', ')})`;
+    case 'or':
+      return `Filter.or(${filter.filters.map(prettyFilter).join(', ')})`;
+  }
+};
+
+const prettyQuery = (query: QueryAST.Query): string => {
+  switch (query.type) {
+    case 'select':
+      return `Query.select(${prettyFilter(query.filter)})`;
+    case 'filter':
+      return `${prettyQuery(query.selection)}.select(${prettyFilter(query.filter)})`;
+    case 'reference-traversal':
+      return `${prettyQuery(query.anchor)}.reference(${JSON.stringify(query.property)})`;
+    case 'incoming-references': {
+      const args: string[] = [];
+      if (query.typename !== null) {
+        args.push(JSON.stringify(query.typename));
+      }
+      if (query.property !== null) {
+        args.push(JSON.stringify(query.property));
+      }
+      return `${prettyQuery(query.anchor)}.referencedBy(${args.join(', ')})`;
+    }
+    case 'relation': {
+      const method =
+        query.direction === 'outgoing' ? 'sourceOf' : query.direction === 'incoming' ? 'targetOf' : 'relationOf';
+      const filterStr = query.filter !== undefined ? prettyFilter(query.filter) : '';
+      return `${prettyQuery(query.anchor)}.${method}(${filterStr})`;
+    }
+    case 'relation-traversal':
+      return `${prettyQuery(query.anchor)}.${query.direction}()`;
+    case 'hierarchy-traversal':
+      return query.direction === 'to-parent'
+        ? `${prettyQuery(query.anchor)}.parent()`
+        : `${prettyQuery(query.anchor)}.children()`;
+    case 'union':
+      return `Query.all(${query.queries.map(prettyQuery).join(', ')})`;
+    case 'set-difference':
+      return `Query.without(${prettyQuery(query.source)}, ${prettyQuery(query.exclude)})`;
+    case 'order': {
+      const orders = query.order.map((o) => {
+        if (o.kind === 'natural') {
+          return 'Order.natural';
+        }
+        if (o.kind === 'rank') {
+          return `Order.rank(${JSON.stringify(o.direction)})`;
+        }
+        return `Order.property(${JSON.stringify(o.property)}, ${JSON.stringify(o.direction)})`;
+      });
+      return `${prettyQuery(query.query)}.orderBy(${orders.join(', ')})`;
+    }
+    case 'options': {
+      const parts: string[] = [];
+      if (query.options.deleted !== undefined) {
+        parts.push(`deleted: ${JSON.stringify(query.options.deleted)}`);
+      }
+      if (query.options.debugLabel !== undefined) {
+        parts.push(`debugLabel: ${JSON.stringify(query.options.debugLabel)}`);
+      }
+      return `${prettyQuery(query.query)}.options({ ${parts.join(', ')} })`;
+    }
+    case 'from': {
+      if (query.from._tag === 'scope') {
+        const scope = query.from.scope;
+        const parts: string[] = [];
+        if (scope.spaceIds !== undefined) {
+          parts.push(`spaceIds: [${scope.spaceIds.join(', ')}]`);
+        }
+        if (scope.queues !== undefined) {
+          parts.push(`queues: [${scope.queues.join(', ')}]`);
+        }
+        if (scope.allQueuesFromSpaces !== undefined) {
+          parts.push(`allQueuesFromSpaces: ${scope.allQueuesFromSpaces}`);
+        }
+        return `${prettyQuery(query.query)}.from({ ${parts.join(', ')} })`;
+      }
+      return `${prettyQuery(query.query)}.from(${prettyQuery(query.from.query)})`;
+    }
+    case 'limit':
+      return `${prettyQuery(query.query)}.limit(${query.limit})`;
+  }
+};