remult 0.27.5 → 0.27.7

package/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -473,7 +473,7 @@ function fieldDbName(f_1, meta_1) {
                     if (!f.options.sqlExpression) return [3 /*break*/, 7];
                     if (!(typeof f.options.sqlExpression === 'function')) return [3 /*break*/, 5];
                     if (f[sqlExpressionInProgressKey] && !forceSqlExpression) {
-                        return [2 /*return*/, "recursive sqlExpression call for field '" + f.key + "'. "];
+                        return [2 /*return*/, "recursive sqlExpression call for field '" + f.key + "'. \0"];
                     }
                     _a.label = 1;
                 case 1:
@@ -483,7 +483,8 @@ function fieldDbName(f_1, meta_1) {
                     return [4 /*yield*/, f.options.sqlExpression(meta)];
                 case 2:
                     result_1 = _a.sent();
-                    f.options.sqlExpression = function () { return result_1; };
+                    if (!result_1.includes('\0'))
+                        f.options.sqlExpression = function () { return result_1; };
                     return [3 /*break*/, 4];
                 case 3:
                     delete f[sqlExpressionInProgressKey];

package/src/live-query/SubscriptionServer.js

@@ -17,7 +17,7 @@ var LiveQueryPublisher = /** @class */ (function () {
             var _this = this;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.liveQueryStorage().forEach(entityKey, function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
+                    case 0: return [4 /*yield*/, this.runPromise(this.liveQueryStorage().forEach(entityKey, function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
                             var query;
                             var _this = this;
                             var q = _b.query, setData = _b.setData;
@@ -117,7 +117,7 @@ var LiveQueryPublisher = /** @class */ (function () {
                                         return [2 /*return*/];
                                 }
                             });
-                        }); })];
+                        }); }))];
                     case 1:
                         _a.sent();
                         return [2 /*return*/];

package/src/remult3/Fields.d.ts

