mongoose-smart-query 1.3.2 → 1.4.0

package/dist/plugin/pipeline.js

@@ -0,0 +1,434 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSmartQueryGetPipeline = createSmartQueryGetPipeline;
+var mongoose_1 = require("mongoose");
+var utils_1 = require("../utils");
+function createSmartQueryGetPipeline(schema, options) {
+    var _a = options.protectedFields, protectedFields = _a === void 0 ? '' : _a, _b = options.defaultFields, defaultFields = _b === void 0 ? '_id' : _b, _c = options.defaultSort, defaultSort = _c === void 0 ? '-_id' : _c, _d = options.defaultLimit, defaultLimit = _d === void 0 ? 20 : _d, _e = options.fieldsForDefaultQuery, fieldsForDefaultQuery = _e === void 0 ? '' : _e, _f = options.pageQueryName, pageQueryName = _f === void 0 ? '$page' : _f, _g = options.limitQueryName, limitQueryName = _g === void 0 ? '$limit' : _g, _h = options.fieldsQueryName, fieldsQueryName = _h === void 0 ? '$fields' : _h, _j = options.sortQueryName, sortQueryName = _j === void 0 ? '$sort' : _j, _k = options.queryName, queryName = _k === void 0 ? '$q' : _k, _l = options.textQueryName, textQueryName = _l === void 0 ? '$text' : _l, _m = options.unwindName, unwindName = _m === void 0 ? '$unwind' : _m, _o = options.allFieldsQueryName, allFieldsQueryName = _o === void 0 ? '$getAllFields' : _o, _p = options.normalizeSearchQuery, normalizeSearchQuery = _p === void 0 ? false : _p;
+    var __protected = (0, utils_1.stringToQuery)(protectedFields);
+    return function (query_1) {
+        return __awaiter(this, arguments, void 0, function (query, forCount, prePipeline, typesenseIds) {
+            function getFieldsProject(query) {
+                if (!query[fieldsQueryName] && defaultFields) {
+                    query[fieldsQueryName] = defaultFields;
+                }
+                var $project = (0, utils_1.stringToQuery)(query[fieldsQueryName]);
+                $project = (0, utils_1.removeKeys)($project, __protected);
+                return $project;
+            }
+            var hasTextIndex, queryEmpresa, $page, $limit, getDefault, getMatch, getUnwind, _a, $match, usingTextSearch, $project, lookupsConfirmados, pipeline, getSort, sort, projectStage, finalProject;
+            var _this = this;
+            var _b;
+            if (forCount === void 0) { forCount = false; }
+            if (prePipeline === void 0) { prePipeline = []; }
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        hasTextIndex = schema.indexes().some(function (_a) {
+                            var index = _a[0];
+                            return Object.values(index).includes('text');
+                        });
+                        queryEmpresa = query.business
+                            ? { business: new mongoose_1.Types.ObjectId(query.business) }
+                            : {};
+                        $page = parseInt(query[pageQueryName]) || 1;
+                        $limit = parseInt(query[limitQueryName]) || defaultLimit;
+                        getDefault = function () { return __awaiter(_this, void 0, void 0, function () {
+                            var $localMatch, lookupFinalMatch, $or, _loop_1, keyInicial;
+                            var _this = this;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        $localMatch = {};
+                                        lookupFinalMatch = {};
+                                        $or = [];
+                                        _loop_1 = function (keyInicial) {
+                                            var _b, _c;
+                                            var path = schema.path(keyInicial);
+                                            if (!path && !keyInicial.includes('.'))
+                                                return "continue";
+                                            var key = keyInicial;
+                                            var lookupKey = void 0;
+                                            var valorQuery = query[key];
+                                            if (keyInicial.includes('.')) {
+                                                var _d = keyInicial.split('.'), keyForanea = _d[0], subKey = _d[1];
+                                                var foraneaKey = schema.path(keyForanea);
+                                                if (foraneaKey && foraneaKey.options.ref) {
+                                                    key = subKey;
+                                                    lookupKey = keyForanea;
+                                                    lookupFinalMatch[lookupKey] = {
+                                                        collection: foraneaKey.options.ref,
+                                                        $match: {},
+                                                    };
+                                                }
+                                            }
+                                            var $toAdd = lookupKey
+                                                ? lookupFinalMatch[lookupKey].$match
+                                                : $localMatch;
+                                            var queryRegex = /(?:\{(\$?[\w ]+)\})?([^{}\n]+)/g;
+                                            var match = void 0;
+                                            var values = [];
+                                            if (typeof valorQuery === 'string') {
+                                                var $filtroActual = {};
+                                                var valor = valorQuery;
+                                                var tieneOperadorOr = valor.startsWith('{$or}');
+                                                if (tieneOperadorOr)
+                                                    valor = valor.replace('{$or}', '');
+                                                while ((match = queryRegex.exec(valor)) !== null) {
+                                                    values.push([match[0], match[1], match[2]]);
+                                                }
+                                                for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
+                                                    var _e = values_1[_i], operator = _e[1], value = _e[2];
+                                                    switch (operator) {
+                                                        case '$exists':
+                                                            $filtroActual[key] = { $exists: value !== 'false' };
+                                                            break;
+                                                        case '$includes':
+                                                            $filtroActual[key] = {
+                                                                $regex: RegExp(value.replace(/[^\w]/g, '.'), 'i'),
+                                                            };
+                                                            break;
+                                                        case '$in':
+                                                        case '$nin': {
+                                                            var findin = value
+                                                                .split(',')
+                                                                .map(function (item) { return (0, utils_1.parseValue)(item.trim(), path === null || path === void 0 ? void 0 : path.instance); });
+                                                            $filtroActual[key] = (_b = {}, _b[operator] = findin, _b);
+                                                            break;
+                                                        }
+                                                        default: {
+                                                            var parsedValue = (0, utils_1.parseValue)(value, path === null || path === void 0 ? void 0 : path.instance);
+                                                            if (operator) {
+                                                                if (typeof $filtroActual[key] === 'object') {
+                                                                    $filtroActual[key][operator] = parsedValue;
+                                                                }
+                                                                else {
+                                                                    $filtroActual[key] = (_c = {}, _c[operator] = parsedValue, _c);
+                                                                }
+                                                            }
+                                                            else {
+                                                                if (typeof value === 'string' && value.includes('$exists')) {
+                                                                    $filtroActual[key] = { $exists: true, $ne: [] };
+                                                                }
+                                                                else {
+                                                                    $filtroActual[key] = parsedValue;
+                                                                }
+                                                            }
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                if (tieneOperadorOr) {
+                                                    $or.push($filtroActual);
+                                                }
+                                                else {
+                                                    Object.assign($toAdd, $filtroActual);
+                                                }
+                                            }
+                                            else {
+                                                $toAdd[key] = (0, utils_1.parseValue)(valorQuery, path === null || path === void 0 ? void 0 : path.instance);
+                                            }
+                                        };
+                                        for (keyInicial in query) {
+                                            _loop_1(keyInicial);
+                                        }
+                                        if ($or.length !== 0)
+                                            $localMatch.$or = $or;
+                                        if (!(Object.keys(lookupFinalMatch).length !== 0)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, Promise.all(Object.entries(lookupFinalMatch).map(function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+                                                var docs;
+                                                var key = _b[0], value = _b[1];
+                                                return __generator(this, function (_c) {
+                                                    switch (_c.label) {
+                                                        case 0: return [4 /*yield*/, mongoose_1.connection
+                                                                .collection(value.collection)
+                                                                .find(__assign(__assign({}, value.$match), queryEmpresa))
+                                                                .project({ _id: 1 })
+                                                                .toArray()];
+                                                        case 1:
+                                                            docs = _c.sent();
+                                                            $localMatch[key] = { $in: docs.map(function (item) { return item._id; }) };
+                                                            return [2 /*return*/];
+                                                    }
+                                                });
+                                            }); }))];
+                                    case 1:
+                                        _a.sent();
+                                        _a.label = 2;
+                                    case 2: return [2 /*return*/, $localMatch];
+                                }
+                            });
+                        }); };
+                        getMatch = function () { return __awaiter(_this, void 0, void 0, function () {
+                            var $queryMatch, _lookupsMatch, usingTextSearch, fields, searchValue, regexParseado, subWordArray, regexFlags_1, regex, _loop_2, _i, fields_1, field, $queryDefault, $or;
+                            var _this = this;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (typesenseIds) {
+                                            return [2 /*return*/, {
+                                                    match: {
+                                                        _id: { $in: typesenseIds.map(function (id) { return new mongoose_1.Types.ObjectId(id); }) },
+                                                    },
+                                                    usingTextSearch: false,
+                                                }];
+                                        }
+                                        $queryMatch = {};
+                                        _lookupsMatch = {};
+                                        usingTextSearch = false;
+                                        if (!(hasTextIndex && query[textQueryName])) return [3 /*break*/, 1];
+                                        $queryMatch = { $text: { $search: query[textQueryName] } };
+                                        usingTextSearch = true;
+                                        return [3 /*break*/, 3];
+                                    case 1:
+                                        if (!(query[queryName] && fieldsForDefaultQuery)) return [3 /*break*/, 3];
+                                        fields = fieldsForDefaultQuery.split(' ');
+                                        searchValue = normalizeSearchQuery
+                                            ? (0, utils_1.normalizeSearchText)(query[queryName])
+                                            : query[queryName];
+                                        regexParseado = searchValue
+                                            .replace(/[()[\\\]]/g, '.')
+                                            .replace(/[+]/g, '\\+')
+                                            .replace(/[*]/g, '\\*');
+                                        subWordArray = regexParseado.split(' ');
+                                        regexFlags_1 = normalizeSearchQuery ? '' : 'i';
+                                        regex = { $regex: RegExp(regexParseado, regexFlags_1) };
+                                        _loop_2 = function (field) {
+                                            var _b, _c, _d;
+                                            var path = schema.path(field);
+                                            if (path) {
+                                                if (!$queryMatch.$or)
+                                                    $queryMatch.$or = [];
+                                                if (subWordArray.length <= 1) {
+                                                    $queryMatch.$or.push((_b = {}, _b[field] = regex, _b));
+                                                }
+                                                else {
+                                                    $queryMatch.$or.push({
+                                                        $and: subWordArray.map(function (word) {
+                                                            var _a;
+                                                            return (_a = {},
+                                                                _a[field] = { $regex: RegExp(word, regexFlags_1) },
+                                                                _a);
+                                                        }),
+                                                    });
+                                                }
+                                            }
+                                            else if (field.includes('.')) {
+                                                var _e = field.split('.'), subField = _e[0], busqueda = _e[1];
+                                                var subpath = schema.path(subField);
+                                                if (subpath && subpath.options.ref) {
+                                                    if (!_lookupsMatch[subField])
+                                                        _lookupsMatch[subField] = {
+                                                            collection: subpath.options.ref,
+                                                            $match: { $or: [(_c = {}, _c[busqueda] = regex, _c)] },
+                                                        };
+                                                    else
+                                                        _lookupsMatch[subField].$match.$or.push((_d = {}, _d[busqueda] = regex, _d));
+                                                }
+                                            }
+                                        };
+                                        for (_i = 0, fields_1 = fields; _i < fields_1.length; _i++) {
+                                            field = fields_1[_i];
+                                            _loop_2(field);
+                                        }
+                                        if (!(Object.keys(_lookupsMatch).length !== 0)) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, Promise.all(Object.entries(_lookupsMatch).map(function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+                                                var docs, idsDocs;
+                                                var _c;
+                                                var key = _b[0], value = _b[1];
+                                                return __generator(this, function (_d) {
+                                                    switch (_d.label) {
+                                                        case 0: return [4 /*yield*/, mongoose_1.connection
+                                                                .collection(value.collection)
+                                                                .find(__assign(__assign({}, value.$match), queryEmpresa))
+                                                                .project({ _id: 1 })
+                                                                .toArray()];
+                                                        case 1:
+                                                            docs = _d.sent();
+                                                            idsDocs = docs.map(function (item) { return item._id; });
+                                                            if (idsDocs.length) {
+                                                                if (!$queryMatch.$or)
+                                                                    $queryMatch.$or = [];
+                                                                $queryMatch.$or.push((_c = {}, _c[key] = { $in: idsDocs }, _c));
+                                                            }
+                                                            return [2 /*return*/];
+                                                    }
+                                                });
+                                            }); }))];
+                                    case 2:
+                                        _a.sent();
+                                        _a.label = 3;
+                                    case 3: return [4 /*yield*/, getDefault()];
+                                    case 4:
+                                        $queryDefault = _a.sent();
+                                        $or = $queryDefault.$or;
+                                        if ($or) {
+                                            delete $queryDefault.$or;
+                                            if (Array.isArray($queryMatch.$or)) {
+                                                $queryMatch.$or = $queryMatch.$or.concat($or);
+                                            }
+                                            else {
+                                                $queryMatch.$or = $or;
+                                            }
+                                        }
+                                        return [2 /*return*/, { match: __assign(__assign({}, $queryDefault), $queryMatch), usingTextSearch: usingTextSearch }];
+                                }
+                            });
+                        }); };
+                        getUnwind = function () {
+                            return !query[unwindName]
+                                ? []
+                                : [
+                                    {
+                                        $unwind: {
+                                            path: "$".concat(query[unwindName]),
+                                            preserveNullAndEmptyArrays: true,
+                                        },
+                                    },
+                                ];
+                        };
+                        return [4 /*yield*/, getMatch()];
+                    case 1:
+                        _a = _c.sent(), $match = _a.match, usingTextSearch = _a.usingTextSearch;
+                        $project = getFieldsProject(query);
+                        lookupsConfirmados = (0, utils_1.getListOfPossibleLookups)(schema, $project);
+                        pipeline = [];
+                        if (Object.keys($match).length !== 0) {
+                            pipeline.push({ $match: $match });
+                        }
+                        pipeline.push.apply(pipeline, prePipeline);
+                        if (forCount) {
+                            pipeline.push.apply(pipeline, __spreadArray(__spreadArray([], getUnwind(), false), [{ $count: 'size' }], false));
+                        }
+                        else {
+                            getSort = function () {
+                                if (usingTextSearch) {
+                                    return { $localSort: { score: { $meta: 'textScore' }, _id: -1 } };
+                                }
+                                if (!query[sortQueryName]) {
+                                    if (!defaultSort)
+                                        return {};
+                                    query[sortQueryName] = defaultSort;
+                                }
+                                var regex = /(-)?([\w.]+)/g;
+                                var $localSort = {};
+                                var $foreignSort = {};
+                                var matched;
+                                while ((matched = regex.exec(query[sortQueryName])) !== null) {
+                                    var order = matched[1];
+                                    var localfield = matched[2];
+                                    var path = !!schema.path(localfield);
+                                    if (path) {
+                                        $localSort[localfield] = order ? -1 : 1;
+                                    }
+                                    else {
+                                        $foreignSort[localfield] = order ? -1 : 1;
+                                    }
+                                }
+                                return {
+                                    $localSort: Object.keys($localSort).length !== 0 ? $localSort : undefined,
+                                    $foreignSort: Object.keys($foreignSort).length !== 0 ? $foreignSort : undefined,
+                                };
+                            };
+                            sort = getSort();
+                            projectStage = [];
+                            if (!(((_b = query[allFieldsQueryName]) === null || _b === void 0 ? void 0 : _b.toString()) === 'true')) {
+                                (0, utils_1.asignarLookups)($project, lookupsConfirmados);
+                                finalProject = __assign({}, $project);
+                                if (usingTextSearch) {
+                                    finalProject.score = { $meta: 'textScore' };
+                                }
+                                projectStage.push({ $project: finalProject });
+                            }
+                            else {
+                                if (protectedFields) {
+                                    projectStage.push({
+                                        $project: (0, utils_1.stringToQuery)(protectedFields, '0'),
+                                    });
+                                }
+                                if (usingTextSearch) {
+                                    projectStage.push({
+                                        $addFields: { score: { $meta: 'textScore' } },
+                                    });
+                                }
+                            }
+                            if (typesenseIds) {
+                                pipeline.push.apply(pipeline, __spreadArray(__spreadArray(__spreadArray([], getUnwind(), false), [{
+                                        $addFields: {
+                                            __order: {
+                                                $indexOfArray: [
+                                                    typesenseIds.map(function (id) { return new mongoose_1.Types.ObjectId(id); }),
+                                                    '$_id',
+                                                ],
+                                            },
+                                        },
+                                    },
+                                    { $sort: { __order: 1 } }], false), projectStage, false));
+                            }
+                            else {
+                                pipeline.push.apply(pipeline, __spreadArray(__spreadArray(__spreadArray(__spreadArray([], (sort.$localSort ? [{ $sort: sort.$localSort }] : []), false), getUnwind(), false), [{ $skip: ($page - 1) * $limit },
+                                    { $limit: $limit }], false), projectStage, false));
+                            }
+                        }
+                        return [2 /*return*/, { pipeline: pipeline, lookupsConfirmados: lookupsConfirmados }];
+                }
+            });
+        });
+    };
+}

