remult 3.4.0-next.7 → 3.4.0

package/esm/src/data-providers/sql-database.js

@@ -4,7 +4,7 @@ import { remult as defaultRemult } from '../remult-proxy.js';
 import { GroupByCountMember, GroupByOperators, } from '../remult3/remult3.js';
 import { getRepository, isAutoIncrement, } from '../remult3/RepositoryImplementation.js';
 import { Sort } from '../sort.js';
-import { ValueConverters } from '../valueConverters.js';
+import { fromDbColumn, toDbColumn } from '../valueConverters.js';
 import { getRepositoryInternals } from '../remult3/repository-internals.js';
 import { isOfType } from '../isOfType.js';
 import { originalSqlExpressionKey } from '../filter/fieldDbName.js';
@@ -51,6 +51,9 @@ export class SqlDatabase {
      * Wraps an identifier with the database's identifier syntax.
      */
     wrapIdentifier = (x) => x;
+    get jsonColumnStorage() {
+        return this.sql.supportsJsonColumnType ? 'native' : 'text';
+    }
     /* @internal*/
     _getSourceSql() {
         return this.sql;
@@ -65,18 +68,6 @@ export class SqlDatabase {
      * @returns The entity data provider.
      */
     getEntityDataProvider(entity) {
-        if (!this.sql.supportsJsonColumnType) {
-            for (const f of entity.fields.toArray()) {
-                if (f.valueConverter.fieldTypeInDb === 'json') {
-                    //@ts-ignore
-                    f.valueConverter = {
-                        ...f.valueConverter,
-                        toDb: ValueConverters.JsonString.toDb,
-                        fromDb: ValueConverters.JsonString.fromDb,
-                    };
-                }
-            }
-        }
         return new ActualSQLEntityDataProvider(entity, this, async (dbName) => {
             if (this.createdEntities.indexOf(dbName.$entityName) < 0) {
                 this.createdEntities.push(dbName.$entityName);
@@ -154,7 +145,7 @@ export class SqlDatabase {
         }
         const r = getRepository(repo);
         var b = new FilterConsumerBridgeToSqlRequest(sqlCommand, dbNames ||
-            (await dbNamesOfWithForceSqlExpression(r.metadata, wrapIdentifier)));
+            (await dbNamesOfWithForceSqlExpression(r.metadata, wrapIdentifier)), jsonColumnStorageOf(r));
         b._addWhere = false;
         await (await getRepositoryInternals(r)._translateWhereToFilter(condition)).__applyToConsumer(b);
         return await b.resolveWhere();
@@ -167,7 +158,7 @@ export class SqlDatabase {
     static async groupByToRaw(repo, options, sql) {
         const r = getRepository(repo);
         const built = await buildGroupBySql(await getRepositoryInternals(r).__buildGroupByOptions(options), sql?.dbNames ??
-            (await dbNamesOfWithForceSqlExpression(r.metadata, sql?.wrapIdentifier ?? wrapIdentifierOf(r))), sql?.sqlCommand ?? new myDummySQLCommand(), false, sql?.limitSyntax ?? limitSyntaxRequired);
+            (await dbNamesOfWithForceSqlExpression(r.metadata, sql?.wrapIdentifier ?? wrapIdentifierOf(r))), sql?.sqlCommand ?? new myDummySQLCommand(), false, sql?.limitSyntax ?? limitSyntaxRequired, jsonColumnStorageForRaw(r, sql?.jsonAsString));
         return {
             sql: built.select,
             toResult: (row) => built.toResult((_, alias) => row[alias]),
@@ -181,7 +172,10 @@ export class SqlDatabase {
     static async selectToRaw(repo, options, sql) {
         const r = getRepository(repo);
         const built = await buildFindSql(r.metadata, await getRepositoryInternals(r)._buildEntityDataProviderFindOptions(options ?? {}), sql?.dbNames ??
-            (await dbNamesOfWithForceSqlExpression(r.metadata, sql?.wrapIdentifier ?? wrapIdentifierOf(r))), sql?.sqlCommand ?? new myDummySQLCommand(), false, sql?.limitSyntax ?? limitSyntaxRequired, { aliasColumns: true, defaultOrderBy: false });
+            (await dbNamesOfWithForceSqlExpression(r.metadata, sql?.wrapIdentifier ?? wrapIdentifierOf(r))), sql?.sqlCommand ?? new myDummySQLCommand(), false, sql?.limitSyntax ?? limitSyntaxRequired, {
+            aliasColumns: true,
+            jsonColumnStorage: jsonColumnStorageForRaw(r, sql?.jsonAsString),
+        });
         return {
             sql: built.select,
             toResult: (row) => built.toResult((_, alias) => row[alias]),
@@ -242,12 +236,12 @@ function splitByMaxParameters(items, parametersInItem, maxParameters) {
         batches.push(batch);
     return batches;
 }
-function countInsertBindParameters(entity, e, row) {
+function countInsertBindParameters(entity, e, row, storage) {
     let n = 0;
     for (const x of entity.fields) {
         if (isDbReadonly(x, e))
             continue;
-        if (x.valueConverter.toDb(row[x.key]) != undefined)
+        if (toDbColumn(x, row[x.key], storage) != undefined)
             n++;
     }
     return n;
@@ -339,7 +333,7 @@ class ActualSQLEntityDataProvider {
         let select = 'select count(*) count from ' + e.$entityName;
         let r = this.sql.createCommand();
         if (where) {
-            let wc = new FilterConsumerBridgeToSqlRequest(r, e);
+            let wc = new FilterConsumerBridgeToSqlRequest(r, e, this.sql.jsonColumnStorage);
             where.__applyToConsumer(wc);
             select += await wc.resolveWhere();
         }
@@ -348,17 +342,19 @@ class ActualSQLEntityDataProvider {
         });
     }
     async groupBy(options) {
-        return await groupByImpl(options, await this.init(), this.sql.createCommand(), this.sql._getSourceSql().orderByNullsFirst, this.sql._getSourceSql().getLimitSqlSyntax);
+        return await groupByImpl(options, await this.init(), this.sql.createCommand(), this.sql._getSourceSql().orderByNullsFirst, this.sql._getSourceSql().getLimitSqlSyntax, this.sql.jsonColumnStorage);
     }
     async find(options) {
         const e = await this.init();
         const r = this.sql.createCommand();
-        const { select, toResult } = await buildFindSql(this.entity, options, e, r, this.sql._getSourceSql().orderByNullsFirst, (limit, offset) => this.strategy.getLimitSqlSyntax(limit, offset));
+        if (options && !options.orderBy)
+            options.orderBy = Sort.createUniqueSort(this.entity, new Sort());
+        const { select, toResult } = await buildFindSql(this.entity, options, e, r, this.sql._getSourceSql().orderByNullsFirst, (limit, offset) => this.strategy.getLimitSqlSyntax(limit, offset), { jsonColumnStorage: this.sql.jsonColumnStorage });
         const result = await r.execute(select);
         return result.rows.map((y) => toResult((i) => y[result.getColumnKeyInResultForIndexInSelect(i)]));
     }
     buildResultRow(colKeys, y, r) {
-        return resultRow(colKeys, (i) => y[r.getColumnKeyInResultForIndexInSelect(i)]);
+        return resultRow(colKeys, (i) => y[r.getColumnKeyInResultForIndexInSelect(i)], this.sql.jsonColumnStorage);
     }
     async buildSelect(e, r, selectedFields, args) {
         return selectColumns(this.entity, e, r, selectedFields, args, false);
@@ -372,7 +368,7 @@ class ActualSQLEntityDataProvider {
             if (isDbReadonly(x, e)) {
             }
             else if (data[x.key] !== undefined) {
-                let v = x.valueConverter.toDb(data[x.key]);
+                let v = toDbColumn(x, data[x.key], this.sql.jsonColumnStorage);
                 if (v !== undefined) {
                     if (!added)
                         added = true;
@@ -383,7 +379,7 @@ class ActualSQLEntityDataProvider {
             }
         }
         const idFilter = this.entity.idMetadata.getIdFilter(id);
-        let f = new FilterConsumerBridgeToSqlRequest(r, e);
+        let f = new FilterConsumerBridgeToSqlRequest(r, e, this.sql.jsonColumnStorage);
         Filter.fromEntityFilter(this.entity, idFilter).__applyToConsumer(f);
         statement += await f.resolveWhere();
         let { colKeys, select } = await this.buildSelect(e, r, undefined, undefined);
@@ -417,7 +413,7 @@ class ActualSQLEntityDataProvider {
             return;
         let e = await this.init();
         let r = this.sql.createCommand();
-        let f = new FilterConsumerBridgeToSqlRequest(r, e);
+        let f = new FilterConsumerBridgeToSqlRequest(r, e, this.sql.jsonColumnStorage);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(...ids)).__applyToConsumer(f);
         let statement = 'delete from ' + e.$entityName;
         statement += await f.resolveWhere();
@@ -431,7 +427,7 @@ class ActualSQLEntityDataProvider {
         let e = await this.init();
         const maxParams = this.strategy.maxParametersInOneSqlStatement ??
             defaultMaxParametersInOneSqlStatement;
-        const batches = splitByMaxParameters(data, (row) => countInsertBindParameters(this.entity, e, row), maxParams);
+        const batches = splitByMaxParameters(data, (row) => countInsertBindParameters(this.entity, e, row, this.sql.jsonColumnStorage), maxParams);
         const result = [];
         for (const batch of batches)
             result.push(...(await this.insertBatch(batch, e, options)));
@@ -447,7 +443,7 @@ class ActualSQLEntityDataProvider {
         for (const x of this.entity.fields) {
             if (isDbReadonly(x, e))
                 continue;
-            if (batch.some((row) => x.valueConverter.toDb(row[x.key]) != undefined))
+            if (batch.some((row) => toDbColumn(x, row[x.key], this.sql.jsonColumnStorage) != undefined))
                 cols.push(x);
         }
         let colSql = '';
@@ -465,7 +461,7 @@ class ActualSQLEntityDataProvider {
                 if (j)
                     vals += ', ';
                 const x = cols[j];
-                const v = x.valueConverter.toDb(batch[i][x.key]);
+                const v = toDbColumn(x, batch[i][x.key], this.sql.jsonColumnStorage);
                 if (v != undefined)
                     vals += toDbSql(r, x, v);
                 else if (x.allowNull)
@@ -520,6 +516,17 @@ function wrapIdentifierOf(r) {
         return dp.wrapIdentifier?.bind(dp);
     return undefined;
 }
+export function jsonColumnStorageOf(r) {
+    const dp = getRepositoryInternals(r)._dataProvider;
+    if (isOfType(dp, 'jsonColumnStorage'))
+        return dp.jsonColumnStorage;
+    return 'native';
+}
+function jsonColumnStorageForRaw(r, jsonAsString) {
+    if (jsonAsString === undefined)
+        return jsonColumnStorageOf(r);
+    return jsonAsString ? 'text' : 'native';
+}
 function limitSyntaxRequired() {
     throw new Error('A raw select with a limit needs limitSyntax, for example SqlDatabase.getDb()._getSourceSql().getLimitSqlSyntax');
 }
@@ -560,21 +567,18 @@ export function getRowAfterUpdate(meta, dataProvider, data, id, operation) {
     });
 }
 /** The select that `find` runs, and the mapping of one result row to field values. With `aliasColumns`, every column is aliased through `wrapIdentifier`, so a row can be read by alias as well as by position. */
-export async function buildFindSql(entity, options, e, r, orderByNullsFirst, limitSyntax, { aliasColumns = false, defaultOrderBy = true } = {}) {
+export async function buildFindSql(entity, options, e, r, orderByNullsFirst, limitSyntax, { aliasColumns = false, jsonColumnStorage = 'native', } = {}) {
     const { colKeys, select: columns } = await selectColumns(entity, e, r, options?.select, options?.args, aliasColumns);
     let select = 'select ' + columns + '\n from ' + e.$entityName;
     if (options) {
         if (options.where) {
-            let where = new FilterConsumerBridgeToSqlRequest(r, e);
+            let where = new FilterConsumerBridgeToSqlRequest(r, e, jsonColumnStorage);
             options.where.__applyToConsumer(where);
             select += await where.resolveWhere();
         }
         if (options.limit) {
             options.orderBy = Sort.createUniqueSort(entity, options.orderBy);
         }
-        if (!options.orderBy && defaultOrderBy) {
-            options.orderBy = Sort.createUniqueSort(entity, new Sort());
-        }
         if (options.orderBy) {
             let first = true;
             for (const c of options.orderBy.Segments) {
@@ -611,7 +615,7 @@ export async function buildFindSql(entity, options, e, r, orderByNullsFirst, lim
         colKeys,
         /** `valueAt` reads one column of a result row, by its position in the select or by its alias (the field key). */
         toResult(valueAt) {
-            return resultRow(colKeys, valueAt);
+            return resultRow(colKeys, valueAt, jsonColumnStorage);
         },
     };
 }
@@ -644,11 +648,11 @@ async function selectColumns(entity, e, r, selectedFields, args, aliasColumns) {
     }
     return { colKeys, select };
 }
-function resultRow(colKeys, valueAt) {
+function resultRow(colKeys, valueAt, storage) {
     let result = {};
     colKeys.forEach((col, index) => {
         try {
-            result[col.key] = col.valueConverter.fromDb(valueAt(index, col.key));
+            result[col.key] = fromDbColumn(col, valueAt(index, col.key), storage);
         }
         catch (err) {
             throw new Error('Failed to load from db:' + col.key + '\r\n' + err);
@@ -656,13 +660,13 @@ function resultRow(colKeys, valueAt) {
     });
     return result;
 }
-export async function groupByImpl(options, e, r, orderByNullFirst, limitSyntax) {
-    const { select, toResult } = await buildGroupBySql(options, e, r, orderByNullFirst, limitSyntax);
+export async function groupByImpl(options, e, r, orderByNullFirst, limitSyntax, jsonColumnStorage = 'native') {
+    const { select, toResult } = await buildGroupBySql(options, e, r, orderByNullFirst, limitSyntax, jsonColumnStorage);
     const result = await r.execute(select);
     return result.rows.map((sql) => toResult((i) => sql[result.getColumnKeyInResultForIndexInSelect(i)]));
 }
 /** The select that `groupBy` runs, and the mapping of one result row back to a `GroupByResult`. Every column is aliased through `wrapIdentifier`, so a row can be read by alias as well as by position. */
-export async function buildGroupBySql(options, e, r, orderByNullFirst, limitSyntax) {
+export async function buildGroupBySql(options, e, r, orderByNullFirst, limitSyntax, jsonColumnStorage = 'native') {
     const aliases = [];
     function alias(name) {
         aliases.push(name);
@@ -689,7 +693,7 @@ export async function buildGroupBySql(options, e, r, orderByNullFirst, limitSynt
                 groupByCols.push(e.$dbNameOf(x));
             }
             processResultRow.push((sqlResult, theResult) => {
-                theResult[x.key] = x.valueConverter.fromDb(sqlResult);
+                theResult[x.key] = fromDbColumn(x, sqlResult, jsonColumnStorage);
             });
         }
     for (const operator of GroupByOperators) {
@@ -707,14 +711,14 @@ export async function buildGroupBySql(options, e, r, orderByNullFirst, limitSynt
                     if (turnToNumber)
                         sqlResult = Number(sqlResult);
                     if (operator === 'max' || operator === 'min')
-                        sqlResult = x.valueConverter.fromDb(sqlResult);
+                        sqlResult = fromDbColumn(x, sqlResult, jsonColumnStorage);
                     theResult[x.key] = { ...theResult[x.key], [operator]: sqlResult };
                 });
             }
     }
     select += '\n from ' + e.$entityName;
     if (options?.where) {
-        let where = new FilterConsumerBridgeToSqlRequest(r, e);
+        let where = new FilterConsumerBridgeToSqlRequest(r, e, jsonColumnStorage);
         options?.where.__applyToConsumer(where);
         select += await where.resolveWhere();
     }

package/esm/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -1,11 +1,22 @@
 import { SqlDatabase } from '../data-providers/sql-database.js';
 import { remult } from '../remult-proxy.js';
 import { getEntityMetadata } from '../remult3/RepositoryImplementation.js';
+import { toDbColumn } from '../valueConverters.js';
 import { entityDbName } from './entityDbName.js';
 import { fieldDbName } from './fieldDbName.js';
+// `[` starts a character class in sql server's like. `]` on its own is a literal
+// everywhere, so escaping the opening bracket is enough. The other engines treat
+// an escaped non-wildcard as that literal, so one escape set works for all of them.
+const REGEX_LIKE_SPECIAL = /[!%_\[]/g;
+// `!` not `\`: a backslash in a string literal is an escape in mysql and in pg without standard_conforming_strings
+export const LIKE_ESCAPE_SQL = " escape '!'";
+export function escapeLike(val) {
+    return val.replace(REGEX_LIKE_SPECIAL, '!$&');
+}
 export class FilterConsumerBridgeToSqlRequest {
     r;
     nameProvider;
+    jsonColumnStorage;
     where = '';
     _addWhere = true;
     promises = [];
@@ -19,9 +30,10 @@ export class FilterConsumerBridgeToSqlRequest {
         }
         return this.where;
     }
-    constructor(r, nameProvider) {
+    constructor(r, nameProvider, jsonColumnStorage = 'native') {
         this.r = r;
         this.nameProvider = nameProvider;
+        this.jsonColumnStorage = jsonColumnStorage;
     }
     custom(key, customItem) {
         throw new Error('Custom filter should be translated before it gets here');
@@ -30,7 +42,7 @@ export class FilterConsumerBridgeToSqlRequest {
         let statement = '';
         this.promises.push((async () => {
             for (const element of orElements) {
-                let f = new FilterConsumerBridgeToSqlRequest(this.r, this.nameProvider);
+                let f = new FilterConsumerBridgeToSqlRequest(this.r, this.nameProvider, this.jsonColumnStorage);
                 f._addWhere = false;
                 element.__applyToConsumer(f);
                 let where = await f.resolveWhere();
@@ -52,7 +64,7 @@ export class FilterConsumerBridgeToSqlRequest {
     }
     not(element) {
         this.promises.push((async () => {
-            let f = new FilterConsumerBridgeToSqlRequest(this.r, this.nameProvider);
+            let f = new FilterConsumerBridgeToSqlRequest(this.r, this.nameProvider, this.jsonColumnStorage);
             f._addWhere = false;
             element.__applyToConsumer(f);
             let where = await f.resolveWhere();
@@ -73,7 +85,7 @@ export class FilterConsumerBridgeToSqlRequest {
                 this.addToWhere(this.nameProvider.$dbNameOf(col) +
                     ' in (' +
                     val
-                        .map((x) => toDbSql(this.r, col, col.valueConverter.toDb(x)))
+                        .map((x) => toDbSql(this.r, col, toDbColumn(col, x, this.jsonColumnStorage)))
                         .join(',') +
                     ')');
             else
@@ -99,39 +111,26 @@ export class FilterConsumerBridgeToSqlRequest {
         this.add(col, val, '<');
     }
     containsCaseInsensitive(col, val) {
-        this.promises.push((async () => {
-            this.addToWhere('lower (' +
-                this.nameProvider.$dbNameOf(col) +
-                ") like lower ('%" +
-                val.replace(/'/g, "''") +
-                "%')");
-        })());
+        this.like(col, '%' + escapeLike(val) + '%');
     }
     notContainsCaseInsensitive(col, val) {
-        this.promises.push((async () => {
-            this.addToWhere('not lower (' +
-                this.nameProvider.$dbNameOf(col) +
-                ") like lower ('%" +
-                val.replace(/'/g, "''") +
-                "%')");
-        })());
+        this.like(col, '%' + escapeLike(val) + '%', 'not ');
     }
     startsWithCaseInsensitive(col, val) {
-        this.promises.push((async () => {
-            this.addToWhere('lower (' +
-                this.nameProvider.$dbNameOf(col) +
-                ") like lower ('" +
-                val.replace(/'/g, "''") +
-                "%')");
-        })());
+        this.like(col, escapeLike(val) + '%');
     }
     endsWithCaseInsensitive(col, val) {
+        this.like(col, '%' + escapeLike(val));
+    }
+    like(col, pattern, not = '') {
         this.promises.push((async () => {
-            this.addToWhere('lower (' +
+            this.addToWhere(not +
+                'lower (' +
                 this.nameProvider.$dbNameOf(col) +
-                ") like lower ('%" +
-                val.replace(/'/g, "''") +
-                "')");
+                ') like lower (' +
+                this.r.param(pattern) +
+                ')' +
+                LIKE_ESCAPE_SQL);
         })());
     }
     add(col, val, operator) {
@@ -140,7 +139,7 @@ export class FilterConsumerBridgeToSqlRequest {
                 ' ' +
                 operator +
                 ' ' +
-                toDbSql(this.r, col, col.valueConverter.toDb(val));
+                toDbSql(this.r, col, toDbColumn(col, val, this.jsonColumnStorage));
             this.addToWhere(x);
         })());
     }
@@ -156,7 +155,7 @@ export class FilterConsumerBridgeToSqlRequest {
     databaseCustom(databaseCustom) {
         this.promises.push((async () => {
             if (databaseCustom?.buildSql) {
-                let item = new CustomSqlFilterBuilder(this.r, this.nameProvider.wrapIdentifier);
+                let item = new CustomSqlFilterBuilder(this.r, this.nameProvider.wrapIdentifier, this.jsonColumnStorage);
                 let sql = await databaseCustom.buildSql(item);
                 if (typeof sql !== 'string')
                     sql = item.sql;
@@ -173,9 +172,11 @@ export class FilterConsumerBridgeToSqlRequest {
 export class CustomSqlFilterBuilder {
     r;
     wrapIdentifier;
-    constructor(r, wrapIdentifier) {
+    jsonColumnStorage;
+    constructor(r, wrapIdentifier, jsonColumnStorage = 'native') {
         this.r = r;
         this.wrapIdentifier = wrapIdentifier;
+        this.jsonColumnStorage = jsonColumnStorage;
         this.param.bind(this);
         this.filterToRaw.bind(this);
     }
@@ -191,8 +192,8 @@ export class CustomSqlFilterBuilder {
      * @returns {string} - The SQL token.
      */
     param = (val, field) => {
-        if (typeof field === 'object' && field.valueConverter.toDb) {
-            val = field.valueConverter.toDb(val);
+        if (field) {
+            val = toDbColumn(field, val, this.jsonColumnStorage);
         }
         return this.r.param(val);
     };

package/esm/src/filter/walk-filter.js

@@ -0,0 +1,29 @@
+/** Return this from {@link walkFilter}'s visitor to drop that field key. */
+export const omitFilterField = Symbol('omitFilterField');
+function isCompoundFilterKey(key) {
+    return key === '$and' || key === '$or' || key === '$not';
+}
+// `$and`, `$or`, and `$not` are entered. Every other key is a field, passed to `visit`.
+// `visit` returns the value to keep, or `omitFilterField` to drop the key.
+export function walkFilter(filter, visit) {
+    if (Array.isArray(filter)) {
+        const result = [];
+        for (const item of filter)
+            result.push(walkFilter(item, visit));
+        return result;
+    }
+    if (!filter || typeof filter !== 'object')
+        return filter;
+    const result = {};
+    for (const key of Object.keys(filter)) {
+        const value = filter[key];
+        if (isCompoundFilterKey(key)) {
+            result[key] = walkFilter(value, visit);
+            continue;
+        }
+        const next = visit(key, value);
+        if (next !== omitFilterField)
+            result[key] = next;
+    }
+    return result;
+}

package/esm/src/remult-proxy.js

@@ -124,10 +124,10 @@ export class RemultProxy {
                 .remultFactory()
                 .repo(...args)
                 .updateMany(...args2),
-            find: (...args2) => self
+            find: (options) => self
                 .remultFactory()
                 .repo(...args)
-                .find(...args2),
+                .find(options),
             groupBy: (...args2) => self
                 .remultFactory()
                 .repo(...args)
@@ -138,14 +138,14 @@ export class RemultProxy {
                 .repo(...args)
                 //@ts-ignore
                 .aggregate(...args2),
-            findFirst: (...args2) => self
+            findFirst: (where, options) => self
                 .remultFactory()
                 .repo(...args)
-                .findFirst(...args2),
-            findOne: (...args2) => self
+                .findFirst(where, options),
+            findOne: (options) => self
                 .remultFactory()
                 .repo(...args)
-                .findOne(...args2),
+                .findOne(options),
             findId: (a, b) => self
                 .remultFactory()
                 .repo(...args)

package/esm/src/remult3/RepositoryImplementation.js

@@ -41,6 +41,18 @@ let classValidatorValidate = undefined;
 //     })
 //     .catch(() => {
 //     });
+// Assigning a `toOne` also writes its `field`/`fields`, which would wipe the FK of a row whose
+// target is missing.
+function setMissingRelationToNull(row, key) {
+    const ref = getEntityRef(row);
+    ref._skipRelationFieldSync = true;
+    try {
+        row[key] = null;
+    }
+    finally {
+        ref._skipRelationFieldSync = false;
+    }
+}
 export class RepositoryImplementation {
     _entity;
     _remult;
@@ -597,7 +609,16 @@ export class RepositoryImplementation {
         if (this._defaultFindOptions) {
             options = { ...this._defaultFindOptions, ...options };
         }
-        let opt = await this._buildEntityDataProviderFindOptions(options);
+        let findOptions = options;
+        if ((!findOptions.orderBy || Object.keys(findOptions.orderBy).length === 0) &&
+            !this._dataProvider.isProxy &&
+            this._info.entityInfo.defaultOrderBy) {
+            findOptions = {
+                ...findOptions,
+                orderBy: this._info.entityInfo.defaultOrderBy,
+            };
+        }
+        let opt = await this._buildEntityDataProviderFindOptions(findOptions);
         if (skipOrderByAndLimit) {
             delete opt.orderBy;
             delete opt.limit;
@@ -633,10 +654,6 @@ export class RepositoryImplementation {
                 return f.key;
             });
         }
-        if (!options.orderBy || Object.keys(options.orderBy).length === 0) {
-            if (!this._dataProvider.isProxy)
-                options.orderBy = this._info.entityInfo.defaultOrderBy;
-        }
         opt.where = await this._translateWhereToFilter(options.where);
         if (options.orderBy !== undefined)
             opt.orderBy = Sort.translateOrderByToSort(this.metadata, options.orderBy);
@@ -727,10 +744,12 @@ export class RepositoryImplementation {
                     for (const row of result) {
                         let { findOptions, returnNull, returnUndefined } = this._findOptionsBasedOnRelation(rel, col, incl, row, otherRepo);
                         const colKey = col.key;
-                        if (returnNull)
-                            row[colKey] = null;
-                        else if (returnUndefined)
-                            row[colKey] = undefined;
+                        if (returnNull || returnUndefined) {
+                            if (rel.type === 'toMany')
+                                row[colKey] = (returnNull ? null : undefined);
+                            else
+                                setMissingRelationToNull(row, colKey);
+                        }
                         else {
                             const entityType = rel.toEntity;
                             const toRepo = otherRepo;
@@ -741,14 +760,12 @@ export class RepositoryImplementation {
                                 metadata: toRepo.metadata,
                             }, findOptions)
                                 .then((result) => {
-                                if (result.length == 0 && rel.type == 'toOne')
-                                    return;
-                                row[colKey] =
-                                    rel.type !== 'toMany'
-                                        ? result.length == 0
-                                            ? null
-                                            : result[0]
-                                        : result;
+                                if (rel.type === 'toMany')
+                                    row[colKey] = result;
+                                else if (result.length == 0)
+                                    setMissingRelationToNull(row, colKey);
+                                else
+                                    row[colKey] = result[0];
                             });
                         }
                     }
@@ -1184,7 +1201,7 @@ class rowHelperBase {
                         },
                         set: (newVal) => {
                             val = newVal;
-                            if (newVal === undefined)
+                            if (newVal === undefined || this._skipRelationFieldSync)
                                 return;
                             const op = col.options;
                             if (op.field) {
@@ -1209,6 +1226,7 @@ class rowHelperBase {
             }
         }
     }
+    _skipRelationFieldSync = false;
     _subscribers;
     subscribe(listener) {
         this.initSubscribers();
@@ -1667,7 +1685,9 @@ export class rowHelperImplementation extends rowHelperBase {
                         await listener.saved?.(this.instance, true);
                     }
             }
-            this.repo._remult.liveQueryPublisher.itemChanged(this.repo.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: false }]);
+            this.repo._remult.liveQueryPublisher.itemChanged(this.repo.metadata.key, [
+                { id: this.getId(), oldId: this.getOriginalId(), deleted: false },
+            ]);
             this.saveOriginalData();
             this._isNew = false;
             return this.instance;
@@ -2454,21 +2474,21 @@ export class ValueListInfo {
     getValues() {
         return this.values;
     }
-    byId(key) {
-        if (this.isNumeric)
-            key = +key;
-        return this.byIdMap.get(key);
-    }
-    fromJson(val) {
-        const known = this.byId(val);
-        if (known !== undefined)
+    /** Declared id only. Pass `useUnknownIdValue` to also apply `unknownIdValue` (`null` and `undefined` still return `undefined`). */
+    byId(key, useUnknownIdValue = false) {
+        const lookupKey = this.isNumeric ? +key : key;
+        const known = this.byIdMap.get(lookupKey);
+        if (known !== undefined || !useUnknownIdValue)
             return known;
-        if (val == null)
+        if (key == null)
             return undefined;
         const fallback = this.unknownIdValue;
         if (typeof fallback !== 'function')
             return fallback;
-        return fallback(this.isNumeric ? +val : val);
+        return fallback(lookupKey);
+    }
+    fromJson(val) {
+        return this.byId(val, true);
     }
     toJson(val) {
         if (!val)

package/esm/src/sort.js

@@ -128,9 +128,6 @@ export class Sort {
      * @returns {Sort} A `Sort` instance representing the unique sort criteria.
      */
     static createUniqueSort(entityMetadata, orderBy) {
-        if ((!orderBy || Object.keys(orderBy).length === 0) &&
-            entityMetadata.options.defaultOrderBy)
-            orderBy = Sort.translateOrderByToSort(entityMetadata, entityMetadata.options.defaultOrderBy);
         if (!orderBy)
             orderBy = new Sort();
         for (const field of entityMetadata.idMetadata.fields) {

package/esm/src/valueConverters.js

@@ -211,6 +211,17 @@ export class ValueConverters {
         fieldTypeInDb: 'json',
     };
 }
+export function fromDbColumn(field, value, storage) {
+    if (storage === 'text' && field.valueConverter.fieldTypeInDb === 'json')
+        return ValueConverters.JsonString.fromDb(value);
+    return field.valueConverter.fromDb(value);
+}
+export function toDbColumn(field, value, storage) {
+    if ((storage === 'text' || storage === 'textOnWrite') &&
+        field.valueConverter.fieldTypeInDb === 'json')
+        return ValueConverters.JsonString.toDb(value);
+    return field.valueConverter.toDb(value);
+}
 function enforceString(value) {
     if (value === null || value === undefined)
         return value;