remult 0.15.4 → 0.16.0-exp.10

package/esm/index.d.ts

@@ -8,10 +8,11 @@ export { RestDataProvider } from './src/data-providers/rest-data-provider';
 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 { SqlDatabase, } from './src/data-providers/sql-database';
+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, isBackend, AllowedForInstance, EventDispatcher, EventSource, HttpProvider, Unobserve, UserInfo } from './src/context';
+export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, ExternalHttpProvider, Unobserve, UserInfo } from './src/context';
 export { IdEntity } from './src/id-entity';
 export { SortSegment, Sort } from './src/sort';
 export { OneToMany, CompoundIdField } from './src/column';
@@ -20,3 +21,4 @@ export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-b
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';
+export { remult } from './src/remult-proxy';

package/esm/index.js

@@ -6,7 +6,8 @@ export { RestDataProvider } from './src/data-providers/rest-data-provider'; //V
 export { InMemoryDataProvider } from './src/data-providers/in-memory-database'; //V
 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 { SqlDatabase, } from './src/data-providers/sql-database'; //V
+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';
@@ -19,3 +20,4 @@ export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-b
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';
+export { remult } from './src/remult-proxy';

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

@@ -81,14 +81,14 @@ export async function createPostgresConnection(options) {
     }
     const db = new SqlDatabase(new PostgresDataProvider(new Pool(config)));
     let remult = new Remult();
-    remult.setDataProvider(db);
+    remult.dataProvider = (db);
     if (options.autoCreateTables === undefined || options.autoCreateTables)
         await verifyStructureOfAllEntities(db, remult);
     return db;
 }
 export async function preparePostgresQueueStorage(sql) {
     let c = new Remult();
-    c.setDataProvider(sql);
+    c.dataProvider = (sql);
     let JobsInQueueEntity = (await import('../server/expressBridge')).JobsInQueueEntity;
     let e = c.repo(JobsInQueueEntity);
     await new PostgresSchemaBuilder(sql).createIfNotExist(e.metadata);

package/esm/remult-express.js

@@ -17,6 +17,7 @@ export function remultExpress(options) {
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
-        registerRouter: x => server.registerRouter(x)
+        registerRouter: x => server.registerRouter(x),
+        withRemultMiddleware: (...args) => server.withRemultMiddleware(...args)
     });
 }

package/esm/server/expressBridge.d.ts

@@ -33,6 +33,7 @@ export interface RemultServer {
     }): any;
     registerRouter(r: GenericRouter): void;
     handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
