remult 0.25.8 → 0.26.0

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

@@ -1,3 +1,4 @@
+import { remult as defaultRemult } from '../src/remult-proxy.js';
 import pg from 'pg';
 const { Pool } = pg;
 import { Remult } from '../src/context.js';
@@ -7,9 +8,11 @@ export class PostgresDataProvider {
     pool;
     options;
     supportsJsonColumnType = true;
-    static getDb(remult) {
-        const sql = SqlDatabase.getDb(remult);
-        const me = sql._getSourceSql();
+    static getDb(dataProvider) {
+        const r = (dataProvider || defaultRemult.dataProvider);
+        if (!r._getSourceSql)
+            throw 'the data provider is not an SqlDatabase';
+        const me = r._getSourceSql();
         if (!me.pool) {
             throw 'the data provider is not a PostgresDataProvider';
         }
@@ -35,6 +38,21 @@ export class PostgresDataProvider {
             this.pool = new PostgresSchemaWrapper(pool, options.schema);
         }
     }
+    end() {
+        return this.pool.end();
+    }
+    provideMigrationBuilder(builder) {
+        var db = new SqlDatabase(this);
+        var sb = new PostgresSchemaBuilder(db, this.options?.schema);
+        return {
+            addColumn: async (meta, field) => {
+                builder.addSql(await sb.getAddColumnScript(meta, field));
+            },
+            createTable: async (meta) => {
+                builder.addSql(await sb.createTableScript(meta));
+            },
+        };
+    }
     wrapIdentifier = (name) => name
         .split('.')
         .map((name) => name.startsWith('"') ? name : '"' + name.replace(/"/g, '""') + '"')
@@ -172,4 +190,7 @@ export class PostgresSchemaWrapper {
             c.release();
         }
     }
+    end() {
+        return this.pool.end();
+    }
 }

package/esm/postgres/schema-builder.js

@@ -1,4 +1,4 @@
-import { dbNamesOf, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+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';
@@ -19,7 +19,7 @@ export function postgresColumnSyntax(x, dbName) {
             if (x.valueConverter == ValueConverters.DateOnly)
                 result += ' date';
             else
-                result += ' timestamp';
+                result += ' timestamptz';
         else
             result += ' ' + x.valueConverter.fieldTypeInDb;
     }
@@ -109,11 +109,9 @@ export class PostgresSchemaBuilder {
         for (const entity of entities) {
             let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
             try {
-                if (!entity.options.sqlExpression) {
-                    if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
-                        await this.createIfNotExist(entity);
-                        await this.verifyAllColumns(entity);
-                    }
+                if (shouldCreateEntity(entity, e)) {
+                    await this.createIfNotExist(entity);
+                    await this.verifyAllColumns(entity);
                 }
             }
             catch (err) {
@@ -130,29 +128,41 @@ export class PostgresSchemaBuilder {
             `${this.whereTableAndSchema(c, e)}`)
             .then(async (r) => {
             if (r.rows.length == 0) {
-                let result = '';
-                for (const x of entity.fields) {
-                    if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
-                        if (result.length != 0)
-                            result += ',';
-                        result += '\r\n  ';
-                        if (isAutoIncrement(x))
-                            result += e.$dbNameOf(x) + ' serial';
-                        else {
-                            result += postgresColumnSyntax(x, e.$dbNameOf(x));
-                        }
-                        if (x == entity.idMetadata.field)
-                            result += ' primary key';
-                    }
-                }
-                let sql = `CREATE SCHEMA IF NOT EXISTS ${this.schemaOnly(e)};
-CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
+                const sql = await this.createTableScript(entity);
                 if (PostgresSchemaBuilder.logToConsole)
                     console.info(sql);
                 await this.pool.execute(sql);
             }
         });
     }
+    /* @internal*/
+    async getAddColumnScript(entity, field) {
+        let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
+        return (`ALTER table ${this.schemaAndName(e)} ` +
+            `ADD column ${postgresColumnSyntax(field, e.$dbNameOf(field))}`);
+    }
+    /* @internal*/
+    async createTableScript(entity) {
+        let result = '';
+        let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
+        for (const x of entity.fields) {
+            if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
+                if (result.length != 0)
+                    result += ',';
+                result += '\r\n  ';
+                if (isAutoIncrement(x))
+                    result += e.$dbNameOf(x) + ' serial';
+                else {
+                    result += postgresColumnSyntax(x, e.$dbNameOf(x));
+                }
+                if (x == entity.idMetadata.field)
+                    result += ' primary key';
+            }
+        }
+        let sql = `CREATE SCHEMA IF NOT EXISTS ${this.schemaOnly(e)};
+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))
@@ -163,8 +173,7 @@ CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
             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 = `ALTER table ${this.schemaAndName(e)} ` +
-                    `ADD column ${postgresColumnSyntax(c(entity), colName)}`;
+                let sql = await this.getAddColumnScript(entity, c(entity));
                 if (PostgresSchemaBuilder.logToConsole)
                     console.info(sql);
                 await this.pool.execute(sql);

package/esm/remult-better-sqlite3.js

@@ -0,0 +1,47 @@
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+export class BetterSqlite3DataProvider extends SqliteCoreDataProvider {
+    constructor(db) {
+        super(() => new BetterSqlite3Command(db), async () => { db.close(); });
+    }
+}
+class BetterSqlite3Command {
+    db;
+    values = {};
+    i = 0;
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        const s = this.db.prepare(sql);
+        if (s.reader) {
+            return new BetterSqlite3SqlResult(s.all(this.values));
+        }
+        else {
+            const result = s.run(this.values);
+            return new BetterSqlite3SqlResult([]);
+        }
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        if (typeof val === "boolean")
+            val = val ? 1 : 0;
+        const key = ':' + (this.i++);
+        this.values[key.substring(1)] = (val);
+        return key;
+    }
+}
+export class BetterSqlite3SqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return Object.keys(this.result[0])[index];
+    }
+}

package/esm/remult-bun-sqlite.js

@@ -0,0 +1,41 @@
+import { SqliteCoreDataProvider } from "./remult-sqlite-core.js";
+export class BunSqliteDataProvider extends SqliteCoreDataProvider {
+    constructor(db) {
+        super(() => new BunSqliteCommand(db), async () => { db.close(); });
+    }
+}
+class BunSqliteCommand {
+    db;
+    values = {};
+    i = 0;
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        const s = this.db.query(sql);
+        return new BunSqliteSqlResult(s.all(this.values));
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        if (typeof val === "boolean")
+            val = val ? 1 : 0;
+        const key = ':' + (this.i++);
+        this.values[key] = (val);
+        return key;
+    }
+}
+class BunSqliteSqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return Object.keys(this.result[0])[index];
+    }
+}

