remult 0.16.3-exp.1 → 0.16.3-exp.2

package/README.md

@@ -128,11 +128,9 @@ app.listen(port, () => {
 ```ts
 // frontend/code.ts
 
-import { Remult } from "remult";
+import { remult } from "remult";
 import { Product } from "../shared/product";
 
-const remult = new Remult();
-
 async function increasePriceOfTofu(priceIncrease: number) {
   const productsRepo = remult.repo(Product);
 
@@ -146,8 +144,8 @@ async function increasePriceOfTofu(priceIncrease: number) {
 
 ```ts
 @BackendMethod({ allowed: Allow.authenticated })
-static async increasePriceOfTofu(priceIncrease: number, remult?: Remult) {
-  const productsRepo = remult!.repo(Product);
+static async increasePriceOfTofu(priceIncrease: number) {
+  const productsRepo = remult.repo(Product);
 
   const product = await productsRepo.findFirst({ name: 'Tofu' }); // use Remult in the backend as an ORM
   product.unitPrice += priceIncrease;

package/esm/index.d.ts

@@ -10,7 +10,7 @@ export { InMemoryDataProvider } from './src/data-providers/in-memory-database';
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider';
 export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider';
 export { SqlDatabase, } from './src/data-providers/sql-database';
-export { CustomSqlFilterObject, CustomSqlFilterBuilder } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { CustomSqlFilterObject, CustomSqlFilterBuilder, dbNamesOf, sqlCondition } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider, JsonEntityStorage } from './src/data-providers/json-data-provider';
 export { Controller, BackendMethodOptions, BackendMethod, ProgressListener } from './src/server-action';
 export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, ExternalHttpProvider, Unobserve, UserInfo } from './src/context';
@@ -18,7 +18,6 @@ export { IdEntity } from './src/id-entity';
 export { SortSegment, Sort } from './src/sort';
 export { OneToMany, CompoundIdField } from './src/column';
 export { Filter } from './src/filter/filter-interfaces';
-export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';

package/esm/index.js

@@ -8,7 +8,7 @@ export { InMemoryDataProvider } from './src/data-providers/in-memory-database';
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider'; //V
 export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider'; //V
 export { SqlDatabase, } from './src/data-providers/sql-database'; //V
-export { CustomSqlFilterBuilder } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { CustomSqlFilterBuilder, dbNamesOf, sqlCondition } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider } from './src/data-providers/json-data-provider'; //V
 //export * from './src/data-api'; //reconsider if to make internal
 export { Controller, BackendMethod, ProgressListener } from './src/server-action';
@@ -17,7 +17,6 @@ export { IdEntity } from './src/id-entity';
 export { Sort } from './src/sort';
 export { OneToMany, CompoundIdField } from './src/column';
 export { Filter } from './src/filter/filter-interfaces';
-export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';

package/esm/postgres/postgres-data-provider.d.ts

@@ -1,4 +1,5 @@
-import { PoolConfig, QueryResult } from 'pg';
+import { ClientBase, PoolConfig, QueryResult } from 'pg';
+import { Remult } from '../src/context';
 import { EntityMetadata } from '../src/remult3';
 import { SqlCommand, SqlImplementation } from '../src/sql-command';
 import { SqlDatabase } from '../src/data-providers/sql-database';
@@ -10,6 +11,7 @@ export interface PostgresClient extends PostgresCommandSource {
 }
 export declare class PostgresDataProvider implements SqlImplementation {
     private pool;
+    static getDb(remult?: Remult): ClientBase;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     getLimitSqlSyntax(limit: number, offset: number): string;
     createCommand(): SqlCommand;

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

@@ -6,6 +6,14 @@ export class PostgresDataProvider {
     constructor(pool) {
         this.pool = pool;
     }
+    static getDb(remult) {
+        const sql = SqlDatabase.getDb(remult);
+        const me = sql._getSourceSql();
+        if (!me.pool) {
+            throw "the data provider is not a PostgresDataProvider";
+        }
+        return me.pool;
+    }
     async entityIsUsedForTheFirstTime(entity) {
     }
     getLimitSqlSyntax(limit, offset) {
@@ -22,7 +30,9 @@ export class PostgresDataProvider {
                 createCommand: () => new PostgresBridgeToSQLCommand(client),
                 entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
                 transaction: () => { throw "nested transactions not allowed"; },
-                getLimitSqlSyntax: this.getLimitSqlSyntax
+                getLimitSqlSyntax: this.getLimitSqlSyntax,
+                //@ts-ignore
+                pool: client
             });
             await client.query('COMMIT');
         }

package/esm/postgres/schema-builder.js

@@ -1,5 +1,5 @@
 import { allEntities } from '../src/context';
-import { getDbNameProvider } from '../src/filter/filter-consumer-bridge-to-sql-request';
+import { dbNamesOf, isDbReadonly } from '../src/filter/filter-consumer-bridge-to-sql-request';
 import { isAutoIncrement } from '../src/remult3';
 import { ValueConverters } from '../src/valueConverters';
 export function postgresColumnSyntax(x, dbName) {
@@ -46,57 +46,57 @@ export class PostgresSchemaBuilder {
         console.log("start verify structure");
         for (const entityClass of allEntities) {
             let entity = remult.repo(entityClass).metadata;
-            let e = await getDbNameProvider(entity);
+            let e = await dbNamesOf(entity);
             try {
                 if (!entity.options.sqlExpression) {
-                    if ((await e.entityName).toLowerCase().indexOf('from ') < 0) {
+                    if ((await e.$entityName).toLowerCase().indexOf('from ') < 0) {
                         await this.createIfNotExist(entity);
                         await this.verifyAllColumns(entity);
                     }
                 }
             }
             catch (err) {
-                console.log("failed verify structure of " + e.entityName + " ", err);
+                console.log("failed verify structure of " + e.$entityName + " ", err);
             }
         }
     }
     async createIfNotExist(entity) {
         var c = this.pool.createCommand();
-        let e = await getDbNameProvider(entity);
-        await c.execute("select 1 from information_Schema.tables where table_name=" + c.addParameterAndReturnSqlToken((e.entityName).toLowerCase()) + this.additionalWhere).then(async (r) => {
+        let e = await dbNamesOf(entity);
+        await c.execute("select 1 from information_Schema.tables where table_name=" + c.addParameterAndReturnSqlToken((e.$entityName).toLowerCase()) + this.additionalWhere).then(async (r) => {
             if (r.rows.length == 0) {
                 let result = '';
                 for (const x of entity.fields) {
-                    if (!e.isDbReadonly(x) || isAutoIncrement(x)) {
+                    if (!isDbReadonly(x, e) || isAutoIncrement(x)) {
                         if (result.length != 0)
                             result += ',';
                         result += '\r\n  ';
                         if (isAutoIncrement(x))
-                            result += e.nameOf(x) + ' serial';
+                            result += e.dbNameOf(x) + ' serial';
                         else {
-                            result += postgresColumnSyntax(x, e.nameOf(x));
+                            result += postgresColumnSyntax(x, e.dbNameOf(x));
                             if (x == entity.idMetadata.field)
                                 result += ' primary key';
                         }
                     }
                 }
-                let sql = 'create table ' + e.entityName + ' (' + result + '\r\n)';
+                let sql = 'create table ' + e.$entityName + ' (' + result + '\r\n)';
                 //console.log(sql);
                 await this.pool.execute(sql);
             }
         });
     }
     async addColumnIfNotExist(entity, c) {
-        let e = await getDbNameProvider(entity);
-        if (e.isDbReadonly(c(entity)))
+        let e = await dbNamesOf(entity);
+        if (isDbReadonly(c(entity), e))
             return;
         try {
             let cmd = this.pool.createCommand();
-            const colName = e.nameOf(c(entity));
+            const colName = e.dbNameOf(c(entity));
             if ((await cmd.execute(`select 1   
         FROM information_schema.columns 
-        WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.entityName).toLocaleLowerCase())} and column_name=${cmd.addParameterAndReturnSqlToken((colName).toLocaleLowerCase())}` + this.additionalWhere)).rows.length == 0) {
-                let sql = `alter table ${e.entityName} add column ${postgresColumnSyntax(c(entity), colName)}`;
+        WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.$entityName).toLocaleLowerCase())} and column_name=${cmd.addParameterAndReturnSqlToken((colName).toLocaleLowerCase())}` + this.additionalWhere)).rows.length == 0) {
+                let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(c(entity), colName)}`;
                 //console.log(sql);
                 await this.pool.execute(sql);
             }
@@ -108,14 +108,14 @@ export class PostgresSchemaBuilder {
     async verifyAllColumns(entity) {
         try {
             let cmd = this.pool.createCommand();
-            let e = await getDbNameProvider(entity);
+            let e = await dbNamesOf(entity);
             let cols = (await cmd.execute(`select column_name   
         FROM information_schema.columns 
-        WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.entityName).toLocaleLowerCase())} ` + this.additionalWhere)).rows.map(x => x.column_name);
+        WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.$entityName).toLocaleLowerCase())} ` + this.additionalWhere)).rows.map(x => x.column_name);
             for (const col of entity.fields) {
-                if (!e.isDbReadonly(col))
-                    if (!cols.includes(e.nameOf(col).toLocaleLowerCase())) {
-                        let sql = `alter table ${e.entityName} add column ${postgresColumnSyntax(col, e.nameOf(col))}`;
+                if (!isDbReadonly(col, e))
+                    if (!cols.includes(e.dbNameOf(col).toLocaleLowerCase())) {
+                        let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(col, e.dbNameOf(col))}`;
                         //console.log(sql);
                         await this.pool.execute(sql);
                     }

package/esm/remult-knex/index.d.ts

@@ -1,43 +1,19 @@
-import { Knex } from 'knex';
-import { Filter, FilterConsumer } from "../src/filter/filter-interfaces";
-import { dbNameProvider } from "../src/filter/filter-consumer-bridge-to-sql-request";
+import type { Knex } from 'knex';
 import { Remult } from "../src/context";
-import { EntityFilter, EntityMetadata } from "../src/remult3";
+import { EntityFilter, EntityMetadata, Repository } from "../src/remult3";
 import { DataProvider, EntityDataProvider } from '../src/data-interfaces';
 import { FieldMetadata } from '../src/column-interfaces';
 export declare class KnexDataProvider implements DataProvider {
     knex: Knex;
     constructor(knex: Knex);
+    static getDb(remult?: Remult): Knex<any, Record<string, any>[]>;
     getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     static customFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
     supportsCustomFilter?: boolean;
 }
 export declare type CustomKnexFilterBuilderFunction = () => Promise<(builder: Knex.QueryBuilder) => void>;
-export declare class FilterConsumerBridgeToKnexRequest implements FilterConsumer {
-    private nameProvider;
-    _addWhere: boolean;
-    promises: Promise<void>[];
-    result: ((builder: Knex.QueryBuilder) => void)[];
-    resolveWhere(): Promise<((builder: Knex.QueryBuilder<any, any>) => void)[]>;
-    constructor(nameProvider: dbNameProvider);
-    custom(key: string, customItem: any): void;
-    or(orElements: Filter[]): void;
-    isNull(col: FieldMetadata): void;
-    isNotNull(col: FieldMetadata): void;
-    isIn(col: FieldMetadata, val: any[]): void;
-    isEqualTo(col: FieldMetadata, val: any): void;
-    isDifferentFrom(col: FieldMetadata, val: any): void;
-    isGreaterOrEqualTo(col: FieldMetadata, val: any): void;
-    isGreaterThan(col: FieldMetadata, val: any): void;
-    isLessOrEqualTo(col: FieldMetadata, val: any): void;
-    isLessThan(col: FieldMetadata, val: any): void;
-    containsCaseInsensitive(col: FieldMetadata, val: any): void;
-    private add;
-    databaseCustom(databaseCustom: {
-        buildKnex: CustomKnexFilterBuilderFunction;
-    }): void;
-}
+export declare function knexCondition<entityType>(repo: Repository<entityType>, condition: EntityFilter<entityType>): Promise<(knex: any) => void>;
 export declare class KnexSchemaBuilder {
     private knex;
     verifyStructureOfAllEntities(remult: Remult): Promise<void>;

package/esm/remult-knex/index.js

@@ -1,15 +1,21 @@
-import knex from 'knex';
 import { customDatabaseFilterToken, Filter } from "../src/filter/filter-interfaces";
-import { getDbNameProvider } from "../src/filter/filter-consumer-bridge-to-sql-request";
+import { dbNamesOf, isDbReadonly } from "../src/filter/filter-consumer-bridge-to-sql-request";
 import { allEntities, Remult } from "../src/context";
 import { isAutoIncrement } from "../src/remult3";
 import { ValueConverters } from "../src/valueConverters";
 import { CompoundIdField } from '../src/column';
 import { Sort } from '../src/sort';
+import { remult as remultContext } from '../src/remult-proxy';
 export class KnexDataProvider {
     constructor(knex) {
         this.knex = knex;
     }
+    static getDb(remult) {
+        const r = (remult || remultContext).dataProvider;
+        if (!r.knex)
+            throw "the data provider is not an KnexDataProvider";
+        return r.knex;
+    }
     getEntityDataProvider(entity) {
         return new KnexEntityDataProvider(entity, this.knex);
     }
@@ -42,7 +48,7 @@ class KnexEntityDataProvider {
         const br = new FilterConsumerBridgeToKnexRequest(e);
         where.__applyToConsumer(br);
         let r = await br.resolveWhere();
-        const result = (await this.knex(e.entityName)
+        const result = (await this.knex(e.$entityName)
             .count().where(b => r.forEach(w => w(b))));
         var row = result[0];
         for (const key in row) {
@@ -60,11 +66,11 @@ class KnexEntityDataProvider {
             if (x.isServerExpression) {
             }
             else {
-                cols.push(e.nameOf(x));
+                cols.push(e.dbNameOf(x));
                 colKeys.push(x);
             }
         }
-        let query = this.knex(e.entityName).select(cols);
+        let query = this.knex(e.$entityName).select(cols);
         if (options?.where) {
             const br = new FilterConsumerBridgeToKnexRequest(e);
             options.where.__applyToConsumer(br);
@@ -76,7 +82,7 @@ class KnexEntityDataProvider {
         }
         if (options.orderBy) {
             query = query.orderBy(options.orderBy.Segments.map(s => ({
-                column: e.nameOf(s.field),
+                column: e.dbNameOf(s.field),
                 order: s.isDescending ? "desc" : "asc"
             })));
         }
@@ -102,7 +108,7 @@ class KnexEntityDataProvider {
         });
     }
     async init() {
-        return await getDbNameProvider(this.entity);
+        return await dbNamesOf(this.entity);
     }
     async update(id, data) {
         const e = await this.init();
@@ -113,17 +119,17 @@ class KnexEntityDataProvider {
             resultFilter = this.entity.idMetadata.getIdFilter(data.id);
         let updateObject = {};
         for (const x of this.entity.fields) {
-            if (e.isDbReadonly(x)) { }
+            if (isDbReadonly(x, e)) { }
             else if (data[x.key] !== undefined) {
                 let v = x.valueConverter.toDb(data[x.key]);
                 if (v !== undefined) {
-                    let key = await e.nameOf(x);
+                    let key = await e.dbNameOf(x);
                     updateObject[key] = v;
                 }
             }
         }
         let where = await f.resolveWhere();
-        await this.knex(e.entityName).update(updateObject).where(b => where.forEach(w => w(b)));
+        await this.knex(e.$entityName).update(updateObject).where(b => where.forEach(w => w(b)));
         return this.find({ where: Filter.fromEntityFilter(this.entity, resultFilter) }).then(y => y[0]);
     }
     async delete(id) {
@@ -131,7 +137,7 @@ class KnexEntityDataProvider {
         let f = new FilterConsumerBridgeToKnexRequest(e);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
         let where = await f.resolveWhere();
-        await this.knex(e.entityName).delete().where(b => where.forEach(w => w(b)));
+        await this.knex(e.$entityName).delete().where(b => where.forEach(w => w(b)));
     }
     async insert(data) {
         const e = await this.init();
@@ -142,16 +148,16 @@ class KnexEntityDataProvider {
             resultFilter = Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(data[this.entity.idMetadata.field.key]));
         let insertObject = {};
         for (const x of this.entity.fields) {
-            if (e.isDbReadonly(x)) { }
+            if (isDbReadonly(x, e)) { }
             else {
                 let v = x.valueConverter.toDb(data[x.key]);
                 if (v != undefined) {
-                    let key = await e.nameOf(x);
+                    let key = await e.dbNameOf(x);
                     insertObject[key] = v;
                 }
             }
         }
-        let insert = this.knex(e.entityName).insert(insertObject);
+        let insert = this.knex(e.$entityName).insert(insertObject);
         if (isAutoIncrement(this.entity.idMetadata.field)) {
             let result = await insert.returning(this.entity.idMetadata.field.key);
             let newId = result[0].id;
@@ -164,7 +170,7 @@ class KnexEntityDataProvider {
         });
     }
 }
-export class FilterConsumerBridgeToKnexRequest {
+class FilterConsumerBridgeToKnexRequest {
     constructor(nameProvider) {
         this.nameProvider = nameProvider;
         this._addWhere = true;
@@ -208,13 +214,13 @@ export class FilterConsumerBridgeToKnexRequest {
         })());
     }
     isNull(col) {
-        this.result.push(b => b.whereNull(this.nameProvider.nameOf(col)));
+        this.result.push(b => b.whereNull(this.nameProvider.dbNameOf(col)));
     }
     isNotNull(col) {
-        this.result.push(b => b.whereNotNull(this.nameProvider.nameOf(col)));
+        this.result.push(b => b.whereNotNull(this.nameProvider.dbNameOf(col)));
     }
     isIn(col, val) {
-        this.result.push(knex => knex.whereIn(this.nameProvider.nameOf(col), val.map(x => col.valueConverter.toDb(x))));
+        this.result.push(knex => knex.whereIn(this.nameProvider.dbNameOf(col), val.map(x => col.valueConverter.toDb(x))));
     }
     isEqualTo(col, val) {
         this.add(col, val, "=");
@@ -235,12 +241,12 @@ export class FilterConsumerBridgeToKnexRequest {
         this.add(col, val, "<");
     }
     containsCaseInsensitive(col, val) {
-        this.result.push(b => b.whereRaw('lower (' + this.nameProvider.nameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')"));
+        this.result.push(b => b.whereRaw('lower (' + this.nameProvider.dbNameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')"));
         this.promises.push((async () => {
         })());
     }
     add(col, val, operator) {
-        this.result.push(b => b.where(this.nameProvider.nameOf(col), operator, col.valueConverter.toDb(val)));
+        this.result.push(b => b.where(this.nameProvider.dbNameOf(col), operator, col.valueConverter.toDb(val)));
     }
     databaseCustom(databaseCustom) {
         this.promises.push((async () => {
@@ -250,6 +256,13 @@ export class FilterConsumerBridgeToKnexRequest {
         })());
     }
 }
+export async function knexCondition(repo, condition) {
+    var b = new FilterConsumerBridgeToKnexRequest(await dbNamesOf(repo.metadata));
+    b._addWhere = false;
+    await (await (repo.translateWhereToFilter(condition))).__applyToConsumer(b);
+    let r = await b.resolveWhere();
+    return knex => r.forEach(y => y(knex));
+}
 export class KnexSchemaBuilder {
     constructor(knex) {
         this.knex = knex;
@@ -273,16 +286,16 @@ export class KnexSchemaBuilder {
         }
     }
     async createIfNotExist(entity) {
-        const e = await getDbNameProvider(entity);
-        if (!await this.knex.schema.hasTable(e.entityName)) {
+        const e = await dbNamesOf(entity);
+        if (!await this.knex.schema.hasTable(e.$entityName)) {
             let cols = new Map();
             for (const f of entity.fields) {
                 cols.set(f, {
-                    name: e.nameOf(f),
-                    readonly: e.isDbReadonly(f)
+                    name: e.dbNameOf(f),
+                    readonly: isDbReadonly(f, e)
                 });
             }
-            await logSql(this.knex.schema.createTable(e.entityName, b => {
+            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))
@@ -298,22 +311,22 @@ export class KnexSchemaBuilder {
         }
     }
     async addColumnIfNotExist(entity, c) {
-        let e = await getDbNameProvider(entity);
-        if (e.isDbReadonly(c(entity)))
+        let e = await dbNamesOf(entity);
+        if (isDbReadonly(c(entity), e))
             return;
         let col = c(entity);
-        let colName = e.nameOf(col);
-        if (!await this.knex.schema.hasColumn(e.entityName, colName)) {
-            await this.knex.schema.alterTable(e.entityName, b => {
+        let colName = e.dbNameOf(col);
+        if (!await this.knex.schema.hasColumn(e.$entityName, colName)) {
+            await this.knex.schema.alterTable(e.$entityName, b => {
                 buildColumn(col, colName, b);
             });
         }
     }
     async verifyAllColumns(entity) {
-        let e = await getDbNameProvider(entity);
+        let e = await dbNamesOf(entity);
         try {
             for (const col of entity.fields) {
-                if (!e.isDbReadonly(col)) {
+                if (isDbReadonly(col, e)) {
                     await this.addColumnIfNotExist(entity, () => col);
                 }
             }
@@ -377,7 +390,7 @@ function logSql(who) {
     return who;
 }
 export async function createKnexDataProvider(config, autoCreateTables = true) {
-    let k = knex(config);
+    let k = (await import('knex')).default(config);
     let result = new KnexDataProvider(k);
     if (autoCreateTables)
         await new KnexSchemaBuilder(k).verifyStructureOfAllEntities(new Remult(result));

package/esm/remult-mongo.d.ts

@@ -1,9 +1,15 @@
-import { MongoClient, Db } from 'mongodb';
-import { DataProvider, EntityDataProvider, EntityMetadata } from '.';
+import type { MongoClient, Db } from 'mongodb';
+import { DataProvider, EntityDataProvider, EntityFilter, EntityMetadata, Remult, Repository } from '.';
 export declare class MongoDataProvider implements DataProvider {
     private db;
     private client;
     constructor(db: Db, client: MongoClient);
+    static getDb(remult?: Remult): Db;
     getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
 }
+export declare function mongoCondition<entityType>(repo: Repository<entityType>, condition: EntityFilter<entityType>): Promise<{
+    $and: any[];
+} | {
+    $and?: undefined;
+}>;

package/esm/remult-mongo.js

@@ -1,10 +1,17 @@
 import { CompoundIdField, Filter } from '.';
-import { getDbNameProvider } from './src/filter/filter-consumer-bridge-to-sql-request';
+import { dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
+import { remult as remultContext } from './src/remult-proxy';
 export class MongoDataProvider {
     constructor(db, client) {
         this.db = db;
         this.client = client;
     }
+    static getDb(remult) {
+        const r = (remult || remultContext).dataProvider;
+        if (!r.db)
+            throw "the data provider is not a MongoDataProvider";
+        return r.db;
+    }
     getEntityDataProvider(entity) {
         return new MongoEntityDataProvider(this.db, entity);
     }
@@ -33,7 +40,7 @@ class MongoEntityDataProvider {
     translateFromJson(row, nameProvider) {
         let result = {};
         for (const col of this.entity.fields) {
-            let val = row[nameProvider.nameOf(col)];
+            let val = row[nameProvider.dbNameOf(col)];
             if (isNull(val))
                 val = null;
             result[col.key] = col.valueConverter.fromDb(val);
@@ -46,7 +53,7 @@ class MongoEntityDataProvider {
             let val = col.valueConverter.toDb(row[col.key]);
             if (val === null)
                 val = NULL;
-            result[nameProvider.nameOf(col)] = val;
+            result[nameProvider.dbNameOf(col)] = val;
         }
         return result;
     }
@@ -73,7 +80,7 @@ class MongoEntityDataProvider {
         if (options.orderBy) {
             op.sort = {};
             for (const s of options.orderBy.Segments) {
-                op.sort[e.nameOf(s.field)] = s.isDescending ? -1 : 1;
+                op.sort[e.dbNameOf(s.field)] = s.isDescending ? -1 : 1;
             }
         }
         return await Promise.all(await collection.find(where, op).map(x => this.translateFromJson(x, e)).toArray());
@@ -116,8 +123,8 @@ class MongoEntityDataProvider {
         return await this.translateFromJson(await collection.findOne({ _id: r.insertedId }), e);
     }
     async collection() {
-        const e = await getDbNameProvider(this.entity);
-        const collection = this.db.collection(e.entityName);
+        const e = await dbNamesOf(this.entity);
+        const collection = this.db.collection(e.$entityName);
         return { e, collection };
     }
 }
@@ -171,7 +178,7 @@ class FilterConsumerBridgeToMongo {
     }
     isIn(col, val) {
         this.result.push(() => ({
-            [this.nameProvider.nameOf(col)]: {
+            [this.nameProvider.dbNameOf(col)]: {
                 $in: val.map(x => col.valueConverter.toDb(x))
             }
         }));
@@ -203,7 +210,7 @@ class FilterConsumerBridgeToMongo {
     }
     add(col, val, operator) {
         this.result.push(() => ({
-            [this.nameProvider.nameOf(col)]: { [operator]: isNull(val) ? val : col.valueConverter.toDb(val) }
+            [this.nameProvider.dbNameOf(col)]: { [operator]: isNull(val) ? val : col.valueConverter.toDb(val) }
         }));
     }
     databaseCustom(databaseCustom) {
@@ -219,3 +226,10 @@ class FilterConsumerBridgeToMongo {
         //   })());
     }
 }
+export async function mongoCondition(repo, condition) {
+    var b = new FilterConsumerBridgeToMongo(await dbNamesOf(repo.metadata));
+    b._addWhere = false;
+    await (await (repo.translateWhereToFilter(condition))).__applyToConsumer(b);
+    let r = await b.resolveWhere();
+    return r;
+}

package/esm/server/expressBridge.d.ts

@@ -30,6 +30,7 @@ export interface RemultServer {
     getRemult(req: GenericRequest): Promise<Remult>;
     openApiDoc(options: {
         title: string;
+        version?: string;
     }): any;
     registerRouter(r: GenericRouter): void;
     handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;