typesense-utils/dist/buildSortBy.js

A list of utilities for typesense search engine

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.buildSortBy = exports.Order = exports.NullOrder = void 0;
const assert = require("assert/strict");
const buildFilterBy_1 = require("./buildFilterBy");
var NullOrder;
(function (NullOrder) {
    NullOrder[NullOrder["First"] = 0] = "First";
    NullOrder[NullOrder["Last"] = 1] = "Last";
})(NullOrder = exports.NullOrder || (exports.NullOrder = {}));
var Order;
(function (Order) {
    Order[Order["Asc"] = 0] = "Asc";
    Order[Order["Desc"] = 1] = "Desc";
})(Order = exports.Order || (exports.Order = {}));
function next(node, path) {
    assert(node && typeof node === 'object');
    const terms = [];
    loop: for (const [key, value] of Object.entries(node)) {
        switch (key) {
            case '$point': {
                const { $order, $point, $exclude_radius, $precision } = node;
                let expr = path.join('.');
                expr += '(';
                expr += $point.join(',');
                if ($precision)
                    expr += `,precision:${$precision}km`;
                if ($exclude_radius)
                    expr += `,exclude_radius:${$exclude_radius}km`;
                expr += ')';
                if ($order === Order.Asc)
                    expr += ':asc';
                if ($order === Order.Desc)
                    expr += ':desc';
                terms.push(expr);
                break loop;
            }
            case '$expr': {
                const { $expr, $order } = node;
                let expr = `_eval(${(0, buildFilterBy_1.buildFilterBy)($expr)})`;
                if ($order === Order.Asc)
                    expr += ':asc';
                if ($order === Order.Desc)
                    expr += ':desc';
                terms.push(expr);
                break loop;
            }
            default: {
                switch (key) {
                    case '$order':
                    case '$null':
                    case '$buckets':
                    case '$bucket_size': {
                        const { $order, $null, $buckets, $bucket_size } = node;
                        let expr = path.join('.');
                        let params;
                        if ($null !== undefined) {
                            params ??= [];
                            params.push($null === NullOrder.First ? 'missing_values:first' : 'missing_values:last');
                        }
                        if ($buckets !== undefined) {
                            params ??= [];
                            params.push(`buckets:${$buckets}`);
                        }
                        if ($bucket_size !== undefined) {
                            params ??= [];
                            params.push(`bucket_size:${$bucket_size}`);
                        }
                        if (params) {
                            expr += `(${params.join(',')})`;
                        }
                        if ($order === Order.Asc)
                            expr += ':asc';
                        if ($order === Order.Desc)
                            expr += ':desc';
                        terms.push(expr);
                        break loop;
                    }
                    default: {
                        const expr = next(value, path.concat(key));
                        if (expr)
                            terms.push(expr);
                        break;
                    }
                }
                break;
            }
        }
    }
    return terms.join(',');
}
/**
 * Builds a sort expression with a list of fields and their corresponding sort orders that will be used for ordering your results.
 *
 * https://typesense.org/docs/0.24.0/api/search.html#sort-results
 */
function buildSortBy(query) {
    return next(query, []);
}
exports.buildSortBy = buildSortBy;