@omgbase/oqx 0.3.0 → 0.5.0

package/src/parser.ts

@@ -21,6 +21,12 @@ import type {
 } from "./ast.ts";
 
 const CONSUMERS = new Set<string>(["collect", "exists", "count", "first", "single"]);
+// Contextual clause words lexed as bare idents; an open-ended range must stop
+// before them rather than consume them as its high bound.
+const CLAUSE_WORDS = new Set<string>([
+  "collect", "exists", "count", "first", "single",
+  "order", "by", "asc", "desc", "follow", "distinct", "frontier", "depth", "in",
+]);
 const RELOPS = new Set<string>(["==", "!=", "<", "<=", ">", ">="]);
 const CMP_OPS = new Set<string>(["==", "!=", "<", "<=", ">", ">="]);
 const ADD_OPS = new Set<string>(["+", "-"]);
@@ -42,6 +48,7 @@ interface BodyClauses {
   select: SelectItem[];
   orderBy: OrderSpec[] | null;
   follow: Follow | null;
+  distinct: boolean;
 }
 
 class Parser {
@@ -81,6 +88,7 @@ class Parser {
         orderBy: directive.sub.orderBy,
         consumer: directive.op,
         follow: directive.sub.follow,
+        distinct: directive.distinct ?? false,
       };
     }
     if (directive) this.fail(`unexpected ${this.tokDesc()} after the top-level directive`);
@@ -99,6 +107,7 @@ class Parser {
       orderBy: body.orderBy,
       consumer: "collect",
       follow: body.follow,
+      distinct: body.distinct,
     };
   }
 