@@ -52,7 +52,7 @@ export declare class Fields {
    * // This approach allows easy management and updates of the allowed values for the `status` field.
    */
     static literal<entityType = unknown, valueType extends string = string>(optionalValues: () => readonly valueType[], ...options: (StringFieldOptions<entityType, valueType> | ((options: StringFieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
-    static enum<entityType = unknown, theEnum = object>(enumType: () => theEnum, ...options: (FieldOptions<entityType, theEnum[keyof theEnum]> | ((options: FieldOptions<entityType, theEnum[keyof theEnum]>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, theEnum[keyof theEnum] | undefined>;
+    static enum<entityType = unknown, theEnum = unknown>(enumType: () => theEnum, ...options: (FieldOptions<entityType, theEnum[keyof theEnum]> | ((options: FieldOptions<entityType, theEnum[keyof theEnum]>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, theEnum[keyof theEnum] | undefined>;
     static string<entityType = unknown, valueType = string>(...options: (StringFieldOptions<entityType, valueType> | ((options: StringFieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
     static boolean<entityType = unknown>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, boolean | undefined>;
 }

package/src/remult3/RepositoryImplementation.js

@@ -2100,7 +2100,7 @@ var rowHelperImplementation = /** @class */ (function (_super) {
             return tslib_1.__generator(this, function (_t) {
                 switch (_t.label) {
                     case 0:
-                        _t.trys.push([0, , 41, 42]);
+                        _t.trys.push([0, , 40, 41]);
                         if (this._saving)
                             throw new Error('cannot save while entity is already saving');
                         this._saving = true;
@@ -2181,7 +2181,7 @@ var rowHelperImplementation = /** @class */ (function (_super) {
                         isNew = this.isNew();
                         _t.label = 13;
                     case 13:
-                        _t.trys.push([13, 38, , 40]);
+                        _t.trys.push([13, 37, , 39]);
                         (_r = this._subscribers) === null || _r === void 0 ? void 0 : _r.reportChanged();
                         if (!this.isNew()) return [3 /*break*/, 19];
                         if (!doNotSave_1) return [3 /*break*/, 16];
@@ -2267,23 +2267,22 @@ var rowHelperImplementation = /** @class */ (function (_super) {
                         }
                         finally { if (e_33) throw e_33.error; }
                         return [7 /*endfinally*/];
-                    case 36: return [4 /*yield*/, this.repo._remult.liveQueryPublisher.itemChanged(this.repo.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: false }])];
-                    case 37:
-                        _t.sent();
+                    case 36:
+                        this.repo._remult.liveQueryPublisher.itemChanged(this.repo.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: false }]);
                         this.saveOriginalData();
                         this._isNew = false;
                         return [2 /*return*/, this.instance];
-                    case 38:
+                    case 37:
                         err_1 = _t.sent();
                         return [4 /*yield*/, this.catchSaveErrors(err_1)];
-                    case 39: throw _t.sent();
-                    case 40: return [3 /*break*/, 42];
-                    case 41:
+                    case 38: throw _t.sent();
+                    case 39: return [3 /*break*/, 41];
+                    case 40:
                         this.isLoading = false;
                         this._reportChangedToEntityAndFields();
                         this._saving = false;
                         return [7 /*endfinally*/];
-                    case 42: return [2 /*return*/];
+                    case 41: return [2 /*return*/];
                 }
             });
         });
@@ -2382,7 +2381,7 @@ var rowHelperImplementation = /** @class */ (function (_super) {
                         this.__assertValidity();
                         _e.label = 3;
                     case 3:
-                        _e.trys.push([3, 17, , 19]);
+                        _e.trys.push([3, 16, , 18]);
                         if (!doDelete) return [3 /*break*/, 5];
                         return [4 /*yield*/, this.edp.delete(this.id)];
                     case 4:
@@ -2423,16 +2422,17 @@ var rowHelperImplementation = /** @class */ (function (_super) {
                         }
                         finally { if (e_36) throw e_36.error; }
                         return [7 /*endfinally*/];
-                    case 15: return [4 /*yield*/, this.repo._remult.liveQueryPublisher.itemChanged(this.repo.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: true }])];
-                    case 16:
-                        _e.sent();
+                    case 15:
+                        this.repo._remult.liveQueryPublisher.itemChanged(this.repo.metadata.key, [
+                            { id: this.getId(), oldId: this.getOriginalId(), deleted: true },
+                        ]);
                         this._wasDeleted = true;
-                        return [3 /*break*/, 19];
-                    case 17:
+                        return [3 /*break*/, 18];
+                    case 16:
                         err_2 = _e.sent();
                         return [4 /*yield*/, this.catchSaveErrors(err_2)];
-                    case 18: throw _e.sent();
-                    case 19: return [2 /*return*/];
+                    case 17: throw _e.sent();
+                    case 18: return [2 /*return*/];
                 }
             });
         });

package/src/remult3/remult3.js

@@ -4,51 +4,37 @@ exports.flags = void 0;
 exports.flags = {
     error500RetryCount: 4,
 };
-//y1 - Hacker News for the tutorial?
+//p1 - add transactional option to backend method
+//p1 - add parameter all to deleteMany, and updateMany
+//p1  filter.apply ApiPreFilter
+//p1 - min, max, avg, sum, countDistinct - noam come up with an api
+/*p1 - add id and use uuid by default, but allow changes with Fields.id.defaultIdProvider NO but defaultProvider yes???
+  //p1 - replace uuid with crypto.randomUUID and allow custom fallback NO
+  //p1 - Add example for luid
+  //p1 - add example for nanoid
+  //p1 - explain the benefits of changing the default provider for testing in docs.
+*/
+//p1 - consider upsert (where,set)
+//p1 TODO - consider id to also support keyof (id:['company','index']) - had problem with | (keyof Partial<entityType>)[] & `entity`
+//p2 - add some kind of options handler that will help with translation etc... like in hagai - something that runs at the stage where options are being built
 /*y1 - https://github.com/remult/remult/discussions/438
      - https://github.com/remult/remult/blob/query-argumets/projects/tests/dbs/test-sql-database.spec.ts#L100-L128
-     //p2 - allow preprocess to replace filter values - for example replace $contains on a specific field, with specific other sql - useful for full text search and other scenarios
      //y1 - consider sql expression gets a dbnames of it's own (that already has the "tableName" defined correctly) maybe also the filter translator
+     //p2 - allow preprocess to replace filter values - for example replace $contains on a specific field, with specific other sql - useful for full text search and other scenarios
      //y2 - soft-delete-discussion https://discord.com/channels/975754286384418847/1230386433093533698/1230386433093533698
 */
-//y1 - add parameter all to deleteMany, and updateMany
-//p1 - fix query docs to also explain how it can be used for infinite scroll and pagination.
-//p1 - when like doesn't have a string - don't send it to the db
-//y1 - 'test expression columns without aliases'
-//y1 - live query update waits for last
-//p1 - add luid - it's cool for order by. - NO
-//p1 - replace uuid with crypto.randomUUID and allow custom fallback NO
-//p1 - add nanoid - NO
-//p1 - add id and use luid by default, but allow changes with Fields.id.defaultIdProvider NO but defaultProvider yes
-/*p1
- * field, fieldType ,ValueListFieldType, - return optional parameter for decorators
- * options to remultExpress tc... should be mandatory
- * return value converter to previous typing
- * add breaking change notification about findOne and findFirst and findId
- */
-//p1 - fix query docs to also explain how it can be used for infinite scroll and pagination.
-//y1 - 'test expression columns without aliases'
-//y1 - ts issue with fields - when a field is optional, it's $ is also optional and thats a problem
+//p2 - fix query docs to also explain how it can be used for infinite scroll and pagination.
+//p2 - when like doesn't have a string - don't send it to the db
 //p1 - vite 5.3 supports ts5 decorators - check and adapt.
-//p1 - see if I can fix the no alias problem in selects
-//p1 - add luid - it's cool for order by.
-//p1 - replace uuid with crypto.randomUUID and allow custom fallback
-//p1 - add nanoid
-//p1 - add id and use luid by default, but allow changes with Fields.id.defaultIdProvider
-//p1 - explain the benefits of changing the default provider for testing in docs.
+//p1 - tutorial about controller - and mutable controller
+//p1 - docs abount subscription channel
+//p1 - Consider enforcing serial operations on JSON database to prevent data loss
 //p1 - fix sqlite to  support alter table when adding a column with ensure schema = on
-//p1 - fix app custom filters example for multiple filters.
-//p1 - add not!!!!
 //p1 - add LifecycleEvent to documentation
-//p1 - Fix hagai and starter project to latest ts
 //p1 - fix chaining of saving and saved in multiple entity options args
 //p1 - review starter and examples and separate remult * auth from the routes
-//p1 - min, max, avg, sum
-//p1 - consider upsert (where,set)
 //y1 - live query with count #436
 //y1 TODO - In the esm version of our tutorial - the imports are automatically .ts and not .js in react and not in vue
-//y1 TODO - consider id to also support keyof (id:['company','index']) - had problem with | (keyof Partial<entityType>)[] & `entity`
-//y1 TODO - readonly key: keyof MembersOnly<entityType> & string
 //y1 TODO - fix remult admin not to load the html into memory until used
 //y2 - talk about insert / update / delete with relations
 /*
@@ -66,15 +52,10 @@ const result = await repo.batch(x=>({
 }))
 */
 //y1 - wait a second to close stream -see pr
-//p1 - Consider enforcing serial operations on JSON database to prevent data loss
 //p1 - prepare the createEntity discussion
-//p1 - return error on connection error
 //p1 - article on displayValue including it's definition for entities that is used in relations
 //p1 - article auth.js with express - played with it, requires type="module" and a few more configurations - https://github.com/noam-honig/express-auth
-//y2 - currently for string fields we default for 255 in knex (which is their default) why not just use text (varchar max) - and only use exact length when one is provided?
 //p2 - create foreign key constraints in user code - https://codesandbox.io/p/devbox/fk-validator-tdshcs
-//p2 - admin url1 - pocketbase use /_ for the admin //{allowed?:Allowed,url?:string} also checkout the admin* as it should probably be something else and didn't work in hono
-//y2 - fix validators cache
 //y2 - should we validate relations
 //y1 - dependency of live query tables  live query refresh of view on table update
 //p1 - see why mongo tests do not run anymore
@@ -94,7 +75,6 @@ const result = await repo.batch(x=>({
   - delete restrict (implicit, or user selected - and if so, how) (delete & update of id)
 
 */
-//y1 - tried to upgrade vitest, nuxt tests are failing with loading uuid - sounds familiar?
 //y1 - talk about the parameter issue with backend methods
 //y2 - livequery for findfirst (@JY)
 /*y2 -
@@ -111,7 +91,6 @@ const result = await repo.batch(x=>({
 //y2 - Fix problem with promise all in sql expression recurssion - when using PromiseAll in row relation loading, some sql expressions appear is recursion call even if they are not
 //p2 - when subscribe is forbidden - the query still runs after the renew process
 //p2 - 'update tasks set  where id = $1
-//p2 - type metadata.key - to keyof entity - based on cwis input
 //y2 - remove __dirname from tutorials
 //p2 - when value changes for field with error, clear error - so the user will feel comfortable
 //p2 - allowApiUpdate should be false for include in api false

package/src/server-action.d.ts

@@ -39,6 +39,13 @@ export interface BackendMethodOptions<type> {
      * {allowed:true, apiPrefix:'someFolder/'}
      */
     apiPrefix?: string;
+    /**
+     * Controls whether this `BackendMethod` runs within a database transaction. If set to `true`, the method will either complete entirely or fail without making any partial changes. If set to `false`, the method will not be transactional and may result in partial changes if it fails.
+     * @default true
+     * @example
+     * {allowed: true, transactional: false}
+     */
+    transactional?: boolean;
     /** EXPERIMENTAL: Determines if this method should be queued for later execution */
     queue?: boolean;
     /** EXPERIMENTAL: Determines if the user should be blocked while this `BackendMethod` is running*/
@@ -53,7 +60,24 @@ export interface ClassMethodDecoratorContextStub<This = unknown, Value extends (
         has(object: This): boolean;
     };
 }
-/** Indicates that the decorated methods runs on the backend. See: [Backend Methods](https://remult.dev/docs/backendMethods.html) */
+/**
+ * Decorator indicating that the decorated method runs on the backend.
+ * It allows the method to be invoked from the frontend while ensuring that the execution happens on the server side.
+ * By default, the method runs within a database transaction, meaning it will either complete entirely or fail without making any partial changes.
+ * This behavior can be controlled using the `transactional` option in the `BackendMethodOptions`.
+ *
+ * For more details, see: [Backend Methods](https://remult.dev/docs/backendMethods.html).
+ *
+ * @param options - Configuration options for the backend method, including permissions, routing, and transactional behavior.
+ *
+ * @example
+ * ```typescript
+ * @BackendMethod({ allowed: true })
+ * async someBackendMethod() {
+ *   // method logic here
+ * }
+ * ```
+ */
 export declare function BackendMethod<type = unknown>(options: BackendMethodOptions<type>): (target: any, context: ClassMethodDecoratorContextStub<type> | string, descriptor?: any) => any;
 export interface jobWasQueuedResult {
     queuedJobId?: string;

package/src/server-action.js

@@ -143,7 +143,7 @@ var myServerAction = /** @class */ (function (_super) {
                     case 0:
                         result = { data: {} };
                         ds = remult.dataProvider;
-                        return [4 /*yield*/, (0, context_js_1.doTransaction)(remult, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        return [4 /*yield*/, decideTransaction(remult, this.options, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                                 var _a, _b, err_2;
                                 return tslib_1.__generator(this, function (_c) {
                                     switch (_c.label) {
@@ -188,7 +188,24 @@ function Controller(key) {
         return target;
     };
 }
-/** Indicates that the decorated methods runs on the backend. See: [Backend Methods](https://remult.dev/docs/backendMethods.html) */
+/**
+ * Decorator indicating that the decorated method runs on the backend.
+ * It allows the method to be invoked from the frontend while ensuring that the execution happens on the server side.
+ * By default, the method runs within a database transaction, meaning it will either complete entirely or fail without making any partial changes.
+ * This behavior can be controlled using the `transactional` option in the `BackendMethodOptions`.
+ *
+ * For more details, see: [Backend Methods](https://remult.dev/docs/backendMethods.html).
+ *
+ * @param options - Configuration options for the backend method, including permissions, routing, and transactional behavior.
+ *
+ * @example
+ * ```typescript
+ * @BackendMethod({ allowed: true })
+ * async someBackendMethod() {
+ *   // method logic here
+ * }
+ * ```
+ */
 function BackendMethod(options) {
     var _this = this;
     return function (target, context, descriptor) {
@@ -242,7 +259,7 @@ function BackendMethod(options) {
                                 return [4 /*yield*/, serverAction_1.doWork(args, undefined)];
                             case 1: return [2 /*return*/, _a.sent()];
                             case 2: return [4 /*yield*/, originalMethod.apply(
-                                //@ts-expect-error I specifically referred to the this of the original function - so it'll be sent inside
+                                //@ts-ignore
                                 this, args)];
                             case 3: return [2 /*return*/, _a.sent()];
                         }
@@ -289,7 +306,7 @@ function BackendMethod(options) {
                                 case 1:
                                     _a.trys.push([1, 3, , 4]);
                                     remult_1 = req;
-                                    return [4 /*yield*/, (0, context_js_1.doTransaction)(remult_1, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                    return [4 /*yield*/, decideTransaction(remult_1, options, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                                             var _a, repo, y, rowInfo, rowHelper, rows, defs, err_4, y, controllerRef, err_5;
                                             var _b, _c, _d;
                                             var _e;
@@ -645,3 +662,21 @@ function prepareReceivedArgs(types, args, remult, ds, res) {
     });
 }
 exports.classBackendMethodsArray = Symbol.for('classBackendMethodsArray');
+//
+function decideTransaction(remult, options, what) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(options.transactional === undefined || options.transactional === true)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, (0, context_js_1.doTransaction)(remult, what)];
+                case 1: return [2 /*return*/, _a.sent()];
+                case 2: return [4 /*yield*/, what(remult.dataProvider)];
+                case 3:
+                    _a.sent();
+                    _a.label = 4;
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}

package/src/validators.d.ts

@@ -47,4 +47,4 @@ export type ValidatorWithArgs<valueType, argsType> = (args: argsType, message?:
 export declare function createValidatorWithArgs<valueType, argsType>(validate: (entity: any, e: ValidateFieldEvent<any, valueType>, args: argsType) => Promise<boolean | string> | boolean | string, defaultMessage: ValidationMessage<valueType, argsType>): ValidatorWithArgs<valueType, argsType> & {
     defaultMessage: ValidationMessage<valueType, argsType>;
 };
-export declare function getEnumValues<theEnum extends object>(enumObj: theEnum): any[];
+export declare function getEnumValues<theEnum>(enumObj: theEnum): any[];