remult 3.3.12 → 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/data-api.js

@@ -113,9 +113,16 @@ export class DataApi {
         }
         try {
             let { aggregate, ...rest } = body;
+            // The aggregate summarizes the whole filtered set, so it must not inherit
+            // the items query's paging/sorting/selection.
+            const aggregateRequest = {
+                get: (key) => ['_limit', '_page', '_sort', '_order', '_select'].includes(key)
+                    ? undefined
+                    : request?.get(key),
+            };
             let [{ r }, [aggregates]] = await Promise.all([
                 this.getArrayImpl(request, rest),
-                this.groupBy(request, { ...aggregate, where: body.where }),
+                this.groupBy(aggregateRequest, { ...aggregate, where: body.where }),
             ]);
             return {
                 items: r,

package/esm/src/data-providers/sql-database.js

@@ -545,6 +545,7 @@ export function getRowAfterUpdate(meta, dataProvider, data, id, operation) {
 export async function groupByImpl(options, e, r, orderByNullFirst, limitSyntax) {
     let select = 'select count(*) as count';
     let groupBy = '';
+    const groupByCols = [];
     const processResultRow = [];
     processResultRow.push((sqlVal, theResult) => {
         theResult[GroupByCountMember] = Number(sqlVal);
@@ -562,6 +563,7 @@ export async function groupByImpl(options, e, r, orderByNullFirst, limitSyntax)
                 else
                     groupBy += ', ';
                 groupBy += e.$dbNameOf(x);
+                groupByCols.push(e.$dbNameOf(x));
             }
             processResultRow.push((sqlResult, theResult) => {
                 theResult[x.key] = x.valueConverter.fromDb(sqlResult);
@@ -625,7 +627,13 @@ export async function groupByImpl(options, e, r, orderByNullFirst, limitSyntax)
         if (orderBy)
             select += orderBy;
     }
-    if (options?.limit) {
+    // Skip paging for a pure aggregate (single row); OFFSET/FETCH without an
+    // ORDER BY is also invalid on SQL Server.
+    if (options?.limit && groupByCols.length) {
+        // SQL Server requires an ORDER BY alongside OFFSET/FETCH; default to the
+        // group columns so paging is valid and deterministic on every dialect.
+        if (!orderBy)
+            select += ' order by ' + groupByCols.join(', ');
         let page = 1;
         if (options.page)
             page = options.page;

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.12",
+    "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/data-api.js

@@ -187,7 +187,7 @@ var DataApi = /** @class */ (function () {
     };
     DataApi.prototype.query = function (response, request, body) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var aggregate, rest, _a, r, _b, aggregates, err_2;
+            var aggregate, rest, aggregateRequest, _a, r, _b, aggregates, err_2;
             return tslib_1.__generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
@@ -198,10 +198,20 @@ var DataApi = /** @class */ (function () {
                         _c.label = 1;
                     case 1:
                         _c.trys.push([1, 3, , 4]);
-                        aggregate = body.aggregate, rest = tslib_1.__rest(body, ["aggregate"]);
+                        aggregate = body.aggregate, rest = tslib_1.__rest(body
+                        // The aggregate summarizes the whole filtered set, so it must not inherit
+                        // the items query's paging/sorting/selection.
+                        , ["aggregate"]);
+                        aggregateRequest = {
+                            get: function (key) {
+                                return ['_limit', '_page', '_sort', '_order', '_select'].includes(key)
+                                    ? undefined
+                                    : request === null || request === void 0 ? void 0 : request.get(key);
+                            },
+                        };
                         return [4 /*yield*/, Promise.all([
                                 this.getArrayImpl(request, rest),
-                                this.groupBy(request, tslib_1.__assign(tslib_1.__assign({}, aggregate), { where: body.where })),
+                                this.groupBy(aggregateRequest, tslib_1.__assign(tslib_1.__assign({}, aggregate), { where: body.where })),
                             ])];
                     case 2:
                         _a = tslib_1.__read.apply(void 0, [_c.sent(), 2]), r = _a[0].r, _b = tslib_1.__read(_a[1], 1), aggregates = _b[0];

package/src/data-providers/sql-database.js

@@ -843,13 +843,14 @@ function groupByImpl(options, e, r, orderByNullFirst, limitSyntax) {
                 ? "count (distinct ".concat(dbName, ")")
                 : "".concat(operator, "( ").concat(dbName, " )");
         }
-        var select, groupBy, processResultRow, _loop_1, _a, _b, x, _loop_2, GroupByOperators_1, GroupByOperators_1_1, operator, e_8_1, where, _c, orderBy, _d, _e, x, field, _f, e_9_1, page, result;
+        var select, groupBy, groupByCols, processResultRow, _loop_1, _a, _b, x, _loop_2, GroupByOperators_1, GroupByOperators_1_1, operator, e_8_1, where, _c, orderBy, _d, _e, x, field, _f, e_9_1, page, result;
         var e_10, _g, e_8, _h, e_9, _j;
         return tslib_1.__generator(this, function (_k) {
             switch (_k.label) {
                 case 0:
                     select = 'select count(*) as count';
                     groupBy = '';
+                    groupByCols = [];
                     processResultRow = [];
                     processResultRow.push(function (sqlVal, theResult) {
                         theResult[remult3_js_1.GroupByCountMember] = Number(sqlVal);
@@ -867,6 +868,7 @@ function groupByImpl(options, e, r, orderByNullFirst, limitSyntax) {
                                 else
                                     groupBy += ', ';
                                 groupBy += e.$dbNameOf(x);
+                                groupByCols.push(e.$dbNameOf(x));
                             }
                             processResultRow.push(function (sqlResult, theResult) {
                                 theResult[x.key] = x.valueConverter.fromDb(sqlResult);
@@ -1049,7 +1051,13 @@ function groupByImpl(options, e, r, orderByNullFirst, limitSyntax) {
                         select += orderBy;
                     _k.label = 20;
                 case 20:
-                    if (options === null || options === void 0 ? void 0 : options.limit) {
+                    // Skip paging for a pure aggregate (single row); OFFSET/FETCH without an
+                    // ORDER BY is also invalid on SQL Server.
+                    if ((options === null || options === void 0 ? void 0 : options.limit) && groupByCols.length) {
+                        // SQL Server requires an ORDER BY alongside OFFSET/FETCH; default to the
+                        // group columns so paging is valid and deterministic on every dialect.
+                        if (!orderBy)
+                            select += ' order by ' + groupByCols.join(', ');
                         page = 1;
                         if (options.page)
                             page = options.page;

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);
     };