remult 3.3.13 → 3.3.14

package/esm/src/context.js

@@ -170,7 +170,15 @@ export class Remult {
             return this.isAllowed(allowed);
         return undefined;
     }
+    /**
+     * @deprecated In SvelteKit, loads run in parallel, so reassigning the shared
+     * `remult` data provider here leaks across loads. Scope the fetch to the read
+     * with `withRemult` instead, e.g.
+     * `withRemult((r) => r.repo(X).find(), { dataProvider: new RestDataProvider(() => ({ httpClient: event.fetch })) })`.
+     * See the SvelteKit "Universal load & SSR" doc.
+     */
     useFetch(fetch) {
+        console.warn('[remult] `useFetch` is deprecated, see https://remult.dev/docs/installation/framework/sveltekit#extra-universal-load-ssr');
         this.dataProvider = new RestDataProvider(() => ({
             httpClient: fetch,
         }));

package/esm/src/remult-proxy.js

@@ -62,6 +62,11 @@ export class RemultProxy {
     clearAllCache() {
         return remultStatic.remultFactory().clearAllCache();
     }
+    /**
+     * @deprecated Mutating the shared request `remult` is unsafe (it can affect a
+     * concurrent `+page.server.ts` on the server). Scope the rest fetch to the read
+     * with `withRemult` instead - see the SvelteKit "Universal load & SSR" doc.
+     */
     useFetch(args) {
         return remultStatic.remultFactory().useFetch(args);
     }
@@ -71,9 +76,11 @@ export class RemultProxy {
         let self = remultStatic;
         let entityCache = this.repoCache.get(args[0]);
         if (!entityCache) {
-            this.repoCache.set(args[0], (entityCache = new Map()));
+            this.repoCache.set(args[0], (entityCache = { byDataProvider: new WeakMap() }));
         }
-        let result = entityCache.get(args[1]);
+        let result = args[1]
+            ? entityCache.byDataProvider.get(args[1])
+            : entityCache.default;
         if (result)
             return result;
         result = {
@@ -184,7 +191,10 @@ export class RemultProxy {
                 .repo(...args)
                 .update(a, b, c),
         };
-        entityCache.set(args[1], result);
+        if (args[1])
+            entityCache.byDataProvider.set(args[1], result);
+        else
+            entityCache.default = result;
         return result;
     };
     get user() {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "3.3.13",
+    "version": "3.3.14",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/src/context.d.ts

@@ -63,6 +63,13 @@ export declare class Remult {
      * [Allowed](https://remult.dev/docs/allowed.html)
      */
     isAllowedForInstance(instance: any, allowed?: AllowedForInstance<any>): boolean;
+    /**
+     * @deprecated In SvelteKit, loads run in parallel, so reassigning the shared
+     * `remult` data provider here leaks across loads. Scope the fetch to the read
+     * with `withRemult` instead, e.g.
+     * `withRemult((r) => r.repo(X).find(), { dataProvider: new RestDataProvider(() => ({ httpClient: event.fetch })) })`.
+     * See the SvelteKit "Universal load & SSR" doc.
+     */
     useFetch(fetch: ApiClient['httpClient']): void;
     /** The current data provider */
     dataProvider: DataProvider;

package/src/context.js

@@ -274,7 +274,15 @@ var Remult = /** @class */ (function () {
             return this.isAllowed(allowed);
         return undefined;
     };
+    /**
+     * @deprecated In SvelteKit, loads run in parallel, so reassigning the shared
+     * `remult` data provider here leaks across loads. Scope the fetch to the read
+     * with `withRemult` instead, e.g.
+     * `withRemult((r) => r.repo(X).find(), { dataProvider: new RestDataProvider(() => ({ httpClient: event.fetch })) })`.
+     * See the SvelteKit "Universal load & SSR" doc.
+     */
     Remult.prototype.useFetch = function (fetch) {
+        console.warn('[remult] `useFetch` is deprecated, see https://remult.dev/docs/installation/framework/sveltekit#extra-universal-load-ssr');
         this.dataProvider = new rest_data_provider_js_1.RestDataProvider(function () { return ({
             httpClient: fetch,
         }); });

package/src/remult-proxy.js

@@ -21,9 +21,11 @@ var RemultProxy = /** @class */ (function () {
             var self = remult_static_js_1.remultStatic;
             var entityCache = _this.repoCache.get(args[0]);
             if (!entityCache) {
-                _this.repoCache.set(args[0], (entityCache = new Map()));
+                _this.repoCache.set(args[0], (entityCache = { byDataProvider: new WeakMap() }));
             }
-            var result = entityCache.get(args[1]);
+            var result = args[1]
+                ? entityCache.byDataProvider.get(args[1])
+                : entityCache.default;
             if (result)
                 return result;
             result = (_a = {
@@ -245,7 +247,10 @@ var RemultProxy = /** @class */ (function () {
                         .repo.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(args), false)).update(a, b, c);
                 },
                 _a);
-            entityCache.set(args[1], result);
+            if (args[1])
+                entityCache.byDataProvider.set(args[1], result);
+            else
+                entityCache.default = result;
             return result;
         };
     }
@@ -336,6 +341,11 @@ var RemultProxy = /** @class */ (function () {
     RemultProxy.prototype.clearAllCache = function () {
         return remult_static_js_1.remultStatic.remultFactory().clearAllCache();
     };
+    /**
+     * @deprecated Mutating the shared request `remult` is unsafe (it can affect a
+     * concurrent `+page.server.ts` on the server). Scope the rest fetch to the read
+     * with `withRemult` instead - see the SvelteKit "Universal load & SSR" doc.
+     */
     RemultProxy.prototype.useFetch = function (args) {
         return remult_static_js_1.remultStatic.remultFactory().useFetch(args);
     };