remult 0.14.3 → 0.14.6

package/src/context.js

@@ -1,170 +1,119 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventSource = exports.queryConfig = exports.Allow = exports.setControllerSettings = exports.MethodHelper = exports.ClassHelper = exports.classHelpers = exports.allEntities = exports.Remult = exports.isBackend = exports.processHttpException = exports.toPromise = exports.retry = exports.HttpProviderBridgeToRestDataProviderHttpProvider = 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) {
+import { Action, actionInfo } from './server-action';
+import { RestDataProvider, RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
+import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
+export class HttpProviderBridgeToRestDataProviderHttpProvider {
+    constructor(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) {
+    async post(url, data) {
+        return await retry(() => toPromise(this.http.post(url, data)));
+    }
+    delete(url) {
         return toPromise(this.http.delete(url));
-    };
-    HttpProviderBridgeToRestDataProviderHttpProvider.prototype.put = function (url, data) {
+    }
+    put(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*/];
+    }
+    async get(url) {
+        return await retry(() => toPromise(this.http.get(url)));
+    }
+}
+export async function retry(what) {
+    while (true) {
+        try {
+            return await what();
+        }
+        catch (err) {
+            if (err.message?.startsWith("Error occurred while trying to proxy") ||
+                err.message?.startsWith("Error occured while trying to proxy") ||
+                err.message?.includes("http proxy error") ||
+                err.message?.startsWith("Gateway Timeout")) {
+                await new Promise((res, req) => {
+                    setTimeout(() => {
+                        res({});
+                    }, 250);
+                });
+                continue;
             }
-        });
-    });
+            throw err;
+        }
+    }
 }
-exports.retry = retry;
-function toPromise(p) {
-    var _this = this;
-    var r;
+export function toPromise(p) {
+    let r;
     if (p["toPromise"] !== undefined) {
         r = p["toPromise"]();
     }
     //@ts-ignore
     else
         r = p;
-    return r.then(function (x) {
+    return r.then((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();
-            }
-        });
-    }); });
+    }).catch(async (ex) => {
+        throw await processHttpException(ex);
+    });
 }
-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,
-                        };
-                    }
-                    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];
-            }
-        });
+export async function processHttpException(ex) {
+    let z = await ex;
+    var error;
+    if (z.error)
+        error = z.error;
+    else if (z.isAxiosError) {
+        if (typeof z.response?.data === "string")
+            error = z.response.data;
+        else
+            error = z?.response?.data;
+    }
+    if (!error)
+        error = z.message;
+    if (z.status == 0 && z.error.isTrusted)
+        error = "Network Error";
+    if (typeof error === 'string') {
+        error = {
+            message: error,
+        };
+    }
+    let httpStatusCode = z.status;
+    if (httpStatusCode === undefined)
+        httpStatusCode = z.response?.status;
+    if (httpStatusCode !== undefined && httpStatusCode !== null) {
+        error.httpStatusCode = httpStatusCode;
+    }
+    var result = Object.assign(error, {
+    //     exception: ex disabled for now because JSON.stringify crashed with this
     });
+    return result;
 }
