remult 0.18.1-exp.21 → 0.18.1-exp.23

package/esm/live-query/DataProviderLiveQueryStorage.d.ts

@@ -0,0 +1,21 @@
+import { DataProvider } from "../src/data-interfaces";
+import { LiveQueryStorage, StoredQuery } from "../src/live-query/SubscriptionServer";
+import { Repository } from "../src/remult3";
+export declare class DataProviderLiveQueryStorage implements LiveQueryStorage {
+    repo: Promise<Repository<LiveQueryStorageEntity>>;
+    constructor(dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>));
+    add({ id, entityKey, data }: StoredQuery): void;
+    remove(queryId: string): void;
+    forEach(entityKey: string, callback: (args: {
+        query: StoredQuery;
+        setData(data: any): Promise<void>;
+    }) => Promise<void>): Promise<void>;
+    keepAliveAndReturnUnknownQueryIds(queryIds: string[]): Promise<string[]>;
+}
+declare class LiveQueryStorageEntity {
+    id: string;
+    entityKey: string;
+    data: any;
+    lastUsed: Date;
+}
+export {};

package/esm/live-query/DataProviderLiveQueryStorage.js

@@ -0,0 +1,71 @@
+import { __decorate, __metadata } from "tslib";
+import { initDataProvider } from "../server/initDataProvider";
+import { Remult } from "../src/context";
+import { Entity, Fields } from "../src/remult3";
+export class DataProviderLiveQueryStorage {
+    constructor(dataProvider) {
+        this.repo = initDataProvider(dataProvider).then(dp => new Remult(dp).repo(LiveQueryStorageEntity));
+    }
+    add({ id, entityKey, data }) {
+        this.repo.then(repo => repo.insert({
+            id, entityKey, data
+        }));
+    }
+    remove(queryId) {
+        this.repo.then(repo => repo.delete(queryId)).catch(() => { });
+    }
+    async forEach(entityKey, callback) {
+        const repo = await this.repo;
+        let d = new Date();
+        d.setMinutes(d.getMinutes() - 5);
+        for (const query of await repo.find({ where: { entityKey } })) {
+            if (query.lastUsed < d)
+                await repo.delete(query);
+            else {
+                await callback({
+                    query, setData: async (data) => {
+                        query.data = data;
+                        await repo.save(query);
+                    },
+                });
+            }
+        }
+    }
+    async keepAliveAndReturnUnknownQueryIds(queryIds) {
+        const repo = await this.repo;
+        for (const query of await repo.find({ where: { id: queryIds } })) {
+            query.lastUsed = new Date();
+            await repo.save(query);
+            queryIds = queryIds.filter(x => x !== query.id);
+        }
+        return queryIds;
+    }
+}
+let LiveQueryStorageEntity = class LiveQueryStorageEntity {
+    constructor() {
+        this.id = '';
+        this.entityKey = '';
+        this.lastUsed = new Date();
+    }
+};
+__decorate([
+    Fields.string(),
+    __metadata("design:type", Object)
+], LiveQueryStorageEntity.prototype, "id", void 0);
+__decorate([
+    Fields.string(),
+    __metadata("design:type", Object)
+], LiveQueryStorageEntity.prototype, "entityKey", void 0);
+__decorate([
+    Fields.object(),
+    __metadata("design:type", Object)
+], LiveQueryStorageEntity.prototype, "data", void 0);
+__decorate([
+    Fields.date(),
+    __metadata("design:type", Object)
+], LiveQueryStorageEntity.prototype, "lastUsed", void 0);
+LiveQueryStorageEntity = __decorate([
+    Entity(undefined, {
+        dbName: 'remult_live_query_storage'
+    })
+], LiveQueryStorageEntity);

package/esm/remult-express.js

@@ -3,7 +3,6 @@ import { createRemultServer } from './server/index';
 import { streamUrl } from './src/live-query/SubscriptionChannel';
 import { v4 as uuid } from 'uuid';
 import { remult } from './src/remult-proxy';