package/esm/remult-knex/index.js

@@ -1,4 +1,5 @@
-import { dbNamesOf, isDbReadonly, shouldNotCreateField, } 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 { CompoundIdField } from '../src/CompoundIdField.js';
 import { remult as remultContext } from '../src/remult-proxy.js';
@@ -13,8 +14,36 @@ export class KnexDataProvider {
     constructor(knex) {
         this.knex = knex;
     }
-    static getDb(remult) {
-        const r = (remult || remultContext).dataProvider;
+    end() {
+        return this.knex.destroy();
+    }
+    /* @internal */
+    provideMigrationBuilder(builder) {
+        var sb = new KnexSchemaBuilder(this.knex);
+        return {
+            async createTable(entity) {
+                let e = await dbNamesOf(entity, (x) => x);
+                sb.createTableKnexCommand(entity, e)
+                    .toSQL()
+                    .forEach((sql) => builder.addSql(sql.sql));
+            },
+            async addColumn(entity, field) {
+                let e = await dbNamesOf(entity, (x) => x);
+                await sb
+                    .createColumnKnexCommand(e, field, e.$dbNameOf(field))
+                    .toSQL()
+                    .forEach((sql) => builder.addSql(sql.sql));
+            },
+        };
+    }
+    createCommand() {
+        return new KnexBridgeToSQLCommand(this.knex);
+    }
+    execute(sql) {
+        return this.createCommand().execute(sql);
+    }
+    static getDb(dataProvider) {
+        const r = (dataProvider || remultContext.dataProvider);
         if (!r.knex)
             throw 'the data provider is not an KnexDataProvider';
         return r.knex;
@@ -43,7 +72,7 @@ export class KnexDataProvider {
                 }
             }
         }
-        return new KnexEntityDataProvider(entity, this.knex);
+        return new KnexEntityDataProvider(entity, this.knex, this.wrapIdentifier);
     }
     async transaction(action) {
         let t = await this.knex.transaction();
@@ -63,9 +92,9 @@ export class KnexDataProvider {
             },
         };
     }
