remult 3.3.17 → 3.3.18-next.0

package/esm/internals.js

@@ -9,3 +9,4 @@ export { isOfType } from './src/isOfType.js';
 export { flags } from './src/remult3/remult3.js';
 export { DataProviderPromiseWrapper } from './src/data-interfaces.js';
 export { pagedQueryResult } from './src/remult3/pagedQueryResult.js';
+export { withFetch } from './src/context.js';

package/esm/server/initAsyncHooks.js

@@ -16,7 +16,7 @@ export function initAsyncHooks() {
         }
     });
 }
-export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
+export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore {
     asyncLocalStorage = new AsyncLocalStorage();
     wasImplemented = 'yes';
     run(store, callback) {
@@ -36,8 +36,14 @@ export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
     getStore() {
         return this.asyncLocalStorage.getStore();
     }
+    createDataProviderAsyncLocalStorage() {
+        return new AsyncLocalStorage();
+    }
 }
 export class StubRemultAsyncLocalStorageCore {
+    createDataProviderAsyncLocalStorage() {
+        return undefined;
+    }
     isStub = true;
     wasImplemented = 'yes';
     async run(store, callback) {
@@ -50,5 +56,3 @@ export class StubRemultAsyncLocalStorageCore {
     lastPromise = Promise.resolve(undefined);
     currentValue;
 }
-export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore extends AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
-}

package/esm/server/test-api-data-provider.js

@@ -98,6 +98,7 @@ async function MakeServerCallWithDifferentStaticRemult(what) {
                 store.remult.user = user;
                 return callback();
             },
+            createDataProviderAsyncLocalStorage: () => undefined,
             wasImplemented: 'yes',
         });
         return await what();

package/esm/src/context.js

@@ -45,6 +45,9 @@ export class RemultAsyncLocalStorage {
         if (val || this.remultObjectStorage?.isStub)
             store.inInitRequest = val;
     }
+    createDataProviderAsyncLocalStorage() {
+        return this.remultObjectStorage?.createDataProviderAsyncLocalStorage();
+    }
     getStore() {
         if (!this.remultObjectStorage) {
             throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
@@ -183,8 +186,15 @@ export class Remult {
             httpClient: fetch,
         }));
     }
+    /* @internal */
+    _myDataProviderStore = new RemultInstanceDataProviderStore(new RestDataProvider(() => this.apiClient));
     /** The current data provider */
