@livequery/mongoose 2.0.21 → 2.0.23

package/build/src/MongoQuery.js

@@ -92,57 +92,75 @@ export class MongoQuery {
         return stack.pop();
     }
     static #parse_summary(req) {
-        const mappers = Object
+        const parsed = Object
             .entries(req.options)
-            .map(([k, v]) => {
-            if (!k.startsWith('::'))
+            .map(([key, v], index) => {
+            if (!key.startsWith('::'))
                 return [];
-            const [a, ...groups] = `${v}`.split('|');
-            const [expr, infix] = a.split(')')[0].split('(');
-            if (!['sum', 'avg', 'max', 'min', 'count'].includes(expr))
-                return [];
-            const query = this.#postfix_to_mongodb(this.#infix_to_postfix(infix));
-            const group_by = groups.length == 0 ? 'NO_GROUP' : groups.join('|');
-            return [{
-                    id: Buffer.from(k, 'utf-8').toString('hex'),
-                    group_id: Buffer.from(group_by, 'utf-8').toString('hex'),
-                    name: k.split('::')[1] || '#',
-                    expr: expr.toLowerCase(),
-                    query,
-                    groups,
-                    group_by
-                }];
-        })
-            .flat(2);
-        const expresisons = mappers.reduce((p, { expr, query, groups, group_id, id }) => {
-            p.set(group_id, {
-                ...p.has(group_id) ? p.get(group_id) : {
-                    _id: groups.length == 0 ? null : groups.reduce((p, by) => {
-                        return {
+            const exprs = `${v}`.split('|').filter(Boolean);
+            const fns = exprs.map(l => {
+                const exp = l.split('(')[0];
+                if (!['sum', 'avg', 'max', 'min', 'count', 'distinct'].includes(exp))
+                    return [];
+                if (exp == 'count' || exp == 'distinct')
+                    return [{ key: exp, query: { $sum: 1 } }];
+                const infix = l.split('(')?.[1]?.split(')')?.[0];
+                if (!infix)
+                    return [];
+                const key = `${exp}_${infix}`;
+                const query = this.#postfix_to_mongodb(this.#infix_to_postfix(infix));
+                return [{ key, query: { [`$${exp}`]: query } }];
+            }).flat(2);
+            const groups = exprs.filter(g => g.match(/^[a-zA-Z_]+$/));
+            const $match = exprs.map(exp => {
+                for (const { c, f } of [
+                    { c: '==', f: 'eq' },
+                    { c: '<>', f: 'ne' },
+                    { c: '>=', f: 'gte' },
+                    { c: '<=', f: 'lte' },
+                    { c: '>', f: 'gt' },
+                    { c: '<', f: 'lt' },
+                    { c: '=', f: 'eq' },
+                ]) {
+                    if (exp.includes(c)) {
+                        const [a, b] = exp.split(c);
+                        return { [a]: { [f]: isNaN(Number(b)) ? (c == '==' ? (b == 'true') : b) : Number(b) } };
+                    }
+                }
+            }).filter(Boolean);
+            const is_distinc_count = `${v}`.includes('distinc');
+            const simple = is_distinc_count ? key : (exprs.length == 1 ? fns[0].key : false);
+            const pipelines = [
+                ...$match.length > 0 ? [{ $match }] : [],
+                {
+                    $group: {
+                        _id: groups.length == 0 ? null : groups.reduce((p, by) => {
+                            return {
+                                ...p,
+                                [by]: `$${by}`
+                            };
+                        }, {}),
+                        ...fns.reduce((p, { query, key }) => ({
                             ...p,
-                            [by]: `$${by}`
-                        };
-                    }, {}),
+                            [key]: query
+                        }), {})
+                    }
                 },
-                ...expr == 'count' ? { [id]: { $sum: 1 } } : {},
-                ...expr == 'max' ? { [id]: { $max: query } } : {},
-                ...expr == 'min' ? { [id]: { $min: query } } : {},
-                ...expr == 'sum' ? { [id]: { $sum: query } } : {}
-            });
-            return p;
-        }, new Map);
-        const pipelines = [...expresisons].reduce((p, [group_by, $group]) => {
-            return {
-                ...p,
-                [group_by]: [
-                    { $group },
+                ...is_distinc_count ? [
+                    {
+                        $count: key
+                    }
+                ] : [
                     {
                         $project: {
-                            ...Object.keys($group._id || {}).reduce((p, c) => ({
+                            ...groups.reduce((p, c) => ({
                                 ...p,
                                 [c]: `$_id.${c}`
                             }), {}),
-                            ...Object.keys($group).reduce((p, c) => ({ ...p, [c]: 1 }), {}),
+                            ...fns.reduce((p, { key }) => ({
+                                ...p,
+                                [key]: 1
+                            }), {}),
                             _id: 0
                         }
                     },
@@ -150,20 +168,23 @@ export class MongoQuery {
                         $limit: 50
                     }
                 ]
+            ];
+            return [{ key, pipelines, simple }];
+        })
+            .flat(1);
+        const pipelines = parsed.reduce((p, { key, pipelines }) => ({
+            ...p,
+            [key]: pipelines
+        }), {});
+        const summary = parsed.length == 0 ? undefined : parsed.reduce((p, { key, simple }) => {
+            return {
+                ...p,
+                [key]: simple ? { $arrayElemAt: [`$${key}.${simple}`, 0] } : `$${key}`
             };
         }, {});
-        const summary = expresisons.size == 0 ? {} : {
-            summary: [...expresisons].reduce((p, [group_by, $group]) => {
-                return {
-                    ...p,
-                    [group_by]: `$${group_by}`
-                };
-            }, {})
-        };
         return {
             pipelines,
-            summary,
-            mappers
+            summary
         };
     }
     static #parse_conditions(filters) {
@@ -294,7 +315,7 @@ export class MongoQuery {
         ];
     }
     static #build_cursor_paging($sort, req) {
-        const { pipelines, summary, mappers } = this.#parse_summary(req);
+        const { pipelines, summary } = this.#parse_summary(req);
         const limit = this.#get_limit(req);
         return [
             {
@@ -306,7 +327,7 @@ export class MongoQuery {
             },
             {
                 $project: {
-                    ...summary,
+                    summary,
                     prev: {
                         $ifNull: [
                             { $arrayElemAt: ["$prev", 0] },
@@ -323,12 +344,7 @@ export class MongoQuery {
             },
             {
                 $project: {
-                    summary: mappers.length == 0 ? 1 : mappers.reduce((p, c) => {
-                        return {
-                            ...p,
-                            [c.name]: { $arrayElemAt: [`$summary.${c.group_id}.${c.id}`, 0] }
-                        };
-                    }, {}),
+                    summary: 1,
                     items: {
                         $concatArrays: ["$prev.items", "$next.items"]
                     },

package/package.json

@@ -6,7 +6,7 @@
     "repository": {
         "url": "git@github.com:livequery/mongoose.git"
     },
-    "version": "2.0.21",
+    "version": "2.0.23",
     "description": "Mongoose datasource mapping for @livequery ecosystem",
     "main": "./build/src/index.js",
     "types": "./build/src/index.d.ts",