@@ -114,6 +123,7 @@ class Parser {
     let select: SelectItem[] = [];
     let orderBy: OrderSpec[] | null = null;
     let follow: Follow | null = null;
+    let distinct = false;
     let sawWhere = false, sawSelect = false, sawOrder = false;
 
     while (!this.at("eof") && !this.at("rbrace")) {
@@ -137,7 +147,7 @@ class Parser {
       if (this.at("kw", "select") || this.at("caret")) {
         if (sawSelect) this.fail("duplicate projection");
         sawSelect = true;
-        if (this.at("kw")) this.next(); // consume `select`; a leading `^` is part of the item
+        if (this.at("kw")) { this.next(); if (this.at("ident", "distinct")) { this.next(); distinct = true; } } // consume `select` + optional `distinct`; a leading `^` is part of the item
         select = this.parseSelectItems();
         continue;
       }
@@ -162,7 +172,7 @@ class Parser {
       }
       this.fail(`unexpected ${this.tokDesc()} — expected from/where/select${orderByAllowed ? "/order by" : ""}/follow`);
     }
-    return { froms, where, select, orderBy, follow };
+    return { froms, where, select, orderBy, follow, distinct };
   }
 
   // Decide, by syntactic shape only, whether a leading unkeyworded run is a
@@ -175,19 +185,27 @@ class Parser {
     let depth = 0;
     for (let i = this.pos; i < this.tokens.length; i++) {
       const t = this.tokens[i]!;
-      if (t.type === "eof" || t.type === "rbrace") break;
+      if (t.type === "eof") break;
+      // Skip nested `{ … }` consumer blocks and `( … )` groups: a keyword/select
+      // inside them is not part of the top-level shape (e.g. `count { select x } == N`).
+      if (t.type === "lbrace" || t.type === "lparen") { depth++; continue; }
+      if (t.type === "rbrace" || t.type === "rparen") { if (depth === 0) break; depth--; continue; }
       if (depth === 0) {
         if (t.type === "colon" || t.type === "comma") return false;
         if (t.type === "kw") break;
         if (t.type === "op" && (CMP_OPS.has(t.value) || t.value === "&&" || t.value === "||")) return true;
         if (t.type === "ident" && t.value === "in") return true;
+        // A consumer directive in where position (`… exists { … }`, `… count { … }`,
+        // optionally `count distinct { … }`) is a predicate.
+        if (t.type === "ident" && CONSUMERS.has(t.value)) {
+          const nx = this.tokens[i + 1];
+          if (nx && (nx.type === "lbrace" || (nx.type === "ident" && nx.value === "distinct"))) return true;
+        }
         if (t.type === "ident" && (t.value === "order" || t.value === "follow")) {
           const nx = this.tokens[i + 1];
           if (nx && nx.type === "ident") break;
         }
       }
-      if (t.type === "lparen") depth++;
-      else if (t.type === "rparen") { if (depth === 0) break; depth--; }
     }
     return false;
   }
@@ -378,21 +396,29 @@ class Parser {
     else if (this.at("ident")) receiver = this.parseNavFrom(this.next()).expr;
     else return null;
 
-    if (this.at("ident") && CONSUMERS.has(this.peek().value) && this.peekAt(1)?.type === "lbrace") {
-      const op = this.next().value as Consumer;
-      this.next(); // '{'
-      const sub = this.parseSubquery();
-      if (!this.at("rbrace")) this.fail(`expected '}' to close the ${op} { … } block`);
-      this.next();
-      return { kind: "op", receiver, op, sub };
+    if (this.at("ident") && CONSUMERS.has(this.peek().value)) {
+      const after = this.peekAt(1);
+      // `<op> { … }` or `<op> distinct { … }`.
+      const opThenBrace = after?.type === "lbrace";
+      const opDistinctBrace = after?.type === "ident" && after.value === "distinct" && this.peekAt(2)?.type === "lbrace";
+      if (opThenBrace || opDistinctBrace) {
+        const op = this.next().value as Consumer;
+        let distinct = false;
+        if (this.at("ident", "distinct")) { this.next(); distinct = true; }
+        this.next(); // '{'
+        const { sub, distinct: bodyDistinct } = this.parseSubquery();
+        if (!this.at("rbrace")) this.fail(`expected '}' to close the ${op} { … } block`);
+        this.next();
+        return { kind: "op", receiver, op, sub, distinct: distinct || bodyDistinct };
+      }
     }
     this.pos = start;
     return null;
   }
 
-  private parseSubquery(): Subquery {
+  private parseSubquery(): { sub: Subquery; distinct: boolean } {
     const body = this.parseBody(true);
-    return { from: body.froms, where: body.where, select: body.select, orderBy: body.orderBy, follow: body.follow };
+    return { sub: { from: body.froms, where: body.where, select: body.select, orderBy: body.orderBy, follow: body.follow }, distinct: body.distinct };
   }
 
   // ---- expression Pratt parser ----------------------------------------------
@@ -414,15 +440,47 @@ class Parser {
   // Comparison / membership (also the entry point for a where scalar leaf, so a
   // where leaf never swallows the where-tree's && / ||).
   private parseCmp(): Expr {
-    let left = this.parseAdd();
+    let left = this.parseRange();
     if (this.peek().type === "op" && CMP_OPS.has(this.peek().value)) {
       const op = this.next().value;
-      return { kind: "binary", op, left, right: this.parseAdd() };
+      return { kind: "binary", op, left, right: this.parseRange() };
     }
-    if (this.at("ident", "in")) { this.next(); return { kind: "in", left, right: this.parseAdd() }; }
+    if (this.at("ident", "in")) { this.next(); return { kind: "in", left, right: this.parseRange() }; }
     return left;
   }
 
+  // Range literal: `lo..hi` / `lo...hi` and the open-ended forms `..hi`, `lo..`.
+  // Binds looser than arithmetic (so `1+1..2*3` is the range 2..6) but tighter
+  // than comparison / `in` (so `n in 1..5` reads as `n in (1..5)`). A leading
+  // `..`/`...` opens the low end; a trailing `..`/`...` with no following value
+  // opens the high end.
+  private parseRange(): Expr {
+    if (this.at("range")) {
+      const exclusiveEnd = this.next().value === "...";
+      return { kind: "range", lo: null, hi: this.parseAdd(), exclusiveEnd };
+    }
+    const lo = this.parseAdd();
+    if (this.at("range")) {
+      const exclusiveEnd = this.next().value === "...";
+      const hi = this.canStartValue() ? this.parseAdd() : null;
+      return { kind: "range", lo, hi, exclusiveEnd };
+    }
+    return lo;
+  }
+
+  // Whether the current token can begin a value expression — used to tell an
+  // open-ended range (`5..` followed by a clause boundary) from a bounded one.
+  // Clause-continuation words (`order`, `by`, `follow`, `asc/desc`, `distinct`,
+  // consumers, …) are lexed as bare idents, so they must NOT count as a value
+  // start, or `where age in 18.. order by name` would read `order` as the bound.
+  private canStartValue(): boolean {
+    const t = this.peek();
+    if (t.type === "ident") return !CLAUSE_WORDS.has(t.value);
+    if (t.type === "number" || t.type === "string" ||
+        t.type === "binding" || t.type === "lparen" || t.type === "caret") return true;
+    return t.type === "op" && (t.value === "-" || t.value === "!");
+  }
+
   private parseAdd(): Expr {
     let left = this.parseMul();
     while (this.peek().type === "op" && ADD_OPS.has(this.peek().value)) {

package/src/semantics.ts

@@ -14,8 +14,8 @@
 //     throws, never orders). Numbers and strings order naturally; mixed types do
 //     not order (false).
 //   • Truthiness: JavaScript truthiness of the value.
-//   • `in`: membership in an array (by ==), substring in a string, or key in an
-//     object.
+//   • `in`: membership in an array (by ==), substring in a string, key in an
+//     object, or coverage by a range (lo..hi / lo...hi / open-ended).
 
 /** Equality with absence-normalization (undefined ≡ null) and strict typing. */
 export function equals(a: unknown, b: unknown): boolean {
@@ -55,12 +55,46 @@ export function arith(op: string, a: unknown, b: unknown): unknown {
 
 export function membership(needle: unknown, haystack: unknown): boolean {
   if (haystack == null) return false;
+  if (isRange(haystack)) return rangeCovers(haystack, needle);
   if (Array.isArray(haystack)) return haystack.some((x) => equals(x, needle));
   if (typeof haystack === "string") return haystack.includes(String(needle));
   if (typeof haystack === "object") return String(needle) in (haystack as object);
   return false;
 }
 
+/** A Ruby-style range value produced by a `lo..hi` / `lo...hi` expression. A
+ * null bound is an open end (`..hi` / `lo..`). `exclusiveEnd` marks the `...`
+ * form (hi is excluded). Tagged so `membership`/`in` can recognize it among
+ * plain objects. */
+export interface OqxRange {
+  readonly __oqxRange: true;
+  readonly lo: unknown;
+  readonly hi: unknown;
+  readonly exclusiveEnd: boolean;
+}
+
+/** Construct a range value (absent bounds normalized to null → open end). */
+export function makeRange(lo: unknown, hi: unknown, exclusiveEnd: boolean): OqxRange {
+  return { __oqxRange: true, lo: lo ?? null, hi: hi ?? null, exclusiveEnd };
+}
+
+/** Whether a value is a range produced by `makeRange`. */
+export function isRange(v: unknown): v is OqxRange {
+  return typeof v === "object" && v !== null && (v as { __oqxRange?: unknown }).__oqxRange === true;
+}
+
+/** Whether `x` falls within `range`: `lo <= x` (when lo is present) and either
+ * `x <= hi` (inclusive) or `x < hi` (exclusive end) (when hi is present). Bound
+ * checks go through `relate`, so an absent `x` — or one that doesn't order
+ * against a bound (mixed types) — is simply not covered (never throws). This
+ * also makes date/time ranges work over ISO-8601 strings or `Date` values,
+ * whose natural ordering `relate` already honors. */
+export function rangeCovers(range: OqxRange, x: unknown): boolean {
+  const geLo = range.lo == null || relate(">=", x, range.lo);
+  const leHi = range.hi == null || relate(range.exclusiveEnd ? "<" : "<=", x, range.hi);
+  return geLo && leHi;
+}
+
 export function truthy(v: unknown): boolean {
   return Boolean(v);
 }