proto.io 0.0.213 → 0.0.214

package/dist/adapters/storage/progres.mjs

@@ -5,10 +5,10 @@ import QueryStream from 'pg-query-stream';
 import { asyncStream, IteratorPool } from '@o2ter/utils-js';
 import Decimal from 'decimal.js';
 import { escapeLiteral, escapeIdentifier } from 'pg/lib/utils';
-import { a as QueryCoditionalSelector, b as QueryFieldSelector, c as QueryExpressionSelector, d as QueryDistanceExpression, e as QueryKeyExpression, f as QueryValueExpression, g as QueryCoditionalExpression, h as QueryComparisonExpression, i as QueryNotExpression, j as QueryArrayExpression, Q as QuerySelector, F as FieldSelectorExpression } from '../../internals/index-DG9HHO_U.mjs';
+import { r as resolveColumn, a as resolveDataType$1, c as QueryCoditionalSelector, d as QueryFieldSelector, e as QueryExpressionSelector, Q as QueryValidator, f as QueryDistanceExpression, g as QueryKeyExpression, h as QueryValueExpression, i as QueryCoditionalExpression, j as QueryComparisonExpression, k as QueryNotExpression, l as QueryArrayExpression, m as QueryNoParamAccumulator, n as QueryExprAccumulator, b as QuerySelector, F as FieldSelectorExpression } from '../../internals/validator-Dxmbwa3P.mjs';
 import '@o2ter/crypto-js';
-import { r as resolveColumn, a as resolveDataType$1, g as generateId, b as accumulatorKeyTypes, Q as QueryValidator } from '../../internals/random-CufRbivU.mjs';
 import { c as PROTO_EVENT } from '../../internals/const-Dkp7Nsv5.mjs';
+import { g as generateId } from '../../internals/random-CYjWDvex.mjs';
 import { P as PVK } from '../../internals/private-CNw40LZ7.mjs';
 
 //
@@ -668,14 +668,19 @@ class SqlStorage {
         const count = parseInt(_count);
         return _.isFinite(count) ? count : 0;
     }
