@comake/skl-js-engine 0.16.0 → 0.16.2

package/dist/storage/sparql/SparqlQueryBuilder.js

@@ -1,667 +0,0 @@
-"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;
-const data_model_1 = __importDefault(require("@rdfjs/data-model"));
-const SparqlUtil_1 = require("../../util/SparqlUtil");
-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();
-    }
-    buildEntitySelectPatternsFromOptions(subject, options) {
-        const relations = options?.select ? undefined : options?.relations;
-        const whereQueryData = this.createWhereQueryData(subject, options?.where);
-        const orderQueryData = this.createOrderQueryData(subject, options?.order);
-        const relationsQueryData = this.createRelationsQueryData(subject, relations);
-        if (whereQueryData.triples.length === 0 && (whereQueryData.filters.length > 0 ||
-            orderQueryData.triples.length > 0 ||
-            (whereQueryData.values.length === 0 &&
-                whereQueryData.graphValues.length === 0 &&
-                whereQueryData.graphTriples.length === 0))) {
-            whereQueryData.triples.push({
-                subject,
-                predicate: this.createVariable(),
-                object: this.createVariable(),
-            });
-        }
-        const wherePatterns = this.createWherePatternsFromQueryData(whereQueryData.values, whereQueryData.triples, whereQueryData.filters, orderQueryData.triples, orderQueryData.filters);
-        const graphWherePatterns = this.createWherePatternsFromQueryData(whereQueryData.graphValues, whereQueryData.graphTriples, whereQueryData.graphFilters, undefined, undefined, undefined, relationsQueryData.patterns);
-        return {
-            where: wherePatterns,
-            orders: orderQueryData.orders,
-            group: orderQueryData.groupByParent ? subject : undefined,
-            graphWhere: graphWherePatterns,
-            graphSelectionTriples: relationsQueryData.selectionTriples,
-        };
-    }
-    buildConstructFromEntitySelectQuery(graphWhere, graphSelectionTriples, select) {
-        let triples;
-        let where = [];
-        if (select) {
-            triples = this.createSelectPattern(select, SparqlUtil_1.entityVariable);
-            where = [
-                (0, SparqlUtil_1.createSparqlOptional)([
-                    (0, SparqlUtil_1.createSparqlBasicGraphPattern)(triples),
-                ]),
-                ...graphWhere,
-            ];
-        }
-        else {
-            triples = [SparqlUtil_1.entityGraphTriple, ...graphSelectionTriples];
-            where = [
-                ...graphWhere,
-                (0, SparqlUtil_1.createSparqlGraphPattern)(SparqlUtil_1.entityVariable, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([SparqlUtil_1.entityGraphTriple])]),
-            ];
-        }
-        return (0, SparqlUtil_1.createSparqlConstructQuery)(triples, where);
-    }
-    createWhereQueryData(subject, where, baseTriples = []) {
-        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: baseTriples, 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 filters = [];
-        let values = [];
-        let triples = [];
-        if (FindOperator_1.FindOperator.isFindOperator(value)) {
-            ({ filters, values, triples } =
-                this.resolveFindOperatorAsExpressionForId(term, value));
-        }
-        else {
-            values = [{
-                    type: 'values',
-                    values: [{
-                            [`?${term.value}`]: data_model_1.default.namedNode(value),
-                        }],
-                }];
-        }
-        if (isOnlyField) {
-            return {
-                values: [],
-                filters: [],
-                triples: [],
-                graphValues: values,
-                graphFilters: filters,
-                graphTriples: triples,
-            };
-        }
-        return {
-            values,
-            filters,
-            triples,
-            graphValues: [],
-            graphFilters: [],
-            graphTriples: [],
-        };
-    }
-    createWhereQueryDataForType(subject, value) {
-        if (FindOperator_1.FindOperator.isFindOperator(value)) {
-            if (value.operator === 'inverse') {
-                const inversePredicate = (0, SparqlUtil_1.createSparqlInversePredicate)([SparqlUtil_1.allTypesAndSuperTypesPath]);
-                const inverseWhereQueryData = this.createWhereQueryDataFromKeyValue(subject, inversePredicate, value.value);
-                return {
-                    values: inverseWhereQueryData.values,
-                    filters: inverseWhereQueryData.filters,
-                    triples: inverseWhereQueryData.triples,
-                    graphValues: [],
-                    graphTriples: [],
-                    graphFilters: [],
-                };
-            }
-            const variable = this.createVariable();
-            const triple = { subject, predicate: SparqlUtil_1.allTypesAndSuperTypesPath, object: 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: [{
-                    subject,
-                    predicate: SparqlUtil_1.allTypesAndSuperTypesPath,
-                    object: data_model_1.default.namedNode(value),
-                }],
-            graphValues: [],
-            graphFilters: [],
-            graphTriples: [],
-        };
-    }
-    createWhereQueryDataFromKeyValue(subject, predicate, value) {
-        if (Array.isArray(value) && FindOperator_1.FindOperator.isFindOperator(value[0])) {
-            return this.createWhereQueryDataForMultipleFindOperators(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: [],
-        };
-    }
-    createWhereQueryDataForFindOperator(subject, predicate, operator) {
-        if (operator.operator === 'inverse') {
-            const inversePredicate = (0, SparqlUtil_1.createSparqlInversePredicate)([predicate]);
-            const inverseWhereQueryData = this.createWhereQueryDataFromKeyValue(subject, inversePredicate, operator.value);
-            return {
-                values: inverseWhereQueryData.values,
-                filters: inverseWhereQueryData.filters,
-                triples: inverseWhereQueryData.triples,
-                graphValues: [],
-                graphTriples: [],
-                graphFilters: [],
-            };
-        }
-        if (FindOperator_1.FindOperator.isPathOperator(operator)) {
-            const pathPredicate = this.pathOperatorToPropertyPath(operator);
-            const combinedPredicate = (0, SparqlUtil_1.createSparqlSequencePredicate)([
-                predicate,
-                pathPredicate,
-            ]);
-            return this.createWhereQueryDataFromKeyValue(subject, combinedPredicate, operator.value.value);
-        }
-        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: [],
-        };
-    }
-    pathOperatorToPropertyPath(operator) {
-        if (operator.operator === 'inversePath') {
-            let subPredicate;
-            const { subPath } = operator.value;
-            if (typeof subPath === 'string') {
-                subPredicate = data_model_1.default.namedNode(subPath);
-            }
-            else {
-                subPredicate = this.pathOperatorToPropertyPath(subPath);
-            }
-            return (0, SparqlUtil_1.createSparqlInversePredicate)([subPredicate]);
-        }
-        if (operator.operator === 'sequencePath') {
-            const { subPath } = operator.value;
-            const subPredicates = subPath
-                .map((sequencePart) => {
-                if (typeof sequencePart === 'string') {
-                    return data_model_1.default.namedNode(sequencePart);
-                }
-                return this.pathOperatorToPropertyPath(sequencePart);
-            });
-            return (0, SparqlUtil_1.createSparqlSequencePredicate)(subPredicates);
-        }
-        if (operator.operator === 'zeroOrMorePath') {
-            const { subPath } = operator.value;
-            let subPredicate;
-            if (typeof subPath === 'string') {
-                subPredicate = data_model_1.default.namedNode(subPath);
-            }
-            else {
-                subPredicate = this.pathOperatorToPropertyPath(subPath);
-            }
-            return (0, SparqlUtil_1.createSparqlZeroOrMorePredicate)([subPredicate]);
-        }
-        if (operator.operator === 'oneOrMorePath') {
-            const { subPath } = operator.value;
-            let subPredicate;
-            if (typeof subPath === 'string') {
-                subPredicate = data_model_1.default.namedNode(subPath);
-            }
-            else {
-                subPredicate = this.pathOperatorToPropertyPath(subPath);
-            }
-            return (0, SparqlUtil_1.createSparqlOneOrMorePredicate)([subPredicate]);
-        }
-        throw new Error(`Operator ${operator.operator} not supported`);
-    }
-    createWhereQueryDataForMultipleFindOperators(subject, predicate, operators) {
-        const variable = this.createVariable();
-        const triple = { subject, predicate, object: variable };
-        const whereQueryData = {
-            values: [],
-            filters: [],
-            triples: [triple],
-            graphValues: [],
-            graphTriples: [],
-            graphFilters: [],
-        };
-        return operators.reduce((obj, operator) => {
-            const { filter, valuePattern } = this.resolveFindOperatorAsExpressionWithMultipleValues(variable, operator, triple);
-            if (valuePattern) {
-                obj.values.push(valuePattern);
-            }
-            if (filter) {
-                obj.filters.push(filter);
-            }
-            return obj;
-        }, whereQueryData);
-    }
-    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) {
-        if (operator.operator === '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: (0, SparqlUtil_1.createSparqlInOperation)(leftSide, resolvedValue),
-            };
-        }
-        if (operator.operator === 'not') {
-            const resolvedExpression = this.resolveValueToExpression(operator.value);
-            return {
-                filter: this.buildNotOperationForMultiValued(leftSide, resolvedExpression, triple),
-                tripleInFilter: true,
-            };
-        }
-        const resolvedExpression = this.resolveValueToExpression(operator.value);
-        switch (operator.operator) {
-            case 'equal':
-                return { filter: (0, SparqlUtil_1.createSparqlEqualOperation)(leftSide, resolvedExpression) };
-            case 'gt':
-                return { filter: (0, SparqlUtil_1.createSparqlGtOperation)(leftSide, resolvedExpression) };
-            case 'gte':
-                return { filter: (0, SparqlUtil_1.createSparqlGteOperation)(leftSide, resolvedExpression) };
-            case 'lt':
-                return { filter: (0, SparqlUtil_1.createSparqlLtOperation)(leftSide, resolvedExpression) };
-            case 'lte':
-                return { filter: (0, SparqlUtil_1.createSparqlLteOperation)(leftSide, resolvedExpression) };
-            default:
-                throw new Error(`Unsupported operator "${operator.operator}"`);
-        }
-    }
-    resolveFindOperatorAsExpressionForId(leftSide, operator) {
-        switch (operator.operator) {
-            case 'inversePath': {
-                const predicate = this.pathOperatorToPropertyPath(operator);
-                return this.createWhereQueryDataFromKeyValue(leftSide, predicate, operator.value.value);
-            }
-            case 'in': {
-                const resolvedValue = this.resolveValueToExpression(operator.value);
-                return {
-                    triples: [],
-                    filters: [],
-                    values: [{
-                            type: 'values',
-                            values: resolvedValue.map((value) => ({ [`?${leftSide.value}`]: value })),
-                        }],
-                };
-            }
-            case 'not':
-                return {
-                    triples: [],
-                    values: [],
-                    filters: [
-                        this.buildNotOperationForId(leftSide, this.resolveValueToExpression(operator.value)),
-                    ],
-                };
-            case 'equal':
-                return {
-                    triples: [],
-                    values: [],
-                    filters: [
-                        (0, SparqlUtil_1.createSparqlEqualOperation)(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);
-    }
-    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 = (0, SparqlUtil_1.createSparqlFilterWithExpression)(expression);
-        }
-        else {
-            filterExpression = (0, SparqlUtil_1.createSparqlFilterWithExpression)((0, SparqlUtil_1.createSparqlEqualOperation)(leftSide, rightSide));
-        }
-        return (0, SparqlUtil_1.createSparqlNotExistsOperation)([
-            (0, SparqlUtil_1.createSparqlSelectGroup)([
-                (0, SparqlUtil_1.createSparqlBasicGraphPattern)([triple]),
-                filterExpression,
-            ]),
-        ]);
-    }
-    buildNotOperationForId(leftSide, rightSide) {
-        if (FindOperator_1.FindOperator.isFindOperator(rightSide)) {
-            const resolvedValue = this.resolveValueToExpression(rightSide.value);
-            switch (rightSide.operator) {
-                case 'in':
-                    return (0, SparqlUtil_1.createSparqlNotInOperation)(leftSide, resolvedValue);
-                case 'equal':
-                    return (0, SparqlUtil_1.createSparqlNotEqualOperation)(leftSide, resolvedValue);
-                default:
-                    throw new Error(`Unsupported Not sub operator "${rightSide.operator}"`);
-            }
-        }
-        return (0, SparqlUtil_1.createSparqlNotEqualOperation)(leftSide, rightSide);
-    }
-    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, isNested = false) {
-        if (!order) {
-            return { triples: [], orders: [], filters: [] };
-        }
-        return Object.entries(order).reduce((obj, [property, orderValue]) => {
-            const orderQueryData = this.createOrderQueryDataForProperty(subject, property, orderValue, isNested);
-            obj.orders = [...obj.orders, ...orderQueryData.orders];
-            obj.triples = [...obj.triples, ...orderQueryData.triples];
-            obj.filters = [...obj.filters, ...orderQueryData.filters];
-            obj.groupByParent = obj.groupByParent ?? orderQueryData.groupByParent;
-            return obj;
-        }, { triples: [], orders: [], filters: [] });
-    }
-    createOrderQueryDataForProperty(subject, property, orderValue, isNested = false) {
-        const predicate = data_model_1.default.namedNode(property);
-        if (FindOperator_1.FindOperator.isFindOperator(orderValue)) {
-            const variable = this.createVariable();
-            const inverseRelationTriple = {
-                subject,
-                predicate: (0, SparqlUtil_1.createSparqlInversePredicate)([predicate]),
-                object: variable,
-            };
-            const subRelationOperatorValue = orderValue.value;
-            const subRelationOrderQueryData = this.createOrderQueryData(variable, subRelationOperatorValue.order, true);
-            const subRelationWhereQueryData = this.createWhereQueryData(variable, subRelationOperatorValue.where);
-            return {
-                triples: [inverseRelationTriple, ...subRelationOrderQueryData.triples, ...subRelationWhereQueryData.triples],
-                filters: subRelationWhereQueryData.filters,
-                orders: subRelationOrderQueryData.orders,
-                groupByParent: true,
-            };
-        }
-        if (property === 'id') {
-            return {
-                triples: [],
-                filters: [],
-                orders: [{
-                        expression: subject,
-                        descending: orderValue === 'DESC' || orderValue === 'desc',
-                    }],
-            };
-        }
-        const variable = this.createVariable();
-        const isDescending = orderValue === 'DESC' || orderValue === 'desc';
-        return {
-            triples: [{ subject, predicate, object: variable }],
-            filters: [],
-            orders: [{
-                    expression: isNested
-                        ? {
-                            type: 'aggregate',
-                            expression: variable,
-                            aggregation: isDescending ? 'max' : 'min',
-                        }
-                        : variable,
-                    descending: isDescending,
-                }],
-        };
-    }
-    createRelationsQueryData(subject, relations) {
-        if (!relations) {
-            return { patterns: [], selectionTriples: [] };
-        }
-        return Object.entries(relations)
-            .reduce((obj, [property, relationsValue]) => {
-            const predicate = data_model_1.default.namedNode(property);
-            if (typeof relationsValue === 'object') {
-                if (FindOperator_1.FindOperator.isFindOperator(relationsValue)) {
-                    const { patterns, selectionTriples } = this.createRelationsQueryDataForInverseRelation(subject, predicate, relationsValue);
-                    return {
-                        patterns: [...obj.patterns, ...patterns],
-                        selectionTriples: [...obj.selectionTriples, ...selectionTriples],
-                    };
-                }
-                const { patterns, selectionTriples } = this.createRelationsQueryDataForNestedRelation(subject, predicate, relationsValue);
-                return {
-                    patterns: [...obj.patterns, ...patterns],
-                    selectionTriples: [...obj.selectionTriples, ...selectionTriples],
-                };
-            }
-            const variable = this.createVariable();
-            const graphTriple = {
-                subject: this.createVariable(),
-                predicate: this.createVariable(),
-                object: this.createVariable(),
-            };
-            const relationPattern = (0, SparqlUtil_1.createSparqlOptional)([
-                (0, SparqlUtil_1.createSparqlBasicGraphPattern)([{ subject, predicate, object: variable }]),
-                (0, SparqlUtil_1.createSparqlGraphPattern)(variable, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([graphTriple])]),
-            ]);
-            return {
-                patterns: [...obj.patterns, relationPattern],
-                selectionTriples: [...obj.selectionTriples, graphTriple],
-            };
-        }, { patterns: [], selectionTriples: [] });
-    }
-    createRelationsQueryDataForInverseRelation(subject, predicate, relationsValue) {
-        const variable = this.createVariable();
-        const graphTriple = {
-            subject: this.createVariable(),
-            predicate: this.createVariable(),
-            object: this.createVariable(),
-        };
-        const inverseRelationTriple = {
-            subject,
-            predicate: (0, SparqlUtil_1.createSparqlInversePredicate)([predicate]),
-            object: variable,
-        };
-        if (typeof relationsValue.value === 'object' &&
-            relationsValue.value.relations) {
-            const subRelationsQueryData = this.createRelationsQueryData(variable, relationsValue.value.relations);
-            const relationPattern = (0, SparqlUtil_1.createSparqlOptional)([
-                (0, SparqlUtil_1.createSparqlBasicGraphPattern)([inverseRelationTriple]),
-                (0, SparqlUtil_1.createSparqlGraphPattern)(variable, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([graphTriple])]),
-                ...subRelationsQueryData.patterns,
-            ]);
-            return {
-                patterns: [relationPattern],
-                selectionTriples: [graphTriple, ...subRelationsQueryData.selectionTriples],
-            };
-        }
-        const relationPattern = (0, SparqlUtil_1.createSparqlOptional)([
-            (0, SparqlUtil_1.createSparqlBasicGraphPattern)([inverseRelationTriple]),
-            (0, SparqlUtil_1.createSparqlGraphPattern)(variable, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([graphTriple])]),
-        ]);
-        return {
-            patterns: [relationPattern],
-            selectionTriples: [graphTriple],
-        };
-    }
-    createRelationsQueryDataForNestedRelation(subject, predicate, relationsValue) {
-        const variable = this.createVariable();
-        const graphTriple = {
-            subject: this.createVariable(),
-            predicate: this.createVariable(),
-            object: this.createVariable(),
-        };
-        const relationTriple = { subject, predicate, object: variable };
-        const subRelationsQueryData = this.createRelationsQueryData(variable, relationsValue);
-        const relationPattern = (0, SparqlUtil_1.createSparqlOptional)([
-            (0, SparqlUtil_1.createSparqlBasicGraphPattern)([relationTriple]),
-            (0, SparqlUtil_1.createSparqlGraphPattern)(variable, [(0, SparqlUtil_1.createSparqlBasicGraphPattern)([graphTriple])]),
-            ...subRelationsQueryData.patterns,
-        ]);
-        return {
-            patterns: [relationPattern],
-            selectionTriples: [graphTriple, ...subRelationsQueryData.selectionTriples],
-        };
-    }
-    createVariable() {
-        return data_model_1.default.variable(this.variableGenerator.getNext());
-    }
-    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;
-        }, []);
-    }
-    createWherePatternsFromQueryData(values, triples, filters, orderTriples, orderFilters, serviceTriples, additionalPatterns) {
-        let patterns = values;
-        if (triples.length > 0) {
-            patterns.push((0, SparqlUtil_1.createSparqlBasicGraphPattern)(triples));
-        }
-        if (orderTriples && orderTriples.length > 0) {
-            const optionalPatterns = [(0, SparqlUtil_1.createSparqlBasicGraphPattern)(orderTriples)];
-            if (orderFilters && orderFilters.length > 0) {
-                optionalPatterns.push((0, SparqlUtil_1.createFilterPatternFromFilters)(orderFilters));
-            }
-            patterns.push((0, SparqlUtil_1.createSparqlOptional)(optionalPatterns));
-        }
-        if (filters.length > 0) {
-            patterns.push((0, SparqlUtil_1.createFilterPatternFromFilters)(filters));
-        }
-        if (serviceTriples) {
-            for (const [service, sTriples] of Object.entries(serviceTriples)) {
-                patterns.unshift((0, SparqlUtil_1.createSparqlServicePattern)(service, sTriples));
-            }
-        }
-        if (additionalPatterns) {
-            patterns = [...patterns, ...additionalPatterns];
-        }
-        return patterns;
-    }
-}
-exports.SparqlQueryBuilder = SparqlQueryBuilder;
-//# sourceMappingURL=SparqlQueryBuilder.js.map