package/dist/{mongoose-smart-query.d.ts → types/index.d.ts}

@@ -1,24 +1,43 @@
-import { Schema, PipelineStage } from 'mongoose';
-/**
- * Normalizes text for search indexing and querying.
- * Converts to lowercase, removes diacritics/accents, and removes any non-alphanumeric character (except the spacer).
- * Multiple spaces/spacers are collapsed into one.
- * @param input String or array of strings to concatenate and normalize.
- * @param spacer String used to join array values or replace spaces. Default is ' '.
- * @returns The normalized string.
- */
-export declare function normalizeSearchText(input: string | Array<string | undefined>, spacer?: string, maxSearchLength?: number): string;
-interface SmartQueryOptions {
+import { PipelineStage } from 'mongoose';
+import type { CollectionCreateSchema } from 'typesense/lib/Typesense/Collections';
+export interface SmartQueryFieldSchema {
+    name: string;
+    type: string;
+    facet?: boolean;
+    optional?: boolean;
+    index?: boolean;
+    sort?: boolean;
+    infix?: boolean;
+    locale?: string;
+    drop?: boolean;
+    mongoField?: string;
+    [key: string]: any;
+}
+export interface PluginTypesenseOptions {
+    schema: Omit<CollectionCreateSchema, 'fields'> & {
+        fields?: SmartQueryFieldSchema[];
+    };
+}
+export interface LookupConfirmado {
+    field: string;
+    from: string;
+    project: Record<string, unknown>;
+}
+export type QueryForeign = Record<string, {
+    collection: string;
+    $match: Record<string, any>;
+}>;
+export interface SmartQueryOptions {
     prePipeline?: PipelineStage[];
     autoPaginate?: boolean;
 }
-interface SmartQueryPagination {
+export interface SmartQueryPagination {
     total: number;
     page: number;
     pages: number;
     limit: number;
 }
-interface SmartQueryResult<T = any> {
+export interface SmartQueryResult<T = any> {
     data: T[];
     pagination: SmartQueryPagination;
 }
@@ -30,8 +49,14 @@ export interface SmartQueryStatics {
         autoPaginate?: false;
     }): Promise<T[]>;
     smartCount(query?: Record<string, any>): Promise<number>;
+    __smartQueryGetPipeline(query: {
+        [key: string]: string;
+    }, forCount?: boolean, prePipeline?: PipelineStage[], typesenseIds?: string[]): Promise<{
+        pipeline: PipelineStage[];
+        lookupsConfirmados: LookupConfirmado[];
+    }>;
 }
-interface PluginOptions {
+export interface PluginOptions {
     /**
      * Fields that should not be included in the query results. Default: `''`.
      */
@@ -88,24 +113,15 @@ interface PluginOptions {
      * If true, applies `normalizeSearchText` to the `$q` search value before executing the query. Default: `false`.
      */
     normalizeSearchQuery?: boolean;
+    /**
+     * Collation to be applied to the aggregate queries. Default: `undefined`.
+     */
+    collation?: any;
+    /**
+     * Configuration for Typesense integration.
+     */
+    typesense?: PluginTypesenseOptions;
 }
-interface TObject {
+export interface TObject {
     [value: string]: any;
 }
-/**
- * Converts a string to object. Example:
- * 'name age friends { name }' => { name: 1, age: 1, friends: { name: 1 } }
- * @param query String to convert to object.
- * @returns The resulting object.
- */
-export declare function stringToQuery(query?: string, value?: string): object;
-/**
- * Remove the keys from the initial object. If after this process the property
- * is empty it is removed
- * @param initial The main object
- * @param toRemove The object with the keys to remove
- * @returns The object without the keys
- */
-export declare function removeKeys(initial: TObject, toRemove: TObject): TObject;
-export default function (schema: Schema, { protectedFields, defaultFields, defaultSort, defaultLimit, fieldsForDefaultQuery, pageQueryName, limitQueryName, fieldsQueryName, sortQueryName, queryName, textQueryName, unwindName, allFieldsQueryName, normalizeSearchQuery, }: PluginOptions): void;
-export {};

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/typesense/builder.d.ts

@@ -0,0 +1,5 @@
+import type { SearchParams } from 'typesense/lib/Typesense/Documents';
+import type { PluginOptions, PluginTypesenseOptions } from '../types';
+export declare const buildTypesenseSearchParameters: (query: {
+    [key: string]: string;
+}, tsSchema: PluginTypesenseOptions["schema"], options: PluginOptions) => SearchParams<any>;