proto.io 0.0.227 → 0.0.229

package/dist/adapters/storage/postgres.mjs

@@ -5,7 +5,7 @@ import QueryStream from 'pg-query-stream';
 import { asyncStream, IteratorPool } from '@o2ter/utils-js';
 import Decimal from 'decimal.js';
 import { escapeIdentifier, escapeLiteral } from 'pg/lib/utils';
-import { r as resolveColumn, b as resolveDataType$1, d as QueryCoditionalSelector, e as QueryFieldSelector, f as QueryExpressionSelector, g as QueryArrayExpression, h as QueryValueExpression, i as QueryKeyExpression, j as QueryCoditionalExpression, k as QueryComparisonExpression, l as QueryNotExpression, m as QueryDistanceExpression, n as QueryZeroParamExpression, o as QueryUnaryExpression, p as QueryBinaryExpression, q as QueryListExpression, s as QueryTernaryExpression, t as QueryCondExpression, Q as QueryValidator, u as QueryZeroParamAccumulator, v as QueryUnaryAccumulator, w as QueryPercentileAccumulator, c as QuerySelector, F as FieldSelectorExpression } from '../../internals/validator-Boj1PUjM.mjs';
+import { r as resolveColumn, c as resolveDataType$1, e as QueryCoditionalSelector, f as QueryFieldSelector, g as QueryExpressionSelector, h as QueryArrayExpression, i as QueryValueExpression, j as QueryKeyExpression, k as QueryCoditionalExpression, l as QueryComparisonExpression, m as QueryNotExpression, n as QueryDistanceExpression, o as QueryZeroParamExpression, p as QueryUnaryExpression, q as QueryBinaryExpression, s as QueryListExpression, t as QueryTernaryExpression, u as QueryCondExpression, Q as QueryValidator, v as QueryGroupAccumulator, w as QueryZeroParamAccumulator, x as QueryUnaryAccumulator, y as QueryPercentileAccumulator, d as QuerySelector, F as FieldSelectorExpression } from '../../internals/validator-DubDY921.mjs';
 import '@o2ter/crypto-js';
 import { d as PROTO_EVENT } from '../../internals/const-68KwNmag.mjs';
 import { g as generateId } from '../../internals/random-CYjWDvex.mjs';
