remult 3.3.18 → 3.3.19-next.1

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

@@ -117,6 +117,8 @@ export class SqlDatabase {
                     doesNotSupportReturningSyntax: this.sql.doesNotSupportReturningSyntax,
                     doesNotSupportReturningSyntaxOnlyForUpdate: this.sql.doesNotSupportReturningSyntaxOnlyForUpdate,
                     orderByNullsFirst: this.sql.orderByNullsFirst,
+                    afterMutation: this.sql.afterMutation,
+                    maxParametersInOneSqlStatement: this.sql.maxParametersInOneSqlStatement,
                 }));
             }
             finally {
@@ -193,6 +195,35 @@ 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.
@@ -441,11 +472,13 @@ class ActualSQLEntityDataProvider {
             return this.buildResultRow(colKeys, sqlResult.rows[0], sqlResult);
         });
     }
-    async delete(id) {
+    async delete(ids) {
+        if (ids.length === 0)
+            return;
         let e = await this.init();
         let r = this.sql.createCommand();
         let f = new FilterConsumerBridgeToSqlRequest(r, e);
-        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(...ids)).__applyToConsumer(f);
         let statement = 'delete from ' + e.$entityName;
         statement += await f.resolveWhere();
         return r.execute(statement).then(() => {
@@ -453,56 +486,90 @@ 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();
-        let cols = '';
-        let vals = '';
-        let added = false;
+        const cols = [];
         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);
+            if (isDbReadonly(x, e))
+                continue;
+            if (batch.some((row) => x.valueConverter.toDb(row[x.key]) != undefined))
+                cols.push(x);
+        }
+        let colSql = '';
+        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)
                     vals += toDbSql(r, x, v);
-                }
+                else if (x.allowNull)
+                    vals += 'null';
+                else
+                    vals += 'DEFAULT';
             }
+            vals += ')';
         }
-        let statement = `insert into ${e.$entityName} (${cols}) values (${vals})`;
+        let statement = `insert into ${e.$entityName} (${colSql}) values ${vals}`;
         let { colKeys, select } = await this.buildSelect(e, r, undefined, undefined);
-        if (!this.sql._getSourceSql().doesNotSupportReturningSyntax &&
-            !(options?.select === 'none'))
+        const source = this.sql._getSourceSql();
+        const wantRows = options?.select !== 'none';
+        if (!source.doesNotSupportReturningSyntax && wantRows)
             statement += ' returning ' + select;
-        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');
-                }
+        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);
             }
-            if (options?.select === 'none')
-                return undefined;
-            return this.buildResultRow(colKeys, sql.rows[0], sql);
+            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;
         });
     }
 }

package/esm/src/remult3/RepositoryImplementation.js

