remult 0.15.3 → 0.16.0-exp.1

package/esm/index.d.ts

@@ -8,7 +8,8 @@ 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';
@@ -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/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;
         });
     }
@@ -53,6 +60,8 @@ export function createRemultServer(options) {
     return bridge;
 }
 ;
+const remultObjectStorage = new AsyncLocalStorage();
+let remultObjectStorageWasSetup = false;
 class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;
@@ -62,6 +71,16 @@ class RemultServerImplementation {
         this.hasQueue = false;
         /* internal */
         this.backendMethodsOpenApi = [];
+        if (!remultObjectStorageWasSetup) {
+            remultObjectStorageWasSetup = true;
+            remult.remultFactory = () => {
+                const r = remultObjectStorage.getStore();
+                if (r)
+                    return r;
+                else
+                    throw "remult object was requested outside of a valid context, try running it within initApi or a remult request cycle";
+            };
+        }
     }
     handle(req, gRes) {
         if (!this.routeImpl) {
@@ -134,22 +153,24 @@ class RemultServerImplementation {
             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'];
+            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.setUser(user);
                 }
-                if (user)
-                    remult.setUser(user);
-            }
-            if (this.options.initRequest) {
-                await this.options.initRequest(remult, req);
-            }
-            what(remult, myReq, myRes, req);
+                if (this.options.initRequest) {
+                    await this.options.initRequest(remult, req);
+                }
+                what(remult, myReq, myRes, req);
+            });
         };
     }
     ;

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

@@ -4,7 +4,7 @@ import { remultFresh } from '../../remult-fresh';
 import { HttpProviderBridgeToRestDataProviderHttpProvider, Remult } from '../context';
 import { InMemoryDataProvider } from '../data-providers/in-memory-database';
 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';
