@driveflux/search 5.0.40 → 5.0.42-next.0

package/dist/index.js

@@ -1,4 +1,3 @@
 export * from './search.js';
 export * from './search-mongodb.js';
 export * from './types.js';
-//# sourceMappingURL=index.js.map

package/dist/search-mongodb.js

@@ -1,71 +1,286 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, 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
+        };
+    }
+}
 import { prisma } from '@driveflux/db';
 import { instantiateSingleton, singleton } from '@driveflux/singleton';
 import { MongoClient } from 'mongodb';
-const getClient = async () => {
-    const client = instantiateSingleton('search__MongoClient', () => new MongoClient(process.env.DATABASE_URL));
-    const isConnected = singleton('search__MongoClientConnected', false);
-    if (!isConnected) {
-        client.on('connectionReady', () => {
-            // update the singleton value to true (second true is to force the value to be true)
-            singleton('search__MongoClientConnected', true, true);
+var getClient = function() {
+    return _async_to_generator(function() {
+        var client, isConnected;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    client = instantiateSingleton('search__MongoClient', function() {
+                        return new MongoClient(process.env.DATABASE_URL);
+                    });
+                    isConnected = singleton('search__MongoClientConnected', false);
+                    if (!!isConnected) return [
+                        3,
+                        2
+                    ];
+                    client.on('connectionReady', function() {
+                        // update the singleton value to true (second true is to force the value to be true)
+                        singleton('search__MongoClientConnected', true, true);
+                    });
+                    client.on('close', function() {
+                        singleton('search__MongoClientConnected', false, true);
+                    });
+                    return [
+                        4,
+                        client.connect()
+                    ];
+                case 1:
+                    _state.sent();
+                    _state.label = 2;
+                case 2:
+                    return [
+                        2,
+                        client
+                    ];
+            }
         });
-        client.on('close', () => {
-            singleton('search__MongoClientConnected', false, true);
-        });
-        await client.connect();
-    }
-    return client;
+    })();
 };
-const getCollectionName = (model) => {
+var getCollectionName = function(model) {
+    var _prisma__runtimeDataModel_models_model;
     // TODO
     // @ts-expect-error - This is a private property
-    return prisma._runtimeDataModel.models[model]?.dbName;
+    return (_prisma__runtimeDataModel_models_model = prisma._runtimeDataModel.models[model]) === null || _prisma__runtimeDataModel_models_model === void 0 ? void 0 : _prisma__runtimeDataModel_models_model.dbName;
 };
-export const searchMongodb = async (model, search) => {
-    const data = await searchMongoDbFull(model, search, ['id'], undefined);
-    return data.map((o) => o._id);
+export var searchMongodb = function(model, search) {
+    return _async_to_generator(function() {
+        var data;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        searchMongoDbFull(model, search, [
+                            'id'
+                        ], undefined)
+                    ];
+                case 1:
+                    data = _state.sent();
+                    return [
+                        2,
+                        data.map(function(o) {
+                            return o._id;
+                        })
+                    ];
+            }
+        });
+    })();
 };
-export const searchMongoDbFull = async (model, search, fields, skip = 0, limit = 10) => {
-    const client = await getClient();
-    const collectionName = getCollectionName(model);
-    if (!collectionName) {
-        return [];
-    }
-    const projectionFields = fields
-        .map((f) => (f === 'id' ? '_id' : f))
-        .reduce((acc, f) => {
-        Object.assign(acc, { [f]: 1 });
-        return acc;
-    }, {});
-    const result = await client
-        .db()
-        .collection(collectionName)
-        .find({
-        $text: {
-            $search: decodeURIComponent(search),
-            $caseSensitive: false,
-        },
-    }, {
-        projection: projectionFields,
-    })
-        .sort({ score: { $meta: 'textScore' } })
-        .skip(skip)
-        .limit(limit)
-        .toArray();
-    return result;
+export var searchMongoDbFull = function(model, search, fields) {
+    var skip = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0, limit = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : 10;
+    return _async_to_generator(function() {
+        var client, collectionName, projectionFields, result;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        getClient()
+                    ];
+                case 1:
+                    client = _state.sent();
+                    collectionName = getCollectionName(model);
+                    if (!collectionName) {
+                        return [
+                            2,
+                            []
+                        ];
+                    }
+                    projectionFields = fields.map(function(f) {
+                        return f === 'id' ? '_id' : f;
+                    }).reduce(function(acc, f) {
+                        Object.assign(acc, _define_property({}, f, 1));
+                        return acc;
+                    }, {});
+                    return [
+                        4,
+                        client.db().collection(collectionName).find({
+                            $text: {
+                                $search: decodeURIComponent(search),
+                                $caseSensitive: false
+                            }
+                        }, {
+                            projection: projectionFields
+                        }).sort({
+                            score: {
+                                $meta: 'textScore'
+                            }
+                        }).skip(skip).limit(limit).toArray()
+                    ];
+                case 2:
+                    result = _state.sent();
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
 };
-export const getMongoDbSearchResultCount = async (model, search) => {
-    const client = await getClient();
-    const collectionName = getCollectionName(model);
-    const count = await client
-        .db()
-        .collection(collectionName)
-        .countDocuments({
-        $text: {
-            $search: decodeURIComponent(search),
-            $caseSensitive: false,
-        },
-    });
-    return count;
+export var getMongoDbSearchResultCount = function(model, search) {
+    return _async_to_generator(function() {
+        var client, collectionName, count;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        getClient()
+                    ];
+                case 1:
+                    client = _state.sent();
+                    collectionName = getCollectionName(model);
+                    return [
+                        4,
+                        client.db().collection(collectionName).countDocuments({
+                            $text: {
+                                $search: decodeURIComponent(search),
+                                $caseSensitive: false
+                            }
+                        })
+                    ];
+                case 2:
+                    count = _state.sent();
+                    return [
+                        2,
+                        count
+                    ];
+            }
+        });
+    })();
 };
