remult 0.27.23-next.0 → 0.27.23-next.2

package/esm/src/data-api.js

@@ -115,7 +115,7 @@ export class DataApi {
             let { aggregate, ...rest } = body;
             let [{ r }, [aggregates]] = await Promise.all([
                 this.getArrayImpl(request, rest),
-                this.groupBy(request, aggregate),
+                this.groupBy(request, { ...aggregate, where: body.where }),
             ]);
             return {
                 items: r,

package/esm/src/validators.js

@@ -1,8 +1,17 @@
 import { getRelationFieldInfo } from '../internals.js';
+/**
+ * Class containing various field validators.
+ */
 export class Validators {
+    /**
+     * Validator to check if a value is required (not null or empty).
+     */
     static required = createValidator(async (_, e) => !e.valueIsNull() &&
         e.value !== '' &&
         (e.value !== undefined || getRelationFieldInfo(e.metadata) !== undefined), 'Should not be empty');
+    /**
+     * Validator to ensure a value is unique in the database.
+     */
     static unique = createValidator(async (_, e) => {
         if (!e.entityRef)
             throw 'unique validation may only work on columns that are attached to an entity';
@@ -16,6 +25,7 @@ export class Validators {
     }, 'already exists');
     /**
      * @deprecated use `unique` instead - it also runs only on the backend
+     * Validator to ensure a value is unique on the backend.
      */
     static uniqueOnBackend = createValidator(async (_, e) => {
         if (e.isBackend() && (e.isNew || e.valueChanged())) {
@@ -26,9 +36,21 @@ export class Validators {
         else
             return true;
     }, Validators.unique.defaultMessage);
+    /**
+     * Validator to check if a value matches a given regular expression.
+     */
     static regex = createValueValidatorWithArgs((val, regex) => regex.test(val));
+    /**
+     * Validator to check if a value is a valid email address.
+     */
     static email = createValueValidator((val) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val), 'Invalid Email');
+    /**
+     * Validator to check if a value is a valid URL.
+     */
     static url = createValueValidator((val) => !!new URL(val), 'Invalid Url');
+    /**
+     * Validator to check if a value is one of the specified values.
+     */
     static in = createValueValidatorWithArgs((val, values) => values.includes(val), (values) => `Value must be one of: ${values
         .map((y) => typeof y === 'object'
         ? y?.['id'] !== undefined
@@ -36,8 +58,17 @@ export class Validators {
             : y?.toString()
         : y)
         .join(', ')}`);
+    /**
+     * Validator to check if a value is not null.
+     */
     static notNull = createValueValidator((val) => val != null, 'Should not be null');
+    /**
+     * Validator to check if a value exists in a given enum.
+     */
     static enum = createValueValidatorWithArgs((value, enumObj) => Object.values(enumObj).includes(value), (enumObj) => `Value must be one of ${getEnumValues(enumObj).join(', ')}`);
+    /**
+     * Validator to check if a related value exists in the database.
+     */
     static relationExists = createValidator(async (_, e) => {
         if (e.valueIsNull())
             return true;
@@ -45,12 +76,31 @@ export class Validators {
             return true;
         return Boolean(await e.load());
     }, 'Relation value does not exist');
+    /**
+     * Validator to check if a value is greater than or equal to a minimum value.
+     */
     static min = createValueValidatorWithArgs((val, minValue) => val >= minValue, (minValue) => `Value must be bigger than or equal to ${minValue}`);
+    /**
+     * Validator to check if a value is less than or equal to a maximum value.
+     */
     static max = createValueValidatorWithArgs((val, maxValue) => val <= maxValue, (maxValue) => `Value must be smaller than or equal to ${maxValue}`);
+    /**
+     * Validator to check if a string's length is less than or equal to a maximum length.
+     */
     static maxLength = createValueValidatorWithArgs((val, maxLength) => val.length <= maxLength, (maxLength) => `Value must be at most ${maxLength} characters`);
+    /**
+     * Validator to check if a string's length is greater than or equal to a minimum length.
+     */
     static minLength = createValueValidatorWithArgs((val, minLength) => val.length >= minLength, (maxLength) => `Value must be at least ${maxLength} characters`);
+    /**
+    * Validator to check if a value is within a specified range.
+    */
+    static range = createValueValidatorWithArgs((val, [minValue, maxValue]) => val >= minValue && val <= maxValue, ([minValue, maxValue]) => `Value must be between ${minValue} and ${maxValue}`);
     static defaultMessage = 'Invalid value';
 }
+/**
+ * Function to create a validator with a custom validation function.
+ */
 export function createValidator(validate, defaultMessage) {
     const validation = async (entity, e, message) => {
         const valid = await validate(entity, e);
@@ -87,9 +137,15 @@ export function createValidator(validate, defaultMessage) {
         withMessage: (message) => async (entity, e) => result(entity, e, message),
     });
 }
+/**
+ * Function to create a value validator.
+ */
 export function valueValidator(validate, defaultMessage) {
     return (entity, e) => validate(e.value) || defaultMessage || false;
 }
+/**
+ * Function to create a value validator with arguments.
+ */
 export function createValueValidator(validate, defaultMessage) {
     return createValidator((_, e) => {
         if (e.value === undefined || e.value === null)
@@ -97,6 +153,9 @@ export function createValueValidator(validate, defaultMessage) {
         return validate(e.value);
     }, defaultMessage);
 }
+/**
+ * Function to create a value validator with arguments and a custom message.
+ */
 export function createValueValidatorWithArgs(validate, defaultMessage) {
     const result = createValidatorWithArgsInternal((_, e, args) => {
         if (e.value === undefined || e.value === null)
@@ -113,6 +172,9 @@ export function createValueValidatorWithArgs(validate, defaultMessage) {
         },
     });
 }
+/**
+ * Function to create a validator with arguments and a custom message.
+ */
 export function createValidatorWithArgs(validate, defaultMessage) {
     return createValidatorWithArgsInternal(validate, defaultMessage);
 }
@@ -143,6 +205,9 @@ function createValidatorWithArgsInternal(validate, defaultMessage, isValueValida
         },
     });
 }
+/**
+ * Function to get the values of an enum.
+ */
 export function getEnumValues(enumObj) {
     return Object.values(enumObj).filter((x) => typeof enumObj[x] !== 'number');
 }

package/package.json

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

package/src/data-api.js

@@ -201,7 +201,7 @@ var DataApi = /** @class */ (function () {
                         aggregate = body.aggregate, rest = tslib_1.__rest(body, ["aggregate"]);
                         return [4 /*yield*/, Promise.all([
                                 this.getArrayImpl(request, rest),
-                                this.groupBy(request, aggregate),
+                                this.groupBy(request, 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/remult3/remult3.d.ts

@@ -1161,7 +1161,7 @@ export declare type EntityIdFields<entityType> = {
 };
 export interface ClassFieldDecoratorContextStub<entityType, valueType> {
     readonly access: {
-        set(object: entityType, value: valueType): void;
+        set(object: entityType, value: valueType | null): void;
     };
     readonly name: string;
 }

package/src/validators.d.ts

@@ -1,56 +1,135 @@
 import type { FieldValidator } from './column-interfaces.js';
 import type { ValidateFieldEvent } from './remult3/remult3.js';
+/**
+ * Class containing various field validators.
+ */
 export declare class Validators {
+    /**
+     * Validator to check if a value is required (not null or empty).
+     */
     static required: Validator<unknown>;
+    /**
+     * Validator to ensure a value is unique in the database.
+     */
     static unique: Validator<unknown>;
     /**
      * @deprecated use `unique` instead - it also runs only on the backend
+     * Validator to ensure a value is unique on the backend.
      */
     static uniqueOnBackend: Validator<unknown>;
+    /**
+     * Validator to check if a value matches a given regular expression.
+     */
     static regex: ValidatorWithArgs<string, RegExp> & {
         defaultMessage: ValueValidationMessage<RegExp>;
     };
+    /**
+     * Validator to check if a value is a valid email address.
+     */
     static email: Validator<string>;
+    /**
+     * Validator to check if a value is a valid URL.
+     */
     static url: Validator<string>;
+    /**
+     * Validator to check if a value is one of the specified values.
+     */
     static in: <T>(value: readonly T[], withMessage?: ValueValidationMessage<T[]>) => FieldValidator<unknown, T> & {
         withMessage: ValueValidationMessage<T[]>;
     };
+    /**
+     * Validator to check if a value is not null.
+     */
     static notNull: Validator<unknown>;
+    /**
+     * Validator to check if a value exists in a given enum.
+     */
     static enum: ValidatorWithArgs<unknown, unknown> & {
         defaultMessage: ValueValidationMessage<unknown>;
     };
+    /**
+     * Validator to check if a related value exists in the database.
+     */
     static relationExists: Validator<unknown>;
+    /**
+     * Validator to check if a value is greater than or equal to a minimum value.
+     */
     static min: ValidatorWithArgs<number, number> & {
         defaultMessage: ValueValidationMessage<number>;
     };
+    /**
+     * Validator to check if a value is less than or equal to a maximum value.
+     */
     static max: ValidatorWithArgs<number, number> & {
         defaultMessage: ValueValidationMessage<number>;
     };
+    /**
+     * Validator to check if a string's length is less than or equal to a maximum length.
+     */
     static maxLength: ValidatorWithArgs<string, number> & {
         defaultMessage: ValueValidationMessage<number>;
     };
+    /**
+     * Validator to check if a string's length is greater than or equal to a minimum length.
+     */
     static minLength: ValidatorWithArgs<string, number> & {
         defaultMessage: ValueValidationMessage<number>;
     };
+    /**
+    * Validator to check if a value is within a specified range.
+    */
+    static range: ValidatorWithArgs<number, [number, number]> & {
+        defaultMessage: ValueValidationMessage<[number, number]>;
+    };
     static defaultMessage: string;
 }
+/**
+ * Type representing a field validator with an optional message.
+ */
 export type Validator<valueType> = FieldValidator<unknown, valueType> & ((message?: ValidationMessage<valueType, undefined>) => FieldValidator<unknown, valueType>) & {
     defaultMessage: ValidationMessage<valueType, undefined>;
     /**
-     * @deprecated  use (message:string) instead - for example: Validators.required("Is needed")
+     * @deprecated use (message:string) instead - for example: Validators.required("Is needed")
      */
     withMessage(message: ValidationMessage<valueType, undefined>): FieldValidator<unknown, valueType>;
 };
+/**
+ * Function to create a validator with a custom validation function.
+ */
 export declare function createValidator<valueType>(validate: (entity: any, e: ValidateFieldEvent<any, valueType>) => Promise<boolean | string> | boolean | string, defaultMessage?: ValidationMessage<valueType, undefined>): Validator<valueType>;
+/**
+ * Function to create a value validator.
+ */
 export declare function valueValidator<valueType>(validate: (value: valueType) => boolean | string | Promise<boolean | string>, defaultMessage?: string): (entity: any, e: ValidateFieldEvent<any, valueType>) => string | boolean | Promise<string | boolean>;
+/**
+ * Function to create a value validator with arguments.
+ */
 export declare function createValueValidator<valueType>(validate: (value: valueType) => boolean | string | Promise<boolean | string>, defaultMessage?: ValidationMessage<valueType, undefined>): Validator<valueType>;
+/**
+ * Function to create a value validator with arguments and a custom message.
+ */
 export declare function createValueValidatorWithArgs<valueType, argsType>(validate: (value: valueType, args: argsType) => boolean | string | Promise<boolean | string>, defaultMessage?: ValueValidationMessage<argsType>): ValidatorWithArgs<valueType, argsType> & {
     defaultMessage: ValueValidationMessage<argsType>;
 };
+/**
+ * Type representing a validation message that can be a string or a function.
+ */
 export type ValueValidationMessage<argsType> = string | ((args: argsType) => string);
+/**
+ * Type representing a validation message with additional parameters.
+ */
 export type ValidationMessage<valueType, argsType> = string | ((entity: any, event: ValidateFieldEvent<any, valueType>, args: argsType) => string);
+/**
+ * Type representing a validator with arguments.
+ */
 export type ValidatorWithArgs<valueType, argsType> = (args: argsType, message?: ValidationMessage<valueType, argsType>) => FieldValidator<unknown, valueType>;
+/**
+ * Function to create a validator with arguments and a custom 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>;
 };
+/**
+ * Function to get the values of an enum.
+ */
 export declare function getEnumValues<theEnum>(enumObj: theEnum): any[];

package/src/validators.js

@@ -9,11 +9,17 @@ exports.createValidatorWithArgs = createValidatorWithArgs;
 exports.getEnumValues = getEnumValues;
 var tslib_1 = require("tslib");
 var internals_js_1 = require("../internals.js");
+/**
+ * Class containing various field validators.
+ */
 var Validators = /** @class */ (function () {
     function Validators() {
     }
     var _a;
     _a = Validators;
+    /**
+     * Validator to check if a value is required (not null or empty).
+     */
     Validators.required = createValidator(function (_, e) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
         return tslib_1.__generator(_a, function (_b) {
             return [2 /*return*/, !e.valueIsNull() &&
@@ -21,6 +27,9 @@ var Validators = /** @class */ (function () {
                     (e.value !== undefined || (0, internals_js_1.getRelationFieldInfo)(e.metadata) !== undefined)];
         });
     }); }, 'Should not be empty');
+    /**
+     * Validator to ensure a value is unique in the database.
+     */
     Validators.unique = createValidator(function (_, e) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
         var _b;
         return tslib_1.__generator(_a, function (_c) {
@@ -39,6 +48,7 @@ var Validators = /** @class */ (function () {
     }); }, 'already exists');
     /**
      * @deprecated use `unique` instead - it also runs only on the backend
+     * Validator to ensure a value is unique on the backend.
      */
     Validators.uniqueOnBackend = createValidator(function (_, e) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
         var _b;
@@ -54,11 +64,23 @@ var Validators = /** @class */ (function () {
             }
         });
     }); }, _a.unique.defaultMessage);
+    /**
+     * Validator to check if a value matches a given regular expression.
+     */
     Validators.regex = createValueValidatorWithArgs(function (val, regex) {
         return regex.test(val);
     });
+    /**
+     * Validator to check if a value is a valid email address.
+     */
     Validators.email = createValueValidator(function (val) { return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val); }, 'Invalid Email');
+    /**
+     * Validator to check if a value is a valid URL.
+     */
     Validators.url = createValueValidator(function (val) { return !!new URL(val); }, 'Invalid Url');
+    /**
+     * Validator to check if a value is one of the specified values.
+     */
     Validators.in = createValueValidatorWithArgs(function (val, values) { return values.includes(val); }, function (values) {
         return "Value must be one of: ".concat(values
             .map(function (y) {
@@ -70,10 +92,19 @@ var Validators = /** @class */ (function () {
         })
             .join(', '));
     });
+    /**
+     * Validator to check if a value is not null.
+     */
     Validators.notNull = createValueValidator(function (val) { return val != null; }, 'Should not be null');
+    /**
+     * Validator to check if a value exists in a given enum.
+     */
     Validators.enum = createValueValidatorWithArgs(function (value, enumObj) { return Object.values(enumObj).includes(value); }, function (enumObj) {
         return "Value must be one of ".concat(getEnumValues(enumObj).join(', '));
     });
+    /**
+     * Validator to check if a related value exists in the database.
+     */
     Validators.relationExists = createValidator(function (_, e) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
         var _b;
         return tslib_1.__generator(_a, function (_c) {
@@ -89,14 +120,39 @@ var Validators = /** @class */ (function () {
             }
         });
     }); }, 'Relation value does not exist');
+    /**
+     * Validator to check if a value is greater than or equal to a minimum value.
+     */
     Validators.min = createValueValidatorWithArgs(function (val, minValue) { return val >= minValue; }, function (minValue) { return "Value must be bigger than or equal to ".concat(minValue); });
+    /**
+     * Validator to check if a value is less than or equal to a maximum value.
+     */
     Validators.max = createValueValidatorWithArgs(function (val, maxValue) { return val <= maxValue; }, function (maxValue) { return "Value must be smaller than or equal to ".concat(maxValue); });
+    /**
+     * Validator to check if a string's length is less than or equal to a maximum length.
+     */
     Validators.maxLength = createValueValidatorWithArgs(function (val, maxLength) { return val.length <= maxLength; }, function (maxLength) { return "Value must be at most ".concat(maxLength, " characters"); });
+    /**
+     * Validator to check if a string's length is greater than or equal to a minimum length.
+     */
     Validators.minLength = createValueValidatorWithArgs(function (val, minLength) { return val.length >= minLength; }, function (maxLength) { return "Value must be at least ".concat(maxLength, " characters"); });
+    /**
+    * Validator to check if a value is within a specified range.
+    */
+    Validators.range = createValueValidatorWithArgs(function (val, _b) {
+        var _c = tslib_1.__read(_b, 2), minValue = _c[0], maxValue = _c[1];
+        return val >= minValue && val <= maxValue;
+    }, function (_b) {
+        var _c = tslib_1.__read(_b, 2), minValue = _c[0], maxValue = _c[1];
+        return "Value must be between ".concat(minValue, " and ").concat(maxValue);
+    });
     Validators.defaultMessage = 'Invalid value';
     return Validators;
 }());
 exports.Validators = Validators;
+/**
+ * Function to create a validator with a custom validation function.
+ */
 function createValidator(validate, defaultMessage) {
     var _this = this;
     var validation = function (entity, e, message) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
@@ -151,11 +207,17 @@ function createValidator(validate, defaultMessage) {
         },
     });
 }
+/**
+ * Function to create a value validator.
+ */
 function valueValidator(validate, defaultMessage) {
     return function (entity, e) {
         return validate(e.value) || defaultMessage || false;
     };
 }
+/**
+ * Function to create a value validator with arguments.
+ */
 function createValueValidator(validate, defaultMessage) {
     return createValidator(function (_, e) {
         if (e.value === undefined || e.value === null)
@@ -163,6 +225,9 @@ function createValueValidator(validate, defaultMessage) {
         return validate(e.value);
     }, defaultMessage);
 }
+/**
+ * Function to create a value validator with arguments and a custom message.
+ */
 function createValueValidatorWithArgs(validate, defaultMessage) {
     var result = createValidatorWithArgsInternal(function (_, e, args) {
         if (e.value === undefined || e.value === null)
@@ -181,6 +246,9 @@ function createValueValidatorWithArgs(validate, defaultMessage) {
         },
     });
 }
+/**
+ * Function to create a validator with arguments and a custom message.
+ */
 function createValidatorWithArgs(validate, defaultMessage) {
     return createValidatorWithArgsInternal(validate, defaultMessage);
 }
@@ -223,6 +291,9 @@ function createValidatorWithArgsInternal(validate, defaultMessage, isValueValida
         },
     });
 }
+/**
+ * Function to get the values of an enum.
+ */
 function getEnumValues(enumObj) {
     return Object.values(enumObj).filter(function (x) { return typeof enumObj[x] !== 'number'; });
 }