@@ -158,7 +158,7 @@ Task = __decorate([
 export { Task };
 async function create3Tasks() {
     const remult = new Remult(axios);
-    Action.provider = new HttpProviderBridgeToRestDataProviderHttpProvider(axios);
+    Remult.defaultHttpProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(axios);
     const taskRepo = remult.repo(Task);
     for (const task of await taskRepo.find()) {
         await taskRepo.delete(task);

package/esm/src/context.d.ts

@@ -41,8 +41,6 @@ export declare class Remult {
     get user(): UserInfo;
     /** Set's the current user info */
     setUser(info: UserInfo | undefined): Promise<void>;
-    private _user;
-    private _userChangeEvent;
     /** Checks if a user was authenticated */
     authenticated(): boolean;
     /** checks if the user has any of the roles specified in the parameters
@@ -59,7 +57,8 @@ export declare class Remult {
     isAllowedForInstance(instance: any, allowed?: AllowedForInstance<any>): boolean;
     /** returns a dispatcher object that fires once a user has changed*/
     get userChange(): EventDispatcher;
-    private repCache;
+    static defaultHttpProvider: RestDataProviderHttpProvider;
+    static setDefaultHttpProvider(provider: HttpProvider | typeof fetch): void;
     /** 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.
@@ -81,6 +80,9 @@ export declare class Remult {
     clearAllCache(): any;
     /** A helper callback that is called whenever an entity is created. */
     static entityRefInit?: (ref: EntityRef<any>, row: any) => void;
+    readonly state: RemultState;
+}
+export interface RemultState {
 }
 export declare const allEntities: ClassType<any>[];
 export interface ControllerOptions {

package/esm/src/context.js

@@ -1,4 +1,4 @@
-import { Action, actionInfo } from './server-action';
+import { actionInfo } from './server-action';
 import { RestDataProvider, RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
 export class HttpProviderBridgeToRestDataProviderHttpProvider {
@@ -97,30 +97,20 @@ export class Remult {
      * If no provider is specified, `fetch` will be used as an http provider
      */
     constructor(provider) {
+        /* @internal */
         this._userChangeEvent = new EventSource();
+        /* @internal */
         this.repCache = new Map();
+        this.state = {};
         if (provider && provider.getEntityDataProvider) {
             this._dataSource = 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);
-            }
+        let httpDataProvider = buildRestDataProvider(provider);
+        if (!httpDataProvider) {
+            httpDataProvider = new UseDefaultRestDataProviderHttpProvider();
         }
-        if (!dataProvider) {
-            dataProvider = new RestDataProviderHttpProviderUsingFetch();
-        }
-        this._dataSource = new RestDataProvider(Remult.apiBaseUrl, dataProvider);
-        if (!Action.provider)
-            Action.provider = dataProvider;
+        this._dataSource = new RestDataProvider(null, httpDataProvider);
     }
     /**Return's a `Repository` of the specific entity type
      * @example
@@ -224,6 +214,12 @@ export class Remult {
     get userChange() {
         return this._userChangeEvent.dispatcher;
     }
+    static setDefaultHttpProvider(provider) {
+        const r = buildRestDataProvider(provider);
+        if (!r)
+            throw provider + " doesn't patch http provider or fetch interface";
+        Remult.defaultHttpProvider = r;
+    }
     /** sets the current data provider */
     setDataProvider(dataProvider) {
         this._dataSource = dataProvider;
@@ -232,6 +228,7 @@ export class Remult {
         this.repCache.clear();
     }
 }
+Remult.defaultHttpProvider = new RestDataProviderHttpProviderUsingFetch();
 /** 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
@@ -239,6 +236,20 @@ export class Remult {
 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) => { };
+class UseDefaultRestDataProviderHttpProvider {
+    post(url, data) {
+        return Remult.defaultHttpProvider.post(url, data);
+    }
+    delete(url) {
+        return Remult.defaultHttpProvider.delete(url);
+    }
+    put(url, data) {
+        return Remult.defaultHttpProvider.put(url, data);
+    }
+    get(url) {
+        return Remult.defaultHttpProvider.get(url);
+    }
+}
 export const allEntities = [];
 export const classHelpers = new Map();
 export class ClassHelper {
@@ -251,6 +262,21 @@ export class MethodHelper {
         this.classes = new Map();
     }
 }
+function buildRestDataProvider(provider) {
+    let httpDataProvider;
+    if (!httpDataProvider) {
+        let http = provider;
+        if (http && http.get && http.put && http.post && http.delete) {
+            httpDataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(http);
+        }
+    }
+    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-interfaces.d.ts

@@ -1,6 +1,7 @@
 import { Sort } from './sort';
 import { Filter } from './filter/filter-interfaces';
 import { EntityMetadata, OmitEB } from './remult3';
+import { HttpProvider } from './context';
 export interface DataProvider {
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
@@ -19,7 +20,7 @@ export interface EntityDataProviderFindOptions {
     page?: number;
     orderBy?: Sort;
 }
-export interface RestDataProviderHttpProvider {
+export interface RestDataProviderHttpProvider extends HttpProvider {
     post(url: string, data: any): Promise<any>;
     delete(url: string): Promise<void>;
     put(url: string, data: any): Promise<any>;

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

@@ -5,7 +5,7 @@ import { EntityMetadata } from '../remult3';
 export declare class RestDataProvider implements DataProvider {
     private url;
     private http;
-    constructor(url: string, http: RestDataProviderHttpProvider);
+    constructor(url: string | null, http: RestDataProviderHttpProvider);
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     supportsCustomFilter: boolean;

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

@@ -1,6 +1,6 @@
 import { UrlBuilder } from '../../urlBuilder';
 import { customUrlToken } from '../filter/filter-interfaces';
-import { retry } from '../context';
+import { Remult, retry } from '../context';
 export class RestDataProvider {
     constructor(url, http) {
         this.url = url;
@@ -8,7 +8,10 @@ export class RestDataProvider {
         this.supportsCustomFilter = true;
     }
     getEntityDataProvider(entity) {
-        return new RestEntityDataProvider(this.url + '/' + entity.key, this.http, entity);
+        let url = this.url;
+        if (url === undefined || url === null)
+            url = Remult.apiBaseUrl;
+        return new RestEntityDataProvider(url + '/' + entity.key, this.http, entity);
     }
     async transaction(action) {
         throw new Error("Method not implemented.");

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

@@ -0,0 +1 @@
+export declare const remult: RemultProxy;

package/esm/src/remult-proxy.js

@@ -0,0 +1,51 @@
+import { Remult } from "./context";
+let defaultRemult = new Remult();
+/*@internal*/
+export class RemultProxy {
+    constructor() {
+        /*@internal*/
+        this.remultFactory = () => defaultRemult;
+        this.repo = (...args) => this.remultFactory().repo(...args);
+    }
+    get state() {
+        return this.instance.state;
+    }
+    get _user() {
+        return this.instance._user;
+    }
+    ;
+    get _userChangeEvent() { return this.instance._userChangeEvent; }
+    ;
+    get _dataSource() { return this.instance._dataSource; }
+    ;
+    get repCache() { return this.instance.repCache; }
+    ;
+    setUser(info) {
+        return this.instance.setUser(info);
+    }
+    authenticated() {
+        return this.instance.authenticated();
+    }
+    isAllowed(roles) {
+        return this.instance.isAllowed(roles);
+    }
+    isAllowedForInstance(instance, allowed) {
+        return this.instance.isAllowedForInstance(instance, allowed);
+    }
+    get userChange() {
+        return this.instance.userChange;
+    }
+    setDataProvider(dataProvider) {
+        return this.instance.setDataProvider(dataProvider);
+    }
+    clearAllCache() {
+        return this.instance.clearAllCache();
+    }
+    get instance() {
+        return this.remultFactory();
+    }
+    get user() {
+        return this.remultFactory().user;
+    }
+}
+export const remult = new RemultProxy();

package/esm/src/server-action.d.ts

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
 import { Remult, AllowedForInstance } from './context';
 import { DataApiRequest, DataApiResponse } from './data-api';
-import { DataProvider, RestDataProviderHttpProvider } from './data-interfaces';
+import { DataProvider } from './data-interfaces';
 interface inArgs {
     args: any[];
 }
@@ -14,7 +14,6 @@ export declare abstract class Action<inParam, outParam> {
     private allowed;
     constructor(actionUrl: string, queue: boolean, allowed: AllowedForInstance<any>);
     static apiUrlForJobStatus: string;
-    static provider: RestDataProviderHttpProvider;
     run(pIn: inParam): Promise<outParam>;
     protected abstract execute(info: inParam, req: Remult, res: DataApiResponse): Promise<outParam>;
     __register(reg: (url: string, queue: boolean, allowed: AllowedForInstance<any>, what: ((data: any, req: Remult, res: DataApiResponse) => void)) => void): void;

package/esm/src/server-action.js

@@ -9,7 +9,7 @@ export class Action {
         this.allowed = allowed;
     }
     async run(pIn) {
-        let r = await Action.provider.post(Remult.apiBaseUrl + '/' + this.actionUrl, pIn);
+        let r = await Remult.defaultHttpProvider.post(Remult.apiBaseUrl + '/' + this.actionUrl, pIn);
         let p = r;
         if (p && p.queuedJobId) {
             let progress = actionInfo.startBusyWithProgress();
@@ -21,7 +21,7 @@ export class Action {
                             await new Promise(res => setTimeout(() => {
                                 res(undefined);
                             }, 200));
-                        runningJob = await Action.provider.post(Remult.apiBaseUrl + '/' + Action.apiUrlForJobStatus, { queuedJobId: r.queuedJobId });
+                        runningJob = await Remult.defaultHttpProvider.post(Remult.apiBaseUrl + '/' + Action.apiUrlForJobStatus, { queuedJobId: r.queuedJobId });
                         if (runningJob.progress) {
                             progress.progress(runningJob.progress);
                         }

package/esm/src/tests/testHelper.spec.js

@@ -5,7 +5,7 @@ import { InMemoryDataProvider } from "../data-providers/in-memory-database";
 import { RestEntityDataProvider } from "../data-providers/rest-data-provider";
 import { SqlDatabase } from "../data-providers/sql-database";
 import { WebSqlDataProvider } from "../data-providers/web-sql-data-provider";
-import { Action, actionInfo, serverActionField } from "../server-action";
+import { actionInfo, serverActionField } from "../server-action";
 import { testConfiguration } from '../shared-tests/entityWithValidations';
 import { TestDataApiResponse } from './TestDataApiResponse';
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 999999;
@@ -48,7 +48,7 @@ export async function testAsIfOnBackend(what) {
 export const ActionTestConfig = {
     db: new InMemoryDataProvider()
 };
-Action.provider = {
+Remult.defaultHttpProvider = {
     delete: undefined,
     get: undefined,
     post: async (urlreq, data) => {

package/index.d.ts

@@ -8,7 +8,8 @@ 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';
@@ -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/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueConverters = exports.Validators = exports.UrlBuilder = exports.FilterConsumerBridgeToSqlRequest = exports.Filter = exports.CompoundIdField = exports.OneToMany = exports.Sort = exports.IdEntity = exports.EventSource = exports.isBackend = exports.Remult = exports.Allow = exports.ProgressListener = exports.BackendMethod = exports.Controller = exports.JsonDataProvider = exports.SqlDatabase = exports.WebSqlDataProvider = exports.ArrayEntityDataProvider = exports.InMemoryDataProvider = exports.RestDataProvider = exports.CaptionTransformer = exports.ValueListInfo = exports.getValueList = exports.ValueListFieldType = exports.getEntityRef = exports.getFields = exports.FieldType = exports.ControllerBase = exports.EntityBase = exports.BuildEntity = exports.Entity = exports.Fields = exports.Field = void 0;
+exports.remult = exports.ValueConverters = exports.Validators = exports.UrlBuilder = exports.FilterConsumerBridgeToSqlRequest = exports.Filter = exports.CompoundIdField = exports.OneToMany = exports.Sort = exports.IdEntity = exports.EventSource = exports.isBackend = exports.Remult = exports.Allow = exports.ProgressListener = exports.BackendMethod = exports.Controller = exports.JsonDataProvider = exports.CustomSqlFilterBuilder = exports.SqlDatabase = exports.WebSqlDataProvider = exports.ArrayEntityDataProvider = exports.InMemoryDataProvider = exports.RestDataProvider = exports.CaptionTransformer = exports.ValueListInfo = exports.getValueList = exports.ValueListFieldType = exports.getEntityRef = exports.getFields = exports.FieldType = exports.ControllerBase = exports.EntityBase = exports.BuildEntity = exports.Entity = exports.Fields = exports.Field = void 0;
 /*
  * Public API Surface of remult
  */
@@ -28,6 +28,8 @@ var web_sql_data_provider_1 = require("./src/data-providers/web-sql-data-provide
 Object.defineProperty(exports, "WebSqlDataProvider", { enumerable: true, get: function () { return web_sql_data_provider_1.WebSqlDataProvider; } });
 var sql_database_1 = require("./src/data-providers/sql-database"); //V
 Object.defineProperty(exports, "SqlDatabase", { enumerable: true, get: function () { return sql_database_1.SqlDatabase; } });
+var filter_consumer_bridge_to_sql_request_1 = require("./src/filter/filter-consumer-bridge-to-sql-request");
+Object.defineProperty(exports, "CustomSqlFilterBuilder", { enumerable: true, get: function () { return filter_consumer_bridge_to_sql_request_1.CustomSqlFilterBuilder; } });
 var json_data_provider_1 = require("./src/data-providers/json-data-provider"); //V
 Object.defineProperty(exports, "JsonDataProvider", { enumerable: true, get: function () { return json_data_provider_1.JsonDataProvider; } });
 //export * from './src/data-api'; //reconsider if to make internal
@@ -49,11 +51,13 @@ Object.defineProperty(exports, "OneToMany", { enumerable: true, get: function ()
 Object.defineProperty(exports, "CompoundIdField", { enumerable: true, get: function () { return column_1.CompoundIdField; } });
 var filter_interfaces_1 = require("./src/filter/filter-interfaces");
 Object.defineProperty(exports, "Filter", { enumerable: true, get: function () { return filter_interfaces_1.Filter; } });
-var filter_consumer_bridge_to_sql_request_1 = require("./src/filter/filter-consumer-bridge-to-sql-request");
-Object.defineProperty(exports, "FilterConsumerBridgeToSqlRequest", { enumerable: true, get: function () { return filter_consumer_bridge_to_sql_request_1.FilterConsumerBridgeToSqlRequest; } });
+var filter_consumer_bridge_to_sql_request_2 = require("./src/filter/filter-consumer-bridge-to-sql-request");
+Object.defineProperty(exports, "FilterConsumerBridgeToSqlRequest", { enumerable: true, get: function () { return filter_consumer_bridge_to_sql_request_2.FilterConsumerBridgeToSqlRequest; } });
 var urlBuilder_1 = require("./urlBuilder");
 Object.defineProperty(exports, "UrlBuilder", { enumerable: true, get: function () { return urlBuilder_1.UrlBuilder; } });
 var validators_1 = require("./src/validators");
 Object.defineProperty(exports, "Validators", { enumerable: true, get: function () { return validators_1.Validators; } });
 var valueConverters_1 = require("./src/valueConverters");
 Object.defineProperty(exports, "ValueConverters", { enumerable: true, get: function () { return valueConverters_1.ValueConverters; } });
+var remult_proxy_1 = require("./src/remult-proxy");
+Object.defineProperty(exports, "remult", { enumerable: true, get: function () { return remult_proxy_1.remult; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.15.3",
+    "version": "0.16.0-exp.1",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",
@@ -60,6 +60,14 @@
         "./graphql": {
             "require": "./graphql.js",
             "import": "./esm/graphql.js"
+        },
+        "./src/remult3": {
+            "require": "./src/remult3/index.js",
+            "import": "./esm/src/remult3/index.js"
+        },
+        "./src/server-action": {
+            "require": "./src/server-action.js",
+            "import": "./esm/src/server-action.js"
         }
     }
 }

package/server/expressBridge.js

@@ -7,6 +7,8 @@ var data_api_1 = require("../src/data-api");
 var context_1 = require("../src/context");
 var remult3_1 = require("../src/remult3");
 var id_entity_1 = require("../src/id-entity");
+var async_hooks_1 = require("async_hooks");
+var remult_proxy_1 = require("../src/remult-proxy");
 ;
 function createRemultServer(options) {
     var _this = this;
@@ -42,11 +44,24 @@ function createRemultServer(options) {
     if (options.initApi) {
         dataProvider = dataProvider.then(function (dp) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var remult;
+            var _this = this;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         remult = new context_1.Remult(dp);
-                        return [4 /*yield*/, options.initApi(remult)];
+                        return [4 /*yield*/, new Promise(function (res) {
+                                remultObjectStorage.run(remult, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                    return tslib_1.__generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0: return [4 /*yield*/, options.initApi(remult)];
+                                            case 1:
+                                                _a.sent();
+                                                res({});
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); });
+                            })];
                     case 1:
                         _a.sent();
                         return [2 /*return*/, dp];
@@ -72,6 +87,8 @@ function createRemultServer(options) {
 }
 exports.createRemultServer = createRemultServer;
 ;
+var remultObjectStorage = new async_hooks_1.AsyncLocalStorage();
+var remultObjectStorageWasSetup = false;
 var RemultServerImplementation = /** @class */ (function () {
     function RemultServerImplementation(queue, options, dataProvider) {
         this.queue = queue;
@@ -81,6 +98,16 @@ var RemultServerImplementation = /** @class */ (function () {
         this.hasQueue = false;
         /* internal */
         this.backendMethodsOpenApi = [];
+        if (!remultObjectStorageWasSetup) {
+            remultObjectStorageWasSetup = true;
+            remult_proxy_1.remult.remultFactory = function () {
+                var r = remultObjectStorage.getStore();
+                if (r)
+                    return r;
+                else
+                    throw "remult object was requested outside of a valid context, try running it within initApi or a remult request cycle";
+            };
+        }
     }
     RemultServerImplementation.prototype.handle = function (req, gRes) {
         if (!this.routeImpl) {
@@ -195,7 +222,8 @@ var RemultServerImplementation = /** @class */ (function () {
     RemultServerImplementation.prototype.process = function (what) {
         var _this = this;
         return function (req, res) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var myReq, myRes, remult, _a, _b, user;
+            var myReq, myRes, remult, _a, _b;
+            var _this = this;
             return tslib_1.__generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
@@ -206,30 +234,39 @@ var RemultServerImplementation = /** @class */ (function () {
                         return [4 /*yield*/, this.dataProvider];
                     case 1:
                         _b.apply(_a, [_c.sent()]);
-                        if (!req) return [3 /*break*/, 5];
-                        user = void 0;
-                        if (!this.options.getUser) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.options.getUser(req)];
-                    case 2:
-                        user = _c.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        user = req['user'];
-                        if (!user)
-                            user = req['auth'];
-                        _c.label = 4;
-                    case 4:
-                        if (user)
-                            remult.setUser(user);
-                        _c.label = 5;
-                    case 5:
-                        if (!this.options.initRequest) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.options.initRequest(remult, req)];
-                    case 6:
-                        _c.sent();
-                        _c.label = 7;
-                    case 7:
-                        what(remult, myReq, myRes, req);
+                        remultObjectStorage.run(remult, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var user;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!req) return [3 /*break*/, 4];
+                                        user = void 0;
+                                        if (!this.options.getUser) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, this.options.getUser(req)];
+                                    case 1:
+                                        user = _a.sent();
+                                        return [3 /*break*/, 3];
+                                    case 2:
+                                        user = req['user'];
+                                        if (!user)
+                                            user = req['auth'];
+                                        _a.label = 3;
+                                    case 3:
+                                        if (user)
+                                            remult.setUser(user);
+                                        _a.label = 4;
+                                    case 4:
+                                        if (!this.options.initRequest) return [3 /*break*/, 6];
+                                        return [4 /*yield*/, this.options.initRequest(remult, req)];
+                                    case 5:
+                                        _a.sent();
+                                        _a.label = 6;
+                                    case 6:
+                                        what(remult, myReq, myRes, req);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
                         return [2 /*return*/];
                 }
             });

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

@@ -292,7 +292,7 @@ function create3Tasks() {
             switch (_f.label) {
                 case 0:
                     remult = new context_1.Remult(axios_1.default);
-                    server_action_1.Action.provider = new context_1.HttpProviderBridgeToRestDataProviderHttpProvider(axios_1.default);
+                    context_1.Remult.defaultHttpProvider = new context_1.HttpProviderBridgeToRestDataProviderHttpProvider(axios_1.default);
                     taskRepo = remult.repo(Task);
                     _f.label = 1;
                 case 1:

package/src/context.d.ts

@@ -41,8 +41,6 @@ export declare class Remult {
     get user(): UserInfo;
     /** Set's the current user info */
     setUser(info: UserInfo | undefined): Promise<void>;
-    private _user;
-    private _userChangeEvent;
     /** Checks if a user was authenticated */
     authenticated(): boolean;
     /** checks if the user has any of the roles specified in the parameters
@@ -59,7 +57,8 @@ export declare class Remult {
     isAllowedForInstance(instance: any, allowed?: AllowedForInstance<any>): boolean;
     /** returns a dispatcher object that fires once a user has changed*/
     get userChange(): EventDispatcher;
-    private repCache;
+    static defaultHttpProvider: RestDataProviderHttpProvider;
+    static setDefaultHttpProvider(provider: HttpProvider | typeof fetch): void;
     /** 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.
@@ -81,6 +80,9 @@ export declare class Remult {
     clearAllCache(): any;
     /** A helper callback that is called whenever an entity is created. */
     static entityRefInit?: (ref: EntityRef<any>, row: any) => void;
+    readonly state: RemultState;
+}
+export interface RemultState {
 }
 export declare const allEntities: ClassType<any>[];
 export interface ControllerOptions {

package/src/context.js

@@ -148,30 +148,20 @@ var Remult = /** @class */ (function () {
      * If no provider is specified, `fetch` will be used as an http provider
      */
     function Remult(provider) {
+        /* @internal */
         this._userChangeEvent = new EventSource();
+        /* @internal */
         this.repCache = new Map();
+        this.state = {};
         if (provider && provider.getEntityDataProvider) {
             this._dataSource = provider;
             return;
         }
-        var dataProvider;
-        if (!dataProvider) {
-            var http = provider;
-            if (http && http.get && http.put && http.post && http.delete) {
-                dataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(http);
-            }
-        }
-        if (!dataProvider) {
-            if (typeof provider === "function") {
-                dataProvider = new rest_data_provider_1.RestDataProviderHttpProviderUsingFetch(provider);
-            }
-        }
-        if (!dataProvider) {
-            dataProvider = new rest_data_provider_1.RestDataProviderHttpProviderUsingFetch();
+        var httpDataProvider = buildRestDataProvider(provider);
+        if (!httpDataProvider) {
+            httpDataProvider = new UseDefaultRestDataProviderHttpProvider();
         }
-        this._dataSource = new rest_data_provider_1.RestDataProvider(Remult.apiBaseUrl, dataProvider);
-        if (!server_action_1.Action.provider)
-            server_action_1.Action.provider = dataProvider;
+        this._dataSource = new rest_data_provider_1.RestDataProvider(null, httpDataProvider);
     }
     /**Return's a `Repository` of the specific entity type
      * @example
@@ -316,6 +306,12 @@ var Remult = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    Remult.setDefaultHttpProvider = function (provider) {
+        var r = buildRestDataProvider(provider);
+        if (!r)
+            throw provider + " doesn't patch http provider or fetch interface";
+        Remult.defaultHttpProvider = r;
+    };
     /** sets the current data provider */
     Remult.prototype.setDataProvider = function (dataProvider) {
         this._dataSource = dataProvider;
@@ -323,6 +319,7 @@ var Remult = /** @class */ (function () {
     Remult.prototype.clearAllCache = function () {
         this.repCache.clear();
     };
+    Remult.defaultHttpProvider = new rest_data_provider_1.RestDataProviderHttpProviderUsingFetch();
     /** 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
@@ -333,6 +330,23 @@ var Remult = /** @class */ (function () {
     return Remult;
 }());
 exports.Remult = Remult;
+var UseDefaultRestDataProviderHttpProvider = /** @class */ (function () {
+    function UseDefaultRestDataProviderHttpProvider() {
+    }
+    UseDefaultRestDataProviderHttpProvider.prototype.post = function (url, data) {
+        return Remult.defaultHttpProvider.post(url, data);
+    };
+    UseDefaultRestDataProviderHttpProvider.prototype.delete = function (url) {
+        return Remult.defaultHttpProvider.delete(url);
+    };
+    UseDefaultRestDataProviderHttpProvider.prototype.put = function (url, data) {
+        return Remult.defaultHttpProvider.put(url, data);
+    };
+    UseDefaultRestDataProviderHttpProvider.prototype.get = function (url) {
+        return Remult.defaultHttpProvider.get(url);
+    };
+    return UseDefaultRestDataProviderHttpProvider;
+}());
 exports.allEntities = [];
 exports.classHelpers = new Map();
 var ClassHelper = /** @class */ (function () {
@@ -349,6 +363,21 @@ var MethodHelper = /** @class */ (function () {
     return MethodHelper;
 }());
 exports.MethodHelper = MethodHelper;
+function buildRestDataProvider(provider) {
+    var httpDataProvider;
+    if (!httpDataProvider) {
+        var http = provider;
+        if (http && http.get && http.put && http.post && http.delete) {
+            httpDataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(http);
+        }
+    }
+    if (!httpDataProvider) {
+        if (typeof provider === "function") {
+            httpDataProvider = new rest_data_provider_1.RestDataProviderHttpProviderUsingFetch(provider);
+        }
+    }
+    return httpDataProvider;
+}
 function setControllerSettings(target, options) {
     var e_3, _a;
     var r = target;

package/src/data-interfaces.d.ts

@@ -1,6 +1,7 @@
 import { Sort } from './sort';
 import { Filter } from './filter/filter-interfaces';
 import { EntityMetadata, OmitEB } from './remult3';
+import { HttpProvider } from './context';
 export interface DataProvider {
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
@@ -19,7 +20,7 @@ export interface EntityDataProviderFindOptions {
     page?: number;
     orderBy?: Sort;
 }
-export interface RestDataProviderHttpProvider {
+export interface RestDataProviderHttpProvider extends HttpProvider {
     post(url: string, data: any): Promise<any>;
     delete(url: string): Promise<void>;
     put(url: string, data: any): Promise<any>;

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

@@ -5,7 +5,7 @@ import { EntityMetadata } from '../remult3';
 export declare class RestDataProvider implements DataProvider {
     private url;
     private http;
-    constructor(url: string, http: RestDataProviderHttpProvider);
+    constructor(url: string | null, http: RestDataProviderHttpProvider);
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     supportsCustomFilter: boolean;

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

@@ -12,7 +12,10 @@ var RestDataProvider = /** @class */ (function () {
         this.supportsCustomFilter = true;
     }
     RestDataProvider.prototype.getEntityDataProvider = function (entity) {
-        return new RestEntityDataProvider(this.url + '/' + entity.key, this.http, entity);
+        var url = this.url;
+        if (url === undefined || url === null)
+            url = context_1.Remult.apiBaseUrl;
+        return new RestEntityDataProvider(url + '/' + entity.key, this.http, entity);
     };
     RestDataProvider.prototype.transaction = function (action) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {

package/src/remult-proxy.d.ts

@@ -0,0 +1 @@
+export declare const remult: RemultProxy;

package/src/remult-proxy.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remult = exports.RemultProxy = void 0;
+var tslib_1 = require("tslib");
+var context_1 = require("./context");
+var defaultRemult = new context_1.Remult();
+/*@internal*/
+var RemultProxy = /** @class */ (function () {
+    function RemultProxy() {
+        var _this = this;
+        /*@internal*/
+        this.remultFactory = function () { return defaultRemult; };
+        this.repo = function () {
+            var _a;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return (_a = _this.remultFactory()).repo.apply(_a, tslib_1.__spread(args));
+        };
+    }
+    Object.defineProperty(RemultProxy.prototype, "state", {
+        get: function () {
+            return this.instance.state;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RemultProxy.prototype, "_user", {
+        get: function () {
+            return this.instance._user;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ;
+    Object.defineProperty(RemultProxy.prototype, "_userChangeEvent", {
+        get: function () { return this.instance._userChangeEvent; },
+        enumerable: false,
+        configurable: true
+    });
+    ;
+    Object.defineProperty(RemultProxy.prototype, "_dataSource", {
+        get: function () { return this.instance._dataSource; },
+        enumerable: false,
+        configurable: true
+    });
+    ;
+    Object.defineProperty(RemultProxy.prototype, "repCache", {
+        get: function () { return this.instance.repCache; },
+        enumerable: false,
+        configurable: true
+    });
+    ;
+    RemultProxy.prototype.setUser = function (info) {
+        return this.instance.setUser(info);
+    };
+    RemultProxy.prototype.authenticated = function () {
+        return this.instance.authenticated();
+    };
+    RemultProxy.prototype.isAllowed = function (roles) {
+        return this.instance.isAllowed(roles);
+    };
+    RemultProxy.prototype.isAllowedForInstance = function (instance, allowed) {
+        return this.instance.isAllowedForInstance(instance, allowed);
+    };
+    Object.defineProperty(RemultProxy.prototype, "userChange", {
+        get: function () {
+            return this.instance.userChange;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RemultProxy.prototype.setDataProvider = function (dataProvider) {
+        return this.instance.setDataProvider(dataProvider);
+    };
+    RemultProxy.prototype.clearAllCache = function () {
+        return this.instance.clearAllCache();
+    };
+    Object.defineProperty(RemultProxy.prototype, "instance", {
+        get: function () {
+            return this.remultFactory();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RemultProxy.prototype, "user", {
+        get: function () {
+            return this.remultFactory().user;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RemultProxy;
+}());
+exports.RemultProxy = RemultProxy;
+exports.remult = new RemultProxy();

package/src/server-action.d.ts

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
 import { Remult, AllowedForInstance } from './context';
 import { DataApiRequest, DataApiResponse } from './data-api';
-import { DataProvider, RestDataProviderHttpProvider } from './data-interfaces';
+import { DataProvider } from './data-interfaces';
 interface inArgs {
     args: any[];
 }
@@ -14,7 +14,6 @@ export declare abstract class Action<inParam, outParam> {
     private allowed;
     constructor(actionUrl: string, queue: boolean, allowed: AllowedForInstance<any>);
     static apiUrlForJobStatus: string;
-    static provider: RestDataProviderHttpProvider;
     run(pIn: inParam): Promise<outParam>;
     protected abstract execute(info: inParam, req: Remult, res: DataApiResponse): Promise<outParam>;
     __register(reg: (url: string, queue: boolean, allowed: AllowedForInstance<any>, what: ((data: any, req: Remult, res: DataApiResponse) => void)) => void): void;

package/src/server-action.js

@@ -18,7 +18,7 @@ var Action = /** @class */ (function () {
             var _this = this;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, Action.provider.post(context_1.Remult.apiBaseUrl + '/' + this.actionUrl, pIn)];
+                    case 0: return [4 /*yield*/, context_1.Remult.defaultHttpProvider.post(context_1.Remult.apiBaseUrl + '/' + this.actionUrl, pIn)];
                     case 1:
                         r = _a.sent();
                         p = r;
@@ -39,7 +39,7 @@ var Action = /** @class */ (function () {
                                         case 1:
                                             _a.sent();
                                             _a.label = 2;
-                                        case 2: return [4 /*yield*/, Action.provider.post(context_1.Remult.apiBaseUrl + '/' + Action.apiUrlForJobStatus, { queuedJobId: r.queuedJobId })];
+                                        case 2: return [4 /*yield*/, context_1.Remult.defaultHttpProvider.post(context_1.Remult.apiBaseUrl + '/' + Action.apiUrlForJobStatus, { queuedJobId: r.queuedJobId })];
                                         case 3:
                                             runningJob_1 = _a.sent();
                                             if (runningJob_1.progress) {

package/src/tests/testHelper.spec.js

@@ -65,7 +65,7 @@ exports.testAsIfOnBackend = testAsIfOnBackend;
 exports.ActionTestConfig = {
     db: new in_memory_database_1.InMemoryDataProvider()
 };
-server_action_1.Action.provider = {
+context_1.Remult.defaultHttpProvider = {
     delete: undefined,
     get: undefined,
     post: function (urlreq, data) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {