remult 0.17.2 → 0.18.0

package/server/expressBridge.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JobsInQueueEntity = exports.EntityQueueStorage = exports.RemultAsyncLocalStorage = exports.createRemultServerCore = void 0;
+exports.JobsInQueueEntity = exports.EntityQueueStorage = exports.RemultServerImplementation = exports.RemultAsyncLocalStorage = exports.createRemultServerCore = void 0;
 var tslib_1 = require("tslib");
 var server_action_1 = require("../src/server-action");
 var data_api_1 = require("../src/data-api");
@@ -8,12 +8,19 @@ var context_1 = require("../src/context");
 var remult3_1 = require("../src/remult3");
 var id_entity_1 = require("../src/id-entity");
 var remult_proxy_1 = require("../src/remult-proxy");
+var SubscriptionServer_1 = require("../src/live-query/SubscriptionServer");
+var SubscriptionChannel_1 = require("../src/live-query/SubscriptionChannel");
+var initDataProvider_1 = require("./initDataProvider");
+var SseSubscriptionServer_1 = require("../SseSubscriptionServer");
 ;
 function createRemultServerCore(options) {
     var _this = this;
     if (!options) {
         options = {};
     }
+    if (!options.subscriptionServer) {
+        options.subscriptionServer = new SseSubscriptionServer_1.SseSubscriptionServer();
+    }
     if (options.logApiEndPoints === undefined)
         options.logApiEndPoints = true;
     server_action_1.actionInfo.runningOnServer = true;
@@ -23,51 +30,116 @@ function createRemultServerCore(options) {
     if (!options.queueStorage) {
         options.queueStorage = new InMemoryQueueStorage();
     }
-    var dataProvider;
-    if (typeof options.dataProvider === "function") {
-        dataProvider = options.dataProvider();
-    }
-    else
-        dataProvider = Promise.resolve(options.dataProvider);
+    var dataProvider = initDataProvider_1.initDataProvider(options.dataProvider);
+    if (options.ensureSchema === undefined)
+        options.ensureSchema = true;
+    RemultAsyncLocalStorage.enable();
     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:
-                    if (dp)
-                        return [2 /*return*/, dp];
-                    return [4 /*yield*/, Promise.resolve().then(function () { return require('./JsonEntityFileStorage'); })];
-                case 1: return [2 /*return*/, new (_a.sent()).JsonFileDataProvider('./db')];
+                    remult = new context_1.Remult(dp);
+                    return [4 /*yield*/, new Promise(function (res) {
+                            RemultAsyncLocalStorage.instance.run(remult, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var started_1, startConsoleLog, entitiesMetadata, _a, _b, item, e_1_1;
+                                var e_1, _c;
+                                return tslib_1.__generator(this, function (_d) {
+                                    switch (_d.label) {
+                                        case 0:
+                                            if (!options.ensureSchema) return [3 /*break*/, 10];
+                                            started_1 = false;
+                                            startConsoleLog = function () {
+                                                if (started_1)
+                                                    return;
+                                                started_1 = true;
+                                                console.time("Ensure Schema");
+                                            };
+                                            if (!dp.ensureSchema) return [3 /*break*/, 2];
+                                            startConsoleLog();
+                                            entitiesMetadata = options.entities.map(function (e) { return remult.repo(e).metadata; });
+                                            return [4 /*yield*/, dp.ensureSchema(entitiesMetadata)];
+                                        case 1:
+                                            _d.sent();
+                                            _d.label = 2;
+                                        case 2:
+                                            _d.trys.push([2, 7, 8, 9]);
+                                            _a = tslib_1.__values([options.liveQueryStorage, options.queueStorage]), _b = _a.next();
+                                            _d.label = 3;
+                                        case 3:
+                                            if (!!_b.done) return [3 /*break*/, 6];
+                                            item = _b.value;
+                                            if (!(item === null || item === void 0 ? void 0 : item.ensureSchema)) return [3 /*break*/, 5];
+                                            startConsoleLog();
+                                            return [4 /*yield*/, item.ensureSchema()];
+                                        case 4:
+                                            _d.sent();
+                                            _d.label = 5;
+                                        case 5:
+                                            _b = _a.next();
+                                            return [3 /*break*/, 3];
+                                        case 6: return [3 /*break*/, 9];
+                                        case 7:
+                                            e_1_1 = _d.sent();
+                                            e_1 = { error: e_1_1 };
+                                            return [3 /*break*/, 9];
+                                        case 8:
+                                            try {
+                                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                            }
+                                            finally { if (e_1) throw e_1.error; }
+                                            return [7 /*endfinally*/];
+                                        case 9:
+                                            if (started_1)
+                                                console.timeEnd("Ensure Schema");
+                                            _d.label = 10;
+                                        case 10:
+                                            if (!options.initApi) return [3 /*break*/, 12];
+                                            return [4 /*yield*/, options.initApi(remult)];
+                                        case 11:
+                                            _d.sent();
+                                            _d.label = 12;
+                                        case 12:
+                                            res({});
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); });
+                        })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, dp];
             }
         });
     }); });
