@lossless.org/client 0.1.0

package/dist_ts/nosqldb/classes.lucene.adapter.js

@@ -0,0 +1,623 @@
+/**
+ * Lucene to MongoDB query adapter for SmartData
+ */
+import * as plugins from './plugins.js';
+import { logger } from './logging.js';
+/**
+ * Lucene query parser
+ */
+export class LuceneParser {
+    pos = 0;
+    input = '';
+    tokens = [];
+    constructor() { }
+    /**
+     * Parse a Lucene query string into an AST
+     */
+    parse(query) {
+        this.input = query.trim();
+        this.pos = 0;
+        this.tokens = this.tokenize(this.input);
+        return this.parseQuery();
+    }
+    /**
+     * Tokenize the input string into tokens
+     */
+    tokenize(input) {
+        const specialChars = /[()\[\]{}"~^:]/;
+        const operators = /AND|OR|NOT|TO/;
+        let tokens = [];
+        let current = '';
+        let inQuote = false;
+        for (let i = 0; i < input.length; i++) {
+            const char = input[i];
+            // Handle quoted strings
+            if (char === '"') {
+                if (inQuote) {
+                    tokens.push(current + char);
+                    current = '';
+                    inQuote = false;
+                }
+                else {
+                    if (current)
+                        tokens.push(current);
+                    current = char;
+                    inQuote = true;
+                }
+                continue;
+            }
+            if (inQuote) {
+                current += char;
+                continue;
+            }
+            // Handle whitespace
+            if (char === ' ' || char === '\t' || char === '\n') {
+                if (current) {
+                    tokens.push(current);
+                    current = '';
+                }
+                continue;
+            }
+            // Handle special characters
+            if (specialChars.test(char)) {
+                if (current) {
+                    tokens.push(current);
+                    current = '';
+                }
+                tokens.push(char);
+                continue;
+            }
+            current += char;
+            // Check if current is an operator
+            if (operators.test(current) && (i + 1 === input.length || /\s/.test(input[i + 1]))) {
+                tokens.push(current);
+                current = '';
+            }
+        }
+        if (current)
+            tokens.push(current);
+        return tokens;
+    }
+    /**
+     * Parse the main query expression
+     */
+    parseQuery() {
+        const left = this.parseBooleanOperand();
+        if (this.pos < this.tokens.length) {
+            const token = this.tokens[this.pos];
+            if (token === 'AND' || token === 'OR') {
+                this.pos++;
+                const right = this.parseQuery();
+                return {
+                    type: token,
+                    left,
+                    right,
+                };
+            }
+            else if (token === 'NOT' || token === '-') {
+                this.pos++;
+                const right = this.parseQuery();
+                return {
+                    type: 'NOT',
+                    left,
+                    right,
+                };
+            }
+        }
+        return left;
+    }
+    /**
+     * Parse boolean operands (terms, phrases, fields, groups)
+     */
+    parseBooleanOperand() {
+        if (this.pos >= this.tokens.length) {
+            throw new Error('Unexpected end of input');
+        }
+        const token = this.tokens[this.pos];
+        // Handle grouping with parentheses
+        if (token === '(') {
+            this.pos++;
+            const group = this.parseQuery();
+            if (this.pos < this.tokens.length && this.tokens[this.pos] === ')') {
+                this.pos++;
+                return { type: 'GROUP', value: group };
+            }
+            else {
+                throw new Error('Unclosed group');
+            }
+        }
+        // Handle fields (field:value)
+        if (this.pos + 1 < this.tokens.length && this.tokens[this.pos + 1] === ':') {
+            const field = token;
+            this.pos += 2; // Skip field and colon
+            if (this.pos < this.tokens.length) {
+                const value = this.parseBooleanOperand();
+                return { type: 'FIELD', field, value };
+            }
+            else {
+                throw new Error('Expected value after field');
+            }
+        }
+        // Handle range queries
+        if (token === '[' || token === '{') {
+            return this.parseRange();
+        }
+        // Handle phrases ("term term")
+        if (token.startsWith('"') && token.endsWith('"')) {
+            const phrase = token.slice(1, -1);
+            this.pos++;
+            // Check for proximity operator
+            let proximity;
+            if (this.pos < this.tokens.length && this.tokens[this.pos] === '~') {
+                this.pos++;
+                if (this.pos < this.tokens.length && /^\d+$/.test(this.tokens[this.pos])) {
+                    proximity = parseInt(this.tokens[this.pos], 10);
+                    this.pos++;
+                }
+                else {
+                    throw new Error('Expected number after proximity operator');
+                }
+            }
+            return { type: 'PHRASE', value: phrase, proximity };
+        }
+        // Handle wildcards
+        if (token.includes('*') || token.includes('?')) {
+            this.pos++;
+            return { type: 'WILDCARD', value: token };
+        }
+        // Handle fuzzy searches
+        if (this.pos + 1 < this.tokens.length && this.tokens[this.pos + 1] === '~') {
+            const term = token;
+            this.pos += 2; // Skip term and tilde
+            let maxEdits = 2; // Default
+            if (this.pos < this.tokens.length && /^\d+$/.test(this.tokens[this.pos])) {
+                maxEdits = parseInt(this.tokens[this.pos], 10);
+                this.pos++;
+            }
+            return { type: 'FUZZY', value: term, maxEdits };
+        }
+        // Simple term
+        this.pos++;
+        return { type: 'TERM', value: token };
+    }
+    /**
+     * Parse range queries
+     */
+    parseRange() {
+        const includeLower = this.tokens[this.pos] === '[';
+        const includeUpper = this.tokens[this.pos + 4] === ']';
+        // Ensure tokens for lower, TO, upper, and closing bracket exist
+        if (this.pos + 4 >= this.tokens.length) {
+            throw new Error('Invalid range query syntax');
+        }
+        this.pos++; // Skip open bracket
+        const lower = this.tokens[this.pos];
+        this.pos++;
+        if (this.tokens[this.pos] !== 'TO') {
+            throw new Error('Expected TO in range query');
+        }
+        this.pos++;
+        const upper = this.tokens[this.pos];
+        this.pos++;
+        if (this.tokens[this.pos] !== (includeLower ? ']' : '}')) {
+            throw new Error('Invalid range query closing bracket');
+        }
+        this.pos++;
+        // For simplicity, assuming the field is handled separately
+        return {
+            type: 'RANGE',
+            field: '', // This will be filled by the field node
+            lower,
+            upper,
+            includeLower,
+            includeUpper,
+        };
+    }
+}
+/**
+ * Transformer for Lucene AST to MongoDB query
+ * FIXED VERSION - proper MongoDB query structure
+ */
+export class LuceneToMongoTransformer {
+    defaultFields;
+    constructor(defaultFields = []) {
+        this.defaultFields = defaultFields;
+    }
+    /**
+     * Escape special characters for use in RegExp patterns
+     */
+    escapeRegex(input) {
+        return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Transform a Lucene AST node to a MongoDB query
+     */
+    transform(node, searchFields) {
+        switch (node.type) {
+            case 'TERM':
+                return this.transformTerm(node, searchFields);
+            case 'PHRASE':
+                return this.transformPhrase(node, searchFields);
+            case 'FIELD':
+                return this.transformField(node);
+            case 'AND':
+                return this.transformAnd(node);
+            case 'OR':
+                return this.transformOr(node);
+            case 'NOT':
+                return this.transformNot(node);
+            case 'RANGE':
+                return this.transformRange(node);
+            case 'WILDCARD':
+                return this.transformWildcard(node, searchFields);
+            case 'FUZZY':
+                return this.transformFuzzy(node, searchFields);
+            case 'GROUP':
+                return this.transform(node.value, searchFields);
+            default:
+                throw new Error(`Unsupported node type: ${node.type}`);
+        }
+    }
+    /**
+     * Transform a term to MongoDB query
+     * FIXED: properly structured $or query for multiple fields
+     */
+    transformTerm(node, searchFields) {
+        // Build regex pattern, support wildcard (*) and fuzzy (?) if present
+        const term = node.value;
+        // Determine regex pattern: wildcard conversion or exact escape
+        let pattern;
+        if (term.includes('*') || term.includes('?')) {
+            pattern = this.luceneWildcardToRegex(term);
+        }
+        else {
+            pattern = this.escapeRegex(term);
+        }
+        // Search across provided fields or default fields
+        const fields = searchFields && searchFields.length > 0 ? searchFields : this.defaultFields;
+        const orConditions = fields.map((field) => ({
+            [field]: { $regex: pattern, $options: 'i' },
+        }));
+        return { $or: orConditions };
+    }
+    /**
+     * Transform a phrase to MongoDB query
+     * FIXED: properly structured $or query for multiple fields
+     */
+    transformPhrase(node, searchFields) {
+        // Use regex across provided fields or default fields, respecting word boundaries
+        const parts = node.value.split(/\s+/).map((t) => this.escapeRegex(t));
+        const pattern = parts.join('\\s+');
+        const fields = searchFields && searchFields.length > 0 ? searchFields : this.defaultFields;
+        const orConditions = fields.map((field) => ({
+            [field]: { $regex: pattern, $options: 'i' },
+        }));
+        return { $or: orConditions };
+    }
+    /**
+     * Transform a field query to MongoDB query
+     */
+    transformField(node) {
+        // Handle special case for range queries on fields
+        if (node.value.type === 'RANGE') {
+            const rangeNode = node.value;
+            rangeNode.field = node.field;
+            return this.transformRange(rangeNode);
+        }
+        // Handle special case for wildcards on fields
+        if (node.value.type === 'WILDCARD') {
+            return {
+                [node.field]: {
+                    $regex: this.luceneWildcardToRegex(node.value.value),
+                    $options: 'i',
+                },
+            };
+        }
+        // Handle special case for fuzzy searches on fields
+        if (node.value.type === 'FUZZY') {
+            return {
+                [node.field]: {
+                    $regex: this.createFuzzyRegex(node.value.value),
+                    $options: 'i',
+                },
+            };
+        }
+        // Special case for exact term matches on fields (supporting wildcard characters)
+        if (node.value.type === 'TERM') {
+            const val = node.value.value;
+            if (val.includes('*') || val.includes('?')) {
+                const regex = this.luceneWildcardToRegex(val);
+                return { [node.field]: { $regex: regex, $options: 'i' } };
+            }
+            return { [node.field]: { $regex: val, $options: 'i' } };
+        }
+        // Special case for phrase matches on fields
+        if (node.value.type === 'PHRASE') {
+            return {
+                [node.field]: {
+                    $regex: `${node.value.value.replace(/\s+/g, '\\s+')}`,
+                    $options: 'i',
+                },
+            };
+        }
+        // For other cases, we'll transform the value and apply it to the field
+        const transformedValue = this.transform(node.value);
+        // If the transformed value uses $text, we need to adapt it for the field
+        if (transformedValue.$text) {
+            return { [node.field]: { $regex: transformedValue.$text.$search, $options: 'i' } };
+        }
+        // Handle $or and $and cases
+        if (transformedValue.$or || transformedValue.$and) {
+            // This is a bit complex - we need to restructure the query to apply the field
+            // For now, simplify by just using a regex on the field
+            const term = this.extractTermFromBooleanQuery(transformedValue);
+            if (term) {
+                return { [node.field]: { $regex: term, $options: 'i' } };
+            }
+        }
+        return { [node.field]: transformedValue };
+    }
+    /**
+     * Extract a term from a boolean query (simplification)
+     */
+    extractTermFromBooleanQuery(query) {
+        if (query.$or && Array.isArray(query.$or) && query.$or.length > 0) {
+            const firstClause = query.$or[0];
+            for (const field in firstClause) {
+                if (firstClause[field].$regex) {
+                    return firstClause[field].$regex;
+                }
+            }
+        }
+        if (query.$and && Array.isArray(query.$and) && query.$and.length > 0) {
+            const firstClause = query.$and[0];
+            for (const field in firstClause) {
+                if (firstClause[field].$regex) {
+                    return firstClause[field].$regex;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Transform AND operator to MongoDB query
+     * FIXED: $and must be an array
+     */
+    transformAnd(node) {
+        return { $and: [this.transform(node.left), this.transform(node.right)] };
+    }
+    /**
+     * Transform OR operator to MongoDB query
+     * FIXED: $or must be an array
+     */
+    transformOr(node) {
+        return { $or: [this.transform(node.left), this.transform(node.right)] };
+    }
+    /**
+     * Transform NOT operator to MongoDB query
+     * FIXED: $and must be an array and $not usage
+     */
+    transformNot(node) {
+        const leftQuery = this.transform(node.left);
+        const rightQuery = this.transform(node.right);
+        // Create a query that includes left but excludes right
+        if (rightQuery.$text) {
+            // For text searches, we need a different approach
+            // We'll use a negated regex instead
+            const searchTerm = rightQuery.$text.$search.replace(/"/g, '');
+            // Determine the fields to apply the negation to
+            const notConditions = [];
+            for (const field in leftQuery) {
+                if (field !== '$or' && field !== '$and') {
+                    notConditions.push({
+                        [field]: { $not: { $regex: searchTerm, $options: 'i' } },
+                    });
+                }
+            }
+            // If left query has $or or $and, we need to handle it differently
+            if (leftQuery.$or) {
+                return {
+                    $and: [leftQuery, { $nor: [{ $or: notConditions }] }],
+                };
+            }
+            else {
+                // Simple case - just add $not to each field
+                return {
+                    $and: [leftQuery, { $and: notConditions }],
+                };
+            }
+        }
+        else {
+            // For other queries, we can use $not directly
+            // We need to handle different structures based on the rightQuery
+            let notQuery = {};
+            if (rightQuery.$or) {
+                notQuery = { $nor: rightQuery.$or };
+            }
+            else if (rightQuery.$and) {
+                // Convert $and to $nor
+                notQuery = { $nor: rightQuery.$and };
+            }
+            else {
+                // Simple field condition
+                for (const field in rightQuery) {
+                    notQuery[field] = { $not: rightQuery[field] };
+                }
+            }
+            return { $and: [leftQuery, notQuery] };
+        }
+    }
+    /**
+     * Transform range query to MongoDB query
+     */
+    transformRange(node) {
+        const range = {};
+        if (node.lower !== '*') {
+            range[node.includeLower ? '$gte' : '$gt'] = this.parseValue(node.lower);
+        }
+        if (node.upper !== '*') {
+            range[node.includeUpper ? '$lte' : '$lt'] = this.parseValue(node.upper);
+        }
+        return { [node.field]: range };
+    }
+    /**
+     * Transform wildcard query to MongoDB query
+     * FIXED: properly structured for multiple fields
+     */
+    transformWildcard(node, searchFields) {
+        // Convert Lucene wildcards to MongoDB regex
+        const regex = this.luceneWildcardToRegex(node.value);
+        // If specific fields are provided, search wildcard across those fields
+        if (searchFields && searchFields.length > 0) {
+            const orConditions = searchFields.map((field) => ({
+                [field]: { $regex: regex, $options: 'i' },
+            }));
+            return { $or: orConditions };
+        }
+        // By default, apply to the default field
+        return { $regex: regex, $options: 'i' };
+    }
+    /**
+     * Transform fuzzy query to MongoDB query
+     * FIXED: properly structured for multiple fields
+     */
+    transformFuzzy(node, searchFields) {
+        // MongoDB doesn't have built-in fuzzy search
+        // This is a very basic approach using regex
+        const regex = this.createFuzzyRegex(node.value);
+        // If specific fields are provided, search fuzzy term across those fields
+        if (searchFields && searchFields.length > 0) {
+            const orConditions = searchFields.map((field) => ({
+                [field]: { $regex: regex, $options: 'i' },
+            }));
+            return { $or: orConditions };
+        }
+        // By default, apply to the default field
+        return { $regex: regex, $options: 'i' };
+    }
+    /**
+     * Convert Lucene wildcards to MongoDB regex patterns
+     */
+    luceneWildcardToRegex(wildcardPattern) {
+        // Replace Lucene wildcards with regex equivalents
+        // * => .*
+        // ? => .
+        // Also escape regex special chars
+        return wildcardPattern
+            .replace(/([.+^${}()|\\])/g, '\\$1') // Escape regex special chars
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+    }
+    /**
+     * Create a simplified fuzzy search regex
+     */
+    createFuzzyRegex(term) {
+        // For a very simple approach, we allow some characters to be optional
+        let regex = '';
+        for (let i = 0; i < term.length; i++) {
+            // Make every other character optional (simplified fuzzy)
+            if (i % 2 === 1) {
+                regex += term[i] + '?';
+            }
+            else {
+                regex += term[i];
+            }
+        }
+        return regex;
+    }
+    /**
+     * Parse string values to appropriate types (numbers, dates, etc.)
+     */
+    parseValue(value) {
+        // Try to parse as number
+        if (/^-?\d+$/.test(value)) {
+            return parseInt(value, 10);
+        }
+        if (/^-?\d+\.\d+$/.test(value)) {
+            return parseFloat(value);
+        }
+        // Try to parse as date (simplified)
+        const date = new Date(value);
+        if (!isNaN(date.getTime())) {
+            return date;
+        }
+        // Default to string
+        return value;
+    }
+}
+/**
+ * Main adapter class
+ */
+export class SmartdataLuceneAdapter {
+    parser;
+    transformer;
+    defaultSearchFields = [];
+    /**
+     * @param defaultSearchFields - Optional array of field names to search across when no field is specified
+     */
+    constructor(defaultSearchFields) {
+        this.parser = new LuceneParser();
+        // Pass default searchable fields into transformer
+        this.transformer = new LuceneToMongoTransformer(defaultSearchFields || []);
+        if (defaultSearchFields) {
+            this.defaultSearchFields = defaultSearchFields;
+        }
+    }
+    /**
+     * Convert a Lucene query string to a MongoDB query object
+     * @param luceneQuery - The Lucene query string to convert
+     * @param searchFields - Optional array of field names to search across (overrides defaultSearchFields)
+     */
+    convert(luceneQuery, searchFields) {
+        try {
+            // For simple single-term queries (no field:, boolean, grouping), use simpler regex
+            if (!luceneQuery.includes(':') &&
+                !luceneQuery.includes(' AND ') &&
+                !luceneQuery.includes(' OR ') &&
+                !luceneQuery.includes(' NOT ') &&
+                !luceneQuery.includes('(') &&
+                !luceneQuery.includes('[')) {
+                const fieldsToSearch = searchFields || this.defaultSearchFields;
+                if (fieldsToSearch && fieldsToSearch.length > 0) {
+                    // Handle wildcard characters in query
+                    let pattern = luceneQuery;
+                    if (luceneQuery.includes('*') || luceneQuery.includes('?')) {
+                        // Use transformer to convert wildcard pattern
+                        pattern = this.transformer.luceneWildcardToRegex(luceneQuery);
+                    }
+                    return {
+                        $or: fieldsToSearch.map((field) => ({
+                            [field]: { $regex: pattern, $options: 'i' },
+                        })),
+                    };
+                }
+            }
+            // For more complex queries, use the full parser
+            // Parse the Lucene query into an AST
+            const ast = this.parser.parse(luceneQuery);
+            // Use provided searchFields, fall back to defaultSearchFields
+            const fieldsToSearch = searchFields || this.defaultSearchFields;
+            // Transform the AST to a MongoDB query
+            return this.transformWithFields(ast, fieldsToSearch);
+        }
+        catch (error) {
+            logger.log('error', `Failed to convert Lucene query "${luceneQuery}":`, error);
+            throw new Error(`Failed to convert Lucene query: ${error}`);
+        }
+    }
+    /**
+     * Helper method to transform the AST with field information
+     */
+    transformWithFields(node, searchFields) {
+        // Special case for term nodes without a specific field
+        if (node.type === 'TERM' ||
+            node.type === 'PHRASE' ||
+            node.type === 'WILDCARD' ||
+            node.type === 'FUZZY') {
+            return this.transformer.transform(node, searchFields);
+        }
+        // For other node types, use the standard transformation
+        return this.transformer.transform(node);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.lucene.adapter.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.lucene.adapter.ts"],"names":[],"mappings":"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"}