@webda/ql 4.0.0-beta.6 → 4.0.0-beta.8

package/lib/query.js

@@ -4,6 +4,151 @@ import { WebdaQLLexer } from "./WebdaQLLexer.js";
 import { CountAllItemContext, CountDistinctItemContext, FieldItemContext, MetricItemContext, OrderFieldExpressionContext, SubExpressionContext, WebdaQLParserParser } from "./WebdaQLParserParser.js";
 import { checkAlias, validateAggregation } from "./aggregation-query.js";
 import { escapeValue, WebdaQLError } from "./webdaql-string.js";
+/**
+ * A value computed at evaluation time
+ */
+export class DynamicValue {
+}
+/**
+ * Dynamic value representing the current timestamp (in milliseconds since epoch) with an optional duration offset
+ */
+export class NowValue extends DynamicValue {
+    offsetMs;
+    raw;
+    name = "NOW";
+    /**
+     * @param offsetMs - offset in milliseconds to add to Date.now()
+     * @param raw - original duration string literal (if parsed from one)
+     */
+    constructor(offsetMs = 0, raw) {
+        super();
+        this.offsetMs = offsetMs;
+        this.raw = raw;
+    }
+    /**
+     * Resolve to current timestamp + offset
+     * @returns timestamp in milliseconds
+     */
+    resolve() {
+        return Date.now() + this.offsetMs;
+    }
+    /**
+     * String representation of NOW function call
+     * @returns WQL NOW function string
+     */
+    toString() {
+        if (this.raw !== undefined && this.raw !== "") {
+            return `NOW('${this.raw}')`;
+        }
+        if (this.offsetMs !== 0) {
+            if (this.offsetMs % 1000 === 0) {
+                return `NOW('${this.offsetMs / 1000}s')`;
+            }
+            return `NOW('${this.offsetMs}ms')`;
+        }
+        return "NOW()";
+    }
+}
+/**
+ * Supported duration units and their factor in seconds
+ */
+const DURATION_UNITS = {
+    s: 1,
+    sec: 1,
+    secs: 1,
+    second: 1,
+    seconds: 1,
+    m: 60,
+    min: 60,
+    mins: 60,
+    minute: 60,
+    minutes: 60,
+    h: 3600,
+    hr: 3600,
+    hour: 3600,
+    hours: 3600,
+    d: 86400,
+    day: 86400,
+    days: 86400,
+    mo: 86400 * 30,
+    mon: 86400 * 30,
+    month: 86400 * 30,
+    months: 86400 * 30,
+    y: 86400 * 365,
+    yr: 86400 * 365,
+    year: 86400 * 365,
+    years: 86400 * 365,
+    ms: 0.001,
+    msec: 0.001,
+    msecs: 0.001,
+    millisecond: 0.001,
+    milliseconds: 0.001
+};
+/**
+ * Parse a duration string or numeric seconds into milliseconds.
+ *
+ * Supports an optional leading sign (`+` or `-`), and composite parts like `1d2h`, `10m`, `30`, `1.5h`.
+ * Numeric inputs are treated as seconds.
+ *
+ * @param input - duration string or numeric seconds
+ * @returns duration offset in milliseconds
+ * @throws {WebdaQLError} if the format or unit is invalid
+ */
+export function parseDurationToMs(input) {
+    if (typeof input === "number") {
+        if (!Number.isFinite(input)) {
+            throw new WebdaQLError(`Invalid duration: ${input}`);
+        }
+        return Math.round(input * 1000);
+    }
+    const raw = String(input).trim();
+    if (!raw) {
+        throw new WebdaQLError("Duration value cannot be empty");
+    }
+    let sign = 1;
+    let rest = raw;
+    if (rest.startsWith("-")) {
+        sign = -1;
+        rest = rest.slice(1).trim();
+    }
+    else if (rest.startsWith("+")) {
+        rest = rest.slice(1).trim();
+    }
+    if (!rest) {
+        throw new WebdaQLError(`Invalid duration format: ${raw}`);
+    }
+    const re = /(\d+(?:\.\d+)?)\s*([a-zA-Z]+)?/g;
+    let totalSeconds = 0;
+    let matched = false;
+    let lastIndex = 0;
+    let m;
+    while ((m = re.exec(rest)) !== null) {
+        const skipped = rest.slice(lastIndex, m.index).trim();
+        if (skipped) {
+            throw new WebdaQLError(`Invalid duration format: ${raw}`);
+        }
+        matched = true;
+        lastIndex = re.lastIndex;
+        const num = parseFloat(m[1]);
+        const unitStr = m[2];
+        if (unitStr) {
+            const u = unitStr.toLowerCase();
+            const factor = DURATION_UNITS[u];
+            if (factor === undefined) {
+                throw new WebdaQLError(`Unsupported duration unit: ${unitStr}`);
+            }
+            totalSeconds += num * factor;
+        }
+        else {
+            totalSeconds += num;
+        }
+    }
+    const trailing = rest.slice(lastIndex).trim();
+    if (!matched || trailing) {
+        throw new WebdaQLError(`Invalid duration format: ${raw}`);
+    }
+    return Math.round(sign * totalSeconds * 1000);
+}
 /**
  * Strip the quotes of a WebdaQL string literal and unescape its contents.
  *
@@ -151,8 +296,8 @@ export class ExpressionBuilder extends AbstractParseTreeVisitor {
      * @param ctx - the order expression context
      */
     visitOrderExpression(ctx) {
-        this.orderBy = ctx.children
-            ?.filter(c => c instanceof OrderFieldExpressionContext)
+        this.orderBy = (ctx.children ?? [])
+            .filter(c => c instanceof OrderFieldExpressionContext)
             .map((c) => this.visitOrderFieldExpression(c));
     }
     /**
@@ -161,7 +306,9 @@ export class ExpressionBuilder extends AbstractParseTreeVisitor {
      * @returns the built Query
      */
     visitWebdaql(ctx) {
-        return ctx.statement() ? this.visitStatement(ctx.statement()) : this.visitFilterQuery(ctx.filterQuery());
+        const statement = ctx.statement();
+        const filter = ctx.filterQuery();
+        return statement ? this.visitStatement(statement) : filter ? this.visitFilterQuery(filter) : this.defaultResult();
     }
     /**
      * Visit a DELETE, UPDATE or SELECT statement
@@ -242,9 +389,19 @@ export class ExpressionBuilder extends AbstractParseTreeVisitor {
      * @returns the assignment
      */
     visitAssignment(ctx) {
+        const raw = this.visit(ctx.getChild(2));
+        if (raw instanceof DynamicValue) {
+            return {
+                field: ctx.identifier().text,
+                rawValue: raw,
+                get value() {
+                    return raw.resolve();
+                }
+            };
+        }
         return {
             field: ctx.identifier().text,
-            value: this.visit(ctx.getChild(2))
+            value: raw
         };
     }
     /**
@@ -327,8 +484,8 @@ export class ExpressionBuilder extends AbstractParseTreeVisitor {
      */
     getComparison(ctx) {
         const res = [];
-        // eslint-disable-next-line prefer-const
-        let [left, _, right] = ctx.children;
+        let left = ctx.getChild(0);
+        let right = ctx.getChild(2);
         if (right instanceof SubExpressionContext) {
             right = right.getChild(1);
         }
@@ -366,7 +523,9 @@ export class ExpressionBuilder extends AbstractParseTreeVisitor {
      * @returns the comparison expression
      */
     visitBinaryComparisonExpression(ctx) {
-        const [left, op, right] = ctx.children;
+        const left = ctx.getChild(0);
+        const op = ctx.getChild(1);
+        const right = ctx.getChild(2);
         // @ts-ignore
         return new ComparisonExpression(op.text, left.text, this.visit(right));
     }
@@ -376,7 +535,7 @@ export class ExpressionBuilder extends AbstractParseTreeVisitor {
      * @returns the array of values
      */
     visitSetExpression(ctx) {
-        return ctx.children.filter((_i, id) => id % 2).map(c => this.visit(c));
+        return (ctx.children ?? []).filter((_i, id) => id % 2).map(c => this.visit(c));
     }
     /**
      * Visit a LIKE expression (e.g. `field LIKE '%pattern_'`)
@@ -384,7 +543,8 @@ export class ExpressionBuilder extends AbstractParseTreeVisitor {
      * @returns the comparison expression
      */
     visitLikeExpression(ctx) {
-        const [left, _, right] = ctx.children;
+        const left = ctx.getChild(0);
+        const right = ctx.getChild(2);
         const value = this.visit(right);
         return new ComparisonExpression("LIKE", left.text, value);
     }
@@ -394,7 +554,8 @@ export class ExpressionBuilder extends AbstractParseTreeVisitor {
      * @returns the comparison expression
      */
     visitInExpression(ctx) {
-        const [left, _, right] = ctx.children;
+        const left = ctx.getChild(0);
+        const right = ctx.getChild(2);
         const value = this.visit(right);
         return new ComparisonExpression("IN", left.text, value);
     }
@@ -404,7 +565,8 @@ export class ExpressionBuilder extends AbstractParseTreeVisitor {
      * @returns the comparison expression
      */
     visitContainsExpression(ctx) {
-        const [left, _, right] = ctx.children;
+        const left = ctx.getChild(0);
+        const right = ctx.getChild(2);
         const value = this.visit(right);
         return new ComparisonExpression("CONTAINS", left.text, value);
     }
@@ -480,6 +642,34 @@ export class ExpressionBuilder extends AbstractParseTreeVisitor {
     visitNumberLiteral(ctx) {
         return parseFloat(ctx.text);
     }
+    /**
+     * Visit a NOW() function call with optional duration offset
+     * @param ctx - the now function context
+     * @returns the NowValue
+     */
+    visitNowFunction(ctx) {
+        const stringLiteral = ctx.stringLiteral();
+        if (stringLiteral) {
+            const raw = unescapeStringLiteral(stringLiteral.text);
+            const offsetMs = parseDurationToMs(raw);
+            return new NowValue(offsetMs, raw);
+        }
+        const integerLiteral = ctx.integerLiteral();
+        if (integerLiteral) {
+            const seconds = parseInt(integerLiteral.text);
+            return new NowValue(seconds * 1000, integerLiteral.text);
+        }
+        const numberLiteral = ctx.numberLiteral();
+        if (numberLiteral) {
+            const seconds = parseFloat(numberLiteral.text);
+            return new NowValue(Math.round(seconds * 1000), numberLiteral.text);
+        }
+        const parameter = ctx.parameter();
+        if (parameter) {
+            return this.visitParameter(parameter);
+        }
+        return new NowValue(0);
+    }
     /**
      * A `?` or `:name` placeholder reaching evaluation was never bound
      * @param ctx - the parameter context
@@ -514,9 +704,9 @@ export const UNARY_COMPARISON_OPERATORS = ["IS NULL", "IS NOT NULL"];
  */
 export class ComparisonExpression extends Expression {
     /**
-     * Right side of the comparison
+     * Right side of the comparison (raw parsed value, possibly DynamicValue)
      */
-    value;
+    rawValue;
     /**
      * Attribute to read from the object (split by .)
      */
@@ -524,13 +714,45 @@ export class ComparisonExpression extends Expression {
     /**
      * @param operator - comparison operator
      * @param attribute - dot-notation path to the object property (e.g. `"user.name"`)
-     * @param value - literal value or array of values (for IN operator) to compare against
+     * @param rawValue - literal value, DynamicValue, or array of values (for IN operator) to compare against
      */
-    constructor(operator, attribute, value) {
+    constructor(operator, attribute, rawValue) {
         super(operator);
-        this.value = value;
+        this.rawValue = rawValue;
         this.attribute = attribute.split(".");
     }
+    /**
+     * Resolved value at evaluation time
+     * @returns the resolved scalar or array value
+     */
+    get value() {
+        if (this.rawValue instanceof DynamicValue) {
+            return this.rawValue.resolve();
+        }
+        if (Array.isArray(this.rawValue)) {
+            return this.rawValue.map(v => (v instanceof DynamicValue ? v.resolve() : v));
+        }
+        return this.rawValue;
+    }
+    /**
+     * Set the raw value
+     * @param val - new value
+     */
+    set value(val) {
+        this.rawValue = val;
+    }
+    /**
+     * @override
+     */
+    isDynamic() {
+        if (this.rawValue instanceof DynamicValue) {
+            return true;
+        }
+        if (Array.isArray(this.rawValue)) {
+            return this.rawValue.some(v => v instanceof DynamicValue);
+        }
+        return false;
+    }
     /**
      * Convert a SQL LIKE pattern to a JavaScript RegExp
      *
@@ -597,19 +819,27 @@ export class ComparisonExpression extends Expression {
      * @override
      */
     eval(target) {
-        const left = ComparisonExpression.getAttributeValue(target, this.attribute);
+        let left = ComparisonExpression.getAttributeValue(target, this.attribute);
+        // WebdaQL has no date literal: a date compared with a string compares as its ISO 8601 form, the way it is
+        // serialized; comparisons with numbers keep the native Date behavior
+        if (left instanceof Date &&
+            !isNaN(left.getTime()) &&
+            this.operator !== "LIKE" &&
+            (typeof this.value === "string" || (Array.isArray(this.value) && this.value.some(v => typeof v === "string")))) {
+            left = left.toISOString();
+        }
         switch (this.operator) {
             case "=":
                 // ignore strong type on purpose
                 return left == this.value;
             case "<=":
-                return left <= this.value;
+                return left <= (this.value ?? 0);
             case ">=":
-                return left >= this.value;
+                return left >= (this.value ?? 0);
             case "<":
-                return left < this.value;
+                return left < (this.value ?? 0);
             case ">":
-                return left > this.value;
+                return left > (this.value ?? 0);
             case "!=":
                 return left != this.value;
             case "LIKE":
@@ -638,10 +868,14 @@ export class ComparisonExpression extends Expression {
      * Serialize a value to its WebdaQL string representation
      *
      * Strings are double-quoted, booleans are uppercased, arrays are bracket-wrapped.
+     * Dynamic values serialize to their canonical function call string (e.g. `NOW('-10m')`).
      * @param value - the value to serialize
      * @returns the serialized string
      */
     toStringValue(value) {
+        if (value instanceof DynamicValue) {
+            return value.toString();
+        }
         if (Array.isArray(value)) {
             return `[${value.map(v => this.toStringValue(v)).join(", ")}]`;
         }
@@ -651,7 +885,7 @@ export class ComparisonExpression extends Expression {
             case "boolean":
                 return value.toString().toUpperCase();
         }
-        return value?.toString();
+        return value === null ? "NULL" : value.toString();
     }
     /**
      * Allow subclass to create different display
@@ -674,7 +908,7 @@ export class ComparisonExpression extends Expression {
         if (UNARY_COMPARISON_OPERATORS.includes(this.operator)) {
             return `${this.toStringAttribute()} ${this.toStringOperator()}`;
         }
-        return `${this.toStringAttribute()} ${this.toStringOperator()} ${this.toStringValue(this.value)}`;
+        return `${this.toStringAttribute()} ${this.toStringOperator()} ${this.toStringValue(this.rawValue)}`;
     }
 }
 /**
@@ -704,6 +938,12 @@ export class LogicalExpression extends Expression {
         }
         return this.children.map(c => c.toString(depth + 1)).join(` ${this.operator} `);
     }
+    /**
+     * @override
+     */
+    isDynamic() {
+        return this.children.some(c => c.isDynamic());
+    }
 }
 /**
  * Logical AND expression — evaluates to `true` only if all children are `true`
@@ -786,6 +1026,12 @@ export class BooleanExpression extends Expression {
     toString() {
         return this.operator;
     }
+    /**
+     * @override
+     */
+    isDynamic() {
+        return false;
+    }
 }
 /**
  * Build an AND / OR expression, folding `TRUE` / `FALSE` constants away
@@ -839,18 +1085,32 @@ function throwingErrorListener(sql) {
     };
 }
 /**
- * Create a lexer and a parser for a query, both throwing on errors
+ * Create a lexer and a parser for a query
  * @param sql - the query string
- * @returns the lexer and the parser
+ * @param options - parser options
+ * @returns the lexer, parser and token stream
  */
-function createParser(sql) {
+export function createParser(sql, options) {
     const lexer = new WebdaQLLexer(CharStreams.fromString(sql || ""));
     lexer.removeErrorListeners();
-    lexer.addErrorListener(throwingErrorListener(sql));
-    const parser = new WebdaQLParserParser(new CommonTokenStream(lexer));
+    if (!options?.tolerant) {
+        lexer.addErrorListener(throwingErrorListener(sql));
+    }
+    const tokens = new CommonTokenStream(lexer);
+    const parser = new WebdaQLParserParser(tokens);
     parser.removeErrorListeners();
-    parser.addErrorListener(throwingErrorListener(sql));
-    return { lexer, parser };
+    if (!options?.tolerant) {
+        parser.addErrorListener(throwingErrorListener(sql));
+    }
+    return { lexer, parser, tokens };
+}
+/**
+ * Create a tolerant lexer and parser that do not throw on syntax errors
+ * @param sql - the query string
+ * @returns the lexer, parser and token stream
+ */
+export function createTolerantParser(sql) {
+    return createParser(sql, { tolerant: true });
 }
 /**
  * Check a query against the WebdaQL grammar without evaluating it
@@ -942,7 +1202,7 @@ export class QueryValidator {
      * @param type - logical operator to combine filters (`"AND"` or `"OR"`)
      * @returns `this` for chaining
      */
-    merge(query, type = "AND") {
+    merge(query = "", type = "AND") {
         const adds = new QueryValidator(query);
         if (adds.query.type !== "SELECT" || adds.query.fields) {
             throw new SyntaxError(`Only a filter can be merged into a query, not a statement (Query: ${query})`);
@@ -1010,6 +1270,13 @@ export class QueryValidator {
     eval(target) {
         return this.query.filter.eval(target);
     }
+    /**
+     * Check whether this query's filter contains any dynamic values
+     * @returns true if any child comparison holds a DynamicValue
+     */
+    isDynamic() {
+        return this.query.filter.isDynamic();
+    }
     /**
      * Display parse tree back as query
      * @param tree - the parse tree to display
@@ -1205,7 +1472,8 @@ export class PartialExpressionBuilder extends ExpressionBuilder {
      * @returns the partial comparison expression
      */
     visitLikeExpression(ctx) {
-        const [left, _, right] = ctx.children;
+        const left = ctx.getChild(0);
+        const right = ctx.getChild(2);
         const value = this.visit(right);
         return new PartialComparisonExpression(this, "LIKE", left.text, value);
     }
@@ -1215,7 +1483,9 @@ export class PartialExpressionBuilder extends ExpressionBuilder {
      * @returns the partial comparison expression
      */
     visitBinaryComparisonExpression(ctx) {
-        const [left, op, right] = ctx.children;
+        const left = ctx.getChild(0);
+        const op = ctx.getChild(1);
+        const right = ctx.getChild(2);
         // @ts-ignore
         return new PartialComparisonExpression(this, op.text, left.text, this.visit(right));
     }
@@ -1225,7 +1495,8 @@ export class PartialExpressionBuilder extends ExpressionBuilder {
      * @returns the partial comparison expression
      */
     visitInExpression(ctx) {
-        const [left, _, right] = ctx.children;
+        const left = ctx.getChild(0);
+        const right = ctx.getChild(2);
         const value = this.visit(right);
         return new PartialComparisonExpression(this, "IN", left.text, value);
     }
@@ -1235,7 +1506,8 @@ export class PartialExpressionBuilder extends ExpressionBuilder {
      * @returns the partial comparison expression
      */
     visitContainsExpression(ctx) {
-        const [left, _, right] = ctx.children;
+        const left = ctx.getChild(0);
+        const right = ctx.getChild(2);
         const value = this.visit(right);
         return new PartialComparisonExpression(this, "CONTAINS", left.text, value);
     }
@@ -1282,7 +1554,7 @@ export function stringifyQuery(query) {
         head = "DELETE";
     }
     else if (query.type === "UPDATE") {
-        head = `UPDATE SET ${(query.assignments ?? []).map(a => new ComparisonExpression("=", a.field, a.value).toString()).join(", ")}`;
+        head = `UPDATE SET ${(query.assignments ?? []).map(a => new ComparisonExpression("=", a.field, a.rawValue ?? a.value).toString()).join(", ")}`;
     }
     else if (query.aggregation) {
         const metrics = Object.entries(query.aggregation.metrics).map(([alias, metric]) => {
@@ -1321,7 +1593,7 @@ const FIELD_SEGMENT = /^[A-Za-z0-9_]+$/;
  * @returns the dotted path
  * @throws {WebdaQLError} when a segment is empty or holds anything but letters, digits and `_`
  */
-function checkFieldPath(field) {
+export function checkFieldPath(field) {
     // Copy first: what is checked is what is printed, whatever the object does on later reads
     const segments = Array.isArray(field) ? snapshot(field) : typeof field === "string" ? field.split(".") : undefined;
     if (!segments?.length || segments.some(segment => typeof segment !== "string" || !FIELD_SEGMENT.test(segment))) {
@@ -1349,6 +1621,9 @@ function snapshot(value) {
  * @throws {WebdaQLError} for anything but a string, a finite number or a boolean
  */
 function checkScalar(value) {
+    if (value instanceof DynamicValue) {
+        return value.toString();
+    }
     if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
         throw new WebdaQLError(`Invalid value in WebdaQL query: ${typeof value}`);
     }
@@ -1387,7 +1662,7 @@ function printExpression(expression, nested) {
     if (expression instanceof ComparisonExpression) {
         const attribute = checkFieldPath(expression.attribute);
         const operator = expression.operator;
-        const value = expression.value;
+        const value = expression.rawValue !== undefined ? expression.rawValue : expression.value;
         if (typeof operator !== "string") {
             throw new WebdaQLError("Invalid operator in WebdaQL query");
         }
@@ -1448,7 +1723,7 @@ export function normalizeQuery(query) {
         head = `UPDATE SET ${assignments
             .map(a => {
             const field = a?.field;
-            const value = a?.value;
+            const value = a?.rawValue ?? a?.value;
             return `${checkFieldPath(field)} = ${checkScalar(value)}`;
         })
             .join(", ")}`;