remult 0.17.3 → 0.18.0

package/src/context.js

@@ -1,143 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventSource = exports.queryConfig = exports.Allow = exports.setControllerSettings = exports.buildRestDataProvider = exports.ClassHelper = exports.classHelpers = exports.allEntities = exports.Remult = exports.isBackend = exports.processHttpException = exports.toPromise = exports.retry = exports.HttpProviderBridgeToRestDataProviderHttpProvider = void 0;
+exports.doTransaction = exports.EventSource = exports.queryConfig = exports.Allow = exports.setControllerSettings = exports.ClassHelper = exports.classHelpers = exports.allEntities = exports.Remult = exports.isBackend = void 0;
 var tslib_1 = require("tslib");
 var server_action_1 = require("./server-action");
 var rest_data_provider_1 = require("./data-providers/rest-data-provider");
 var RepositoryImplementation_1 = require("./remult3/RepositoryImplementation");
-var HttpProviderBridgeToRestDataProviderHttpProvider = /** @class */ (function () {
-    function HttpProviderBridgeToRestDataProviderHttpProvider(http) {
-        this.http = http;
-    }
-    HttpProviderBridgeToRestDataProviderHttpProvider.prototype.post = function (url, data) {
-        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: return [4 /*yield*/, retry(function () { return toPromise(_this.http.post(url, data)); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    HttpProviderBridgeToRestDataProviderHttpProvider.prototype.delete = function (url) {
-        return toPromise(this.http.delete(url));
-    };
-    HttpProviderBridgeToRestDataProviderHttpProvider.prototype.put = function (url, data) {
-        return toPromise(this.http.put(url, data));
-    };
-    HttpProviderBridgeToRestDataProviderHttpProvider.prototype.get = function (url) {
-        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: return [4 /*yield*/, retry(function () { return toPromise(_this.http.get(url)); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    return HttpProviderBridgeToRestDataProviderHttpProvider;
-}());
-exports.HttpProviderBridgeToRestDataProviderHttpProvider = HttpProviderBridgeToRestDataProviderHttpProvider;
-function retry(what) {
-    var _a, _b, _c, _d;
-    return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var err_1;
-        return tslib_1.__generator(this, function (_e) {
-            switch (_e.label) {
-                case 0:
-                    if (!true) return [3 /*break*/, 7];
-                    _e.label = 1;
-                case 1:
-                    _e.trys.push([1, 3, , 6]);
-                    return [4 /*yield*/, what()];
-                case 2: return [2 /*return*/, _e.sent()];
-                case 3:
-                    err_1 = _e.sent();
-                    if (!(((_a = err_1.message) === null || _a === void 0 ? void 0 : _a.startsWith("Error occurred while trying to proxy")) || ((_b = err_1.message) === null || _b === void 0 ? void 0 : _b.startsWith("Error occured while trying to proxy")) || ((_c = err_1.message) === null || _c === void 0 ? void 0 : _c.includes("http proxy error")) || ((_d = err_1.message) === null || _d === void 0 ? void 0 : _d.startsWith("Gateway Timeout")))) return [3 /*break*/, 5];
-                    return [4 /*yield*/, new Promise(function (res, req) {
-                            setTimeout(function () {
-                                res({});
-                            }, 250);
-                        })];
-                case 4:
-                    _e.sent();
-                    return [3 /*break*/, 0];
-                case 5: throw err_1;
-                case 6: return [3 /*break*/, 0];
-                case 7: return [2 /*return*/];
-            }
-        });
-    });
-}
-exports.retry = retry;
-function toPromise(p) {
-    var _this = this;
-    var r;
-    if (p["toPromise"] !== undefined) {
-        r = p["toPromise"]();
-    }
-    //@ts-ignore
-    else
-        r = p;
-    return r.then(function (x) {
-        if (x && (x.status == 200 || x.status == 201) && x.headers && x.request && x.data) //for axios
-            return x.data;
-        return x;
-    }).catch(function (ex) { 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*/, processHttpException(ex)];
-                case 1: throw _a.sent();
-            }
-        });
-    }); });
-}
-exports.toPromise = toPromise;
-function processHttpException(ex) {
-    var _a, _b, _c;
-    return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var z, error, httpStatusCode, result;
-        return tslib_1.__generator(this, function (_d) {
-            switch (_d.label) {
-                case 0: return [4 /*yield*/, ex];
-                case 1:
-                    z = _d.sent();
-                    if (z.error)
-                        error = z.error;
-                    else if (z.isAxiosError) {
-                        if (typeof ((_a = z.response) === null || _a === void 0 ? void 0 : _a.data) === "string")
-                            error = z.response.data;
-                        else
-                            error = (_b = z === null || z === void 0 ? void 0 : z.response) === null || _b === void 0 ? void 0 : _b.data;
-                    }
-                    if (!error)
-                        error = z.message;
-                    if (z.status == 0 && z.error.isTrusted)
-                        error = "Network Error";
-                    if (typeof error === 'string') {
-                        error = {
-                            message: error,
-                        };
-                    }
-                    if (z.modelState)
-                        error.modelState = z.modelState;
-                    httpStatusCode = z.status;
-                    if (httpStatusCode === undefined)
-                        httpStatusCode = (_c = z.response) === null || _c === void 0 ? void 0 : _c.status;
-                    if (httpStatusCode !== undefined && httpStatusCode !== null) {
-                        error.httpStatusCode = httpStatusCode;
-                    }
-                    result = Object.assign(error, {
-                    //     exception: ex disabled for now because JSON.stringify crashed with this
-                    });
-                    return [2 /*return*/, result];
-            }
-        });
-    });
-}
-exports.processHttpException = processHttpException;
+var LiveQueryClient_1 = require("./live-query/LiveQueryClient");
+var SseSubscriptionClient_1 = require("./live-query/SseSubscriptionClient");
+var remult_proxy_1 = require("./remult-proxy");
+var buildRestDataProvider_1 = require("./buildRestDataProvider");
 function isBackend() {
     return server_action_1.actionInfo.runningOnServer;
 }