+    withRemultMiddleware(req: GenericRequest, res: GenericResponse, next: VoidFunction): any;
 }
 export declare type GenericRouter = {
     route(path: string): SpecificRoute;

package/esm/server/expressBridge.js

@@ -4,6 +4,8 @@ import { DataApi, serializeError } from '../src/data-api';
 import { allEntities, Remult } from '../src/context';
 import { Entity, Fields, getEntityKey } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
+import { AsyncLocalStorage } from 'async_hooks';
+import { remult } from '../src/remult-proxy';
 ;
 export function createRemultServer(options) {
     if (!options) {
@@ -32,7 +34,12 @@ export function createRemultServer(options) {
     if (options.initApi) {
         dataProvider = dataProvider.then(async (dp) => {
             var remult = new Remult(dp);
-            await options.initApi(remult);
+            await new Promise((res) => {
+                remultObjectStorage.run(remult, async () => {
+                    await options.initApi(remult);
+                    res({});
+                });
+            });
             return dp;
         });
     }
@@ -47,12 +54,14 @@ export function createRemultServer(options) {
         options.controllers = allControllers;
     }
     if (options.rootPath === undefined)
-        options.rootPath = Remult.apiBaseUrl;
+        options.rootPath = '/api';
     actionInfo.runningOnServer = true;
     let bridge = new RemultServerImplementation(new inProcessQueueHandler(options.queueStorage), options, dataProvider);
     return bridge;
 }
 ;
+const remultObjectStorage = new AsyncLocalStorage();
+let remultObjectStorageWasSetup = false;
 class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;
@@ -62,6 +71,19 @@ class RemultServerImplementation {
         this.hasQueue = false;
         /* internal */
         this.backendMethodsOpenApi = [];
+        if (!remultObjectStorageWasSetup) {
+            remultObjectStorageWasSetup = true;
+            remult.remultFactory = () => {
+                const r = remultObjectStorage.getStore();
+                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");
+            };
+        }
+    }
+    withRemultMiddleware(req, res, next) {
+        this.process(async () => { next(); })(req, res);
     }
     handle(req, gRes) {
         if (!this.routeImpl) {
@@ -101,7 +123,8 @@ class RemultServerImplementation {
                             else
                                 res.success(job.info);
                         });
-                    }
+                    },
+                    doWork: undefined
                 }, r);
         }
         this.options.entities.forEach(e => {
@@ -133,23 +156,28 @@ class RemultServerImplementation {
             let myReq = new ExpressRequestBridgeToDataApiRequest(req);
             let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
             let remult = new Remult();
-            remult.setDataProvider(await this.dataProvider);
-            if (req) {
-                let user;
-                if (this.options.getUser)
-                    user = await this.options.getUser(req);
-                else {
-                    user = req['user'];
-                    if (!user)
-                        user = req['auth'];
-                }
-                if (user)
-                    remult.setUser(user);
-            }
-            if (this.options.initRequest) {
-                await this.options.initRequest(remult, req);
-            }
-            what(remult, myReq, myRes, req);
+            remult.dataProvider = (await this.dataProvider);
+            await new Promise(res => {
+                remultObjectStorage.run(remult, async () => {
+                    if (req) {
+                        let user;
+                        if (this.options.getUser)
+                            user = await this.options.getUser(req);
+                        else {
+                            user = req['user'];
+                            if (!user)
+                                user = req['auth'];
+                        }
+                        if (user)
+                            remult.user = (user);
+                    }
+                    if (this.options.initRequest) {
+                        await this.options.initRequest(remult, req);
+                    }
+                    await what(remult, myReq, myRes, req);
+                    res({});
+                });
+            });
         };
     }
     ;

package/esm/src/backend-tests/test-http-server.backend-spec.js

@@ -1,13 +1,14 @@
 import { __decorate, __metadata } from "tslib";
 import axios from 'axios';
 import { remultFresh } from '../../remult-fresh';
-import { HttpProviderBridgeToRestDataProviderHttpProvider, Remult } from '../context';
+import { Remult } from '../context';
 import { InMemoryDataProvider } from '../data-providers/in-memory-database';
+import { remult } from '../remult-proxy';
 import { Entity, Fields } from '../remult3';
-import { Action, BackendMethod } from '../server-action';
+import { BackendMethod } from '../server-action';
 import { Categories } from '../tests/remult-3-entities';
-Remult.apiBaseUrl = 'http://localhost:3003/api';
-let path = Remult.apiBaseUrl + '/tasks';
+remult.apiClient.url = 'http://localhost:3003/api';
+let path = remult.apiClient.url + '/tasks';
 const environments = [
 // ["next", 3000],
 // ["nest", 3001],
@@ -21,8 +22,8 @@ const environments = [
 function test(name, test) {
     for (const [env, port] of environments) {
         const theTest = async () => {
-            Remult.apiBaseUrl = `http://localhost:${port}/api`;
-            path = Remult.apiBaseUrl + '/tasks';
+            remult.apiClient.url = `http://localhost:${port}/api`;
+            path = remult.apiClient.url + '/tasks';
             await test();
         };
         const testName = env + ` ${port}: ${name}`;
@@ -93,7 +94,7 @@ test("test http 201", async () => {
 });
 test("test regular api call", async () => {
     await create3Tasks();
-    let result = await axios.get(Remult.apiBaseUrl + "/test");
+    let result = await axios.get(remult.apiClient.url + "/test");
     expect(result.data.result).toBe(3);
 });
 class FreshResponseTest {
@@ -106,9 +107,11 @@ class FreshResponseTest {
     }
 }
 it("test fresh", async () => {
-    const api = remultFresh({ entities: [Categories],
+    const api = remultFresh({
+        entities: [Categories],
         dataProvider: new InMemoryDataProvider(),
-        rootPath: '/api' }, FreshResponseTest);
+        rootPath: '/api'
+    }, FreshResponseTest);
     const r = await api.handle({
         url: '/api/Categories',
         json() {
@@ -158,7 +161,7 @@ Task = __decorate([
 export { Task };
 async function create3Tasks() {
     const remult = new Remult(axios);
-    Action.provider = new HttpProviderBridgeToRestDataProviderHttpProvider(axios);
+    remult.apiClient.httpClient = axios;
     const taskRepo = remult.repo(Task);
     for (const task of await taskRepo.find()) {
         await taskRepo.delete(task);

package/esm/src/context.d.ts

@@ -1,7 +1,8 @@
 import { DataProvider, RestDataProviderHttpProvider } from "./data-interfaces";
+import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
-export interface HttpProvider {
+export interface ExternalHttpProvider {
     post(url: string, data: any): Promise<any> | {
         toPromise(): Promise<any>;
     };
@@ -17,7 +18,7 @@ export interface HttpProvider {
 }
 export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements RestDataProviderHttpProvider {
     private http;
-    constructor(http: HttpProvider);
+    constructor(http: ExternalHttpProvider);
     post(url: string, data: any): Promise<any>;
     delete(url: string): Promise<void>;
     put(url: string, data: any): Promise<any>;
@@ -37,12 +38,7 @@ export declare class Remult {
      *
      */
     repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
-    /** Returns the current user's info */
-    get user(): UserInfo;
-    /** Set's the current user info */
-    setUser(info: UserInfo | undefined): Promise<void>;
-    private _user;
-    private _userChangeEvent;
+    user?: UserInfo;
     /** Checks if a user was authenticated */
     authenticated(): boolean;
     /** checks if the user has any of the roles specified in the parameters
@@ -57,30 +53,31 @@ export declare class Remult {
      * [Allowed](https://remult.dev/docs/allowed.html)
      */
     isAllowedForInstance(instance: any, allowed?: AllowedForInstance<any>): boolean;
-    /** returns a dispatcher object that fires once a user has changed*/
-    get userChange(): EventDispatcher;
-    private repCache;
     /** Creates a new instance of the `remult` object.
      *
      * Can receive either an HttpProvider or a DataProvider as a parameter - which will be used to fetch data from.
      *
      * If no provider is specified, `fetch` will be used as an http provider
      */
-    constructor(provider?: HttpProvider | DataProvider | typeof fetch);
-    /** The api Base Url to be used in all remult calls. by default it's set to `/api`.
-     *
-     * Set this property in case you want to determine a non relative api url
-     */
-    static apiBaseUrl: string;
+    constructor(http: ExternalHttpProvider | typeof fetch | ApiClient);
+    constructor(p: DataProvider);
+    constructor();
+    call<T extends ((...args: any[]) => Promise<Y>), Y>(backendMethod: T, self?: any): T;
     /** The current data provider */
-    _dataSource: DataProvider;
-    /** sets the current data provider */
-    setDataProvider(dataProvider: DataProvider): void;
+    dataProvider: DataProvider;
     /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
     static onFind: (metadata: EntityMetadata, options: FindOptions<any>) => void;
     clearAllCache(): any;
     /** A helper callback that is called whenever an entity is created. */
     static entityRefInit?: (ref: EntityRef<any>, row: any) => void;
+    readonly context: RemultContext;
+    apiClient: ApiClient;
+}
+export interface RemultContext {
+}
+export interface ApiClient {
+    httpClient?: ExternalHttpProvider | typeof fetch;
+    url?: string;
 }
 export declare const allEntities: ClassType<any>[];
 export interface ControllerOptions {
@@ -93,6 +90,7 @@ export declare class ClassHelper {
 export declare class MethodHelper {
     classes: Map<any, ControllerOptions>;
 }
+export declare function buildRestDataProvider(provider: ExternalHttpProvider | typeof fetch): RestDataProviderHttpProvider | RestDataProviderHttpProviderUsingFetch;
 export declare function setControllerSettings(target: any, options: ControllerOptions): void;
 export interface UserInfo {
     id: string;

package/esm/src/context.js

@@ -1,4 +1,4 @@
-import { Action, actionInfo } from './server-action';
+import { actionInfo, serverActionField } from './server-action';
 import { RestDataProvider, RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
 export class HttpProviderBridgeToRestDataProviderHttpProvider {
@@ -75,6 +75,8 @@ export async function processHttpException(ex) {
             message: error,
         };
     }
+    if (z.modelState)
+        error.modelState = z.modelState;
     let httpStatusCode = z.status;
     if (httpStatusCode === undefined)
         httpStatusCode = z.response?.status;
@@ -90,37 +92,31 @@ export function isBackend() {
     return actionInfo.runningOnServer;
 }
 export class Remult {
-    /** Creates a new instance of the `remult` object.
-     *
-     * Can receive either an HttpProvider or a DataProvider as a parameter - which will be used to fetch data from.
-     *
-     * If no provider is specified, `fetch` will be used as an http provider
-     */
     constructor(provider) {
-        this._userChangeEvent = new EventSource();
+        /* @internal */
         this.repCache = new Map();
+        /** The current data provider */
+        this.dataProvider = new RestDataProvider(() => this.apiClient);
+        this.context = {};
+        this.apiClient = {
+            url: '/api'
+        };
         if (provider && provider.getEntityDataProvider) {
-            this._dataSource = provider;
+            this.dataProvider = provider;
             return;
         }
-        let dataProvider;
-        if (!dataProvider) {
-            let http = provider;
-            if (http && http.get && http.put && http.post && http.delete) {
-                dataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(http);
-            }
-        }
-        if (!dataProvider) {
-            if (typeof provider === "function") {
-                dataProvider = new RestDataProviderHttpProviderUsingFetch(provider);
-            }
+        if (isExternalHttpProvider(provider)) {
+            this.apiClient.httpClient = provider;
         }
-        if (!dataProvider) {
-            dataProvider = new RestDataProviderHttpProviderUsingFetch();
+        else if (typeof (provider) === "function")
+            this.apiClient.httpClient = provider;
+        else if (provider) {
+            const apiClient = provider;
+            if (apiClient.httpClient)
+                this.apiClient.httpClient = apiClient.httpClient;
+            if (apiClient.url)
+                this.apiClient.url = apiClient.url;
         }
-        this._dataSource = new RestDataProvider(Remult.apiBaseUrl, dataProvider);
-        if (!Action.provider)
-            Action.provider = dataProvider;
     }
     /**Return's a `Repository` of the specific entity type
      * @example
@@ -130,7 +126,7 @@ export class Remult {
      */
     repo(entity, dataProvider) {
         if (dataProvider === undefined)
-            dataProvider = this._dataSource;
+            dataProvider = this.dataProvider;
         let dpCache = this.repCache.get(dataProvider);
         if (!dpCache)
             this.repCache.set(dataProvider, dpCache = new Map());
@@ -140,39 +136,10 @@ export class Remult {
         }
         return r;
     }
-    /** Returns the current user's info */
-    get user() {
-        if (this._user === undefined) {
-            return {
-                id: undefined,
-                name: '',
-                roles: []
-            };
-        }
-        return this._user;
-    }
-    /** Set's the current user info */
-    async setUser(info) {
-        this._user = info;
-        if (this._user === null)
-            this._user = undefined;
-        let auth = info;
-        if (auth) {
-            if (!this._user.id && auth.sub)
-                this._user.id = auth.sub;
-            if (!this._user.roles && auth.permissions) {
-                this._user.roles = auth.permissions;
-            }
-            if (!this._user.name)
-                this._user.name = auth.username;
-        }
-        if (this._user && !this._user.roles)
-            this._user.roles = [];
-        await this._userChangeEvent.fire();
-    }
+    /*  delete me */
     /** Checks if a user was authenticated */
     authenticated() {
-        return this.user.id !== undefined;
+        return this.user?.id !== undefined;
     }
     /** checks if the user has any of the roles specified in the parameters
      * @example
@@ -197,7 +164,7 @@ export class Remult {
         if (typeof roles === 'boolean')
             return roles;
         if (typeof roles === 'string')
-            if (this.user.roles.indexOf(roles.toString()) >= 0)
+            if (this.user?.roles?.indexOf(roles.toString()) >= 0)
                 return true;
         return false;
     }
@@ -220,25 +187,22 @@ export class Remult {
         else
             return this.isAllowed(allowed);
     }
-    /** returns a dispatcher object that fires once a user has changed*/
-    get userChange() {
-        return this._userChangeEvent.dispatcher;
-    }
-    /** sets the current data provider */
-    setDataProvider(dataProvider) {
-        this._dataSource = dataProvider;
+    call(backendMethod, self) {
+        const z = (backendMethod[serverActionField]);
+        if (!z.doWork)
+            throw Error("The method received is not a valid backend method");
+        //@ts-ignore
+        return (...args) => {
+            return z.doWork(args, self, this.apiClient.url, buildRestDataProvider(this.apiClient.httpClient));
+        };
     }
     clearAllCache() {
         this.repCache.clear();
     }
 }
-/** The api Base Url to be used in all remult calls. by default it's set to `/api`.
- *
- * Set this property in case you want to determine a non relative api url
- */
-Remult.apiBaseUrl = '/api';
 /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
 Remult.onFind = (metadata, options) => { };
+;
 export const allEntities = [];
 export const classHelpers = new Map();
 export class ClassHelper {
@@ -251,6 +215,28 @@ export class MethodHelper {
         this.classes = new Map();
     }
 }
+function isExternalHttpProvider(item) {
+    let http = item;
+    if (http && http.get && http.put && http.post && http.delete)
+        return true;
+    return false;
+}
+export function buildRestDataProvider(provider) {
+    if (!provider)
+        return new RestDataProviderHttpProviderUsingFetch();
+    let httpDataProvider;
+    if (!httpDataProvider) {
+        if (isExternalHttpProvider(provider)) {
+            httpDataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(provider);
+        }
+    }
+    if (!httpDataProvider) {
+        if (typeof provider === "function") {
+            httpDataProvider = new RestDataProviderHttpProviderUsingFetch(provider);
+        }
+    }
+    return httpDataProvider;
+}
 export function setControllerSettings(target, options) {
     let r = target;
     while (true) {

package/esm/src/data-providers/rest-data-provider.d.ts

@@ -2,10 +2,10 @@ import { EntityDataProvider, DataProvider, EntityDataProviderFindOptions, RestDa
 import { UrlBuilder } from '../../urlBuilder';
 import { Filter } from '../filter/filter-interfaces';
 import { EntityMetadata } from '../remult3';
+import { ApiClient } from '../context';
 export declare class RestDataProvider implements DataProvider {
-    private url;
-    private http;
-    constructor(url: string, http: RestDataProviderHttpProvider);
+    private apiProvider;
+    constructor(apiProvider: () => ApiClient);
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     supportsCustomFilter: boolean;
@@ -14,7 +14,7 @@ export declare class RestEntityDataProvider implements EntityDataProvider {
     private url;
     private http;
     private entity;
-    constructor(url: string, http: RestDataProviderHttpProvider, entity: EntityMetadata);
+    constructor(url: () => string, http: () => RestDataProviderHttpProvider, entity: EntityMetadata);
     translateFromJson(row: any): {};
     translateToJson(row: any): {};
     count(where: Filter): Promise<number>;

package/esm/src/data-providers/rest-data-provider.js

@@ -1,14 +1,20 @@
 import { UrlBuilder } from '../../urlBuilder';
 import { customUrlToken } from '../filter/filter-interfaces';
-import { retry } from '../context';
+import { buildRestDataProvider, retry } from '../context';
 export class RestDataProvider {
-    constructor(url, http) {
-        this.url = url;
-        this.http = http;
+    constructor(apiProvider) {
+        this.apiProvider = apiProvider;
         this.supportsCustomFilter = true;
     }
     getEntityDataProvider(entity) {
-        return new RestEntityDataProvider(this.url + '/' + entity.key, this.http, entity);
+        return new RestEntityDataProvider(() => {
+            let url = this.apiProvider()?.url;
+            if (url === undefined || url === null)
+                url = '/api';
+            return url + '/' + entity.key;
+        }, () => {
+            return buildRestDataProvider(this.apiProvider().httpClient);
+        }, entity);
     }
     async transaction(action) {
         throw new Error("Method not implemented.");
@@ -35,7 +41,7 @@ export class RestEntityDataProvider {
         return result;
     }
     async count(where) {
-        let url = new UrlBuilder(this.url);
+        let url = new UrlBuilder(this.url());
         url.add("__action", "count");
         let filterObject;
         if (where) {
@@ -44,12 +50,12 @@ export class RestEntityDataProvider {
                 filterObject = undefined;
         }
         if (filterObject)
-            return this.http.post(url.url, filterObject).then(r => +(r.count));
+            return this.http().post(url.url, filterObject).then(r => +(r.count));
         else
-            return this.http.get(url.url).then(r => +(r.count));
+            return this.http().get(url.url).then(r => +(r.count));
     }
     find(options) {
-        let url = new UrlBuilder(this.url);
+        let url = new UrlBuilder(this.url());
         let filterObject;
         if (options) {
             if (options.where) {
@@ -78,10 +84,10 @@ export class RestEntityDataProvider {
         }
         if (filterObject) {
             url.add("__action", "get");
-            return this.http.post(url.url, filterObject).then(x => x.map(y => this.translateFromJson(y)));
+            return this.http().post(url.url, filterObject).then(x => x.map(y => this.translateFromJson(y)));
         }
         else
-            return this.http.get(url.url).then(x => x.map(y => this.translateFromJson(y)));
+            return this.http().get(url.url).then(x => x.map(y => this.translateFromJson(y)));
         ;
     }
     update(id, data) {
@@ -91,13 +97,13 @@ export class RestEntityDataProvider {
             if (keys.includes(col.key))
                 result[col.key] = col.valueConverter.toJson(data[col.key]);
         }
-        return this.http.put(this.url + '/' + encodeURIComponent(id), result).then(y => this.translateFromJson(y));
+        return this.http().put(this.url() + '/' + encodeURIComponent(id), result).then(y => this.translateFromJson(y));
     }
     delete(id) {
-        return this.http.delete(this.url + '/' + encodeURIComponent(id));
+        return this.http().delete(this.url() + '/' + encodeURIComponent(id));
     }
     insert(data) {
-        return this.http.post(this.url, this.translateToJson(data)).then(y => this.translateFromJson(y));
+        return this.http().post(this.url(), this.translateToJson(data)).then(y => this.translateFromJson(y));
     }
 }
 export class RestDataProviderHttpProviderUsingFetch {

package/esm/src/remult-proxy.d.ts

@@ -0,0 +1,2 @@
+import { Remult } from "./context";
+export declare const remult: Remult;