remult 3.3.17-next.0 → 3.3.18-next.0

package/SseSubscriptionServer.d.ts

@@ -1,9 +1,8 @@
 import type { GenericResponse } from './server/index.js';
-import type { SubscriptionServerRouteApi, SubscriptionServerWithRoutes } from './server/remult-api-server.js';
 import type { Remult } from './src/context.js';
-export declare class SseSubscriptionServer implements SubscriptionServerWithRoutes {
+import type { SubscriptionServer } from './src/live-query/SubscriptionServer.js';
+export declare class SseSubscriptionServer implements SubscriptionServer {
     private canUserConnectToChannel?;
-    initApiServer(api: SubscriptionServerRouteApi): void;
     constructor(canUserConnectToChannel?: ((channel: string, remult: Remult) => boolean) | undefined);
     publishMessage<T>(channel: string, message: any): Promise<void>;
 }

package/SseSubscriptionServer.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.clientConnection = exports.SseSubscriptionServer = void 0;
 var tslib_1 = require("tslib");
 var SseSubscriptionClient_js_1 = require("./src/live-query/SseSubscriptionClient.js");
-var SubscriptionChannel_js_1 = require("./src/live-query/SubscriptionChannel.js");
 var SseSubscriptionServer = /** @class */ (function () {
     function SseSubscriptionServer(canUserConnectToChannel) {
         this.canUserConnectToChannel = canUserConnectToChannel;
@@ -17,45 +16,6 @@ var SseSubscriptionServer = /** @class */ (function () {
             this.canUserConnectToChannel = function () { return true; };
         }
     }
-    SseSubscriptionServer.prototype.initApiServer = function (api) {
-        var _this = this;
-        var streamPath = '/' + SubscriptionChannel_js_1.streamUrl;
-        api.addRoute(streamPath, 'get', function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
-            var req = _b.req, origRes = _b.origRes;
-            return tslib_1.__generator(this, function (_c) {
-                this.openHttpServerStream(req, origRes);
-                return [2 /*return*/];
-            });
-        }); });
-        api.addRoute(streamPath + '/subscribe', 'post', function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
-            var _c;
-            var remult = _b.remult, res = _b.res, getBody = _b.getBody;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _c = this.subscribeToChannel;
-                        return [4 /*yield*/, getBody()];
-                    case 1:
-                        _c.apply(this, [_d.sent(), res, remult]);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        api.addRoute(streamPath + '/unsubscribe', 'post', function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
-            var _c;
-            var remult = _b.remult, res = _b.res, getBody = _b.getBody;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _c = this.subscribeToChannel;
-                        return [4 /*yield*/, getBody()];
-                    case 1:
-                        _c.apply(this, [_d.sent(), res, remult, true]);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    };
     //@internal
     SseSubscriptionServer.prototype.subscribeToChannel = function (_a, res, remult, remove) {
         var e_1, _b;

package/esm/SseSubscriptionServer.js

@@ -1,19 +1,6 @@
 import { ConnectionNotFoundError } from './src/live-query/SseSubscriptionClient.js';
-import { streamUrl } from './src/live-query/SubscriptionChannel.js';
 export class SseSubscriptionServer {
     canUserConnectToChannel;
-    initApiServer(api) {
-        const streamPath = '/' + streamUrl;
-        api.addRoute(streamPath, 'get', async ({ req, origRes }) => {
-            this.openHttpServerStream(req, origRes);
-        });
-        api.addRoute(streamPath + '/subscribe', 'post', async ({ remult, res, getBody }) => {
-            this.subscribeToChannel(await getBody(), res, remult);
-        });
-        api.addRoute(streamPath + '/unsubscribe', 'post', async ({ remult, res, getBody }) => {
-            this.subscribeToChannel(await getBody(), res, remult, true);
-        });
-    }
     //@internal
     subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
         for (const c of this.connections) {

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/remult-api-server.js

@@ -2,7 +2,7 @@ import { __decorate, __metadata } from "tslib";
 import { SseSubscriptionServer } from '../SseSubscriptionServer.js';
 import { Remult, RemultAsyncLocalStorage, withRemult } from '../src/context.js';
 import { DataApi, serializeError } from '../src/data-api.js';
-import { liveQueryKeepAliveRoute } from '../src/live-query/SubscriptionChannel.js';
+import { liveQueryKeepAliveRoute, streamUrl, } from '../src/live-query/SubscriptionChannel.js';
 import { InMemoryLiveQueryStorage, LiveQueryPublisher, } from '../src/live-query/SubscriptionServer.js';
 import { IdEntity } from '../src/remult3/IdEntity.js';
 import { Fields } from '../src/remult3/Fields.js';
@@ -266,20 +266,19 @@ export class RemultServerImplementation {
                 r.route(this.options.rootPath + '/admin').get(admin());
             }
             r.route(this.options.rootPath + '/me').get(this.process(async (remult, req, res) => res.success(remult.user ?? null)));
-            const subscriptionServer = this.options.subscriptionServer;
-            if (isOfType(subscriptionServer, 'initApiServer')) {
-                subscriptionServer.initApiServer({
-                    rootPath: this.options.rootPath,
-                    addRoute: (relativePath, method, handler) => {
-                        r.route(this.options.rootPath + relativePath)[method](this.process(async (remult, _, res, req, origRes, origReq) => handler({
-                            remult,
-                            res,
-                            req,
-                            origRes,
-                            getBody: () => this.coreOptions.getRequestBody(origReq),
-                        })));
-                    },
-                });
+            if (this.options.subscriptionServer instanceof SseSubscriptionServer) {
+                const streamPath = this.options.rootPath + '/' + streamUrl;
+                r.route(streamPath).get(this.process(async (remult, req, res, origReq, origRes) => {
+                    ;
+                    remult.subscriptionServer.openHttpServerStream(origReq, origRes);
+                }));
+                r.route(streamPath + '/subscribe').post(this.process(async (remult, _2, res, _, _1, origReq) => {
+                    const body = remult.subscriptionServer.subscribeToChannel(await this.coreOptions.getRequestBody(origReq), res, remult);
+                }));
+                r.route(streamPath + '/unsubscribe').post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
+                    ;
+                    remult.subscriptionServer.subscribeToChannel(await this.coreOptions.getRequestBody(origReq), res, remult, true);
+                }));
             }
             r.route(this.options.rootPath + '/' + liveQueryKeepAliveRoute).post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
                 res.success(await remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(await this.coreOptions.getRequestBody(origReq)));

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/esm/src/remult3/RepositoryImplementation.js

@@ -1698,8 +1698,10 @@ export class rowHelperImplementation extends rowHelperBase {
                 }
             }
             else if (!getRelationFieldInfo(col))
-                if (data[col.key] === undefined)
-                    delete this.instance[col.key];
+                if (data[col.key] === undefined) {
+                    if (!Reflect.deleteProperty(this.instance, col.key))
+                        this.instance[col.key] = undefined;
+                }
                 else
                     this.instance[col.key] = data[col.key];
         }

package/internals.d.ts

@@ -14,8 +14,7 @@ export declare const actionInfo: {
 };
 export { isOfType } from './src/isOfType.js';
 export type { ClassType } from './classType.js';
-export type { SubscriptionServerWithRoutes, SubscriptionServerRouteApi, SubscriptionServerRouteHandlerArgs, } from './server/remult-api-server.js';
-export type { DataApiResponse } from './src/data-api.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-next.0",
+    "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/remult-api-server.d.ts

@@ -1,7 +1,6 @@
 import type { ClassType } from '../classType.js';
 import type { Allowed, UserInfo } from '../src/context.js';
 import { Remult } from '../src/context.js';
-import type { DataApiResponse } from '../src/data-api.js';
 import type { DataProvider } from '../src/data-interfaces.js';
 import type { LiveQueryStorage, SubscriptionServer } from '../src/live-query/SubscriptionServer.js';
 import { IdEntity } from '../src/remult3/IdEntity.js';
@@ -168,22 +167,6 @@ export interface GenericResponse {
     status(statusCode: number): GenericResponse;
     end(): void;
 }
-/** A `SubscriptionServer` that also needs to serve http routes (for example SSE),
- * can implement this interface to register them on the api server */
-export interface SubscriptionServerWithRoutes extends SubscriptionServer {
-    initApiServer(api: SubscriptionServerRouteApi): void;
-}
-export interface SubscriptionServerRouteApi {
-    rootPath: string;
-    addRoute(relativePath: string, method: 'get' | 'post', handler: (args: SubscriptionServerRouteHandlerArgs) => Promise<void>): void;
-}
-export interface SubscriptionServerRouteHandlerArgs {
-    remult: Remult;
-    res: DataApiResponse;
-    req: GenericRequestInfo;
-    origRes: GenericResponse;
-    getBody(): Promise<any>;
-}
 export interface queuedJobInfo {
     info: queuedJobInfoResponse;
     userId: string;

package/server/remult-api-server.js

@@ -441,25 +441,45 @@ var RemultServerImplementation = /** @class */ (function () {
             r.route(this.options.rootPath + '/me').get(this.process(function (remult, req, res) { return tslib_1.__awaiter(_this, void 0, void 0, function () { var _a; return tslib_1.__generator(this, function (_b) {
                 return [2 /*return*/, res.success((_a = remult.user) !== null && _a !== void 0 ? _a : null)];
             }); }); }));
-            var subscriptionServer = this.options.subscriptionServer;
-            if ((0, isOfType_js_1.isOfType)(subscriptionServer, 'initApiServer')) {
-                subscriptionServer.initApiServer({
-                    rootPath: this.options.rootPath,
-                    addRoute: function (relativePath, method, handler) {
-                        r.route(_this.options.rootPath + relativePath)[method](_this.process(function (remult, _, res, req, origRes, origReq) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var _this = this;
-                            return tslib_1.__generator(this, function (_a) {
-                                return [2 /*return*/, handler({
-                                        remult: remult,
-                                        res: res,
-                                        req: req,
-                                        origRes: origRes,
-                                        getBody: function () { return _this.coreOptions.getRequestBody(origReq); },
-                                    })];
-                            });
-                        }); }));
-                    },
-                });
+            if (this.options.subscriptionServer instanceof SseSubscriptionServer_js_1.SseSubscriptionServer) {
+                var streamPath = this.options.rootPath + '/' + SubscriptionChannel_js_1.streamUrl;
+                r.route(streamPath).get(this.process(function (remult, req, res, origReq, origRes) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    return tslib_1.__generator(this, function (_a) {
+                        ;
+                        remult.subscriptionServer.openHttpServerStream(origReq, origRes);
+                        return [2 /*return*/];
+                    });
+                }); }));
+                r.route(streamPath + '/subscribe').post(this.process(function (remult, _2, res, _, _1, origReq) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var body, _a, _b;
+                    return tslib_1.__generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0:
+                                _b = (_a = remult.subscriptionServer).subscribeToChannel;
+                                return [4 /*yield*/, this.coreOptions.getRequestBody(origReq)];
+                            case 1:
+                                body = _b.apply(_a, [_c.sent(), res,
+                                    remult]);
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }));
+                r.route(streamPath + '/unsubscribe').post(this.process(function (remult, req, res, reqInfo, origRes, origReq) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var _a, _b;
+                    return tslib_1.__generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0:
+                                ;
+                                _b = (_a = remult.subscriptionServer).subscribeToChannel;
+                                return [4 /*yield*/, this.coreOptions.getRequestBody(origReq)];
+                            case 1:
+                                _b.apply(_a, [_c.sent(), res,
+                                    remult,
+                                    true]);
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }));
             }
             r.route(this.options.rootPath + '/' + SubscriptionChannel_js_1.liveQueryKeepAliveRoute).post(this.process(function (remult, req, res, reqInfo, origRes, origReq) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                 var _a, _b, _c, _d;

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;

package/src/remult3/RepositoryImplementation.js

@@ -2856,8 +2856,10 @@ var rowHelperImplementation = /** @class */ (function (_super) {
                     case 6: return [3 /*break*/, 8];
                     case 7:
                         if (!(0, relationInfoMember_js_1.getRelationFieldInfo)(col))
-                            if (data[col.key] === undefined)
-                                delete this.instance[col.key];
+                            if (data[col.key] === undefined) {
+                                if (!Reflect.deleteProperty(this.instance, col.key))
+                                    this.instance[col.key] = undefined;
+                            }
                             else
                                 this.instance[col.key] = data[col.key];
                         _d.label = 8;