remult 0.25.8 → 0.26.0

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

@@ -6,8 +6,87 @@ import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
  */
 export class Filter {
     apply;
-    static createCustom(rawFilterTranslator, key = '') {
-        let rawFilterInfo = { key: key, rawFilterTranslator };
+    //@internal
+    static throwErrorIfFilterIsEmpty(where, methodName) {
+        if (Filter.isFilterEmpty(where)) {
+            throw {
+                message: `${methodName}: requires a filter to protect against accidental delete/update of all rows`,
+                httpStatusCode: 400,
+            };
+        }
+    }
+    //@internal
+    static isFilterEmpty(where) {
+        if (where.$and) {
+            for (const a of where.$and) {
+                if (!Filter.isFilterEmpty(a)) {
+                    return false;
+                }
+            }
+        }
+        if (where.$or) {
+            for (const a of where.$or) {
+                if (Filter.isFilterEmpty(a)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (Object.keys(where).filter((x) => !['$or', '$and'].includes(x)).length == 0) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Retrieves precise values for each property in a filter for an entity.
+     * @template entityType The type of the entity being filtered.
+     * @param metadata The metadata of the entity being filtered.
+     * @param filter The filter to analyze.
+     * @returns A promise that resolves to a FilterPreciseValues object containing the precise values for each property.
+     * @example
+     * const preciseValues = await Filter.getPreciseValues(meta, {
+     *   status: { $ne: 'active' },
+     *   $or: [
+     *     { customerId: ["1", "2"] },
+     *     { customerId: "3" }
+     *   ]
+     * });
+     * console.log(preciseValues);
+     * // Output:
+     * // {
+     * //   "customerId": ["1", "2", "3"], // Precise values inferred from the filter
+     * //   "status": undefined,           // Cannot infer precise values for 'status'
+     * // }
+    
+     */
+    static async getPreciseValues(metadata, filter) {
+        const result = new preciseValuesCollector();
+        await Filter.fromEntityFilter(metadata, filter).__applyToConsumer(result);
+        return result.preciseValues;
+    }
+    /**
+     * Retrieves precise values for each property in a filter for an entity.
+     * @template entityType The type of the entity being filtered.
+     * @param metadata The metadata of the entity being filtered.
+     * @param filter The filter to analyze.
+     * @returns A promise that resolves to a FilterPreciseValues object containing the precise values for each property.
+     * @example
+     * const preciseValues = await where.getPreciseValues();
+     * console.log(preciseValues);
+     * // Output:
+     * // {
+     * //   "customerId": ["1", "2", "3"], // Precise values inferred from the filter
+     * //   "status": undefined,           // Cannot infer precise values for 'status'
+     * // }
+    
+     */
+    async getPreciseValues() {
+        const result = new preciseValuesCollector();
+        await this.__applyToConsumer(result);
+        return result.preciseValues;
+    }
+    static createCustom(translator, key = '') {
+        let rawFilterInfo = { key: key, rawFilterTranslator: translator };
         return Object.assign((x) => {
             let z = {};
             if (x == undefined)
@@ -190,7 +269,6 @@ export class Filter {
             return await filter();
         return filter;
     }
-    //@internal
     toJson() {
         let r = new FilterSerializer();
         this.__applyToConsumer(r);
@@ -474,7 +552,21 @@ export function entityFilterToJson(entityDefs, where) {
     return Filter.fromEntityFilter(entityDefs, where).toJson();
 }
 export function buildFilterFromRequestParameters(entity, filterInfo) {
-    let where = [];
+    let where = {};
+    function addAnd(what) {
+        if (!where.$and) {
+            where.$and = [];
+        }
+        where.$and.push(what);
+    }
+    function addToFilterObject(key, val) {
+        if (where[key] === undefined)
+            where[key] = val;
+        else {
+            addAnd({ [key]: val });
+        }
+    }
+    ;
     [...entity.fields].forEach((col) => {
         function addFilter(operation, theFilter, jsonArray = false, asString = false) {
             let val = filterInfo.get(col.key + operation);
@@ -494,7 +586,7 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
                     }
                     let f = theFilter(theVal);
                     if (f !== undefined) {
-                        where.push({ [col.key]: f });
+                        addToFilterObject(col.key, f);
                     }
                 };
                 if (!jsonArray && val instanceof Array) {
@@ -528,10 +620,10 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
                 case 'y':
                 case 'true':
                 case 'yes':
-                    where.push({ [col.key]: null });
+                    addToFilterObject(col.key, null);
                     break;
                 default:
-                    where.push({ [col.key]: { $ne: null } });
+                    addToFilterObject(col.key, { $ne: null });
                     break;
             }
         }
@@ -546,12 +638,19 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
                 get: (key) => x[key],
             })),
         }));
-        if (or.length == 1)
-            where.push(or[0]);
-        else
-            where.push({
+        if (or.length == 1) {
+            if (!where.$or) {
+                where.$or = or[0].$or;
+            }
+            else {
+                where.$or.push(or[0].$or);
+            }
+        }
+        else {
+            addAnd({
                 $and: or,
             });
+        }
     }
     for (const key in entity.entityType) {
         const element = entity.entityType[key];
@@ -563,7 +662,7 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
                 const addItem = (item) => {
                     if (item[customArrayToken] != undefined)
                         item = item[customArrayToken];
-                    where.push({ [customUrlToken + key]: item });
+                    addToFilterObject(customUrlToken + key, item);
                 };
                 if (Array.isArray(custom)) {
                     custom.forEach((item) => addItem(item));
@@ -573,9 +672,7 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
             }
         }
     }
-    if (where.length == 1)
-        return where[0];
-    return { $and: where };
+    return where;
     function separateArrayFromInnerArray(val) {
         if (!Array.isArray(val))
             return [val];
@@ -691,5 +788,120 @@ export function __updateEntityBasedOnWhere(entityDefs, where, r) {
         });
     }
 }
-// toRaw of default remult threw and exception
-// toRaw didn't respect
+class preciseValuesCollector {
+    rawValues = {};
+    preciseValues = new Proxy(this.rawValues, {
+        get: (target, prop) => {
+            if (prop in target) {
+                let result = target[prop];
+                if (result.bad)
+                    return undefined;
+                if (result.values.length > 0) {
+                    const relInfo = getRelationFieldInfo(result.field);
+                    if (relInfo) {
+                        if (relInfo.type === 'reference') {
+                            return result.values.map((x) => {
+                                return relInfo.toRepo.metadata.idMetadata.getIdFilter(x);
+                            });
+                        }
+                        else
+                            throw new Error('Only relations toOne without field are supported.');
+                    }
+                    return result.values;
+                }
+            }
+            return undefined;
+        },
+    });
+    ok(col, ...val) {
+        let x = this.rawValues[col.key];
+        if (!x) {
+            this.rawValues[col.key] = {
+                field: col,
+                bad: false,
+                values: [...val],
+            };
+        }
+        else {
+            x.values.push(...val.filter((y) => !x.values.includes(y)));
+        }
+    }
+    notOk(col) {
+        let x = this.rawValues[col.key];
+        if (!x) {
+            this.rawValues[col.key] = {
+                field: col,
+                bad: true,
+                values: [],
+            };
+        }
+        else {
+            x.bad = true;
+        }
+    }
+    or(orElements) {
+        const result = orElements.map((or) => {
+            let x = new preciseValuesCollector();
+            or.__applyToConsumer(x);
+            return x;
+        });
+        for (const or of result) {
+            for (const key in or.rawValues) {
+                if (Object.prototype.hasOwnProperty.call(or.rawValues, key)) {
+                    const element = or.rawValues[key];
+                    if (element) {
+                        if (element.bad)
+                            this.notOk(element.field);
+                        else {
+                            this.ok(element.field, ...element.values);
+                        }
+                    }
+                }
+            }
+        }
+        for (const key in this.rawValues) {
+            if (Object.prototype.hasOwnProperty.call(this.rawValues, key)) {
+                for (const r of result) {
+                    const element = r.rawValues[key];
+                    if (!element)
+                        this.notOk(this.rawValues[key].field);
+                }
+            }
+        }
+    }
+    isEqualTo(col, val) {
+        this.ok(col, val);
+    }
+    isDifferentFrom(col, val) {
+        this.notOk(col);
+    }
+    isNull(col) {
+        this.ok(col, null);
+    }
+    isNotNull(col) {
+        this.notOk(col);
+    }
+    isGreaterOrEqualTo(col, val) {
+        this.notOk(col);
+    }
+    isGreaterThan(col, val) {
+        this.notOk(col);
+    }
+    isLessOrEqualTo(col, val) {
+        this.notOk(col);
+    }
+    isLessThan(col, val) {
+        this.notOk(col);
+    }
+    containsCaseInsensitive(col, val) {
+        this.notOk(col);
+    }
+    notContainsCaseInsensitive(col, val) {
+        this.notOk(col);
+    }
+    isIn(col, val) {
+        this.ok(col, ...val);
+    }
+    custom(key, customItem) { }
+    databaseCustom(databaseCustom) { }
+}

package/esm/src/isOfType.js

@@ -0,0 +1,9 @@
+export function isOfType(obj, checkMethod) {
+    return typeof obj[checkMethod] !== 'undefined';
+}
+export function cast(obj, checkMethod) {
+    if (isOfType(obj, checkMethod)) {
+        return obj;
+    }
+    throw new Error(`Object is not of type ${checkMethod.toString()}`);
+}

package/esm/src/remult3/Fields.js

@@ -2,9 +2,13 @@ import { createId } from '@paralleldrive/cuid2';
 import { v4 as uuid } from 'uuid';
 import { ValueConverters } from '../valueConverters.js';
 import { buildOptions } from './RepositoryImplementation.js';
-import { Validators } from '../validators.js';
+import { Validators, createValueValidator, getEnumValues } from '../validators.js';
 import { relationInfoMemberInOptions } from './relationInfoMember.js';
 import { remultStatic } from '../remult-static.js';
+import { addValidator } from './addValidator.js';
+const validateNumber = createValueValidator((x) => {
+    return !isNaN(x) && isFinite(x);
+});
 export class Fields {
     /**
      * Stored as a JSON.stringify - to store as json use Fields.json
@@ -34,6 +38,7 @@ export class Fields {
     static integer(...options) {
         return Field(() => Number, {
             valueConverter: ValueConverters.Integer,
+            validate: validateNumber,
         }, ...options);
     }
     static autoIncrement(...options) {
@@ -47,7 +52,9 @@ export class Fields {
         }, ...options);
     }
     static number(...options) {
-        return Field(() => Number, ...options);
+        return Field(() => Number, {
+            validate: validateNumber,
+        }, ...options);
     }
     static createdAt(...options) {
         return Field(() => Date, {
@@ -76,6 +83,11 @@ export class Fields {
             },
         }, ...options);
     }
+    /**
+   * A CUID (Collision Resistant Unique Identifier) field.
+   * This id value is determined on the backend on insert, and can't be updated through the API.
+   * The CUID is generated using the `@paralleldrive/cuid2` npm package.
+   */
     static cuid(...options) {
         return Field(() => String, {
             allowApiUpdate: false,
@@ -86,6 +98,61 @@ export class Fields {
             },
         }, ...options);
     }
+    /**
+   * Defines a field that can hold a value from a specified set of string literals.
+   * @param {() => readonly valueType[]} optionalValues - A function that returns an array of allowed string literals.
+   * @returns {ClassFieldDecorator<entityType, valueType | undefined>} - A class field decorator.
+   *
+   * @example
+   
+   * class MyEntity {
+   *   .@Fields.literal(() => ['open', 'closed', 'frozen', 'in progress'] as const)
+   *   status: 'open' | 'closed' | 'frozen' | 'in progress' = 'open';
+   * }
+   
+   *
+   * // This defines a field `status` in `MyEntity` that can only hold the values 'open', 'closed', 'frozen', or 'in progress'.
+   *
+   * @example
+   * // For better reusability and maintainability:
+   
+   * const statuses = ['open', 'closed', 'frozen', 'in progress'] as const;
+   * type StatusType = typeof statuses[number];
+   *
+   * class MyEntity {
+   *   .@Fields.literal(() => statuses)
+   *   status: StatusType = 'open';
+   * }
+   
+   *
+   * // This approach allows easy management and updates of the allowed values for the `status` field.
+   */
+    static literal(optionalValues, ...options) {
+        return Fields.string({
+            validate: (entity, event) => Validators.in(optionalValues())(entity, event)
+        }, ...options);
+    }
+    static enum(enumType, ...options) {
+        let valueConverter;
+        return Field(() => 
+        //@ts-ignore
+        enumType(), {
+            validate: (entity, event) => Validators.enum(enumType())(entity, event)
+        }, ...options, (options) => {
+            if (valueConverter === undefined) {
+                let enumObj = enumType();
+                let enumValues = getEnumValues(enumObj);
+                valueConverter = enumValues.find(x => typeof x === "string") ? ValueConverters.String : ValueConverters.Integer;
+            }
+            if (!options.valueConverter) {
+                options.valueConverter = valueConverter;
+            }
+            else if (!options.valueConverter.fieldTypeInDb) {
+                //@ts-ignore
+                options.valueConverter.fieldTypeInDb = valueConverter.fieldTypeInDb;
+            }
+        });
+    }
     static string(...options) {
         return Field(() => String, ...options);
     }
@@ -186,7 +253,7 @@ export function Field(valueType, ...options) {
         let factory = (remult) => {
             let r = buildOptions(options, remult);
             if (r.required) {
-                r.validate = addValidator(r.validate, Validators.required);
+                r.validate = addValidator(r.validate, Validators.required, true);
             }
             if (r.maxLength) {
                 r.validate = addValidator(r.validate, Validators.maxLength(r.maxLength));
@@ -240,18 +307,3 @@ export function checkTarget(target) {
     if (!target)
         throw new Error("Set the 'experimentalDecorators:true' option in your 'tsconfig' or 'jsconfig' (target undefined)");
 }
-function addValidator(validators, newValidator, atStart = false) {
-    if (!newValidator)
-        return;
-    const newValidators = Array.isArray(newValidator)
-        ? newValidator
-        : [newValidator];
-    const validatorsArray = Array.isArray(validators)
-        ? validators
-        : validators
-            ? [validators]
-            : [];
-    return atStart
-        ? [...newValidators, ...validatorsArray]
-        : [...validatorsArray, ...newValidators];
-}

package/esm/src/remult3/RepositoryImplementation.js

@@ -14,6 +14,8 @@ import { RelationLoader } from './relation-loader.js';
 import { getInternalKey, } from './repository-internals.js';
 import { entityDbName, fieldDbName, } from '../filter/filter-consumer-bridge-to-sql-request.js';
 import { remultStatic } from '../remult-static.js';
+import { Validators } from '../validators.js';
+import { addValidator } from './addValidator.js';
 //import  { remult } from "../remult-proxy";
 let classValidatorValidate = undefined;
 // import ("class-validator".toString())
@@ -269,7 +271,8 @@ export class RepositoryImplementation {
             }
         }
     }
-    async updateMany(where, set) {
+    async updateMany({ where }, set) {
+        Filter.throwErrorIfFilterIsEmpty(where, 'updateMany');
         if (this._dataProvider.isProxy) {
             return this._edp.updateMany(await this._translateWhereToFilter(where), set);
         }
@@ -635,7 +638,8 @@ export class RepositoryImplementation {
     async count(where) {
         return this._edp.count(await this._translateWhereToFilter(where));
     }
-    async deleteMany(where) {
+    async deleteMany({ where, }) {
+        Filter.throwErrorIfFilterIsEmpty(where, 'deleteMany');
         if (this._dataProvider.isProxy) {
             return this._edp.deleteMany(await this._translateWhereToFilter(where));
         }
@@ -767,11 +771,22 @@ export class RepositoryImplementation {
                 $and: [z, this._defaultFindOptions?.where],
             };
         }
-        if (this.metadata.options.backendPrefilter && !this._dataProvider.isProxy) {
-            let z = where;
-            where = {
-                $and: [z, await Filter.resolve(this.metadata.options.backendPrefilter)],
-            };
+        if (!this._dataProvider.isProxy) {
+            if (this.metadata.options.backendPreprocessFilter) {
+                where = await this.metadata.options.backendPreprocessFilter(where, {
+                    metadata: this.metadata,
+                    getFilterPreciseValues: (filter) => Filter.getPreciseValues(this.metadata, filter || where),
+                });
+            }
+            if (this.metadata.options.backendPrefilter) {
+                let z = where;
+                where = {
+                    $and: [
+                        z,
+                        await Filter.resolve(this.metadata.options.backendPrefilter),
+                    ],
+                };
+            }
         }
         let r = await Filter.fromEntityFilter(this.metadata, where);
         if (r && !this._dataProvider.isProxy) {
@@ -1184,7 +1199,7 @@ export class rowHelperImplementation extends rowHelperBase {
             return this.instance[y.key];
         };
         if (this.metadata.idMetadata.field instanceof CompoundIdField)
-            return this.metadata.idMetadata.field.fields.map(getVal).join(',');
+            return this.metadata.idMetadata.field.getId(getVal);
         return getVal(this.metadata.idMetadata.field);
     }
     saveMoreOriginalData() {
@@ -1242,7 +1257,7 @@ export class rowHelperImplementation extends rowHelperBase {
                 await this.__validateEntity();
             let doNotSave = false;
             let e = this.buildLifeCycleEvent(() => (doNotSave = true));
-            if (!this.remult.dataProvider.isProxy) {
+            if (!this.repository._dataProvider.isProxy) {
                 for (const col of this.fields) {
                     if (col.metadata.options.saving)
                         await col.metadata.options.saving(this.instance, col, e);
@@ -1296,7 +1311,7 @@ export class rowHelperImplementation extends rowHelperBase {
                     }
                 }
                 await this.loadDataFrom(updatedRow);
-                if (!this.remult.dataProvider.isProxy) {
+                if (!this.repository._dataProvider.isProxy) {
                     if (this.info.entityInfo.saved)
                         await this.info.entityInfo.saved(this.instance, e);
                     if (this.repository.listeners)
@@ -1359,14 +1374,14 @@ export class rowHelperImplementation extends rowHelperBase {
     async delete() {
         this.__clearErrorsAndReportChanged();
         let e = this.buildLifeCycleEvent();
-        if (!this.remult.dataProvider.isProxy) {
+        if (!this.repository._dataProvider.isProxy) {
             if (this.info.entityInfo.deleting)
                 await this.info.entityInfo.deleting(this.instance, e);
         }
         this.__assertValidity();
         try {
             await this.edp.delete(this.id);
-            if (!this.remult.dataProvider.isProxy) {
+            if (!this.repository._dataProvider.isProxy) {
                 if (this.info.entityInfo.deleted)
                     await this.info.entityInfo.deleted(this.instance, e);
             }
@@ -1922,9 +1937,13 @@ class EntityFullInfo {
         getIdFilter: (...ids) => {
             if (this.idMetadata.field instanceof CompoundIdField) {
                 let field = this.idMetadata.field;
-                return {
-                    $or: ids.map((x) => field.isEqualTo(x)),
-                };
+                if (ids.length == 1) {
+                    return field.isEqualTo(ids[0]);
+                }
+                else
+                    return {
+                        $or: ids.map((x) => field.isEqualTo(x)),
+                    };
             }
             if (ids.length == 1)
                 return {
@@ -1959,6 +1978,13 @@ export function ValueListFieldType(...options) {
             ;
             (o.valueConverter = ValueListInfo.get(type)),
                 (o.displayValue = (item, val) => val?.caption);
+            o.validate = (entity, ref) => {
+                const values = ValueListInfo.get(type).getValues();
+                if (ref.value && !values.find((v) => v === ref.value)) {
+                    ref.value = values.find((v) => v.id === ref.value.id) || ref.value;
+                }
+                return Validators.in(values)(entity, ref);
+            };
         }, ...options)(type, context);
     };
 }
@@ -2070,8 +2096,11 @@ export function buildOptions(options, remult) {
         if (o) {
             if (typeof o === 'function')
                 o(r, remult);
-            else
-                Object.assign(r, o);
+            else {
+                const { validate, ...otherOptions } = o;
+                r.validate = addValidator(r.validate, validate);
+                Object.assign(r, otherOptions);
+            }
         }
     }
     return r;
@@ -2080,10 +2109,7 @@ export function decorateColumnSettings(settings, remult) {
     if (settings.valueType) {
         let settingsOnTypeLevel = settings.valueType[storableMember];
         if (settingsOnTypeLevel) {
-            settings = {
-                ...buildOptions(settingsOnTypeLevel, remult),
-                ...settings,
-            };
+            settings = buildOptions([...settingsOnTypeLevel, settings], remult);
         }
     }
     if (settings.valueType == String) {

package/esm/src/remult3/addValidator.js

@@ -0,0 +1,15 @@
+export function addValidator(validators, newValidator, atStart = false) {
+    if (!newValidator)
+        return validators;
+    const newValidators = Array.isArray(newValidator)
+        ? newValidator
+        : [newValidator];
+    const validatorsArray = Array.isArray(validators)
+        ? validators
+        : validators
+            ? [validators]
+            : [];
+    return atStart
+        ? [...newValidators, ...validatorsArray]
+        : [...validatorsArray, ...newValidators];
+}