remult 0.16.3-exp.3 → 0.16.3

package/README.md

@@ -3,6 +3,7 @@
     <img src="https://github.com/remult/remult/raw/master/docs/.vuepress/public/logo.png" width="140" height="140">
   </a>
   <h1>Remult</h1>
+  <p>A CRUD framework for full-stack TypeScript</p>
 	<a href="https://circleci.com/gh/remult/remult/tree/master" rel="nofollow">
 		<img alt="CircleCI" src="https://circleci.com/gh/remult/remult/tree/master.svg?style=shield">
 	</a>
@@ -24,14 +25,28 @@
   <a href="https://twitter.com/intent/tweet?text=Remult%20-%20open-source%20CRUD%20framework%20for%20full-stack%20TypeScript%0A%0A%40remultjs%0A&url=https%3A%2F%2Fgithub.com%2Fremult%2Fremult">
     <img alt="Twitter URL" src="https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Ftwitter.com%2Fintent%2Ftweet%3Ftext%3DRemult%2520-%2520open-source%2520CRUD%2520framework%2520for%2520full-stack%2520TypeScript%250A%250A%2540remultjs%250A%26url%3Dhttps%253A%252F%252Fgithub.com%252Fremult%252Fremult">
   </a>
-	<a href="https://twitter.com/remultjs" rel="nofollow">
-	  <img alt="Twitter Follow" src="https://img.shields.io/twitter/url.svg?label=Follow%20%40remultjs&style=social&url=https%3A%2F%2Ftwitter.com%2FRemultJs">
-	</a>
 </div>
+
+<br/>
+
+<div align="center">
+  <a href="#getting-started">Getting Started</a> |
+  <a href="#documentation">Documentation</a> |
+  <a href="#example-apps">Example Apps</a>
+</div>
+
 <hr/>
+<br/>
 
-[Getting Started](#getting-started) | [Documentation](#documentation) |
-[Example Apps](#example-apps)
+<a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
+  <p align="center">
+    <img src="https://github.com/remult/remult/raw/master/static/images/video-thumbnail.jpg" alt="Video thumbnail" width="320" />
+  </p>
+</a>
+
+<a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
+  <p align="center">Watch code demo on YouTube here</p>
+</a>
 
 ## What is Remult?
 
@@ -39,6 +54,13 @@
 as a single source of truth for your API, frontend type-safe API client and
 backend ORM**.
 
+* :zap: Zero-boilerplate CRUD API routes with paging, sorting, and filtering for Express / Fastify / Next.js / NestJS / Koa / others...
+* :ok_hand: Fullstack type-safety for API queries, mutations and RPC, without code generation
+* :sparkles: Input validation, defined once, runs both on the backend and on the frontend for best UX
+* :lock: Fine-grained code-based API authorization
+* :relieved: Incrementally adoptable
+* :rocket: Production ready
+
 ### Status
 
 Remult is **production-ready** and, in fact, used in production apps since 2018.

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, dbNamesOf, sqlCondition } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { CustomSqlFilterObject, CustomSqlFilterBuilder } 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,6 +18,7 @@ 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, dbNamesOf, sqlCondition } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { CustomSqlFilterBuilder } 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,6 +17,7 @@ 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,5 +1,4 @@
-import { ClientBase, PoolConfig, QueryResult } from 'pg';
-import { Remult } from '../src/context';
+import { PoolConfig, QueryResult } from 'pg';
 import { EntityMetadata } from '../src/remult3';
 import { SqlCommand, SqlImplementation } from '../src/sql-command';
 import { SqlDatabase } from '../src/data-providers/sql-database';
@@ -11,7 +10,6 @@ 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,14 +6,6 @@ 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) {
@@ -30,9 +22,7 @@ export class PostgresDataProvider {
                 createCommand: () => new PostgresBridgeToSQLCommand(client),
                 entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
                 transaction: () => { throw "nested transactions not allowed"; },
-                getLimitSqlSyntax: this.getLimitSqlSyntax,
-                //@ts-ignore
-                pool: client
+                getLimitSqlSyntax: this.getLimitSqlSyntax
             });
             await client.query('COMMIT');
         }

package/esm/postgres/postgresColumnSyntax.d.ts

