remult 0.25.6-exp.3 → 0.25.6-exp.5

package/esm/src/filter/filter-interfaces.js

@@ -173,7 +173,18 @@ export class Filter {
     __applyToConsumer(add) {
         this.apply(add);
     }
-    //@internal
+    /**
+     * Resolves an entity filter.
+     *
+     * This method takes a filter which can be either an instance of `EntityFilter`
+     * or a function that returns an instance of `EntityFilter` or a promise that
+     * resolves to an instance of `EntityFilter`. It then resolves the filter if it
+     * is a function and returns the resulting `EntityFilter`.
+     *
+     * @template entityType The type of the entity that the filter applies to.
+     * @param {EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>)} filter The filter to resolve.
+     * @returns {Promise<EntityFilter<entityType>>} The resolved entity filter.
+     */
     static async resolve(filter) {
         if (typeof filter === 'function')
             return await filter();

package/esm/src/validators.js

@@ -89,12 +89,12 @@ export function createValueValidator(validate, defaultMessage) {
     }, defaultMessage);
 }
 export function createValueValidatorWithArgs(validate, defaultMessage) {
-    const result = createValidatorWithArgs((_, e, args) => {
+    const result = createValidatorWithArgsInternal((_, e, args) => {
         if (e.value === undefined || e.value === null)
             return true;
         return validate(e.value, args);
     }, (_, e, args) => (typeof defaultMessage === 'function' && defaultMessage(args)) ||
-        defaultMessage);
+        defaultMessage, true);
     return Object.assign((entity, e) => result(entity, e), {
         get defaultMessage() {
             return defaultMessage;
@@ -105,13 +105,21 @@ export function createValueValidatorWithArgs(validate, defaultMessage) {
     });
 }
 export function createValidatorWithArgs(validate, defaultMessage) {
+    return createValidatorWithArgsInternal(validate, defaultMessage);
+}
+function createValidatorWithArgsInternal(validate, defaultMessage, isValueValidator = false) {
     const result = (args, message) => async (entity, e) => {
         const valid = await validate(entity, e, args);
         if (typeof valid === 'string')
             e.error = valid;
         else if (!valid)
-            e.error =
-                message || defaultMessage
+            e.error = message
+                ? typeof message === 'function'
+                    ? isValueValidator
+                        ? message(args)
+                        : message(entity, e, args)
+                    : message
+                : defaultMessage
                     ? typeof defaultMessage === 'function'
                         ? defaultMessage(entity, e, args)
                         : defaultMessage

package/package.json

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

package/src/filter/filter-interfaces.d.ts

@@ -122,6 +122,19 @@ export declare class Filter {
     static fromEntityFilter<T>(entity: EntityMetadata<T>, whereItem: EntityFilter<T>): Filter;
     constructor(apply: (add: FilterConsumer) => void);
     __applyToConsumer(add: FilterConsumer): void;
+    /**
+     * Resolves an entity filter.
+     *
+     * This method takes a filter which can be either an instance of `EntityFilter`
+     * or a function that returns an instance of `EntityFilter` or a promise that
+     * resolves to an instance of `EntityFilter`. It then resolves the filter if it
+     * is a function and returns the resulting `EntityFilter`.
+     *
+     * @template entityType The type of the entity that the filter applies to.
+     * @param {EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>)} filter The filter to resolve.
+     * @returns {Promise<EntityFilter<entityType>>} The resolved entity filter.
+     */
+    static resolve<entityType>(filter: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>)): Promise<EntityFilter<entityType>>;
 }
 export interface FilterConsumer {
     or(orElements: Filter[]): any;

package/src/filter/filter-interfaces.js

@@ -181,7 +181,18 @@ var Filter = /** @class */ (function () {
     Filter.prototype.__applyToConsumer = function (add) {
         this.apply(add);
     };
-    //@internal
+    /**
+     * Resolves an entity filter.
+     *
+     * This method takes a filter which can be either an instance of `EntityFilter`
+     * or a function that returns an instance of `EntityFilter` or a promise that
+     * resolves to an instance of `EntityFilter`. It then resolves the filter if it
+     * is a function and returns the resulting `EntityFilter`.
+     *
+     * @template entityType The type of the entity that the filter applies to.
+     * @param {EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>)} filter The filter to resolve.
+     * @returns {Promise<EntityFilter<entityType>>} The resolved entity filter.
+     */
     Filter.resolve = function (filter) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {

package/src/validators.js

@@ -146,14 +146,14 @@ function createValueValidator(validate, defaultMessage) {
 }
 exports.createValueValidator = createValueValidator;
 function createValueValidatorWithArgs(validate, defaultMessage) {
-    var result = createValidatorWithArgs(function (_, e, args) {
+    var result = createValidatorWithArgsInternal(function (_, e, args) {
         if (e.value === undefined || e.value === null)
             return true;
         return validate(e.value, args);
     }, function (_, e, args) {
         return (typeof defaultMessage === 'function' && defaultMessage(args)) ||
             defaultMessage;
-    });
+    }, true);
     return Object.assign(function (entity, e) { return result(entity, e); }, {
         get defaultMessage() {
             return defaultMessage;
@@ -165,7 +165,12 @@ function createValueValidatorWithArgs(validate, defaultMessage) {
 }
 exports.createValueValidatorWithArgs = createValueValidatorWithArgs;
 function createValidatorWithArgs(validate, defaultMessage) {
+    return createValidatorWithArgsInternal(validate, defaultMessage);
+}
+exports.createValidatorWithArgs = createValidatorWithArgs;
+function createValidatorWithArgsInternal(validate, defaultMessage, isValueValidator) {
     var _this = this;
+    if (isValueValidator === void 0) { isValueValidator = false; }
     var result = function (args, message) {
         return function (entity, e) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var valid;
@@ -177,8 +182,13 @@ function createValidatorWithArgs(validate, defaultMessage) {
                         if (typeof valid === 'string')
                             e.error = valid;
                         else if (!valid)
-                            e.error =
-                                message || defaultMessage
+                            e.error = message
+                                ? typeof message === 'function'
+                                    ? isValueValidator
+                                        ? message(args)
+                                        : message(entity, e, args)
+                                    : message
+                                : defaultMessage
                                     ? typeof defaultMessage === 'function'
                                         ? defaultMessage(entity, e, args)
                                         : defaultMessage
@@ -197,4 +207,3 @@ function createValidatorWithArgs(validate, defaultMessage) {
         },
     });
 }
-exports.createValidatorWithArgs = createValidatorWithArgs;