@@ -282,7 +282,7 @@ export class RepositoryImplementation {
             return ref.delete();
         if (typeof item === 'string' || typeof item === 'number')
             if (this._dataProvider.isProxy)
-                return this._edp.delete(item);
+                return this._edp.delete([item]);
             else {
                 let ref2 = await this.findId(item);
                 if (!ref2)
@@ -323,36 +323,26 @@ export class RepositoryImplementation {
     }
     async insert(entity, options) {
         if (Array.isArray(entity)) {
-            if (this._dataProvider.isProxy) {
-                let refs = [];
-                let raw = [];
-                for (const item of entity) {
-                    this.__cleanupPartialObject(item);
-                    let ref = getEntityRef(entity, false);
-                    if (ref) {
-                        if (!ref.isNew())
-                            throw 'Item is not new';
-                    }
-                    else {
-                        ref = (await this.getEntityRef(this.create(item)));
-                    }
-                    refs.push(ref);
-                    raw.push(await ref.buildDtoForInsert());
+            let refs = [];
+            let raw = [];
+            for (const item of entity) {
+                this.__cleanupPartialObject(item);
+                let ref = getEntityRef(item, false);
+                if (ref) {
+                    if (!ref.isNew())
+                        throw 'Item is not new';
                 }
-                const inserted = await this._edp.insertMany(raw, options);
-                if (options?.select === 'none')
-                    return undefined;
-                return promiseAll(inserted, (item, i) => refs[i].processInsertResponseDto(item));
-            }
-            else {
-                let r = [];
-                for (const item of entity) {
-                    r.push(await this.insert(item, options));
+                else {
+                    ref = this.getEntityRef(this.create(item));
                 }
-                if (options?.select === 'none')
-                    return undefined;
-                return r;
+                refs.push(ref);
+                raw.push(await ref.buildDtoForInsert());
             }
+            const inserted = await this._edp.insert(raw, options);
+            const result = await promiseAll(inserted, (row, i) => refs[i].processInsertResponseDto(row));
+            if (options?.select === 'none')
+                return undefined;
+            return result;
         }
         else {
             let ref = getEntityRef(entity, false);
@@ -886,14 +876,19 @@ export class RepositoryImplementation {
             return this._edp.deleteMany(where === 'all' ? 'all' : await this._translateWhereToFilter(where));
         }
         else {
-            let deleted = 0;
             if (where === 'all')
                 where = undefined;
+            const prepared = [];
             for await (const item of this.query({ where, aggregate: undefined })) {
-                await getEntityRef(item).delete();
-                deleted++;
+                const ref = getEntityRef(item);
+                prepared.push({ ref, ...(await ref.__prepareDelete()) });
             }
-            return deleted;
+            const ids = prepared.filter((x) => x.doDelete).map((x) => x.ref.id);
+            if (ids.length)
+                await this._edp.delete(ids);
+            for (const x of prepared)
+                await x.ref.__finishDelete(x.event);
+            return prepared.length;
         }
     }
     _cache = new Map();
@@ -1562,7 +1557,7 @@ export class rowHelperImplementation extends rowHelperBase {
                         }))[0];
                     }
                     else
-                        updatedRow = await this.edp.insert(d, options);
+                        updatedRow = (await this.edp.insert([d], options))[0];
                 }
                 else {
                     let changesOnly = {};
@@ -1617,13 +1612,40 @@ export class rowHelperImplementation extends rowHelperBase {
         }
     }
     async processInsertResponseDto(updatedRow) {
-        await this.loadDataFrom(updatedRow);
-        this.saveOriginalData();
-        this._isNew = false;
-        return this.instance;
+        try {
+            if (updatedRow)
+                await this.loadDataFrom(updatedRow);
+            const e = this.buildLifeCycleEvent();
+            e.id = this.getId();
+            if (!this.repo._dataProvider.isProxy) {
+                if (this.info.entityInfo.saved)
+                    await this.info.entityInfo.saved(this.instance, e);
+                if (this.repo.listeners)
+                    for (const listener of this.repo.listeners) {
+                        await listener.saved?.(this.instance, true);
+                    }
+            }
+            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;
+        }
+        catch (err) {
+            throw await this.catchSaveErrors(err);
+        }
     }
     async buildDtoForInsert() {
         await this.__validateEntity();
+        const e = this.buildLifeCycleEvent();
+        if (!this.repo._dataProvider.isProxy) {
+            for (const col of this.fields) {
+                if (col.metadata.options.saving)
+                    await col.metadata.options.saving(this.instance, col, e);
+            }
+            if (this.info.entityInfo.saving) {
+                await this.info.entityInfo.saving(this.instance, e);
+            }
+        }
         this.__assertValidity();
         let d = this.copyDataToObject(this.isNew());
         for (const field of this.metadata.fields) {
@@ -1652,36 +1674,44 @@ export class rowHelperImplementation extends rowHelperBase {
         return await this.repo._translateWhereToFilter(this.repo.metadata.idMetadata.getIdFilter(this.id));
     }
     async delete() {
+        try {
+            const { doDelete, event } = await this.__prepareDelete();
+            if (doDelete)
+                await this.edp.delete([this.id]);
+            await this.__finishDelete(event);
+        }
+        catch (err) {
+            throw await this.catchSaveErrors(err);
+        }
+    }
+    //@internal
+    async __prepareDelete() {
         this.__clearErrorsAndReportChanged();
         let doDelete = true;
-        let e = this.buildLifeCycleEvent(() => (doDelete = false));
+        const event = this.buildLifeCycleEvent(() => (doDelete = false));
         if (!this.repo._dataProvider.isProxy) {
             if (this.info.entityInfo.deleting)
-                await this.info.entityInfo.deleting(this.instance, e);
+                await this.info.entityInfo.deleting(this.instance, event);
         }
         this.__assertValidity();
-        try {
-            if (doDelete) {
-                if (this.id === undefined)
-                    throw new Error('Invalid operation, id is undefined');
-                await this.edp.delete(this.id);
-            }
-            if (!this.repo._dataProvider.isProxy) {
-                if (this.info.entityInfo.deleted)
-                    await this.info.entityInfo.deleted(this.instance, e);
-            }
-            if (this.repo.listeners)
-                for (const listener of this.repo.listeners) {
-                    await listener.deleted?.(this.instance);
-                }
-            this.repo._remult.liveQueryPublisher.itemChanged(this.repo.metadata.key, [
-                { id: this.getId(), oldId: this.getOriginalId(), deleted: true },
-            ]);
-            this._wasDeleted = true;
-        }
-        catch (err) {
-            throw await this.catchSaveErrors(err);
+        if (doDelete && this.id === undefined)
+            throw new Error('Invalid operation, id is undefined');
+        return { doDelete, event };
+    }
+    //@internal
+    async __finishDelete(e) {
+        if (!this.repo._dataProvider.isProxy) {
+            if (this.info.entityInfo.deleted)
+                await this.info.entityInfo.deleted(this.instance, e);
         }
+        if (this.repo.listeners)
+            for (const listener of this.repo.listeners) {
+                await listener.deleted?.(this.instance);
+            }
+        this.repo._remult.liveQueryPublisher.itemChanged(this.repo.metadata.key, [
+            { id: this.getId(), oldId: this.getOriginalId(), deleted: true },
+        ]);
+        this._wasDeleted = true;
     }
     async loadDataFrom(data, loadItems) {
         for (const col of this.info.fields) {

package/index.d.ts

@@ -2,10 +2,11 @@ import type { ClassType } from './classType.js';
 import type { DataProvider } from './src/data-interfaces.js';
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider.js';
 export type { ClassType } from './classType.js';
-export { ValidateFieldEvent, MembersOnly, NumericKeys, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, FindOptionsBase, QueryResult, QueryOptions, UpsertOptions, Repository, GroupByOptions, GroupByResult, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, Subscribable, RefSubscriber, RefSubscriberBase, RelationOptions, ObjectMembersOnly, MembersToInclude, RepositoryRelations, EntityIdFields, EntitySelectFields, InsertOrUpdateOptions, ClassFieldDecorator, ClassFieldDecoratorContextStub, //n1 consider removing in ts5
+export type { ValidateFieldEvent, MembersOnly, NumericKeys, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, FindOptionsBase, QueryResult, QueryOptions, UpsertOptions, Repository, GroupByOptions, GroupByResult, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, Subscribable, RefSubscriber, RefSubscriberBase, RelationOptions, ObjectMembersOnly, MembersToInclude, RepositoryRelations, EntityIdFields, EntitySelectFields, InsertOrUpdateOptions, ClassFieldDecorator, ClassFieldDecoratorContextStub, //n1 consider removing in ts5
 LifecycleEvent, FieldsRefBase, FieldsRefForEntityBase, RepositoryRelationsForEntityBase, ControllerRefForControllerBase, ControllerRefBase, ControllerRef, EntityRefForEntityBase, IdMetadata, FindFirstOptionsBase, } from './src/remult3/remult3.js';
 export { standardSchema } from './src/standard-schema/index.js';
-export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, } from './src/remult3/RepositoryImplementation.js';
+export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListInfo, } from './src/remult3/RepositoryImplementation.js';
+export type { ValueListFieldOptions } from './src/remult3/RepositoryImplementation.js';
 export { LabelTransformer } from './src/remult3/RepositoryImplementation.js';
 /**
  * @deprecated use `LabelTransformer` instead
@@ -16,33 +17,46 @@ export declare const CaptionTransformer: {
 };
 export { Entity } from './src/remult3/entity.js';
 export { getEntityRef } from './src/remult3/getEntityRef.js';
-export { Field, Fields, StringFieldOptions, Relations, } from './src/remult3/Fields.js';
+export { Field, Fields, Relations } from './src/remult3/Fields.js';
+export type { StringFieldOptions } from './src/remult3/Fields.js';
 export { IdEntity } from './src/remult3/IdEntity.js';
 export { describeClass, describeBackendMethods, describeEntity, } from './src/remult3/classDescribers.js';
-export { EntityOptions, PreprocessFilterEvent } from './src/entity.js';
-export { DataProvider, EntityDataProvider, EntityDataProviderGroupByOptions, EntityDataProviderFindOptions, ErrorInfo, EntityError, RestDataProviderHttpProvider, } from './src/data-interfaces.js';
-export { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult, } from './src/sql-command.js';
-export { FieldMetadata, FieldOptions, FieldValidator, ValueConverter, ValueListItem, // reconsider, maybe it should go to remult angular as the abstraction ?
+export type { EntityOptions, PreprocessFilterEvent } from './src/entity.js';
+export { EntityError } from './src/data-interfaces.js';
+export type { DataProvider, EntityDataProvider, EntityDataProviderGroupByOptions, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider, } from './src/data-interfaces.js';
+export type { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult, } from './src/sql-command.js';
+export type { FieldMetadata, FieldOptions, FieldValidator, ValueConverter, ValueListItem, // reconsider, maybe it should go to remult angular as the abstraction ?
 ValueOrExpression, } from './src/column-interfaces.js';
 export { RestDataProvider } from './src/data-providers/rest-data-provider.js';
 export { InMemoryDataProvider } from './src/data-providers/in-memory-database.js';
 export { SqlDatabase } from './src/data-providers/sql-database.js';
-export { CustomSqlFilterBuilder, dbNamesOf, dbNamesOfOptions, CustomSqlFilterBuilderFunction, EntityDbNames, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
-export { JsonDataProvider, JsonEntityStorage, } from './src/data-providers/json-data-provider.js';
+export { CustomSqlFilterBuilder, dbNamesOf, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+export type { dbNamesOfOptions, CustomSqlFilterBuilderFunction, EntityDbNames, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+export { JsonDataProvider } from './src/data-providers/json-data-provider.js';
+export type { JsonEntityStorage } from './src/data-providers/json-data-provider.js';
 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 { Controller, BackendMethodOptions, BackendMethod, ProgressListener, ForbiddenError, } from './src/server-action.js';
-export { Allowed, Allow, Remult, withRemult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, UserInfo, } from './src/context.js';
-export { ExternalHttpProvider } from './src/buildRestDataProvider.js';
-export { SortSegment, Sort } from './src/sort.js';
+export { IndexedDbDataProvider, IndexedDbIndexBuilder, } from './src/data-providers/indexed-db-data-provider.js';
+export type { IndexedDbDataProviderOptions, IndexedDbIndexDef, } from './src/data-providers/indexed-db-data-provider.js';
+export { Controller, BackendMethod, ProgressListener, ForbiddenError, } from './src/server-action.js';
+export type { BackendMethodOptions } from './src/server-action.js';
+export { Allow, Remult, withRemult, isBackend, EventSource, } from './src/context.js';
+export type { Allowed, RemultContext, ApiClient, AllowedForInstance, EventDispatcher, UserInfo, } from './src/context.js';
+export type { ExternalHttpProvider } from './src/buildRestDataProvider.js';
+export { Sort } from './src/sort.js';
+export type { SortSegment } from './src/sort.js';
 export { CompoundIdField } from './src/CompoundIdField.js';
-export { Filter, FilterConsumer, FilterPreciseValues, } from './src/filter/filter-interfaces.js';
+export { Filter } from './src/filter/filter-interfaces.js';
+export type { FilterConsumer, FilterPreciseValues, } from './src/filter/filter-interfaces.js';
 export { UrlBuilder } from './urlBuilder.js';
-export { Validators, ValidationMessage, ValueValidationMessage, Validator, ValidatorWithArgs, valueValidator, createValidator, createValidatorWithArgs, createValueValidatorWithArgs, createValueValidator, } from './src/validators.js';
+export { Validators, valueValidator, createValidator, createValidatorWithArgs, createValueValidatorWithArgs, createValueValidator, } from './src/validators.js';
+export type { ValidationMessage, ValueValidationMessage, Validator, ValidatorWithArgs, } from './src/validators.js';
 export { ValueConverters } from './src/valueConverters.js';
 export { remult } from './src/remult-proxy.js';
-export { SubscriptionServer, LiveQueryStorage, StoredQuery, InMemoryLiveQueryStorage, } from './src/live-query/SubscriptionServer.js';
-export { SubscriptionListener, SubscriptionClientConnection, SubscriptionClient, SubscriptionChannel, LiveQueryChange, Unsubscribe, } from './src/live-query/SubscriptionChannel.js';
+export { InMemoryLiveQueryStorage } from './src/live-query/SubscriptionServer.js';
+export type { SubscriptionServer, LiveQueryStorage, StoredQuery, } from './src/live-query/SubscriptionServer.js';
+export { SubscriptionChannel } from './src/live-query/SubscriptionChannel.js';
+export type { SubscriptionListener, SubscriptionClientConnection, SubscriptionClient, LiveQueryChange, Unsubscribe, } from './src/live-query/SubscriptionChannel.js';
 /**
  * A convenient shortcut function to quickly obtain a repository for a specific entity type in Remult.
  *

package/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remult = exports.ValueConverters = exports.createValueValidator = exports.createValueValidatorWithArgs = exports.createValidatorWithArgs = exports.createValidator = exports.valueValidator = exports.Validators = exports.UrlBuilder = exports.Filter = exports.CompoundIdField = exports.Sort = exports.EventSource = exports.isBackend = exports.withRemult = exports.Remult = exports.Allow = exports.ForbiddenError = exports.ProgressListener = exports.BackendMethod = exports.Controller = exports.JsonEntityIndexedDbStorage = exports.JsonEntityOpfsStorage = exports.JsonDataProvider = exports.dbNamesOf = exports.CustomSqlFilterBuilder = exports.SqlDatabase = exports.InMemoryDataProvider = exports.RestDataProvider = exports.EntityError = exports.describeEntity = exports.describeBackendMethods = exports.describeClass = exports.IdEntity = exports.Relations = exports.Fields = exports.Field = exports.getEntityRef = exports.Entity = exports.CaptionTransformer = exports.LabelTransformer = exports.ValueListInfo = exports.getValueList = exports.ValueListFieldType = exports.getFields = exports.FieldType = exports.ControllerBase = exports.EntityBase = exports.standardSchema = exports.ArrayEntityDataProvider = void 0;
-exports.SubscriptionChannel = exports.InMemoryLiveQueryStorage = void 0;
+exports.createValueValidator = exports.createValueValidatorWithArgs = exports.createValidatorWithArgs = exports.createValidator = exports.valueValidator = exports.Validators = exports.UrlBuilder = exports.Filter = exports.CompoundIdField = exports.Sort = exports.EventSource = exports.isBackend = exports.withRemult = exports.Remult = exports.Allow = exports.ForbiddenError = exports.ProgressListener = exports.BackendMethod = exports.Controller = exports.IndexedDbIndexBuilder = exports.IndexedDbDataProvider = exports.JsonEntityIndexedDbStorage = exports.JsonEntityOpfsStorage = exports.JsonDataProvider = exports.dbNamesOf = exports.CustomSqlFilterBuilder = exports.SqlDatabase = exports.InMemoryDataProvider = exports.RestDataProvider = exports.EntityError = exports.describeEntity = exports.describeBackendMethods = exports.describeClass = exports.IdEntity = exports.Relations = exports.Fields = exports.Field = exports.getEntityRef = exports.Entity = exports.CaptionTransformer = exports.LabelTransformer = exports.ValueListInfo = exports.getValueList = exports.ValueListFieldType = exports.getFields = exports.FieldType = exports.ControllerBase = exports.EntityBase = exports.standardSchema = exports.ArrayEntityDataProvider = void 0;
+exports.SubscriptionChannel = exports.InMemoryLiveQueryStorage = exports.remult = exports.ValueConverters = void 0;
 exports.repo = repo;
 var array_entity_data_provider_js_1 = require("./src/data-providers/array-entity-data-provider.js");
 Object.defineProperty(exports, "ArrayEntityDataProvider", { enumerable: true, get: function () { return array_entity_data_provider_js_1.ArrayEntityDataProvider; } });
@@ -53,6 +53,9 @@ var json_entity_opfs_storage_js_1 = require("./src/data-providers/json-entity-op
 Object.defineProperty(exports, "JsonEntityOpfsStorage", { enumerable: true, get: function () { return json_entity_opfs_storage_js_1.JsonEntityOpfsStorage; } });
 var json_entity_indexed_db_data_provider_js_1 = require("./src/data-providers/json-entity-indexed-db-data-provider.js");
 Object.defineProperty(exports, "JsonEntityIndexedDbStorage", { enumerable: true, get: function () { return json_entity_indexed_db_data_provider_js_1.JsonEntityIndexedDbStorage; } });
+var indexed_db_data_provider_js_1 = require("./src/data-providers/indexed-db-data-provider.js");
+Object.defineProperty(exports, "IndexedDbDataProvider", { enumerable: true, get: function () { return indexed_db_data_provider_js_1.IndexedDbDataProvider; } });
+Object.defineProperty(exports, "IndexedDbIndexBuilder", { enumerable: true, get: function () { return indexed_db_data_provider_js_1.IndexedDbIndexBuilder; } });
 //export * from './src/data-api'; //reconsider if to make internal
 var server_action_js_1 = require("./src/server-action.js");
 Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return server_action_js_1.Controller; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "3.3.18",
+    "version": "3.3.19-next.1",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/remult-d1.d.ts

@@ -3,6 +3,7 @@ import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
 export declare function createD1DataProvider(d1: D1Database): SqlDatabase;
 export declare class D1DataProvider extends SqliteCoreDataProvider {
     private d1;
+    maxParametersInOneSqlStatement: number;
     /**
      * For production or local d1 using binding
      *

package/remult-d1.js

@@ -23,6 +23,7 @@ var D1DataProvider = /** @class */ (function (_super) {
             });
         }); }) || this;
         _this.d1 = d1;
+        _this.maxParametersInOneSqlStatement = 100;
         return _this;
     }
     D1DataProvider.prototype.transaction = function (action) {

package/remult-knex/index.d.ts

@@ -20,12 +20,12 @@ export declare class KnexDataProvider implements DataProvider, HasWrapIdentifier
     static rawFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
     static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>, wrapIdentifier?: (name: string) => string): Promise<(knex: Knex.QueryBuilder) => void>;
     isProxy?: boolean;
-    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
+    ensureSchema(entities: EntityMetadata[]): Promise<void>;
 }
 export type CustomKnexFilterBuilderFunction = () => Promise<(builder: Knex.QueryBuilder) => void>;
 export declare class KnexSchemaBuilder {
     private knex;
-    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
+    ensureSchema(entities: EntityMetadata[]): Promise<void>;
     createIfNotExist(entity: EntityMetadata): Promise<void>;
     createTableKnexCommand(entity: EntityMetadata, e: EntityDbNamesBase): Knex.SchemaBuilder;
     addColumnIfNotExist(entity: EntityMetadata, c: (e: EntityMetadata) => FieldMetadata): Promise<void>;