-import { getEntityKey } from './src/remult3';
 export function remultExpress(options) {
     let app = express.Router();
     if (!options) {
@@ -25,21 +24,6 @@ export function remultExpress(options) {
     if (canRegisterRoute.registerRoutes) {
         canRegisterRoute.registerRoutes(app, options.rootPath, server);
     }
-    server.runWithRequest = async (req, entityKey, what) => {
-        for (const e of options.entities) {
-            let key = getEntityKey(e);
-            if (key === entityKey) {
-                await new Promise((result) => {
-                    server.withRemult(options.requestSerializer.fromJson(req), undefined, async () => {
-                        await what(remult.repo(e));
-                        result({});
-                    });
-                });
-                return;
-            }
-        }
-        throw new Error("Couldn't find entity " + entityKey);
-    };
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),

package/esm/server/expressBridge.js

@@ -7,6 +7,7 @@ import { IdEntity } from '../src/id-entity';
 import { remult } from '../src/remult-proxy';
 import { LiveQueryPublisher, InMemoryLiveQueryStorage } from '../src/live-query/SubscriptionServer';
 import { liveQueryKeepAliveRoute } from '../src/live-query/SubscriptionChannel';
+import { initDataProvider } from './initDataProvider';
 ;
 export function createRemultServerCore(options) {
     if (!options) {
@@ -21,17 +22,7 @@ export function createRemultServerCore(options) {
     if (!options.queueStorage) {
         options.queueStorage = new InMemoryQueueStorage();
     }
-    let dataProvider;
-    if (typeof options.dataProvider === "function") {
-        dataProvider = options.dataProvider();
-    }
-    else
-        dataProvider = Promise.resolve(options.dataProvider);
-    dataProvider = dataProvider.then(async (dp) => {
-        if (dp)
-            return dp;
-        return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
-    });
+    let dataProvider = initDataProvider(options.dataProvider);
     RemultAsyncLocalStorage.enable();
     if (options.initApi) {
         dataProvider = dataProvider.then(async (dp) => {
@@ -116,6 +107,21 @@ export class RemultServerImplementation {
         this.options = options;
         this.dataProvider = dataProvider;
         this.liveQueryStorage = new InMemoryLiveQueryStorage();
+        this.runWithRequest = async (req, entityKey, what) => {
+            for (const e of this.options.entities) {
+                let key = getEntityKey(e);
+                if (key === entityKey) {
+                    await new Promise((result) => {
+                        this.withRemult(this.options.requestSerializer.fromJson(req), undefined, async () => {
+                            await what(remult.repo(e));
+                            result({});
+                        });
+                    });
+                    return;
+                }
+            }
+            throw new Error("Couldn't find entity " + entityKey);
+        };
         this.registeredRouter = false;
         this.hasQueue = false;
         /* internal */
@@ -125,6 +131,7 @@ export class RemultServerImplementation {
         if (options.subscriptionServer)
             this.subscriptionServer = options.subscriptionServer;
     }
+    ;
     withRemult(req, res, next) {
         this.process(async () => { next(); })(req, res);
     }

package/esm/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/esm/server/initDataProvider.js

@@ -0,0 +1,14 @@
+export function initDataProvider(optionsDataProvider) {
+    let dataProvider;
+    if (typeof optionsDataProvider === "function") {
+        dataProvider = optionsDataProvider();
+    }
+    else
+        dataProvider = Promise.resolve(optionsDataProvider);
+    dataProvider = dataProvider.then(async (dp) => {
+        if (dp)
+            return dp;
+        return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
+    });
+    return dataProvider;
+}

package/esm/src/live-query/SubscriptionServer.d.ts

@@ -3,7 +3,7 @@ export interface SubscriptionServer {
 }
 export interface LiveQueryStorage {
     add(query: StoredQuery): void;
-    remove(queryId: any): void;
+    remove(queryId: string): void;
     forEach(entityKey: string, callback: (args: {
         query: StoredQuery;
         setData(data: any): Promise<void>;

package/live-query/DataProviderLiveQueryStorage.d.ts

@@ -0,0 +1,21 @@
+import { DataProvider } from "../src/data-interfaces";
+import { LiveQueryStorage, StoredQuery } from "../src/live-query/SubscriptionServer";
+import { Repository } from "../src/remult3";
+export declare class DataProviderLiveQueryStorage implements LiveQueryStorage {
+    repo: Promise<Repository<LiveQueryStorageEntity>>;
+    constructor(dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>));
+    add({ id, entityKey, data }: StoredQuery): void;
+    remove(queryId: string): void;
+    forEach(entityKey: string, callback: (args: {
+        query: StoredQuery;
+        setData(data: any): Promise<void>;
+    }) => Promise<void>): Promise<void>;
+    keepAliveAndReturnUnknownQueryIds(queryIds: string[]): Promise<string[]>;
+}
+declare class LiveQueryStorageEntity {
+    id: string;
+    entityKey: string;
+    data: any;
+    lastUsed: Date;
+}
+export {};

package/live-query/DataProviderLiveQueryStorage.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataProviderLiveQueryStorage = void 0;
+var tslib_1 = require("tslib");
+var initDataProvider_1 = require("../server/initDataProvider");
+var context_1 = require("../src/context");
+var remult3_1 = require("../src/remult3");
+var DataProviderLiveQueryStorage = /** @class */ (function () {
+    function DataProviderLiveQueryStorage(dataProvider) {
+        this.repo = initDataProvider_1.initDataProvider(dataProvider).then(function (dp) {
+            return new context_1.Remult(dp).repo(LiveQueryStorageEntity);
+        });
+    }
+    DataProviderLiveQueryStorage.prototype.add = function (_a) {
+        var id = _a.id, entityKey = _a.entityKey, data = _a.data;
+        this.repo.then(function (repo) { return repo.insert({
+            id: id, entityKey: entityKey, data: data
+        }); });
+    };
+    DataProviderLiveQueryStorage.prototype.remove = function (queryId) {
+        this.repo.then(function (repo) { return repo.delete(queryId); }).catch(function () { });
+    };
+    DataProviderLiveQueryStorage.prototype.forEach = function (entityKey, callback) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var repo, d, _loop_1, _a, _b, query, e_1_1;
+            var e_1, _c;
+            var _this = this;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.repo];
+                    case 1:
+                        repo = _d.sent();
+                        d = new Date();
+                        d.setMinutes(d.getMinutes() - 5);
+                        _loop_1 = function (query) {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!(query.lastUsed < d)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, repo.delete(query)];
+                                    case 1:
+                                        _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 2: return [4 /*yield*/, callback({
+                                            query: query, setData: function (data) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                                return tslib_1.__generator(this, function (_a) {
+                                                    switch (_a.label) {
+                                                        case 0:
+                                                            query.data = data;
+                                                            return [4 /*yield*/, repo.save(query)];
+                                                        case 1:
+                                                            _a.sent();
+                                                            return [2 /*return*/];
+                                                    }
+                                                });
+                                            }); },
+                                        })];
+                                    case 3:
+                                        _a.sent();
+                                        _a.label = 4;
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 8, 9, 10]);
+                        return [4 /*yield*/, repo.find({ where: { entityKey: entityKey } })];
+                    case 3:
+                        _a = tslib_1.__values.apply(void 0, [_d.sent()]), _b = _a.next();
+                        _d.label = 4;
+                    case 4:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        query = _b.value;
+                        return [5 /*yield**/, _loop_1(query)];
+                    case 5:
+                        _d.sent();
+                        _d.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DataProviderLiveQueryStorage.prototype.keepAliveAndReturnUnknownQueryIds = function (queryIds) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var repo, _loop_2, _a, _b, query, e_2_1;
+            var e_2, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.repo];
+                    case 1:
+                        repo = _d.sent();
+                        _loop_2 = function (query) {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        query.lastUsed = new Date();
+                                        return [4 /*yield*/, repo.save(query)];
+                                    case 1:
+                                        _a.sent();
+                                        queryIds = queryIds.filter(function (x) { return x !== query.id; });
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 8, 9, 10]);
+                        return [4 /*yield*/, repo.find({ where: { id: queryIds } })];
+                    case 3:
+                        _a = tslib_1.__values.apply(void 0, [_d.sent()]), _b = _a.next();
+                        _d.label = 4;
+                    case 4:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        query = _b.value;
+                        return [5 /*yield**/, _loop_2(query)];
+                    case 5:
+                        _d.sent();
+                        _d.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_2_1 = _d.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/, queryIds];
+                }
+            });
+        });
+    };
+    return DataProviderLiveQueryStorage;
+}());
+exports.DataProviderLiveQueryStorage = DataProviderLiveQueryStorage;
+var LiveQueryStorageEntity = /** @class */ (function () {
+    function LiveQueryStorageEntity() {
+        this.id = '';
+        this.entityKey = '';
+        this.lastUsed = new Date();
+    }
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", Object)
+    ], LiveQueryStorageEntity.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", Object)
+    ], LiveQueryStorageEntity.prototype, "entityKey", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.object(),
+        tslib_1.__metadata("design:type", Object)
+    ], LiveQueryStorageEntity.prototype, "data", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.date(),
+        tslib_1.__metadata("design:type", Object)
+    ], LiveQueryStorageEntity.prototype, "lastUsed", void 0);
+    LiveQueryStorageEntity = tslib_1.__decorate([
+        remult3_1.Entity(undefined, {
+            dbName: 'remult_live_query_storage'
+        })
+    ], LiveQueryStorageEntity);
+    return LiveQueryStorageEntity;
+}());

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.18.1-exp.21",
+    "version": "0.18.1-exp.23",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",
@@ -118,6 +118,14 @@
             },
             "import": "./esm/live-query/ably.js"
         },
