remult 0.14.6 → 0.14.7

package/src/context.js

@@ -1,119 +1,170 @@
-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) {
+"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) {
         this.http = http;
     }
-    async post(url, data) {
-        return await retry(() => toPromise(this.http.post(url, data)));
-    }
-    delete(url) {
+    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));
-    }
-    put(url, data) {
+    };
+    HttpProviderBridgeToRestDataProviderHttpProvider.prototype.put = function (url, data) {
         return toPromise(this.http.put(url, data));
-    }
-    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;
+    };
+    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*/];
             }
-            throw err;
-        }
-    }
+        });
+    });
 }
-export function toPromise(p) {
-    let r;
+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((x) => {
+    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(async (ex) => {
-        throw await processHttpException(ex);
-    });
+    }).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();
+            }
+        });
+    }); });
 }
-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
+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];
+            }
+        });
     });
-    return result;
 }
-export function isBackend() {
-    return actionInfo.runningOnServer;
+exports.processHttpException = processHttpException;
+function isBackend() {
+    return server_action_1.actionInfo.runningOnServer;
 }
-export class Remult {
+exports.isBackend = isBackend;
+var Remult = /** @class */ (function () {
     /** 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
      */
-    constructor(provider) {
+    function Remult(provider) {
         this._userChangeEvent = new EventSource();
         this.repCache = new Map();
         if (provider && provider.getEntityDataProvider) {
             this._dataSource = provider;
             return;
         }
-        let http = provider;
-        let dataProvider;
+        var http = provider;
+        var dataProvider;
         if (http) {
             dataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(http);
         }
         if (!dataProvider) {
-            dataProvider = new RestDataProviderHttpProviderUsingFetch();
+            dataProvider = new rest_data_provider_1.RestDataProviderHttpProviderUsingFetch();
         }
-        this._dataSource = new RestDataProvider(Remult.apiBaseUrl, dataProvider);
-        if (!Action.provider)
-            Action.provider = dataProvider;
+        this._dataSource = new rest_data_provider_1.RestDataProvider(Remult.apiBaseUrl, dataProvider);
+        if (!server_action_1.Action.provider)
+            server_action_1.Action.provider = dataProvider;
     }
     /**Return's a `Repository` of the specific entity type
      * @example
@@ -121,64 +172,90 @@ export class Remult {
      * @see [Repository](https://remult.dev/docs/ref_repository.html)
      *
      */
-    repo(entity, dataProvider) {
+    Remult.prototype.repo = function (entity, dataProvider) {
         if (dataProvider === undefined)
             dataProvider = this._dataSource;
-        let dpCache = this.repCache.get(dataProvider);
+        var dpCache = this.repCache.get(dataProvider);
         if (!dpCache)
             this.repCache.set(dataProvider, dpCache = new Map());
-        let r = dpCache.get(entity);
+        var r = dpCache.get(entity);
         if (!r) {
-            dpCache.set(entity, r = new RepositoryImplementation(entity, this, dataProvider));
+            dpCache.set(entity, r = new RepositoryImplementation_1.RepositoryImplementation(entity, this, dataProvider));
         }
         return r;
-    }
-    /** 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 */
-    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;
+    };
+    Object.defineProperty(Remult.prototype, "user", {
+        /** Returns the current user's info */
+        get: function () {
+            if (this._user === undefined) {
+                return {
+                    id: undefined,
+                    name: '',
+                    roles: []
+                };
             }
-            if (!this._user.name)
-                this._user.name = auth.username;
-        }
-        if (this._user && !this._user.roles)
-            this._user.roles = [];
-        await this._userChangeEvent.fire();
-    }
+            return this._user;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** 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*/];
+                }
+            });
+        });
+    };
     /** Checks if a user was authenticated */
-    authenticated() {
+    Remult.prototype.authenticated = function () {
         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)
      */
-    isAllowed(roles) {
+    Remult.prototype.isAllowed = function (roles) {
+        var e_1, _a;
         if (roles == undefined)
             return undefined;
         if (roles instanceof Array) {
-            for (const role of roles) {
-                if (this.isAllowed(role) === true) {
-                    return true;
+            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);
                 }
+                finally { if (e_1) throw e_1.error; }
             }
             return false;
         }
@@ -191,17 +268,28 @@ export class Remult {
             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)
      */
-    isAllowedForInstance(instance, allowed) {
+    Remult.prototype.isAllowedForInstance = function (instance, allowed) {
+        var e_2, _a;
         if (Array.isArray(allowed)) {
             {
-                for (const item of allowed) {
-                    if (this.isAllowedForInstance(instance, item))
-                        return true;
+                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; }
                 }
             }
         }
@@ -210,76 +298,144 @@ export class Remult {
         }
         else
             return this.isAllowed(allowed);
-    }
-    /** returns a dispatcher object that fires once a user has changed*/
-    get userChange() {
-        return this._userChangeEvent.dispatcher;
-    }
+    };
+    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
+    });
     /** sets the current data provider */
-    setDataProvider(dataProvider) {
+    Remult.prototype.setDataProvider = function (dataProvider) {
         this._dataSource = dataProvider;
-    }
-    clearAllCache() {
+    };
+    Remult.prototype.clearAllCache = function () {
         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 = (metadata, options) => { };
-export const allEntities = [];
-export const classHelpers = new Map();
-export class ClassHelper {
-    constructor() {
+    };
+    /** 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() {
         this.methods = [];
     }
-}
-export class MethodHelper {
-    constructor() {
+    return ClassHelper;
+}());
+exports.ClassHelper = ClassHelper;
+var MethodHelper = /** @class */ (function () {
+    function MethodHelper() {
         this.classes = new Map();
     }
-}
-export function setControllerSettings(target, options) {
-    let r = target;
+    return MethodHelper;
+}());
+exports.MethodHelper = MethodHelper;
+function setControllerSettings(target, options) {
+    var e_3, _a;
+    var r = target;
     while (true) {
-        let helper = classHelpers.get(r);
+        var helper = exports.classHelpers.get(r);
         if (helper) {
-            for (const m of helper.methods) {
-                m.classes.set(target, options);
+            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; }
             }
         }
-        let p = Object.getPrototypeOf(r.prototype);
+        var p = Object.getPrototypeOf(r.prototype);
         if (p == null)
             break;
         r = p.constructor;
     }
 }
-export class Allow {
-}
-Allow.everyone = () => true;
-Allow.authenticated = (remult) => remult.authenticated();
-export const queryConfig = {
+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 = {
     defaultPageSize: 200
 };
-export class EventSource {
-    constructor() {
+var EventSource = /** @class */ (function () {
+    function EventSource() {
+        var _this = this;
         this.listeners = [];
         this.dispatcher = {
-            observe: async (what) => {
-                this.listeners.push(what);
-                await what();
-                return () => {
-                    this.listeners = this.listeners.filter(x => x != what);
-                };
-            }
+            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; });
+                                }];
+                    }
+                });
+            }); }
         };
     }
-    async fire() {
-        for (const l of this.listeners) {
-            await l();
-        }
-    }
-}
+    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;