mongoose-smart-query 1.3.3 → 1.4.1

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import mongooseSmartQuery from './plugin';
+export * from './types';
+export * from './utils';
+export * from './typesense';
+export default mongooseSmartQuery;

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var plugin_1 = __importDefault(require("./plugin"));
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./typesense"), exports);
+exports.default = plugin_1.default;

package/dist/plugin/index.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from 'mongoose';
+import type { PluginOptions } from '../types';
+export default function mongooseSmartQuery(schema: Schema, rawOptions: PluginOptions): void;

package/dist/plugin/index.js

@@ -0,0 +1,22 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = mongooseSmartQuery;
+var pipeline_1 = require("./pipeline");
+var methods_1 = require("./methods");
+function mongooseSmartQuery(schema, rawOptions) {
+    var options = __assign({ protectedFields: '', defaultFields: '_id', defaultSort: '-_id', defaultLimit: 20, fieldsForDefaultQuery: '', pageQueryName: '$page', limitQueryName: '$limit', fieldsQueryName: '$fields', sortQueryName: '$sort', queryName: '$q', textQueryName: '$text', unwindName: '$unwind', allFieldsQueryName: '$getAllFields', normalizeSearchQuery: false }, rawOptions);
+    schema.statics.__smartQueryGetPipeline = (0, pipeline_1.createSmartQueryGetPipeline)(schema, options);
+    schema.statics.smartQuery = (0, methods_1.createSmartQuery)(options);
+    schema.statics.smartCount = (0, methods_1.createSmartCount)(options);
+}

package/dist/plugin/methods.d.ts

@@ -0,0 +1,8 @@
+import { Model } from 'mongoose';
+import type { PluginOptions, SmartQueryOptions, SmartQueryResult } from '../types';
+export declare function createSmartQuery(options: PluginOptions): <T>(this: Model<T>, query?: {
+    [key: string]: string;
+}, smartOptions?: SmartQueryOptions) => Promise<T[] | SmartQueryResult<T>>;
+export declare function createSmartCount(options: PluginOptions): <T>(this: Model<T>, query?: {
+    [key: string]: string;
+}) => Promise<any>;

package/dist/plugin/methods.js

