proto.io 0.0.211 → 0.0.213

package/dist/adapters/storage/progres.js

@@ -11,7 +11,7 @@ var Decimal = require('decimal.js');
 var utils = require('pg/lib/utils');
 var index$1 = require('../../internals/index-D8O7SinR.js');
 require('@o2ter/crypto-js');
-var random$1 = require('../../internals/random-CyU_Y2Ay.js');
+var random$1 = require('../../internals/random-DzvxbWAc.js');
 var _const = require('../../internals/const-C3I6cfav.js');
 var _private = require('../../internals/private-Ciddhure.js');
 
@@ -218,12 +218,12 @@ class QueryCompiler {
     _encodeIncludes(query) {
         const names = {};
         const populates = {};
-        const countMatches = [];
+        const groupMatches = {};
         for (const include of query.includes) {
             const { paths: [colname, ...subpath], dataType } = random$1.resolveColumn(this.schema, query.className, include);
             names[colname] = dataType;
-            if (index.isRelation(dataType) && _.includes(query.countMatches, colname))
-                countMatches.push(colname);
+            if (index.isRelation(dataType) && !_.isNil(query.groupMatches[colname]))
+                groupMatches[colname] = query.groupMatches[colname];
             if (index.isPointer(dataType) || index.isRelation(dataType)) {
                 if (_.isEmpty(subpath))
                     throw Error(`Invalid path: ${include}`);
@@ -254,21 +254,26 @@ class QueryCompiler {
         }
         for (const [colname, populate] of _.toPairs(populates)) {
             const _matches = query.matches[colname];
-            const { includes, populates, countMatches } = this._encodeIncludes({
+            const { includes, populates, groupMatches } = this._encodeIncludes({
                 className: populate.className,
                 includes: populate.subpaths,
                 matches: _matches.matches,
-                countMatches: [
-                    ..._.filter(query.countMatches, x => _.startsWith(x, `${colname}.`)).map(x => x.slice(colname.length + 1)),
-                    ..._matches.countMatches ?? [],
-                ],
+                groupMatches: {
+                    ..._.mapKeys(_.pickBy(query.groupMatches, (x, k) => _.startsWith(k, `${colname}.`)), (x, k) => k.slice(colname.length + 1)),
+                    ..._matches.groupMatches ?? {},
+                },
             });
             populate.sort = _encodeSorting(includes, populates, _matches.sort);
             populate.includes = includes;
             populate.populates = populates;
-            populate.countMatches = countMatches;
+            populate.groupMatches = groupMatches;
         }
-        return { className: query.className, includes: names, populates, countMatches: _.uniq(countMatches) };
+        return {
+            className: query.className,
+            includes: names,
+            populates,
+            groupMatches,
+        };
     }
     _baseSelectQuery(query, options) {
         const fetchName = `_fetch_$${query.className.toLowerCase()}`;
@@ -304,7 +309,11 @@ class QueryCompiler {
         ) AS ${{ identifier: fetchName }}
         ${!_.isEmpty(filter) ? sql `WHERE ${{ literal: _.map(filter, x => sql `(${x})`), separator: ' AND ' }}` : sql ``}
         ${_options?.sort ? _options?.sort : sql ``}
-        ${!_.isEmpty(query.sort) ? sql `ORDER BY ${this._encodeSort(query.sort, { className: query.className, name: fetchName })}` : sql ``}
+        ${!_.isEmpty(query.sort) ? sql `ORDER BY ${this._encodeSort(query.sort, {
+                name: fetchName,
+                className: query.className,
+                groupMatches: query.groupMatches,
+            })}` : sql ``}
         ${query.limit ? sql `LIMIT ${{ literal: `${query.limit}` }}` : sql ``}
         ${query.skip ? sql `OFFSET ${{ literal: `${query.skip}` }}` : sql ``}
       `,
@@ -409,7 +418,7 @@ class QueryCompiler {
     }
     _selectIncludes(className, includes) {
         const _includes = _.pickBy(includes, v => _.isString(v) || (v.type !== 'pointer' && v.type !== 'relation'));
-        return _.map(_includes, (dataType, colname) => {
+        return _.flatMap(_includes, (dataType, colname) => {
             if (!_.isString(dataType) && index.isPrimitive(dataType) && !_.isNil(dataType.default)) {
                 return sql `COALESCE(${{ identifier: className }}.${{ identifier: colname }}, ${{ value: dataType.default }}) AS ${{ identifier: colname }}`;
             }
@@ -430,7 +439,7 @@ class QueryCompiler {
     `)}`;
     }
     _selectPopulateMap(context) {
-        return _.map(context.populates, (populate, field) => this.dialect.selectPopulate(this, context, populate, field, _.includes(context.countMatches, field)));
+        return _.map(context.populates, (populate, field) => this.dialect.selectPopulate(this, context, populate, field));
     }
     insert(options, values) {
         const _values = _.map(values, attr => ({
@@ -568,9 +577,15 @@ class SqlStorage {
         const { query, values } = sql.compile(this.dialect);
         return this._query(query, values);
     }
-    _decodeShapedObject(dataType, value) {
+    _decodeMatchTypes(value, matchType) {
+        if (!_.isPlainObject(value))
+            return;
+        return _.mapValues(value, (v, k) => this.dialect.decodeType(matchType[k], v));
+    }
+    _decodeShapedObject(dataType, value, matchesType) {
         const result = {};
         for (const { path, type } of index.shapePaths(dataType)) {
+            const matchType = _.get(matchesType, path) ?? {};
             if (_.isString(type)) {
                 const _value = this.dialect.decodeType(type, _.get(value, path));
                 if (!_.isNil(_value))
@@ -579,17 +594,17 @@ class SqlStorage {
             else if (index.isPointer(type)) {
                 const _value = _.get(value, path);
                 if (_.isPlainObject(_value)) {
-                    const decoded = this._decodeObject(type.target, _value);
+                    const decoded = this._decodeObject(type.target, _value, matchType);
                     if (decoded.objectId)
                         _.set(result, path, decoded);
                 }
             }
             else if (index.isRelation(type)) {
                 const _value = _.get(value, path);
-                if (_.isString(_value) && _value.match(/^\d+$/g))
-                    _.set(result, path, parseInt(_value));
-                else if (_.isArray(_value))
-                    _.set(result, path, _value.map(x => this._decodeObject(type.target, x)));
+                if (_.isArray(_value))
+                    _.set(result, path, _value.map(x => this._decodeObject(type.target, x, matchType)));
+                else if (_.isPlainObject(_value))
+                    _.set(result, path, this._decodeMatchTypes(_value, matchType));
             }
             else {
                 const _value = this.dialect.decodeType(type.type, _.get(value, path)) ?? type.default;
@@ -599,7 +614,7 @@ class SqlStorage {
         }
         return result;
     }
-    _decodeObject(className, attrs) {
+    _decodeObject(className, attrs, matchesType) {
         const fields = this.schema[className].fields;
         const obj = new index.TObject(className);
         const _attrs = {};
@@ -607,6 +622,7 @@ class SqlStorage {
             _.set(_attrs, key, value);
         }
         for (const [key, value] of _.toPairs(_attrs)) {
+            const matchType = matchesType[key] ?? {};
             const dataType = fields[key];
             if (!dataType)
                 continue;
@@ -614,20 +630,20 @@ class SqlStorage {
                 obj[_private.PVK].attributes[key] = this.dialect.decodeType(dataType, value);
             }
             else if (index.isShape(dataType)) {
-                obj[_private.PVK].attributes[key] = this._decodeShapedObject(dataType, value);
+                obj[_private.PVK].attributes[key] = this._decodeShapedObject(dataType, value, matchType);
             }
             else if (index.isPointer(dataType)) {
                 if (_.isPlainObject(value)) {
-                    const decoded = this._decodeObject(dataType.target, value);
+                    const decoded = this._decodeObject(dataType.target, value, matchType);
                     if (decoded.objectId)
                         obj[_private.PVK].attributes[key] = decoded;
                 }
             }
             else if (index.isRelation(dataType)) {
-                if (_.isString(value) && value.match(/^\d+$/g))
-                    obj[_private.PVK].attributes[key] = parseInt(value);
-                else if (_.isArray(value))
-                    obj[_private.PVK].attributes[key] = value.map(x => this._decodeObject(dataType.target, x));
+                if (_.isArray(value))
+                    obj[_private.PVK].attributes[key] = value.map(x => this._decodeObject(dataType.target, x, matchType));
+                else if (_.isPlainObject(value))
+                    obj[_private.PVK].attributes[key] = this._decodeMatchTypes(value, matchType);
             }
             else {
                 obj[_private.PVK].attributes[key] = this.dialect.decodeType(dataType.type, value) ?? dataType.default;
@@ -656,6 +672,18 @@ class SqlStorage {
         const count = parseInt(_count);
         return _.isFinite(count) ? count : 0;
     }
+    _matchesType(options) {
+        const types = {};
+        for (const [key, match] of _.entries(options.matches)) {
+            types[key] = this._matchesType(match);
+        }
+        for (const [key, group] of _.entries(options.groupMatches)) {
+            for (const [field, expr] of _.entries(group)) {
+                _.set(types, `${key}.${field}`, random$1.accumulatorKeyTypes[expr.type]);
+            }
+        }
+        return types;
+    }
     find(query) {
         const self = this;
         const compiler = self._makeCompiler(false, query.extraFilter);
@@ -663,7 +691,7 @@ class SqlStorage {
         return (async function* () {
             const objects = self.query(_query);
             for await (const object of objects) {
-                yield self._decodeObject(query.className, object);
+                yield self._decodeObject(query.className, object, self._matchesType(query));
             }
         })();
     }
@@ -676,7 +704,7 @@ class SqlStorage {
         return (async function* () {
             const objects = self.query(_query);
             for await (const object of objects) {
-                yield self._decodeObject(query.className, object);
+                yield self._decodeObject(query.className, object, self._matchesType(query));
             }
         })();
     }
@@ -690,7 +718,7 @@ class SqlStorage {
         return (async function* () {
             const objects = self.query(query);
             for await (const { _class, ...object } of objects) {
-                yield self._decodeObject(_class, object);
+                yield self._decodeObject(_class, object, {});
             }
         })();
     }
@@ -705,29 +733,29 @@ class SqlStorage {
         return (async function* () {
             const objects = self.query(_query);
             for await (const object of objects) {
-                yield self._decodeObject(query.className, object);
+                yield self._decodeObject(query.className, object, self._matchesType(query));
             }
         })();
     }
     async insert(options, values) {
         const compiler = this._makeCompiler(true);
         const result = await this.query(compiler.insert(options, values));
-        return _.map(result, x => this._decodeObject(options.className, x));
+        return _.map(result, x => this._decodeObject(options.className, x, this._matchesType(options)));
     }
     async update(query, update) {
         const compiler = this._makeCompiler(true, query.extraFilter);
         const updated = await this.query(compiler.update(query, update));
-        return _.map(updated, x => this._decodeObject(query.className, x));
+        return _.map(updated, x => this._decodeObject(query.className, x, this._matchesType(query)));
     }
     async upsert(query, update, setOnInsert) {
         const compiler = this._makeCompiler(true, query.extraFilter);
         const upserted = await this.query(compiler.upsert(query, update, setOnInsert));
-        return _.map(upserted, x => this._decodeObject(query.className, x));
+        return _.map(upserted, x => this._decodeObject(query.className, x, this._matchesType(query)));
     }
     async delete(query) {
         const compiler = this._makeCompiler(true, query.extraFilter);
         const deleted = await this.query(compiler.delete(query));
-        return _.map(deleted, x => this._decodeObject(query.className, x));
+        return _.map(deleted, x => this._decodeObject(query.className, x, this._matchesType(query)));
     }
 }
 
@@ -773,7 +801,15 @@ const _fetchElement = (parent, colname, subpath, dataType) => {
     }
     else if (!_.isEmpty(subpath)) {
         const _subpath = sql `${_.map(subpath, x => sql `${{ quote: x.startsWith('$') ? `$${x}` : x }}`)}`;
-        if (dataType && index._isTypeof(dataType, ['array', 'string[]', 'relation'])) {
+        const match = parent.groupMatches?.[colname]?.[subpath[0]];
+        if (dataType && index.isRelation(dataType) && subpath.length === 1 && match) {
+            return {
+                element: sql `${{ identifier: parent.name }}.${{ identifier: `${colname}.${subpath[0]}` }}`,
+                json: false,
+                dataType: random$1.accumulatorKeyTypes[match.type],
+            };
+        }
+        else if (dataType && index._isTypeof(dataType, ['array', 'string[]', 'relation'])) {
             return {
                 element: sql `jsonb_extract_path(to_jsonb(${element}), ${_subpath})`,
                 json: true,
@@ -833,7 +869,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 } = _fetchElement(parent, colname, subpath, dataType);
+        const { element, json, dataType: _dataType } = _fetchElement(parent, colname, subpath, dataType);
         if (index.isPointer(dataType))
             return { element: sql `${{ identifier: parent.name }}.${{ identifier: `${colname}._id` }}`, dataType };
         const populate = index.isRelation(dataType) && _resolvePopulate(_.toPath(colname), parent.populates);
@@ -841,7 +877,7 @@ const fetchElement = (compiler, parent, field) => {
             return { element, dataType: json ? null : dataType };
         return {
             element,
-            dataType: json ? null : dataType,
+            dataType: json ? null : _dataType ?? dataType,
             relation: {
                 colname,
                 target: dataType.target,
@@ -1181,7 +1217,7 @@ const _encodeJsonValue = (value) => {
         return sql `jsonb_build_object(${_.map(value, (v, k) => sql `${{ value: k }}, ${_encodeJsonValue(v)}`)})`;
     return sql `to_jsonb(${{ value }})`;
 };
-const _encodePopulateInclude = (className, colname, dataType) => {
+const _jsonPopulateInclude = (className, colname, dataType) => {
     switch (index._typeof(dataType)) {
         case 'decimal':
             return sql `jsonb_build_object(
@@ -1896,45 +1932,83 @@ const _selectRelationPopulate = (compiler, parent, populate, field, encode) => {
         cond = sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ANY(${_foreign(populate.colname)})`;
     }
     return sql `
-    SELECT ${_.compact(_.flatMap(subpaths, ({ path, type }) => [
-        encode && _encodePopulateInclude(populate.name, path, type),
-        !encode && sql `${{ identifier: populate.name }}.${{ identifier: path }}`,
-        !encode && index.isRelation(type) && sql `${{ identifier: populate.name }}.${{ identifier: `$${path}` }}`,
+    SELECT ${_.compact(_.flatMap(subpaths, ({ path, type }) => encode ? [
+        _jsonPopulateInclude(populate.name, path, type)
+    ] : [
+        ...(populate.groupMatches[path] ? _.map(_.keys(populate.groupMatches[path]), k => sql `${{ identifier: populate.name }}.${{ identifier: `${path}.${k}` }}`) : [
+            sql `${{ identifier: populate.name }}.${{ identifier: path }}`
+        ]),
+        index.isRelation(type) && sql `${{ identifier: populate.name }}.${{ identifier: `$${path}` }}`,
     ]))}
     FROM ${{ identifier: populate.name }} WHERE ${cond}
-    ${!_.isEmpty(populate.sort) ? sql `ORDER BY ${compiler._encodeSort(populate.sort, { className: populate.className, name: populate.name })}` : sql ``}
+    ${!_.isEmpty(populate.sort) ? sql `ORDER BY ${compiler._encodeSort(populate.sort, populate)}` : sql ``}
     ${populate.limit ? sql `LIMIT ${{ literal: `${populate.limit}` }}` : sql ``}
     ${populate.skip ? sql `OFFSET ${{ literal: `${populate.skip}` }}` : sql ``}
     ${compiler.selectLock ? compiler.isUpdate ? sql `FOR UPDATE NOWAIT` : sql `FOR SHARE NOWAIT` : sql ``}
   `;
 };
-const selectPopulate = (compiler, parent, populate, field, countMatches) => {
+const selectPopulate = (compiler, parent, populate, field) => {
     if (populate.type === 'relation') {
-        return {
-            columns: [
-                countMatches ? sql `
-          (
-            SELECT COUNT(*) FROM (
-              ${_selectRelationPopulate(compiler, parent, populate, field, false)}
-            ) ${{ identifier: populate.name }}
-          ) AS ${{ identifier: field }}
-        ` : sql `
-          ARRAY(
-            SELECT to_jsonb(${{ identifier: populate.name }}) FROM (
-              ${_selectRelationPopulate(compiler, parent, populate, field, true)}
-            ) ${{ identifier: populate.name }}
-          ) AS ${{ identifier: field }}
-        `,
-                sql `${{ identifier: parent.name }}.${{ identifier: field }} AS ${{ identifier: `$${field}` }}`
-            ],
-        };
+        const { groupMatches } = parent;
+        const columns = [
+            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');
+                            columns.push(sql `
+                (
+                  SELECT ${{ literal: op }}(${value}) FROM (
+                    ${_selectRelationPopulate(compiler, parent, populate, field, false)}
+                  ) ${{ identifier: populate.name }}
+                ) AS ${{ identifier: `${field}.${key}` }}
+              `);
+                        }
+                        break;
+                }
+            }
+        }
+        else {
+            columns.push(sql `
+        ARRAY(
+          SELECT to_jsonb(${{ identifier: populate.name }}) FROM (
+            ${_selectRelationPopulate(compiler, parent, populate, field, true)}
+          ) ${{ identifier: populate.name }}
+        ) AS ${{ identifier: field }}
+      `);
+        }
+        return { columns };
     }
     const _local = (field) => sql `${{ identifier: parent.name }}.${{ identifier: field }}`;
     const _foreign = (field) => sql `${{ identifier: populate.name }}.${{ identifier: field }}`;
     const subpaths = resolveSubpaths(compiler, populate);
     return {
         columns: _.compact(_.flatMap(subpaths, ({ path, type }) => [
-            sql `${{ identifier: populate.name }}.${{ identifier: path }} AS ${{ identifier: `${field}.${path}` }}`,
+            ...populate.groupMatches[path] ? _.map(_.keys(populate.groupMatches[path]), k => sql `${{ identifier: populate.name }}.${{ identifier: `${path}.${k}` }} AS ${{ identifier: `${field}.${path}.${k}` }}`) : [
+                sql `${{ identifier: populate.name }}.${{ identifier: path }} AS ${{ identifier: `${field}.${path}` }}`
+            ],
             index.isRelation(type) && sql `${{ identifier: populate.name }}.${{ identifier: `$${path}` }} AS ${{ identifier: `$${field}.${path}` }}`,
         ])),
         join: sql `
@@ -2019,9 +2093,8 @@ const encodePopulate = (compiler, parent, remix) => {
         parent.filter && compiler._encodeFilter(parent, parent.filter),
         compiler.extraFilter && compiler._encodeFilter(parent, compiler.extraFilter(parent.className)),
     ]);
-    const _populates = _.map(parent.populates, (populate, field) => selectPopulate(compiler, parent, populate, field, _.includes(parent.countMatches, field)));
+    const _populates = _.map(parent.populates, (populate, field) => selectPopulate(compiler, parent, populate, field));
     const _joins = _.compact(_.map(_populates, ({ join }) => join));
-    const _includes = _.pickBy(parent.includes, v => index.isPrimitive(v));
     const { joins: _joins2 = [], field: _foreignField = undefined, rows = false, } = parent.foreignField ? encodeForeignField(compiler, {
         className: parent.className,
         name: parent.name,
@@ -2035,7 +2108,7 @@ const encodePopulate = (compiler, parent, remix) => {
         SELECT
         ${{
             literal: [
-                ..._.map(_.keys(_includes), colname => sql `${{ identifier: parent.name }}.${{ identifier: colname }}`),
+                ...compiler._selectIncludes(parent.name, parent.includes),
                 ..._.flatMap(_populates, ({ columns: column }) => column),
                 ..._foreignField ? [sql `${rows ? sql `ARRAY(${_foreignField})` : _foreignField} AS ${{ identifier: parent.colname }}`] : [],
             ], separator: ',\n'
@@ -2088,9 +2161,6 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                         break;
                     return sql `${element} ${nullSafeEqual()} ${{ value: expr.value.objectId }}`;
                 }
-                if (relation && _.includes(parent.countMatches, relation.colname)) {
-                    return sql `${element} ${nullSafeEqual()} ${encodeType(colname, 'number', expr.value)}`;
-                }
                 return sql `${element} ${nullSafeEqual()} ${encodeValue(expr.value)}`;
             }
         case '$ne':
@@ -2104,9 +2174,6 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                         break;
                     return sql `${element} ${nullSafeNotEqual()} ${{ value: expr.value.objectId }}`;
                 }
-                if (relation && _.includes(parent.countMatches, relation.colname)) {
-                    return sql `${element} ${nullSafeNotEqual()} ${encodeType(colname, 'number', expr.value)}`;
-                }
                 return sql `${element} ${nullSafeNotEqual()} ${encodeValue(expr.value)}`;
             }
         case '$gt':
@@ -2150,9 +2217,6 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                 else if (!_.isString(dataType) && dataType?.type === 'pointer' && expr.value instanceof index.TObject && expr.value.objectId) {
                     return sql `${element} ${{ literal: op }} ${{ value: expr.value.objectId }}`;
                 }
-                else if (relation && _.includes(parent.countMatches, relation.colname)) {
-                    return sql `${element} ${{ literal: op }} ${encodeType(colname, 'number', expr.value)}`;
-                }
                 else if (!dataType) {
                     if (expr.value instanceof Decimal || _.isNumber(expr.value)) {
                         return sql `(
@@ -2343,8 +2407,10 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                 if (dataType && index._isTypeof(dataType, 'string')) {
                     return sql `COALESCE(length(${element}), 0) = ${{ value: expr.value }}`;
                 }
-                if (relation && _.includes(parent.countMatches, relation.colname)) {
-                    return sql `${element} = ${{ value: expr.value }}`;
+                if (relation && parent.className && parent.groupMatches?.[colname]) {
+                    const tempName = `_populate_expr_$${compiler.nextIdx()}`;
+                    const populate = _selectRelationPopulate(compiler, { className: parent.className, name: parent.name }, relation.populate, `$${field}`, false);
+                    return sql `(SELECT COUNT(*) FROM (${populate}) AS ${{ identifier: tempName }}) = ${{ value: expr.value }}`;
                 }
                 if (dataType && index._isTypeof(dataType, ['array', 'string[]', 'vector', 'relation'])) {
                     return sql `COALESCE(array_length(${element}, 1), 0) = ${{ value: expr.value }}`;
@@ -2367,8 +2433,10 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                 if (dataType && index._isTypeof(dataType, 'string')) {
                     return sql `COALESCE(length(${element}), 0) ${{ literal: expr.value ? '=' : '<>' }} 0`;
                 }
-                if (relation && _.includes(parent.countMatches, relation.colname)) {
-                    return sql `${element} ${{ literal: expr.value ? '=' : '<>' }} 0`;
+                if (relation && parent.className && parent.groupMatches?.[colname]) {
+                    const tempName = `_populate_expr_$${compiler.nextIdx()}`;
+                    const populate = _selectRelationPopulate(compiler, { className: parent.className, name: parent.name }, relation.populate, `$${field}`, false);
+                    return sql `${{ literal: expr.value ? 'NOT EXISTS' : 'EXISTS' }}(SELECT * FROM (${populate}) AS ${{ identifier: tempName }})`;
                 }
                 if (dataType && index._isTypeof(dataType, ['array', 'string[]', 'vector', 'relation'])) {
                     return sql `COALESCE(array_length(${element}, 1), 0) ${{ literal: expr.value ? '=' : '<>' }} 0`;