-    dataProvider = new RestDataProvider(() => this.apiClient);
+    set dataProvider(dataProvider) {
+        this._myDataProviderStore.getStore().dataProvider = dataProvider;
+    }
+    get dataProvider() {
+        return this._myDataProviderStore.getStore().dataProvider;
+    }
     /* @internal */
     repCache = new Map();
     constructor(provider) {
@@ -311,10 +321,11 @@ export async function doTransaction(remult, what) {
     const prev = remult.dataProvider;
     try {
         await remult.dataProvider.transaction(async (ds) => {
-            remult.dataProvider = ds;
-            remult.liveQueryPublisher = trans;
-            await what(ds);
-            ok = true;
+            await withRemultDataProvider({ dataProvider: ds, remult }, async () => {
+                remult.liveQueryPublisher = trans;
+                await what(ds);
+                ok = true;
+            });
         });
         if (ok)
             await trans.flush();
@@ -358,6 +369,54 @@ class transactionLiveQueryPublisher {
 }
 export async function withRemult(callback, options) {
     const remult = new Remult();
-    remult.dataProvider = await initDataProvider(options?.dataProvider, true, async () => remult.dataProvider);
-    return remultStatic.asyncContext.run(remult, (r) => callback(r));
+    return remultStatic.asyncContext.run(remult, async (r) => {
+        remult.dataProvider = await initDataProvider(options?.dataProvider, true, async () => remult.dataProvider);
+        return await callback(r);
+    });
+}
+export class RemultInstanceDataProviderStore {
+    constructor(dataProvider) {
+        this._myDataProviderStore = { dataProvider };
+    }
+    _myDataProviderStore;
+    getStore = () => this._myDataProviderStore;
+    asyncStore;
+    async withDataProvider(dataProvider, callback) {
+        if (!this.asyncStore) {
+            this.asyncStore =
+                remultStatic.asyncContext.createDataProviderAsyncLocalStorage();
+            if (this.asyncStore) {
+                this.getStore = () => this.asyncStore.getStore() ?? this._myDataProviderStore;
+            }
+        }
+        if (this.asyncStore) {
+            return this.asyncStore.run({ dataProvider }, async () => {
+                return await callback();
+            });
+        }
+        else {
+            const prev = this._myDataProviderStore;
+            try {
+                this._myDataProviderStore = { dataProvider };
+                return await callback();
+            }
+            finally {
+                this._myDataProviderStore = prev;
+            }
+        }
+    }
+}
+export function withRemultDataProvider({ dataProvider, remult }, callback) {
+    remult = remult ?? remultStatic.remultFactory();
+    return remult._myDataProviderStore.withDataProvider(dataProvider, callback);
+}
+export function withFetch(fetch, callback) {
+    const remult = remultStatic.remultFactory();
+    return withRemultDataProvider({
+        remult,
+        dataProvider: new RestDataProvider(() => ({
+            ...remult.apiClient,
+            httpClient: fetch,
+        })),
+    }, callback);
 }

package/esm/src/remult-proxy.js

@@ -215,5 +215,9 @@ export class RemultProxy {
     set subscriptionServer(value) {
         remultStatic.remultFactory().subscriptionServer = value;
     }
+    /** @internal */
+    get _myDataProviderStore() {
+        return remultStatic.remultFactory()._myDataProviderStore;
+    }
 }
 export const remult = new RemultProxy();

package/internals.d.ts

@@ -17,3 +17,4 @@ export type { ClassType } from './classType.js';
 export { flags } from './src/remult3/remult3.js';
 export { DataProviderPromiseWrapper } from './src/data-interfaces.js';
 export { pagedQueryResult } from './src/remult3/pagedQueryResult.js';
+export { withFetch } from './src/context.js';

package/internals.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pagedQueryResult = exports.DataProviderPromiseWrapper = exports.flags = exports.isOfType = exports.actionInfo = exports.__updateEntityBasedOnWhere = exports.getEntitySettings = exports.fieldOptionsEnricher = exports.getControllerRef = exports.controllerRefImpl = exports.decorateColumnSettings = exports.getRelationFieldInfo = exports.getRelationInfo = exports.sqlRelationsFilter = exports.sqlRelations = void 0;
+exports.withFetch = exports.pagedQueryResult = exports.DataProviderPromiseWrapper = exports.flags = exports.isOfType = exports.actionInfo = exports.__updateEntityBasedOnWhere = exports.getEntitySettings = exports.fieldOptionsEnricher = exports.getControllerRef = exports.controllerRefImpl = exports.decorateColumnSettings = exports.getRelationFieldInfo = exports.getRelationInfo = exports.sqlRelationsFilter = exports.sqlRelations = void 0;
 var remult_static_js_1 = require("./src/remult-static.js");
 var sql_relations_js_1 = require("./src/data-providers/sql-relations.js");
 Object.defineProperty(exports, "sqlRelations", { enumerable: true, get: function () { return sql_relations_js_1.sqlRelations; } });
@@ -26,3 +26,5 @@ var data_interfaces_js_1 = require("./src/data-interfaces.js");
 Object.defineProperty(exports, "DataProviderPromiseWrapper", { enumerable: true, get: function () { return data_interfaces_js_1.DataProviderPromiseWrapper; } });
 var pagedQueryResult_js_1 = require("./src/remult3/pagedQueryResult.js");
 Object.defineProperty(exports, "pagedQueryResult", { enumerable: true, get: function () { return pagedQueryResult_js_1.pagedQueryResult; } });
+var context_js_1 = require("./src/context.js");
+Object.defineProperty(exports, "withFetch", { enumerable: true, get: function () { return context_js_1.withFetch; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "3.3.17",
+    "version": "3.3.18-next.0",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/server/initAsyncHooks.d.ts

@@ -1,18 +1,22 @@
-import { type RemultAsyncLocalStorageCore } from '../src/context.js';
+import { AsyncLocalStorage } from 'async_hooks';
+import { type RemultAsyncLocalStorageCore, type RemultInAsyncLocalStorage } from '../src/context.js';
+import type { DataProvider } from '../src/data-interfaces.js';
 export declare function initAsyncHooks(): void;
-export declare class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl<T> implements RemultAsyncLocalStorageCore<T> {
+export declare class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore implements RemultAsyncLocalStorageCore {
     private asyncLocalStorage;
     wasImplemented: "yes";
-    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
-    getStore(): T | undefined;
+    run<R>(store: RemultInAsyncLocalStorage, callback: () => Promise<R>): Promise<R>;
+    getStore(): RemultInAsyncLocalStorage | undefined;
+    createDataProviderAsyncLocalStorage(): AsyncLocalStorage<{
+        dataProvider: DataProvider;
+    }>;
 }
-export declare class StubRemultAsyncLocalStorageCore<T> implements RemultAsyncLocalStorageCore<T> {
+export declare class StubRemultAsyncLocalStorageCore implements RemultAsyncLocalStorageCore {
+    createDataProviderAsyncLocalStorage(): undefined;
     isStub: boolean;
     wasImplemented: "yes";
-    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
-    getStore(): T | undefined;
-    lastPromise: Promise<T | undefined>;
-    currentValue?: T;
-}
-export declare class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore<T> extends AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl<T> {
+    run<R>(store: RemultInAsyncLocalStorage, callback: () => Promise<R>): Promise<R>;
+    getStore(): RemultInAsyncLocalStorage | undefined;
+    lastPromise: Promise<RemultInAsyncLocalStorage | undefined>;
+    currentValue?: RemultInAsyncLocalStorage;
 }

package/server/initAsyncHooks.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = exports.StubRemultAsyncLocalStorageCore = exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = void 0;
+exports.StubRemultAsyncLocalStorageCore = exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = void 0;
 exports.initAsyncHooks = initAsyncHooks;
 var tslib_1 = require("tslib");
 var async_hooks_1 = require("async_hooks");
@@ -29,12 +29,12 @@ function initAsyncHooks() {
         });
     }); });
 }
-var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = /** @class */ (function () {
-    function AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl() {
+var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = /** @class */ (function () {
+    function AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore() {
         this.asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
         this.wasImplemented = 'yes';
     }
-    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl.prototype.run = function (store, callback) {
+    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.prototype.run = function (store, callback) {
         var _this = this;
         var r;
         this.asyncLocalStorage.run(store, function () {
@@ -60,18 +60,24 @@ var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = /** @class */ (fu
         });
         return r;
     };
-    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl.prototype.getStore = function () {
+    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.prototype.getStore = function () {
         return this.asyncLocalStorage.getStore();
     };
-    return AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl;
+    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.prototype.createDataProviderAsyncLocalStorage = function () {
+        return new async_hooks_1.AsyncLocalStorage();
+    };
+    return AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore;
 }());
-exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl;
+exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore;
 var StubRemultAsyncLocalStorageCore = /** @class */ (function () {
     function StubRemultAsyncLocalStorageCore() {
         this.isStub = true;
         this.wasImplemented = 'yes';
         this.lastPromise = Promise.resolve(undefined);
     }
+    StubRemultAsyncLocalStorageCore.prototype.createDataProviderAsyncLocalStorage = function () {
+        return undefined;
+    };
     StubRemultAsyncLocalStorageCore.prototype.run = function (store, callback) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {
@@ -90,11 +96,3 @@ var StubRemultAsyncLocalStorageCore = /** @class */ (function () {
     return StubRemultAsyncLocalStorageCore;
 }());
 exports.StubRemultAsyncLocalStorageCore = StubRemultAsyncLocalStorageCore;
-var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = /** @class */ (function (_super) {
-    tslib_1.__extends(AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore, _super);
-    function AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore;
-}(AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl));
-exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore;

package/server/test-api-data-provider.js

@@ -161,6 +161,7 @@ function MakeServerCallWithDifferentStaticRemult(what) {
                             store.remult.user = user;
                             return callback();
                         },
+                        createDataProviderAsyncLocalStorage: function () { return undefined; },
                         wasImplemented: 'yes',
                     });
                     return [4 /*yield*/, what()];

package/src/context.d.ts

@@ -8,23 +8,31 @@ export declare class RemultAsyncLocalStorage {
     private readonly remultObjectStorage;
     static enable(): void;
     static disable(): void;
-    constructor(remultObjectStorage: RemultAsyncLocalStorageCore<{
-        remult: Remult;
-        inInitRequest?: boolean;
-    }> | undefined);
+    constructor(remultObjectStorage: RemultAsyncLocalStorageCore | undefined);
     run<T>(remult: Remult, callback: (remult: Remult) => Promise<T>): Promise<T>;
     isInInitRequest(): boolean | undefined;
     setInInitRequest(val: boolean): void;
-    getStore(): {
-        remult: Remult;
-        inInitRequest?: boolean;
-    } | undefined;
+    createDataProviderAsyncLocalStorage(): DataProviderAsyncLocalStorage | undefined;
+    getStore(): RemultInAsyncLocalStorage | undefined;
 }
-export type RemultAsyncLocalStorageCore<T> = {
-    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
-    getStore(): T | undefined;
+export type RemultAsyncLocalStorageCore = {
+    run<R>(store: RemultInAsyncLocalStorage, callback: () => Promise<R>): Promise<R>;
+    getStore(): RemultInAsyncLocalStorage | undefined;
     wasImplemented: 'yes';
     isStub?: boolean;
+    createDataProviderAsyncLocalStorage(): DataProviderAsyncLocalStorage | undefined;
+};
+export type RemultInAsyncLocalStorage = {
+    remult: Remult;
+    inInitRequest?: boolean;
+};
+export type DataProviderAsyncLocalStorage = {
+    run<R>(data: {
+        dataProvider: DataProvider;
+    }, callback: () => Promise<R>): Promise<R>;
+    getStore(): {
+        dataProvider: DataProvider;
+    } | undefined;
 };
 export declare function isBackend(): boolean;
 export declare class Remult {
@@ -72,7 +80,8 @@ export declare class Remult {
      */
     useFetch(fetch: ApiClient['httpClient']): void;
     /** The current data provider */
-    dataProvider: DataProvider;
+    set dataProvider(dataProvider: DataProvider);
+    get dataProvider(): DataProvider;
     /** 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.
@@ -250,3 +259,19 @@ export declare function doTransaction(remult: Remult, what: (dp: DataProvider) =
 export declare function withRemult<T>(callback: (remult: Remult) => Promise<T>, options?: {
     dataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
 }): Promise<T>;
+export declare class RemultInstanceDataProviderStore {
+    constructor(dataProvider: DataProvider);
+    _myDataProviderStore: {
+        dataProvider: DataProvider;
+    };
+    getStore: () => {
+        dataProvider: DataProvider;
+    };
+    asyncStore?: DataProviderAsyncLocalStorage;
+    withDataProvider<T>(dataProvider: DataProvider, callback: () => Promise<T>): Promise<T>;
+}
+export declare function withRemultDataProvider<T>({ dataProvider, remult }: {
+    dataProvider: DataProvider;
+    remult?: Remult;
+}, callback: () => Promise<T>): Promise<T>;
+export declare function withFetch<T>(fetch: ApiClient['httpClient'], callback: () => Promise<T>): Promise<T>;

package/src/context.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventSource = exports.queryConfig = exports.Allow = exports.ClassHelper = exports.Remult = exports.RemultAsyncLocalStorage = void 0;
+exports.RemultInstanceDataProviderStore = exports.EventSource = exports.queryConfig = exports.Allow = exports.ClassHelper = exports.Remult = exports.RemultAsyncLocalStorage = void 0;
 exports.isBackend = isBackend;
 exports.setControllerSettings = setControllerSettings;
 exports.doTransaction = doTransaction;
 exports.withRemult = withRemult;
+exports.withRemultDataProvider = withRemultDataProvider;
+exports.withFetch = withFetch;
 var tslib_1 = require("tslib");
 var data_interfaces_js_1 = require("./data-interfaces.js");
 var rest_data_provider_js_1 = require("./data-providers/rest-data-provider.js");
@@ -59,6 +61,10 @@ var RemultAsyncLocalStorage = /** @class */ (function () {
         if (val || ((_b = this.remultObjectStorage) === null || _b === void 0 ? void 0 : _b.isStub))
             store.inInitRequest = val;
     };
+    RemultAsyncLocalStorage.prototype.createDataProviderAsyncLocalStorage = function () {
+        var _a;
+        return (_a = this.remultObjectStorage) === null || _a === void 0 ? void 0 : _a.createDataProviderAsyncLocalStorage();
+    };
     RemultAsyncLocalStorage.prototype.getStore = function () {
         if (!this.remultObjectStorage) {
             throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
@@ -109,8 +115,8 @@ var Remult = /** @class */ (function () {
             }
             return r;
         };
-        /** The current data provider */
-        this.dataProvider = new rest_data_provider_js_1.RestDataProvider(function () { return _this.apiClient; });
+        /* @internal */
+        this._myDataProviderStore = new RemultInstanceDataProviderStore(new rest_data_provider_js_1.RestDataProvider(function () { return _this.apiClient; }));
         /* @internal */
         this.repCache = new Map();
         /* @internal*/
@@ -287,6 +293,17 @@ var Remult = /** @class */ (function () {
             httpClient: fetch,
         }); });
     };
+    Object.defineProperty(Remult.prototype, "dataProvider", {
+        get: function () {
+            return this._myDataProviderStore.getStore().dataProvider;
+        },
+        /** The current data provider */
+        set: function (dataProvider) {
+            this._myDataProviderStore.getStore().dataProvider = dataProvider;
+        },
+        enumerable: false,
+        configurable: true
+    });
     //@ts-ignore // type error of typescript regarding args that doesn't appear in my normal development
     /** Used to call a `backendMethod` using a specific `remult` object
      * @example
@@ -434,15 +451,24 @@ function doTransaction(remult, what) {
                 case 1:
                     _a.trys.push([1, , 5, 6]);
                     return [4 /*yield*/, remult.dataProvider.transaction(function (ds) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var _this = this;
                             return tslib_1.__generator(this, function (_a) {
                                 switch (_a.label) {
-                                    case 0:
-                                        remult.dataProvider = ds;
-                                        remult.liveQueryPublisher = trans;
-                                        return [4 /*yield*/, what(ds)];
+                                    case 0: return [4 /*yield*/, withRemultDataProvider({ dataProvider: ds, remult: remult }, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                            return tslib_1.__generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0:
+                                                        remult.liveQueryPublisher = trans;
+                                                        return [4 /*yield*/, what(ds)];
+                                                    case 1:
+                                                        _a.sent();
+                                                        ok = true;
+                                                        return [2 /*return*/];
+                                                }
+                                            });
+                                        }); })];
                                     case 1:
                                         _a.sent();
-                                        ok = true;
                                         return [2 /*return*/];
                                 }
                             });
@@ -549,20 +575,87 @@ var transactionLiveQueryPublisher = /** @class */ (function () {
 }());
 function withRemult(callback, options) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var remult, _a;
+        var remult;
         var _this = this;
-        return tslib_1.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    remult = new Remult();
-                    _a = remult;
-                    return [4 /*yield*/, (0, initDataProvider_js_1.initDataProvider)(options === null || options === void 0 ? void 0 : options.dataProvider, true, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-                            return [2 /*return*/, remult.dataProvider];
-                        }); }); })];
-                case 1:
-                    _a.dataProvider = _b.sent();
-                    return [2 /*return*/, remult_static_js_1.remultStatic.asyncContext.run(remult, function (r) { return callback(r); })];
-            }
+        return tslib_1.__generator(this, function (_a) {
+            remult = new Remult();
+            return [2 /*return*/, remult_static_js_1.remultStatic.asyncContext.run(remult, function (r) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var _a;
+                    var _this = this;
+                    return tslib_1.__generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                _a = remult;
+                                return [4 /*yield*/, (0, initDataProvider_js_1.initDataProvider)(options === null || options === void 0 ? void 0 : options.dataProvider, true, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                                        return [2 /*return*/, remult.dataProvider];
+                                    }); }); })];
+                            case 1:
+                                _a.dataProvider = _b.sent();
+                                return [4 /*yield*/, callback(r)];
+                            case 2: return [2 /*return*/, _b.sent()];
+                        }
+                    });
+                }); })];
         });
     });
 }
