remult 0.16.3-exp.3 → 0.16.3

package/esm/remult-mongo.d.ts

@@ -1,15 +1,9 @@
-import type { MongoClient, Db } from 'mongodb';
-import { DataProvider, EntityDataProvider, EntityFilter, EntityMetadata, Remult, Repository } from '.';
+import { MongoClient, Db } from 'mongodb';
+import { DataProvider, EntityDataProvider, EntityMetadata } 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,17 +1,10 @@
 import { CompoundIdField, Filter } from '.';
-import { dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
-import { remult as remultContext } from './src/remult-proxy';
+import { getDbNameProvider } from './src/filter/filter-consumer-bridge-to-sql-request';
 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);
     }
@@ -40,7 +33,7 @@ class MongoEntityDataProvider {
     translateFromJson(row, nameProvider) {
         let result = {};
         for (const col of this.entity.fields) {
-            let val = row[nameProvider.dbNameOf(col)];
+            let val = row[nameProvider.nameOf(col)];
             if (isNull(val))
                 val = null;
             result[col.key] = col.valueConverter.fromDb(val);
@@ -53,7 +46,7 @@ class MongoEntityDataProvider {
             let val = col.valueConverter.toDb(row[col.key]);
             if (val === null)
                 val = NULL;
-            result[nameProvider.dbNameOf(col)] = val;
+            result[nameProvider.nameOf(col)] = val;
         }
         return result;
     }
@@ -80,7 +73,7 @@ class MongoEntityDataProvider {
         if (options.orderBy) {
             op.sort = {};
             for (const s of options.orderBy.Segments) {
-                op.sort[e.dbNameOf(s.field)] = s.isDescending ? -1 : 1;
+                op.sort[e.nameOf(s.field)] = s.isDescending ? -1 : 1;
             }
         }
         return await Promise.all(await collection.find(where, op).map(x => this.translateFromJson(x, e)).toArray());
@@ -123,8 +116,8 @@ class MongoEntityDataProvider {
         return await this.translateFromJson(await collection.findOne({ _id: r.insertedId }), e);
     }
     async collection() {
-        const e = await dbNamesOf(this.entity);
-        const collection = this.db.collection(e.$entityName);
+        const e = await getDbNameProvider(this.entity);
+        const collection = this.db.collection(e.entityName);
         return { e, collection };
     }
 }
@@ -178,7 +171,7 @@ class FilterConsumerBridgeToMongo {
     }
     isIn(col, val) {
         this.result.push(() => ({
-            [this.nameProvider.dbNameOf(col)]: {
+            [this.nameProvider.nameOf(col)]: {
                 $in: val.map(x => col.valueConverter.toDb(x))
             }
         }));
@@ -210,7 +203,7 @@ class FilterConsumerBridgeToMongo {
     }
     add(col, val, operator) {
         this.result.push(() => ({
-            [this.nameProvider.dbNameOf(col)]: { [operator]: isNull(val) ? val : col.valueConverter.toDb(val) }
+            [this.nameProvider.nameOf(col)]: { [operator]: isNull(val) ? val : col.valueConverter.toDb(val) }
         }));
     }
     databaseCustom(databaseCustom) {
@@ -226,10 +219,3 @@ 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

@@ -57,6 +57,15 @@ export interface GenericResponse {
     status(statusCode: number): GenericResponse;
     end(): any;
 }
+export declare class RemultAsyncLocalStorage {
+    private readonly remultObjectStorage;
+    static enable(): void;
+    static disable(): void;
+    constructor(remultObjectStorage: import('async_hooks').AsyncLocalStorage<Remult>);
+    run(remult: Remult, callback: VoidFunction): void;
+    getRemult(): Remult;
+    static instance: RemultAsyncLocalStorage;
+}
 export interface queuedJobInfo {
     info: queuedJobInfoResponse;
     userId: string;

package/esm/server/expressBridge.js

@@ -30,30 +30,12 @@ export function createRemultServer(options) {
             return dp;
         return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
     });
-    if (!remultObjectStorage) {
-        dataProvider = dataProvider.then(async (dp) => {
-            try {
-                const asyncHooks = await import('async_hooks');
-                remultObjectStorage = new RemultAsyncLocalStorage(new asyncHooks.AsyncLocalStorage());
-            }
-            catch {
-                remultObjectStorage = new RemultAsyncLocalStorage(undefined);
-            }
-            remult.remultFactory = () => {
-                const r = remultObjectStorage.getRemult();
-                if (r)
-                    return r;
-                else
-                    throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
-            };
-            return dp;
-        });
-    }
+    RemultAsyncLocalStorage.enable();
     if (options.initApi) {
         dataProvider = dataProvider.then(async (dp) => {
             var remult = new Remult(dp);
             await new Promise((res) => {
-                remultObjectStorage.run(remult, async () => {
+                RemultAsyncLocalStorage.instance.run(remult, async () => {
                     await options.initApi(remult);
                     res({});
                 });
@@ -78,10 +60,22 @@ export function createRemultServer(options) {
     return bridge;
 }
 ;
-class RemultAsyncLocalStorage {
+export class RemultAsyncLocalStorage {
     constructor(remultObjectStorage) {
         this.remultObjectStorage = remultObjectStorage;
     }
+    static enable() {
+        remult.remultFactory = () => {
+            const r = RemultAsyncLocalStorage.instance.getRemult();
+            if (r)
+                return r;
+            else
+                throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
+        };
+    }
+    static disable() {
+        remult.resetFactory();
+    }
     run(remult, callback) {
         if (this.remultObjectStorage)
             this.remultObjectStorage.run(remult, callback);
@@ -90,12 +84,12 @@ class RemultAsyncLocalStorage {
     }
     getRemult() {
         if (!this.remultObjectStorage) {
-            throw "can't use static remult in this environment, `async_hooks` were not found";
+            throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
         }
         return this.remultObjectStorage.getStore();
     }
 }
-let remultObjectStorage;
+RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
 class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;
@@ -182,7 +176,7 @@ class RemultServerImplementation {
             let remult = new Remult();
             remult.dataProvider = (await this.dataProvider);
             await new Promise(res => {
-                remultObjectStorage.run(remult, async () => {
+                RemultAsyncLocalStorage.instance.run(remult, async () => {
                     if (req) {
                         let user;
                         if (this.options.getUser)

package/esm/server/initAsyncHooks.d.ts

@@ -0,0 +1 @@
+export declare function initAsyncHooks(): void;

package/esm/server/initAsyncHooks.js

@@ -0,0 +1,9 @@
+import { AsyncLocalStorage } from 'async_hooks';
+import { RemultAsyncLocalStorage } from './expressBridge';
+let init = false;
+export function initAsyncHooks() {
+    if (init)
+        return;
+    init = true;
+    RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(new AsyncLocalStorage());
+}

package/esm/server/register-actions-on-server.d.ts

@@ -0,0 +1,3 @@
+import { SiteArea } from "./expressBridge";
+import { ClassType } from "../classType";
+export declare function registerActionsOnServer(area: SiteArea, controllers?: ClassType<any>[]): void;

package/esm/server/register-actions-on-server.js

@@ -0,0 +1,24 @@
+import { serverActionField, actionInfo, classBackendMethodsArray } from '../src/server-action';
+export function registerActionsOnServer(area, controllers) {
+    var addAction = (a) => {
+        let x = a[serverActionField];
+        if (!x) {
+            throw 'failed to set server action, did you forget the BackendMethod Decorator?';
+        }
+        area.addAction(x);
+    };
+    actionInfo.runningOnServer = true;
+    if (controllers && controllers.length > 0) {
+        for (const c of controllers) {
+            let z = c[classBackendMethodsArray];
+            if (z)
+                for (const a of z) {
+                    addAction(a);
+                }
+        }
+    }
+    else
+        actionInfo.allActions.forEach((a) => {
+            addAction(a);
+        });
+}

package/esm/server/register-entities-on-server.d.ts

@@ -0,0 +1,3 @@
+import { SiteArea } from "./expressBridge";
+import { ClassType } from "../classType";
+export declare function registerEntitiesOnServer(area: SiteArea, entities?: ClassType<any>[]): void;

package/esm/server/register-entities-on-server.js

@@ -0,0 +1,15 @@
+import { getEntityKey } from "../src/remult3";
+import { allEntities } from "../src/context";
+import { DataApi } from "../src/data-api";
+export function registerEntitiesOnServer(area, entities) {
+    if (!entities)
+        entities = allEntities;
+    //add Api Entries
+    entities.forEach(e => {
+        let key = getEntityKey(e);
+        if (key != undefined)
+            area.add(key, c => {
+                return new DataApi(c.repo(e), c);
+            });
+    });
+}

package/esm/src/backend-tests/my-test.backend-spec.js

@@ -1,12 +1,12 @@
 import { Remult } from "../context";
-import { knexCondition, KnexDataProvider } from '../../remult-knex';
+import { KnexDataProvider } from '../../remult-knex';
 import { config } from 'dotenv';
-import { testKnexPGSqlImpl, testMongo, testPostgresImplementation } from "./backend-database-test-setup.backend-spec";
+import { testKnexPGSqlImpl, testPostgresImplementation } from "./backend-database-test-setup.backend-spec";
 import { entityWithValidations } from "../shared-tests/entityWithValidations";
-import { PostgresDataProvider } from "../../postgres";
-import { MongoDataProvider, mongoCondition } from "../../remult-mongo";
 import { SqlDatabase } from "../data-providers/sql-database";
-import { dbNamesOf } from "../filter/filter-consumer-bridge-to-sql-request";
+import { RemultAsyncLocalStorage } from "../../server/expressBridge";
+import { initAsyncHooks } from "../../server/initAsyncHooks";
+import { remult } from "../remult-proxy";
 config();
 testPostgresImplementation("default order by", async ({ createEntity }) => {
     let s = await entityWithValidations.create4RowsInDp(createEntity);
@@ -61,63 +61,47 @@ testKnexPGSqlImpl("knex filter2", async ({ createEntity }) => {
         }
     })).length).toBe(3);
 }, false);
-testPostgresImplementation("work with native sql", async ({ remult, createEntity }) => {
-    const repo = await entityWithValidations.create4RowsInDp(createEntity);
-    const sql = SqlDatabase.getDb(remult);
-    const r = await sql.execute("select count(*) as c from " + repo.metadata.options.dbName);
-    expect(r.rows[0].c).toBe('4');
-}, false);
-testPostgresImplementation("work with native sql2", async ({ remult, createEntity }) => {
-    const repo = await entityWithValidations.create4RowsInDp(createEntity);
-    const sql = PostgresDataProvider.getDb(remult);
-    const r = await sql.query("select count(*) as c from " + repo.metadata.options.dbName);
-    expect(r.rows[0].c).toBe('4');
-}, false);
-testPostgresImplementation("work with native sql3", async ({ remult, createEntity }) => {
-    const repo = await entityWithValidations.create4RowsInDp(createEntity);
-    await SqlDatabase.getDb(remult)._getSourceSql().transaction(async (x) => {
-        const sql = PostgresDataProvider.getDb(new Remult(new SqlDatabase(x)));
-        const r = await sql.query("select count(*) as c from " + repo.metadata.options.dbName);
-        expect(r.rows[0].c).toBe('4');
-    });
-}, false);
-testKnexPGSqlImpl("work with native knex", async ({ remult, createEntity }) => {
-    const repo = await entityWithValidations.create4RowsInDp(createEntity);
-    const knex = KnexDataProvider.getDb(remult);
-    const r = await knex(repo.metadata.options.dbName).count();
-    expect(r[0].count).toBe('4');
-}, false);
-testKnexPGSqlImpl("work with native knex2", async ({ remult, createEntity }) => {
-    const repo = await entityWithValidations.create4RowsInDp(createEntity);
-    await (remult.dataProvider).transaction(async (db) => {
-        const sql = KnexDataProvider.getDb(new Remult(db));
-        const r = await sql(repo.metadata.options.dbName).count();
-        expect(r[0].count).toBe('4');
+it("test async hooks and static remult", async () => {
+    let gotException = true;
+    try {
+        RemultAsyncLocalStorage.instance.getRemult();
+        gotException = false;
+    }
+    catch { }
+    expect(gotException).toBe(true);
+    initAsyncHooks();
+    expect(RemultAsyncLocalStorage.instance.getRemult()).toBe(undefined);
+    RemultAsyncLocalStorage.enable();
+    try {
+        remult.isAllowed(false);
+        gotException = false;
+    }
+    catch { }
+    expect(gotException).toBe(true);
+    const promises = [];
+    RemultAsyncLocalStorage.instance.run(new Remult(), () => {
+        remult.user = { id: 'noam' };
+        promises.push(new Promise(res => {
+            setTimeout(() => {
+                expect(remult.user.id).toBe('noam');
+                res({});
+            }, 10);
+        }));
+        RemultAsyncLocalStorage.instance.run(new Remult(), () => {
+            remult.user = { id: 'yoni' };
+            promises.push(new Promise(res => {
+                setTimeout(() => {
+                    expect(remult.user.id).toBe('yoni');
+                    res({});
+                }, 10);
+            }));
+        });
+        promises.push(new Promise(res => {
+            setTimeout(() => {
+                expect(remult.user.id).toBe('noam');
+                res({});
+            }, 10);
+        }));
     });
-}, false);
-testKnexPGSqlImpl("work with native knex3", async ({ remult, createEntity }) => {
-    const repo = await entityWithValidations.create4RowsInDp(createEntity);
-    const knex = KnexDataProvider.getDb(remult);
-    const t = await dbNamesOf(repo);
-    const r = await knex((await t).$entityName).select(t.myId, t.name);
-    expect(r.length).toBe(4);
-}, false);
-testMongo("work with native mongo", async ({ remult, createEntity }) => {
-    const repo = await entityWithValidations.create4RowsInDp(createEntity);
-    const mongo = MongoDataProvider.getDb(remult);
-    const r = await (await mongo.collection(repo.metadata.options.dbName)).countDocuments();
-    expect(r).toBe(4);
-}, false);
-testKnexPGSqlImpl("knex with filter", async ({ remult, createEntity }) => {
-    const repo = await entityWithValidations.create4RowsInDp(createEntity);
-    const knex = KnexDataProvider.getDb(remult);
-    const e = await dbNamesOf(repo);
-    const r = await knex(e.$entityName).count().where(await knexCondition(repo, { myId: [1, 3] }));
-    expect(r[0].count).toBe('2');
-}, false);
-testMongo("work with native mongo and condition", async ({ remult, createEntity }) => {
-    const repo = await entityWithValidations.create4RowsInDp(createEntity);
-    const mongo = MongoDataProvider.getDb(remult);
-    const r = await (await mongo.collection(repo.metadata.options.dbName)).countDocuments(await mongoCondition(repo, { myId: [1, 2] }));
-    expect(r).toBe(2);
-}, false);
+    await Promise.all(promises);
+});

package/esm/src/data-providers/sql-database.d.ts

@@ -2,10 +2,8 @@ import { EntityDataProvider, DataProvider } from "../data-interfaces";
 import { SqlCommand, SqlImplementation, SqlResult } from "../sql-command";
 import { CustomSqlFilterBuilderFunction } from "../filter/filter-consumer-bridge-to-sql-request";
 import { EntityMetadata, EntityFilter } from "../remult3";
-import { Remult } from "../context";
 export declare class SqlDatabase implements DataProvider {
     private sql;
-    static getDb(remult?: Remult): SqlDatabase;
     createCommand(): SqlCommand;
     execute(sql: string): Promise<SqlResult>;
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;

package/esm/src/data-providers/sql-database.js

@@ -1,34 +1,23 @@
 import { CompoundIdField } from "../column";
-import { dbNamesOf, FilterConsumerBridgeToSqlRequest, isDbReadonly } from "../filter/filter-consumer-bridge-to-sql-request";
+import { FilterConsumerBridgeToSqlRequest, getDbNameProvider } from "../filter/filter-consumer-bridge-to-sql-request";
 import { customDatabaseFilterToken, Filter } from '../filter/filter-interfaces';
 import { Sort } from '../sort';
-import { RepositoryImplementation } from "../remult3";
 // @dynamic
 export class SqlDatabase {
     constructor(sql) {
         this.sql = sql;
         this.createdEntities = [];
     }
-    static getDb(remult) {
-        const r = (remult || RepositoryImplementation.defaultRemult).dataProvider;
-        if (!r.createCommand)
-            throw "the data provider is not an SqlDatabase";
-        return r;
-    }
     createCommand() {
         return new LogSQLCommand(this.sql.createCommand(), SqlDatabase.LogToConsole);
     }
     async execute(sql) {
         return await this.createCommand().execute(sql);
     }
-    /* @internal*/
-    _getSourceSql() {
-        return this.sql;
-    }
     getEntityDataProvider(entity) {
         return new ActualSQLServerDataProvider(entity, this, async (dbName) => {
-            if (this.createdEntities.indexOf(dbName.$entityName) < 0) {
-                this.createdEntities.push(dbName.$entityName);
+            if (this.createdEntities.indexOf(dbName.entityName) < 0) {
+                this.createdEntities.push(dbName.entityName);
                 await this.sql.entityIsUsedForTheFirstTime(entity);
             }
         }, this.sql);
@@ -106,13 +95,13 @@ class ActualSQLServerDataProvider {
         this.strategy = strategy;
     }
     async init() {
-        let dbNameProvider = await dbNamesOf(this.entity);
+        let dbNameProvider = await getDbNameProvider(this.entity);
         await this.iAmUsed(dbNameProvider);
         return dbNameProvider;
     }
     async count(where) {
         let e = await this.init();
-        let select = 'select count(*) count from ' + e.$entityName;
+        let select = 'select count(*) count from ' + e.entityName;
         let r = this.sql.createCommand();
         if (where) {
             let wc = new FilterConsumerBridgeToSqlRequest(r, e);
@@ -127,7 +116,7 @@ class ActualSQLServerDataProvider {
         let e = await this.init();
         let { colKeys, select } = this.buildSelect(e);
         select = 'select ' + select;
-        select += '\n from ' + e.$entityName;
+        select += '\n from ' + e.entityName;
         let r = this.sql.createCommand();
         if (options) {
             if (options.where) {
@@ -158,7 +147,7 @@ class ActualSQLServerDataProvider {
                     }
                     else
                         select += ', ';
-                    select += e.dbNameOf(c.field);
+                    select += e.nameOf(c.field);
                     if (c.isDescending)
                         select += ' desc';
                 }
@@ -200,7 +189,7 @@ class ActualSQLServerDataProvider {
             else {
                 if (colKeys.length > 0)
                     select += ', ';
-                select += e.dbNameOf(x);
+                select += e.nameOf(x);
                 colKeys.push(x);
             }
         }
@@ -211,12 +200,12 @@ class ActualSQLServerDataProvider {
         let r = this.sql.createCommand();
         let f = new FilterConsumerBridgeToSqlRequest(r, e);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        let statement = 'update ' + e.$entityName + ' set ';
+        let statement = 'update ' + e.entityName + ' set ';
         let added = false;
         for (const x of this.entity.fields) {
             if (x instanceof CompoundIdField) {
             }
-            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) {
@@ -224,7 +213,7 @@ class ActualSQLServerDataProvider {
                         added = true;
                     else
                         statement += ', ';
-                    statement += e.dbNameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
+                    statement += e.nameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
                 }
             }
         }
@@ -240,7 +229,7 @@ class ActualSQLServerDataProvider {
         let r = this.sql.createCommand();
         let f = new FilterConsumerBridgeToSqlRequest(r, e);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        let statement = 'delete from ' + e.$entityName;
+        let statement = 'delete from ' + e.entityName;
         statement += await f.resolveWhere();
         return r.execute(statement).then(() => { });
     }
@@ -251,7 +240,7 @@ class ActualSQLServerDataProvider {
         let vals = '';
         let added = false;
         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) {
@@ -261,12 +250,12 @@ class ActualSQLServerDataProvider {
                         cols += ', ';
                         vals += ', ';
                     }
-                    cols += e.dbNameOf(x);
+                    cols += e.nameOf(x);
                     vals += r.addParameterAndReturnSqlToken(v);
                 }
             }
         }
-        let statement = `insert into ${e.$entityName} (${cols}) values (${vals})`;
+        let statement = `insert into ${e.entityName} (${cols}) values (${vals})`;
         let { colKeys, select } = this.buildSelect(e);
         statement += ' returning ' + select;
         return await r.execute(statement).then(sql => this.buildResultRow(colKeys, sql.rows[0], sql));

package/esm/src/data-providers/web-sql-data-provider.d.ts

@@ -1,15 +1,12 @@
-/// <reference types="websql" />
 import { __RowsOfDataForTesting } from "../__RowsOfDataForTesting";
 import { SqlCommand, SqlImplementation } from "../sql-command";
 import { EntityMetadata } from "../remult3";
-import { Remult } from "../context";
 export declare class WebSqlDataProvider implements SqlImplementation, __RowsOfDataForTesting {
     private databaseName;
     rows: {
         [tableName: string]: any;
     };
     constructor(databaseName: string, databaseSize?: number);
-    static getDb(remult?: Remult): Database;
     getLimitSqlSyntax(limit: number, offset: number): string;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     dropTable(entity: EntityMetadata): Promise<void>;

package/esm/src/data-providers/web-sql-data-provider.js

@@ -1,6 +1,6 @@
 import { isAutoIncrement } from "../remult3";
 import { SqlDatabase } from "./sql-database";
-import { dbNamesOf, isDbReadonly } from "../filter/filter-consumer-bridge-to-sql-request";
+import { getDbNameProvider } from "../filter/filter-consumer-bridge-to-sql-request";
 //SqlDatabase.LogToConsole = true;
 export class WebSqlDataProvider {
     constructor(databaseName, databaseSize = 2 * 1024 * 1024) {
@@ -8,14 +8,6 @@ export class WebSqlDataProvider {
         //@ts-ignore
         this.db = window.openDatabase(databaseName, '1.0', databaseName, databaseSize);
     }
-    static getDb(remult) {
-        const sql = SqlDatabase.getDb(remult);
-        const me = sql._getSourceSql();
-        if (!me.db) {
-            throw "the data provider is not a WebSqlDataProvider";
-        }
-        return me.db;
-    }
     getLimitSqlSyntax(limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     }
@@ -23,34 +15,34 @@ export class WebSqlDataProvider {
         await this.createTable(entity);
     }
     async dropTable(entity) {
-        let e = await dbNamesOf(entity);
-        let sql = 'drop  table if exists ' + e.$entityName;
+        let e = await getDbNameProvider(entity);
+        let sql = 'drop  table if exists ' + e.entityName;
         if (SqlDatabase.LogToConsole)
             console.log(sql);
         await this.createCommand().execute(sql);
     }
     async createTable(entity) {
         let result = '';
-        let e = await dbNamesOf(entity);
+        let e = await getDbNameProvider(entity);
         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)) {
                     if (x.key != entity.idMetadata.field.key)
                         throw "in web sql, autoincrement is only allowed for primary key";
-                    result += e.dbNameOf(x) + ' integer primary key autoincrement';
+                    result += e.nameOf(x) + ' integer primary key autoincrement';
                 }
                 else {
-                    result += this.addColumnSqlSyntax(x, e.dbNameOf(x));
+                    result += this.addColumnSqlSyntax(x, e.nameOf(x));
                     if (x.key == entity.idMetadata.field.key) {
                         result += ' primary key';
                     }
                 }
             }
         }
-        let sql = 'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
+        let sql = 'create table if not exists ' + e.entityName + ' (' + result + '\r\n)';
         if (SqlDatabase.LogToConsole)
             console.log(sql);
         await this.createCommand().execute(sql);