remult 3.3.18-next.0 → 3.3.19-next.1

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

@@ -9,4 +9,3 @@ export { isOfType } from './src/isOfType.js';
 export { flags } from './src/remult3/remult3.js';
 export { DataProviderPromiseWrapper } from './src/data-interfaces.js';
 export { pagedQueryResult } from './src/remult3/pagedQueryResult.js';
-export { withFetch } from './src/context.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

@@ -234,16 +234,87 @@ 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);
+        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), 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) {
@@ -591,6 +662,45 @@ 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,22 +266,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);

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;
     }

package/esm/server/initAsyncHooks.js

@@ -16,7 +16,7 @@ export function initAsyncHooks() {
         }
     });
 }
-export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore {
+export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
     asyncLocalStorage = new AsyncLocalStorage();
     wasImplemented = 'yes';
     run(store, callback) {
@@ -36,14 +36,8 @@ export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore {
     getStore() {
         return this.asyncLocalStorage.getStore();
     }
-    createDataProviderAsyncLocalStorage() {
-        return new AsyncLocalStorage();
-    }
 }
 export class StubRemultAsyncLocalStorageCore {
-    createDataProviderAsyncLocalStorage() {
-        return undefined;
-    }
     isStub = true;
     wasImplemented = 'yes';
     async run(store, callback) {
@@ -56,3 +50,5 @@ export class StubRemultAsyncLocalStorageCore {
     lastPromise = Promise.resolve(undefined);
     currentValue;
 }
+export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore extends AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
+}

package/esm/server/test-api-data-provider.js

@@ -98,7 +98,6 @@ async function MakeServerCallWithDifferentStaticRemult(what) {
                 store.remult.user = user;
                 return callback();
             },
-            createDataProviderAsyncLocalStorage: () => undefined,
             wasImplemented: 'yes',
         });
         return await what();

package/esm/src/context.js

@@ -45,9 +45,6 @@ export class RemultAsyncLocalStorage {
         if (val || this.remultObjectStorage?.isStub)
             store.inInitRequest = val;
     }
-    createDataProviderAsyncLocalStorage() {
-        return this.remultObjectStorage?.createDataProviderAsyncLocalStorage();
-    }
     getStore() {
         if (!this.remultObjectStorage) {
             throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
@@ -186,15 +183,8 @@ export class Remult {
             httpClient: fetch,
         }));
     }
-    /* @internal */
-    _myDataProviderStore = new RemultInstanceDataProviderStore(new RestDataProvider(() => this.apiClient));
     /** The current data provider */
-    set dataProvider(dataProvider) {
-        this._myDataProviderStore.getStore().dataProvider = dataProvider;
-    }
-    get dataProvider() {
-        return this._myDataProviderStore.getStore().dataProvider;
-    }
+    dataProvider = new RestDataProvider(() => this.apiClient);
     /* @internal */
     repCache = new Map();
     constructor(provider) {
@@ -321,11 +311,10 @@ export async function doTransaction(remult, what) {
     const prev = remult.dataProvider;
     try {
         await remult.dataProvider.transaction(async (ds) => {
-            await withRemultDataProvider({ dataProvider: ds, remult }, async () => {
-                remult.liveQueryPublisher = trans;
-                await what(ds);
-                ok = true;
-            });
+            remult.dataProvider = ds;
+            remult.liveQueryPublisher = trans;
+            await what(ds);
+            ok = true;
         });
         if (ok)
             await trans.flush();
@@ -369,54 +358,6 @@ class transactionLiveQueryPublisher {
 }
 export async function withRemult(callback, options) {
     const remult = new Remult();
-    return remultStatic.asyncContext.run(remult, async (r) => {
-        remult.dataProvider = await initDataProvider(options?.dataProvider, true, async () => remult.dataProvider);
-        return await callback(r);
-    });
-}
-export class RemultInstanceDataProviderStore {
-    constructor(dataProvider) {
-        this._myDataProviderStore = { dataProvider };
-    }
-    _myDataProviderStore;
-    getStore = () => this._myDataProviderStore;
-    asyncStore;
-    async withDataProvider(dataProvider, callback) {
-        if (!this.asyncStore) {
-            this.asyncStore =
-                remultStatic.asyncContext.createDataProviderAsyncLocalStorage();
-            if (this.asyncStore) {
-                this.getStore = () => this.asyncStore.getStore() ?? this._myDataProviderStore;
-            }
-        }
-        if (this.asyncStore) {
-            return this.asyncStore.run({ dataProvider }, async () => {
-                return await callback();
-            });
-        }
-        else {
-            const prev = this._myDataProviderStore;
-            try {
-                this._myDataProviderStore = { dataProvider };
-                return await callback();
-            }
-            finally {
-                this._myDataProviderStore = prev;
-            }
-        }
-    }
-}
-export function withRemultDataProvider({ dataProvider, remult }, callback) {
-    remult = remult ?? remultStatic.remultFactory();
-    return remult._myDataProviderStore.withDataProvider(dataProvider, callback);
-}
-export function withFetch(fetch, callback) {
-    const remult = remultStatic.remultFactory();
-    return withRemultDataProvider({
-        remult,
-        dataProvider: new RestDataProvider(() => ({
-            ...remult.apiClient,
-            httpClient: fetch,
-        })),
-    }, callback);
+    remult.dataProvider = await initDataProvider(options?.dataProvider, true, async () => remult.dataProvider);
+    return remultStatic.asyncContext.run(remult, (r) => callback(r));
 }

package/esm/src/data-interfaces.js

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

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

@@ -267,8 +267,14 @@ export class ArrayEntityDataProvider {
     translateToJson(row, dbNames) {
         let result = {};
         for (const col of this.entity.fields) {
-            if (!isDbReadonly(col, dbNames))
-                result[dbNames.$dbNameOf(col)] = col.valueConverter.toJson(row[col.key]);
+            if (!isDbReadonly(col, dbNames)) {
+                let val = row[col.key];
+                if (val === undefined) {
+                    if (col.allowNull)
+                        val = null;
+                }
+                result[dbNames.$dbNameOf(col)] = col.valueConverter.toJson(val);
+            }
         }
         return result;
     }
@@ -312,18 +318,30 @@ export class ArrayEntityDataProvider {
         }
         throw new Error(`ArrayEntityDataProvider: Couldn't find row with id "${id}" in entity "${this.entity.key}" to update`);
     }
-    async delete(id) {
+    async delete(ids) {
+        for (const id of ids)
+            await this.deleteOne(id);
+    }
+    //@internal
+    async deleteOne(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 Promise.resolve();
+                return;
             }
         }
         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;