devextreme/cjs/__internal/data/m_remote_query.js

HTML5 JavaScript Component Suite for Responsive Web Development

/**
 * DevExtreme (cjs/__internal/data/m_remote_query.js)
 * Version: 24.2.6
 * Build date: Mon Mar 17 2025
 *
 * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
 * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
 */

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = void 0;
var _array_query = _interopRequireDefault(require("../../common/data/array_query"));
var _errors = require("../../common/data/errors");
var _query_adapters = _interopRequireDefault(require("../../common/data/query_adapters"));
var _deferred = require("../../core/utils/deferred");
var _iterator = require("../../core/utils/iterator");
var _type = require("../../core/utils/type");

function _interopRequireDefault(e) {
    return e && e.__esModule ? e : {
        default: e
    }
}
const remoteQueryImpl = function(url, queryOptions, tasks) {
    tasks = tasks || [];
    queryOptions = queryOptions || {};
    const createTask = function(name, args) {
        return {
            name: name,
            args: args
        }
    };
    const exec = function(executorTask) {
        const d = new _deferred.Deferred;
        let _adapterFactory;
        let _adapter;
        let _taskQueue;
        let _currentTask;
        let _mergedSortArgs;
        const rejectWithNotify = function(error) {
            const handler = queryOptions.errorHandler;
            if (handler) {
                handler(error)
            }(0, _errors.handleError)(error);
            d.reject(error)
        };

        function mergeSortTask(task) {
            switch (task.name) {
                case "sortBy":
                    _mergedSortArgs = [task.args];
                    return true;
                case "thenBy":
                    if (!_mergedSortArgs) {
                        throw _errors.errors.Error("E4004")
                    }
                    _mergedSortArgs.push(task.args);
                    return true
            }
            return false
        }
        try {
            _adapterFactory = queryOptions.adapter;
            if (!(0, _type.isFunction)(_adapterFactory)) {
                _adapterFactory = _query_adapters.default[_adapterFactory]
            }
            _adapter = _adapterFactory(queryOptions);
            _taskQueue = [].concat(tasks).concat(executorTask);
            const {
                optimize: optimize
            } = _adapter;
            if (optimize) {
                optimize(_taskQueue)
            }
            while (_taskQueue.length) {
                _currentTask = _taskQueue[0];
                if (!mergeSortTask(_currentTask)) {
                    if (_mergedSortArgs) {
                        _taskQueue.unshift(createTask("multiSort", [_mergedSortArgs]));
                        _mergedSortArgs = null;
                        continue
                    }
                    if ("enumerate" !== String(_currentTask.name)) {
                        if (!_adapter[_currentTask.name] || false === _adapter[_currentTask.name].apply(_adapter, _currentTask.args)) {
                            break
                        }
                    }
                }
                _taskQueue.shift()
            }! function() {
                const head = _taskQueue[0];
                const unmergedTasks = [];
                if (head && "multiSort" === head.name) {
                    _taskQueue.shift();
                    (0, _iterator.each)(head.args[0], (function() {
                        unmergedTasks.push(createTask(unmergedTasks.length ? "thenBy" : "sortBy", this))
                    }))
                }
                _taskQueue = unmergedTasks.concat(_taskQueue)
            }();
            _adapter.exec(url).done(((result, extra) => {
                if (!_taskQueue.length) {
                    d.resolve(result, extra)
                } else {
                    let clientChain = (0, _array_query.default)(result, {
                        errorHandler: queryOptions.errorHandler
                    });
                    (0, _iterator.each)(_taskQueue, (function() {
                        clientChain = clientChain[this.name].apply(clientChain, this.args)
                    }));
                    clientChain.done(d.resolve).fail(d.reject)
                }
            })).fail(rejectWithNotify)
        } catch (x) {
            rejectWithNotify(x)
        }
        return d.promise()
    };
    const query = {};
    (0, _iterator.each)(["sortBy", "thenBy", "filter", "slice", "select", "groupBy"], (function() {
        const name = String(this);
        query[name] = function() {
            return remoteQueryImpl(url, queryOptions, tasks.concat(createTask(name, arguments)))
        }
    }));
    (0, _iterator.each)(["count", "min", "max", "sum", "avg", "aggregate", "enumerate"], (function() {
        const name = String(this);
        query[name] = function() {
            return exec.call(this, createTask(name, arguments))
        }
    }));
    return query
};
var _default = exports.default = remoteQueryImpl;