-    static async filterToRaw(entity, condition) {
+    static async filterToRaw(entity, condition, wrapIdentifier) {
         const repo = getRepository(entity);
-        var b = new FilterConsumerBridgeToKnexRequest(await dbNamesOf(repo.metadata, (x) => x));
+        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();
@@ -80,13 +109,15 @@ export class KnexDataProvider {
 class KnexEntityDataProvider {
     entity;
     knex;
-    constructor(entity, knex) {
+    rawSqlWrapIdentifier;
+    constructor(entity, knex, rawSqlWrapIdentifier) {
         this.entity = entity;
         this.knex = knex;
+        this.rawSqlWrapIdentifier = rawSqlWrapIdentifier;
     }
     async count(where) {
         const e = await this.init();
-        const br = new FilterConsumerBridgeToKnexRequest(e);
+        const br = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier);
         where.__applyToConsumer(br);
         let r = await br.resolveWhere();
         const result = await this.knex(e.$entityName)
@@ -115,7 +146,7 @@ class KnexEntityDataProvider {
         }
         let query = this.knex(e.$entityName).select(cols);
         if (options?.where) {
-            const br = new FilterConsumerBridgeToKnexRequest(e);
+            const br = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier);
             options.where.__applyToConsumer(br);
             let r = await br.resolveWhere();
             query.where((b) => r.forEach((y) => y(b)));
@@ -160,11 +191,12 @@ class KnexEntityDataProvider {
                 return r.$dbNameOf(f);
             },
             $entityName: r.$entityName,
+            wrapIdentifier: r.wrapIdentifier,
         };
     }
     async update(id, data) {
         const e = await this.init();
-        let f = new FilterConsumerBridgeToKnexRequest(e);
+        let f = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
         let resultFilter = this.entity.idMetadata.getIdFilter(id);
         if (data.id != undefined)
@@ -191,7 +223,7 @@ class KnexEntityDataProvider {
     }
     async delete(id) {
         const e = await this.init();
-        let f = new FilterConsumerBridgeToKnexRequest(e);
+        let f = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
         let where = await f.resolveWhere();
         await this.knex(e.$entityName)
@@ -239,7 +271,8 @@ class KnexEntityDataProvider {
     }
 }
 class FilterConsumerBridgeToKnexRequest {
-    nameProvider;
+    innerNameProvider;
+    rawSqlWrapIdentifier;
     _addWhere = true;
     promises = [];
     result = [];
@@ -253,8 +286,9 @@ class FilterConsumerBridgeToKnexRequest {
         }
         return this.result;
     }
-    constructor(nameProvider) {
-        this.nameProvider = nameProvider;
+    constructor(innerNameProvider, rawSqlWrapIdentifier) {
+        this.innerNameProvider = innerNameProvider;
+        this.rawSqlWrapIdentifier = rawSqlWrapIdentifier;
     }
     custom(key, customItem) {
         throw new Error('Custom filter should be translated before it gets here');
@@ -263,7 +297,7 @@ class FilterConsumerBridgeToKnexRequest {
         this.promises.push((async () => {
             const result = [];
             for (const element of orElements) {
-                let f = new FilterConsumerBridgeToKnexRequest(this.nameProvider);
+                let f = new FilterConsumerBridgeToKnexRequest(this.innerNameProvider, this.rawSqlWrapIdentifier);
                 f._addWhere = false;
                 element.__applyToConsumer(f);
                 let where = await f.resolveWhere();
@@ -283,13 +317,13 @@ class FilterConsumerBridgeToKnexRequest {
         })());
     }
     isNull(col) {
-        this.result.push((b) => b.whereNull(this.nameProvider.$dbNameOf(col)));
+        this.result.push((b) => b.whereNull(this.innerNameProvider.$dbNameOf(col)));
     }
     isNotNull(col) {
-        this.result.push((b) => b.whereNotNull(this.nameProvider.$dbNameOf(col)));
+        this.result.push((b) => b.whereNotNull(this.innerNameProvider.$dbNameOf(col)));
     }
     isIn(col, val) {
-        this.result.push((knex) => knex.whereIn(this.nameProvider.$dbNameOf(col), val.map((x) => translateValueAndHandleArrayAndHandleArray(col, x))));
+        this.result.push((knex) => knex.whereIn(this.innerNameProvider.$dbNameOf(col), val.map((x) => translateValueAndHandleArrayAndHandleArray(col, x))));
     }
     isEqualTo(col, val) {
         this.add(col, val, '=');
@@ -311,7 +345,7 @@ class FilterConsumerBridgeToKnexRequest {
     }
     containsCaseInsensitive(col, val) {
         this.result.push((b) => b.whereRaw('lower (' +
-            b.client.ref(this.nameProvider.$dbNameOf(col)) +
+            b.client.ref(this.innerNameProvider.$dbNameOf(col)) +
             ") like lower ('%" +
             val.replace(/'/g, "''") +
             "%')"));
@@ -319,20 +353,30 @@ class FilterConsumerBridgeToKnexRequest {
     }
     notContainsCaseInsensitive(col, val) {
         this.result.push((b) => b.whereRaw('not lower (' +
-            b.client.ref(this.nameProvider.$dbNameOf(col)) +
+            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.nameProvider.$dbNameOf(col), operator, translateValueAndHandleArrayAndHandleArray(col, val)));
+        this.result.push((b) => b.where(this.innerNameProvider.$dbNameOf(col), operator, translateValueAndHandleArrayAndHandleArray(col, val)));
     }
     databaseCustom(databaseCustom) {
         this.promises.push((async () => {
             if (databaseCustom?.buildKnex) {
                 this.result.push(await databaseCustom.buildKnex());
             }
+            if (databaseCustom?.buildSql) {
+                let r = new KnexCommandHelper();
+                const item = new CustomSqlFilterBuilder(r, this.rawSqlWrapIdentifier);
+                let sql = await databaseCustom.buildSql(item);
+                if (typeof sql !== 'string')
+                    sql = item.sql;
+                if (sql) {
+                    this.result.push((b) => b.whereRaw(sql, r.values));
+                }
+            }
         })());
     }
 }
@@ -350,11 +394,9 @@ export class KnexSchemaBuilder {
         for (const entity of entities) {
             let e = await dbNamesOf(entity, (x) => x);
             try {
-                if (!entity.options.sqlExpression) {
-                    if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
-                        await this.createIfNotExist(entity);
-                        await this.verifyAllColumns(entity);
-                    }
+                if (shouldCreateEntity(entity, e)) {
+                    await this.createIfNotExist(entity);
+                    await this.verifyAllColumns(entity);
                 }
             }
             catch (err) {
@@ -366,27 +408,30 @@ export class KnexSchemaBuilder {
     async createIfNotExist(entity) {
         const e = await dbNamesOf(entity, (x) => x);
         if (!(await this.knex.schema.hasTable(e.$entityName))) {
-            let cols = new Map();
-            for (const f of entity.fields) {
-                cols.set(f, {
-                    name: e.$dbNameOf(f),
-                    readonly: shouldNotCreateField(f, e),
-                });
-            }
-            await logSql(this.knex.schema.createTable(e.$entityName, (b) => {
-                for (const x of entity.fields) {
-                    if (!cols.get(x).readonly || isAutoIncrement(x)) {
-                        if (isAutoIncrement(x))
-                            b.increments(cols.get(x).name);
-                        else {
-                            buildColumn(x, cols.get(x).name, b, supportsJsonDataStorage(this.knex));
-                            if (x == entity.idMetadata.field)
-                                b.primary([cols.get(x).name]);
-                        }
+            await logSql(this.createTableKnexCommand(entity, e));
+        }
+    }
+    createTableKnexCommand(entity, e) {
+        let cols = new Map();
+        for (const f of entity.fields) {
+            cols.set(f, {
+                name: e.$dbNameOf(f),
+                readonly: shouldNotCreateField(f, e),
+            });
+        }
+        return this.knex.schema.createTable(e.$entityName, (b) => {
+            for (const x of entity.fields) {
+                if (!cols.get(x).readonly || isAutoIncrement(x)) {
+                    if (isAutoIncrement(x))
+                        b.increments(cols.get(x).name);
+                    else {
+                        buildColumn(x, cols.get(x).name, b, supportsJsonDataStorage(this.knex));
+                        if (x == entity.idMetadata.field)
+                            b.primary([cols.get(x).name]);
                     }
                 }
-            }));
-        }
+            }
+        });
     }
     async addColumnIfNotExist(entity, c) {
         let e = await dbNamesOf(entity, (x) => x);
@@ -395,11 +440,14 @@ export class KnexSchemaBuilder {
         let col = c(entity);
         let colName = e.$dbNameOf(col);
         if (!(await this.knex.schema.hasColumn(e.$entityName, colName))) {
-            await logSql(this.knex.schema.alterTable(e.$entityName, (b) => {
-                buildColumn(col, colName, b, supportsJsonDataStorage(this.knex));
-            }));
+            await logSql(this.createColumnKnexCommand(e, col, colName));
         }
     }
+    createColumnKnexCommand(e, col, colName) {
+        return this.knex.schema.alterTable(e.$entityName, (b) => {
+            buildColumn(col, colName, b, supportsJsonDataStorage(this.knex));
+        });
+    }
     async verifyAllColumns(entity) {
         let e = await dbNamesOf(entity, (x) => x);
         try {
@@ -475,16 +523,24 @@ export function buildColumn(x, dbName, b, supportsJson = true) {
         else if (x.valueConverter.fieldTypeInDb == 'json')
             if (supportsJson)
                 b.json(dbName);
-            else
-                b.text(dbName);
+            else {
+                let c = b.text(dbName);
+                if (!x.allowNull)
+                    c.defaultTo('').notNullable();
+            }
         else
             b.specificType(dbName, x.valueConverter.fieldTypeInDb);
     }
-    else {
+    else if (x.valueType === String) {
         let c = b.string(dbName, x.options.maxLength);
         if (!x.allowNull)
             c.defaultTo('').notNullable();
     }
+    else {
+        let c = b.text(dbName);
+        if (!x.allowNull)
+            c.defaultTo('').notNullable();
+    }
 }
 function logSql(who) {
     if (KnexSchemaBuilder.logToConsole)
@@ -502,3 +558,76 @@ function translateValueAndHandleArrayAndHandleArray(field, val) {
         return JSON.stringify(result);
     return result;
 }
+class KnexCommandHelper {
+    values = {};
+    i = 0;
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (Array.isArray(val))
+            val = JSON.stringify(val);
+        const key = ':' + this.i++;
+        this.values[key.substring(1)] = val;
+        return key;
+    }
+}
+class KnexBridgeToSQLCommand extends KnexCommandHelper {
+    source;
+    constructor(source) {
+        super();
+        this.source = source;
+    }
+    values = {};
+    i = 0;
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (Array.isArray(val))
+            val = JSON.stringify(val);
+        const key = ':' + this.i++;
+        this.values[key.substring(1)] = val;
+        return key;
+    }
+    async execute(sql) {
+        return await this.source.raw(sql, this.values).then((r) => {
+            switch (this.source.client.config.client) {
+                case 'mysql':
+                case 'mysql2':
+                    return new KnexPostgresBridgeToSQLQueryResult({
+                        fields: r[1],
+                        rows: r[0],
+                    });
+                case 'pg':
+                    return new KnexPostgresBridgeToSQLQueryResult(r);
+                default:
+                case 'better-sqlite3':
+                case 'mssql':
+                    return new KnexPostgresBridgeToSQLQueryResult({
+                        rows: r,
+                    });
+            }
+        });
+    }
+}
+class KnexPostgresBridgeToSQLQueryResult {
+    r;
+    getColumnKeyInResultForIndexInSelect(index) {
+        if (this.r.fields)
+            return this.r.fields[index].name;
+        if (this.rows.length == 0)
+            throw Error('No rows');
+        let i = 0;
+        for (let m in this.rows[0]) {
+            if (i++ == index)
+                return m;
+        }
+        throw Error('index not found');
+    }
+    constructor(r) {
+        this.r = r;
+        this.rows = r.rows;
+    }
+    rows;
+}

package/esm/remult-mongo.js

@@ -16,8 +16,8 @@ export class MongoDataProvider {
     }
     session;
     disableTransactions = false;
-    static getDb(remult) {
-        const r = (remult || remultContext).dataProvider;
+    static getDb(dataProvider) {
+        const r = (dataProvider || remultContext.dataProvider);
         if (!r.db)
             throw 'the data provider is not a MongoDataProvider';
         return { db: r.db, session: r.session };