@@ -437,6 +437,15 @@ class QueryCompiler {
     _selectPopulateMap(context) {
         return _.map(context.populates, (populate, field) => this.dialect.selectPopulate(this, context, populate, field));
     }
+    groupFind(query, accumulators) {
+        return this._modifyQuery(query, (fetchName, context) => {
+            const columns = _.map(accumulators, (expr, field) => {
+                const aggSQL = this.dialect.encodeAccumulatorColumn(this, { ...context, name: fetchName, className: query.className }, expr, fetchName);
+                return sql `${aggSQL} AS ${{ identifier: field }}`;
+            });
+            return sql `SELECT ${{ literal: columns, separator: ', ' }} FROM ${{ identifier: fetchName }}`;
+        });
+    }
     insert(options, values) {
         const _values = _.map(values, attr => ({
             ..._defaultInsertOpts(options),
@@ -1442,6 +1451,30 @@ class SqlStorage {
             }
         })();
     }
+    async groupFind(query, accumulators) {
+        const compiler = this._makeCompiler(true, query.extraFilter);
+        const [result] = await this.query(compiler.groupFind(query, accumulators));
+        if (!result)
+            return result;
+        // Decode accumulator results based on their types
+        const decoded = {};
+        for (const [key, accumulator] of _.toPairs(accumulators)) {
+            const evalType = accumulator.evalType(this.schema, query.className);
+            if (evalType === 'array') {
+                // For $group operators, result is already parsed JSONB array
+                decoded[key] = result[key];
+            }
+            else if (evalType && isPrimitive(evalType)) {
+                // Extract primitive type from PrimitiveType
+                const primitiveType = _.isString(evalType) ? evalType : evalType.type;
+                decoded[key] = this.dialect.decodeType(primitiveType, result[key]);
+            }
+            else {
+                decoded[key] = result[key];
+            }
+        }
+        return decoded;
+    }
     refs(object, classNames, roles) {
         const self = this;
         const query = sql `
@@ -2211,6 +2244,152 @@ const updateOperation = (paths, dataType, operation) => {
     throw Error('Invalid update operation');
 };
 
+//
+//  accumulators.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+const encodeColumn = (compiler, context, expr) => {
+    if (expr instanceof QueryZeroParamAccumulator) {
+        switch (expr.type) {
+            case '$count':
+                return sql `COUNT(*)`;
+            default:
+                throw Error('Invalid expression');
+        }
+    }
+    else if (expr instanceof QueryUnaryAccumulator) {
+        if (!expr.expr)
+            throw Error('Invalid expression');
+        const { sql: value } = encodeTypedQueryExpression(compiler, context, expr.expr) ?? {};
+        if (!value)
+            throw Error('Invalid expression');
+        switch (expr.type) {
+            case '$most':
+                return sql `MODE() WITHIN GROUP (ORDER BY (${value}))`;
+            default:
+                {
+                    const op = {
+                        '$max': 'MAX',
+                        '$min': 'MIN',
+                        '$avg': 'AVG',
+                        '$sum': 'SUM',
+                        '$stdDevPop': 'STDDEV_POP',
+                        '$stdDevSamp': 'STDDEV_SAMP',
+                        '$varPop': 'VAR_POP',
+                        '$varSamp': 'VAR_SAMP',
+                    }[expr.type];
+                    return sql `${{ literal: op }}(${value})`;
+                }
+        }
+    }
+    else if (expr instanceof QueryPercentileAccumulator) {
+        const op = {
+            'discrete': 'PERCENTILE_DISC',
+            'continuous': 'PERCENTILE_CONT',
+        }[expr.mode];
+        if (!expr.input)
+            throw Error('Invalid expression');
+        const { sql: value } = encodeTypedQueryExpression(compiler, context, expr.input) ?? {};
+        if (!value)
+            throw Error('Invalid expression');
+        return sql `${{ literal: op }}(${{ value: expr.p }}) WITHIN GROUP (ORDER BY (${value}))`;
+    }
+    else {
+        throw Error('Invalid expression');
+    }
+};
+const encodeAccumulatorExpression = (compiler, parent, populate, field, expr, aliasName) => {
+    if (expr instanceof QueryGroupAccumulator) {
+        if (!expr.key)
+            throw Error('Invalid expression');
+        const { sql: keyValue } = encodeTypedQueryExpression(compiler, populate, expr.key) ?? {};
+        if (!keyValue)
+            throw Error('Invalid expression');
+        const aggSQL = encodeColumn(compiler, populate, expr.value);
+        return sql `
+      (
+        SELECT COALESCE(
+          jsonb_agg(
+            jsonb_build_object('key', grouped_key, 'value', grouped_value)
+          ),
+          '[]'::jsonb
+        ) FROM (
+          SELECT ${keyValue} AS grouped_key, ${aggSQL} AS grouped_value
+          FROM (
+            ${_selectRelationPopulate(compiler, parent, populate, field, false)}
+          ) ${{ identifier: populate.name }}
+          GROUP BY grouped_key
+        ) AS _grouped
+      ) AS ${{ identifier: aliasName }}
+    `;
+    }
+    const aggSQL = encodeColumn(compiler, populate, expr);
+    return sql `
+    (
+      SELECT ${aggSQL} FROM (
+        ${_selectRelationPopulate(compiler, parent, populate, field, false)}
+      ) ${{ identifier: populate.name }}
+    ) AS ${{ identifier: aliasName }}
+  `;
+};
+const encodeAccumulatorColumn = (compiler, context, expr, fetchName) => {
+    if (expr instanceof QueryGroupAccumulator) {
+        if (!expr.key)
+            throw Error('Invalid expression');
+        // Try to get typed expression first
+        let keyValue;
+        const typedResult = encodeTypedQueryExpression(compiler, context, expr.key);
+        if (typedResult?.sql) {
+            keyValue = typedResult.sql;
+        }
+        else if (expr.key instanceof QueryKeyExpression) {
+            // For non-primitive types (like arrays), use raw element
+            const { element } = fetchElement(compiler, context, expr.key.key);
+            keyValue = element;
+        }
+        else {
+            throw Error('Invalid expression');
+        }
+        const aggSQL = encodeColumn(compiler, context, expr.value);
+        return sql `
+      (
+        SELECT COALESCE(
+          jsonb_agg(
+            jsonb_build_object('key', grouped_key, 'value', grouped_value)
+          ),
+          '[]'::jsonb
+        )
+        FROM (
+          SELECT ${keyValue} AS grouped_key, ${aggSQL} AS grouped_value
+          FROM ${{ identifier: fetchName }}
+          GROUP BY grouped_key
+        ) AS _grouped
+      )
+    `;
+    }
+    return encodeColumn(compiler, context, expr);
+};
+
 //
 //  populate.ts
 //
@@ -2313,79 +2492,7 @@ const selectPopulate = (compiler, parent, populate, field) => {
         ];
         if (!_.isEmpty(groupMatches?.[field])) {
             for (const [key, expr] of _.entries(groupMatches[field])) {
-                if (expr instanceof QueryZeroParamAccumulator) {
-                    switch (expr.type) {
-                        case '$count':
-                            columns.push(sql `
-                (
-                  SELECT COUNT(*) FROM (
-                    ${_selectRelationPopulate(compiler, parent, populate, field, false)}
-                  ) ${{ identifier: populate.name }}
-                ) AS ${{ identifier: `${field}.${key}` }}
-              `);
-                            break;
-                    }
-                }
-                else if (expr instanceof QueryUnaryAccumulator) {
-                    if (!expr.expr)
-                        throw Error('Invalid expression');
-                    const { sql: value } = encodeTypedQueryExpression(compiler, populate, expr.expr) ?? {};
-                    if (!value)
-                        throw Error('Invalid expression');
-                    switch (expr.type) {
-                        case '$most':
-                            columns.push(sql `
-                (
-                  SELECT MODE() WITHIN GROUP (ORDER BY (${value})) FROM (
-                    ${_selectRelationPopulate(compiler, parent, populate, field, false)}
-                  ) ${{ identifier: populate.name }}
-                ) AS ${{ identifier: `${field}.${key}` }}
-              `);
-                            break;
-                        default:
-                            {
-                                const op = {
-                                    '$max': 'MAX',
-                                    '$min': 'MIN',
-                                    '$avg': 'AVG',
-                                    '$sum': 'SUM',
-                                    '$stdDevPop': 'STDDEV_POP',
-                                    '$stdDevSamp': 'STDDEV_SAMP',
-                                    '$varPop': 'VAR_POP',
-                                    '$varSamp': 'VAR_SAMP',
-                                }[expr.type];
-                                columns.push(sql `
-                  (
-                    SELECT ${{ literal: op }}(${value}) FROM (
-                      ${_selectRelationPopulate(compiler, parent, populate, field, false)}
-                    ) ${{ identifier: populate.name }}
-                  ) AS ${{ identifier: `${field}.${key}` }}
-                `);
-                            }
-                            break;
-                    }
-                }
-                else if (expr instanceof QueryPercentileAccumulator) {
-                    const op = {
-                        'discrete': 'PERCENTILE_DISC',
-                        'continuous': 'PERCENTILE_CONT',
-                    }[expr.mode];
-                    if (!expr.input)
-                        throw Error('Invalid expression');
-                    const { sql: value } = encodeTypedQueryExpression(compiler, populate, expr.input) ?? {};
-                    if (!value)
-                        throw Error('Invalid expression');
-                    columns.push(sql `
-            (
-              SELECT ${{ literal: op }}(${{ value: expr.p }}) WITHIN GROUP (ORDER BY (${value})) FROM (
-                ${_selectRelationPopulate(compiler, parent, populate, field, false)}
-              ) ${{ identifier: populate.name }}
-            ) AS ${{ identifier: `${field}.${key}` }}
-          `);
-                }
-                else {
-                    throw Error('Invalid expression');
-                }
+                columns.push(encodeAccumulatorExpression(compiler, parent, populate, field, expr, `${field}.${key}`));
             }
         }
         else {
@@ -3066,6 +3173,7 @@ const PostgresDialect = {
     encodePopulate,
     encodeRelation,
     encodeSortKey,
+    encodeAccumulatorColumn,
     random,
 };