remult 0.25.8 → 0.26.0

package/server/expressBridge.js

@@ -16,6 +16,7 @@ var server_action_info_js_1 = require("../src/server-action-info.js");
 var initDataProvider_js_1 = require("./initDataProvider.js");
 var remult_static_js_1 = require("../src/remult-static.js");
 var remult_admin_js_1 = tslib_1.__importDefault(require("./remult-admin.js"));
+var isOfType_js_1 = require("../src/isOfType.js");
 function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
@@ -443,16 +444,16 @@ var RemultServerImplementation = /** @class */ (function () {
             return tslib_1.__generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
-                        _b = (_a = dataApiFactory(c)).put;
+                        _b = (_a = dataApiFactory(c)).updateManyThroughPutRequest;
                         _c = [res,
-                            ''];
+                            req];
                         return [4 /*yield*/, this.coreOptions.getRequestBody(orig)];
                     case 1: return [2 /*return*/, _b.apply(_a, _c.concat([_d.sent()]))];
                 }
             });
         }); }))
-            .delete(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-            return [2 /*return*/, dataApiFactory(c).delete(res, '')];
+            .delete(this.process(function (c, req, res, _, __, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, dataApiFactory(c).deleteMany(res, req, undefined)];
         }); }); }))
             .post(this.process(function (c, req, res, _, __, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var _a, _b, _c;
@@ -543,7 +544,7 @@ var RemultServerImplementation = /** @class */ (function () {
                                 genReq.params = req['_tempParams'];
                         }
                         myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
-                        myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req);
+                        myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req, this.options.error);
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 3, , 4]);
@@ -592,7 +593,7 @@ var RemultServerImplementation = /** @class */ (function () {
                         return [3 /*break*/, 4];
                     case 3:
                         err_1 = _a.sent();
-                        myRes.error((0, data_api_js_1.serializeError)(err_1));
+                        myRes.error(err_1, undefined);
                         return [3 /*break*/, 4];
                     case 4: return [2 /*return*/];
                 }
@@ -791,6 +792,17 @@ var RemultServerImplementation = /** @class */ (function () {
                     return secureBase(condition, def, item);
                 };
                 var apiPath = (spec.paths[this_2.options.rootPath + '/' + key] = {});
+                var itemInBody = {
+                    requestBody: {
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: '#/components/schemas/' + mutationKey,
+                                },
+                            },
+                        },
+                    },
+                };
                 var apiPathWithId = (spec.paths[this_2.options.rootPath + '/' + key + '/{id}'] = {});
                 //https://github.com/2fd/open-api.d.ts
                 apiPath.get = secure(meta.options.allowApiRead, true, {
@@ -842,6 +854,68 @@ var RemultServerImplementation = /** @class */ (function () {
                         },
                     },
                 });
