remult 0.15.5-exp.1 → 0.15.5-exp.2

package/esm/src/data-providers/rest-data-provider.js

@@ -132,6 +132,12 @@ export class RestDataProviderHttpProviderUsingFetch {
         var h = init.headers;
         h.append('Content-type', "application/json");
         init.credentials = 'include';
+        if (typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof (window.document.cookie !== 'undefined'))
+            for (const cookie of window.document.cookie.split(';')) {
+                if (cookie.trim().startsWith('XSRF-TOKEN=')) {
+                    h.append('X-XSRF-TOKEN', cookie.split('=')[1]);
+                }
+            }
         return (this.fetch || fetch)(url, init).then(response => {
             return onSuccess(response);
         }).catch(async (error) => {

package/esm/src/remult-proxy.d.ts

@@ -0,0 +1,2 @@
+import { Remult } from "./context";
+export declare const remult: Remult;

package/esm/src/remult-proxy.js

@@ -0,0 +1,48 @@
+import { Remult } from "./context";
+import { RepositoryImplementation } from "./remult3";
+let defaultRemult = new Remult();
+/*@internal*/
+export class RemultProxy {
+    constructor() {
+        /*@internal*/
+        this.remultFactory = () => defaultRemult;
+        this.repo = (...args) => this.remultFactory().repo(...args);
+    }
+    call(backendMethod, self) {
+        return this.remultFactory().call(backendMethod, self);
+    }
+    get context() {
+        return this.remultFactory().context;
+    }
+    get dataProvider() { return this.remultFactory().dataProvider; }
+    ;
+    set dataProvider(provider) { this.remultFactory().dataProvider = provider; }
+    get repCache() { return this.remultFactory().repCache; }
+    ;
+    authenticated() {
+        return this.remultFactory().authenticated();
+    }
+    isAllowed(roles) {
+        return this.remultFactory().isAllowed(roles);
+    }
+    isAllowedForInstance(instance, allowed) {
+        return this.remultFactory().isAllowedForInstance(instance, allowed);
+    }
+    clearAllCache() {
+        return this.remultFactory().clearAllCache();
+    }
+    get user() {
+        return this.remultFactory().user;
+    }
+    set user(info) {
+        this.remultFactory().user = info;
+    }
+    get apiClient() {
+        return this.remultFactory().apiClient;
+    }
+    set apiClient(client) {
+        this.remultFactory().apiClient = client;
+    }
+}
+export const remult = new RemultProxy();
+RepositoryImplementation.defaultRemult = remult;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.15.5-exp.1",
+    "version": "0.15.5-exp.2",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",

package/src/data-providers/rest-data-provider.js

@@ -198,6 +198,7 @@ var RestDataProviderHttpProviderUsingFetch = /** @class */ (function () {
         });
     };
     RestDataProviderHttpProviderUsingFetch.prototype.myFetch = function (url, init) {
+        var e_4, _a;
         var _this = this;
         if (!init)
             init = {};
@@ -206,6 +207,22 @@ var RestDataProviderHttpProviderUsingFetch = /** @class */ (function () {
         var h = init.headers;
         h.append('Content-type', "application/json");
         init.credentials = 'include';
+        if (typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof (window.document.cookie !== 'undefined'))
+            try {
+                for (var _b = tslib_1.__values(window.document.cookie.split(';')), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var cookie = _c.value;
+                    if (cookie.trim().startsWith('XSRF-TOKEN=')) {
+                        h.append('X-XSRF-TOKEN', cookie.split('=')[1]);
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
         return (this.fetch || fetch)(url, init).then(function (response) {
             return onSuccess(response);
         }).catch(function (error) { return tslib_1.__awaiter(_this, void 0, void 0, function () {

package/src/remult-proxy.d.ts

@@ -0,0 +1,2 @@
+import { Remult } from "./context";
+export declare const remult: Remult;

package/src/remult-proxy.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remult = exports.RemultProxy = void 0;
+var tslib_1 = require("tslib");
+var context_1 = require("./context");
+var remult3_1 = require("./remult3");
+var defaultRemult = new context_1.Remult();
+/*@internal*/
+var RemultProxy = /** @class */ (function () {
+    function RemultProxy() {
+        var _this = this;
+        /*@internal*/
+        this.remultFactory = function () { return defaultRemult; };
+        this.repo = function () {
+            var _a;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return (_a = _this.remultFactory()).repo.apply(_a, tslib_1.__spread(args));
+        };
+    }
+    RemultProxy.prototype.call = function (backendMethod, self) {
+        return this.remultFactory().call(backendMethod, self);
+    };
+    Object.defineProperty(RemultProxy.prototype, "context", {
+        get: function () {
+            return this.remultFactory().context;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RemultProxy.prototype, "dataProvider", {
+        get: function () { return this.remultFactory().dataProvider; },
+        set: function (provider) { this.remultFactory().dataProvider = provider; },
+        enumerable: false,
+        configurable: true
+    });
+    ;
+    Object.defineProperty(RemultProxy.prototype, "repCache", {
+        get: function () { return this.remultFactory().repCache; },
+        enumerable: false,
+        configurable: true
+    });
+    ;
+    RemultProxy.prototype.authenticated = function () {
+        return this.remultFactory().authenticated();
+    };
+    RemultProxy.prototype.isAllowed = function (roles) {
+        return this.remultFactory().isAllowed(roles);
+    };
+    RemultProxy.prototype.isAllowedForInstance = function (instance, allowed) {
+        return this.remultFactory().isAllowedForInstance(instance, allowed);
+    };
+    RemultProxy.prototype.clearAllCache = function () {
+        return this.remultFactory().clearAllCache();
+    };
+    Object.defineProperty(RemultProxy.prototype, "user", {
+        get: function () {
+            return this.remultFactory().user;
+        },
+        set: function (info) {
+            this.remultFactory().user = info;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RemultProxy.prototype, "apiClient", {
+        get: function () {
+            return this.remultFactory().apiClient;
+        },
+        set: function (client) {
+            this.remultFactory().apiClient = client;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RemultProxy;
+}());
+exports.RemultProxy = RemultProxy;
+exports.remult = new RemultProxy();
+remult3_1.RepositoryImplementation.defaultRemult = exports.remult;