remult 3.4.0-next.1 → 3.4.0-next.10

package/SseSubscriptionServer.d.ts

@@ -1,10 +1,12 @@
 import type { GenericResponse } from './server/index.js';
+import type { SubscriptionServerRouteApi } from './server/remult-api-server.js';
 import type { Remult } from './src/context.js';
 import type { SubscriptionServer } from './src/live-query/SubscriptionServer.js';
 /** Keep below typical proxy idle (30s) and Heroku H15 (55s). */
 export declare const ssePingMs = 15000;
 export declare class SseSubscriptionServer implements SubscriptionServer {
     private canUserConnectToChannel?;
+    initApiServer(api: SubscriptionServerRouteApi): void;
     constructor(canUserConnectToChannel?: ((channel: string, remult: Remult) => boolean) | undefined);
     publishMessage<T>(channel: string, message: any): Promise<void>;
 }

package/SseSubscriptionServer.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.clientConnection = exports.SseSubscriptionServer = exports.ssePingMs = void 0;
 var tslib_1 = require("tslib");
 var SseSubscriptionClient_js_1 = require("./src/live-query/SseSubscriptionClient.js");
+var SubscriptionChannel_js_1 = require("./src/live-query/SubscriptionChannel.js");
 /** Keep below typical proxy idle (30s) and Heroku H15 (55s). */
 exports.ssePingMs = 15000;
 var SseSubscriptionServer = /** @class */ (function () {
@@ -18,6 +19,45 @@ var SseSubscriptionServer = /** @class */ (function () {
             this.canUserConnectToChannel = function () { return true; };
         }
     }
+    SseSubscriptionServer.prototype.initApiServer = function (api) {
+        var _this = this;
+        var streamPath = '/' + SubscriptionChannel_js_1.streamUrl;
+        api.addRoute(streamPath, 'get', function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
+            var req = _b.req, origRes = _b.origRes;
+            return tslib_1.__generator(this, function (_c) {
+                this.openHttpServerStream(req, origRes);
+                return [2 /*return*/];
+            });
+        }); });
+        api.addRoute(streamPath + '/subscribe', 'post', function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
+            var _c;
+            var remult = _b.remult, res = _b.res, getBody = _b.getBody;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _c = this.subscribeToChannel;
+                        return [4 /*yield*/, getBody()];
+                    case 1:
+                        _c.apply(this, [_d.sent(), res, remult]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        api.addRoute(streamPath + '/unsubscribe', 'post', function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
+            var _c;
+            var remult = _b.remult, res = _b.res, getBody = _b.getBody;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _c = this.subscribeToChannel;
+                        return [4 /*yield*/, getBody()];
+                    case 1:
+                        _c.apply(this, [_d.sent(), res, remult, true]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    };
     //@internal
     SseSubscriptionServer.prototype.subscribeToChannel = function (_a, res, remult, remove) {
         var e_1, _b;

package/esm/SseSubscriptionServer.js

@@ -1,8 +1,21 @@
 import { ConnectionNotFoundError } from './src/live-query/SseSubscriptionClient.js';
+import { streamUrl } from './src/live-query/SubscriptionChannel.js';
 /** Keep below typical proxy idle (30s) and Heroku H15 (55s). */
 export const ssePingMs = 15_000;
 export class SseSubscriptionServer {
     canUserConnectToChannel;
+    initApiServer(api) {
+        const streamPath = '/' + streamUrl;
+        api.addRoute(streamPath, 'get', async ({ req, origRes }) => {
+            this.openHttpServerStream(req, origRes);
+        });
+        api.addRoute(streamPath + '/subscribe', 'post', async ({ remult, res, getBody }) => {
+            this.subscribeToChannel(await getBody(), res, remult);
+        });
+        api.addRoute(streamPath + '/unsubscribe', 'post', async ({ remult, res, getBody }) => {
+            this.subscribeToChannel(await getBody(), res, remult, true);
+        });
+    }
     //@internal
     subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
         for (const c of this.connections) {

package/esm/index.js

@@ -9,31 +9,32 @@ export { LabelTransformer } from './src/remult3/RepositoryImplementation.js';
 export const CaptionTransformer = LabelTransformer;
 export { Entity } from './src/remult3/entity.js';
 export { getEntityRef } from './src/remult3/getEntityRef.js';
-export { Field, Fields, Relations, } from './src/remult3/Fields.js';
+export { Field, Fields, Relations } from './src/remult3/Fields.js';
 export { IdEntity } from './src/remult3/IdEntity.js';
 export { describeClass, describeBackendMethods, describeEntity, } from './src/remult3/classDescribers.js';
-export { EntityError, } from './src/data-interfaces.js'; //V
+export { EntityError } from './src/data-interfaces.js'; //V
 export { RestDataProvider } from './src/data-providers/rest-data-provider.js'; //V
 export { InMemoryDataProvider } from './src/data-providers/in-memory-database.js'; //V
 export { SqlDatabase } from './src/data-providers/sql-database.js'; //V
 export { CustomSqlFilterBuilder, dbNamesOf, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
-export { JsonDataProvider, } from './src/data-providers/json-data-provider.js'; //V
+export { JsonDataProvider } from './src/data-providers/json-data-provider.js'; //V
 export { JsonEntityOpfsStorage } from './src/data-providers/json-entity-opfs-storage.js';
 export { JsonEntityIndexedDbStorage } from './src/data-providers/json-entity-indexed-db-data-provider.js';
+export { IndexedDbDataProvider, IndexedDbIndexBuilder, } from './src/data-providers/indexed-db-data-provider.js';
 //export * from './src/data-api'; //reconsider if to make internal
 export { Controller, BackendMethod, ProgressListener, ForbiddenError, } from './src/server-action.js';
 export { Allow, Remult, withRemult, isBackend, EventSource, } from './src/context.js';
 export { Sort } from './src/sort.js';
 export { CompoundIdField } from './src/CompoundIdField.js';
-export { Filter, } from './src/filter/filter-interfaces.js';
+export { Filter } from './src/filter/filter-interfaces.js';
 export { UrlBuilder } from './urlBuilder.js';
 export { Validators, valueValidator, createValidator, createValidatorWithArgs, createValueValidatorWithArgs, createValueValidator, } from './src/validators.js';
 export { ValueConverters } from './src/valueConverters.js';
 export { remult } from './src/remult-proxy.js';
 import { remult } from './src/remult-proxy.js';
 //export { getId } from './src/remult3/getId';
-export { InMemoryLiveQueryStorage, } from './src/live-query/SubscriptionServer.js';
-export { SubscriptionChannel, } from './src/live-query/SubscriptionChannel.js';
+export { InMemoryLiveQueryStorage } from './src/live-query/SubscriptionServer.js';
+export { SubscriptionChannel } from './src/live-query/SubscriptionChannel.js';
 /**
  * A convenient shortcut function to quickly obtain a repository for a specific entity type in Remult.
  *

package/esm/internals.js

@@ -4,8 +4,10 @@ export { getRelationInfo, getRelationFieldInfo, } from './src/remult3/relationIn
 export { decorateColumnSettings, controllerRefImpl, getControllerRef, fieldOptionsEnricher, } from './src/remult3/RepositoryImplementation.js';
 export { getEntitySettings } from './src/remult3/getEntityRef.js';
 export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces.js';
+export { omitFilterField, walkFilter } from './src/filter/walk-filter.js';
 export const actionInfo = remultStatic.actionInfo;
 export { isOfType } from './src/isOfType.js';
 export { flags } from './src/remult3/remult3.js';
+export { SseSubscriptionClient } from './src/live-query/SseSubscriptionClient.js';
 export { DataProviderPromiseWrapper } from './src/data-interfaces.js';
 export { pagedQueryResult } from './src/remult3/pagedQueryResult.js';

package/esm/remult-d1.js

@@ -6,6 +6,7 @@ export function createD1DataProvider(d1) {
 }
 export class D1DataProvider extends SqliteCoreDataProvider {
     d1;
+    maxParametersInOneSqlStatement = 100;
     /**
      * For production or local d1 using binding
      *

package/esm/remult-knex/index.js

@@ -1,12 +1,12 @@
-import { CustomSqlFilterBuilder, dbNamesOfWithForceSqlExpression, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+import { CustomSqlFilterBuilder, dbNamesOfWithForceSqlExpression, escapeLike, LIKE_ESCAPE_SQL, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
 import { dbNamesOf, isDbReadonly, shouldCreateEntity, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
 import { customDatabaseFilterToken, Filter, } from '../src/filter/filter-interfaces.js';
 import { remult as remultContext } from '../src/remult-proxy.js';
 import { getRepository, isAutoIncrement, } from '../src/remult3/RepositoryImplementation.js';
 import { Sort } from '../src/sort.js';
-import { ValueConverters } from '../src/valueConverters.js';
+import { fromDbColumn, toDbColumn, ValueConverters, } from '../src/valueConverters.js';
 import { getRepositoryInternals } from '../src/remult3/repository-internals.js';
-import { groupByImpl, getRowAfterUpdate, } from '../src/data-providers/sql-database.js';
+import { groupByImpl, getRowAfterUpdate, jsonColumnStorageOf, } from '../src/data-providers/sql-database.js';
 export class KnexDataProvider {
     knex;
     constructor(knex) {
@@ -46,29 +46,14 @@ export class KnexDataProvider {
         return r.knex;
     }
     wrapIdentifier = (x) => this.knex.ref(x) + '';
-    getEntityDataProvider(entity) {
+    get jsonColumnStorage() {
         if (!supportsJsonLoadingAndSaving(this.knex))
-            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,
-                    };
-                }
-            }
-        else if (this.knex.client.config.client === 'mysql2') {
-            for (const f of entity.fields.toArray()) {
-                if (f.valueConverter.fieldTypeInDb === 'json') {
-                    //@ts-ignore
-                    f.valueConverter = {
-                        ...f.valueConverter,
-                        toDb: ValueConverters.JsonString.toDb,
-                    };
-                }
-            }
-        }
+            return 'text';
+        if (this.knex.client.config.client === 'mysql2')
+            return 'textOnWrite';
+        return 'native';
+    }
+    getEntityDataProvider(entity) {
         return new KnexEntityDataProvider(entity, this.knex, this.wrapIdentifier, this);
     }
     async transaction(action) {
@@ -93,7 +78,7 @@ export class KnexDataProvider {
         if (!wrapIdentifier)
             wrapIdentifier = (x) => x;
         const repo = getRepository(entity);
-        var b = new FilterConsumerBridgeToKnexRequest(await dbNamesOfWithForceSqlExpression(repo.metadata, wrapIdentifier), wrapIdentifier ?? wrapIdentifier);
+        var b = new FilterConsumerBridgeToKnexRequest(await dbNamesOfWithForceSqlExpression(repo.metadata, wrapIdentifier), wrapIdentifier ?? wrapIdentifier, jsonColumnStorageOf(repo));
         b._addWhere = false;
         await (await getRepositoryInternals(repo)._translateWhereToFilter(condition)).__applyToConsumer(b);
         let r = await b.resolveWhere();
@@ -119,7 +104,7 @@ class KnexEntityDataProvider {
     async groupBy(options) {
         return groupByImpl(options, await dbNamesOf(this.entity, this.dp.wrapIdentifier), this.dp.createCommand(), false, (limit, offset) => this.knex.client.config.client?.includes('mssql')
             ? ' offset ' + offset + ' rows fetch next ' + limit + ' rows only'
-            : ' limit ' + limit + ' offset ' + offset);
+            : ' limit ' + limit + ' offset ' + offset, this.dp.jsonColumnStorage);
     }
     getEntityFrom(e) {
         if (this.entity.options.sqlExpression)
@@ -128,7 +113,7 @@ class KnexEntityDataProvider {
     }
     async count(where) {
         const e = await this.init();
-        const br = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier);
+        const br = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier, this.dp.jsonColumnStorage);
         where.__applyToConsumer(br);
         let r = await br.resolveWhere();
         const result = await this.getEntityFrom(e)
@@ -162,7 +147,7 @@ class KnexEntityDataProvider {
         }
         let query = this.getEntityFrom(e).select(cols);
         if (options?.where) {
-            const br = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier);
+            const br = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier, this.dp.jsonColumnStorage);
             options.where.__applyToConsumer(br);
             let r = await br.resolveWhere();
             query.where((b) => r.forEach((y) => y(b)));
@@ -188,7 +173,7 @@ class KnexEntityDataProvider {
             for (let m in y) {
                 let field = colKeys[i++];
                 try {
-                    result[field.key] = field.valueConverter.fromDb(y[m]);
+                    result[field.key] = fromDbColumn(field, y[m], this.dp.jsonColumnStorage);
                 }
                 catch (err) {
                     throw new Error('Failed to load from db:' + field.key + '\r\n' + err);
@@ -212,14 +197,14 @@ class KnexEntityDataProvider {
     }
     async update(id, data, options) {
         const e = await this.init();
-        let f = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier);
+        let f = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier, this.dp.jsonColumnStorage);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
         let updateObject = {};
         for (const x of this.entity.fields) {
             if (isDbReadonly(x, e)) {
             }
             else if (data[x.key] !== undefined) {
-                let v = translateValueAndHandleArrayAndHandleArray(x, data[x.key]);
+                let v = translateValueAndHandleArrayAndHandleArray(x, data[x.key], this.dp.jsonColumnStorage);
                 if (v !== undefined) {
                     let key = await e.$dbNameOf(x);
                     updateObject[key] = v;
@@ -234,23 +219,91 @@ class KnexEntityDataProvider {
             return undefined;
         return getRowAfterUpdate(this.entity, this, data, id, 'update');
     }
-    async delete(id) {
+    async delete(ids) {
+        if (ids.length === 0)
+            return;
         const e = await this.init();
-        let f = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier);
-        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+        let f = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier, this.dp.jsonColumnStorage);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(...ids)).__applyToConsumer(f);
         let where = await f.resolveWhere();
         await this.getEntityFrom(e)
             .delete()
             .where((b) => where.forEach((w) => w(b)));
     }
     async insert(data, options) {
+        if (data.length === 0)
+            return [];
+        if (isMysqlKnex(this.knex) &&
+            isAutoIncrement(this.entity.idMetadata.field) &&
+            options?.select !== 'none') {
+            const result = [];
+            for (const row of data)
+                result.push(await this.insertOne(row, options));
+            return result;
+        }
+        const e = await this.init();
+        const batches = splitByMaxParameters(data, (row) => countKnexInsertBindParameters(this.entity, e, row, this.dp.jsonColumnStorage), knexMaxParametersInOneSqlStatement(this.knex));
+        const result = [];
+        for (const batch of batches)
+            result.push(...(await this.insertBatch(batch, e, options)));
+        return result;
+    }
+    async insertBatch(batch, e, options) {
+        const cols = [];
+        for (const x of this.entity.fields) {
+            if (isDbReadonly(x, e))
+                continue;
+            if (batch.some((row) => translateValueAndHandleArrayAndHandleArray(x, row[x.key], this.dp.jsonColumnStorage) != undefined))
+                cols.push(x);
+        }
+        const insertObjects = [];
+        for (const row of batch) {
+            const insertObject = {};
+            for (const x of cols) {
+                const v = translateValueAndHandleArrayAndHandleArray(x, row[x.key], this.dp.jsonColumnStorage);
+                const key = await e.$dbNameOf(x);
+                if (v != undefined)
+                    insertObject[key] = v;
+                else if (x.allowNull)
+                    insertObject[key] = null;
+                else
+                    insertObject[key] = this.knex.raw('DEFAULT');
+            }
+            insertObjects.push(insertObject);
+        }
+        let insert = this.getEntityFrom(e).insert(insertObjects);
+        const wantRows = options?.select !== 'none';
+        if (isAutoIncrement(this.entity.idMetadata.field) && wantRows) {
+            const result = await insert.returning(this.entity.idMetadata.field.dbName);
+            const ids = result.map((r) => r && typeof r === 'object' ? r[this.entity.idMetadata.field.dbName] : r);
+            return this.loadRowsByIds(ids);
+        }
+        await insert;
+        if (!wantRows)
+            return batch.map(() => undefined);
+        return this.loadRowsByIds(batch.map((row) => this.entity.idMetadata.getId(row)));
+    }
+    async loadRowsByIds(ids) {
+        const found = await this.find({
+            where: Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(...ids)),
+        });
+        const byId = new Map(found.map((row) => [this.entity.idMetadata.getId(row) + '', row]));
+        return ids.map((id) => {
+            const row = byId.get(id + '');
+            if (!row)
+                throw new Error(`Failed to insert row - result contained ${found.length} rows`);
+            return row;
+        });
+    }
+    //@internal
+    async insertOne(data, options) {
         const e = await this.init();
         let insertObject = {};
         for (const x of this.entity.fields) {
             if (isDbReadonly(x, e)) {
             }
             else {
-                let v = translateValueAndHandleArrayAndHandleArray(x, data[x.key]);
+                let v = translateValueAndHandleArrayAndHandleArray(x, data[x.key], this.dp.jsonColumnStorage);
                 if (v != undefined) {
                     let key = await e.$dbNameOf(x);
                     insertObject[key] = v;
@@ -286,6 +339,7 @@ class KnexEntityDataProvider {
 class FilterConsumerBridgeToKnexRequest {
     innerNameProvider;
     rawSqlWrapIdentifier;
+    jsonColumnStorage;
     _addWhere = true;
     promises = [];
     result = [];
@@ -299,9 +353,10 @@ class FilterConsumerBridgeToKnexRequest {
         }
         return this.result;
     }
-    constructor(innerNameProvider, rawSqlWrapIdentifier) {
+    constructor(innerNameProvider, rawSqlWrapIdentifier, jsonColumnStorage) {
         this.innerNameProvider = innerNameProvider;
         this.rawSqlWrapIdentifier = rawSqlWrapIdentifier;
+        this.jsonColumnStorage = jsonColumnStorage;
     }
     custom(key, customItem) {
         throw new Error('Custom filter should be translated before it gets here');
@@ -310,7 +365,7 @@ class FilterConsumerBridgeToKnexRequest {
         this.promises.push((async () => {
             const result = [];
             for (const element of orElements) {
-                let f = new FilterConsumerBridgeToKnexRequest(this.innerNameProvider, this.rawSqlWrapIdentifier);
+                let f = new FilterConsumerBridgeToKnexRequest(this.innerNameProvider, this.rawSqlWrapIdentifier, this.jsonColumnStorage);
                 f._addWhere = false;
                 element.__applyToConsumer(f);
                 let where = await f.resolveWhere();
@@ -331,7 +386,7 @@ class FilterConsumerBridgeToKnexRequest {
     }
     not(element) {
         this.promises.push((async () => {
-            let f = new FilterConsumerBridgeToKnexRequest(this.innerNameProvider, this.rawSqlWrapIdentifier);
+            let f = new FilterConsumerBridgeToKnexRequest(this.innerNameProvider, this.rawSqlWrapIdentifier, this.jsonColumnStorage);
             f._addWhere = false;
             element.__applyToConsumer(f);
             let where = await f.resolveWhere();
@@ -353,7 +408,7 @@ class FilterConsumerBridgeToKnexRequest {
         this.result.push((b) => b.whereNotNull(this.innerNameProvider.$dbNameOf(col)));
     }
     isIn(col, val) {
-        this.result.push((knex) => knex.whereIn(this.innerNameProvider.$dbNameOf(col), val.map((x) => translateValueAndHandleArrayAndHandleArray(col, x))));
+        this.result.push((knex) => knex.whereIn(this.innerNameProvider.$dbNameOf(col), val.map((x) => translateValueAndHandleArrayAndHandleArray(col, x, this.jsonColumnStorage))));
     }
     isEqualTo(col, val) {
         this.add(col, val, '=');
@@ -374,39 +429,27 @@ class FilterConsumerBridgeToKnexRequest {
         this.add(col, val, '<');
     }
     containsCaseInsensitive(col, val) {
-        this.result.push((b) => b.whereRaw('lower (' +
-            b.client.ref(this.innerNameProvider.$dbNameOf(col)) +
-            ") like lower ('%" +
-            val.replace(/'/g, "''") +
-            "%')"));
-        this.promises.push((async () => { })());
+        this.like(col, '%' + escapeLike(val) + '%');
     }
     notContainsCaseInsensitive(col, val) {
-        this.result.push((b) => b.whereRaw('not lower (' +
-            b.client.ref(this.innerNameProvider.$dbNameOf(col)) +
-            ") like lower ('%" +
-            val.replace(/'/g, "''") +
-            "%')"));
-        this.promises.push((async () => { })());
+        this.like(col, '%' + escapeLike(val) + '%', 'not ');
     }
     startsWithCaseInsensitive(col, val) {
-        this.result.push((b) => b.whereRaw('lower (' +
-            b.client.ref(this.innerNameProvider.$dbNameOf(col)) +
-            ") like lower ('" +
-            val.replace(/'/g, "''") +
-            "%')"));
-        this.promises.push((async () => { })());
+        this.like(col, escapeLike(val) + '%');
     }
     endsWithCaseInsensitive(col, val) {
-        this.result.push((b) => b.whereRaw('lower (' +
+        this.like(col, '%' + escapeLike(val));
+    }
+    like(col, pattern, not = '') {
+        this.result.push((b) => b.whereRaw(not +
+            'lower (' +
             b.client.ref(this.innerNameProvider.$dbNameOf(col)) +
-            ") like lower ('%" +
-            val.replace(/'/g, "''") +
-            "')"));
+            ') like lower (?)' +
+            LIKE_ESCAPE_SQL, [pattern]));
         this.promises.push((async () => { })());
     }
     add(col, val, operator) {
-        this.result.push((b) => b.where(this.innerNameProvider.$dbNameOf(col), operator, translateValueAndHandleArrayAndHandleArray(col, val)));
+        this.result.push((b) => b.where(this.innerNameProvider.$dbNameOf(col), operator, translateValueAndHandleArrayAndHandleArray(col, val, this.jsonColumnStorage)));
     }
     databaseCustom(databaseCustom) {
         this.promises.push((async () => {
@@ -415,7 +458,7 @@ class FilterConsumerBridgeToKnexRequest {
             }
             if (databaseCustom?.buildSql) {
                 let r = new KnexCommandHelper();
-                const item = new CustomSqlFilterBuilder(r, this.rawSqlWrapIdentifier);
+                const item = new CustomSqlFilterBuilder(r, this.rawSqlWrapIdentifier, this.jsonColumnStorage);
                 let sql = await databaseCustom.buildSql(item);
                 if (typeof sql !== 'string')
                     sql = item.sql;
@@ -591,8 +634,48 @@ export async function createKnexDataProvider(config) {
     let result = new KnexDataProvider(k);
     return result;
 }
-function translateValueAndHandleArrayAndHandleArray(field, val) {
-    let result = field.valueConverter.toDb(val);
+const defaultMaxParametersInOneSqlStatement = 2000;
+function isMysqlKnex(knex) {
+    const client = knex.client.config.client;
+    return client === 'mysql2' || client === 'mysql';
+}
+function knexMaxParametersInOneSqlStatement(knex) {
+    const client = String(knex.client.config.client ?? '');
+    if (client.includes('sqlite'))
+        return 999;
+    return defaultMaxParametersInOneSqlStatement;
+}
+function splitByMaxParameters(items, parametersInItem, maxParameters) {
+    const batches = [];
+    let batch = [];
+    let params = 0;
+    for (const item of items) {
+        const n = parametersInItem(item);
+        if (batch.length > 0 && params + n > maxParameters) {
+            batches.push(batch);
+            batch = [];
+            params = 0;
+        }
+        batch.push(item);
+        params += n;
+    }
+    if (batch.length)
+        batches.push(batch);
+    return batches;
+}
+function countKnexInsertBindParameters(entity, e, row, storage) {
+    let n = 0;
+    for (const x of entity.fields) {
+        if (isDbReadonly(x, e))
+            continue;
+        if (translateValueAndHandleArrayAndHandleArray(x, row[x.key], storage) !=
+            undefined)
+            n++;
+    }
+    return n;
+}
+function translateValueAndHandleArrayAndHandleArray(field, val, storage) {
+    let result = toDbColumn(field, val, storage);
     if (Array.isArray(result))
         return JSON.stringify(result);
     return result;

package/esm/remult-mongo.js

@@ -119,6 +119,8 @@ class MongoEntityDataProvider {
     translateToDb(row, nameProvider) {
         let result = {};
         for (const col of this.entity.fields) {
+            if (col.dbReadOnly || col.isServerExpression)
+                continue;
             let val = toDb(col, row[col.key]);
             if (val === null)
                 val = NULL;
@@ -255,7 +257,7 @@ class MongoEntityDataProvider {
         for (const f of this.entity.fields) {
             if (!f.dbReadOnly && !f.isServerExpression) {
                 if (keys.includes(f.key)) {
-                    newR[f.key] = toDb(f, data[f.key]);
+                    newR[e.$dbNameOf(f)] = toDb(f, data[f.key]);
                 }
             }
         }
@@ -266,22 +268,31 @@ class MongoEntityDataProvider {
             return undefined;
         return getRowAfterUpdate(this.entity, this, data, id, 'update');
     }
-    async delete(id) {
+    async delete(ids) {
+        if (ids.length === 0)
+            return;
         const { e, collection } = await this.collection();
         let f = new FilterConsumerBridgeToMongo(e);
-        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        await collection.deleteOne(await f.resolveWhere(), {
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(...ids)).__applyToConsumer(f);
+        await collection.deleteMany(await f.resolveWhere(), {
             session: this.session,
         });
     }
     async insert(data, options) {
+        if (data.length === 0)
+            return [];
         let { collection, e } = await this.collection();
-        let r = await collection.insertOne(await this.translateToDb(data, e), {
-            session: this.session,
-        });
+        const docs = [];
+        for (const row of data)
+            docs.push(await this.translateToDb(row, e));
+        const r = await collection.insertMany(docs, { session: this.session });
         if (options?.select === 'none')
-            return undefined;
-        return await this.translateFromDb(await collection.findOne({ _id: r.insertedId }, { session: this.session }), e);
+            return data.map(() => undefined);
+        const result = [];
+        for (let i = 0; i < data.length; i++) {
+            result.push(await this.translateFromDb(await collection.findOne({ _id: r.insertedIds[i] }, { session: this.session }), e));
+        }
+        return result;
     }
     async collection() {
         const e = await dbNamesOf(this.entity);
@@ -377,23 +388,27 @@ class FilterConsumerBridgeToMongo {
         this.add(col, val, '$lt');
     }
     containsCaseInsensitive(col, val) {
-        this.add(col, val, '$regex', { $options: 'i' });
+        this.addRegex(col, val);
     }
     notContainsCaseInsensitive(col, val) {
-        this.result.push(() => ({
-            [this.nameProvider.$dbNameOf(col)]: {
-                $not: {
-                    $regex: isNull(val) ? val : toDb(col, val),
-                    $options: 'i',
-                },
-            },
-        }));
+        this.addRegex(col, val, '', '', true);
     }
     startsWithCaseInsensitive(col, val) {
-        this.add(col, `^${val}`, '$regex', { $options: 'i' });
+        this.addRegex(col, val, '^');
     }
     endsWithCaseInsensitive(col, val) {
-        this.add(col, `${val}$`, '$regex', { $options: 'i' });
+        this.addRegex(col, val, '', '$');
+    }
+    addRegex(col, val, start = '', end = '', negate = false) {
+        this.result.push(() => {
+            const regex = {
+                $regex: start + toDb(col, val).replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + end,
+                $options: 'i',
+            };
+            return {
+                [this.nameProvider.$dbNameOf(col)]: negate ? { $not: regex } : regex,
+            };
+        });
     }
     add(col, val, operator, moreOptions) {
         this.result.push(() => ({

package/esm/remult-sqlite-core.js

@@ -13,6 +13,7 @@ export class SqliteCoreDataProvider {
         this.doesNotSupportReturningSyntaxOnlyForUpdate = doesNotSupportReturningSyntaxOnlyForUpdate;
     }
     orderByNullsFirst;
+    maxParametersInOneSqlStatement = 999;
     getLimitSqlSyntax(limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     }