remult 3.3.19-next.2 → 3.4.0-next.2

package/SseSubscriptionServer.d.ts

@@ -1,6 +1,8 @@
 import type { GenericResponse } from './server/index.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?;
     constructor(canUserConnectToChannel?: ((channel: string, remult: Remult) => boolean) | undefined);

package/SseSubscriptionServer.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clientConnection = exports.SseSubscriptionServer = void 0;
+exports.clientConnection = exports.SseSubscriptionServer = exports.ssePingMs = void 0;
 var tslib_1 = require("tslib");
 var SseSubscriptionClient_js_1 = require("./src/live-query/SseSubscriptionClient.js");
+/** Keep below typical proxy idle (30s) and Heroku H15 (55s). */
+exports.ssePingMs = 15000;
 var SseSubscriptionServer = /** @class */ (function () {
     function SseSubscriptionServer(canUserConnectToChannel) {
         this.canUserConnectToChannel = canUserConnectToChannel;
@@ -137,7 +139,7 @@ var clientConnection = /** @class */ (function () {
         this.write('', 'keep-alive');
         this.timeOutRef = setTimeout(function () {
             _this.sendLiveMessage();
-        }, 45000);
+        }, exports.ssePingMs);
     };
     return clientConnection;
 }());

package/esm/SseSubscriptionServer.js

@@ -1,4 +1,6 @@
 import { ConnectionNotFoundError } from './src/live-query/SseSubscriptionClient.js';
+/** Keep below typical proxy idle (30s) and Heroku H15 (55s). */
+export const ssePingMs = 15_000;
 export class SseSubscriptionServer {
     canUserConnectToChannel;
     //@internal
@@ -101,6 +103,6 @@ export class clientConnection {
         this.write('', 'keep-alive');
         this.timeOutRef = setTimeout(() => {
             this.sendLiveMessage();
-        }, 45000);
+        }, ssePingMs);
     }
 }

package/esm/index.js

@@ -9,32 +9,31 @@ 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/live-query/data-provider-live-query-storage.js