-//# sourceMappingURL=search-mongodb.js.map

package/dist/search.js

@@ -1,57 +1,340 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, 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
+        };
+    }
+}
 import { prisma } from '@driveflux/db';
 import { getIdRegex, ID_PREFIX_MAP } from '@driveflux/db/id';
 import { Ok } from '@driveflux/result';
 import { camelCase } from 'change-case';
 import { z } from 'zod';
 import { searchMongoDbFull } from './search-mongodb.js';
-import { SEARCH_RESULT_FIELDS_MAP, } from './types.js';
-const SEARCHABLE_MODELS = Object.keys(SEARCH_RESULT_FIELDS_MAP);
-const Query = z.object({
+import { SEARCH_RESULT_FIELDS_MAP } from './types.js';
+var SEARCHABLE_MODELS = Object.keys(SEARCH_RESULT_FIELDS_MAP);
+var Query = z.object({
     q: z.string(),
-    take: z.number().default(5),
+    take: z.number().default(5)
 });
-const ID_PREFIXES = Object.entries(ID_PREFIX_MAP)
-    .filter(([model]) => SEARCHABLE_MODELS.includes(model))
-    .map(([_, prefix]) => prefix);
-export const search = async (req) => {
-    const { q, take } = Query.parse(req.query);
-    const matches = q.match(getIdRegex(ID_PREFIXES));
-    let targetModel;
-    if (matches) {
-        const id = matches[0];
-        const prefix = matches[1];
-        targetModel = Object.keys(SEARCH_RESULT_FIELDS_MAP).find((key) => ID_PREFIX_MAP[key] === prefix);
-        if (targetModel) {
-            // TODO
-            // @ts-expect-error prisma can't union models
-            const result = await prisma[camelCase(targetModel)].findUnique({
-                where: {
-                    id,
-                },
-                select: Object.fromEntries(SEARCH_RESULT_FIELDS_MAP[targetModel].map((f) => [f, true])),
-            });
-            return new Ok({
-                [targetModel]: result ? [result] : [],
-            });
-        }
-    }
-    const results = await Promise.allSettled(SEARCHABLE_MODELS.map((m) => searchMongoDbFull(m, q, SEARCH_RESULT_FIELDS_MAP[m], take)));
-    return new Ok(Object.fromEntries(SEARCHABLE_MODELS.map((m, i) => {
-        const result = results[i];
-        return [
-            m,
-            result.status === 'fulfilled'
-                ? result.value.map((o) => {
-                    const { _id, ...rest } = o;
-                    return _id
-                        ? {
-                            ...rest,
-                            id: `${_id}`,
-                        }
-                        : rest;
-                })
-                : [],
-        ];
-    }).filter(([, v]) => v.length > 0)));
+var ID_PREFIXES = Object.entries(ID_PREFIX_MAP).filter(function(param) {
+    var _param = _sliced_to_array(param, 1), model = _param[0];
+    return SEARCHABLE_MODELS.includes(model);
+}).map(function(param) {
+    var _param = _sliced_to_array(param, 2), _ = _param[0], prefix = _param[1];
+    return prefix;
+});
+export var search = function(req) {
+    return _async_to_generator(function() {
+        var _Query_parse, q, take, matches, targetModel, id, prefix, result, results;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _Query_parse = Query.parse(req.query), q = _Query_parse.q, take = _Query_parse.take;
+                    matches = q.match(getIdRegex(ID_PREFIXES));
+                    if (!matches) return [
+                        3,
+                        2
+                    ];
+                    id = matches[0];
+                    prefix = matches[1];
+                    targetModel = Object.keys(SEARCH_RESULT_FIELDS_MAP).find(function(key) {
+                        return ID_PREFIX_MAP[key] === prefix;
+                    });
+                    if (!targetModel) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        prisma[camelCase(targetModel)].findUnique({
+                            where: {
+                                id: id
+                            },
+                            select: Object.fromEntries(SEARCH_RESULT_FIELDS_MAP[targetModel].map(function(f) {
+                                return [
+                                    f,
+                                    true
+                                ];
+                            }))
+                        })
+                    ];
+                case 1:
+                    result = _state.sent();
+                    return [
+                        2,
+                        new Ok(_define_property({}, targetModel, result ? [
+                            result
+                        ] : []))
+                    ];
+                case 2:
+                    return [
+                        4,
+                        Promise.allSettled(SEARCHABLE_MODELS.map(function(m) {
+                            return searchMongoDbFull(m, q, SEARCH_RESULT_FIELDS_MAP[m], take);
+                        }))
+                    ];
+                case 3:
+                    results = _state.sent();
+                    return [
+                        2,
+                        new Ok(Object.fromEntries(SEARCHABLE_MODELS.map(function(m, i) {
+                            var result = results[i];
+                            return [
+                                m,
+                                result.status === 'fulfilled' ? result.value.map(function(o) {
+                                    var _id = o._id, rest = _object_without_properties(o, [
+                                        "_id"
+                                    ]);
+                                    return _id ? _object_spread_props(_object_spread({}, rest), {
+                                        id: "".concat(_id)
+                                    }) : rest;
+                                }) : []
+                            ];
+                        }).filter(function(param) {
+                            var _param = _sliced_to_array(param, 2), v = _param[1];
+                            return v.length > 0;
+                        })))
+                    ];
+            }
+        });
+    })();
 };
