remult 0.17.3 → 0.18.0

package/esm/postgres/schema-builder.d.ts

@@ -6,7 +6,8 @@ export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string):
 export declare function verifyStructureOfAllEntities(db: SqlDatabase, remult: Remult): Promise<void>;
 export declare class PostgresSchemaBuilder {
     private pool;
-    verifyStructureOfAllEntities(remult: Remult): Promise<void>;
+    verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     createIfNotExist(entity: EntityMetadata): Promise<void>;
     addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: ((e: T) => FieldMetadata)): Promise<void>;
     verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;

package/esm/postgres/schema-builder.js

@@ -1,5 +1,6 @@
 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 { RemultProxy } from '../src/remult-proxy';
 import { isAutoIncrement } from '../src/remult3';
 import { ValueConverters } from '../src/valueConverters';
 export function postgresColumnSyntax(x, dbName) {
@@ -43,86 +44,105 @@ export class PostgresSchemaBuilder {
         }
     }
     async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure");
-        for (const entityClass of allEntities) {
+        if (!remult) {
+            remult = RemultProxy.defaultRemult;
+        }
+        const completed = new Set();
+        const entities = [];
+        for (const entityClass of [...allEntities].reverse()) {
             let entity = remult.repo(entityClass).metadata;
-            let e = await getDbNameProvider(entity);
+            let e = await dbNamesOf(entity);
+            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);
             try {
                 if (!entity.options.sqlExpression) {
-                    if ((await e.entityName).toLowerCase().indexOf('from ') < 0) {
+                    if (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.error("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));
-                            if (x == entity.idMetadata.field)
-                                result += ' primary key';
+                            result += postgresColumnSyntax(x, e.$dbNameOf(x));
                         }
+                        if (x == entity.idMetadata.field)
+                            result += ' primary key';
                     }
                 }
-                let sql = 'create table ' + e.entityName + ' (' + result + '\r\n)';
-                //console.log(sql);
+                let sql = 'create table ' + e.$entityName + ' (' + result + '\r\n)';
+                if (PostgresSchemaBuilder.logToConsole)
+                    console.info(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)}`;
-                //console.log(sql);
+        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)}`;
+                if (PostgresSchemaBuilder.logToConsole)
+                    console.info(sql);
                 await this.pool.execute(sql);
             }
         }
         catch (err) {
-            console.log(err);
+            console.error(err);
         }
     }
     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))}`;
-                        //console.log(sql);
+                if (!isDbReadonly(col, e))
+                    if (!cols.includes(e.$dbNameOf(col).toLocaleLowerCase())) {
+                        let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(col, e.$dbNameOf(col))}`;
+                        if (PostgresSchemaBuilder.logToConsole)
+                            console.info(sql);
                         await this.pool.execute(sql);
                     }
             }
         }
         catch (err) {
-            console.log(err);
+            console.error(err);
         }
     }
 }
+//@internal
+PostgresSchemaBuilder.logToConsole = true;

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

@@ -1,46 +1,24 @@
-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, RepositoryOverloads } 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, any[]>;
     getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    static customFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
-    supportsCustomFilter?: boolean;
+    static rawFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
+    static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<(knex: any) => void>;
+    supportsRawFilter?: boolean;
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
 }
 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 class KnexSchemaBuilder {
     private knex;
-    verifyStructureOfAllEntities(remult: Remult): Promise<void>;
+    verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     createIfNotExist(entity: EntityMetadata): Promise<void>;
     addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: ((e: T) => FieldMetadata)): Promise<void>;
     verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
@@ -48,4 +26,4 @@ export declare class KnexSchemaBuilder {
     constructor(knex: Knex);
 }
 export declare function buildColumn(x: FieldMetadata, dbName: string, b: Knex.CreateTableBuilder): void;
-export declare function createKnexDataProvider(config: Knex.Config, autoCreateTables?: boolean): Promise<KnexDataProvider>;
+export declare function createKnexDataProvider(config: Knex.Config): Promise<KnexDataProvider>;

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 { allEntities, Remult } from "../src/context";
-import { isAutoIncrement } from "../src/remult3";
+import { dbNamesOf, isDbReadonly } from "../src/filter/filter-consumer-bridge-to-sql-request";
+import { allEntities } from "../src/context";
+import { isAutoIncrement, getRepository } from "../src/remult3";
 import { ValueConverters } from "../src/valueConverters";
 import { CompoundIdField } from '../src/column';
 import { Sort } from '../src/sort';
+import { remult as remultContext, RemultProxy } 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);
     }
@@ -24,13 +30,25 @@ export class KnexDataProvider {
             throw err;
         }
     }
-    static customFilter(build) {
+    static rawFilter(build) {
         return {
             [customDatabaseFilterToken]: {
                 buildKnex: build
             }
         };
     }
+    static async filterToRaw(entity, condition) {
+        const repo = getRepository(entity);
+        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));
+    }
+    async ensureSchema(entities) {
+        var sb = new KnexSchemaBuilder(this.knex);
+        await sb.ensureSchema(entities);
+    }
 }
 class KnexEntityDataProvider {
     constructor(entity, knex) {
@@ -42,7 +60,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 +78,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 +94,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 +120,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 +131,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 +149,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 +160,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 newId;
             if (this.knex.client.config.client === 'mysql2') {
@@ -171,7 +189,7 @@ class KnexEntityDataProvider {
         });
     }
 }