+                apiPath.delete = secure(meta.options.allowApiDelete, true, {
+                    description: 'deletes row of ' +
+                        key +
+                        '. supports filter operators. For more info on filtering [see this article](https://remult.dev/docs/rest-api.html#filter)',
+                    parameters: tslib_1.__spreadArray([], tslib_1.__read(parameters), false),
+                    responses: {
+                        '400': {
+                            description: 'Error: Bad Request',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        $ref: '#/components/schemas/InvalidResponse',
+                                    },
+                                },
+                            },
+                        },
+                        '200': {
+                            description: 'returns the number of deleted rows ' + key,
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            deleted: {
+                                                type: 'number',
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                apiPath.put = secure(meta.options.allowApiDelete, true, tslib_1.__assign(tslib_1.__assign({ description: 'updates row of ' +
+                        key +
+                        '. supports filter operators. For more info on filtering [see this article](https://remult.dev/docs/rest-api.html#filter)', parameters: tslib_1.__spreadArray([], tslib_1.__read(parameters), false) }, itemInBody), { responses: {
+                        '400': {
+                            description: 'Error: Bad Request',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        $ref: '#/components/schemas/InvalidResponse',
+                                    },
+                                },
+                            },
+                        },
+                        '200': {
+                            description: 'returns the number of updated rows ' + key,
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            updated: {
+                                                type: 'number',
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    } }));
                 var idParameter = {
                     name: 'id',
                     in: 'path',
@@ -849,17 +923,6 @@ var RemultServerImplementation = /** @class */ (function () {
                     required: true,
                     schema: { type: 'string' },
                 };
-                var itemInBody = {
-                    requestBody: {
-                        content: {
-                            'application/json': {
-                                schema: {
-                                    $ref: '#/components/schemas/' + mutationKey,
-                                },
-                            },
-                        },
-                    },
-                };
                 apiPath.post = secure(meta.options.allowApiInsert, false, tslib_1.__assign(tslib_1.__assign({ 
                     //"summary": "insert a " + key,
                     //"description": "insert a " + key,
@@ -1001,12 +1064,13 @@ var ExpressRequestBridgeToDataApiRequest = /** @class */ (function () {
     return ExpressRequestBridgeToDataApiRequest;
 }());
 var ExpressResponseBridgeToDataApiResponse = /** @class */ (function () {
-    function ExpressResponseBridgeToDataApiResponse(r, req) {
+    function ExpressResponseBridgeToDataApiResponse(r, req, handleError) {
         this.r = r;
         this.req = req;
+        this.handleError = handleError;
     }
     ExpressResponseBridgeToDataApiResponse.prototype.forbidden = function () {
-        this.setStatus(403).end();
+        this.error({ message: 'Forbidden' }, undefined, 403);
     };
     ExpressResponseBridgeToDataApiResponse.prototype.setStatus = function (status) {
         return this.r.status(status);
@@ -1022,24 +1086,68 @@ var ExpressResponseBridgeToDataApiResponse = /** @class */ (function () {
         this.setStatus(204).end();
     };
     ExpressResponseBridgeToDataApiResponse.prototype.notFound = function () {
-        this.setStatus(404).end();
+        this.error({ message: 'Forbidden' }, undefined, 404);
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.error = function (data) {
-        var _a, _b, _c;
-        data = (0, data_api_js_1.serializeError)(data);
-        console.error({
-            message: data.message,
-            stack: (_a = data.stack) === null || _a === void 0 ? void 0 : _a.split('\n'),
-            url: (_b = this.req) === null || _b === void 0 ? void 0 : _b.url,
-            method: (_c = this.req) === null || _c === void 0 ? void 0 : _c.method,
+    ExpressResponseBridgeToDataApiResponse.prototype.error = function (exception, entity, httpStatusCode) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var data, responseSent, sendError;
+            var _this = this;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        data = (0, data_api_js_1.serializeError)(exception);
+                        if (!httpStatusCode) {
+                            if (data.httpStatusCode) {
+                                httpStatusCode = data.httpStatusCode;
+                            }
+                            else if ((0, isOfType_js_1.isOfType)(exception, 'isForbiddenError') &&
+                                exception.isForbiddenError) {
+                                httpStatusCode = 403;
+                            }
+                            else if (data.modelState) {
+                                httpStatusCode = 400;
+                            }
+                            else {
+                                httpStatusCode = 500;
+                            }
+                        }
+                        responseSent = false;
+                        sendError = function (httpStatusCode, body) {
+                            var _a, _b, _c;
+                            if (responseSent) {
+                                throw Error('Error response already sent');
+                            }
+                            responseSent = true;
+                            console.error({
+                                message: body.message,
+                                httpStatusCode: httpStatusCode,
+                                stack: (_a = data.stack) === null || _a === void 0 ? void 0 : _a.split('\n'),
+                                url: (_b = _this.req) === null || _b === void 0 ? void 0 : _b.url,
+                                method: (_c = _this.req) === null || _c === void 0 ? void 0 : _c.method,
+                            });
+                            _this.setStatus(httpStatusCode).json(body);
+                        };
+                        return [4 /*yield*/, ((_a = this.handleError) === null || _a === void 0 ? void 0 : _a.call(this, {
+                                httpStatusCode: httpStatusCode,
+                                req: this.req,
+                                entity: entity,
+                                exception: exception,
+                                responseBody: data,
+                                sendError: sendError,
+                            }))];
+                    case 1:
+                        _b.sent();
+                        if (!responseSent) {
+                            sendError(httpStatusCode, data);
+                        }
+                        return [2 /*return*/];
+                }
+            });
         });
-        this.setStatus(400).json(data);
     };
     return ExpressResponseBridgeToDataApiResponse;
 }());
-function throwError() {
-    throw 'Invalid';
-}
 var inProcessQueueHandler = /** @class */ (function () {
     function inProcessQueueHandler(storage) {
         this.storage = storage;

package/server/initAsyncHooks.d.ts

@@ -1 +1,17 @@
+import { type RemultAsyncLocalStorageCore } from '../src/context.js';
 export declare function initAsyncHooks(): void;
+export declare class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl<T> implements RemultAsyncLocalStorageCore<T> {
+    private asyncLocalStorage;
+    wasImplemented: 'yes';
+    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
+    getStore(): T;
+}
+export declare class SequentialRemultAsyncLocalStorageCore<T> implements RemultAsyncLocalStorageCore<T> {
+    wasImplemented: 'yes';
+    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
+    getStore(): T;
+    lastPromise: Promise<T>;
+    currentValue: T;
+}
+export declare class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore<T> extends AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl<T> {
+}

package/server/initAsyncHooks.js

@@ -1,14 +1,140 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initAsyncHooks = void 0;
+exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = exports.SequentialRemultAsyncLocalStorageCore = exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = exports.initAsyncHooks = void 0;
+var tslib_1 = require("tslib");
 var async_hooks_1 = require("async_hooks");
 var context_js_1 = require("../src/context.js");
 var remult_static_js_1 = require("../src/remult-static.js");
 var init = false;
 function initAsyncHooks() {
+    var _this = this;
     if (init)
         return;
     init = true;
-    remult_static_js_1.remultStatic.asyncContext = new context_js_1.RemultAsyncLocalStorage(new async_hooks_1.AsyncLocalStorage());
+    remult_static_js_1.remultStatic.asyncContext = new context_js_1.RemultAsyncLocalStorage(new AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore());
+    var test = new async_hooks_1.AsyncLocalStorage();
+    test.run(1, function () { 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*/, Promise.resolve()];
+                case 1:
+                    _a.sent();
+                    if (test.getStore() === undefined) {
+                        console.log("async_hooks.AsyncLocalStorage not working, using sequential implementation (You're probably running on stackblitz, this will work on a normal nodejs environment");
+                        remult_static_js_1.remultStatic.asyncContext = new context_js_1.RemultAsyncLocalStorage(new SequentialRemultAsyncLocalStorageCore());
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 }
 exports.initAsyncHooks = initAsyncHooks;
+var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = /** @class */ (function () {
+    function AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl() {
+        this.asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+    }
+    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl.prototype.run = function (store, callback) {
+        var _this = this;
+        var r;
+        this.asyncLocalStorage.run(store, function () {
+            r = new Promise(function (res, rej) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var _a, err_1;
+                return tslib_1.__generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _b.trys.push([0, 2, , 3]);
+                            _a = res;
+                            return [4 /*yield*/, callback()];
+                        case 1:
+                            _a.apply(void 0, [_b.sent()]);
+                            return [3 /*break*/, 3];
+                        case 2:
+                            err_1 = _b.sent();
+                            rej(err_1);
+                            return [3 /*break*/, 3];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+        return r;
+    };
+    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl.prototype.getStore = function () {
+        return this.asyncLocalStorage.getStore();
+    };
+    return AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl;
+}());
+exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl;
+var ignoreInStack = ["AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.run", "RemultAsyncLocalStorage.run", "Module.withRemult", "RemultServerImplementation.runWithRemult"];
+var SequentialRemultAsyncLocalStorageCore = /** @class */ (function () {
+    function SequentialRemultAsyncLocalStorageCore() {
+        this.lastPromise = Promise.resolve(undefined);
+    }
+    SequentialRemultAsyncLocalStorageCore.prototype.run = function (store, callback) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var log, stack_1, y, nextPromise;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        log = function (msg) {
+                        };
+                        if (false) {
+                            stack_1 = new Error().stack;
+                            y = stack_1.split('\n');
+                            while (y.length > 0 && (y[0].trim().startsWith("Error") || ignoreInStack.includes(y[0].trim().split(' ')[1]))) {
+                                y.splice(0, 1);
+                            }
+                            stack_1 = y.join('\n');
+                            log = function (msg) {
+                                console.log(msg, stack_1);
+                            };
+                        }
+                        log('waiting on ');
+                        nextPromise = this.lastPromise.then(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var previousValue, result;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        log('executing  ');
+                                        previousValue = this.currentValue;
+                                        this.currentValue = store;
+                                        return [4 /*yield*/, callback()];
+                                    case 1:
+                                        result = _a.sent();
+                                        this.currentValue = previousValue;
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); });
+                        this.lastPromise = nextPromise.catch(function () {
+                            log("Error on ");
+                            return undefined;
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, nextPromise];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3:
+                        log('completed  ');
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SequentialRemultAsyncLocalStorageCore.prototype.getStore = function () {
+        return this.currentValue;
+    };
+    return SequentialRemultAsyncLocalStorageCore;
+}());
+exports.SequentialRemultAsyncLocalStorageCore = SequentialRemultAsyncLocalStorageCore;
+var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = /** @class */ (function (_super) {
+    tslib_1.__extends(AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore, _super);
+    function AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore;
+}(AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl));
+exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore;

package/src/CompoundIdField.js

@@ -28,11 +28,17 @@ var CompoundIdField = /** @class */ (function () {
         return Promise.resolve('');
     };
     CompoundIdField.prototype.getId = function (instance) {
+        var get = function (field) {
+            return instance[field.key];
+        };
+        if (typeof instance === 'function') {
+            get = instance;
+        }
         var r = '';
         this.fields.forEach(function (c) {
             if (r.length > 0)
                 r += ',';
-            r += instance[c.key];
+            r += c.valueConverter.toJson(get(c));
         });
         return r;
     };
@@ -48,7 +54,7 @@ var CompoundIdField = /** @class */ (function () {
         var val = value.toString();
         var id = val.split(',');
         this.fields.forEach(function (c, i) {
-            result[c.key] = id[i];
+            result[c.key] = c.valueConverter.fromJson(id[i]);
         });
         return result;
     };

package/src/column-interfaces.d.ts

@@ -247,17 +247,23 @@ export interface ValueConverter<valueType> {
      */
     displayValue?(val: valueType): string;
     /**
-     * Specifies the storage type used in the database for this field.
+     * Specifies the storage type used in the database for this field. This can be used to explicitly define the data type and precision of the field in the database.
      *
      * @example
-     * readonly fieldTypeInDb = 'decimal(18,2)';
+     * // Define a field with a specific decimal precision in the database
+     * @Fields.number({
+     *   valueConverter: {
+     *     fieldTypeInDb: 'decimal(18,8)'
+     *   }
+     * })
+     * price=0;
      */
     readonly fieldTypeInDb?: string;
     /**
      * Specifies the type of HTML input element suitable for values of valueType.
      *
      * @example
-     * readonly inputType = 'date';
+     * inputType = 'date';
      */
     readonly inputType?: string;
 }

package/src/context.d.ts

@@ -8,13 +8,14 @@ export declare class RemultAsyncLocalStorage {
     private readonly remultObjectStorage;
     static enable(): void;
     static disable(): void;
-    constructor(remultObjectStorage: myAsyncLocalStorage<Remult>);
-    run(remult: Remult, callback: (remult: Remult) => void): void;
+    constructor(remultObjectStorage: RemultAsyncLocalStorageCore<Remult>);
+    run<T>(remult: Remult, callback: (remult: Remult) => Promise<T>): Promise<T>;
     getRemult(): Remult;
 }
-type myAsyncLocalStorage<T> = {
-    run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;
+export type RemultAsyncLocalStorageCore<T> = {
+    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
     getStore(): T | undefined;
+    wasImplemented: 'yes';
 };
 export declare function isBackend(): boolean;
 export declare class Remult {
@@ -92,6 +93,8 @@ export interface ApiClient {
      * @example
      * // Using Angular HttpClient
      * remult.apiClient.httpClient = httpClient;
+     * @see
+     * If you want to add headers using angular httpClient, see: https://medium.com/angular-shots/shot-3-how-to-add-http-headers-to-every-request-in-angular-fab3d10edc26
      *
      * @example
      * // Using fetch (default)
@@ -183,8 +186,7 @@ export interface itemChange {
     oldId: any;
     deleted: boolean;
 }
-export declare function doTransaction(remult: Remult, what: () => Promise<void>): Promise<void>;
+export declare function doTransaction(remult: Remult, what: (dp: DataProvider) => Promise<void>): Promise<void>;
 export declare function withRemult<T>(callback: (remult: any) => Promise<T>, options?: {
     dataProvider?: DataProvider;
 }): Promise<T>;
-export {};

package/src/context.js

@@ -28,10 +28,16 @@ var RemultAsyncLocalStorage = /** @class */ (function () {
         (0, remult_static_js_1.resetFactory)();
     };
     RemultAsyncLocalStorage.prototype.run = function (remult, callback) {
-        if (this.remultObjectStorage)
-            this.remultObjectStorage.run(remult, function () { return callback(remult); });
-        else
-            callback(remult);
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                if (this.remultObjectStorage) {
+                    return [2 /*return*/, this.remultObjectStorage.run(remult, function () { return callback(remult); })];
+                }
+                else
+                    return [2 /*return*/, callback(remult)];
+                return [2 /*return*/];
+            });
+        });
     };
     RemultAsyncLocalStorage.prototype.getRemult = function () {
         if (!this.remultObjectStorage) {
@@ -322,20 +328,24 @@ var EventSource = /** @class */ (function () {
 exports.EventSource = EventSource;
 function doTransaction(remult, what) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var trans, ok, result;
+        var trans, ok, prev;
         var _this = this;
         return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     trans = new transactionLiveQueryPublisher(remult.liveQueryPublisher);
                     ok = true;
+                    prev = remult.dataProvider;
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, , 5, 6]);
                     return [4 /*yield*/, remult.dataProvider.transaction(function (ds) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                             return tslib_1.__generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
                                         remult.dataProvider = ds;
                                         remult.liveQueryPublisher = trans;
-                                        return [4 /*yield*/, what()];
+                                        return [4 /*yield*/, what(ds)];
                                     case 1:
                                         _a.sent();
                                         ok = true;
@@ -343,14 +353,18 @@ function doTransaction(remult, what) {
                                 }
                             });
                         }); })];
-                case 1:
-                    result = _a.sent();
-                    if (!ok) return [3 /*break*/, 3];
-                    return [4 /*yield*/, trans.flush()];
                 case 2:
                     _a.sent();
-                    _a.label = 3;
-                case 3: return [2 /*return*/];
+                    if (!ok) return [3 /*break*/, 4];
+                    return [4 /*yield*/, trans.flush()];
+                case 3:
+                    _a.sent();
+                    _a.label = 4;
+                case 4: return [3 /*break*/, 6];
+                case 5:
+                    remult.dataProvider = prev;
+                    return [7 /*endfinally*/];
+                case 6: return [2 /*return*/];
             }
         });
     });
@@ -441,32 +455,9 @@ var transactionLiveQueryPublisher = /** @class */ (function () {
     return transactionLiveQueryPublisher;
 }());
 function withRemult(callback, options) {
-    var _this = this;
     var remult = new Remult();
     if (options === null || options === void 0 ? void 0 : options.dataProvider)
         remult.dataProvider = options.dataProvider;
-    var r;
-    remult_static_js_1.remultStatic.asyncContext.run(remult, function () {
-        r = new Promise(function (res, rej) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var _a, err_1;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 2, , 3]);
-                        _a = res;
-                        return [4 /*yield*/, callback(remult)];
-                    case 1:
-                        _a.apply(void 0, [_b.sent()]);
-                        return [3 /*break*/, 3];
-                    case 2:
-                        err_1 = _b.sent();
-                        rej(err_1);
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    return r;
+    return remult_static_js_1.remultStatic.asyncContext.run(remult, function (r) { return callback(r); });
 }
 exports.withRemult = withRemult;

package/src/data-api.d.ts

@@ -1,6 +1,6 @@
 import type { Remult } from './context.js';
 import type { ErrorInfo } from './data-interfaces.js';
-import type { FindOptions, Repository } from './remult3/remult3.js';
+import type { EntityMetadata, FindOptions, Repository } from './remult3/remult3.js';
 import type { rowHelperImplementation } from './remult3/RepositoryImplementation.js';
 export declare class DataApi<T = any> {
     private repository;
@@ -10,18 +10,22 @@ export declare class DataApi<T = any> {
     httpPost(res: DataApiResponse, req: DataApiRequest, body: any, serializeContext: () => Promise<any>): Promise<void>;
     static defaultGetLimit: number;
     get(response: DataApiResponse, id: any): Promise<void>;
-    count(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
-    deleteMany(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
-    getArrayImpl(response: DataApiResponse, request: DataApiRequest, filterBody: any): Promise<{
+    count(response: DataApiResponse, request: DataApiRequest, body?: any): Promise<void>;
+    deleteMany(response: DataApiResponse, request: DataApiRequest, body?: any): Promise<void>;
+    getArrayImpl(response: DataApiResponse, request: DataApiRequest, body: any): Promise<{
         r: any[];
         findOptions: FindOptions<T>;
     }>;
     private includeNone;
-    getArray(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
-    liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeContext: () => Promise<any>, queryChannel: string): Promise<void>;
+    getArray(response: DataApiResponse, request: DataApiRequest, body?: any): Promise<void>;
+    liveQuery(response: DataApiResponse, request: DataApiRequest, body: any, serializeContext: () => Promise<any>, queryChannel: string): Promise<void>;
     private buildWhere;
     private doOnId;
-    updateMany(response: DataApiResponse, request: DataApiRequest, body?: any): Promise<void>;
+    updateManyThroughPutRequest(response: DataApiResponse, request: DataApiRequest, body: any): Promise<void>;
+    updateManyImplementation(response: DataApiResponse, request: DataApiRequest, body: {
+        where: any;
+        set: any;
+    }): Promise<void>;
     actualUpdate(row: any, body: any): Promise<rowHelperImplementation<T>>;
     put(response: DataApiResponse, id: any, body: any): Promise<void>;
     actualDelete(row: any): Promise<void>;
@@ -33,8 +37,8 @@ export interface DataApiResponse {
     deleted(): void;
     created(data: any): void;
     notFound(): void;
-    error(data: ErrorInfo): void;
-    forbidden(): void;
+    error(data: ErrorInfo, entity: EntityMetadata | undefined, statusCode?: number | undefined): void;
+    forbidden(message?: string): void;
     progress(progress: number): void;
 }
 export interface DataApiRequest {