-    RemultAsyncLocalStorage.enable();
-    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*/, new Promise(function (res) {
-                                RemultAsyncLocalStorage.instance.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];
+    if (!options.requestSerializer) {
+        options.requestSerializer = {
+            toJson: function (x) {
+                var e_2, _a;
+                var r = {
+                    url: x.url
+                };
+                try {
+                    for (var _b = tslib_1.__values(['session', 'auth', 'user']), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var key = _c.value;
+                        if (x[key])
+                            r[key] = x[key];
+                    }
                 }
-            });
-        }); });
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return r;
+            },
+            fromJson: function (x) {
+                return x;
+            }
+        };
     }
     {
         var allControllers = [];
@@ -119,16 +191,90 @@ var RemultAsyncLocalStorage = /** @class */ (function () {
     return RemultAsyncLocalStorage;
 }());
 exports.RemultAsyncLocalStorage = RemultAsyncLocalStorage;
+/* @internal*/
 var RemultServerImplementation = /** @class */ (function () {
     function RemultServerImplementation(queue, options, dataProvider) {
+        var _this = this;
         this.queue = queue;
         this.options = options;
         this.dataProvider = dataProvider;
+        this.liveQueryStorage = new SubscriptionServer_1.InMemoryLiveQueryStorage();
+        this.runWithRequest = function (req, entityKey, what) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _loop_1, _a, _b, e, state_1, e_3_1;
+            var e_3, _c;
+            var _this = this;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _loop_1 = function (e) {
+                            var key;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        key = remult3_1.getEntityKey(e);
+                                        if (!(key === entityKey)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, new Promise(function (result) {
+                                                _this.withRemult(_this.options.requestSerializer.fromJson(req), undefined, 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*/, what(remult_proxy_1.remult.repo(e))];
+                                                            case 1:
+                                                                _a.sent();
+                                                                result({});
+                                                                return [2 /*return*/];
+                                                        }
+                                                    });
+                                                }); });
+                                            })];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/, { value: void 0 }];
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        _a = tslib_1.__values(this.options.entities), _b = _a.next();
+                        _d.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        e = _b.value;
+                        return [5 /*yield**/, _loop_1(e)];
+                    case 3:
+                        state_1 = _d.sent();
+                        if (typeof state_1 === "object")
+                            return [2 /*return*/, state_1.value];
+                        _d.label = 4;
+                    case 4:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_3_1 = _d.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 8: throw new Error("Couldn't find entity " + entityKey);
+                }
+            });
+        }); };
         this.registeredRouter = false;
         this.hasQueue = false;
         /* internal */
         this.backendMethodsOpenApi = [];