+var RemultInstanceDataProviderStore = /** @class */ (function () {
+    function RemultInstanceDataProviderStore(dataProvider) {
+        var _this = this;
+        this.getStore = function () { return _this._myDataProviderStore; };
+        this._myDataProviderStore = { dataProvider: dataProvider };
+    }
+    RemultInstanceDataProviderStore.prototype.withDataProvider = function (dataProvider, callback) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var prev;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.asyncStore) {
+                            this.asyncStore =
+                                remult_static_js_1.remultStatic.asyncContext.createDataProviderAsyncLocalStorage();
+                            if (this.asyncStore) {
+                                this.getStore = function () { var _a; return (_a = _this.asyncStore.getStore()) !== null && _a !== void 0 ? _a : _this._myDataProviderStore; };
+                            }
+                        }
+                        if (!this.asyncStore) return [3 /*break*/, 1];
+                        return [2 /*return*/, this.asyncStore.run({ dataProvider: dataProvider }, 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*/, callback()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); })];
+                    case 1:
+                        prev = this._myDataProviderStore;
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, , 4, 5]);
+                        this._myDataProviderStore = { dataProvider: dataProvider };
+                        return [4 /*yield*/, callback()];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        this._myDataProviderStore = prev;
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return RemultInstanceDataProviderStore;
+}());
+exports.RemultInstanceDataProviderStore = RemultInstanceDataProviderStore;
+function withRemultDataProvider(_a, callback) {
+    var dataProvider = _a.dataProvider, remult = _a.remult;
+    remult = remult !== null && remult !== void 0 ? remult : remult_static_js_1.remultStatic.remultFactory();
+    return remult._myDataProviderStore.withDataProvider(dataProvider, callback);
+}
+function withFetch(fetch, callback) {
+    var remult = remult_static_js_1.remultStatic.remultFactory();
+    return withRemultDataProvider({
+        remult: remult,
+        dataProvider: new rest_data_provider_js_1.RestDataProvider(function () { return (tslib_1.__assign(tslib_1.__assign({}, remult.apiClient), { httpClient: fetch })); }),
+    }, callback);
+}

package/src/remult-proxy.js

@@ -379,6 +379,14 @@ var RemultProxy = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(RemultProxy.prototype, "_myDataProviderStore", {
+        /** @internal */
+        get: function () {
+            return remult_static_js_1.remultStatic.remultFactory()._myDataProviderStore;
+        },
+        enumerable: false,
+        configurable: true
+    });
     return RemultProxy;
 }());
 exports.RemultProxy = RemultProxy;