proto.io 0.0.163 → 0.0.165

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-CSNRyhjB.js');
 require('@o2ter/crypto-js');
-var random$1 = require('../../internals/random-uT4D0y_q.js');
+var random$1 = require('../../internals/random-q0PeamQE.js');
 var _private = require('../../internals/private-CSB1Ep4g.js');
 
 //
@@ -116,7 +116,8 @@ class SQL {
                 query += dialect.boolean(value.value);
             }
             else if (_.isString(value.value)) {
-                query += `${dialect.quote(value.value)}::TEXT`;
+                query += `${dialect.placeholder(nextIdx())}::TEXT`;
+                values.push(value.value);
             }
             else if (_.isSafeInteger(value.value)) {
                 query += `${value.value}`;
@@ -223,12 +224,14 @@ class QueryCompiler {
     dialect;
     selectLock;
     isUpdate;
+    extraFilter;
     idx = 0;
-    constructor(schema, dialect, selectLock, isUpdate) {
-        this.schema = schema;
-        this.dialect = dialect;
-        this.selectLock = selectLock;
-        this.isUpdate = isUpdate;
+    constructor(options) {
+        this.schema = options.schema;
+        this.dialect = options.dialect;
+        this.selectLock = options.selectLock;
+        this.isUpdate = options.isUpdate;
+        this.extraFilter = options.extraFilter;
     }
     nextIdx() {
         return this.idx++;
@@ -285,11 +288,11 @@ class QueryCompiler {
     }
     _baseSelectQuery(query, options) {
         const context = this._makeContext(query);
-        const _stages = _.mapValues(context.populates, (populate) => this.dialect.encodePopulate(this, context, populate));
+        const _stages = _.mapValues(context.populates, (populate) => this.dialect.encodePopulate(this, populate));
         const stages = _.fromPairs(_.flatMap(_.values(_stages), (p) => _.toPairs(p)));
         const fetchName = `_fetch_$${query.className.toLowerCase()}`;
         const parent = { className: query.className, name: fetchName };
-        const baseFilter = this._encodeFilter(context, parent, query.filter);
+        const baseFilter = this._encodeFilter(parent, query.filter);
         const populates = this._selectPopulateMap(context, query.className, fetchName);
         const joins = _.compact(_.map(populates, ({ join }) => join));
         const includes = {
@@ -303,7 +306,7 @@ class QueryCompiler {
         const filter = _.compact([
             baseFilter,
             _options?.extraFilter,
-            query.relatedBy && this.dialect.encodeRelation(this, context, parent, query.relatedBy),
+            query.relatedBy && this.dialect.encodeRelation(this, parent, query.relatedBy),
         ]);
         return {
             stages,
@@ -324,9 +327,9 @@ class QueryCompiler {
       `,
         };
     }
-    _refetch(name, query, context) {
+    _refetch(name, query) {
         const _context = this._encodeIncludes(query.className, query.includes, query.matches);
-        const populates = _.mapValues(_context.populates, (populate) => this.dialect.encodePopulate(this, context, populate, { className: query.className, name }));
+        const populates = _.mapValues(_context.populates, (populate) => this.dialect.encodePopulate(this, populate, { className: query.className, name }));
         const stages = _.fromPairs(_.flatMap(_.values(populates), (p) => _.toPairs(p)));
         const _populates = this._selectPopulateMap(_context, query.className, name);
         const _joins = _.compact(_.map(_populates, ({ join }) => join));
@@ -397,8 +400,8 @@ class QueryCompiler {
         }
         return result;
     }
-    _encodeCoditionalSelector(parent, filter, context) {
-        const queries = _.compact(_.map(filter.exprs, x => this._encodeFilter(context, parent, x)));
+    _encodeCoditionalSelector(parent, filter) {
+        const queries = _.compact(_.map(filter.exprs, x => this._encodeFilter(parent, x)));
         if (_.isEmpty(queries))
             return;
         switch (filter.type) {
@@ -407,12 +410,12 @@ class QueryCompiler {
             case '$or': return sql `(${{ literal: _.map(queries, x => sql `(${x})`), separator: ' OR ' }})`;
         }
     }
-    _encodeFilter(context, parent, filter) {
+    _encodeFilter(parent, filter) {
         if (filter instanceof index$1.QueryCoditionalSelector) {
-            return this._encodeCoditionalSelector(parent, filter, context);
+            return this._encodeCoditionalSelector(parent, filter);
         }
         if (filter instanceof index$1.QueryFieldSelector) {
-            return this.dialect.encodeFieldExpression(this, context, parent, filter.field, filter.expr);
+            return this.dialect.encodeFieldExpression(this, parent, filter.field, filter.expr);
         }
         if (filter instanceof index$1.QueryExpressionSelector) {
             return this.dialect.encodeQueryExpression(this, parent, filter.expr);
@@ -453,7 +456,7 @@ class QueryCompiler {
         });
         const name = `_insert_$${options.className.toLowerCase()}`;
         const context = this._makeContext(options);
-        const populates = _.mapValues(context.populates, (populate) => this.dialect.encodePopulate(this, context, populate));
+        const populates = _.mapValues(context.populates, (populate) => this.dialect.encodePopulate(this, populate));
         const stages = _.fromPairs(_.flatMap(_.values(populates), (p) => _.toPairs(p)));
         const _populates = this._selectPopulateMap(context, options.className, name);
         const joins = _.compact(_.map(_populates, ({ join }) => join));
@@ -488,7 +491,7 @@ class QueryCompiler {
     `;
     }
     updateOne(query, update) {
-        return this._modifyQuery({ ...query, limit: 1 }, (fetchName, context) => {
+        return this._modifyQuery({ ...query, limit: 1 }, (fetchName) => {
             const name = `_update_$${query.className.toLowerCase()}`;
             return sql `
           , ${{ identifier: name }} AS (
@@ -498,7 +501,7 @@ class QueryCompiler {
             WHERE ${{ identifier: query.className }}._id IN (SELECT ${{ identifier: fetchName }}._id FROM ${{ identifier: fetchName }})
             RETURNING *
           )
-          ${this._refetch(name, query, context)}
+          ${this._refetch(name, query)}
         `;
         });
     }
@@ -507,7 +510,7 @@ class QueryCompiler {
             ..._defaultInsertOpts(query),
             ...this._encodeObjectAttrs(query.className, setOnInsert),
         });
-        return this._modifyQuery({ ...query, limit: 1 }, (fetchName, context) => {
+        return this._modifyQuery({ ...query, limit: 1 }, (fetchName) => {
             const updateName = `_update_$${query.className.toLowerCase()}`;
             const insertName = `_insert_$${query.className.toLowerCase()}`;
             const upsertName = `_upsert_$${query.className.toLowerCase()}`;
@@ -531,7 +534,7 @@ class QueryCompiler {
             UNION
             SELECT * FROM ${{ identifier: insertName }}
           )
-          ${this._refetch(upsertName, query, context)}
+          ${this._refetch(upsertName, query)}
         `;
         });
     }
@@ -666,12 +669,21 @@ class SqlStorage {
         }
         return obj;
     }
+    _makeCompiler(isUpdate, extraFilter) {
+        return new QueryCompiler({
+            schema: this.schema,
+            dialect: this.dialect,
+            selectLock: this.selectLock(),
+            isUpdate,
+            extraFilter,
+        });
+    }
     async explain(query) {
-        const compiler = new QueryCompiler(this.schema, this.dialect, this.selectLock(), false);
+        const compiler = this._makeCompiler(false, query.extraFilter);
         return this._explain(compiler, query);
     }
     async count(query) {
-        const compiler = new QueryCompiler(this.schema, this.dialect, this.selectLock(), false);
+        const compiler = this._makeCompiler(false, query.extraFilter);
         const [{ count: _count }] = await this.query(compiler._selectQuery(query, {
             select: sql `COUNT(*) AS count`,
         }));
@@ -680,7 +692,7 @@ class SqlStorage {
     }
     find(query) {
         const self = this;
-        const compiler = new QueryCompiler(self.schema, self.dialect, self.selectLock(), false);
+        const compiler = self._makeCompiler(false, query.extraFilter);
         const _query = compiler._selectQuery(query);
         return (async function* () {
             const objects = self.query(_query);
@@ -691,7 +703,7 @@ class SqlStorage {
     }
     random(query, opts) {
         const self = this;
-        const compiler = new QueryCompiler(self.schema, self.dialect, self.selectLock(), false);
+        const compiler = self._makeCompiler(false, query.extraFilter);
         const _query = compiler._selectQuery({ ...query, sort: {} }, {
             sort: sql `ORDER BY ${self.dialect.random(opts ?? {})}`,
         });
@@ -718,7 +730,7 @@ class SqlStorage {
     }
     nonrefs(query) {
         const self = this;
-        const compiler = new QueryCompiler(self.schema, self.dialect, self.selectLock(), false);
+        const compiler = self._makeCompiler(false, query.extraFilter);
         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' }})`)})
@@ -732,32 +744,32 @@ class SqlStorage {
         })();
     }
     async insert(options, attrs) {
-        const compiler = new QueryCompiler(this.schema, this.dialect, this.selectLock(), true);
+        const compiler = this._makeCompiler(true);
         const result = _.first(await this.query(compiler.insert(options, attrs)));
         return _.isNil(result) ? undefined : this._decodeObject(options.className, result);
     }
     async insertMany(options, values) {
-        const compiler = new QueryCompiler(this.schema, this.dialect, this.selectLock(), true);
+        const compiler = this._makeCompiler(true);
         const result = await this.query(compiler.insertMany(options, values));
         return result.length;
     }
     async updateOne(query, update) {
-        const compiler = new QueryCompiler(this.schema, this.dialect, this.selectLock(), true);
+        const compiler = this._makeCompiler(true, query.extraFilter);
         const updated = _.first(await this.query(compiler.updateOne(query, update)));
         return _.isNil(updated) ? undefined : this._decodeObject(query.className, updated);
     }
     async upsertOne(query, update, setOnInsert) {
-        const compiler = new QueryCompiler(this.schema, this.dialect, this.selectLock(), true);
+        const compiler = this._makeCompiler(true, query.extraFilter);
         const upserted = _.first(await this.query(compiler.upsertOne(query, update, setOnInsert)));
         return _.isNil(upserted) ? undefined : this._decodeObject(query.className, upserted);
     }
     async deleteOne(query) {
-        const compiler = new QueryCompiler(this.schema, this.dialect, this.selectLock(), true);
+        const compiler = this._makeCompiler(true, query.extraFilter);
         const deleted = _.first(await this.query(compiler.deleteOne(query)));
         return _.isNil(deleted) ? undefined : this._decodeObject(query.className, deleted);
     }
     async deleteMany(query) {
-        const compiler = new QueryCompiler(this.schema, this.dialect, this.selectLock(), true);
+        const compiler = this._makeCompiler(true, query.extraFilter);
         const deleted = await this.query(compiler.deleteMany(query));
         return deleted.length;
     }
@@ -1113,10 +1125,55 @@ class PostgresClientDriver {
         });
     }
 }
+class PostgresPubSub {
+    client;
+    subscribers = {};
+    channels = [];
+    constructor(client) {
+        this.client = client;
+        (async () => {
+            try {
+                (await client).on('notification', ({ channel, payload }) => {
+                    if (!payload)
+                        return;
+                    try {
+                        const _payload = index._decodeValue(JSON.parse(payload));
+                        for (const subscriber of this.subscribers[_.toUpper(channel)]) {
+                            subscriber(_payload);
+                        }
+                    }
+                    catch (e) {
+                        console.error(`Unknown payload: ${e}`);
+                    }
+                });
+            }
+            catch (e) {
+                console.error(e);
+            }
+        })();
+    }
+    async shutdown() {
+        (await this.client).release();
+    }
+    async listen(channel) {
+        this.channels.push(channel);
+        await (await this.client).query(`LISTEN ${channel}`);
+    }
+    subscribe(channel, callback) {
+        if (_.isNil(this.subscribers[channel]))
+            this.subscribers[channel] = [];
+        this.subscribers[channel].push(callback);
+        return () => {
+            this.subscribers[channel] = this.subscribers[channel].filter(x => x !== callback);
+        };
+    }
+    isEmpty() {
+        return _.every(_.values(this.subscribers), x => _.isEmpty(x));
+    }
+}
 class PostgresDriver extends PostgresClientDriver {
     database;
     pubsub;
-    subscribers = [];
     constructor(config) {
         if (_.isEmpty(config))
             throw Error('Invalid postgre config.');
@@ -1129,26 +1186,11 @@ class PostgresDriver extends PostgresClientDriver {
         await this._release_pubsub();
         await this.database.end();
     }
-    async _init_pubsub() {
+    _init_pubsub() {
         if (this.pubsub)
             return;
         try {
-            this.pubsub = this.database.connect();
-            const pubsub = await this.pubsub;
-            pubsub.on('notification', ({ channel, payload }) => {
-                if (_.toUpper(channel) !== PROTO_POSTGRES_MSG || !payload)
-                    return;
-                try {
-                    const _payload = index._decodeValue(JSON.parse(payload));
-                    for (const subscriber of this.subscribers) {
-                        subscriber(_payload);
-                    }
-                }
-                catch (e) {
-                    console.error(`Unknown payload: ${e}`);
-                }
-            });
-            await pubsub.query(`LISTEN ${PROTO_POSTGRES_MSG}`);
+            this.pubsub = new PostgresPubSub(this.database.connect());
         }
         catch (e) {
             console.error(e);
@@ -1157,18 +1199,22 @@ class PostgresDriver extends PostgresClientDriver {
     async _release_pubsub() {
         const pubsub = this.pubsub;
         this.pubsub = undefined;
-        await (await pubsub)?.release();
+        await pubsub?.shutdown();
     }
-    subscribe(callback) {
+    _subscribe(channel, callback) {
         this._init_pubsub();
-        this.subscribers.push(callback);
+        if (!_.includes(this.pubsub.channels, channel))
+            this.pubsub.listen(channel);
+        const release = this.pubsub.subscribe(channel, callback);
         return () => {
-            this.subscribers = this.subscribers.filter(x => x !== callback);
-            if (_.isEmpty(this.subscribers)) {
+            release();
+            if (this.pubsub?.isEmpty())
                 this._release_pubsub();
-            }
         };
     }
+    subscribe(callback) {
+        return this._subscribe(PROTO_POSTGRES_MSG, callback);
+    }
 }
 
 //
@@ -1856,7 +1902,7 @@ const encodeQueryExpression = (compiler, parent, expr) => {
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 //
-const encodeFieldExpression = (compiler, context, parent, field, expr) => {
+const encodeFieldExpression = (compiler, parent, field, expr) => {
     const [colname] = _.toPath(field);
     const { element, dataType, relation } = fetchElement(compiler, parent, field);
     const encodeValue = (value) => dataType ? encodeType(colname, dataType, value) : _encodeJsonValue(index._encodeValue(value));
@@ -2085,7 +2131,7 @@ const encodeFieldExpression = (compiler, context, parent, field, expr) => {
             {
                 if (!(expr.value instanceof index$1.FieldSelectorExpression))
                     break;
-                return sql `NOT (${encodeFieldExpression(compiler, context, parent, field, expr.value)})`;
+                return sql `NOT (${encodeFieldExpression(compiler, parent, field, expr.value)})`;
             }
         case '$pattern':
             {
@@ -2177,7 +2223,7 @@ const encodeFieldExpression = (compiler, context, parent, field, expr) => {
                 if (!(expr.value instanceof index$1.QuerySelector))
                     break;
                 const tempName = `_expr_$${compiler.nextIdx()}`;
-                const filter = compiler._encodeFilter(context, { name: tempName, className: relation?.target }, expr.value);
+                const filter = compiler._encodeFilter({ name: tempName, className: relation?.target }, expr.value);
                 if (!filter)
                     break;
                 if (relation) {
@@ -2204,7 +2250,7 @@ const encodeFieldExpression = (compiler, context, parent, field, expr) => {
                 if (!(expr.value instanceof index$1.QuerySelector))
                     break;
                 const tempName = `_expr_$${compiler.nextIdx()}`;
-                const filter = compiler._encodeFilter(context, { name: tempName, className: relation?.target }, expr.value);
+                const filter = compiler._encodeFilter({ name: tempName, className: relation?.target }, expr.value);
                 if (!filter)
                     break;
                 if (relation) {
@@ -2298,31 +2344,36 @@ const selectPopulate = (compiler, parent, populate, field) => {
     const _local = (field) => sql `${{ identifier: parent.name }}.${{ identifier: field }}`;
     const _foreign = (field) => sql `${{ identifier: populate.name }}.${{ identifier: field }}`;
     const subpaths = resolveSubpaths(compiler, populate);
+    const cond = [];
+    if (compiler.extraFilter) {
+        const filter = compiler.extraFilter(populate.className);
+        cond.push(compiler._encodeFilter(populate, filter));
+    }
     if (populate.type === 'pointer') {
+        cond.push(sql `${sql `(${{ quote: populate.className + '$' }} || ${_foreign('_id')})`} = ${_local(field)}`);
         return {
             columns: _.map(subpaths, ({ path }) => sql `${{ identifier: populate.name }}.${{ identifier: path }} AS ${{ identifier: `${field}.${path}` }}`),
             join: sql `
         LEFT JOIN ${{ identifier: populate.name }}
-        ON ${sql `(${{ quote: populate.className + '$' }} || ${_foreign('_id')})`} = ${_local(field)}
+        ON ${{ literal: _.map(_.compact(cond), x => sql `(${x})`), separator: ' AND ' }}
       `,
         };
     }
-    let cond;
     if (_.isNil(populate.foreignField)) {
-        cond = sql `${sql `(${{ quote: populate.className + '$' }} || ${_foreign('_id')})`} = ANY(${_local(field)})`;
+        cond.push(sql `${sql `(${{ quote: populate.className + '$' }} || ${_foreign('_id')})`} = ANY(${_local(field)})`);
     }
     else if (_isPointer(compiler.schema, populate.className, populate.foreignField)) {
-        cond = sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ${_foreign(populate.colname)}`;
+        cond.push(sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ${_foreign(populate.colname)}`);
     }
     else {
-        cond = sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ANY(${_foreign(populate.colname)})`;
+        cond.push(sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ANY(${_foreign(populate.colname)})`);
     }
     return {
         columns: [sql `
       ARRAY(
         SELECT to_jsonb(${{ identifier: populate.name }}) FROM (
           SELECT ${_.map(subpaths, ({ path, type }) => _encodePopulateInclude(populate.name, path, type))}
-          FROM ${{ identifier: populate.name }} WHERE ${cond}
+          FROM ${{ identifier: populate.name }} WHERE ${{ literal: _.map(_.compact(cond), x => sql `(${x})`), separator: ' AND ' }}
           ${!_.isEmpty(populate.sort) ? sql `ORDER BY ${compiler._encodeSort(populate.sort, { className: populate.className, name: populate.name })}` : sql ``}
           ${populate.limit ? sql `LIMIT ${{ literal: `${populate.limit}` }}` : sql ``}
           ${populate.skip ? sql `OFFSET ${{ literal: `${populate.skip}` }}` : sql ``}
@@ -2335,13 +2386,13 @@ const selectPopulate = (compiler, parent, populate, field) => {
 const encodeRemix = (parent, remix) => sql `${remix?.className === parent.className ? sql `
   (SELECT * FROM ${{ identifier: remix.name }} UNION SELECT * FROM ${{ identifier: parent.className }})
 ` : { identifier: parent.className }}`;
-const encodeForeignField = (compiler, context, parent, foreignField, remix) => {
+const encodeForeignField = (compiler, parent, foreignField, remix) => {
     const { paths: [colname, ...subpath], dataType } = random$1.resolveColumn(compiler.schema, parent.className, foreignField);
     const tempName = `_populate_$${compiler.nextIdx()}`;
     const _local = (field) => sql `${{ identifier: parent.name }}.${{ identifier: field }}`;
     const _foreign = (field) => sql `${{ identifier: tempName }}.${{ identifier: field }}`;
     if (_.isEmpty(subpath) && index.isRelation(dataType) && dataType.foreignField) {
-        const { joins, field, rows, array } = encodeForeignField(compiler, context, { className: dataType.target, name: tempName }, dataType.foreignField, remix);
+        const { joins, field, rows, array } = encodeForeignField(compiler, { className: dataType.target, name: tempName }, dataType.foreignField, remix);
         return {
             joins: [],
             field: sql `(
@@ -2364,27 +2415,32 @@ const encodeForeignField = (compiler, context, parent, foreignField, remix) => {
     }
     if (!index.isPointer(dataType) && !index.isRelation(dataType))
         throw Error(`Invalid path: ${foreignField}`);
-    const { joins, field, rows, array } = encodeForeignField(compiler, context, { className: dataType.target, name: tempName }, subpath.join('.'), remix);
+    const { joins, field, rows, array } = encodeForeignField(compiler, { className: dataType.target, name: tempName }, subpath.join('.'), remix);
+    const cond = [];
+    if (compiler.extraFilter) {
+        const filter = compiler.extraFilter(dataType.target);
+        cond.push(compiler._encodeFilter({ className: dataType.target, name: tempName }, filter));
+    }
     if (index.isPointer(dataType)) {
+        cond.push(sql `${sql `(${{ quote: dataType.target + '$' }} || ${_foreign('_id')})`} = ${_local(colname)}`);
         return {
             joins: [sql `
         LEFT JOIN ${encodeRemix({ className: dataType.target }, remix)} AS ${{ identifier: tempName }}
-        ON ${sql `(${{ quote: dataType.target + '$' }} || ${_foreign('_id')})`} = ${_local(colname)}
+        ON ${{ literal: _.map(_.compact(cond), x => sql `(${x})`), separator: ' AND ' }}
       `, ...joins],
             field,
             array,
             rows,
         };
     }
-    let cond;
     if (_.isNil(dataType.foreignField)) {
-        cond = sql `${sql `(${{ quote: dataType.target + '$' }} || ${_foreign('_id')})`} = ANY(${_local(colname)})`;
+        cond.push(sql `${sql `(${{ quote: dataType.target + '$' }} || ${_foreign('_id')})`} = ANY(${_local(colname)})`);
     }
     else if (_isPointer(compiler.schema, dataType.target, dataType.foreignField)) {
-        cond = sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ${_foreign(dataType.foreignField)}`;
+        cond.push(sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ${_foreign(dataType.foreignField)}`);
     }
     else {
-        cond = sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ANY(${_foreign(dataType.foreignField)})`;
+        cond.push(sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ANY(${_foreign(dataType.foreignField)})`);
     }
     return {
         joins: [],
@@ -2392,23 +2448,23 @@ const encodeForeignField = (compiler, context, parent, foreignField, remix) => {
       SELECT ${array ? sql `UNNEST(${field})` : field}
       FROM ${encodeRemix({ className: dataType.target }, remix)} AS ${{ identifier: tempName }}
       ${!_.isEmpty(joins) ? { literal: joins, separator: '\n' } : sql ``}
-      WHERE ${cond}
+      WHERE ${{ literal: _.map(_.compact(cond), x => sql `(${x})`), separator: ' AND ' }}
     )`,
         array: false,
         rows: true,
     };
 };
-const encodePopulate = (compiler, context, parent, remix) => {
-    const _filter = compiler._encodeFilter(context, parent, parent.filter);
+const encodePopulate = (compiler, parent, remix) => {
+    const _filter = parent.filter && compiler._encodeFilter(parent, parent.filter);
     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, context, {
+    const { joins: _joins2 = [], field: _foreignField = undefined, rows = false, } = parent.foreignField ? encodeForeignField(compiler, {
         className: parent.className,
         name: parent.name,
     }, parent.foreignField, remix) : {};
     return _.reduce(parent.populates, (acc, populate) => ({
-        ...encodePopulate(compiler, context, populate, remix),
+        ...encodePopulate(compiler, populate, remix),
         ...acc,
     }), {
         [parent.name]: sql `
@@ -2453,11 +2509,11 @@ const encodePopulate = (compiler, context, parent, remix) => {
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 //
-const encodeRelation = (compiler, context, parent, relatedBy) => {
+const encodeRelation = (compiler, parent, relatedBy) => {
     const name = `_relation_$${relatedBy.className.toLowerCase()}`;
     const _local = (field) => sql `${{ identifier: parent.name }}.${{ identifier: field }}`;
     const _foreign = (field) => sql `${{ identifier: name }}.${{ identifier: field }}`;
-    const { joins, field } = encodeForeignField(compiler, context, { className: relatedBy.className, name }, relatedBy.key);
+    const { joins, field } = encodeForeignField(compiler, { className: relatedBy.className, name }, relatedBy.key);
     return sql `EXISTS (
     SELECT 1
     FROM ${{ identifier: relatedBy.className }} AS ${{ identifier: name }}