-export class FilterConsumerBridgeToKnexRequest {
+class FilterConsumerBridgeToKnexRequest {
     constructor(nameProvider) {
         this.nameProvider = nameProvider;
         this._addWhere = true;
@@ -215,13 +233,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, "=");
@@ -242,12 +260,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 () => {
@@ -263,33 +281,38 @@ export class KnexSchemaBuilder {
         this.additionalWhere = '';
     }
     async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure");
-        for (const entity of allEntities) {
-            let metadata = remult.repo(entity).metadata;
+        if (!remult)
+            remult = RemultProxy.defaultRemult;
+        const entities = allEntities.map(x => remult.repo(x).metadata);
+        this.ensureSchema(entities);
+    }
+    async ensureSchema(entities) {
+        for (const entity of entities) {
+            let e = await dbNamesOf(entity);
             try {
-                if (!metadata.options.sqlExpression) {
-                    if ((await metadata.getDbName()).toLowerCase().indexOf('from ') < 0) {
-                        await this.createIfNotExist(metadata);
-                        await this.verifyAllColumns(metadata);
+                if (!entity.options.sqlExpression) {
+                    if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
+                        await this.createIfNotExist(entity);
+                        await this.verifyAllColumns(entity);
                     }
                 }
             }
             catch (err) {
-                console.log("failed verify structure of " + await metadata.getDbName() + " ", err);
+                console.error("failed ensure schema of " + e.$entityName + " ", err);
             }
         }
     }
     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))
@@ -305,31 +328,33 @@ 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 logSql(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)) {
+            for (const col of entity.fields.toArray()) {
+                if (!isDbReadonly(col, e)) {
                     await this.addColumnIfNotExist(entity, () => col);
                 }
             }
         }
         catch (err) {
-            console.log(err);
+            console.error(err);
         }
     }
 }
+//@internal
+KnexSchemaBuilder.logToConsole = true;
 export function buildColumn(x, dbName, b) {
     if (x.valueType == Number) {
         if (!x.valueConverter.fieldTypeInDb) {
@@ -380,13 +405,12 @@ export function buildColumn(x, dbName, b) {
     }
 }
 function logSql(who) {
-    //console.log(who.toSQL().sql);
+    if (KnexSchemaBuilder.logToConsole)
+        console.info(who.toSQL());
     return who;
 }
-export async function createKnexDataProvider(config, autoCreateTables = true) {
-    let k = knex(config);
+export async function createKnexDataProvider(config) {
+    let k = (await import('knex')).default(config);
     let result = new KnexDataProvider(k);
-    if (autoCreateTables)
-        await new KnexSchemaBuilder(k).verifyStructureOfAllEntities(new Remult(result));
     return result;
 }

package/esm/remult-mongo.d.ts

@@ -1,9 +1,16 @@
-import { MongoClient, Db } from 'mongodb';
-import { DataProvider, EntityDataProvider, EntityMetadata } from '.';
+import type { MongoClient, Db } from 'mongodb';
+import { DataProvider, EntityDataProvider, EntityFilter, EntityMetadata, Remult } from '.';
+import { RepositoryOverloads } from './src/remult3';
 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>;
+    static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<{
+        $and: any[];
+    } | {
+        $and?: undefined;
+    }>;
 }

package/esm/remult-mongo.js

@@ -1,10 +1,18 @@
 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 { getRepository } from './src/remult3';
+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);
     }
@@ -20,6 +28,14 @@ export class MongoDataProvider {
             throw err;
         }
     }
+    static async filterToRaw(entity, condition) {
+        const repo = getRepository(entity);
+        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;
+    }
 }
 const NULL = { $null: "$null" };
 function isNull(x) {
@@ -33,7 +49,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 +62,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 +89,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 +132,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 +187,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 +219,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) {

package/esm/remult-next.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import type { GetServerSideProps, NextApiRequest, PreviewData, NextApiHandler } from "next";
+import type { ParsedUrlQuery } from "querystring";
+import { RemultServer, RemultServerOptions } from "./server";
+export declare function remultNext(options?: RemultServerOptions<NextApiRequest>): RemultServer & NextApiHandler & {
+    getServerSideProps<P extends {
+        [key: string]: any;
+    } = {
+        [key: string]: any;
+    }, Q extends ParsedUrlQuery = ParsedUrlQuery, D extends PreviewData = PreviewData>(getServerPropsFunction: GetServerSideProps<P, Q, D>): GetServerSideProps<P, Q, D>;
+};

package/esm/remult-next.js

@@ -0,0 +1,27 @@
+import { createRemultServer } from "./server";
+export function remultNext(options) {
+    let result = createRemultServer(options);
+    return Object.assign((req, res) => result.handle(req, res), result, {
+        getRemult: (...args) => result.getRemult(...args),
+        handle: (...args) => result.handle(...args),
+        openApiDoc: (...args) => result.openApiDoc(...args),
+        registerRouter: (...args) => result.registerRouter(...args),
+        withRemult: (...args) => result.withRemult(...args),
+    }, {
+        getServerSideProps: (getServerPropsFunction) => {
+            return (context) => {
+                return new Promise((res, err) => {
+                    result.withRemult(context, undefined, async () => {
+                        try {
+                            let r = await getServerPropsFunction(context);
+                            res(JSON.parse(JSON.stringify(r)));
+                        }
+                        catch (e) {
+                            err(e);
+                        }
+                    });
+                });
+            };
+        }
+    });
+}