@dxos/echo-query 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo-query",
-  "version": "0.8.4-main.9be5663bfe",
+  "version": "0.8.4-main.abd8ff62ef",
   "description": "ECHO queries.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -24,9 +24,6 @@
     "./api.d.ts": "./dist/query-lite/index.d.ts"
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {}
-  },
   "files": [
     "dist",
     "src"
@@ -35,22 +32,22 @@
     "@lezer/common": "^1.2.2",
     "@lezer/lezer": "^1.1.2",
     "@lezer/lr": "^1.4.2",
-    "@dxos/context": "0.8.4-main.9be5663bfe",
-    "@dxos/debug": "0.8.4-main.9be5663bfe",
-    "@dxos/echo": "0.8.4-main.9be5663bfe",
-    "@dxos/echo-protocol": "0.8.4-main.9be5663bfe",
-    "@dxos/errors": "0.8.4-main.9be5663bfe",
-    "@dxos/invariant": "0.8.4-main.9be5663bfe",
-    "@dxos/node-std": "0.8.4-main.9be5663bfe",
-    "@dxos/util": "0.8.4-main.9be5663bfe",
-    "@dxos/vendor-quickjs": "0.8.4-main.9be5663bfe"
+    "@dxos/debug": "0.8.4-main.abd8ff62ef",
+    "@dxos/errors": "0.8.4-main.abd8ff62ef",
+    "@dxos/echo-protocol": "0.8.4-main.abd8ff62ef",
+    "@dxos/echo": "0.8.4-main.abd8ff62ef",
+    "@dxos/invariant": "0.8.4-main.abd8ff62ef",
+    "@dxos/node-std": "0.8.4-main.abd8ff62ef",
+    "@dxos/context": "0.8.4-main.abd8ff62ef",
+    "@dxos/util": "0.8.4-main.abd8ff62ef",
+    "@dxos/vendor-quickjs": "0.8.4-main.abd8ff62ef"
   },
   "devDependencies": {
     "@lezer/generator": "^1.7.1",
     "tsdown": "^0.16.7",
-    "typescript": "^6.0.2",
-    "@dxos/random": "0.8.4-main.9be5663bfe",
-    "@dxos/echo-generator": "0.8.4-main.9be5663bfe"
+    "typescript": "^6.0.3",
+    "@dxos/echo-generator": "0.8.4-main.abd8ff62ef",
+    "@dxos/random": "0.8.4-main.abd8ff62ef"
   },
   "publishConfig": {
     "access": "public"

package/src/parser/query-builder.ts

@@ -28,7 +28,7 @@ export class QueryBuilder {
    */
   validate(input: string): boolean {
     try {
-      const tree = this._parser.parse(input);
+      const tree = this._parser.parse(normalizeInput(input));
       return tree.cursor().node.name === 'Query';
     } catch {
       return false;
@@ -40,8 +40,9 @@ export class QueryBuilder {
    */
   build(input: string): BuildResult {
     try {
-      const tree = this._parser.parse(input);
-      return this.buildQuery(tree, input);
+      const normalized = normalizeInput(input);
+      const tree = this._parser.parse(normalized);
+      return this.buildQuery(tree, normalized);
     } catch {
       return {};
     }
@@ -245,8 +246,9 @@ export class QueryBuilder {
             let exprEnd = cursor.to;
 
             while (cursor.nextSibling() && depth > 0) {
-              if (cursor.node.name === '(') depth++;
-              else if (cursor.node.name === ')') {
+              if (cursor.node.name === '(') {
+                depth++;
+              } else if (cursor.node.name === ')') {
                 depth--;
                 if (depth === 0) {
                   exprEnd = cursor.from;
@@ -355,8 +357,8 @@ export class QueryBuilder {
     cursor.firstChild(); // Move to String node.
     const text = this._getNodeText(cursor, input);
     cursor.parent(); // Go back to TextFilter.
-    // Remove quotes.
-    return Filter.text(text.slice(1, -1));
+    // Remove quotes and decode escapes.
+    return Filter.text(unescapeStringLiteral(text.slice(1, -1)));
   }
 
   /**
@@ -479,9 +481,9 @@ export class QueryBuilder {
 
     switch (valueType) {
       case 'String': {
-        // Remove quotes.
+        // Remove quotes and decode escapes.
         const str = this._getNodeText(cursor, input);
-        return str.slice(1, -1);
+        return unescapeStringLiteral(str.slice(1, -1));
       }
 
       case 'Number':
@@ -537,3 +539,261 @@ export class QueryBuilder {
     return input.slice(cursor.from, cursor.to);
   }
 }
+
+const KEYWORDS = new Set(['AND', 'OR', 'NOT']);
+const VALUE_LITERALS = new Set(['true', 'false', 'null']);
+const SPECIAL_CHARS = /[\s(){}\[\],"']/;
+const PROPERTY_KEY = /^[a-zA-Z_][a-zA-Z0-9_.]*$/;
+const NUMBER_LITERAL = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+
+// Common URL schemes — `http://...`, `mailto:rich@...` etc. should be searched as text,
+// not auto-promoted to property filters.
+const URL_SCHEMES = new Set([
+  'http',
+  'https',
+  'ftp',
+  'ftps',
+  'file',
+  'mailto',
+  'tel',
+  'sms',
+  'data',
+  'javascript',
+  'ws',
+  'wss',
+  'ssh',
+  'git',
+]);
+
+/**
+ * Normalize raw user input into a form the lezer grammar can parse.
+ * - Bare text fragments (e.g. `foo`) are wrapped in quotes so they parse as TextFilter.
+ * - Property values that aren't already quoted/numeric/boolean (e.g. `from:rich@dxos.org`) are quoted.
+ * - Tags, type filters, operators, parens, braces, quoted strings, and assignments pass through unchanged.
+ */
+export const normalizeInput = (input: string): string => {
+  const out: string[] = [];
+  let pos = 0;
+  while (pos < input.length) {
+    const currentChar = input[pos];
+
+    // Whitespace.
+    if (/\s/.test(currentChar)) {
+      out.push(currentChar);
+      pos++;
+      continue;
+    }
+
+    // Quoted string (already a valid TextFilter / Value).
+    // Single-quote only opens a string if the previous char isn't a word-char,
+    // so apostrophes inside barewords (e.g. `don't`, `O'Connor`) stay attached.
+    const prevChar = pos > 0 ? input[pos - 1] : '';
+    const isStringOpener =
+      currentChar === '"' || (currentChar === "'" && (pos === 0 || !/[a-zA-Z0-9_]/.test(prevChar)));
+    if (isStringOpener) {
+      const quoteChar = currentChar;
+      let scanIndex = pos + 1;
+      while (scanIndex < input.length && input[scanIndex] !== quoteChar) {
+        if (input[scanIndex] === '\\' && scanIndex + 1 < input.length) {
+          scanIndex += 2;
+        } else {
+          scanIndex++;
+        }
+      }
+      out.push(input.slice(pos, Math.min(scanIndex + 1, input.length)));
+      pos = scanIndex + 1;
+      continue;
+    }
+
+    // Object/array literals: pass through (contents already structured).
+    if (currentChar === '{' || currentChar === '[') {
+      const closeChar = currentChar === '{' ? '}' : ']';
+      let depth = 1;
+      let scanIndex = pos + 1;
+      while (scanIndex < input.length && depth > 0) {
+        const innerChar = input[scanIndex];
+        if (innerChar === '"' || innerChar === "'") {
+          const quoteChar = innerChar;
+          scanIndex++;
+          while (scanIndex < input.length && input[scanIndex] !== quoteChar) {
+            if (input[scanIndex] === '\\' && scanIndex + 1 < input.length) {
+              scanIndex += 2;
+            } else {
+              scanIndex++;
+            }
+          }
+          scanIndex++;
+        } else if (innerChar === currentChar) {
+          depth++;
+          scanIndex++;
+        } else if (innerChar === closeChar) {
+          depth--;
+          scanIndex++;
+        } else {
+          scanIndex++;
+        }
+      }
+      out.push(input.slice(pos, scanIndex));
+      pos = scanIndex;
+      continue;
+    }
+
+    // Single-char structural tokens. `}` / `]` only reach here when unmatched —
+    // pass them through so the lezer parser can produce a clear error rather than spinning.
+    if (
+      currentChar === '(' ||
+      currentChar === ')' ||
+      currentChar === '=' ||
+      currentChar === ',' ||
+      currentChar === '}' ||
+      currentChar === ']'
+    ) {
+      out.push(currentChar);
+      pos++;
+      continue;
+    }
+
+    // Relations.
+    if ((currentChar === '-' && input[pos + 1] === '>') || (currentChar === '<' && input[pos + 1] === '-')) {
+      out.push(input.slice(pos, pos + 2));
+      pos += 2;
+      continue;
+    }
+
+    // NOT prefix (`!`) — single token.
+    if (currentChar === '!') {
+      out.push(currentChar);
+      pos++;
+      continue;
+    }
+
+    // Tag.
+    if (currentChar === '#') {
+      let scanIndex = pos + 1;
+      while (scanIndex < input.length && /[a-zA-Z0-9_-]/.test(input[scanIndex])) {
+        scanIndex++;
+      }
+      out.push(input.slice(pos, scanIndex));
+      pos = scanIndex;
+      continue;
+    }
+
+    // Bareword: scan until next whitespace or special char.
+    let scanIndex = pos;
+    while (scanIndex < input.length) {
+      const innerChar = input[scanIndex];
+      if (innerChar === '"') {
+        break;
+      }
+      if (innerChar === "'" && scanIndex > pos && !/[a-zA-Z0-9_]/.test(input[scanIndex - 1])) {
+        break;
+      }
+      if (innerChar === "'" && scanIndex === pos) {
+        break;
+      }
+      if (innerChar !== "'" && SPECIAL_CHARS.test(innerChar)) {
+        break;
+      }
+      if (innerChar === '-' && input[scanIndex + 1] === '>') {
+        break;
+      }
+      if (innerChar === '<' && input[scanIndex + 1] === '-') {
+        break;
+      }
+      scanIndex++;
+    }
+    // Defensive: if no characters were consumed, advance one to avoid infinite loops.
+    if (scanIndex === pos) {
+      out.push(currentChar);
+      pos++;
+      continue;
+    }
+    const token = input.slice(pos, scanIndex);
+    pos = scanIndex;
+
+    // Operators.
+    if (KEYWORDS.has(token.toUpperCase())) {
+      out.push(token);
+      continue;
+    }
+
+    // Property/type filter (`key:value`).
+    const colonIdx = token.indexOf(':');
+    if (colonIdx > 0) {
+      const key = token.slice(0, colonIdx);
+      const rest = token.slice(colonIdx + 1);
+
+      // type:typename — leave for grammar's TypeFilter (Identifier value).
+      if (key === 'type') {
+        out.push(token);
+        continue;
+      }
+
+      // URLs (`http://...`, `mailto:rich@...`) and URL-paths starting with `//`
+      // are searched as text rather than auto-promoted to property filters.
+      const isUrlScheme = URL_SCHEMES.has(key.toLowerCase()) || rest.startsWith('//');
+      if (!isUrlScheme && PROPERTY_KEY.test(key)) {
+        if (rest.length === 0) {
+          // Trailing colon while typing — pass through.
+          out.push(token);
+          continue;
+        }
+        const firstValueChar = rest[0];
+        if (firstValueChar === '"' || firstValueChar === "'") {
+          // Already quoted.
+          out.push(token);
+          continue;
+        }
+        if (firstValueChar === '{' || firstValueChar === '[') {
+          // Object/array literal value.
+          out.push(token);
+          continue;
+        }
+        if (VALUE_LITERALS.has(rest) || NUMBER_LITERAL.test(rest)) {
+          // Boolean / null / number literal.
+          out.push(token);
+          continue;
+        }
+        out.push(`${key}:"${escapeStringLiteral(rest)}"`);
+        continue;
+      }
+
+      // URL or unknown key shape — fall through to text.
+    }
+
+    // Identifier followed by `=` is the LHS of an Assignment — keep as-is.
+    if (PROPERTY_KEY.test(token)) {
+      let lookahead = pos;
+      while (lookahead < input.length && /\s/.test(input[lookahead])) {
+        lookahead++;
+      }
+      if (input[lookahead] === '=') {
+        out.push(token);
+        continue;
+      }
+    }
+
+    // Bare text fragment: quote so it parses as TextFilter.
+    out.push(`"${escapeStringLiteral(token)}"`);
+  }
+
+  return out.join('');
+};
+
+/** Escape a raw value into a string literal body (without surrounding quotes). */
+const escapeStringLiteral = (value: string): string => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+
+/** Decode `\\` and `\"` escapes inside a string literal body. */
+const unescapeStringLiteral = (literalBody: string): string => {
+  let out = '';
+  for (let i = 0; i < literalBody.length; i++) {
+    const ch = literalBody[i];
+    if (ch === '\\' && i + 1 < literalBody.length) {
+      out += literalBody[i + 1];
+      i++;
+    } else {
+      out += ch;
+    }
+  }
+  return out;
+};

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.
 
@@ -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

@@ -573,6 +573,21 @@ class QueryClass implements Query$.Any {
       options,
     });
   }
+
+  debugLabel(label: string): Query$.Any {
+    if (this.ast.type === 'options') {
+      return new QueryClass({
+        type: 'options',
+        query: this.ast.query,
+        options: { ...this.ast.options, debugLabel: label },
+      });
+    }
+    return new QueryClass({
+      type: 'options',
+      query: this.ast,
+      options: { debugLabel: label },
+    });
+  }
 }
 
 export const Query1: typeof Query$ = QueryClass;
@@ -701,6 +716,9 @@ const prettyQuery = (query: QueryAST.Query): 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': {