@@ -0,0 +1,2 @@
+import { FieldMetadata } from '../src/column-interfaces';
+export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;

package/esm/postgres/postgresColumnSyntax.js

@@ -0,0 +1,30 @@
+import { ValueConverters } from '../valueConverters';
+export function postgresColumnSyntax(x, dbName) {
+    let result = dbName;
+    if (x.valueType == Number) {
+        if (!x.valueConverter.fieldTypeInDb)
+            result += " numeric" + (x.allowNull ? "" : " default 0 not null");
+        else
+            result += " " + x.valueConverter.fieldTypeInDb + (x.allowNull ? "" : " default 0 not null");
+    }
+    else if (x.valueType == Date) {
+        if (!x.valueConverter.fieldTypeInDb)
+            if (x.valueConverter == ValueConverters.DateOnly)
+                result += " date";
+            else
+                result += " timestamp";
+        else
+            result += " " + x.valueConverter.fieldTypeInDb;
+    }
+    else if (x.valueType == Boolean)
+        result += " boolean" + (x.allowNull ? "" : " default false not null");
+    else if (x.valueConverter.fieldTypeInDb) {
+        result += " " + x.valueConverter.fieldTypeInDb;
+        if (!x.allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
+            result += " default 0 not null";
+        }
+    }
+    else
+        result += " varchar" + (x.allowNull ? "" : " default '' not null");
+    return result;
+}

package/esm/postgres/schema-builder.js

@@ -1,5 +1,5 @@
 import { allEntities } from '../src/context';