-    _matchesType(options) {
+    _matchesType(compiler, options) {
         const types = {};
         for (const [key, match] of _.entries(options.matches)) {
-            types[key] = this._matchesType(match);
+            const type = resolveDataType$1(compiler.schema, options.className, key);
+            if (_.isNil(type))
+                continue;
+            if (isPointer(type) || isRelation(type)) {
+                types[key] = this._matchesType(compiler, { className: type.target, ...match });
+            }
         }
         for (const [key, group] of _.entries(options.groupMatches)) {
             for (const [field, expr] of _.entries(group)) {
-                _.set(types, `${key}.${field}`, accumulatorKeyTypes[expr.type]);
+                _.set(types, `${key}.${field}`, expr.evalType(compiler.schema, options.className));
             }
         }
         return types;
@@ -683,24 +688,26 @@ class SqlStorage {
     find(query) {
         const self = this;
         const compiler = self._makeCompiler(false, query.extraFilter);
+        const _matchesType = self._matchesType(compiler, query);
         const _query = compiler._selectQuery(query);
         return (async function* () {
             const objects = self.query(_query);
             for await (const object of objects) {
-                yield self._decodeObject(query.className, object, self._matchesType(query));
+                yield self._decodeObject(query.className, object, _matchesType);
             }
         })();
     }
     random(query, opts) {
         const self = this;
         const compiler = self._makeCompiler(false, query.extraFilter);
+        const _matchesType = self._matchesType(compiler, query);
         const _query = compiler._selectQuery({ ...query, sort: {} }, {
             sort: sql `ORDER BY ${self.dialect.random(opts ?? {})}`,
         });
         return (async function* () {
             const objects = self.query(_query);
             for await (const object of objects) {
-                yield self._decodeObject(query.className, object, self._matchesType(query));
+                yield self._decodeObject(query.className, object, _matchesType);
             }
         })();
     }
@@ -721,6 +728,7 @@ class SqlStorage {
     nonrefs(query) {
         const self = this;
         const compiler = self._makeCompiler(false, query.extraFilter);
+        const _matchesType = self._matchesType(compiler, query);
         const _query = compiler._selectQuery(query, ({ fetchName }) => ({
             extraFilter: sql `
         NOT EXISTS (${this._refs(this.schema, query.className, ['_id'], sql `(${{ quote: query.className + '$' }} || ${{ identifier: fetchName }}.${{ identifier: '_id' }})`)})
@@ -729,29 +737,33 @@ class SqlStorage {
         return (async function* () {
             const objects = self.query(_query);
             for await (const object of objects) {
-                yield self._decodeObject(query.className, object, self._matchesType(query));
+                yield self._decodeObject(query.className, object, _matchesType);
             }
         })();
     }
     async insert(options, values) {
         const compiler = this._makeCompiler(true);
+        const _matchesType = this._matchesType(compiler, options);
         const result = await this.query(compiler.insert(options, values));
-        return _.map(result, x => this._decodeObject(options.className, x, this._matchesType(options)));
+        return _.map(result, x => this._decodeObject(options.className, x, _matchesType));
     }
     async update(query, update) {
         const compiler = this._makeCompiler(true, query.extraFilter);
+        const _matchesType = this._matchesType(compiler, query);
         const updated = await this.query(compiler.update(query, update));
-        return _.map(updated, x => this._decodeObject(query.className, x, this._matchesType(query)));
+        return _.map(updated, x => this._decodeObject(query.className, x, _matchesType));
     }
     async upsert(query, update, setOnInsert) {
         const compiler = this._makeCompiler(true, query.extraFilter);
+        const _matchesType = this._matchesType(compiler, query);
         const upserted = await this.query(compiler.upsert(query, update, setOnInsert));
-        return _.map(upserted, x => this._decodeObject(query.className, x, this._matchesType(query)));
+        return _.map(upserted, x => this._decodeObject(query.className, x, _matchesType));
     }
     async delete(query) {
         const compiler = this._makeCompiler(true, query.extraFilter);
+        const _matchesType = this._matchesType(compiler, query);
         const deleted = await this.query(compiler.delete(query));
-        return _.map(deleted, x => this._decodeObject(query.className, x, this._matchesType(query)));
+        return _.map(deleted, x => this._decodeObject(query.className, x, _matchesType));
     }
 }
 
@@ -779,7 +791,7 @@ class SqlStorage {
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 //
-const _fetchElement = (parent, colname, subpath, dataType) => {
+const _fetchElement = (compiler, parent, colname, subpath, dataType) => {
     const element = sql `${{ identifier: parent.name }}.${{ identifier: parent.name.startsWith('_doller_expr_$') ? '$' : colname }}`;
     if (!parent.className) {
         if (colname !== '$') {
@@ -802,7 +814,7 @@ const _fetchElement = (parent, colname, subpath, dataType) => {
             return {
                 element: sql `${{ identifier: parent.name }}.${{ identifier: `${colname}.${subpath[0]}` }}`,
                 json: false,
-                dataType: accumulatorKeyTypes[match.type],
+                dataType: match.evalType(compiler.schema, dataType.target),
             };
         }
         else if (dataType && _isTypeof(dataType, ['array', 'string[]', 'relation'])) {
@@ -865,7 +877,7 @@ const _resolvePopulate = (path, populates) => {
 const fetchElement = (compiler, parent, field) => {
     if (parent.className) {
         const { dataType, colname, subpath } = resolvePaths(compiler, parent.className, _.toPath(field));
-        const { element, json, dataType: _dataType } = _fetchElement(parent, colname, subpath, dataType);
+        const { element, json, dataType: _dataType } = _fetchElement(compiler, parent, colname, subpath, dataType);
         if (isPointer(dataType))
             return { element: sql `${{ identifier: parent.name }}.${{ identifier: `${colname}._id` }}`, dataType };
         const populate = isRelation(dataType) && _resolvePopulate(_.toPath(colname), parent.populates);
@@ -897,7 +909,7 @@ const fetchElement = (compiler, parent, field) => {
         }
     }
     const [colname, ...subpath] = _.toPath(field);
-    const { element } = _fetchElement(parent, colname, subpath);
+    const { element } = _fetchElement(compiler, parent, colname, subpath);
     return { element, dataType: null, relation: null };
 };
 
@@ -1685,7 +1697,19 @@ const encodeTypedQueryExpression = (compiler, parent, expr) => {
     if (expr instanceof QueryKeyExpression) {
         const { element, dataType } = fetchElement(compiler, parent, expr.key);
         const _dataType = dataType ? _typeof(dataType) : null;
-        if (_dataType && _PrimitiveValue.includes(_dataType)) {
+        if (_dataType === 'number') {
+            return [
+                { type: 'number', sql: element },
+                { type: 'decimal', sql: sql `CAST((${element}) AS DECIMAL)` },
+            ];
+        }
+        else if (_dataType === 'decimal') {
+            return [
+                { type: 'decimal', sql: element },
+                { type: 'number', sql: element },
+            ];
+        }
+        else if (_dataType && _PrimitiveValue.includes(_dataType)) {
             return [{ type: _dataType, sql: element }];
         }
     }
@@ -1950,39 +1974,44 @@ const selectPopulate = (compiler, parent, populate, field) => {
             sql `${{ identifier: parent.name }}.${{ identifier: field }} AS ${{ identifier: `$${field}` }}`,
         ];
         if (!_.isEmpty(groupMatches?.[field])) {
-            for (const [key, { type, expr }] of _.entries(groupMatches[field])) {
-                switch (type) {
-                    case '$count':
-                        columns.push(sql `
-              (
-                SELECT COUNT(*) FROM (
-                  ${_selectRelationPopulate(compiler, parent, populate, field, false)}
-                ) ${{ identifier: populate.name }}
-              ) AS ${{ identifier: `${field}.${key}` }}
-            `);
-                        break;
-                    case '$avg':
-                    case '$sum':
-                        {
-                            const op = {
-                                '$avg': 'AVG',
-                                '$sum': 'SUM',
-                            }[type];
-                            if (!expr)
-                                throw Error('Invalid expression');
-                            const exprs = encodeTypedQueryExpression(compiler, populate, expr);
-                            const { sql: value } = (_.includes(['$avg'], type) ? _.find(exprs, e => e.type === 'number') : _.first(exprs)) ?? {};
-                            if (!value)
-                                throw Error('Invalid expression');
+            for (const [key, expr] of _.entries(groupMatches[field])) {
+                if (expr instanceof QueryNoParamAccumulator) {
+                    switch (expr.type) {
+                        case '$count':
                             columns.push(sql `
                 (
-                  SELECT ${{ literal: op }}(${value}) FROM (
+                  SELECT COUNT(*) FROM (
                     ${_selectRelationPopulate(compiler, parent, populate, field, false)}
                   ) ${{ identifier: populate.name }}
                 ) AS ${{ identifier: `${field}.${key}` }}
               `);
-                        }
-                        break;
+                            break;
+                    }
+                }
+                else if (expr instanceof QueryExprAccumulator) {
+                    const op = {
+                        '$max': 'MAX',
+                        '$min': 'MIN',
+                        '$avg': 'AVG',
+                        '$sum': 'SUM',
+                        '$stdDevPop': 'STDDEV_POP',
+                        '$stdDevSamp': 'STDDEV_SAMP',
+                        '$varPop': 'VAR_POP',
+                        '$varSamp': 'VAR_SAMP',
+                    }[expr.type];
+                    if (!expr.expr)
+                        throw Error('Invalid expression');
+                    const exprs = encodeTypedQueryExpression(compiler, populate, expr.expr);
+                    const value = _.first(exprs)?.sql;
+                    if (!value)
+                        throw Error('Invalid expression');
+                    columns.push(sql `
+            (
+              SELECT ${{ literal: op }}(${value}) FROM (
+                ${_selectRelationPopulate(compiler, parent, populate, field, false)}
+              ) ${{ identifier: populate.name }}
+            ) AS ${{ identifier: `${field}.${key}` }}
+          `);
                 }
             }
         }