@@ -145,19 +16,30 @@ exports.isBackend = isBackend;
 var Remult = /** @class */ (function () {
     function Remult(provider) {
         var _this = this;
-        /* @internal */
-        this.repCache = new Map();
         /** The current data provider */
         this.dataProvider = new rest_data_provider_1.RestDataProvider(function () { return _this.apiClient; });
+        /* @internal */
+        this.repCache = new Map();
+        /* @internal*/
+        this.liveQueryPublisher = {
+            itemChanged: function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/];
+            }); }); }
+        };
+        /* @internal*/
+        this.liveQuerySubscriber = new LiveQueryClient_1.LiveQueryClient(function () { return _this.apiClient; }, function () { var _a; return (_a = _this.user) === null || _a === void 0 ? void 0 : _a.id; });
+        /** context information that can be used to store custom information that will be disposed as part of the `remult` object */
         this.context = {};
+        /** The api client that will be used by `remult` to perform calls to the `api` */
         this.apiClient = {
-            url: '/api'
+            url: '/api',
+            subscriptionClient: new SseSubscriptionClient_1.SseSubscriptionClient()
         };
         if (provider && provider.getEntityDataProvider) {
             this.dataProvider = provider;
             return;
         }
-        if (isExternalHttpProvider(provider)) {
+        if (buildRestDataProvider_1.isExternalHttpProvider(provider)) {
             this.apiClient.httpClient = provider;
         }
         else if (typeof (provider) === "function")
@@ -168,13 +50,18 @@ var Remult = /** @class */ (function () {
                 this.apiClient.httpClient = apiClient.httpClient;
             if (apiClient.url)
                 this.apiClient.url = apiClient.url;
+            if (apiClient.subscriptionClient)
+                this.apiClient.subscriptionClient = apiClient.subscriptionClient;
+            if (apiClient.wrapMessageHandling)
+                this.apiClient.wrapMessageHandling = apiClient.wrapMessageHandling;
         }
     }
     /**Return's a `Repository` of the specific entity type
      * @example
      * const taskRepo = remult.repo(Task);
      * @see [Repository](https://remult.dev/docs/ref_repository.html)
-     *
+     * @param entity - the entity to use
+     * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
      */
     Remult.prototype.repo = function (entity, dataProvider) {
         if (dataProvider === undefined)
@@ -188,7 +75,6 @@ var Remult = /** @class */ (function () {
         }
         return r;
     };
-    /*  delete me */
     /** Checks if a user was authenticated */
     Remult.prototype.authenticated = function () {
         var _a;
@@ -258,11 +144,19 @@ var Remult = /** @class */ (function () {
             }
         }
         else if (typeof (allowed) === "function") {
-            return allowed(this, instance);
+            return allowed(instance, this);
         }
         else
             return this.isAllowed(allowed);
     };
+    //@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
+     * await remult.call(TasksController.setAll, undefined, true);
+     * @param backendMethod - the backend method to call
+     * @param classInstance - the class instance of the backend method, for static backend methods use undefined
+     * @param args - the arguments to send to the backend method
+    */
     Remult.prototype.call = function (backendMethod, classInstance) {
         var args = [];
         for (var _i = 2; _i < arguments.length; _i++) {
@@ -272,7 +166,7 @@ var Remult = /** @class */ (function () {
         if (!z.doWork)
             throw Error("The method received is not a valid backend method");
         //@ts-ignore
-        return z.doWork(args, classInstance, this.apiClient.url, buildRestDataProvider(this.apiClient.httpClient));
+        return z.doWork(args, classInstance, this.apiClient.url, buildRestDataProvider_1.buildRestDataProvider(this.apiClient.httpClient));
     };
     Remult.prototype.clearAllCache = function () {
         this.repCache.clear();
@@ -282,6 +176,7 @@ var Remult = /** @class */ (function () {
     return Remult;
 }());
 exports.Remult = Remult;
+remult_proxy_1.RemultProxy.defaultRemult = new Remult();
 ;
 exports.allEntities = [];
 exports.classHelpers = new Map();
@@ -292,29 +187,6 @@ var ClassHelper = /** @class */ (function () {
     return ClassHelper;
 }());
 exports.ClassHelper = ClassHelper;
-function isExternalHttpProvider(item) {
-    var http = item;
-    if (http && http.get && http.put && http.post && http.delete)
-        return true;
-    return false;
-}
-function buildRestDataProvider(provider) {
-    if (!provider)
-        return new rest_data_provider_1.RestDataProviderHttpProviderUsingFetch();
-    var httpDataProvider;
-    if (!httpDataProvider) {
-        if (isExternalHttpProvider(provider)) {
-            httpDataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(provider);
-        }
-    }
-    if (!httpDataProvider) {
-        if (typeof provider === "function") {
-            httpDataProvider = new rest_data_provider_1.RestDataProviderHttpProviderUsingFetch(provider);
-        }
-    }
-    return httpDataProvider;
-}
-exports.buildRestDataProvider = buildRestDataProvider;
 function setControllerSettings(target, options) {
     var r = target;
     while (true) {
@@ -333,7 +205,20 @@ var Allow = /** @class */ (function () {
     function Allow() {
     }
     Allow.everyone = function () { return true; };
-    Allow.authenticated = function (remult) { return remult.authenticated(); };
+    Allow.authenticated = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (args.length > 1) {
+            return args[1].authenticated();
+        }
+        else if (args.length == 1) {
+            if (args[0].authenticated)
+                return args[0].authenticated();
+        }
+        return remult_proxy_1.RemultProxy.defaultRemult.authenticated();
+    };
     return Allow;
 }());
 exports.Allow = Allow;
@@ -401,3 +286,123 @@ var EventSource = /** @class */ (function () {
     return EventSource;
 }());
 exports.EventSource = EventSource;
+function doTransaction(remult, what) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var trans, ok, result;
+        var _this = this;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    trans = new transactionLiveQueryPublisher(remult.liveQueryPublisher);
+                    ok = true;
+                    return [4 /*yield*/, remult.dataProvider.transaction(function (ds) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        remult.dataProvider = (ds);
+                                        remult.liveQueryPublisher = trans;
+                                        return [4 /*yield*/, what()];
+                                    case 1:
+                                        _a.sent();
+                                        ok = true;
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                case 1:
+                    result = _a.sent();
+                    if (!ok) return [3 /*break*/, 3];
+                    return [4 /*yield*/, trans.flush()];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.doTransaction = doTransaction;
+var transactionLiveQueryPublisher = /** @class */ (function () {
+    function transactionLiveQueryPublisher(orig) {
+        this.orig = orig;
+        this.transactionItems = new Map();
+    }
+    transactionLiveQueryPublisher.prototype.itemChanged = function (entityKey, changes) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var items, _loop_1, changes_1, changes_1_1, c;
+            var e_4, _a;
+            return tslib_1.__generator(this, function (_b) {
+                items = this.transactionItems.get(entityKey);
+                if (!items) {
+                    this.transactionItems.set(entityKey, items = []);
+                }
+                _loop_1 = function (c) {
+                    if (c.oldId !== undefined) {
+                        var item = items.find(function (y) { return y.id === c.oldId; });
+                        if (item !== undefined) {
+                            if (c.deleted)
+                                item.deleted = true;
+                            if (c.id != item.id)
+                                item.id = c.id;
+                        }
+                        else
+                            items.push(c);
+                    }
+                    else
+                        items.push(c);
+                };
+                try {
+                    for (changes_1 = tslib_1.__values(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
+                        c = changes_1_1.value;
+                        _loop_1(c);
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    transactionLiveQueryPublisher.prototype.flush = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, key, e_5_1;
+            var e_5, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 5, 6, 7]);
+                        _a = tslib_1.__values(this.transactionItems.keys()), _b = _a.next();
+                        _d.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 4];
+                        key = _b.value;
+                        return [4 /*yield*/, this.orig.itemChanged(key, this.transactionItems.get(key))];
+                    case 2:
+                        _d.sent();
+                        _d.label = 3;
+                    case 3:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 7];
+                    case 5:
+                        e_5_1 = _d.sent();
+                        e_5 = { error: e_5_1 };
+                        return [3 /*break*/, 7];
+                    case 6:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return transactionLiveQueryPublisher;
+}());

package/src/data-api.d.ts

@@ -1,16 +1,21 @@
 import { Remult } from './context';
-import { Repository } from './remult3';
+import { FindOptions, Repository } from './remult3';
 import { ErrorInfo } from './data-interfaces';
 export declare class DataApi<T = any> {
     private repository;
     private remult;
     constructor(repository: Repository<T>, remult: Remult);
-    httpGet(res: DataApiResponse, req: DataApiRequest): Promise<void>;
-    httpPost(res: DataApiResponse, req: DataApiRequest, body: any): Promise<void>;
+    httpGet(res: DataApiResponse, req: DataApiRequest, serializeRequest: () => any): Promise<void>;
+    httpPost(res: DataApiResponse, req: DataApiRequest, body: any, serializeRequest: () => any): Promise<void>;
     static defaultGetLimit: number;
     get(response: DataApiResponse, id: any): Promise<void>;
     count(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
+    getArrayImpl(response: DataApiResponse, request: DataApiRequest, filterBody: any): Promise<{
+        r: any[];
+        findOptions: FindOptions<T>;
+    }>;
     getArray(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
+    liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeRequest: () => any, queryChannel: string): Promise<void>;
     private buildWhere;
     private doOnId;
     put(response: DataApiResponse, id: any, body: any): Promise<void>;
@@ -31,3 +36,4 @@ export interface DataApiRequest {
 }
 export declare function determineSort(sortUrlParm: string, dirUrlParam: string): any;
 export declare function serializeError(data: ErrorInfo): ErrorInfo<any>;
+export declare function getLiveQueryChannel(queryId: string, userId: string): string;