-import { dbNamesOf, isDbReadonly } from '../src/filter/filter-consumer-bridge-to-sql-request';
+import { getDbNameProvider } 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 dbNamesOf(entity);
+            let e = await getDbNameProvider(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 dbNamesOf(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 getDbNameProvider(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 (!isDbReadonly(x, e) || isAutoIncrement(x)) {
+                    if (!e.isDbReadonly(x) || isAutoIncrement(x)) {
                         if (result.length != 0)
                             result += ',';
                         result += '\r\n  ';
                         if (isAutoIncrement(x))
-                            result += e.dbNameOf(x) + ' serial';
+                            result += e.nameOf(x) + ' serial';
                         else {
-                            result += postgresColumnSyntax(x, e.dbNameOf(x));
+                            result += postgresColumnSyntax(x, e.nameOf(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 dbNamesOf(entity);
-        if (isDbReadonly(c(entity), e))
+        let e = await getDbNameProvider(entity);
+        if (e.isDbReadonly(c(entity)))
             return;
         try {
             let cmd = this.pool.createCommand();
-            const colName = e.dbNameOf(c(entity));
+            const colName = e.nameOf(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 dbNamesOf(entity);
+            let e = await getDbNameProvider(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 (!isDbReadonly(col, e))
-                    if (!cols.includes(e.dbNameOf(col).toLocaleLowerCase())) {
-                        let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(col, e.dbNameOf(col))}`;
+                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);
                         await this.pool.execute(sql);
                     }

package/esm/remult-express.js

@@ -1,5 +1,6 @@
 import * as express from 'express';
 import { createRemultServer } from './server/expressBridge';
+import { initAsyncHooks } from './server/initAsyncHooks';
 export function remultExpress(options) {
     let app = express.Router();
     if (!options) {
@@ -12,6 +13,7 @@ export function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
+    initAsyncHooks();
     const server = createRemultServer(options);
     server.registerRouter(app);
     return Object.assign(app, {

package/esm/remult-fastify.js

@@ -1,4 +1,5 @@
 import { createRemultServer } from './server/expressBridge';
+import { initAsyncHooks } from './server/initAsyncHooks';
 export function remultFastify(options) {
     function fastifyHandler(handler) {
         const response = (req, res) => {
@@ -18,6 +19,7 @@ export function remultFastify(options) {
         };
         return response;
     }
+    initAsyncHooks();
     const api = createRemultServer(options);
     const pluginFunction = async (instance, op) => {
         //@ts-ignore

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

@@ -1,19 +1,43 @@
-import type { Knex } from 'knex';
+import { Knex } from 'knex';
+import { Filter, FilterConsumer } from "../src/filter/filter-interfaces";
+import { dbNameProvider } from "../src/filter/filter-consumer-bridge-to-sql-request";
 import { Remult } from "../src/context";
-import { EntityFilter, EntityMetadata, Repository } from "../src/remult3";
+import { EntityFilter, EntityMetadata } 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 function knexCondition<entityType>(repo: Repository<entityType>, condition: EntityFilter<entityType>): Promise<(knex: any) => 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>;

package/esm/remult-knex/index.js

@@ -1,21 +1,15 @@
+import knex from 'knex';
 import { customDatabaseFilterToken, Filter } from "../src/filter/filter-interfaces";
-import { dbNamesOf, isDbReadonly } from "../src/filter/filter-consumer-bridge-to-sql-request";
+import { getDbNameProvider } 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);
     }
@@ -48,7 +42,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) {
@@ -66,11 +60,11 @@ class KnexEntityDataProvider {
             if (x.isServerExpression) {
             }
             else {
-                cols.push(e.dbNameOf(x));
+                cols.push(e.nameOf(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);
@@ -82,7 +76,7 @@ class KnexEntityDataProvider {
         }
         if (options.orderBy) {
             query = query.orderBy(options.orderBy.Segments.map(s => ({
-                column: e.dbNameOf(s.field),
+                column: e.nameOf(s.field),
                 order: s.isDescending ? "desc" : "asc"
             })));
         }
@@ -108,7 +102,7 @@ class KnexEntityDataProvider {
         });
     }
     async init() {
-        return await dbNamesOf(this.entity);
+        return await getDbNameProvider(this.entity);
     }
     async update(id, data) {
         const e = await this.init();
@@ -119,17 +113,17 @@ class KnexEntityDataProvider {
             resultFilter = this.entity.idMetadata.getIdFilter(data.id);
         let updateObject = {};
         for (const x of this.entity.fields) {
-            if (isDbReadonly(x, e)) { }
+            if (e.isDbReadonly(x)) { }
             else if (data[x.key] !== undefined) {
                 let v = x.valueConverter.toDb(data[x.key]);
                 if (v !== undefined) {
-                    let key = await e.dbNameOf(x);
+                    let key = await e.nameOf(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) {
@@ -137,7 +131,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();
@@ -148,16 +142,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 (isDbReadonly(x, e)) { }
+            if (e.isDbReadonly(x)) { }
             else {
                 let v = x.valueConverter.toDb(data[x.key]);
                 if (v != undefined) {
-                    let key = await e.dbNameOf(x);
+                    let key = await e.nameOf(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;
@@ -170,7 +164,7 @@ class KnexEntityDataProvider {
         });
     }
 }
-class FilterConsumerBridgeToKnexRequest {
+export class FilterConsumerBridgeToKnexRequest {
     constructor(nameProvider) {
         this.nameProvider = nameProvider;
         this._addWhere = true;
@@ -214,13 +208,13 @@ class FilterConsumerBridgeToKnexRequest {
         })());
     }
     isNull(col) {
-        this.result.push(b => b.whereNull(this.nameProvider.dbNameOf(col)));
+        this.result.push(b => b.whereNull(this.nameProvider.nameOf(col)));
     }
     isNotNull(col) {
-        this.result.push(b => b.whereNotNull(this.nameProvider.dbNameOf(col)));
+        this.result.push(b => b.whereNotNull(this.nameProvider.nameOf(col)));
     }
     isIn(col, val) {
-        this.result.push(knex => knex.whereIn(this.nameProvider.dbNameOf(col), val.map(x => col.valueConverter.toDb(x))));
+        this.result.push(knex => knex.whereIn(this.nameProvider.nameOf(col), val.map(x => col.valueConverter.toDb(x))));
     }
     isEqualTo(col, val) {
         this.add(col, val, "=");
@@ -241,12 +235,12 @@ class FilterConsumerBridgeToKnexRequest {
         this.add(col, val, "<");
     }
     containsCaseInsensitive(col, val) {
-        this.result.push(b => b.whereRaw('lower (' + this.nameProvider.dbNameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')"));
+        this.result.push(b => b.whereRaw('lower (' + this.nameProvider.nameOf(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, col.valueConverter.toDb(val)));
+        this.result.push(b => b.where(this.nameProvider.nameOf(col), operator, col.valueConverter.toDb(val)));
     }
     databaseCustom(databaseCustom) {
         this.promises.push((async () => {
@@ -256,13 +250,6 @@ 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;
@@ -286,16 +273,16 @@ export class KnexSchemaBuilder {
         }
     }
     async createIfNotExist(entity) {
-        const e = await dbNamesOf(entity);
-        if (!await this.knex.schema.hasTable(e.$entityName)) {
+        const e = await getDbNameProvider(entity);
+        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: isDbReadonly(f, e)
+                    name: e.nameOf(f),
+                    readonly: e.isDbReadonly(f)
                 });
             }
-            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))
@@ -311,22 +298,22 @@ export class KnexSchemaBuilder {
         }
     }
     async addColumnIfNotExist(entity, c) {
-        let e = await dbNamesOf(entity);
-        if (isDbReadonly(c(entity), e))
+        let e = await getDbNameProvider(entity);
+        if (e.isDbReadonly(c(entity)))
             return;
         let col = c(entity);
-        let colName = e.dbNameOf(col);
-        if (!await this.knex.schema.hasColumn(e.$entityName, colName)) {
-            await this.knex.schema.alterTable(e.$entityName, b => {
+        let colName = e.nameOf(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 dbNamesOf(entity);
+        let e = await getDbNameProvider(entity);
         try {
             for (const col of entity.fields) {
-                if (isDbReadonly(col, e)) {
+                if (!e.isDbReadonly(col)) {
                     await this.addColumnIfNotExist(entity, () => col);
                 }
             }
@@ -390,7 +377,7 @@ function logSql(who) {
     return who;
 }
 export async function createKnexDataProvider(config, autoCreateTables = true) {
-    let k = (await import('knex')).default(config);
+    let k = knex(config);
     let result = new KnexDataProvider(k);
     if (autoCreateTables)
         await new KnexSchemaBuilder(k).verifyStructureOfAllEntities(new Remult(result));

package/esm/remult-middleware.d.ts

@@ -0,0 +1,2 @@
+import { RemultMiddlewareOptions } from './server/expressBridge';
+export declare function remultMiddleware(options?: RemultMiddlewareOptions): import("./server/expressBridge").RemultExpressBridge;

package/esm/remult-middleware.js

@@ -0,0 +1,65 @@
+import { remultMiddlewareBase } from './server/expressBridge';
+export function remultMiddleware(options) {
+    const m = new middleware();
+    let app = Object.assign((req, res, next) => m.handleRequest(req, res, next), {
+        route: (path) => m.route(path)
+    });
+    return remultMiddlewareBase(app, options);
+}
+class middleware {
+    constructor() {
+        this.map = new Map();
+    }
+    route(path) {
+        //consider using:
+        //* https://raw.githubusercontent.com/cmorten/opine/main/src/utils/pathToRegex.ts
+        //* https://github.com/pillarjs/path-to-regexp
+        let r = path.toLowerCase();
+        let m = new Map();
+        this.map.set(r, m);
+        const route = {
+            get: (h) => {
+                m.set("get", h);
+                return route;
+            },
+            put: (h) => {
+                m.set("put", h);
+                return route;
+            },
+            post: (h) => {
+                m.set("post", h);
+                return route;
+            },
+            delete: (h) => {
+                m.set("delete", h);
+                return route;
+            }
+        };
+        return route;
+    }
+    handleRequest(req, res, next) {
+        let lowerPath = req.path.toLowerCase();
+        let m = this.map.get(lowerPath);
+        if (m) {
+            let h = m.get(req.method.toLowerCase());
+            if (h) {
+                h(req, res, next);
+                return;
+            }
+        }
+        let idPosition = req.path.lastIndexOf('/');
+        if (idPosition >= 0) {
+            lowerPath = req.path.substring(0, idPosition) + '/:id';
+            m = this.map.get(lowerPath);
+            if (m) {
+                let h = m.get(req.method.toLowerCase());
+                if (h) {
+                    req.params.id = req.path.substring(idPosition + 1);
+                    h(req, res, next);
+                    return;
+                }
+            }
+        }
+        next();
+    }
+}