-exports.processHttpException = processHttpException;
-function isBackend() {
-    return server_action_1.actionInfo.runningOnServer;
+export function isBackend() {
+    return actionInfo.runningOnServer;
 }
-exports.isBackend = isBackend;
-var Remult = /** @class */ (function () {
+export class Remult {
     /** Creates a new instance of the `remult` object.
      *
      * Can receive either an HttpProvider or a DataProvider as a parameter - which will be used to fetch data from.
      *
      * If no provider is specified, `fetch` will be used as an http provider
      */
-    function Remult(provider) {
+    constructor(provider) {
         this._userChangeEvent = new EventSource();
         this.repCache = new Map();
         if (provider && provider.getEntityDataProvider) {
             this._dataSource = provider;
             return;
         }
-        var http = provider;
-        var dataProvider;
+        let http = provider;
+        let dataProvider;
         if (http) {
             dataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(http);
         }
         if (!dataProvider) {
-            dataProvider = new rest_data_provider_1.RestDataProviderHttpProviderUsingFetch();
+            dataProvider = new RestDataProviderHttpProviderUsingFetch();
         }
-        this._dataSource = new rest_data_provider_1.RestDataProvider(Remult.apiBaseUrl, dataProvider);
-        if (!server_action_1.Action.provider)
-            server_action_1.Action.provider = dataProvider;
+        this._dataSource = new RestDataProvider(Remult.apiBaseUrl, dataProvider);
+        if (!Action.provider)
+            Action.provider = dataProvider;
     }
     /**Return's a `Repository` of the specific entity type
      * @example
@@ -172,90 +121,64 @@ var Remult = /** @class */ (function () {
      * @see [Repository](https://remult.dev/docs/ref_repository.html)
      *
      */
-    Remult.prototype.repo = function (entity, dataProvider) {
+    repo(entity, dataProvider) {
         if (dataProvider === undefined)
             dataProvider = this._dataSource;
-        var dpCache = this.repCache.get(dataProvider);
+        let dpCache = this.repCache.get(dataProvider);
         if (!dpCache)
             this.repCache.set(dataProvider, dpCache = new Map());
-        var r = dpCache.get(entity);
+        let r = dpCache.get(entity);
         if (!r) {
-            dpCache.set(entity, r = new RepositoryImplementation_1.RepositoryImplementation(entity, this, dataProvider));
+            dpCache.set(entity, r = new RepositoryImplementation(entity, this, dataProvider));
         }
         return r;
-    };
-    Object.defineProperty(Remult.prototype, "user", {
-        /** Returns the current user's info */
-        get: function () {
-            if (this._user === undefined) {
-                return {
-                    id: undefined,
-                    name: '',
-                    roles: []
-                };
-            }
-            return this._user;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    /** Returns the current user's info */
+    get user() {
+        if (this._user === undefined) {
+            return {
+                id: undefined,
+                name: '',
+                roles: []
+            };
+        }
+        return this._user;
+    }
     /** Set's the current user info */
-    Remult.prototype.setUser = function (info) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var auth;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this._user = info;
-                        auth = info;
-                        if (auth) {
-                            if (!this._user.id && auth.sub)
-                                this._user.id = auth.sub;
-                            if (!this._user.roles && auth.permissions) {
-                                this._user.roles = auth.permissions;
-                            }
-                            if (!this._user.name)
-                                this._user.name = auth.username;
-                        }
-                        if (this._user && !this._user.roles)
-                            this._user.roles = [];
-                        return [4 /*yield*/, this._userChangeEvent.fire()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async setUser(info) {
+        this._user = info;
+        let auth = info;
+        if (auth) {
+            if (!this._user.id && auth.sub)
+                this._user.id = auth.sub;
+            if (!this._user.roles && auth.permissions) {
+                this._user.roles = auth.permissions;
+            }
+            if (!this._user.name)
+                this._user.name = auth.username;
+        }
+        if (this._user && !this._user.roles)
+            this._user.roles = [];
+        await this._userChangeEvent.fire();
+    }
     /** Checks if a user was authenticated */
-    Remult.prototype.authenticated = function () {
+    authenticated() {
         return this.user.id !== undefined;
-    };
+    }
     /** checks if the user has any of the roles specified in the parameters
      * @example
      * remult.isAllowed("admin")
      * @see
      * [Allowed](https://remult.dev/docs/allowed.html)
      */
-    Remult.prototype.isAllowed = function (roles) {
-        var e_1, _a;
+    isAllowed(roles) {
         if (roles == undefined)
             return undefined;
         if (roles instanceof Array) {
-            try {
-                for (var roles_1 = tslib_1.__values(roles), roles_1_1 = roles_1.next(); !roles_1_1.done; roles_1_1 = roles_1.next()) {
-                    var role = roles_1_1.value;
-                    if (this.isAllowed(role) === true) {
-                        return true;
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (roles_1_1 && !roles_1_1.done && (_a = roles_1.return)) _a.call(roles_1);
+            for (const role of roles) {
+                if (this.isAllowed(role) === true) {
+                    return true;
                 }
-                finally { if (e_1) throw e_1.error; }
             }
             return false;
         }
@@ -268,28 +191,17 @@ var Remult = /** @class */ (function () {
             if (this.user.roles.indexOf(roles.toString()) >= 0)
                 return true;
         return false;
-    };
+    }
     /** checks if the user matches the allowedForInstance callback
      * @see
      * [Allowed](https://remult.dev/docs/allowed.html)
      */
-    Remult.prototype.isAllowedForInstance = function (instance, allowed) {
-        var e_2, _a;
+    isAllowedForInstance(instance, allowed) {
         if (Array.isArray(allowed)) {
             {
-                try {
-                    for (var allowed_1 = tslib_1.__values(allowed), allowed_1_1 = allowed_1.next(); !allowed_1_1.done; allowed_1_1 = allowed_1.next()) {
-                        var item = allowed_1_1.value;
-                        if (this.isAllowedForInstance(instance, item))
-                            return true;
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (allowed_1_1 && !allowed_1_1.done && (_a = allowed_1.return)) _a.call(allowed_1);
-                    }
-                    finally { if (e_2) throw e_2.error; }
+                for (const item of allowed) {
+                    if (this.isAllowedForInstance(instance, item))
+                        return true;
                 }
             }
         }
@@ -298,144 +210,76 @@ var Remult = /** @class */ (function () {
         }
         else
             return this.isAllowed(allowed);
-    };
-    Object.defineProperty(Remult.prototype, "userChange", {
-        /** returns a dispatcher object that fires once a user has changed*/
-        get: function () {
-            return this._userChangeEvent.dispatcher;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    /** returns a dispatcher object that fires once a user has changed*/
+    get userChange() {
+        return this._userChangeEvent.dispatcher;
+    }
     /** sets the current data provider */
-    Remult.prototype.setDataProvider = function (dataProvider) {
+    setDataProvider(dataProvider) {
         this._dataSource = dataProvider;
-    };
-    Remult.prototype.clearAllCache = function () {
+    }
+    clearAllCache() {
         this.repCache.clear();
-    };
-    /** The api Base Url to be used in all remult calls. by default it's set to `/api`.
-     *
-     * Set this property in case you want to determine a non relative api url
-     */
-    Remult.apiBaseUrl = '/api';
-    /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
-    Remult.onFind = function (metadata, options) { };
-    return Remult;
-}());
-exports.Remult = Remult;
-exports.allEntities = [];
-exports.classHelpers = new Map();
-var ClassHelper = /** @class */ (function () {
-    function ClassHelper() {
+    }
+}
+/** The api Base Url to be used in all remult calls. by default it's set to `/api`.
+ *
+ * Set this property in case you want to determine a non relative api url
+ */
+Remult.apiBaseUrl = '/api';
+/** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
+Remult.onFind = (metadata, options) => { };
+export const allEntities = [];
+export const classHelpers = new Map();
+export class ClassHelper {
+    constructor() {
         this.methods = [];
     }
-    return ClassHelper;
-}());
-exports.ClassHelper = ClassHelper;
-var MethodHelper = /** @class */ (function () {
-    function MethodHelper() {
+}
+export class MethodHelper {
+    constructor() {
         this.classes = new Map();
     }
-    return MethodHelper;
-}());
-exports.MethodHelper = MethodHelper;
-function setControllerSettings(target, options) {
-    var e_3, _a;
-    var r = target;
+}
+export function setControllerSettings(target, options) {
+    let r = target;
     while (true) {
-        var helper = exports.classHelpers.get(r);
+        let helper = classHelpers.get(r);
         if (helper) {
-            try {
-                for (var _b = (e_3 = void 0, tslib_1.__values(helper.methods)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var m = _c.value;
-                    m.classes.set(target, options);
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_3) throw e_3.error; }
+            for (const m of helper.methods) {
+                m.classes.set(target, options);
             }
         }
-        var p = Object.getPrototypeOf(r.prototype);
+        let p = Object.getPrototypeOf(r.prototype);
         if (p == null)
             break;
         r = p.constructor;
     }
 }
-exports.setControllerSettings = setControllerSettings;
-var Allow = /** @class */ (function () {
-    function Allow() {
-    }
-    Allow.everyone = function () { return true; };
-    Allow.authenticated = function (remult) { return remult.authenticated(); };
-    return Allow;
-}());
-exports.Allow = Allow;
-exports.queryConfig = {
+export class Allow {
+}
+Allow.everyone = () => true;
+Allow.authenticated = (remult) => remult.authenticated();
+export const queryConfig = {
     defaultPageSize: 200
 };
-var EventSource = /** @class */ (function () {
-    function EventSource() {
-        var _this = this;
+export class EventSource {
+    constructor() {
         this.listeners = [];
         this.dispatcher = {
-            observe: function (what) { 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:
-                            this.listeners.push(what);
-                            return [4 /*yield*/, what()];
-                        case 1:
-                            _a.sent();
-                            return [2 /*return*/, function () {
-                                    _this.listeners = _this.listeners.filter(function (x) { return x != what; });
-                                }];
-                    }
-                });
-            }); }
+            observe: async (what) => {
+                this.listeners.push(what);
+                await what();
+                return () => {
+                    this.listeners = this.listeners.filter(x => x != what);
+                };
+            }
         };
     }
-    EventSource.prototype.fire = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, _b, l, e_4_1;
-            var e_4, _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.listeners), _b = _a.next();
-                        _d.label = 1;
-                    case 1:
-                        if (!!_b.done) return [3 /*break*/, 4];
-                        l = _b.value;
-                        return [4 /*yield*/, l()];
-                    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_4_1 = _d.sent();
-                        e_4 = { error: e_4_1 };
-                        return [3 /*break*/, 7];
-                    case 6:
-                        try {
-                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                        }
-                        finally { if (e_4) throw e_4.error; }
-                        return [7 /*endfinally*/];
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return EventSource;
-}());
-exports.EventSource = EventSource;
+    async fire() {
+        for (const l of this.listeners) {
+            await l();
+        }
+    }
+}