remult 0.27.24 → 0.30.0-next.1

package/README.md

@@ -41,8 +41,6 @@ Remult uses **TypeScript entities** as a single source of truth for: ✅ CRUD +
 
 **Remult is frontend and backend framework agnostic** and comes with adapters for Express, Fastify, Next.js, Nuxt, SvelteKit, SolidStart, Nest, Koa, Hapi and Hono.
 
-> **Want to experience Remult firsthand? [Try our interactive online tutorial](https://learn.remult.dev/).**
-
 Remult promotes a **consistent query syntax for both frontend and Backend code**:
 
 ```ts

package/SseSubscriptionServer.d.ts

@@ -1,9 +1,10 @@
+/// <reference types="node" />
 import type { GenericResponse } from './server/index.js';
 import type { Remult } from './src/context.js';
 import type { SubscriptionServer } from './src/live-query/SubscriptionServer.js';
 export declare class SseSubscriptionServer implements SubscriptionServer {
     private canUserConnectToChannel?;
-    constructor(canUserConnectToChannel?: ((channel: string, remult: Remult) => boolean) | undefined);
+    constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
     publishMessage<T>(channel: string, message: any): Promise<void>;
 }
 export interface ResponseRequiredForSSE {
@@ -14,11 +15,11 @@ export interface ResponseRequiredForSSE {
 export declare class clientConnection {
     response: GenericResponse & ResponseRequiredForSSE;
     channels: Record<string, boolean>;
-    timeOutRef?: NodeJS.Timeout;
+    timeOutRef: NodeJS.Timeout;
     close(): void;
     closed: boolean;
     write(eventData: string, eventType?: string): void;
-    connectionId: string;
+    connectionId: any;
     constructor(response: GenericResponse & ResponseRequiredForSSE);
     sendLiveMessage(): void;
 }

package/assign.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assign = assign;
+exports.assign = void 0;
 function assign(item, valuesToSet) {
     if (valuesToSet)
         Object.assign(item, valuesToSet);
     return item;
 }
+exports.assign = assign;

package/esm/graphql.js

@@ -315,7 +315,7 @@ export function remultGraphql(options) {
                     value: getMetaType(meta),
                 }, argErrorDetail, argClientMutationId);
                 root[createResolverKey] = handleMutationWithErrors(async (dApi, response, setResult, arg1, req) => {
-                    await dApi.httpPost({
+                    await dApi.post({
                         ...response,
                         created: (y) => {
                             const orig = { ...y };
@@ -324,7 +324,7 @@ export function remultGraphql(options) {
                                 [toCamelCase(getMetaType(meta))]: y,
                             });
                         },
-                    }, { get: () => undefined }, arg1.input, undefined);
+                    }, arg1.input);
                 });
                 resolversMutation[createResolverKey] = (origItem, args, req, gqlInfo) => root[createResolverKey](args, req, gqlInfo);
             }
@@ -976,7 +976,7 @@ export function translateWhereToRestBody(fields, { where }) {
         }
     }
     if (where.OR) {
-        result.OR = where.OR.map((where) => translateWhereToRestBody(fields, { where })?.where);
+        result.OR = where.OR.map((where) => translateWhereToRestBody(fields, { where }).where);
     }
     return { where: result };
 }

package/esm/index.js

@@ -5,14 +5,13 @@ export { getEntityRef } from './src/remult3/getEntityRef.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 { RestDataProvider } from './src/data-providers/rest-data-provider.js'; //V
 export { InMemoryDataProvider } from './src/data-providers/in-memory-database.js'; //V
+export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider.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 { JsonEntityOpfsStorage } from './src/data-providers/json-entity-opfs-storage.js';
-export { JsonEntityIndexedDbStorage } from './src/data-providers/json-entity-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';

package/esm/internals.js

@@ -1,7 +1,6 @@
 import { remultStatic } from './src/remult-static.js';
-export { sqlRelations, sqlRelationsFilter, } from './src/data-providers/sql-relations.js';
 export { getRelationInfo, getRelationFieldInfo, } from './src/remult3/relationInfoMember.js';
-export { decorateColumnSettings, controllerRefImpl, getControllerRef, fieldOptionsEnricher, } from './src/remult3/RepositoryImplementation.js';
+export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation.js';
 export { getEntitySettings } from './src/remult3/getEntityRef.js';
 export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces.js';
 export const actionInfo = remultStatic.actionInfo;

package/esm/live-query/data-provider-live-query-storage.js

@@ -3,6 +3,7 @@ import { Remult } from '../src/context.js';
 import { EntityBase } from '../src/remult3/RepositoryImplementation.js';
 import { Fields } from '../src/remult3/Fields.js';
 import { Entity } from '../src/remult3/entity.js';
+import { remultStatic } from '../src/remult-static.js';
 import { initDataProviderOrJson } from '../server/initDataProviderOrJson.js';
 export class DataProviderLiveQueryStorage {
     repo;
@@ -89,3 +90,4 @@ LiveQueryStorageEntity = __decorate([
     /*@internal */
 ], LiveQueryStorageEntity);
 export { LiveQueryStorageEntity };
+remultStatic.allEntities.splice(remultStatic.allEntities.indexOf(LiveQueryStorageEntity), 1);

package/esm/migrations/migrate.js

@@ -1,4 +1,5 @@
-import { Entity, IdEntity, Fields, remult, Remult, describeClass, } from '../index.js';
+import { __decorate, __metadata } from "tslib";
+import { Entity, IdEntity, Fields, remult, Remult, } from '../index.js';
 import { initDataProviderOrJson } from '../server/initDataProviderOrJson.js';
 import { doTransaction } from '../src/context.js';
 import { cast, isOfType } from '../src/isOfType.js';
@@ -20,12 +21,16 @@ export async function migrate(options) {
     const prev = remult.dataProvider;
     remult.dataProvider = dataProvider;
     try {
-        class VersionInfo extends IdEntity {
+        let VersionInfo = class VersionInfo extends IdEntity {
             version = -1;
-        }
-        describeClass(VersionInfo, Entity(migrationTableName), {
-            version: Fields.integer(),
-        });
+        };
+        __decorate([
+            Fields.number(),
+            __metadata("design:type", Object)
+        ], VersionInfo.prototype, "version", void 0);
+        VersionInfo = __decorate([
+            Entity(migrationTableName)
+        ], VersionInfo);
         const steps = Object.entries(options.migrations).sort(([a], [b]) => parseInt(a) - parseInt(b));
         if (dataProvider.ensureSchema) {
             await dataProvider.ensureSchema([

package/esm/postgres/postgres-data-provider.js

@@ -32,7 +32,7 @@ export class PostgresDataProvider {
             this.wrapIdentifier = options.wrapIdentifier;
         if (!options?.wrapIdentifier && options?.caseInsensitiveIdentifiers)
             this.wrapIdentifier = (name) => name;
-        if (options?.orderByNullsFirst)
+        if (options.orderByNullsFirst)
             this.orderByNullsFirst = options.orderByNullsFirst;
         if (options?.schema) {
             this.pool = new PostgresSchemaWrapper(pool, options.schema);

package/esm/postgres/schema-builder.js

@@ -1,4 +1,6 @@
 import { dbNamesOf, shouldCreateEntity, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+import { remult as defaultRemult } from '../src/remult-proxy.js';
+import { remultStatic } from '../src/remult-static.js';
 import { isAutoIncrement } from '../src/remult3/RepositoryImplementation.js';
 import { ValueConverters } from '../src/valueConverters.js';
 export function postgresColumnSyntax(x, dbName) {
@@ -33,6 +35,9 @@ export function postgresColumnSyntax(x, dbName) {
         result += ' varchar' + (x.allowNull ? '' : " default '' not null");
     return result;
 }
+export async function verifyStructureOfAllEntities(db, remult) {
+    return await new PostgresSchemaBuilder(db).verifyStructureOfAllEntities(remult);
+}
 export class PostgresSchemaBuilder {
     pool;
     //@internal
@@ -84,6 +89,22 @@ export class PostgresSchemaBuilder {
         // Should default to `public`
         return 'public';
     }
+    async verifyStructureOfAllEntities(remult) {
+        if (!remult) {
+            remult = defaultRemult;
+        }
+        const completed = new Set();
+        const entities = [];
+        for (const entityClass of [...remultStatic.allEntities].reverse()) {
+            let entity = remult.repo(entityClass).metadata;
+            let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
+            if (completed.has(e.$entityName))
+                continue;
+            completed.add(e.$entityName);
+            entities.push(entity);
+        }
+        await this.ensureSchema(entities);
+    }
     async ensureSchema(entities) {
         for (const entity of entities) {
             let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
@@ -143,6 +164,26 @@ export class PostgresSchemaBuilder {
 CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
         return sql;
     }
+    async addColumnIfNotExist(entity, c) {
+        let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
+        if (shouldNotCreateField(c(entity), e))
+            return;
+        try {
+            let cmd = this.pool.createCommand();
+            const colName = e.$dbNameOf(c(entity));
+            if ((await cmd.execute(`SELECT 1 FROM information_schema.columns WHERE ` +
+                `${this.whereTableAndSchema(cmd, e)} ` +
+                `AND column_name=${cmd.param(colName.toLocaleLowerCase())}`)).rows.length == 0) {
+                let sql = await this.getAddColumnScript(entity, c(entity));
+                if (PostgresSchemaBuilder.logToConsole)
+                    console.info(sql);
+                await this.pool.execute(sql);
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
     async verifyAllColumns(entity) {
         try {
             let cmd = this.pool.createCommand();

package/esm/remult-hapi.js

@@ -33,7 +33,7 @@ export function remultHapi(options) {
                                 res(h.response(html).code(status));
                             },
                             json(data) {
-                                res(h.response(data === null ? 'null' : data).code(status));
+                                res(h.response(data).code(status));
                             },
                             write(data) {
                                 stream.write(data);

package/esm/remult-hono.js

@@ -18,7 +18,6 @@ export function remultHono(options) {
                 }),
                 url: c.req.url,
                 on: (e, do1) => {
-                    ;
                     c['_tempOnClose'](() => do1());
                     //   c.req.on('close', do1)
                 },
@@ -79,8 +78,7 @@ export function remultHono(options) {
                                     res(streamSSE(c, (s) => {
                                         sse = s;
                                         return new Promise((res) => {
-                                            ;
-                                            c['_tempOnClose'] = (x) => sse.onAbort(() => x());
+                                            c['_tempOnClose'] = (x) => sse.onAbort(() => x);
                                         });
                                     }));
                                 },

package/esm/remult-knex/index.js

@@ -1,4 +1,4 @@
-import { CustomSqlFilterBuilder, dbNamesOfWithForceSqlExpression, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+import { CustomSqlFilterBuilder, } 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';
@@ -6,7 +6,8 @@ import { getRepository, isAutoIncrement, } from '../src/remult3/RepositoryImplem
 import { Sort } from '../src/sort.js';
 import { ValueConverters } from '../src/valueConverters.js';
 import { getRepositoryInternals } from '../src/remult3/repository-internals.js';
-import { groupByImpl, getRowAfterUpdate, } from '../src/data-providers/sql-database.js';
+import { remultStatic } from '../src/remult-static.js';
+import { getRowAfterUpdate } from '../src/data-providers/sql-database.js';
 export class KnexDataProvider {
     knex;
     constructor(knex) {
@@ -15,6 +16,7 @@ export class KnexDataProvider {
     end() {
         return this.knex.destroy();
     }
+    /* @internal */
     provideMigrationBuilder(builder) {
         var sb = new KnexSchemaBuilder(this.knex);
         return {
@@ -69,7 +71,7 @@ export class KnexDataProvider {
                 }
             }
         }
-        return new KnexEntityDataProvider(entity, this.knex, this.wrapIdentifier, this);
+        return new KnexEntityDataProvider(entity, this.knex, this.wrapIdentifier);
     }
     async transaction(action) {
         let t = await this.knex.transaction();
@@ -90,10 +92,8 @@ export class KnexDataProvider {
         };
     }
     static async filterToRaw(entity, condition, wrapIdentifier) {
-        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 dbNamesOf(repo.metadata, (x) => x), wrapIdentifier);
         b._addWhere = false;
         await (await getRepositoryInternals(repo)._translateWhereToFilter(condition)).__applyToConsumer(b);
         let r = await b.resolveWhere();
@@ -109,15 +109,10 @@ class KnexEntityDataProvider {
     entity;
     knex;
     rawSqlWrapIdentifier;
-    dp;
-    constructor(entity, knex, rawSqlWrapIdentifier, dp) {
+    constructor(entity, knex, rawSqlWrapIdentifier) {
         this.entity = entity;
         this.knex = knex;
         this.rawSqlWrapIdentifier = rawSqlWrapIdentifier;
-        this.dp = dp;
-    }
-    async groupBy(options) {
-        return groupByImpl(options, await dbNamesOf(this.entity, this.dp.wrapIdentifier), this.dp.createCommand(), false, (limit, offset) => ' limit ' + limit + ' offset ' + offset);
     }
     async count(where) {
         const e = await this.init();
@@ -144,10 +139,7 @@ class KnexEntityDataProvider {
             if (x.isServerExpression) {
             }
             else {
-                let name = e.$dbNameOf(x);
-                if (x.options.sqlExpression)
-                    name = this.knex.raw('?? as ' + x.key, [name]);
-                cols.push(name);
+                cols.push(e.$dbNameOf(x));
                 colKeys.push(x);
             }
         }
@@ -189,7 +181,7 @@ class KnexEntityDataProvider {
         });
     }
     async init() {
-        const r = (await dbNamesOfWithForceSqlExpression(this.entity, (x) => x));
+        const r = (await dbNamesOf(this.entity, (x) => x));
         return {
             $dbNameOf: (f) => {
                 let fm = f;
@@ -255,8 +247,8 @@ class KnexEntityDataProvider {
                 newId = result[0];
             }
             else {
-                let result = await insert.returning(this.entity.idMetadata.field.dbName);
-                newId = result[0][this.entity.idMetadata.field.dbName];
+                let result = await insert.returning(this.entity.idMetadata.field.key);
+                newId = result[0].id;
             }
             return this.find({
                 where: new Filter((x) => x.isEqualTo(this.entity.idMetadata.field, newId)),
@@ -313,23 +305,6 @@ class FilterConsumerBridgeToKnexRequest {
             }
         })());
     }
-    not(element) {
-        this.promises.push((async () => {
-            let f = new FilterConsumerBridgeToKnexRequest(this.innerNameProvider, this.rawSqlWrapIdentifier);
-            f._addWhere = false;
-            element.__applyToConsumer(f);
-            let where = await f.resolveWhere();
-            if (where.length > 0) {
-                this.result.push((b) => {
-                    b.whereNot((b) => {
-                        where.forEach((x) => x(b));
-                    });
-                });
-            }
-            else
-                return; //empty or means all rows
-        })());
-    }
     isNull(col) {
         this.result.push((b) => b.whereNull(this.innerNameProvider.$dbNameOf(col)));
     }
@@ -373,22 +348,6 @@ class FilterConsumerBridgeToKnexRequest {
             "%')"));
         this.promises.push((async () => { })());
     }
-    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 () => { })());
-    }
-    endsWithCaseInsensitive(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 () => { })());
-    }
     add(col, val, operator) {
         this.result.push((b) => b.where(this.innerNameProvider.$dbNameOf(col), operator, translateValueAndHandleArrayAndHandleArray(col, val)));
     }
@@ -414,6 +373,12 @@ export class KnexSchemaBuilder {
     knex;
     //@internal
     static logToConsole = true;
+    async verifyStructureOfAllEntities(remult) {
+        if (!remult)
+            remult = remultContext;
+        const entities = remultStatic.allEntities.map((x) => remult.repo(x).metadata);
+        await this.ensureSchema(entities);
+    }
     async ensureSchema(entities) {
         for (const entity of entities) {
             let e = await dbNamesOf(entity, (x) => x);

package/esm/remult-mongo.js

@@ -1,11 +1,10 @@
 import { ObjectId, } from 'mongodb';
 import { Filter } from './index.js';
-import { dbNamesOf, dbNamesOfWithForceSqlExpression, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+import { dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request.js';
 import { remult as remultContext } from './src/remult-proxy.js';
 import { getRepository } from './src/remult3/RepositoryImplementation.js';
 import { getRepositoryInternals } from './src/remult3/repository-internals.js';
 import { getRowAfterUpdate } from './src/data-providers/sql-database.js';
-import { GroupByCountMember, GroupByOperators } from './src/remult3/remult3.js';
 export class MongoDataProvider {
     db;
     client;
@@ -23,12 +22,6 @@ export class MongoDataProvider {
             throw 'the data provider is not a MongoDataProvider';
         return { db: r.db, session: r.session };
     }
-    async ensureSchema(entities) {
-        for (const entity of entities) {
-            const m = new MongoEntityDataProvider(this.db, entity, this.session);
-            await m.ensureSchema();
-        }
-    }
     getEntityDataProvider(entity) {
         return new MongoEntityDataProvider(this.db, entity, this.session);
     }
@@ -57,7 +50,7 @@ export class MongoDataProvider {
     }
     static async filterToRaw(entity, condition) {
         const repo = getRepository(entity);
-        var b = new FilterConsumerBridgeToMongo(await dbNamesOfWithForceSqlExpression(repo.metadata));
+        var b = new FilterConsumerBridgeToMongo(await dbNamesOf(repo.metadata));
         b._addWhere = false;
         await (await getRepositoryInternals(repo)._translateWhereToFilter(condition)).__applyToConsumer(b);
         let r = await b.resolveWhere();
@@ -72,25 +65,6 @@ class MongoEntityDataProvider {
     db;
     entity;
     session;
-    async ensureSchema() {
-        const { collection, e } = await this.collection();
-        if (!(await this.db.collections()).find((x) => x.collectionName == e.$entityName)) {
-            await this.db.createCollection(e.$entityName);
-            if (this.entity.idMetadata.field &&
-                e.$dbNameOf(this.entity.idMetadata.field) != '_id') {
-                const index = {};
-                for (const f of this.entity.idMetadata.fields) {
-                    index[e.$dbNameOf(f)] = 1;
-                }
-                try {
-                    await collection.createIndex(index, { unique: true });
-                }
-                catch (err) {
-                    throw err;
-                }
-            }
-        }
-    }
     constructor(db, entity, session) {
         this.db = db;
         this.entity = entity;
@@ -100,14 +74,6 @@ class MongoEntityDataProvider {
         let result = {};
         for (const col of this.entity.fields) {
             let val = row[nameProvider.$dbNameOf(col)];
-            if (val === undefined) {
-                if (!col.allowNull) {
-                    if (col.valueType === String)
-                        val = '';
-                }
-                else
-                    val = null;
-            }
             if (isNull(val))
                 val = null;
             result[col.key] = fromDb(col, val);
@@ -131,93 +97,6 @@ class MongoEntityDataProvider {
         let w = await x.resolveWhere();
         return await collection.countDocuments(w, { session: this.session });
     }
-    async groupBy(options) {
-        let { collection, e } = await this.collection();
-        let x = new FilterConsumerBridgeToMongo(e);
-        const pipeLine = [];
-        if (options?.where) {
-            options.where.__applyToConsumer(x);
-            let where = await x.resolveWhere();
-            pipeLine.push({ $match: where });
-        }
-        const processResultRow = [];
-        const $group = {
-            __count: { $sum: 1 },
-        };
-        processResultRow.push((mongoRow, resultRow) => {
-            resultRow[GroupByCountMember] = mongoRow.__count;
-        });
-        pipeLine.push({ $group });
-        const $addFields = {};
-        pipeLine.push({ $addFields });
-        if (options?.group) {
-            $group._id = {};
-            for (const element of options.group) {
-                const name = e.$dbNameOf(element);
-                $group._id[name] = `$${name}`;
-                processResultRow.push((mongoRow, resultRow) => {
-                    resultRow[element.key] = element.valueConverter.fromDb(mongoRow._id[name]);
-                });
-            }
-        }
-        else {
-            $group._id = null;
-        }
-        for (const operator of GroupByOperators) {
-            if (options?.[operator]) {
-                for (const element of options[operator]) {
-                    const name = e.$dbNameOf(element) + '_' + operator;
-                    if (operator === 'distinctCount') {
-                        $group[name + '_temp'] = { $addToSet: `$${e.$dbNameOf(element)}` };
-                        $addFields[name] = { $size: `$${name + '_temp'}` };
-                    }
-                    else
-                        $group[name] = { ['$' + operator]: `$${e.$dbNameOf(element)}` };
-                    processResultRow.push((mongoRow, resultRow) => {
-                        resultRow[element.key] = {
-                            ...resultRow[element.key],
-                            [operator]: mongoRow[name],
-                        };
-                    });
-                }
-            }
-        }
-        if (options?.orderBy) {
-            let sort = {};
-            for (const x of options.orderBy) {
-                const direction = x.isDescending ? -1 : 1;
-                switch (x.operation) {
-                    case 'count':
-                        sort['__count'] = direction;
-                        break;
-                    case undefined:
-                        sort['_id.' + e.$dbNameOf(x.field)] = direction;
-                        break;
-                    default:
-                        sort[e.$dbNameOf(x.field) + '_' + x.operation] = direction;
-                        break;
-                }
-            }
-            pipeLine.push({ $sort: sort });
-        }
-        if (options?.limit) {
-            pipeLine.push({ $limit: options.limit });
-            if (options.page) {
-                pipeLine.push({ $skip: (options.page - 1) * options.limit });
-            }
-        }
-        const r = await collection
-            .aggregate(pipeLine, { session: this.session })
-            .toArray();
-        const r2 = r.map((x) => {
-            let resultRow = {};
-            for (const f of processResultRow) {
-                f(x, resultRow);
-            }
-            return resultRow;
-        });
-        return r2;
-    }
     async find(options) {
         let { collection, e } = await this.collection();
         let x = new FilterConsumerBridgeToMongo(e);
@@ -266,9 +145,7 @@ class MongoEntityDataProvider {
         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(), {
-            session: this.session,
-        });
+        collection.deleteOne(await f.resolveWhere(), { session: this.session });
     }
     async insert(data) {
         let { collection, e } = await this.collection();
@@ -326,19 +203,6 @@ class FilterConsumerBridgeToMongo {
             }));
         })());
     }
-    not(element) {
-        this.promises.push((async () => {
-            let f = new FilterConsumerBridgeToMongo(this.nameProvider);
-            f._addWhere = false;
-            element.__applyToConsumer(f);
-            let where = await f.resolveWhere();
-            if (where) {
-                this.result.push(() => ({
-                    $nor: [where],
-                }));
-            }
-        })());
-    }
     isNull(col) {
         this.add(col, NULL, '$eq');
     }
@@ -383,12 +247,6 @@ class FilterConsumerBridgeToMongo {
             },
         }));
     }
-    startsWithCaseInsensitive(col, val) {
-        this.add(col, `^${val}`, '$regex', { $options: 'i' });
-    }
-    endsWithCaseInsensitive(col, val) {
-        this.add(col, `${val}$`, '$regex', { $options: 'i' });
-    }
     add(col, val, operator, moreOptions) {
         this.result.push(() => ({
             [this.nameProvider.$dbNameOf(col)]: {

package/esm/remult-nuxt.js

@@ -41,7 +41,7 @@ export function remultNuxt(options) {
                 setResponseStatus(event, r.statusCode);
             if (r.html)
                 return r.html;
-            return r.data == null ? 'null' : r.data;
+            return r.data;
         }
     };
     return Object.assign(handler, {