@comake/skl-js-engine 0.4.0 → 0.5.0

package/dist/storage/sparql/SparqlQueryBuilder.js

@@ -1,672 +1,3 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SparqlQueryBuilder = void 0;
-/* eslint-disable unicorn/expiring-todo-comments */
-const data_model_1 = __importDefault(require("@rdfjs/data-model"));
-const TripleUtil_1 = require("../../util/TripleUtil");
-const Util_1 = require("../../util/Util");
-const Vocabularies_1 = require("../../util/Vocabularies");
-const FindOperator_1 = require("../FindOperator");
-const VariableGenerator_1 = require("./VariableGenerator");
-class SparqlQueryBuilder {
-    constructor() {
-        this.variableGenerator = new VariableGenerator_1.VariableGenerator();
-    }
-    buildValuesForVariables(valuesByVariable) {
-        return Object.entries(valuesByVariable)
-            .map(([variableName, values]) => ({
-            type: 'values',
-            values: values.map((value) => ({
-                [`?${variableName}`]: value,
-            })),
-        }));
-    }
-    filterWithExpression(expression) {
-        return { type: 'filter', expression };
-    }
-    buildPatternsFromQueryOptions(subject, where, order, relations) {
-        const queryData = this.createQueryData(subject, where, order, relations);
-        const wherePatterns = this.createWherePatternsFromQueryData(queryData.values, queryData.triples, queryData.optionalTriples, queryData.filters);
-        const graphWherePatterns = this.createWherePatternsFromQueryData(queryData.graphValues, queryData.graphTriples, queryData.optionalGraphTriples, queryData.graphFilters);
-        return {
-            variables: queryData.relationsVariables,
-            where: wherePatterns,
-            orders: queryData.orders,
-            graphWhere: graphWherePatterns,
-        };
-    }
-    createWherePatternsFromQueryData(values, triples, optionalTriples, filters) {
-        const patterns = values;
-        if (triples.length > 0) {
-            patterns.push(this.sparqlBasicGraphPattern(triples));
-        }
-        if (optionalTriples.length > 0) {
-            patterns.push(this.sparqlOptionalWithTriples(optionalTriples));
-        }
-        if (filters.length > 0) {
-            patterns.push(this.filterPatternFromFilters(filters));
-        }
-        return patterns;
-    }
-    filterPatternFromFilters(filters) {
-        if (filters.length > 1) {
-            return this.filterWithExpression({
-                type: 'operation',
-                operator: '&&',
-                args: filters,
-            });
-        }
-        return this.filterWithExpression(filters[0]);
-    }
-    sparqlOptionalWithTriples(triples) {
-        return {
-            type: 'optional',
-            patterns: [this.sparqlBasicGraphPattern(triples)],
-        };
-    }
-    sparqlBasicGraphPattern(triples) {
-        return { type: 'bgp', triples };
-    }
-    buildConstructFromEntitySelectQuery(graphWhere, graphSelectVariables, select) {
-        let triples;
-        let where = [];
-        if (select) {
-            // TODO: fix when select and relations are used.
-            triples = this.createSelectPattern(select, TripleUtil_1.entityVariable);
-            where = [
-                this.sparqlOptionalSelectGraph(TripleUtil_1.entityVariable, triples),
-                ...graphWhere,
-            ];
-        }
-        else {
-            const graphSelectsAndTriplePatterns = this.createGraphSelectsAndTriplePatterns(graphSelectVariables);
-            const entityGraphTriple = { subject: TripleUtil_1.subjectNode, predicate: TripleUtil_1.predicateNode, object: TripleUtil_1.objectNode };
-            triples = [
-                entityGraphTriple,
-                ...graphSelectsAndTriplePatterns.triples,
-            ];
-            where = [
-                ...graphWhere,
-                this.sparqlSelectGraph(TripleUtil_1.entityVariable, [this.sparqlBasicGraphPattern([entityGraphTriple])]),
-                ...graphSelectsAndTriplePatterns.graphPatterns,
-            ];
-        }
-        return {
-            type: 'query',
-            prefixes: {},
-            queryType: 'CONSTRUCT',
-            template: triples,
-            where,
-        };
-    }
-    createSelectPattern(select, subject) {
-        if (Array.isArray(select)) {
-            return select.map((selectPredicate) => ({
-                subject,
-                predicate: data_model_1.default.namedNode(selectPredicate),
-                object: this.createVariable(),
-            }));
-        }
-        return Object.entries(select).reduce((arr, [key, value]) => {
-            const variable = this.createVariable();
-            arr.push({ subject, predicate: data_model_1.default.namedNode(key), object: variable });
-            if (typeof value === 'object') {
-                arr = [...arr, ...this.createSelectPattern(value, variable)];
-            }
-            return arr;
-        }, []);
-    }
-    createGraphSelectsAndTriplePatterns(variables) {
-        return variables.reduce((obj, variable) => {
-            const triple = {
-                subject: this.createVariable(),
-                predicate: this.createVariable(),
-                object: this.createVariable(),
-            };
-            obj.triples.push(triple);
-            obj.graphPatterns.push(this.sparqlSelectGraph(variable, [this.sparqlBasicGraphPattern([triple])]));
-            return obj;
-        }, { triples: [], graphPatterns: [] });
-    }
-    sparqlSelectGraph(name, patterns) {
-        return {
-            type: 'graph',
-            name: name,
-            patterns,
-        };
-    }
-    sparqlOptionalSelectGraph(name, triples) {
-        return {
-            type: 'graph',
-            name: name,
-            patterns: [{
-                    type: 'optional',
-                    patterns: [{
-                            type: 'bgp',
-                            triples,
-                        }],
-                }],
-        };
-    }
-    createQueryData(subject, where, order, relations) {
-        const whereQueryData = this.createWhereQueryData(subject, where);
-        const orderQueryData = this.createOrderQueryData(subject, order);
-        const relationsQueryData = this.createRelationsQueryData(subject, relations);
-        const optionalTriples = orderQueryData.triples;
-        const optionalGraphTriples = [...relationsQueryData.triples, ...relationsQueryData.graphTriples];
-        if (whereQueryData.triples.length === 0 && (whereQueryData.filters.length > 0 ||
-            optionalTriples.length > 0 ||
-            (whereQueryData.values.length === 0 &&
-                whereQueryData.graphValues.length === 0 &&
-                whereQueryData.graphTriples.length === 0))) {
-            whereQueryData.triples.push({
-                subject,
-                predicate: this.createVariable(),
-                object: this.createVariable(),
-            });
-        }
-        return {
-            relationsVariables: relationsQueryData.variables,
-            values: whereQueryData.values,
-            triples: whereQueryData.triples,
-            filters: whereQueryData.filters,
-            optionalTriples,
-            orders: orderQueryData.orders,
-            graphValues: whereQueryData.graphValues,
-            graphTriples: whereQueryData.graphTriples,
-            optionalGraphTriples,
-            graphFilters: [...whereQueryData.graphFilters],
-        };
-    }
-    createWhereQueryData(subject, where) {
-        const hasSingleKey = Object.keys(where ?? {}).length === 1;
-        const whereQueryData = Object.entries(where ?? {}).reduce((obj, [key, value]) => {
-            const whereQueryDataForField = this.createWhereQueryDataForField(subject, key, value, hasSingleKey);
-            return {
-                values: [...obj.values, ...whereQueryDataForField.values],
-                triples: [...obj.triples, ...whereQueryDataForField.triples],
-                filters: [...obj.filters, ...whereQueryDataForField.filters],
-                graphValues: [...obj.graphValues, ...whereQueryDataForField.graphValues],
-                graphTriples: [...obj.graphTriples, ...whereQueryDataForField.graphTriples],
-                graphFilters: [...obj.graphFilters, ...whereQueryDataForField.graphFilters],
-            };
-        }, { values: [], triples: [], filters: [], graphValues: [], graphTriples: [], graphFilters: [] });
-        return whereQueryData;
-    }
-    createWhereQueryDataForField(subject, field, value, isOnlyField) {
-        if (field === 'id') {
-            return this.createWhereQueryDataForIdValue(subject, value, isOnlyField);
-        }
-        if (field === 'type') {
-            return this.createWhereQueryDataForType(subject, value);
-        }
-        const predicate = data_model_1.default.namedNode(field);
-        return this.createWhereQueryDataFromKeyValue(subject, predicate, value);
-    }
-    createWhereQueryDataForIdValue(term, value, isOnlyField) {
-        let filter;
-        let valuePattern;
-        if (FindOperator_1.FindOperator.isFindOperator(value)) {
-            ({ filter, valuePattern } = this.resolveFindOperatorAsExpressionForId(term, value));
-        }
-        else {
-            valuePattern = {
-                type: 'values',
-                values: [{
-                        [`?${term.value}`]: data_model_1.default.namedNode(value),
-                    }],
-            };
-        }
-        if (isOnlyField) {
-            return {
-                values: [],
-                filters: [],
-                triples: [],
-                graphValues: valuePattern ? [valuePattern] : [],
-                graphFilters: filter ? [filter] : [],
-                graphTriples: [],
-            };
-        }
-        return {
-            values: valuePattern ? [valuePattern] : [],
-            filters: filter ? [filter] : [],
-            triples: [],
-            graphValues: [],
-            graphFilters: [],
-            graphTriples: [],
-        };
-    }
-    createWhereQueryDataForType(subject, value) {
-        if (FindOperator_1.FindOperator.isFindOperator(value)) {
-            const variable = this.createVariable();
-            const triple = this.buildTypesAndSuperTypesTriple(subject, variable);
-            const { filter, valuePattern, tripleInFilter } = this.resolveFindOperatorAsExpressionWithMultipleValues(variable, value, triple);
-            return {
-                values: valuePattern ? [valuePattern] : [],
-                filters: filter ? [filter] : [],
-                triples: tripleInFilter ? [] : [triple],
-                graphValues: [],
-                graphFilters: [],
-                graphTriples: [],
-            };
-        }
-        return {
-            values: [],
-            filters: [],
-            triples: [this.buildTypesAndSuperTypesTriple(subject, data_model_1.default.namedNode(value))],
-            graphValues: [],
-            graphFilters: [],
-            graphTriples: [],
-        };
-    }
-    createWhereQueryDataFromKeyValue(subject, predicate, value) {
-        if (FindOperator_1.FindOperator.isFindOperator(value)) {
-            return this.createWhereQueryDataForFindOperator(subject, predicate, value);
-        }
-        if (Array.isArray(value)) {
-            return value.reduce((obj, valueItem) => {
-                const valueWhereQueryData = this.createWhereQueryDataFromKeyValue(subject, predicate, valueItem);
-                return {
-                    values: [...obj.values, ...valueWhereQueryData.values],
-                    filters: [...obj.filters, ...valueWhereQueryData.filters],
-                    triples: [...obj.triples, ...valueWhereQueryData.triples],
-                    graphValues: [...obj.graphValues, ...valueWhereQueryData.graphValues],
-                    graphFilters: [...obj.graphFilters, ...valueWhereQueryData.graphFilters],
-                    graphTriples: [...obj.graphTriples, ...valueWhereQueryData.graphTriples],
-                };
-            }, { values: [], filters: [], triples: [], graphTriples: [], graphValues: [], graphFilters: [] });
-        }
-        if (typeof value === 'object') {
-            if ('@value' in value) {
-                return this.createWhereQueryDataForValueObject(subject, predicate, value);
-            }
-            return this.createWhereQueryDataForNestedWhere(subject, predicate, value);
-        }
-        const term = this.resolveValueToTerm(value);
-        return {
-            values: [],
-            filters: [],
-            triples: [{ subject, predicate, object: term }],
-            graphValues: [],
-            graphFilters: [],
-            graphTriples: [],
-        };
-    }
-    inversePropertyPredicate(predicate) {
-        return {
-            type: 'path',
-            pathType: '^',
-            items: [predicate],
-        };
-    }
-    createWhereQueryDataForFindOperator(subject, predicate, operator) {
-        if (operator.operator === 'inverse') {
-            const inversePredicate = this.inversePropertyPredicate(predicate);
-            const inverseWhereQueryData = this.createWhereQueryDataFromKeyValue(subject, inversePredicate, operator.value);
-            return {
-                values: inverseWhereQueryData.values,
-                filters: inverseWhereQueryData.filters,
-                triples: inverseWhereQueryData.triples,
-                graphValues: [],
-                graphTriples: [],
-                graphFilters: [],
-            };
-        }
-        const variable = this.createVariable();
-        const triple = { subject, predicate, object: variable };
-        const { filter, valuePattern } = this.resolveFindOperatorAsExpressionWithMultipleValues(variable, operator, triple);
-        return {
-            values: valuePattern ? [valuePattern] : [],
-            filters: filter ? [filter] : [],
-            triples: [triple],
-            graphValues: [],
-            graphTriples: [],
-            graphFilters: [],
-        };
-    }
-    createWhereQueryDataForNestedWhere(subject, predicate, where) {
-        const subNodeVariable = this.createVariable();
-        const subWhereQueryData = this.createWhereQueryData(subNodeVariable, where);
-        return {
-            values: [...subWhereQueryData.values, ...subWhereQueryData.graphValues],
-            filters: subWhereQueryData.filters,
-            triples: [
-                { subject, predicate, object: subNodeVariable },
-                ...subWhereQueryData.triples,
-            ],
-            graphValues: [],
-            graphFilters: [],
-            graphTriples: [],
-        };
-    }
-    createWhereQueryDataForValueObject(subject, predicate, valueObject) {
-        const term = this.valueObjectToTerm(valueObject);
-        return {
-            values: [],
-            filters: [],
-            triples: [{ subject, predicate, object: term }],
-            graphValues: [],
-            graphFilters: [],
-            graphTriples: [],
-        };
-    }
-    valueObjectToTerm(valueObject) {
-        let typeOrLanguage;
-        let value;
-        if ('@type' in valueObject && valueObject['@type'] === '@json') {
-            typeOrLanguage = Vocabularies_1.RDF.JSON;
-            value = JSON.stringify(valueObject['@value']);
-        }
-        else {
-            typeOrLanguage = ('@type' in valueObject ? valueObject['@type'] : valueObject['@language']);
-            value = valueObject['@value'].toString();
-        }
-        return data_model_1.default.literal(value, typeOrLanguage);
-    }
-    resolveFindOperatorAsExpressionWithMultipleValues(leftSide, operator, triple, dontUseValuePattern = false) {
-        switch (operator.operator) {
-            case 'in': {
-                const resolvedValue = this.resolveValueToExpression(operator.value);
-                if (Array.isArray(resolvedValue) && !dontUseValuePattern) {
-                    return {
-                        valuePattern: {
-                            type: 'values',
-                            values: resolvedValue.map((value) => ({ [`?${leftSide.value}`]: value })),
-                        },
-                    };
-                }
-                return {
-                    filter: this.buildInOperation(leftSide, resolvedValue),
-                };
-            }
-            case 'not':
-                return {
-                    filter: this.buildNotOperationForMultiValued(leftSide, this.resolveValueToExpression(operator.value), triple),
-                    tripleInFilter: true,
-                };
-            case 'equal':
-                return {
-                    filter: this.buildEqualOperation(leftSide, this.resolveValueToExpression(operator.value)),
-                };
-            case 'gt':
-                return {
-                    filter: this.buildGtOperation(leftSide, this.resolveValueToExpression(operator.value)),
-                };
-            case 'gte':
-                return {
-                    filter: this.buildGteOperation(leftSide, this.resolveValueToExpression(operator.value)),
-                };
-            case 'lt':
-                return {
-                    filter: this.buildLtOperation(leftSide, this.resolveValueToExpression(operator.value)),
-                };
-            case 'lte':
-                return {
-                    filter: this.buildLteOperation(leftSide, this.resolveValueToExpression(operator.value)),
-                };
-            default:
-                throw new Error(`Unsupported operator "${operator.operator}"`);
-        }
-    }
-    resolveFindOperatorAsExpressionForId(leftSide, operator) {
-        switch (operator.operator) {
-            case 'in': {
-                const resolvedValue = this.resolveValueToExpression(operator.value);
-                return {
-                    valuePattern: {
-                        type: 'values',
-                        values: resolvedValue.map((value) => ({ [`?${leftSide.value}`]: value })),
-                    },
-                };
-            }
-            case 'not':
-                return {
-                    filter: this.buildNotOperationForId(leftSide, this.resolveValueToExpression(operator.value)),
-                };
-            case 'equal':
-                return {
-                    filter: this.buildEqualOperation(leftSide, this.resolveValueToExpression(operator.value)),
-                };
-            default:
-                throw new Error(`Unsupported operator "${operator.operator}"`);
-        }
-    }
-    resolveValueToExpression(value) {
-        if (FindOperator_1.FindOperator.isFindOperator(value)) {
-            return value;
-        }
-        if (Array.isArray(value)) {
-            return value.map((valueItem) => this.resolveValueToTerm(valueItem));
-        }
-        return this.resolveValueToTerm(value);
-    }
-    buildInOperation(leftSide, rightSide) {
-        return {
-            type: 'operation',
-            operator: 'in',
-            args: [leftSide, rightSide],
-        };
-    }
-    buildNotInOperation(leftSide, rightSide) {
-        return {
-            type: 'operation',
-            operator: 'notin',
-            args: [leftSide, rightSide],
-        };
-    }
-    buildNotOperationForMultiValued(leftSide, rightSide, triple) {
-        let filterExpression;
-        const rightSideIsOperation = typeof rightSide === 'object' && 'operator' in rightSide;
-        if (rightSideIsOperation) {
-            let expression;
-            try {
-                ({ filter: expression } = this.resolveFindOperatorAsExpressionWithMultipleValues(leftSide, rightSide, triple, true));
-            }
-            catch {
-                throw new Error(`Unsupported Not sub operator "${rightSide.operator}"`);
-            }
-            filterExpression = this.filterWithExpression(expression);
-        }
-        else {
-            filterExpression = this.filterWithExpression(this.buildEqualOperation(leftSide, rightSide));
-        }
-        return {
-            type: 'operation',
-            operator: 'notexists',
-            args: [
-                {
-                    type: 'group',
-                    patterns: [
-                        {
-                            type: 'bgp',
-                            triples: [triple],
-                        },
-                        filterExpression,
-                    ],
-                },
-            ],
-        };
-    }
-    buildNotOperationForId(leftSide, rightSide) {
-        if (FindOperator_1.FindOperator.isFindOperator(rightSide)) {
-            switch (rightSide.operator) {
-                case 'in':
-                    return this.buildNotInOperation(leftSide, this.resolveValueToExpression(rightSide.value));
-                case 'equal':
-                    return this.buildNotEqualOperation(leftSide, this.resolveValueToExpression(rightSide.value));
-                default:
-                    throw new Error(`Unsupported Not sub operator "${rightSide.operator}"`);
-            }
-        }
-        return this.buildNotEqualOperation(leftSide, rightSide);
-    }
-    buildEqualOperation(leftSide, rightSide) {
-        return {
-            type: 'operation',
-            operator: '=',
-            args: [leftSide, rightSide],
-        };
-    }
-    buildGtOperation(leftSide, rightSide) {
-        return {
-            type: 'operation',
-            operator: '>',
-            args: [leftSide, rightSide],
-        };
-    }
-    buildGteOperation(leftSide, rightSide) {
-        return {
-            type: 'operation',
-            operator: '>=',
-            args: [leftSide, rightSide],
-        };
-    }
-    buildLtOperation(leftSide, rightSide) {
-        return {
-            type: 'operation',
-            operator: '<',
-            args: [leftSide, rightSide],
-        };
-    }
-    buildLteOperation(leftSide, rightSide) {
-        return {
-            type: 'operation',
-            operator: '<=',
-            args: [leftSide, rightSide],
-        };
-    }
-    buildNotEqualOperation(leftSide, rightSide) {
-        return {
-            type: 'operation',
-            operator: '!=',
-            args: [leftSide, rightSide],
-        };
-    }
-    buildTypesAndSuperTypesTriple(subject, object) {
-        return { subject, predicate: TripleUtil_1.allTypesAndSuperTypesPath, object };
-    }
-    resolveValueToTerm(value) {
-        if (typeof value === 'object' && '@value' in value) {
-            return (0, TripleUtil_1.valueToLiteral)(value['@value'], '@type' in value ? value['@type'] : undefined);
-        }
-        if ((0, Util_1.isUrl)(value)) {
-            return data_model_1.default.namedNode(value);
-        }
-        return (0, TripleUtil_1.valueToLiteral)(value);
-    }
-    createOrderQueryData(subject, order) {
-        if (!order) {
-            return { triples: [], orders: [], variables: [] };
-        }
-        return Object.entries(order).reduce((obj, [property, direction]) => {
-            const orderQueryData = this.createOrderQueryDataForProperty(subject, property, direction);
-            obj.orders = [...obj.orders, orderQueryData.order];
-            obj.variables.push(orderQueryData.variable);
-            if (orderQueryData.triple) {
-                obj.triples.push(orderQueryData.triple);
-            }
-            return obj;
-        }, { triples: [], orders: [], variables: [] });
-    }
-    createOrderQueryDataForProperty(subject, property, direction) {
-        if (property === 'id') {
-            return {
-                triple: undefined,
-                order: {
-                    expression: subject,
-                    descending: direction === 'DESC' || direction === 'desc',
-                },
-                variable: subject,
-            };
-        }
-        const variable = this.createVariable();
-        return {
-            triple: {
-                subject,
-                predicate: data_model_1.default.namedNode(property),
-                object: variable,
-            },
-            order: {
-                expression: variable,
-                descending: direction === 'DESC' || direction === 'desc',
-            },
-            variable,
-        };
-    }
-    createRelationsQueryData(subject, relations) {
-        if (!relations) {
-            return { variables: [], triples: [], graphTriples: [] };
-        }
-        return Object.entries(relations)
-            .reduce((obj, [property, relationsValue]) => {
-            const variable = this.createVariable();
-            const predicate = data_model_1.default.namedNode(property);
-            if (typeof relationsValue === 'object') {
-                if (FindOperator_1.FindOperator.isFindOperator(relationsValue)) {
-                    const { triples, variables, graphTriples } = this.createRelationsQueryDataForInverseRelation(subject, predicate, variable, relationsValue);
-                    return {
-                        triples: [...obj.triples, ...triples],
-                        variables: [...obj.variables, variable, ...variables],
-                        graphTriples: [...obj.graphTriples, ...graphTriples],
-                    };
-                }
-                const { triples, variables, graphTriples } = this.createRelationsQueryDataForNestedRelation(subject, predicate, variable, relationsValue);
-                return {
-                    triples: [...obj.triples, ...triples],
-                    variables: [variable, ...obj.variables, ...variables],
-                    graphTriples: [...obj.graphTriples, ...graphTriples],
-                };
-            }
-            const relationTriple = { subject, predicate, object: variable };
-            return {
-                ...obj,
-                triples: [...obj.triples, relationTriple],
-                variables: [...obj.variables, variable],
-            };
-        }, { variables: [], triples: [], graphTriples: [] });
-    }
-    createRelationsQueryDataForInverseRelation(subject, predicate, variable, relationsValue) {
-        const inverseRelationTriple = {
-            subject,
-            predicate: this.inversePropertyPredicate(predicate),
-            object: variable,
-        };
-        if (typeof relationsValue.value === 'object' &&
-            relationsValue.value.relations) {
-            const subRelationsQueryData = this.createRelationsQueryData(variable, relationsValue.value.relations);
-            return {
-                triples: [inverseRelationTriple],
-                variables: subRelationsQueryData.variables,
-                graphTriples: [
-                    ...subRelationsQueryData.triples,
-                    ...subRelationsQueryData.graphTriples,
-                ],
-            };
-        }
-        return {
-            triples: [inverseRelationTriple],
-            variables: [],
-            graphTriples: [],
-        };
-    }
-    createRelationsQueryDataForNestedRelation(subject, predicate, variable, relationsValue) {
-        const relationTriple = { subject, predicate, object: variable };
-        const subRelationsQueryData = this.createRelationsQueryData(variable, relationsValue);
-        return {
-            triples: [relationTriple],
-            variables: subRelationsQueryData.variables,
-            graphTriples: [
-                ...subRelationsQueryData.triples,
-                ...subRelationsQueryData.graphTriples,
-            ],
-        };
-    }
-    createVariable() {
-        return data_model_1.default.variable(this.variableGenerator.getNext());
-    }
-}
-exports.SparqlQueryBuilder = SparqlQueryBuilder;
 //# sourceMappingURL=SparqlQueryBuilder.js.map