@comake/skl-js-engine 0.15.5 → 0.16.1

package/dist/storage/query-adapter/sparql/SparqlQueryBuilder.js

@@ -0,0 +1,667 @@
+"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