@@ -52,12 +52,14 @@ export class DataProviderLiveQueryStorage {
     }
     async keepAliveAndReturnUnknownQueryIds(queryIds) {
         const repo = await this.repo;
+        const versions = {};
         for (const query of await repo.find({ where: { id: queryIds } })) {
             query.lastUsedIso = new Date().toISOString();
             await repo.save(query);
+            versions[query.id] = query.data?.version ?? 0;
             queryIds = queryIds.filter((x) => x !== query.id);
         }
-        return queryIds;
+        return { unknownQueryIds: queryIds, versions };
     }
 }
 let LiveQueryStorageEntity = class LiveQueryStorageEntity extends EntityBase {

package/esm/remult-d1.js

@@ -6,7 +6,6 @@ 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

@@ -234,87 +234,16 @@ class KnexEntityDataProvider {
             return undefined;
         return getRowAfterUpdate(this.entity, this, data, id, 'update');
     }
-    async delete(ids) {
-        if (ids.length === 0)
-            return;
+    async delete(id) {
         const e = await this.init();
         let f = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier);
-        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(...ids)).__applyToConsumer(f);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__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), 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]) !=
-                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]);
-                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) {
@@ -662,45 +591,6 @@ export async function createKnexDataProvider(config) {
     let result = new KnexDataProvider(k);
     return result;
 }
-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) {
-    let n = 0;
-    for (const x of entity.fields) {
-        if (isDbReadonly(x, e))
-            continue;
-        if (translateValueAndHandleArrayAndHandleArray(x, row[x.key]) != undefined)
-            n++;
-    }
-    return n;
-}
 function translateValueAndHandleArrayAndHandleArray(field, val) {
     let result = field.valueConverter.toDb(val);
     if (Array.isArray(result))

package/esm/remult-mongo.js

@@ -266,31 +266,22 @@ class MongoEntityDataProvider {
             return undefined;
         return getRowAfterUpdate(this.entity, this, data, id, 'update');
     }
-    async delete(ids) {
-        if (ids.length === 0)
-            return;
+    async delete(id) {
         const { e, collection } = await this.collection();
         let f = new FilterConsumerBridgeToMongo(e);
-        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(...ids)).__applyToConsumer(f);
-        await collection.deleteMany(await f.resolveWhere(), {
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+        await collection.deleteOne(await f.resolveWhere(), {
             session: this.session,
         });
     }
     async insert(data, options) {
-        if (data.length === 0)
-            return [];
         let { collection, e } = await this.collection();
-        const docs = [];
-        for (const row of data)
-            docs.push(await this.translateToDb(row, e));
-        const r = await collection.insertMany(docs, { session: this.session });
+        let r = await collection.insertOne(await this.translateToDb(data, e), {
+            session: this.session,
+        });
         if (options?.select === 'none')
-            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;
+            return undefined;
+        return await this.translateFromDb(await collection.findOne({ _id: r.insertedId }, { session: this.session }), e);
     }
     async collection() {
         const e = await dbNamesOf(this.entity);

package/esm/remult-sqlite-core.js

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

package/esm/server/remult-api-server.js

@@ -281,7 +281,12 @@ export class RemultServerImplementation {
                 }));
             }
             r.route(this.options.rootPath + '/' + liveQueryKeepAliveRoute).post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
-                res.success(await remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(await this.coreOptions.getRequestBody(origReq)));
+                const body = await this.coreOptions.getRequestBody(origReq);
+                const queryIds = Array.isArray(body)
+                    ? body
+                    : (body?.queryIds ?? []);
+                const result = await remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(queryIds);
+                res.success(Array.isArray(body) ? result.unknownQueryIds : result);
             }));
         }
         this.entities.forEach((e) => {

package/esm/src/data-api.js

@@ -358,6 +358,7 @@ export class DataApi {
                 requestJson: await serializeContext(),
                 findOptionsJson: findOptionsToJson(r.findOptions, this.repository.metadata),
                 lastIds: r.r.map((y) => this.repository.metadata.idMetadata.getId(y)),
+                version: 0,
             };
             await this.remult.liveQueryStorage.add({
                 entityKey: this.repository.metadata.key,

package/esm/src/data-interfaces.js

@@ -40,11 +40,11 @@ class EntityDataProviderPromiseWrapper {
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
     }
-    delete(ids) {
-        return this.dataProvider.then((dp) => dp.delete(ids));
+    delete(id) {
+        return this.dataProvider.then((dp) => dp.delete(id));
     }
-    insert(data, options) {
-        return this.dataProvider.then((dp) => dp.insert(data, options));
+    insert(data) {
+        return this.dataProvider.then((dp) => dp.insert(data));
     }
     count(where) {
         return this.dataProvider.then((dp) => dp.count(where));

package/esm/src/data-providers/array-entity-data-provider.js

@@ -318,30 +318,18 @@ export class ArrayEntityDataProvider {
         }
         throw new Error(`ArrayEntityDataProvider: Couldn't find row with id "${id}" in entity "${this.entity.key}" to update`);
     }
-    async delete(ids) {
-        for (const id of ids)
-            await this.deleteOne(id);
-    }
-    //@internal
-    async deleteOne(id) {
+    async delete(id) {
         const names = await this.init();
         let idMatches = this.idMatches(id, names);
         for (let i = 0; i < this.rows().length; i++) {
             if (idMatches(this.rows()[i])) {
                 this.rows().splice(i, 1);
-                return;
+                return Promise.resolve();
             }
         }
         throw new Error(`ArrayEntityDataProvider: Couldn't find row with id "${id}" in entity "${this.entity.key}" to delete`);
     }
     async insert(data) {
-        const result = [];
-        for (const row of data)
-            result.push(await this.insertOne(row));
-        return result;
-    }
-    //@internal
-    async insertOne(data) {
         const names = await this.init();
         let j = this.translateToJson(data, names);
         let idf = this.entity.idMetadata.field;

package/esm/src/data-providers/json-data-provider.js

@@ -49,8 +49,8 @@ class JsonEntityDataProvider {
             return x;
         }))));
     }
-    delete(ids) {
-        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.delete(ids).then(async (x) => {
+    delete(id) {
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.delete(id).then(async (x) => {
             await save();
             return x;
         }))));

package/esm/src/data-providers/rest-data-provider.js

@@ -303,20 +303,21 @@ export class RestEntityDataProvider {
         }
         return result;
     }
-    async delete(ids) {
-        if (ids.length === 0)
-            return;
-        if (ids.length === 1 && ids[0] !== '')
-            return this.http().delete(this.url() + '/' + encodeURIComponent(ids[0]));
-        await this.deleteMany(Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(...ids)));
+    async delete(id) {
+        if (id == '')
+            await this.deleteMany(Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)));
+        else
+            return this.http().delete(this.url() + '/' + encodeURIComponent(id));
     }
     insert(data, options) {
         return this.http()
-            .post(this.url() + (options?.select === 'none' ? '?_select=$none' : ''), data.map((row) => this.translateToJson(row)))
-            .then((y) => {
-            const rows = Array.isArray(y) ? y : [y];
-            return rows.map((row) => row ? this.translateFromJson(row) : undefined);
-        });
+            .post(this.url() + (options?.select === 'none' ? '?_select=$none' : ''), this.translateToJson(data))
+            .then((y) => this.translateFromJson(y));
+    }
+    insertMany(data, options) {
+        return this.http()
+            .post(this.url() + (options?.select === 'none' ? '?_select=$none' : ''), data.map((data) => this.translateToJson(data)))
+            .then((y) => y.map((y) => this.translateFromJson(y)));
     }
 }
 export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {

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

@@ -117,8 +117,6 @@ export class SqlDatabase {
                     doesNotSupportReturningSyntax: this.sql.doesNotSupportReturningSyntax,
                     doesNotSupportReturningSyntaxOnlyForUpdate: this.sql.doesNotSupportReturningSyntaxOnlyForUpdate,
                     orderByNullsFirst: this.sql.orderByNullsFirst,
-                    afterMutation: this.sql.afterMutation,
-                    maxParametersInOneSqlStatement: this.sql.maxParametersInOneSqlStatement,
                 }));
             }
             finally {
@@ -195,35 +193,6 @@ export class SqlDatabase {
     createdEntities = [];
     end;
 }
-const defaultMaxParametersInOneSqlStatement = 2000;
-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 countInsertBindParameters(entity, e, row) {
-    let n = 0;
-    for (const x of entity.fields) {
-        if (isDbReadonly(x, e))
-            continue;
-        if (x.valueConverter.toDb(row[x.key]) != undefined)
-            n++;
-    }
-    return n;
-}
 const icons = new Map([
     // CRUD
     ['INSERT', '⚪'], // Used to insert new data into a database.
@@ -472,13 +441,11 @@ class ActualSQLEntityDataProvider {
             return this.buildResultRow(colKeys, sqlResult.rows[0], sqlResult);
         });
     }
-    async delete(ids) {
-        if (ids.length === 0)
-            return;
+    async delete(id) {
         let e = await this.init();
         let r = this.sql.createCommand();
         let f = new FilterConsumerBridgeToSqlRequest(r, e);
-        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(...ids)).__applyToConsumer(f);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
         let statement = 'delete from ' + e.$entityName;
         statement += await f.resolveWhere();
         return r.execute(statement).then(() => {
@@ -486,90 +453,56 @@ class ActualSQLEntityDataProvider {
         });
     }
     async insert(data, options) {
-        if (data.length === 0)
-            return [];
         let e = await this.init();
-        const maxParams = this.strategy.maxParametersInOneSqlStatement ??
-            defaultMaxParametersInOneSqlStatement;
-        const batches = splitByMaxParameters(data, (row) => countInsertBindParameters(this.entity, e, row), maxParams);
-        const result = [];
-        for (const batch of batches)
-            result.push(...(await this.insertBatch(batch, e, options)));
-        return result;
-    }
-    //@internal
-    async insertOne(data, options) {
-        return (await this.insert([data], options))[0];
-    }
-    async insertBatch(batch, e, options) {
         let r = this.sql.createCommand();
-        const cols = [];
-        for (const x of this.entity.fields) {
-            if (isDbReadonly(x, e))
-                continue;
-            if (batch.some((row) => x.valueConverter.toDb(row[x.key]) != undefined))
-                cols.push(x);
-        }
-        let colSql = '';
+        let cols = '';
         let vals = '';
-        for (let i = 0; i < cols.length; i++) {
-            if (i)
-                colSql += ', ';
-            colSql += e.$dbNameOf(cols[i]);
-        }
-        for (let i = 0; i < batch.length; i++) {
-            if (i)
-                vals += ',';
-            vals += '(';
-            for (let j = 0; j < cols.length; j++) {
-                if (j)
-                    vals += ', ';
-                const x = cols[j];
-                const v = x.valueConverter.toDb(batch[i][x.key]);
-                if (v != undefined)
+        let added = false;
+        for (const x of this.entity.fields) {
+            if (isDbReadonly(x, e)) {
+            }
+            else {
+                let v = x.valueConverter.toDb(data[x.key]);
+                if (v != undefined) {
+                    if (!added)
+                        added = true;
+                    else {
+                        cols += ', ';
+                        vals += ', ';
+                    }
+                    cols += e.$dbNameOf(x);
                     vals += toDbSql(r, x, v);
-                else if (x.allowNull)
-                    vals += 'null';
-                else
-                    vals += 'DEFAULT';
+                }
             }
-            vals += ')';
         }
-        let statement = `insert into ${e.$entityName} (${colSql}) values ${vals}`;
+        let statement = `insert into ${e.$entityName} (${cols}) values (${vals})`;
         let { colKeys, select } = await this.buildSelect(e, r, undefined, undefined);
-        const source = this.sql._getSourceSql();
-        const wantRows = options?.select !== 'none';
-        if (!source.doesNotSupportReturningSyntax && wantRows)
+        if (!this.sql._getSourceSql().doesNotSupportReturningSyntax &&
+            !(options?.select === 'none'))
             statement += ' returning ' + select;
-        const sql = await r.execute(statement);
-        source.afterMutation?.();
-        if (!wantRows)
-            return batch.map(() => undefined);
-        if (source.doesNotSupportReturningSyntax) {
-            if (isAutoIncrement(this.entity.idMetadata.field)) {
-                const lastId = sql.rows[0];
-                if (typeof lastId !== 'number')
-                    throw new Error('Auto increment, for a database that is does not support returning syntax, should return an array with the single last added id. Instead it returned: ' +
-                        JSON.stringify(lastId));
-                const ids = [];
-                for (let id = lastId - batch.length + 1; id <= lastId; id++)
-                    ids.push(id);
-                return this.loadRowsByIds(ids);
+        return await r.execute(statement).then((sql) => {
+            this.sql._getSourceSql().afterMutation?.();
+            if (this.sql._getSourceSql().doesNotSupportReturningSyntax) {
+                if (isAutoIncrement(this.entity.idMetadata.field)) {
+                    const id = sql.rows[0];
+                    if (typeof id !== 'number')
+                        throw new Error('Auto increment, for a database that is does not support returning syntax, should return an array with the single last added id. Instead it returned: ' +
+                            JSON.stringify(id));
+                    if (options?.select === 'none')
+                        return undefined;
+                    return this.find({
+                        where: new Filter((x) => x.isEqualTo(this.entity.idMetadata.field, id)),
+                    }).then((r) => r[0]);
+                }
+                else {
+                    if (options?.select === 'none')
+                        return undefined;
+                    return getRowAfterUpdate(this.entity, this, data, undefined, 'insert');
+                }
             }
-            return this.loadRowsByIds(batch.map((row) => this.entity.idMetadata.getId(row)));
-        }
-        return sql.rows.map((row) => this.buildResultRow(colKeys, row, sql));
-    }
-    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;
+            if (options?.select === 'none')
+                return undefined;
+            return this.buildResultRow(colKeys, sql.rows[0], sql);
         });
     }
 }