@@ -0,0 +1,253 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSmartQuery = createSmartQuery;
+exports.createSmartCount = createSmartCount;
+var mongoose_1 = require("mongoose");
+var utils_1 = require("../utils");
+var typesense_1 = require("../typesense");
+function createSmartQuery(options) {
+    var _a = options.defaultLimit, defaultLimit = _a === void 0 ? 20 : _a, _b = options.pageQueryName, pageQueryName = _b === void 0 ? '$page' : _b, _c = options.limitQueryName, limitQueryName = _c === void 0 ? '$limit' : _c, collation = options.collation, typesense = options.typesense;
+    return function () {
+        return __awaiter(this, arguments, void 0, function (query, smartOptions) {
+            var _a, prePipeline, _b, autoPaginate, docs, pagination, lookupsConfirmados, useMongoDirectly, typesenseIds, typesenseTotal, searchParams, searchResults, error_1, tsIdsArg, dataPromise, countPromise, _c, dataResult, countResult, total, page, limit, pages, tsIdsArg, _d, pipeline, lookups, agg, queryEmpresa, foraneos, index, docsEx, confirmado, _loop_1, _i, docs_1, doc;
+            var _this = this;
+            var _e, _f;
+            if (query === void 0) { query = {}; }
+            if (smartOptions === void 0) { smartOptions = {}; }
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        _a = smartOptions.prePipeline, prePipeline = _a === void 0 ? [] : _a, _b = smartOptions.autoPaginate, autoPaginate = _b === void 0 ? false : _b;
+                        docs = [];
+                        pagination = null;
+                        useMongoDirectly = true;
+                        typesenseIds = [];
+                        typesenseTotal = 0;
+                        if (!(typesense_1.globalTypesenseClient && typesense)) return [3 /*break*/, 4];
+                        if (!!(0, typesense_1.hasUnindexedFields)(query, typesense.schema, options)) return [3 /*break*/, 4];
+                        _g.label = 1;
+                    case 1:
+                        _g.trys.push([1, 3, , 4]);
+                        searchParams = (0, typesense_1.buildTypesenseSearchParameters)(query, typesense.schema, options);
+                        return [4 /*yield*/, typesense_1.globalTypesenseClient
+                                .collections(typesense.schema.name)
+                                .documents()
+                                .search(searchParams)];
+                    case 2:
+                        searchResults = _g.sent();
+                        typesenseIds =
+                            ((_e = searchResults.hits) === null || _e === void 0 ? void 0 : _e.map(function (h) { return h.document.id; })) || [];
+                        typesenseTotal = searchResults.found || 0;
+                        useMongoDirectly = false;
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _g.sent();
+                        console.error('Error fetching from Typesense, falling back to MongoDB:', error_1);
+                        useMongoDirectly = true;
+                        return [3 /*break*/, 4];
+                    case 4:
+                        if (!useMongoDirectly && typesenseTotal === 0) {
+                            if (autoPaginate) {
+                                return [2 /*return*/, {
+                                        data: [],
+                                        pagination: {
+                                            total: 0,
+                                            page: parseInt(query[pageQueryName]) || 1,
+                                            pages: 0,
+                                            limit: parseInt(query[limitQueryName]) || defaultLimit,
+                                        },
+                                    }];
+                            }
+                            return [2 /*return*/, []];
+                        }
+                        if (!autoPaginate) return [3 /*break*/, 6];
+                        tsIdsArg = useMongoDirectly ? undefined : typesenseIds;
+                        dataPromise = this
+                            .__smartQueryGetPipeline(__assign({}, query), false, prePipeline, tsIdsArg)
+                            .then(function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+                            var agg;
+                            var _c;
+                            var pipeline = _b.pipeline, lookups = _b.lookupsConfirmados;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        agg = this.aggregate(pipeline);
+                                        if (collation)
+                                            agg.collation(collation);
+                                        _c = {};
+                                        return [4 /*yield*/, agg];
+                                    case 1: return [2 /*return*/, (_c.docs = _d.sent(),
+                                            _c.lookups = lookups,
+                                            _c)];
+                                }
+                            });
+                        }); });
+                        countPromise = void 0;
+                        if (!useMongoDirectly) {
+                            countPromise = Promise.resolve([{ size: typesenseTotal }]);
+                        }
+                        else {
+                            countPromise = this
+                                .__smartQueryGetPipeline(__assign({}, query), true, // forCount
+                            prePipeline)
+                                .then(function (_a) {
+                                var pipeline = _a.pipeline;
+                                return _this.aggregate(pipeline);
+                            });
+                        }
+                        return [4 /*yield*/, Promise.all([
+                                dataPromise,
+                                countPromise,
+                            ])];
+                    case 5:
+                        _c = _g.sent(), dataResult = _c[0], countResult = _c[1];
+                        docs = dataResult.docs;
+                        lookupsConfirmados = dataResult.lookups;
+                        total = ((_f = countResult[0]) === null || _f === void 0 ? void 0 : _f.size) || 0;
+                        page = parseInt(query[pageQueryName]) || 1;
+                        limit = parseInt(query[limitQueryName]) || defaultLimit;
+                        pages = Math.ceil(total / limit);
+                        pagination = { total: total, page: page, pages: pages, limit: limit };
+                        return [3 /*break*/, 9];
+                    case 6:
+                        tsIdsArg = useMongoDirectly ? undefined : typesenseIds;
+                        return [4 /*yield*/, this.__smartQueryGetPipeline(__assign({}, query), false, prePipeline, tsIdsArg)];
+                    case 7:
+                        _d = _g.sent(), pipeline = _d.pipeline, lookups = _d.lookupsConfirmados;
+                        lookupsConfirmados = lookups;
+                        agg = this.aggregate(pipeline);
+                        if (collation)
+                            agg.collation(collation);
+                        return [4 /*yield*/, agg];
+                    case 8:
+                        docs = _g.sent();
+                        _g.label = 9;
+                    case 9:
+                        queryEmpresa = query.business
+                            ? { business: new mongoose_1.Types.ObjectId(query.business) }
+                            : {};
+                        return [4 /*yield*/, Promise.all(lookupsConfirmados.map(function (item) {
+                                var ids = docs.reduce(function (acc, val) {
+                                    var valor = (0, utils_1.getCampo)(val, item.field);
+                                    if (valor)
+                                        acc.push(valor);
+                                    return acc;
+                                }, []);
+                                return ids.length !== 0
+                                    ? mongoose_1.connection
+                                        .collection(item.from)
+                                        .find(__assign({ _id: { $in: ids } }, queryEmpresa))
+                                        .project(item.project)
+                                        .toArray()
+                                    : [];
+                            }))];
+                    case 10:
+                        foraneos = _g.sent();
+                        for (index in lookupsConfirmados) {
+                            docsEx = foraneos[index];
+                            confirmado = lookupsConfirmados[index];
+                            _loop_1 = function (doc) {
+                                var keyPrincipal = (0, utils_1.getCampo)(doc, confirmado.field);
+                                if (keyPrincipal)
+                                    (0, utils_1.reemplazarSubdoc)(doc, confirmado.field, docsEx.find(function (item) { return item._id.equals(keyPrincipal); }));
+                            };
+                            for (_i = 0, docs_1 = docs; _i < docs_1.length; _i++) {
+                                doc = docs_1[_i];
+                                _loop_1(doc);
+                            }
+                        }
+                        if (autoPaginate) {
+                            return [2 /*return*/, { data: docs, pagination: pagination }];
+                        }
+                        return [2 /*return*/, docs];
+                }
+            });
+        });
+    };
+}
+function createSmartCount(options) {
+    var typesense = options.typesense;
+    return function () {
+        return __awaiter(this, arguments, void 0, function (query) {
+            var searchParams, searchResults, error_2, pipeline, result;
+            if (query === void 0) { query = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(typesense_1.globalTypesenseClient &&
+                            typesense &&
+                            !(0, typesense_1.hasUnindexedFields)(query, typesense.schema, options))) return [3 /*break*/, 4];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        searchParams = (0, typesense_1.buildTypesenseSearchParameters)(query, typesense.schema, options);
+                        return [4 /*yield*/, typesense_1.globalTypesenseClient
+                                .collections(typesense.schema.name)
+                                .documents()
+                                .search(searchParams)];
+                    case 2:
+                        searchResults = _a.sent();
+                        return [2 /*return*/, searchResults.found || 0];
+                    case 3:
+                        error_2 = _a.sent();
+                        console.error('Error fetching count from Typesense, falling back to MongoDB:', error_2);
+                        return [3 /*break*/, 4];
+                    case 4: return [4 /*yield*/, this.__smartQueryGetPipeline(__assign({}, query), true)];
+                    case 5:
+                        pipeline = (_a.sent()).pipeline;
+                        return [4 /*yield*/, this.aggregate(pipeline)];
+                    case 6:
+                        result = _a.sent();
+                        return [2 /*return*/, result.length === 0 ? 0 : result[0].size];
+                }
+            });
+        });
+    };
+}

package/dist/plugin/pipeline.d.ts

@@ -0,0 +1,8 @@
+import { Model, PipelineStage, Schema } from 'mongoose';
+import type { PluginOptions } from '../types';
+export declare function createSmartQueryGetPipeline(schema: Schema, options: PluginOptions): <T>(this: Model<T>, query: {
+    [key: string]: string;
+}, forCount?: boolean, prePipeline?: PipelineStage[], typesenseIds?: string[]) => Promise<{
+    pipeline: PipelineStage[];
+    lookupsConfirmados: import("../types").LookupConfirmado[];
+}>;