@ja-platform/db 0.0.0-dev-20261113193343 → 0.0.0-stage

package/dist/query/queryOperations.js

@@ -1,678 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = exports.Tokenizer = exports.TrueExpression = exports.OrExpression = exports.AndExpression = exports.RelationMatch = exports.Operation = void 0;
-exports.expressionFromHash = expressionFromHash;
-exports.parse = parse;
-const TypeOperations_1 = require("../types/TypeOperations");
-// # Query
-// This module handles the parsing and representation of query expressions.
-// It contains the logic to filter a single object based on an expression.
-// It is up to the database adapters to perform optimised queries based on an index.
-const parser_schema_1 = require("@ja-platform/parser-schema");
-const parser_type_system_1 = require("@ja-platform/parser-type-system");
-// Build an expression from a hash such as {make: 'Nokia', model: '5800'}
-function expressionFromHash(scopeType, hash) {
-    let operations = [];
-    for (let key in hash) {
-        if (hash.hasOwnProperty(key)) {
-            let value = hash[key];
-            const attribute = scopeType.getAttribute(key);
-            if (attribute == null) {
-                throw new Error(`'${key}' is not defined on '${scopeType.name}'`);
-            }
-            if (parser_schema_1.SchemaModelType.isInstanceOf(attribute.type) && value != null) {
-                value = value.id;
-            }
-            const operation = new Operation(attribute, '=', value);
-            operations.push(operation);
-        }
-    }
-    return new AndExpression(operations);
-}
-// ## Operation
-// An operation has an attribute (variable), operator and (constant) value to compare with.
-function discardMillis(ms) {
-    return Math.floor(ms / 1000) * 1000;
-}
-class Operation {
-    constructor(attribute, operator, value) {
-        this.attribute = attribute;
-        this.operator = operator;
-        this.value = value;
-    }
-    normalize() {
-        if (this.operator == 'in') {
-            // Allows using this in indexes
-            return new OrExpression(this.value.map((v) => new AndExpression([new Operation(this.attribute, '=', v)])));
-        }
-        return new OrExpression([new AndExpression([this])]);
-    }
-    attributes() {
-        return [this.attribute];
-    }
-    evaluate(object) {
-        let attributeValue;
-        if (this.attribute.relationship) {
-            attributeValue = object.belongs_to[this.attribute.relationship];
-            if (typeof this.value == 'undefined') {
-                // Most likely an incorrect parameter was passed to the query.
-                // We don't want to interpret this the same as null.
-                return false;
-            }
-        }
-        else if (this.attribute.name == 'id') {
-            attributeValue = object.id;
-        }
-        else {
-            const rawAttributeValue = object.attributes[this.attribute.name];
-            if (rawAttributeValue == null) {
-                attributeValue = null;
-            }
-            else {
-                attributeValue = (0, TypeOperations_1.operationsFor)(this.attribute.type).valueFromJSON(rawAttributeValue);
-            }
-        }
-        const compareDiff = compare(attributeValue, this.value);
-        if (this.operator == '=') {
-            if (compareDiff !== null) {
-                return compareDiff === 0;
-            }
-            if (Array.isArray(attributeValue) && !Array.isArray(this.value)) {
-                return false;
-            }
-            return attributeValue == this.value;
-        }
-        else if (this.operator == '!=') {
-            if (compareDiff !== null) {
-                return compareDiff !== 0;
-            }
-            if (Array.isArray(attributeValue) && !Array.isArray(this.value)) {
-                return true;
-            }
-            return attributeValue != this.value;
-        }
-        else if (this.operator == '>') {
-            if (compareDiff === null) {
-                return false;
-            }
-            return compareDiff > 0;
-        }
-        else if (this.operator == '<') {
-            if (compareDiff === null) {
-                return false;
-            }
-            return compareDiff < 0;
-        }
-        else if (this.operator == '>=') {
-            if (compareDiff === null) {
-                return false;
-            }
-            return compareDiff >= 0;
-        }
-        else if (this.operator == '<=') {
-            if (compareDiff === null) {
-                return false;
-            }
-            return compareDiff <= 0;
-        }
-        else if (this.operator == 'contains') {
-            if (typeof attributeValue == 'string' && typeof this.value == 'string') {
-                return attributeValue.toLowerCase().indexOf(this.value.toLowerCase()) >= 0;
-            }
-            else if (Array.isArray(attributeValue) && Array.isArray(this.value)) {
-                for (let child of this.value) {
-                    if (attributeValue.indexOf(child) < 0) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            else if (Array.isArray(attributeValue)) {
-                return attributeValue.indexOf(this.value) >= 0;
-            }
-            else {
-                return false;
-            }
-        }
-        else if (this.operator == 'starts with') {
-            if (typeof attributeValue == 'string' && typeof this.value == 'string') {
-                return attributeValue.toLowerCase().indexOf(this.value.toLowerCase()) === 0;
-            }
-            else {
-                return false;
-            }
-        }
-        else if (this.operator == 'in') {
-            if (Array.isArray(this.value)) {
-                if (Array.isArray(attributeValue)) {
-                    return (this.value.findIndex((value) => {
-                        return attributeValue.indexOf(value) >= 0;
-                    }) >= 0);
-                }
-                else {
-                    return (this.value.findIndex((value) => {
-                        const compared = compare(attributeValue, value);
-                        return compared == 0 || (compared == null && value == attributeValue);
-                    }) >= 0);
-                }
-            }
-            else {
-                throw new Error("Array value is required for 'in' operator");
-            }
-        }
-        else if (this.operator == 'not in') {
-            if (Array.isArray(this.value)) {
-                if (Array.isArray(attributeValue)) {
-                    return (this.value.findIndex((value) => {
-                        return attributeValue.indexOf(value) >= 0;
-                    }) == -1);
-                }
-                else {
-                    return (this.value.findIndex((value) => {
-                        const compared = compare(attributeValue, value);
-                        return compared == 0 || (compared == null && value == attributeValue);
-                    }) == -1);
-                }
-            }
-            else {
-                throw new Error("Array value is required for 'not in' operator");
-            }
-        }
-        else {
-            throw Error('Operator ' + this.operator + ' is not implemented yet');
-        }
-    }
-    toString() {
-        return this.attribute.name + ' ' + this.operator + ' ' + this.value;
-    }
-    toOriginalExpression() {
-        if (this.attribute.relationship) {
-            // Works for both relationships (user = ?) and relationship ids (user_id = ?)
-            return [this.attribute.relationship + '_id ' + this.operator + ' ?', this.value];
-        }
-        else {
-            return [this.attribute.name + ' ' + this.operator + ' ?', this.value];
-        }
-    }
-}
-exports.Operation = Operation;
-function compare(a, b) {
-    let compareDiff = null;
-    if (typeof a == 'number' && typeof b == 'number') {
-        compareDiff = a - b;
-    }
-    else if (typeof a == 'string' && typeof b == 'string') {
-        if (a < b) {
-            compareDiff = -1;
-        }
-        else if (a > b) {
-            compareDiff = 1;
-        }
-        else {
-            compareDiff = 0;
-        }
-    }
-    else if (a instanceof Date && b instanceof Date) {
-        // Compare seconds only
-        compareDiff = discardMillis(a.getTime()) - discardMillis(b.getTime());
-    }
-    else if (parser_schema_1.Day.isDay(a) || parser_schema_1.Day.isDay(b)) {
-        // New syntax only
-        try {
-            // Convert both to Days, in the local timezone.
-            // Also works for JSON strings.
-            compareDiff = new parser_schema_1.Day(a).valueOf() - new parser_schema_1.Day(b).valueOf();
-        }
-        catch (err) {
-            compareDiff = null;
-        }
-    }
-    else if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length != b.length) {
-            return null;
-        }
-        for (let i = 0; i < a.length && i < b.length; i++) {
-            const child = compare(a[i], b[i]);
-            if (child != 0) {
-                return null;
-            }
-        }
-        return 0;
-    }
-    return compareDiff;
-}
-// ## RelationMatch
-// A RelationMatch searches for a relationship match
-class RelationMatch {
-    constructor(name, id) {
-        this.name = name;
-        this.id = id;
-    }
-    normalize() {
-        return new OrExpression([new AndExpression([this])]);
-    }
-    evaluate(object) {
-        const relatedId = object.belongs_to[this.name];
-        return relatedId == this.id;
-    }
-    toString() {
-        return this.name + ' = ' + this.id;
-    }
-    toOriginalExpression() {
-        return [this.name + '_id = ?', this.id];
-    }
-}
-exports.RelationMatch = RelationMatch;
-// ## AndExpression
-// Takes any number of expressions, and combine them with an "and".
-class AndExpression {
-    constructor(operands) {
-        this.operands = operands;
-    }
-    join(otherAnd) {
-        const ops = this.operands.concat(otherAnd.operands);
-        return new AndExpression(ops);
-    }
-    normalize() {
-        let i;
-        // Step 1: filter out TrueExpression
-        let operands = [];
-        for (i = 0; i < this.operands.length; i++) {
-            const op = this.operands[i];
-            if (!(op instanceof TrueExpression)) {
-                operands.push(op);
-            }
-        }
-        if (operands.length === 0) {
-            return new TrueExpression().normalize();
-        }
-        else if (operands.length == 1) {
-            return operands[0].normalize();
-        }
-        else if (operands.length > 2) {
-            const a = new AndExpression(operands.slice(0, 2));
-            const b = new AndExpression(operands.slice(2));
-            return new AndExpression([a, b]).normalize();
-        }
-        else {
-            const left = operands[0].normalize().operands;
-            const right = operands[1].normalize().operands;
-            let newOperands = [];
-            for (i = 0; i < left.length; i++) {
-                for (let j = 0; j < right.length; j++) {
-                    newOperands.push(left[i].join(right[j]));
-                }
-            }
-            return new OrExpression(newOperands);
-        }
-    }
-    evaluate(object) {
-        for (let i = 0; i < this.operands.length; i++) {
-            const operand = this.operands[i];
-            if (!operand.evaluate(object)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    toString() {
-        let s = '(';
-        for (let i = 0; i < this.operands.length; i++) {
-            const operand = this.operands[i];
-            s += operand.toString();
-            if (i != this.operands.length - 1) {
-                s += ' and ';
-            }
-        }
-        s += ')';
-        return s;
-    }
-    toOriginalExpression() {
-        let args = [];
-        let s = '(';
-        for (let i = 0; i < this.operands.length; i++) {
-            const operand = this.operands[i];
-            if (operand instanceof TrueExpression)
-                continue;
-            let opPair = operand.toOriginalExpression();
-            if (opPair[0] == '') {
-                // nested TrueExpression
-                continue;
-            }
-            if (s.length > 1) {
-                // Not the first operand
-                s += ' and ';
-            }
-            s += opPair[0];
-            args.push.apply(args, opPair.slice(1));
-        }
-        s += ')';
-        if (s.length == 2) {
-            return new TrueExpression().toOriginalExpression();
-        }
-        return [s, ...args];
-    }
-}
-exports.AndExpression = AndExpression;
-// ## OrExpression
-// Takes any number of expressions, and combine them with an "or".
-class OrExpression {
-    constructor(operands) {
-        this.operands = operands;
-    }
-    normalize() {
-        const newOperands = [];
-        this.operands.forEach(function (op) {
-            const norm = op.normalize();
-            norm.operands.forEach(function (subop) {
-                newOperands.push(subop);
-            });
-        });
-        return new OrExpression(newOperands);
-    }
-    evaluate(object) {
-        for (let i = 0; i < this.operands.length; i++) {
-            const operand = this.operands[i];
-            if (operand.evaluate(object)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    toString() {
-        let s = '(';
-        for (let i = 0; i < this.operands.length; i++) {
-            const operand = this.operands[i];
-            s += operand.toString();
-            if (i != this.operands.length - 1) {
-                s += ' or ';
-            }
-        }
-        s += ')';
-        return s;
-    }
-    toOriginalExpression() {
-        let args = [];
-        let s = '(';
-        for (let i = 0; i < this.operands.length; i++) {
-            const operand = this.operands[i];
-            if (operand instanceof TrueExpression) {
-                // One TrueExpression makes the entire OR clause true
-                return operand.toOriginalExpression();
-            }
-            const opPair = operand.toOriginalExpression();
-            s += opPair[0];
-            args.push.apply(args, opPair.slice(1));
-            if (i != this.operands.length - 1) {
-                s += ' or ';
-            }
-        }
-        s += ')';
-        return [s, ...args];
-    }
-}
-exports.OrExpression = OrExpression;
-// ## TrueExpression
-// Simple expression that is always true.
-class TrueExpression {
-    constructor() { }
-    normalize() {
-        return new OrExpression([new AndExpression([this])]);
-    }
-    evaluate(object) {
-        return true;
-    }
-    toString() {
-        return 'true';
-    }
-    toOriginalExpression() {
-        return [''];
-    }
-}
-exports.TrueExpression = TrueExpression;
-// We should probably support international characters as well
-function isLetter(character) {
-    return (character >= 'a' && character <= 'z') || (character >= 'A' && character <= 'Z');
-}
-function isDigit(character) {
-    return character >= '0' && character <= '9';
-}
-const OPERATORS = ['>=', '<=', '=', '!=', '>', '<', 'starts with', 'contains', 'in', 'not in'];
-const BOOLEAN_LOGIC = ['and', 'or'];
-// ## Tokenizer
-// The Tokenizer is responsible for interpreting the raw characters, and splitting the expression into
-// tokens.
-class Tokenizer {
-    constructor(expression) {
-        this.expression = expression;
-        this.i = 0;
-        this.interpolatorCount = 0;
-        if (expression == null) {
-            throw new Error('expression is required');
-        }
-        this.advance();
-    }
-    exception(message, start, end) {
-        let error = new Error(message + '\n' + this.expression + '\n' + new Array(this.i + 1).join(' ') + '^');
-        if (start == null) {
-            start = this.i;
-        }
-        error.position = start;
-        error.positionEnd = end == null ? start + 1 : end;
-        error.plainMessage = message;
-        return error;
-    }
-    isWordSeparator(p) {
-        return p >= this.expression.length || this.expression[p] == ' ';
-    }
-    isWord() {
-        this.checkBuffer();
-        return isLetter(this.expression[this.i]) || this.expression[this.i] == '_';
-    }
-    hasMore() {
-        return this.i < this.expression.length;
-    }
-    // Read an operator, for example "!=" or "starts with".
-    readOperator() {
-        return this.readToken(OPERATORS);
-    }
-    // Read an "and" or "or".
-    readBooleanLogic() {
-        return this.readToken(BOOLEAN_LOGIC);
-    }
-    // Is the current token an "or"?
-    isOr() {
-        return this.isToken(['or']);
-    }
-    // Is the current token an "and"?
-    isAnd() {
-        return this.isToken(['and']);
-    }
-    // Are we at a closing or opening parenthesis?
-    isParenthesis() {
-        this.checkBuffer();
-        return this.expression[this.i] == '(' || this.expression[this.i] == ')';
-    }
-    // Read a single parenthesis. Throws an exception if we are not at one.
-    readParenthesis() {
-        if (!this.isParenthesis()) {
-            throw this.exception('Expected ( or )');
-        }
-        const c = this.expression[this.i];
-        this.i++;
-        this.advance();
-        return c;
-    }
-    // Read an interpolation character "?"
-    readInterpolator() {
-        this.checkBuffer();
-        if (this.expression[this.i] == '?' && (this.isWordSeparator(this.i + 1) || this.expression[this.i + 1] == ')')) {
-            this.i += 1;
-            this.advance();
-            return this.interpolatorCount++;
-        }
-        else {
-            throw this.exception('Expected ?');
-        }
-    }
-    // Read a single alphanumeric word. May contain underscores.
-    readWord() {
-        this.checkBuffer();
-        let word = '';
-        word += this.expression[this.i];
-        let offset = 1;
-        while (this.expression.length > this.i + offset &&
-            (isLetter(this.expression[this.i + offset]) ||
-                isDigit(this.expression[this.i + offset]) ||
-                this.expression[this.i + offset] == '_')) {
-            word += this.expression[this.i + offset++];
-        }
-        this.i += offset;
-        this.advance();
-        return word;
-    }
-    // Advance to the next non-whitespace character.
-    advance() {
-        this.previousPosition = this.i - 1;
-        while (this.hasMore() && this.expression[this.i] == ' ') {
-            this.i++;
-        }
-    }
-    checkBuffer() {
-        if (!this.hasMore()) {
-            throw this.exception('Unexpected end of expression');
-        }
-    }
-    // Given an array of tokens, read and return one of them at the current position.
-    // Throws an exception if none of them are found.
-    // Use isToken() first to check if one of the tokens is present.
-    readToken(tokens) {
-        this.checkBuffer();
-        for (let j = 0; j < tokens.length; j++) {
-            const token = tokens[j];
-            if (this.i + token.length <= this.expression.length) {
-                if (token == this.expression.substring(this.i, this.i + token.length)) {
-                    this.i += token.length;
-                    this.advance();
-                    return token;
-                }
-            }
-        }
-        throw this.exception('Expected one of ' + JSON.stringify(tokens));
-    }
-    // Checks if one of the given array of tokens is present at the current position.
-    isToken(tokens) {
-        this.checkBuffer();
-        for (let j = 0; j < tokens.length; j++) {
-            const token = tokens[j];
-            if (this.i + token.length <= this.expression.length) {
-                if (token == this.expression.substring(this.i, this.i + token.length)) {
-                    if (!isLetter(token[token.length - 1]) || this.isWordSeparator(this.i + token.length)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
-}
-exports.Tokenizer = Tokenizer;
-// ## Parser
-// The parser uses the tokenizer to build an Expression object.
-class Parser {
-    constructor(scopeType, tokenizer, args) {
-        this.scopeType = scopeType;
-        this.tokenizer = tokenizer;
-        this.args = args;
-        if (args == null) {
-            this.args = [];
-        }
-    }
-    parse() {
-        const e = this.parseOrExpression();
-        if (this.tokenizer.hasMore()) {
-            throw this.tokenizer.exception('Invalid expression (expected expression to end)');
-        }
-        return e;
-    }
-    /*
-     expr    : term ( ( AND | OR ) term ) *
-     term    : ( attribute operator value ) | ( \( expression \) )
-     factor  : NUMBER ;
-    */
-    parseOrExpression() {
-        const e = this.parseAndExpression();
-        if (this.tokenizer.hasMore() && this.tokenizer.isOr()) {
-            let expressions = [e];
-            while (this.tokenizer.hasMore() && this.tokenizer.isOr()) {
-                this.tokenizer.readBooleanLogic();
-                expressions.push(this.parseAndExpression());
-            }
-            return new OrExpression(expressions);
-        }
-        else {
-            return e;
-        }
-    }
-    parseAndExpression() {
-        const e = this.parseTerm();
-        if (this.tokenizer.hasMore() && this.tokenizer.isAnd()) {
-            let expressions = [e];
-            while (this.tokenizer.hasMore() && this.tokenizer.isAnd()) {
-                this.tokenizer.readBooleanLogic();
-                expressions.push(this.parseTerm());
-            }
-            return new AndExpression(expressions);
-        }
-        else {
-            return e;
-        }
-    }
-    parseTerm() {
-        if (this.tokenizer.isWord()) {
-            let attributeStart = this.tokenizer.i;
-            const attributeName = this.tokenizer.readWord();
-            let attributeEnd = this.tokenizer.previousPosition + 1;
-            const operator = this.tokenizer.readOperator();
-            let interpolatorPosition = this.tokenizer.i;
-            const valueIndex = this.tokenizer.readInterpolator();
-            const attribute = this.scopeType.getAttribute(attributeName);
-            if (attribute == null) {
-                throw this.tokenizer.exception("'" + attributeName + "' is not a valid field of '" + this.scopeType.name + "'", attributeStart, attributeEnd);
-            }
-            else if (parser_type_system_1.ArrayType.isInstanceOf(attribute.type) || parser_schema_1.QueryType.isInstanceOf(attribute.type)) {
-                throw this.tokenizer.exception("Cannot query by has-many field '" + attributeName + "'", attributeStart, attributeEnd);
-            }
-            if (this.args.length > valueIndex) {
-                let value = this.args[valueIndex];
-                if (parser_schema_1.SchemaModelType.isInstanceOf(attribute.type) && value != null) {
-                    value = value.id;
-                }
-                return new Operation(attribute, operator, value);
-            }
-            else {
-                throw this.tokenizer.exception('Not enough arguments to interpolate', interpolatorPosition);
-            }
-        }
-        else if (this.tokenizer.isParenthesis()) {
-            let c = this.tokenizer.readParenthesis();
-            if (c != '(') {
-                throw this.tokenizer.exception('Expected (', this.tokenizer.previousPosition);
-            }
-            const e = this.parseOrExpression();
-            c = this.tokenizer.readParenthesis();
-            if (c != ')') {
-                throw this.tokenizer.exception('Expected )', this.tokenizer.previousPosition);
-            }
-            return e;
-        }
-        else {
-            throw this.tokenizer.exception('Expected attribute name or (');
-        }
-    }
-}
-exports.Parser = Parser;
-function parse(scopeType, expression, args) {
-    return new Parser(scopeType, new Tokenizer(expression), args).parse();
-}
-//# sourceMappingURL=queryOperations.js.map