+        if (options.liveQueryStorage)
+            this.liveQueryStorage = options.liveQueryStorage;
+        if (options.subscriptionServer)
+            this.subscriptionServer = options.subscriptionServer;
     }
+    ;
     RemultServerImplementation.prototype.withRemult = function (req, res, next) {
         var _this = this;
         this.process(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
@@ -136,15 +282,18 @@ var RemultServerImplementation = /** @class */ (function () {
             return [2 /*return*/];
         }); }); })(req, res);
     };
-    RemultServerImplementation.prototype.handle = function (req, gRes) {
+    RemultServerImplementation.prototype.getRouteImpl = function () {
         if (!this.routeImpl) {
             this.routeImpl = new RouteImplementation();
             this.registerRouter(this.routeImpl);
         }
-        return this.routeImpl.handle(req, gRes);
+        return this.routeImpl;
+    };
+    RemultServerImplementation.prototype.handle = function (req, gRes) {
+        return this.getRouteImpl().handle(req, gRes);
     };
     RemultServerImplementation.prototype.registerRouter = function (r) {
-        var e_1, _a, e_2, _b;
+        var e_4, _a, e_5, _b;
         var _this = this;
         if (this.registeredRouter)
             throw "Router already registered";
@@ -156,7 +305,7 @@ var RemultServerImplementation = /** @class */ (function () {
                     var z = c[server_action_1.classBackendMethodsArray];
                     if (z)
                         try {
-                            for (var z_1 = (e_2 = void 0, tslib_1.__values(z)), z_1_1 = z_1.next(); !z_1_1.done; z_1_1 = z_1.next()) {
+                            for (var z_1 = (e_5 = void 0, tslib_1.__values(z)), z_1_1 = z_1.next(); !z_1_1.done; z_1_1 = z_1.next()) {
                                 var a = z_1_1.value;
                                 var x = a[server_action_1.serverActionField];
                                 if (!x) {
@@ -165,21 +314,21 @@ var RemultServerImplementation = /** @class */ (function () {
                                 this.addAction(x, r);
                             }
                         }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
                         finally {
                             try {
                                 if (z_1_1 && !z_1_1.done && (_b = z_1.return)) _b.call(z_1);
                             }
-                            finally { if (e_2) throw e_2.error; }
+                            finally { if (e_5) throw e_5.error; }
                         }
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
             finally {
                 try {
                     if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                 }
-                finally { if (e_1) throw e_1.error; }
+                finally { if (e_4) throw e_4.error; }
             }
             if (this.hasQueue)
                 this.addAction({
@@ -207,6 +356,40 @@ var RemultServerImplementation = /** @class */ (function () {
                     },
                     doWork: undefined
                 }, r);
+            if (this.options.subscriptionServer instanceof SseSubscriptionServer_1.SseSubscriptionServer) {
+                var streamPath = this.options.rootPath + '/' + SubscriptionChannel_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, req, res, origReq, origRes) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    return tslib_1.__generator(this, function (_a) {
+                        remult.subscriptionServer.subscribeToChannel(origReq.body, res, remult);
+                        return [2 /*return*/];
+                    });
+                }); }));
+                r.route(streamPath + '/unsubscribe').post(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.subscribeToChannel(origReq.body, res, remult, true);
+                        return [2 /*return*/];
+                    });
+                }); }));
+            }
+            r.route(this.options.rootPath + '/' + SubscriptionChannel_1.liveQueryKeepAliveRoute).post(this.process(function (remult, req, res, origReq, origRes) { 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 = res).success;
+                            return [4 /*yield*/, remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(origReq.body)];
+                        case 1:
+                            _b.apply(_a, [_c.sent()]);
+                            return [2 /*return*/];
+                    }
+                });
+            }); }));
         }
         this.options.entities.forEach(function (e) {
             var key = remult3_1.getEntityKey(e);
@@ -220,19 +403,22 @@ var RemultServerImplementation = /** @class */ (function () {
         var _this = this;
         var myRoute = this.options.rootPath + '/' + key;
         if (this.options.logApiEndPoints)
-            console.log("[remult] " + myRoute);
+            console.info("[remult] " + myRoute);
         r.route(myRoute)
-            .get(this.process(function (c, req, res) {
-            return dataApiFactory(c).httpGet(res, req);
+            .get(this.process(function (c, req, res, orig) {
+            return dataApiFactory(c).httpGet(res, req, function () { return _this.options.requestSerializer.toJson(orig); });
         })).put(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
             return [2 /*return*/, dataApiFactory(c).put(res, '', orig.body)];
         }); }); }))
             .delete(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
             return [2 /*return*/, dataApiFactory(c).delete(res, '')];
         }); }); }))