+        "./live-query/data-provider-live-query-storage": {
+            "require": "./live-query/DataProviderLiveQueryStorage.js",
+            "node": {
+                "require": "./live-query/DataProviderLiveQueryStorage.js",
+                "import": "./live-query/DataProviderLiveQueryStorage.js"
+            },
+            "import": "./esm/live-query/DataProviderLiveQueryStorage.js"
+        },
         "./graphql": {
             "require": "./graphql.js",
             "node": {

package/remult-express.js

@@ -7,9 +7,7 @@ var index_1 = require("./server/index");
 var SubscriptionChannel_1 = require("./src/live-query/SubscriptionChannel");
 var uuid_1 = require("uuid");
 var remult_proxy_1 = require("./src/remult-proxy");
-var remult3_1 = require("./src/remult3");
 function remultExpress(options) {
-    var _this = this;
     var app = express.Router();
     if (!options) {
         options = {};
@@ -30,72 +28,6 @@ function remultExpress(options) {
     if (canRegisterRoute.registerRoutes) {
         canRegisterRoute.registerRoutes(app, options.rootPath, server);
     }
-    server.runWithRequest = function (req, entityKey, what) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var _loop_1, _a, _b, e, state_1, e_1_1;
-        var e_1, _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) {
-                                            server.withRemult(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(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_1_1 = _d.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 8];
-                case 7:
-                    try {
-                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                    return [7 /*endfinally*/];
-                case 8: throw new Error("Couldn't find entity " + entityKey);
-            }
-        });
-    }); };
     return Object.assign(app, {
         getRemult: function (req) { return server.getRemult(req); },
         openApiDoc: function (options) { return server.openApiDoc(options); },
@@ -125,7 +57,7 @@ var SseSubscriptionServer = /** @class */ (function () {
     }
     //@internal
     SseSubscriptionServer.prototype.subscribeToChannel = function (_a, res, remult, remove) {
-        var e_2, _b;
+        var e_1, _b;
         var channel = _a.channel, clientId = _a.clientId;
         if (remove === void 0) { remove = false; }
         try {
@@ -149,17 +81,17 @@ var SseSubscriptionServer = /** @class */ (function () {
                 }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
                 if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_1) throw e_1.error; }
         }
         res.sendStatus(404);
     };
     SseSubscriptionServer.prototype.publishMessage = function (channel, message) {
-        var e_3, _a;
+        var e_2, _a;
         var data = JSON.stringify({ channel: channel, data: message });
         try {
             for (var _b = tslib_1.__values(this.connections), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -170,12 +102,12 @@ var SseSubscriptionServer = /** @class */ (function () {
                 }
             }
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        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_3) throw e_3.error; }
+            finally { if (e_2) throw e_2.error; }
         }
     };
     //@internal

package/server/expressBridge.js

@@ -10,6 +10,7 @@ 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");
 ;
 function createRemultServerCore(options) {
     var _this = this;
@@ -25,23 +26,7 @@ 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);
-    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')];
-            }
-        });
-    }); });
+    var dataProvider = initDataProvider_1.initDataProvider(options.dataProvider);
     RemultAsyncLocalStorage.enable();
     if (options.initApi) {
         dataProvider = dataProvider.then(function (dp) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
@@ -152,10 +137,77 @@ 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_2_1;
+            var e_2, _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_2_1 = _d.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 8: throw new Error("Couldn't find entity " + entityKey);
+                }
+            });
+        }); };
         this.registeredRouter = false;
         this.hasQueue = false;
         /* internal */
