@praxisui/specification 1.0.0-beta.30 → 1.0.0-beta.40

package/fesm2022/praxisui-specification.mjs

@@ -13,6 +13,13 @@ var ComparisonOperator;
     ComparisonOperator["STARTS_WITH"] = "startsWith";
     ComparisonOperator["ENDS_WITH"] = "endsWith";
     ComparisonOperator["IN"] = "in";
+    ComparisonOperator["NOT_IN"] = "notIn";
+    ComparisonOperator["MATCHES"] = "matches";
+    ComparisonOperator["NOT_MATCHES"] = "notMatches";
+    ComparisonOperator["IS_NULL"] = "isNull";
+    ComparisonOperator["IS_NOT_NULL"] = "isNotNull";
+    ComparisonOperator["IS_EMPTY"] = "isEmpty";
+    ComparisonOperator["IS_NOT_EMPTY"] = "isNotEmpty";
 })(ComparisonOperator || (ComparisonOperator = {}));
 const OPERATOR_SYMBOLS = {
     [ComparisonOperator.EQUALS]: '==',
@@ -24,7 +31,14 @@ const OPERATOR_SYMBOLS = {
     [ComparisonOperator.CONTAINS]: 'contains',
     [ComparisonOperator.STARTS_WITH]: 'startsWith',
     [ComparisonOperator.ENDS_WITH]: 'endsWith',
-    [ComparisonOperator.IN]: 'in'
+    [ComparisonOperator.IN]: 'in',
+    [ComparisonOperator.NOT_IN]: 'not in',
+    [ComparisonOperator.MATCHES]: 'matches',
+    [ComparisonOperator.NOT_MATCHES]: '!~',
+    [ComparisonOperator.IS_NULL]: 'is null',
+    [ComparisonOperator.IS_NOT_NULL]: 'is not null',
+    [ComparisonOperator.IS_EMPTY]: 'is empty',
+    [ComparisonOperator.IS_NOT_EMPTY]: 'is not empty'
 };
 
 class FieldSpecification extends Specification {
@@ -60,6 +74,26 @@ class FieldSpecification extends Specification {
                 return String(fieldValue).endsWith(String(this.value));
             case ComparisonOperator.IN:
                 return Array.isArray(this.value) && this.value.includes(fieldValue);
+            case ComparisonOperator.NOT_IN:
+                return Array.isArray(this.value) && !this.value.includes(fieldValue);
+            case ComparisonOperator.MATCHES:
+                if (this.value === undefined || this.value === null) {
+                    return false;
+                }
+                return this.toRegExp(this.value).test(String(fieldValue));
+            case ComparisonOperator.NOT_MATCHES:
+                if (this.value === undefined || this.value === null) {
+                    return false;
+                }
+                return !this.toRegExp(this.value).test(String(fieldValue));
+            case ComparisonOperator.IS_NULL:
+                return fieldValue === null || fieldValue === undefined;
+            case ComparisonOperator.IS_NOT_NULL:
+                return fieldValue !== null && fieldValue !== undefined;
+            case ComparisonOperator.IS_EMPTY:
+                return this.isEmpty(fieldValue);
+            case ComparisonOperator.IS_NOT_EMPTY:
+                return this.isNotEmpty(fieldValue);
             default:
                 throw new Error(`Unsupported operator: ${this.operator}`);
         }
@@ -90,10 +124,25 @@ class FieldSpecification extends Specification {
             case ComparisonOperator.ENDS_WITH:
                 return `endsWith(${fieldName}, ${JSON.stringify(this.value)})`;
             case ComparisonOperator.IN:
+            case ComparisonOperator.NOT_IN: {
                 const values = Array.isArray(this.value)
                     ? this.value.map((v) => JSON.stringify(v)).join(', ')
                     : JSON.stringify(this.value);
-                return `${fieldName} in (${values})`;
+                const keyword = this.operator === ComparisonOperator.NOT_IN ? 'not in' : 'in';
+                return `${fieldName} ${keyword} [${values}]`;
+            }
+            case ComparisonOperator.MATCHES:
+                return `${fieldName} matches ${this.formatMatchesValue(this.value)}`;
+            case ComparisonOperator.NOT_MATCHES:
+                return `${fieldName} !~ ${this.formatMatchesValue(this.value)}`;
+            case ComparisonOperator.IS_NULL:
+                return `${fieldName} is null`;
+            case ComparisonOperator.IS_NOT_NULL:
+                return `${fieldName} is not null`;
+            case ComparisonOperator.IS_EMPTY:
+                return `${fieldName} is empty`;
+            case ComparisonOperator.IS_NOT_EMPTY:
+                return `${fieldName} is not empty`;
             default:
                 return `${fieldName} ${symbol} ${JSON.stringify(this.value)}`;
         }
@@ -107,6 +156,53 @@ class FieldSpecification extends Specification {
     getValue() {
         return this.value;
     }
+    toRegExp(value) {
+        if (value instanceof RegExp) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            const regexLiteral = value.match(/^\/(.+)\/([gimsuy]*)$/);
+            if (regexLiteral) {
+                return new RegExp(regexLiteral[1], regexLiteral[2]);
+            }
+            return new RegExp(value);
+        }
+        return new RegExp(String(value));
+    }
+    isEmpty(value) {
+        // Consider null/undefined as empty to align with DSL semantics for "is empty".
+        if (value === null || value === undefined) {
+            return true;
+        }
+        if (typeof value === 'string' || Array.isArray(value)) {
+            return value.length === 0;
+        }
+        if (value instanceof Set || value instanceof Map) {
+            return value.size === 0;
+        }
+        if (typeof value === 'object') {
+            return Object.keys(value).length === 0;
+        }
+        return false;
+    }
+    isNotEmpty(value) {
+        if (value === null || value === undefined) {
+            return false;
+        }
+        return !this.isEmpty(value);
+    }
+    formatMatchesValue(value) {
+        if (value instanceof RegExp) {
+            return value.toString();
+        }
+        if (typeof value === 'string') {
+            const regexLiteral = value.match(/^\/.+\/[gimsuy]*$/);
+            if (regexLiteral) {
+                return value;
+            }
+        }
+        return JSON.stringify(value);
+    }
 }
 
 class AndSpecification extends Specification {
@@ -125,6 +221,7 @@ class AndSpecification extends Specification {
         return {
             type: 'and',
             specs: this.specifications.map((spec) => spec.toJSON()),
+            metadata: this.metadata,
         };
     }
     static fromJSON(json) {
@@ -176,6 +273,7 @@ class OrSpecification extends Specification {
         return {
             type: 'or',
             specs: this.specifications.map((spec) => spec.toJSON()),
+            metadata: this.metadata,
         };
     }
     static fromJSON(json) {
@@ -401,7 +499,8 @@ class FunctionSpecification extends Specification {
     }
     isSatisfiedBy(obj) {
         const registry = this.registry || FunctionRegistry.getInstance();
-        return registry.execute(this.functionName, obj, ...this.args);
+        const resolvedArgs = this.args.map((arg) => this.resolveArg(obj, arg));
+        return registry.execute(this.functionName, obj, ...resolvedArgs);
     }
     toJSON() {
         return {
@@ -439,6 +538,59 @@ class FunctionSpecification extends Specification {
     clone() {
         return new FunctionSpecification(this.functionName, [...this.args], this.registry, this.metadata);
     }
+    resolveArg(obj, arg) {
+        if (Array.isArray(arg)) {
+            return arg.map((entry) => this.resolveArg(obj, entry));
+        }
+        if (this.isFieldArg(arg)) {
+            const lookup = this.getPathValue(obj, arg.field);
+            if (lookup.found)
+                return lookup.value;
+            // Backward-compatible fallback when field path is not present.
+            return arg.field;
+        }
+        return arg;
+    }
+    isFieldArg(arg) {
+        return !!(arg
+            && typeof arg === 'object'
+            && arg.type === 'field'
+            && typeof arg.field === 'string');
+    }
+    getPathValue(source, path) {
+        if (!source || typeof source !== 'object') {
+            return { found: false, value: undefined };
+        }
+        const raw = String(path || '').trim();
+        if (!raw) {
+            return { found: false, value: undefined };
+        }
+        const blocked = new Set(['__proto__', 'prototype', 'constructor']);
+        if (blocked.has(raw)) {
+            return { found: false, value: undefined };
+        }
+        if (raw in source) {
+            return { found: true, value: source[raw] };
+        }
+        if (!raw.includes('.')) {
+            return { found: false, value: undefined };
+        }
+        const segments = raw.split('.').filter(Boolean);
+        let cursor = source;
+        for (const segment of segments) {
+            if (blocked.has(segment)) {
+                return { found: false, value: undefined };
+            }
+            if (cursor == null || (typeof cursor !== 'object' && typeof cursor !== 'function')) {
+                return { found: false, value: undefined };
+            }
+            if (!(segment in cursor)) {
+                return { found: false, value: undefined };
+            }
+            cursor = cursor[segment];
+        }
+        return { found: true, value: cursor };
+    }
 }
 
 class AtLeastSpecification extends Specification {
@@ -649,6 +801,26 @@ class FieldToFieldSpecification extends Specification {
                 return String(valueA).endsWith(String(valueB));
             case ComparisonOperator.IN:
                 return Array.isArray(valueB) && valueB.includes(valueA);
+            case ComparisonOperator.NOT_IN:
+                return Array.isArray(valueB) && !valueB.includes(valueA);
+            case ComparisonOperator.MATCHES:
+                if (valueB === undefined || valueB === null) {
+                    return false;
+                }
+                return this.toRegExp(valueB).test(String(valueA));
+            case ComparisonOperator.NOT_MATCHES:
+                if (valueB === undefined || valueB === null) {
+                    return false;
+                }
+                return !this.toRegExp(valueB).test(String(valueA));
+            case ComparisonOperator.IS_NULL:
+                return valueA === null || valueA === undefined;
+            case ComparisonOperator.IS_NOT_NULL:
+                return valueA !== null && valueA !== undefined;
+            case ComparisonOperator.IS_EMPTY:
+                return this.isEmpty(valueA);
+            case ComparisonOperator.IS_NOT_EMPTY:
+                return this.isNotEmpty(valueA);
             default:
                 throw new Error(`Unsupported operator: ${this.operator}`);
         }
@@ -688,7 +860,22 @@ class FieldToFieldSpecification extends Specification {
             case ComparisonOperator.ENDS_WITH:
                 return `endsWith(${leftField}, ${rightField})`;
             case ComparisonOperator.IN:
-                return `${leftField} in ${rightField}`;
+            case ComparisonOperator.NOT_IN: {
+                const keyword = this.operator === ComparisonOperator.NOT_IN ? 'not in' : 'in';
+                return `${leftField} ${keyword} ${rightField}`;
+            }
+            case ComparisonOperator.MATCHES:
+                return `${leftField} matches ${rightField}`;
+            case ComparisonOperator.NOT_MATCHES:
+                return `${leftField} !~ ${rightField}`;
+            case ComparisonOperator.IS_NULL:
+                return `${leftField} is null`;
+            case ComparisonOperator.IS_NOT_NULL:
+                return `${leftField} is not null`;
+            case ComparisonOperator.IS_EMPTY:
+                return `${leftField} is empty`;
+            case ComparisonOperator.IS_NOT_EMPTY:
+                return `${leftField} is not empty`;
             default:
                 return `${leftField} ${symbol} ${rightField}`;
         }
@@ -711,6 +898,40 @@ class FieldToFieldSpecification extends Specification {
     clone() {
         return new FieldToFieldSpecification(this.fieldA, this.operator, this.fieldB, this.transformA ? [...this.transformA] : undefined, this.transformB ? [...this.transformB] : undefined, this.transformRegistry, this.metadata);
     }
+    toRegExp(value) {
+        if (value instanceof RegExp) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            const regexLiteral = value.match(/^\/(.+)\/([gimsuy]*)$/);
+            if (regexLiteral) {
+                return new RegExp(regexLiteral[1], regexLiteral[2]);
+            }
+            return new RegExp(value);
+        }
+        return new RegExp(String(value));
+    }
+    isEmpty(value) {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        if (typeof value === 'string' || Array.isArray(value)) {
+            return value.length === 0;
+        }
+        if (value instanceof Set || value instanceof Map) {
+            return value.size === 0;
+        }
+        if (typeof value === 'object') {
+            return Object.keys(value).length === 0;
+        }
+        return false;
+    }
+    isNotEmpty(value) {
+        if (value === null || value === undefined) {
+            return false;
+        }
+        return !this.isEmpty(value);
+    }
 }
 
 class DefaultContextProvider {
@@ -1778,6 +1999,7 @@ var TokenType;
     TokenType["NUMBER"] = "NUMBER";
     TokenType["BOOLEAN"] = "BOOLEAN";
     TokenType["NULL"] = "NULL";
+    TokenType["REGEX"] = "REGEX";
     // Operators
     TokenType["AND"] = "AND";
     TokenType["OR"] = "OR";
@@ -1792,6 +2014,13 @@ var TokenType;
     TokenType["GREATER_THAN"] = "GREATER_THAN";
     TokenType["GREATER_THAN_OR_EQUAL"] = "GREATER_THAN_OR_EQUAL";
     TokenType["IN"] = "IN";
+    TokenType["NOT_IN"] = "NOT_IN";
+    TokenType["MATCHES"] = "MATCHES";
+    TokenType["NOT_MATCHES"] = "NOT_MATCHES";
+    TokenType["IS_NULL"] = "IS_NULL";
+    TokenType["IS_NOT_NULL"] = "IS_NOT_NULL";
+    TokenType["IS_EMPTY"] = "IS_EMPTY";
+    TokenType["IS_NOT_EMPTY"] = "IS_NOT_EMPTY";
     // Function tokens
     TokenType["CONTAINS"] = "CONTAINS";
     TokenType["STARTS_WITH"] = "STARTS_WITH";
@@ -1818,8 +2047,29 @@ const OPERATOR_KEYWORDS = {
     'not': TokenType.NOT,
     '!': TokenType.NOT,
     'xor': TokenType.XOR,
+    '^': TokenType.XOR,
     'implies': TokenType.IMPLIES,
+    '=>': TokenType.IMPLIES,
+    'eq': TokenType.EQUALS,
+    'equals': TokenType.EQUALS,
+    'neq': TokenType.NOT_EQUALS,
+    'notequals': TokenType.NOT_EQUALS,
+    'lt': TokenType.LESS_THAN,
+    'lte': TokenType.LESS_THAN_OR_EQUAL,
+    'gt': TokenType.GREATER_THAN,
+    'gte': TokenType.GREATER_THAN_OR_EQUAL,
     'in': TokenType.IN,
+    'matches': TokenType.MATCHES,
+    '!~': TokenType.NOT_MATCHES,
+    'notmatches': TokenType.NOT_MATCHES,
+    'isnull': TokenType.IS_NULL,
+    'isNull': TokenType.IS_NULL,
+    'isnotnull': TokenType.IS_NOT_NULL,
+    'isNotNull': TokenType.IS_NOT_NULL,
+    'isempty': TokenType.IS_EMPTY,
+    'isEmpty': TokenType.IS_EMPTY,
+    'isnotempty': TokenType.IS_NOT_EMPTY,
+    'isNotEmpty': TokenType.IS_NOT_EMPTY,
     'true': TokenType.BOOLEAN,
     'false': TokenType.BOOLEAN,
     'null': TokenType.NULL
@@ -1827,6 +2077,8 @@ const OPERATOR_KEYWORDS = {
 const COMPARISON_OPERATORS = {
     '==': TokenType.EQUALS,
     '!=': TokenType.NOT_EQUALS,
+    '!~': TokenType.NOT_MATCHES,
+    '~': TokenType.MATCHES,
     '<': TokenType.LESS_THAN,
     '<=': TokenType.LESS_THAN_OR_EQUAL,
     '>': TokenType.GREATER_THAN,
@@ -1863,6 +2115,10 @@ class DslTokenizer {
         if (this.position >= this.input.length) {
             return this.createToken(TokenType.EOF, '');
         }
+        const multiWordOperator = this.readMultiWordOperator();
+        if (multiWordOperator) {
+            return multiWordOperator;
+        }
         const char = this.input[this.position];
         // Field references ${...}
         if (char === '$' && this.peek() === '{') {
@@ -1872,11 +2128,25 @@ class DslTokenizer {
         if (char === '"' || char === "'") {
             return this.readString(char);
         }
+        // Regex literals /pattern/flags
+        if (char === '/') {
+            return this.readRegex();
+        }
         // Numbers
         if (this.isDigit(char) || (char === '-' && this.isDigit(this.peek()))) {
             return this.readNumber();
         }
         // Multi-character operators
+        if (char === '!' && this.peek() === '~') {
+            const token = this.createToken(TokenType.NOT_MATCHES, '!~');
+            this.advance(2);
+            return token;
+        }
+        if (char === '=' && this.peek() === '>') {
+            const token = this.createToken(TokenType.IMPLIES, '=>');
+            this.advance(2);
+            return token;
+        }
         const twoChar = this.input.substr(this.position, 2);
         if (COMPARISON_OPERATORS[twoChar]) {
             const token = this.createToken(COMPARISON_OPERATORS[twoChar], twoChar);
@@ -1904,6 +2174,8 @@ class DslTokenizer {
                     return token;
                 }
                 return this.createTokenAndAdvance(TokenType.NOT, char);
+            case '~':
+                return this.createTokenAndAdvance(TokenType.MATCHES, char);
             case '<':
                 if (this.peek() === '=') {
                     const token = this.createToken(TokenType.LESS_THAN_OR_EQUAL, '<=');
@@ -1939,6 +2211,8 @@ class DslTokenizer {
                     return token;
                 }
                 break;
+            case '^':
+                return this.createTokenAndAdvance(TokenType.XOR, char);
         }
         // Identifiers and keywords
         if (this.isAlpha(char) || char === '_') {
@@ -2006,6 +2280,39 @@ class DslTokenizer {
         this.advance(); // Skip closing quote
         return this.createToken(TokenType.STRING, value, start);
     }
+    readRegex() {
+        const start = this.position;
+        this.advance(); // Skip opening /
+        let pattern = '';
+        while (this.position < this.input.length) {
+            const current = this.input[this.position];
+            if (current === '\\') {
+                pattern += current;
+                this.advance();
+                if (this.position < this.input.length) {
+                    pattern += this.input[this.position];
+                    this.advance();
+                }
+                continue;
+            }
+            if (current === '/') {
+                break;
+            }
+            pattern += current;
+            this.advance();
+        }
+        if (this.position >= this.input.length) {
+            throw new Error('Unterminated regex literal');
+        }
+        this.advance(); // Skip closing /
+        let flags = '';
+        while (this.position < this.input.length && this.isAlpha(this.input[this.position])) {
+            flags += this.input[this.position];
+            this.advance();
+        }
+        const value = `/${pattern}/${flags}`;
+        return this.createToken(TokenType.REGEX, value, start);
+    }
     readNumber() {
         const start = this.position;
         let value = '';
@@ -2038,6 +2345,27 @@ class DslTokenizer {
         const tokenType = OPERATOR_KEYWORDS[value] || TokenType.IDENTIFIER;
         return this.createToken(tokenType, value, start);
     }
+    readMultiWordOperator() {
+        const remaining = this.input.slice(this.position);
+        const patterns = [
+            { regex: /^is\s+not\s+empty\b/i, type: TokenType.IS_NOT_EMPTY },
+            { regex: /^is\s+not\s+null\b/i, type: TokenType.IS_NOT_NULL },
+            { regex: /^is\s+empty\b/i, type: TokenType.IS_EMPTY },
+            { regex: /^is\s+null\b/i, type: TokenType.IS_NULL },
+            { regex: /^not\s+in\b/i, type: TokenType.NOT_IN },
+            { regex: /^not\s+matches\b/i, type: TokenType.NOT_MATCHES },
+        ];
+        for (const pattern of patterns) {
+            const match = remaining.match(pattern.regex);
+            if (match && match[0]) {
+                const tokenValue = remaining.substring(0, match[0].length);
+                const token = this.createToken(pattern.type, tokenValue, this.position);
+                this.advance(match[0].length);
+                return token;
+            }
+        }
+        return null;
+    }
     skipWhitespace() {
         while (this.position < this.input.length && this.isWhitespace(this.input[this.position])) {
             if (this.input[this.position] === '\n') {
@@ -2098,6 +2426,7 @@ class DslParser {
     functionRegistry;
     tokens = [];
     current = 0;
+    lastArgumentTokenType = null;
     constructor(functionRegistry) {
         this.functionRegistry = functionRegistry;
     }
@@ -2171,16 +2500,19 @@ class DslParser {
     parseComparison() {
         let left = this.parsePrimary();
         if (this.matchComparison()) {
-            const operator = this.previous().type;
+            const operatorToken = this.previous();
+            const compOp = this.tokenTypeToComparisonOperator(operatorToken.type);
             // Parse RHS allowing literals, arrays and identifiers (as values)
-            const rightValue = this.parseArgument();
-            // Field to field comparison not implemented
-            if (left instanceof FieldSpecification && rightValue instanceof FieldSpecification) {
-                throw new Error('Field to field comparison not yet implemented in parser');
-            }
+            const rightValue = this.operatorRequiresValue(compOp)
+                ? this.parseArgument()
+                : this.defaultValueForOperator(compOp);
             if (left instanceof FieldSpecification) {
                 const field = left.getField();
-                const compOp = this.tokenTypeToComparisonOperator(operator);
+                if ((this.lastArgumentTokenType === TokenType.FIELD_REFERENCE ||
+                    this.lastArgumentTokenType === TokenType.IDENTIFIER) &&
+                    typeof rightValue === 'string') {
+                    return new FieldToFieldSpecification(field, compOp, rightValue);
+                }
                 return new FieldSpecification(field, compOp, rightValue);
             }
             throw new Error('Invalid comparison expression');
@@ -2197,7 +2529,7 @@ class DslParser {
             const fieldName = this.previous().value;
             return new FieldSpecification(fieldName, ComparisonOperator.EQUALS, true);
         }
-        if (this.match(TokenType.IDENTIFIER)) {
+        if (this.match(TokenType.IDENTIFIER, TokenType.MATCHES, TokenType.NOT_MATCHES)) {
             const identifier = this.previous().value;
             // Check if this is a function call
             if (this.match(TokenType.LEFT_PAREN)) {
@@ -2210,14 +2542,17 @@ class DslParser {
     }
     parseFunctionCall(functionName) {
         const args = [];
+        const argTokenTypes = [];
         if (!this.check(TokenType.RIGHT_PAREN)) {
             do {
                 args.push(this.parseArgument());
+                argTokenTypes.push(this.lastArgumentTokenType ?? TokenType.EOF);
             } while (this.match(TokenType.COMMA));
         }
         this.consume(TokenType.RIGHT_PAREN, "Expected ')' after function arguments");
         // Handle special built-in functions
-        switch (functionName) {
+        const normalizedFunctionName = this.normalizeFunctionName(functionName);
+        switch (normalizedFunctionName) {
             case 'atLeast':
                 if (args.length !== 2) {
                     throw new Error('atLeast requires exactly 2 arguments');
@@ -2241,38 +2576,61 @@ class DslParser {
             case 'contains':
             case 'startsWith':
             case 'endsWith':
+            case 'matches':
+            case 'notMatches':
                 if (args.length !== 2) {
-                    throw new Error(`${functionName} requires exactly 2 arguments`);
+                    throw new Error(`${normalizedFunctionName} requires exactly 2 arguments`);
                 }
                 const field = args[0];
                 const value = args[1];
-                const op = this.functionNameToOperator(functionName);
+                const op = this.functionNameToOperator(normalizedFunctionName);
                 return new FieldSpecification(field, op, value);
             default:
-                return new FunctionSpecification(functionName, args, this.functionRegistry);
+                // Custom functions keep identifier args as raw strings (legacy),
+                // but preserve explicit field references (${field}) as typed args.
+                const customArgs = args.map((arg, index) => {
+                    const tokenType = argTokenTypes[index];
+                    if (tokenType === TokenType.FIELD_REFERENCE && typeof arg === 'string') {
+                        return { type: 'field', field: arg };
+                    }
+                    return arg;
+                });
+                return new FunctionSpecification(normalizedFunctionName, customArgs, this.functionRegistry);
         }
     }
     parseArgument() {
+        this.lastArgumentTokenType = null;
         if (this.match(TokenType.STRING)) {
+            this.lastArgumentTokenType = TokenType.STRING;
             return this.previous().value;
         }
         if (this.match(TokenType.NUMBER)) {
             const value = this.previous().value;
+            this.lastArgumentTokenType = TokenType.NUMBER;
             return value.includes('.') ? parseFloat(value) : parseInt(value, 10);
         }
+        if (this.match(TokenType.REGEX)) {
+            this.lastArgumentTokenType = TokenType.REGEX;
+            return this.parseRegexLiteral(this.previous().value);
+        }
         if (this.match(TokenType.BOOLEAN)) {
+            this.lastArgumentTokenType = TokenType.BOOLEAN;
             return this.previous().value === 'true';
         }
         if (this.match(TokenType.NULL)) {
+            this.lastArgumentTokenType = TokenType.NULL;
             return null;
         }
         if (this.match(TokenType.FIELD_REFERENCE)) {
+            this.lastArgumentTokenType = TokenType.FIELD_REFERENCE;
             return this.previous().value;
         }
-        if (this.match(TokenType.IDENTIFIER)) {
+        if (this.match(TokenType.IDENTIFIER, TokenType.MATCHES, TokenType.NOT_MATCHES)) {
+            this.lastArgumentTokenType = this.previous().type;
             return this.previous().value;
         }
         if (this.match(TokenType.LEFT_BRACKET)) {
+            this.lastArgumentTokenType = TokenType.LEFT_BRACKET;
             const elements = [];
             if (!this.check(TokenType.RIGHT_BRACKET)) {
                 do {
@@ -2282,10 +2640,11 @@ class DslParser {
             this.consume(TokenType.RIGHT_BRACKET, "Expected ']' after array elements");
             return elements;
         }
+        this.lastArgumentTokenType = null;
         throw new Error(`Unexpected token in argument: ${this.peek().value}`);
     }
     matchComparison() {
-        return this.match(TokenType.EQUALS, TokenType.NOT_EQUALS, TokenType.LESS_THAN, TokenType.LESS_THAN_OR_EQUAL, TokenType.GREATER_THAN, TokenType.GREATER_THAN_OR_EQUAL, TokenType.IN);
+        return this.match(TokenType.EQUALS, TokenType.NOT_EQUALS, TokenType.LESS_THAN, TokenType.LESS_THAN_OR_EQUAL, TokenType.GREATER_THAN, TokenType.GREATER_THAN_OR_EQUAL, TokenType.IN, TokenType.NOT_IN, TokenType.MATCHES, TokenType.NOT_MATCHES, TokenType.IS_NULL, TokenType.IS_NOT_NULL, TokenType.IS_EMPTY, TokenType.IS_NOT_EMPTY);
     }
     tokenTypeToComparisonOperator(tokenType) {
         switch (tokenType) {
@@ -2303,22 +2662,50 @@ class DslParser {
                 return ComparisonOperator.GREATER_THAN_OR_EQUAL;
             case TokenType.IN:
                 return ComparisonOperator.IN;
+            case TokenType.NOT_IN:
+                return ComparisonOperator.NOT_IN;
+            case TokenType.MATCHES:
+                return ComparisonOperator.MATCHES;
+            case TokenType.NOT_MATCHES:
+                return ComparisonOperator.NOT_MATCHES;
+            case TokenType.IS_NULL:
+                return ComparisonOperator.IS_NULL;
+            case TokenType.IS_NOT_NULL:
+                return ComparisonOperator.IS_NOT_NULL;
+            case TokenType.IS_EMPTY:
+                return ComparisonOperator.IS_EMPTY;
+            case TokenType.IS_NOT_EMPTY:
+                return ComparisonOperator.IS_NOT_EMPTY;
             default:
                 throw new Error(`Unknown comparison operator: ${tokenType}`);
         }
     }
     functionNameToOperator(functionName) {
-        switch (functionName) {
+        const normalizedFunctionName = this.normalizeFunctionName(functionName);
+        switch (normalizedFunctionName) {
             case 'contains':
                 return ComparisonOperator.CONTAINS;
             case 'startsWith':
                 return ComparisonOperator.STARTS_WITH;
             case 'endsWith':
                 return ComparisonOperator.ENDS_WITH;
+            case 'matches':
+                return ComparisonOperator.MATCHES;
+            case 'notMatches':
+                return ComparisonOperator.NOT_MATCHES;
             default:
-                throw new Error(`Unknown function: ${functionName}`);
+                throw new Error(`Unknown function: ${normalizedFunctionName}`);
         }
     }
+    normalizeFunctionName(functionName) {
+        const raw = String(functionName || '').trim();
+        const compactLower = raw.replace(/\s+/g, '').toLowerCase();
+        if (compactLower === 'matches')
+            return 'matches';
+        if (compactLower === 'notmatches')
+            return 'notMatches';
+        return raw;
+    }
     extractValue(spec) {
         // This is a simplified extraction - in a real implementation
         // we'd need to handle more complex cases
@@ -2327,6 +2714,34 @@ class DslParser {
         }
         return spec;
     }
+    operatorRequiresValue(operator) {
+        switch (operator) {
+            case ComparisonOperator.IS_NULL:
+            case ComparisonOperator.IS_NOT_NULL:
+            case ComparisonOperator.IS_EMPTY:
+            case ComparisonOperator.IS_NOT_EMPTY:
+                return false;
+            default:
+                return true;
+        }
+    }
+    defaultValueForOperator(operator) {
+        switch (operator) {
+            case ComparisonOperator.IS_NULL:
+            case ComparisonOperator.IS_NOT_NULL:
+            case ComparisonOperator.IS_EMPTY:
+            case ComparisonOperator.IS_NOT_EMPTY:
+                return null;
+            default:
+                return undefined;
+        }
+    }
+    parseRegexLiteral(raw) {
+        const lastSlash = raw.lastIndexOf('/');
+        const pattern = raw.slice(1, lastSlash);
+        const flags = raw.slice(lastSlash + 1);
+        return new RegExp(pattern, flags);
+    }
     match(...types) {
         for (const type of types) {
             if (this.check(type)) {
@@ -2666,7 +3081,8 @@ class DslValidator {
         'contains', 'startsWith', 'endsWith', 'atLeast', 'exactly',
         'forEach', 'uniqueBy', 'minLength', 'maxLength',
         'requiredIf', 'visibleIf', 'disabledIf', 'readonlyIf',
-        'ifDefined', 'ifNotNull', 'ifExists', 'withDefault'
+        'ifDefined', 'ifNotNull', 'ifExists', 'withDefault',
+        'matches', 'notMatches'
     ];
     constructor(config = {}) {
         this.config = {
@@ -2799,7 +3215,9 @@ class DslValidator {
         }
     }
     validateTokens(tokens, input, issues) {
-        for (const token of tokens) {
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            const nextToken = tokens[i + 1];
             if (token.type === TokenType.EOF)
                 continue;
             // Validate numbers
@@ -2821,6 +3239,11 @@ class DslValidator {
             }
             // Validate field references
             if (token.type === TokenType.FIELD_REFERENCE || token.type === TokenType.IDENTIFIER) {
+                // Function names are identifiers too, but should be validated as functions
+                // (validateSemantics), not as field references.
+                const isFunctionIdentifier = this.isFunctionToken(token, nextToken);
+                if (isFunctionIdentifier)
+                    continue;
                 if (this.config.knownFields.length > 0) {
                     if (!this.config.knownFields.includes(token.value)) {
                         issues.push({
@@ -2848,6 +3271,14 @@ class DslValidator {
             const prevToken = tokens[i - 1];
             // Check for consecutive operators
             if (this.isOperatorToken(token) && this.isOperatorToken(nextToken)) {
+                // `matches(` and `notMatches(` can be tokenized as operator-like function names.
+                if (this.isFunctionToken(nextToken, tokens[i + 2])) {
+                    continue;
+                }
+                // Allow NOT after binary operators (e.g. AND NOT, OR NOT)
+                if (this.isBinaryOperatorToken(token) && nextToken.type === TokenType.NOT) {
+                    continue;
+                }
                 issues.push({
                     type: ValidationIssueType.UNEXPECTED_TOKEN,
                     severity: ValidationSeverity.ERROR,
@@ -2863,6 +3294,9 @@ class DslValidator {
             }
             // Check for operators at the beginning/end
             if (i === 0 && this.isBinaryOperatorToken(token)) {
+                if (this.isFunctionToken(token, nextToken)) {
+                    continue;
+                }
                 issues.push({
                     type: ValidationIssueType.UNEXPECTED_TOKEN,
                     severity: ValidationSeverity.ERROR,
@@ -2897,8 +3331,8 @@ class DslValidator {
         for (let i = 0; i < tokens.length; i++) {
             const token = tokens[i];
             const nextToken = tokens[i + 1];
-            if (token.type === TokenType.IDENTIFIER && nextToken?.type === TokenType.LEFT_PAREN) {
-                const functionName = token.value;
+            if (this.isFunctionToken(token, nextToken)) {
+                const functionName = this.normalizeFunctionTokenName(token);
                 // Check if function is known
                 const allKnownFunctions = [
                     ...this.BUILT_IN_FUNCTIONS,
@@ -3010,16 +3444,35 @@ class DslValidator {
             'ifDefined': 2,
             'ifNotNull': 2,
             'ifExists': 2,
-            'withDefault': 3
+            'withDefault': 3,
+            'matches': 2,
+            'notMatches': 2
         };
         return argCounts[functionName] ?? null;
     }
+    isFunctionToken(token, nextToken) {
+        if (!token || !nextToken)
+            return false;
+        if (nextToken.type !== TokenType.LEFT_PAREN)
+            return false;
+        return token.type === TokenType.IDENTIFIER
+            || token.type === TokenType.MATCHES
+            || token.type === TokenType.NOT_MATCHES;
+    }
+    normalizeFunctionTokenName(token) {
+        if (token.type === TokenType.MATCHES)
+            return 'matches';
+        if (token.type === TokenType.NOT_MATCHES)
+            return 'notMatches';
+        return token.value;
+    }
     isOperatorToken(token) {
         return [
             TokenType.AND, TokenType.OR, TokenType.NOT, TokenType.XOR, TokenType.IMPLIES,
             TokenType.EQUALS, TokenType.NOT_EQUALS, TokenType.LESS_THAN,
             TokenType.LESS_THAN_OR_EQUAL, TokenType.GREATER_THAN, TokenType.GREATER_THAN_OR_EQUAL,
-            TokenType.IN
+            TokenType.IN, TokenType.NOT_IN, TokenType.MATCHES, TokenType.NOT_MATCHES,
+            TokenType.IS_NULL, TokenType.IS_NOT_NULL, TokenType.IS_EMPTY, TokenType.IS_NOT_EMPTY
         ].includes(token.type);
     }
     isBinaryOperatorToken(token) {
@@ -3027,7 +3480,7 @@ class DslValidator {
             TokenType.AND, TokenType.OR, TokenType.XOR, TokenType.IMPLIES,
             TokenType.EQUALS, TokenType.NOT_EQUALS, TokenType.LESS_THAN,
             TokenType.LESS_THAN_OR_EQUAL, TokenType.GREATER_THAN, TokenType.GREATER_THAN_OR_EQUAL,
-            TokenType.IN
+            TokenType.IN, TokenType.NOT_IN, TokenType.MATCHES, TokenType.NOT_MATCHES
         ].includes(token.type);
     }
     suggestSimilarField(fieldName) {
@@ -3222,8 +3675,8 @@ class SpecificationFactory {
     static exactly(exact, specs) {
         return new ExactlySpecification(exact, specs);
     }
-    static fieldToField(fieldA, operator, fieldB, transformA, transformB, registry) {
-        return new FieldToFieldSpecification(fieldA, operator, fieldB, transformA, transformB, registry);
+    static fieldToField(fieldA, operator, fieldB, transformA, transformB, registry, metadata) {
+        return new FieldToFieldSpecification(fieldA, operator, fieldB, transformA, transformB, registry, metadata);
     }
     static contextual(template, provider) {
         return new ContextualSpecification(template, provider);