-//# sourceMappingURL=search.js.map

package/dist/types.js

@@ -1,11 +1,11 @@
-export const SEARCH_RESULT_FIELDS_MAP = {
+export var SEARCH_RESULT_FIELDS_MAP = {
     Subscription: [
         'id',
         'userName',
         'vehicleName',
         'businessName',
         'fluxStatus',
-        'payerType',
+        'payerType'
     ],
     Vehicle: [
         'id',
@@ -16,7 +16,7 @@ export const SEARCH_RESULT_FIELDS_MAP = {
         'niceName',
         'registrationNumber',
         'status',
-        'hostId',
+        'hostId'
     ],
     User: [
         'id',
@@ -25,11 +25,25 @@ export const SEARCH_RESULT_FIELDS_MAP = {
         'email',
         'department',
         'groups',
-        'status',
+        'status'
+    ],
+    Business: [
+        'id',
+        'name',
+        'registrationNumber'
+    ],
+    Host: [
+        'id',
+        'name',
+        'email',
+        'accountManagerId'
+    ],
+    Coupon: [
+        'id',
+        'code',
+        'name',
+        'status'
     ],
-    Business: ['id', 'name', 'registrationNumber'],
-    Host: ['id', 'name', 'email', 'accountManagerId'],
-    Coupon: ['id', 'code', 'name', 'status'],
     Invoice: [
         'id',
         'notes',
@@ -37,7 +51,7 @@ export const SEARCH_RESULT_FIELDS_MAP = {
         'paid',
         'status',
         'total',
-        'payerName',
+        'payerName'
     ],
     Payout: [
         'id',
@@ -45,10 +59,23 @@ export const SEARCH_RESULT_FIELDS_MAP = {
         'paidOut',
         'hostId',
         'reversalTotal',
-        'toPayAt',
+        'toPayAt'
+    ],
+    ServiceCenter: [
+        'id',
+        'name',
+        'address'
     ],
-    ServiceCenter: ['id', 'name', 'address'],
-    SubscriptionReservation: ['id', 'vehicleId', 'subscriptionId', 'status'],
-    Log: ['id', 'userId', 'resourceId', 'resourceType'],
+    SubscriptionReservation: [
+        'id',
+        'vehicleId',
+        'subscriptionId',
+        'status'
+    ],
+    Log: [
+        'id',
+        'userId',
+        'resourceId',
+        'resourceType'
+    ]
 };
-//# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driveflux/search",
-  "version": "5.0.40",
+  "version": "5.0.42-next.0",
   "type": "module",
   "exports": {
     ".": {
@@ -12,7 +12,7 @@
     "dist"
   ],
   "dependencies": {
-    "@driveflux/db": "4.0.16-feature-microlino.0",
+    "@driveflux/db": "4.0.17-feature-microlino.1",
     "@driveflux/result": "6.0.0",
     "change-case": "^5.4.4",
     "mongodb": "^6.20.0",