@@ -165,6 +217,7 @@ var RemultServerImplementation = /** @class */ (function () {
         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) {
@@ -180,7 +233,7 @@ var RemultServerImplementation = /** @class */ (function () {
         return this.routeImpl.handle(req, gRes);
     };
     RemultServerImplementation.prototype.registerRouter = function (r) {
-        var e_2, _a, e_3, _b;
+        var e_3, _a, e_4, _b;
         var _this = this;
         if (this.registeredRouter)
             throw "Router already registered";
@@ -192,7 +245,7 @@ var RemultServerImplementation = /** @class */ (function () {
                     var z = c[server_action_1.classBackendMethodsArray];
                     if (z)
                         try {
-                            for (var z_1 = (e_3 = 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_4 = 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) {
@@ -201,21 +254,21 @@ var RemultServerImplementation = /** @class */ (function () {
                                 this.addAction(x, r);
                             }
                         }
-                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
                         finally {
                             try {
                                 if (z_1_1 && !z_1_1.done && (_b = z_1.return)) _b.call(z_1);
                             }
-                            finally { if (e_3) throw e_3.error; }
+                            finally { if (e_4) throw e_4.error; }
                         }
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
             finally {
                 try {
                     if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                 }
-                finally { if (e_2) throw e_2.error; }
+                finally { if (e_3) throw e_3.error; }
             }
             if (this.hasQueue)
                 this.addAction({
@@ -436,7 +489,7 @@ var RemultServerImplementation = /** @class */ (function () {
         });
     };
     RemultServerImplementation.prototype.openApiDoc = function (options) {
-        var e_4, _a, e_5, _b;
+        var e_5, _a, e_6, _b;
         var r = new context_1.Remult();
         if (!options.version)
             options.version = "1.0.0";
@@ -486,15 +539,15 @@ var RemultServerImplementation = /** @class */ (function () {
                 return item;
             }
         };
-        var _loop_1 = function (e) {
-            var e_6, _a;
+        var _loop_2 = function (e) {
+            var e_7, _a;
             var meta = r.repo(e).metadata;
             var key = remult3_1.getEntityKey(e);
             var parameters = [];
             if (key) {
                 var properties = {};
                 try {
-                    for (var _b = (e_6 = void 0, tslib_1.__values(meta.fields)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    for (var _b = (e_7 = 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" :
@@ -522,12 +575,12 @@ var RemultServerImplementation = /** @class */ (function () {
                         });
                     }
                 }
-                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
                 finally {
                     try {
                         if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                     }
-                    finally { if (e_6) throw e_6.error; }
+                    finally { if (e_7) throw e_7.error; }
                 }
                 spec.components.schemas[key] = {
                     type: "object",
@@ -667,15 +720,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_4_1) { e_4 = { error: e_4_1 }; }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
         finally {
             try {
                 if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
             }
-            finally { if (e_4) throw e_4.error; }
+            finally { if (e_5) throw e_5.error; }
         }
         try {
             for (var _e = tslib_1.__values(this.backendMethodsOpenApi), _f = _e.next(); !_f.done; _f = _e.next()) {
@@ -718,12 +771,12 @@ var RemultServerImplementation = /** @class */ (function () {
                 };
             }
         }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
         finally {
             try {
                 if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
             }
-            finally { if (e_5) throw e_5.error; }
+            finally { if (e_6) throw e_6.error; }
         }
         spec.components.schemas["InvalidResponse"] = {
             "type": "object",

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/live-query/SubscriptionServer.d.ts

@@ -3,7 +3,7 @@ export interface SubscriptionServer {
 }
 export interface LiveQueryStorage {
     add(query: StoredQuery): void;
-    remove(queryId: any): void;
+    remove(queryId: string): void;
     forEach(entityKey: string, callback: (args: {
         query: StoredQuery;
         setData(data: any): Promise<void>;