-            .post(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-            return [2 /*return*/, dataApiFactory(c).httpPost(res, req, orig.body)];
-        }); }); }));
+            .post(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, dataApiFactory(c).httpPost(res, req, orig.body, function () { return _this.options.requestSerializer.toJson(orig); })];
+            });
+        }); }));
         r.route(myRoute + '/:id')
             //@ts-ignore
             .get(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
@@ -249,19 +435,22 @@ 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 () {
+        return function (req, origRes) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var myReq, myRes, remult, _a;
             var _this = this;
             return tslib_1.__generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         myReq = new ExpressRequestBridgeToDataApiRequest(req);
-                        myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
+                        myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req);
                         remult = new context_1.Remult();
+                        remult.liveQueryPublisher = new SubscriptionServer_1.LiveQueryPublisher(function () { return remult.subscriptionServer; }, function () { return remult.liveQueryStorage; }, this.runWithRequest);
                         _a = remult;
                         return [4 /*yield*/, this.dataProvider];
                     case 1:
                         _a.dataProvider = (_b.sent());
+                        remult.subscriptionServer = this.subscriptionServer;
+                        remult.liveQueryStorage = this.liveQueryStorage;
                         return [4 /*yield*/, new Promise(function (res) {
                                 RemultAsyncLocalStorage.instance.run(remult, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                                     var user;
@@ -286,11 +475,19 @@ var RemultServerImplementation = /** @class */ (function () {
                                                 _a.label = 4;
                                             case 4:
                                                 if (!this.options.initRequest) return [3 /*break*/, 6];
-                                                return [4 /*yield*/, this.options.initRequest(remult, req)];
+                                                return [4 /*yield*/, this.options.initRequest(req, {
+                                                        remult: remult,
+                                                        get liveQueryStorage() {
+                                                            return remult.liveQueryStorage;
+                                                        },
+                                                        set liveQueryStorage(value) {
+                                                            remult.liveQueryStorage = value;
+                                                        }
+                                                    })];
                                             case 5:
                                                 _a.sent();
                                                 _a.label = 6;
-                                            case 6: return [4 /*yield*/, what(remult, myReq, myRes, req)];
+                                            case 6: return [4 /*yield*/, what(remult, myReq, myRes, req, origRes)];
                                             case 7:
                                                 _a.sent();
                                                 res({});
@@ -339,7 +536,7 @@ var RemultServerImplementation = /** @class */ (function () {
             })();
             _this.backendMethodsOpenApi.push({ path: myUrl, allowed: allowed, tag: tag });
             if (_this.options.logApiEndPoints)
-                console.log("[remult] " + myUrl);
+                console.info("[remult] " + myUrl);
             if (queue) {
                 _this.hasQueue = true;
                 _this.queue.mapQueuedAction(myUrl, what);
@@ -366,7 +563,7 @@ var RemultServerImplementation = /** @class */ (function () {
         });
     };
     RemultServerImplementation.prototype.openApiDoc = function (options) {
-        var e_3, _a, e_4, _b;
+        var e_6, _a, e_7, _b;
         var r = new context_1.Remult();
         if (!options.version)
             options.version = "1.0.0";
@@ -416,15 +613,15 @@ var RemultServerImplementation = /** @class */ (function () {
                 return item;
             }
         };
-        var _loop_1 = function (e) {
-            var e_5, _a;
+        var _loop_2 = function (e) {
+            var e_8, _a;
             var meta = r.repo(e).metadata;
             var key = remult3_1.getEntityKey(e);
             var parameters = [];
             if (key) {
                 var properties = {};
                 try {
-                    for (var _b = (e_5 = void 0, tslib_1.__values(meta.fields)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    for (var _b = (e_8 = void 0, tslib_1.__values(meta.fields)), _c = _b.next(); !_c.done; _c = _b.next()) {
                         var f = _c.value;
                         var type = f.valueType == String ? "string" :
                             f.valueType == Boolean ? "boolean" :
@@ -452,12 +649,12 @@ var RemultServerImplementation = /** @class */ (function () {
                         });
                     }
                 }
-                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
                 finally {
                     try {
                         if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                     }
-                    finally { if (e_5) throw e_5.error; }
+                    finally { if (e_8) throw e_8.error; }
                 }
                 spec.components.schemas[key] = {
                     type: "object",
@@ -597,15 +794,15 @@ var RemultServerImplementation = /** @class */ (function () {
         try {
             for (var _c = tslib_1.__values(this.options.entities), _d = _c.next(); !_d.done; _d = _c.next()) {
                 var e = _d.value;
-                _loop_1(e);
+                _loop_2(e);
             }
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
         finally {
             try {
                 if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
             }
-            finally { if (e_3) throw e_3.error; }
+            finally { if (e_6) throw e_6.error; }
         }
         try {
             for (var _e = tslib_1.__values(this.backendMethodsOpenApi), _f = _e.next(); !_f.done; _f = _e.next()) {
@@ -648,12 +845,12 @@ var RemultServerImplementation = /** @class */ (function () {
                 };
             }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
         finally {
             try {
                 if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
             }
-            finally { if (e_4) throw e_4.error; }
+            finally { if (e_7) throw e_7.error; }
         }
         spec.components.schemas["InvalidResponse"] = {
             "type": "object",
@@ -670,6 +867,7 @@ var RemultServerImplementation = /** @class */ (function () {
     };
     return RemultServerImplementation;
 }());
+exports.RemultServerImplementation = RemultServerImplementation;
 var ExpressRequestBridgeToDataApiRequest = /** @class */ (function () {
     function ExpressRequestBridgeToDataApiRequest(r) {
         this.r = r;
@@ -740,7 +938,11 @@ var inProcessQueueHandler = /** @class */ (function () {
                         this.actions.get(url)(body, req, {
                             error: function (error) { return job.setErrorResult(data_api_1.serializeError(error)); },
                             success: function (result) { return job.setResult(result); },
-                            progress: function (progress) { return job.setProgress(progress); }
+                            progress: function (progress) { return job.setProgress(progress); },
+                            created: function () { throw Error("Created response not expected for queue"); },
+                            deleted: function () { throw Error("deleted response not expected for queue"); },
+                            notFound: function () { throw Error("notFound response not expected for queue"); },
+                            forbidden: function () { return job.setErrorResult("Forbidden"); }
                         });
                         return [2 /*return*/, id];
                 }
@@ -954,6 +1156,18 @@ var RouteImplementation = /** @class */ (function () {
                             function class_1() {
                                 this.statusCode = 200;
                             }
+                            class_1.prototype.write = function (data) {
+                                gRes.write(data);
+                            };
+                            class_1.prototype.writeHead = function (statusCode, headers) {
+                                gRes.writeHead(statusCode, headers);
+                                this.statusCode = statusCode;
+                                res({ statusCode: statusCode });
+                            };
+                            class_1.prototype.flush = function () {
+                                if (gRes.flush)
+                                    gRes.flush();
+                            };
                             class_1.prototype.json = function (data) {
                                 if (gRes !== undefined)
                                     gRes.json(data);

package/server/index.d.ts

@@ -1,4 +1,5 @@
 import { GenericRequest, RemultServer, RemultServerOptions } from './expressBridge';
-export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
+export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
 export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;

package/server/index.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRemultServer = exports.JsonFileDataProvider = exports.JsonEntityFileStorage = void 0;
+exports.createRemultServer = exports.DataProviderLiveQueryStorage = exports.JsonFileDataProvider = exports.JsonEntityFileStorage = void 0;
 var expressBridge_1 = require("./expressBridge");
 var initAsyncHooks_1 = require("./initAsyncHooks");
 var JsonEntityFileStorage_1 = require("./JsonEntityFileStorage");
 Object.defineProperty(exports, "JsonEntityFileStorage", { enumerable: true, get: function () { return JsonEntityFileStorage_1.JsonEntityFileStorage; } });
 Object.defineProperty(exports, "JsonFileDataProvider", { enumerable: true, get: function () { return JsonEntityFileStorage_1.JsonFileDataProvider; } });
+var data_provider_live_query_storage_1 = require("../live-query/data-provider-live-query-storage");
+Object.defineProperty(exports, "DataProviderLiveQueryStorage", { enumerable: true, get: function () { return data_provider_live_query_storage_1.DataProviderLiveQueryStorage; } });
 function createRemultServer(options) {
     initAsyncHooks_1.initAsyncHooks();
     return expressBridge_1.createRemultServerCore(options);

package/server/initDataProvider.d.ts

@@ -0,0 +1,2 @@
+import { DataProvider } from '../src/data-interfaces';
+export declare function initDataProvider(optionsDataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>)): Promise<DataProvider>;

package/server/initDataProvider.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDataProvider = void 0;
+var tslib_1 = require("tslib");
+function initDataProvider(optionsDataProvider) {
+    var _this = this;
+    var dataProvider;
+    if (typeof optionsDataProvider === "function") {
+        dataProvider = optionsDataProvider();
+    }
+    else
+        dataProvider = Promise.resolve(optionsDataProvider);
+    dataProvider = dataProvider.then(function (dp) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (dp)
+                        return [2 /*return*/, dp];
+                    return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('./JsonEntityFileStorage')); })];
+                case 1: return [2 /*return*/, new (_a.sent()).JsonFileDataProvider('./db')];
+            }
+        });
+    }); });
+    return dataProvider;
+}
+exports.initDataProvider = initDataProvider;

package/src/buildRestDataProvider.d.ts

@@ -0,0 +1,31 @@
+import { RestDataProviderHttpProvider } from "./data-interfaces";
+import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
+export declare function buildRestDataProvider(provider: ExternalHttpProvider | typeof fetch): RestDataProviderHttpProviderUsingFetch | RestDataProviderHttpProvider;
+export declare function isExternalHttpProvider(item: any): boolean;
+export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements RestDataProviderHttpProvider {
+    private http;
+    constructor(http: ExternalHttpProvider);
+    post(url: string, data: any): Promise<any>;
+    delete(url: string): Promise<void>;
+    put(url: string, data: any): Promise<any>;
+    get(url: string): Promise<any>;
+}
+export declare function retry<T>(what: () => Promise<T>): Promise<T>;
+export declare function toPromise<T>(p: Promise<T> | {
+    toPromise(): Promise<T>;
+}): Promise<any>;
+export declare function processHttpException(ex: any): Promise<any>;
+export interface ExternalHttpProvider {
+    post(url: string, data: any): Promise<any> | {
+        toPromise(): Promise<any>;
+    };
+    delete(url: string): Promise<void> | {
+        toPromise(): Promise<void>;
+    };
+    put(url: string, data: any): Promise<any> | {
+        toPromise(): Promise<any>;
+    };
+    get(url: string): Promise<any> | {
+        toPromise(): Promise<any>;
+    };
+}