remult 0.26.19 → 0.26.21

package/esm/remult-knex/index.js

@@ -307,6 +307,23 @@ class FilterConsumerBridgeToKnexRequest {
             }
         })());
     }
+    not(element) {
+        this.promises.push((async () => {
+            let f = new FilterConsumerBridgeToKnexRequest(this.innerNameProvider, this.rawSqlWrapIdentifier);
+            f._addWhere = false;
+            element.__applyToConsumer(f);
+            let where = await f.resolveWhere();
+            if (where.length > 0) {
+                this.result.push((b) => {
+                    b.whereNot((b) => {
+                        where.forEach((x) => x(b));
+                    });
+                });
+            }
+            else
+                return; //empty or means all rows
+        })());
+    }
     isNull(col) {
         this.result.push((b) => b.whereNull(this.innerNameProvider.$dbNameOf(col)));
     }
@@ -350,6 +367,22 @@ class FilterConsumerBridgeToKnexRequest {
             "%')"));
         this.promises.push((async () => { })());
     }
+    startsWithCaseInsensitive(col, val) {
+        this.result.push((b) => b.whereRaw('lower (' +
+            b.client.ref(this.innerNameProvider.$dbNameOf(col)) +
+            ") like lower ('" +
+            val.replace(/'/g, "''") +
+            "%')"));
+        this.promises.push((async () => { })());
+    }
+    endsWithCaseInsensitive(col, val) {
+        this.result.push((b) => b.whereRaw('lower (' +
+            b.client.ref(this.innerNameProvider.$dbNameOf(col)) +
+            ") like lower ('%" +
+            val.replace(/'/g, "''") +
+            "')"));
+        this.promises.push((async () => { })());
+    }
     add(col, val, operator) {
         this.result.push((b) => b.where(this.innerNameProvider.$dbNameOf(col), operator, translateValueAndHandleArrayAndHandleArray(col, val)));
     }

package/esm/remult-mongo.js

@@ -203,6 +203,19 @@ class FilterConsumerBridgeToMongo {
             }));
         })());
     }
+    not(element) {
+        this.promises.push((async () => {
+            let f = new FilterConsumerBridgeToMongo(this.nameProvider);
+            f._addWhere = false;
+            element.__applyToConsumer(f);
+            let where = await f.resolveWhere();
+            if (where) {
+                this.result.push(() => ({
+                    $nor: [where],
+                }));
+            }
+        })());
+    }
     isNull(col) {
         this.add(col, NULL, '$eq');
     }
@@ -247,6 +260,12 @@ class FilterConsumerBridgeToMongo {
             },
         }));
     }
+    startsWithCaseInsensitive(col, val) {
+        this.add(col, `^${val}`, '$regex', { $options: 'i' });
+    }
+    endsWithCaseInsensitive(col, val) {
+        this.add(col, `${val}$`, '$regex', { $options: 'i' });
+    }
     add(col, val, operator, moreOptions) {
         this.result.push(() => ({
             [this.nameProvider.$dbNameOf(col)]: {

package/esm/src/data-api.js

@@ -123,6 +123,8 @@ export class DataApi {
                 w.__applyToConsumer({
                     containsCaseInsensitive: () => { },
                     notContainsCaseInsensitive: () => { },
+                    startsWithCaseInsensitive: () => { },
+                    endsWithCaseInsensitive: () => { },
                     isDifferentFrom: () => { },
                     isEqualTo: (col, val) => {
                         if (this.repository.metadata.idMetadata.isIdField(col))
@@ -140,6 +142,7 @@ export class DataApi {
                     isLessThan: () => { },
                     isNotNull: () => { },
                     isNull: () => { },
+                    not: () => { },
                     or: () => { },
                 });
             }

package/esm/src/data-providers/array-entity-data-provider.js

@@ -215,6 +215,12 @@ class FilterConsumerBridgeToObject {
         }
         this.ok = false;
     }
+    not(element) {
+        let filter = new FilterConsumerBridgeToObject(this.row, this.dbNames);
+        element.__applyToConsumer(filter);
+        if (filter.ok)
+            this.ok = false;
+    }
     isNull(col) {
         if (this.row[this.dbNames.$dbNameOf(col)] != null)
             this.ok = false;
@@ -283,4 +289,32 @@ class FilterConsumerBridgeToObject {
         if (s.toLowerCase().indexOf(val) >= 0)
             this.ok = false;
     }
+    startsWithCaseInsensitive(col, val) {
+        let v = this.row[this.dbNames.$dbNameOf(col)];
+        if (!v) {
+            this.ok = false;
+            return;
+        }
+        let s = '' + v;
+        if (val)
+            val = col.valueConverter.toJson(val);
+        if (val)
+            val = val.toString().toLowerCase();
+        if (!s.toLowerCase().startsWith(val))
+            this.ok = false;
+    }
+    endsWithCaseInsensitive(col, val) {
+        let v = this.row[this.dbNames.$dbNameOf(col)];
+        if (!v) {
+            this.ok = false;
+            return;
+        }
+        let s = '' + v;
+        if (val)
+            val = col.valueConverter.toJson(val);
+        if (val)
+            val = val.toString().toLowerCase();
+        if (!s.toLowerCase().endsWith(val))
+            this.ok = false;
+    }
 }

package/esm/src/data-providers/rest-data-provider.js

@@ -316,6 +316,8 @@ export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
                 if (element.length > 10)
                     return false;
             }
+            if (key === 'NOT')
+                return false;
         }
     }
     for (const key in filter) {

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

@@ -49,6 +49,17 @@ export class FilterConsumerBridgeToSqlRequest {
             this.addToWhere('(' + statement + ')');
         })());
     }
+    not(element) {
+        this.promises.push((async () => {
+            let f = new FilterConsumerBridgeToSqlRequest(this.r, this.nameProvider);
+            f._addWhere = false;
+            element.__applyToConsumer(f);
+            let where = await f.resolveWhere();
+            if (!where)
+                return; //since if any member of or is empty, then the entire or is irrelevant
+            this.addToWhere('not (' + where + ')');
+        })());
+    }
     isNull(col) {
         this.promises.push((async () => this.addToWhere(this.nameProvider.$dbNameOf(col) + ' is null'))());
     }
@@ -104,6 +115,24 @@ export class FilterConsumerBridgeToSqlRequest {
                 "%')");
         })());
     }
+    startsWithCaseInsensitive(col, val) {
+        this.promises.push((async () => {
+            this.addToWhere('lower (' +
+                this.nameProvider.$dbNameOf(col) +
+                ") like lower ('" +
+                val.replace(/'/g, "''") +
+                "%')");
+        })());
+    }
+    endsWithCaseInsensitive(col, val) {
+        this.promises.push((async () => {
+            this.addToWhere('lower (' +
+                this.nameProvider.$dbNameOf(col) +
+                ") like lower ('%" +
+                val.replace(/'/g, "''") +
+                "')");
+        })());
+    }
     add(col, val, operator) {
         this.promises.push((async () => {
             let x = this.nameProvider.$dbNameOf(col) +

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

@@ -159,6 +159,9 @@ export class Filter {
                     if (key == '$or') {
                         result.push(new OrFilter(...fieldToFilter.map((x) => Filter.fromEntityFilter(entity, x))));
                     }
+                    else if (key == '$not') {
+                        result.push(new NotFilter(Filter.fromEntityFilter(entity, fieldToFilter)));
+                    }
                     else if (key == '$and') {
                         result.push(new AndFilter(...fieldToFilter.map((x) => Filter.fromEntityFilter(entity, x))));
                     }
@@ -225,6 +228,14 @@ export class Filter {
                                             found = true;
                                             result.push(fh.contains(element));
                                             break;
+                                        case '$startsWith':
+                                            found = true;
+                                            result.push(fh.startsWith(element));
+                                            break;
+                                        case '$endsWith':
+                                            found = true;
+                                            result.push(fh.endsWith(element));
+                                            break;
                                         case '$notContains':
                                             found = true;
                                             result.push(fh.notContains(element));
@@ -327,6 +338,12 @@ class filterHelper {
     notContains(val) {
         return new Filter((add) => add.notContainsCaseInsensitive(this.metadata, val));
     }
+    startsWith(val) {
+        return new Filter((add) => add.startsWithCaseInsensitive(this.metadata, val));
+    }
+    endsWith(val) {
+        return new Filter((add) => add.endsWithCaseInsensitive(this.metadata, val));
+    }
     isLessThan(val) {
         val = this.processVal(val);
         return new Filter((add) => add.isLessThan(this.metadata, val));
@@ -396,6 +413,12 @@ class manyToOneFilterHelper {
     notContains(val) {
         throw new Error('Invalid for Many To One Relation Field');
     }
+    endsWith(val) {
+        throw new Error('Invalid for Many To One Relation Field');
+    }
+    startsWith(val) {
+        throw new Error('Invalid for Many To One Relation Field');
+    }
     isLessThan(val) {
         throw new Error('Invalid for Many To One Relation Field');
     }
@@ -474,6 +497,15 @@ export class OrFilter extends Filter {
         this.filters = filters;
     }
 }
+export class NotFilter extends Filter {
+    filter;
+    constructor(filter) {
+        super((add) => {
+            add.not(filter);
+        });
+        this.filter = filter;
+    }
+}
 export const customUrlToken = '$custom$';
 export const customDatabaseFilterToken = '$db$';
 const customArrayToken = '$an array';
@@ -512,6 +544,11 @@ export class FilterSerializer {
             return f.result;
         }));
     }
+    not(filter) {
+        let f = new FilterSerializer();
+        filter.__applyToConsumer(f);
+        this.add('NOT', f.result);
+    }
     isNull(col) {
         this.add(col.key + '.null', true);
     }
@@ -545,6 +582,12 @@ export class FilterSerializer {
     notContainsCaseInsensitive(col, val) {
         this.add(col.key + '.notContains', val);
     }
+    startsWithCaseInsensitive(col, val) {
+        this.add(col.key + '.startsWith', val);
+    }
+    endsWithCaseInsensitive(col, val) {
+        this.add(col.key + '.endsWith', val);
+    }
 }
 export function entityFilterToJson(entityDefs, where) {
     if (!where)
@@ -629,6 +672,8 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
         }
         addFilter('.contains', (val) => ({ $contains: val }), false, true);
         addFilter('.notContains', (val) => ({ $notContains: val }), false, true);
+        addFilter('.startsWith', (val) => ({ $startsWith: val }), false, true);
+        addFilter('.endsWith', (val) => ({ $endsWith: val }), false, true);
     });
     let val = filterInfo.get('OR');
     if (val) {
@@ -652,6 +697,37 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
             });
         }
     }
+    val = filterInfo.get('NOT');
+    if (val) {
+        let array = separateArrayFromInnerArray(val);
+        const not = [];
+        for (const e1 of array) {
+            let z = e1;
+            if (Array.isArray(e1)) {
+                for (const e2 of e1) {
+                    not.push({
+                        $not: buildFilterFromRequestParameters(entity, {
+                            get: (key) => e2[key],
+                        }),
+                    });
+                }
+            }
+            else
+                not.push({
+                    $not: buildFilterFromRequestParameters(entity, {
+                        get: (key) => e1[key],
+                    }),
+                });
+        }
+        if (not.length == 1 && !where.$not) {
+            where = not[0];
+        }
+        else {
+            addAnd({
+                $and: not,
+            });
+        }
+    }
     for (const key in entity.entityType) {
         const element = entity.entityType[key];
         if (element &&
@@ -710,6 +786,16 @@ class customTranslator {
         }));
         this.commands.push((x) => x.or(newOrElements));
     }
+    not(filter) {
+        let newNotElement;
+        this.promises.push((async () => {
+            let c = new customTranslator(this.translateCustom);
+            filter.__applyToConsumer(c);
+            await c.resolve();
+            newNotElement = new Filter((x) => c.applyTo(x));
+        })());
+        this.commands.push((x) => x.not(newNotElement));
+    }
     isEqualTo(col, val) {
         this.commands.push((x) => x.isEqualTo(col, val));
     }
@@ -740,6 +826,12 @@ class customTranslator {
     notContainsCaseInsensitive(col, val) {
         this.commands.push((x) => x.notContainsCaseInsensitive(col, val));
     }
+    startsWithCaseInsensitive(col, val) {
+        this.commands.push((x) => x.startsWithCaseInsensitive(col, val));
+    }
+    endsWithCaseInsensitive(col, val) {
+        this.commands.push((x) => x.endsWithCaseInsensitive(col, val));
+    }
     isIn(col, val) {
         this.commands.push((x) => x.isIn(col, val));
     }
@@ -773,6 +865,8 @@ export function __updateEntityBasedOnWhere(entityDefs, where, r) {
             databaseCustom: emptyFunction,
             containsCaseInsensitive: emptyFunction,
             notContainsCaseInsensitive: emptyFunction,
+            startsWithCaseInsensitive: emptyFunction,
+            endsWithCaseInsensitive: emptyFunction,
             isDifferentFrom: emptyFunction,
             isEqualTo: (col, val) => {
                 r[col.key] = val;
@@ -784,6 +878,7 @@ export function __updateEntityBasedOnWhere(entityDefs, where, r) {
             isLessThan: emptyFunction,
             isNotNull: emptyFunction,
             isNull: emptyFunction,
+            not: emptyFunction,
             or: emptyFunction,
         });
     }
@@ -839,6 +934,7 @@ class preciseValuesCollector {
             x.bad = true;
         }
     }
+    not(filter) { }
     or(orElements) {
         const result = orElements.map((or) => {
             let x = new preciseValuesCollector();
@@ -899,6 +995,12 @@ class preciseValuesCollector {
     notContainsCaseInsensitive(col, val) {
         this.notOk(col);
     }
+    startsWithCaseInsensitive(col, val) {
+        this.notOk(col);
+    }
+    endsWithCaseInsensitive(col, val) {
+        this.notOk(col);
+    }
     isIn(col, val) {
         this.ok(col, ...val);
     }

package/esm/src/remult3/__updateEntityBasedOnWhere.js

@@ -8,6 +8,8 @@ export function __updateEntityBasedOnWhere(entityDefs, where, r) {
             databaseCustom: emptyFunction,
             containsCaseInsensitive: emptyFunction,
             notContainsCaseInsensitive: emptyFunction,
+            startsWithCaseInsensitive: emptyFunction,
+            endsWithCaseInsensitive: emptyFunction,
             isDifferentFrom: emptyFunction,
             isEqualTo: (col, val) => {
                 r[col.key] = val;
@@ -19,6 +21,7 @@ export function __updateEntityBasedOnWhere(entityDefs, where, r) {
             isLessThan: emptyFunction,
             isNotNull: emptyFunction,
             isNull: emptyFunction,
+            not: emptyFunction,
             or: emptyFunction,
         });
     }

package/package.json

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

package/remult-knex/index.js

@@ -606,6 +606,33 @@ var FilterConsumerBridgeToKnexRequest = /** @class */ (function () {
             });
         }); })());
     };
+    FilterConsumerBridgeToKnexRequest.prototype.not = function (element) {
+        var _this = this;
+        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var f, where;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        f = new FilterConsumerBridgeToKnexRequest(this.innerNameProvider, this.rawSqlWrapIdentifier);
+                        f._addWhere = false;
+                        element.__applyToConsumer(f);
+                        return [4 /*yield*/, f.resolveWhere()];
+                    case 1:
+                        where = _a.sent();
+                        if (where.length > 0) {
+                            this.result.push(function (b) {
+                                b.whereNot(function (b) {
+                                    where.forEach(function (x) { return x(b); });
+                                });
+                            });
+                        }
+                        else
+                            return [2 /*return*/]; //empty or means all rows
+                        return [2 /*return*/];
+                }
+            });
+        }); })());
+    };
     FilterConsumerBridgeToKnexRequest.prototype.isNull = function (col) {
         var _this = this;
         this.result.push(function (b) { return b.whereNull(_this.innerNameProvider.$dbNameOf(col)); });
@@ -666,6 +693,32 @@ var FilterConsumerBridgeToKnexRequest = /** @class */ (function () {
             return [2 /*return*/];
         }); }); })());
     };
+    FilterConsumerBridgeToKnexRequest.prototype.startsWithCaseInsensitive = function (col, val) {
+        var _this = this;
+        this.result.push(function (b) {
+            return b.whereRaw('lower (' +
+                b.client.ref(_this.innerNameProvider.$dbNameOf(col)) +
+                ") like lower ('" +
+                val.replace(/'/g, "''") +
+                "%')");
+        });
+        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/];
+        }); }); })());
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.endsWithCaseInsensitive = function (col, val) {
+        var _this = this;
+        this.result.push(function (b) {
+            return b.whereRaw('lower (' +
+                b.client.ref(_this.innerNameProvider.$dbNameOf(col)) +
+                ") like lower ('%" +
+                val.replace(/'/g, "''") +
+                "')");
+        });
+        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/];
+        }); }); })());
+    };
     FilterConsumerBridgeToKnexRequest.prototype.add = function (col, val, operator) {
         var _this = this;
         this.result.push(function (b) {

package/remult-mongo.js

@@ -431,6 +431,29 @@ var FilterConsumerBridgeToMongo = /** @class */ (function () {
             });
         }); })());
     };
+    FilterConsumerBridgeToMongo.prototype.not = function (element) {
+        var _this = this;
+        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var f, where;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        f = new FilterConsumerBridgeToMongo(this.nameProvider);
+                        f._addWhere = false;
+                        element.__applyToConsumer(f);
+                        return [4 /*yield*/, f.resolveWhere()];
+                    case 1:
+                        where = _a.sent();
+                        if (where) {
+                            this.result.push(function () { return ({
+                                $nor: [where],
+                            }); });
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); })());
+    };
     FilterConsumerBridgeToMongo.prototype.isNull = function (col) {
         this.add(col, NULL, '$eq');
     };
@@ -483,6 +506,12 @@ var FilterConsumerBridgeToMongo = /** @class */ (function () {
                 _a);
         });
     };
+    FilterConsumerBridgeToMongo.prototype.startsWithCaseInsensitive = function (col, val) {
+        this.add(col, "^".concat(val), '$regex', { $options: 'i' });
+    };
+    FilterConsumerBridgeToMongo.prototype.endsWithCaseInsensitive = function (col, val) {
+        this.add(col, "".concat(val, "$"), '$regex', { $options: 'i' });
+    };
     FilterConsumerBridgeToMongo.prototype.add = function (col, val, operator, moreOptions) {
         var _this = this;
         this.result.push(function () {

package/src/data-api.js

@@ -233,6 +233,8 @@ var DataApi = /** @class */ (function () {
                             w.__applyToConsumer({
                                 containsCaseInsensitive: function () { },
                                 notContainsCaseInsensitive: function () { },
+                                startsWithCaseInsensitive: function () { },
+                                endsWithCaseInsensitive: function () { },
                                 isDifferentFrom: function () { },
                                 isEqualTo: function (col, val) {
                                     if (_this.repository.metadata.idMetadata.isIdField(col))
@@ -250,6 +252,7 @@ var DataApi = /** @class */ (function () {
                                 isLessThan: function () { },
                                 isNotNull: function () { },
                                 isNull: function () { },
+                                not: function () { },
                                 or: function () { },
                             });
                         }

package/src/data-providers/array-entity-data-provider.js

@@ -353,6 +353,12 @@ var FilterConsumerBridgeToObject = /** @class */ (function () {
         }
         this.ok = false;
     };
+    FilterConsumerBridgeToObject.prototype.not = function (element) {
+        var filter = new FilterConsumerBridgeToObject(this.row, this.dbNames);
+        element.__applyToConsumer(filter);
+        if (filter.ok)
+            this.ok = false;
+    };
     FilterConsumerBridgeToObject.prototype.isNull = function (col) {
         if (this.row[this.dbNames.$dbNameOf(col)] != null)
             this.ok = false;
@@ -432,5 +438,33 @@ var FilterConsumerBridgeToObject = /** @class */ (function () {
         if (s.toLowerCase().indexOf(val) >= 0)
             this.ok = false;
     };
+    FilterConsumerBridgeToObject.prototype.startsWithCaseInsensitive = function (col, val) {
+        var v = this.row[this.dbNames.$dbNameOf(col)];
+        if (!v) {
+            this.ok = false;
+            return;
+        }
+        var s = '' + v;
+        if (val)
+            val = col.valueConverter.toJson(val);
+        if (val)
+            val = val.toString().toLowerCase();
+        if (!s.toLowerCase().startsWith(val))
+            this.ok = false;
+    };
+    FilterConsumerBridgeToObject.prototype.endsWithCaseInsensitive = function (col, val) {
+        var v = this.row[this.dbNames.$dbNameOf(col)];
+        if (!v) {
+            this.ok = false;
+            return;
+        }
+        var s = '' + v;
+        if (val)
+            val = col.valueConverter.toJson(val);
+        if (val)
+            val = val.toString().toLowerCase();
+        if (!s.toLowerCase().endsWith(val))
+            this.ok = false;
+    };
     return FilterConsumerBridgeToObject;
 }());

package/src/data-providers/rest-data-provider.js

@@ -446,6 +446,8 @@ function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
                 if (element.length > 10)
                     return false;
             }
+            if (key === 'NOT')
+                return false;
         }
     }
     var _loop_1 = function (key) {

package/src/filter/filter-consumer-bridge-to-sql-request.d.ts

@@ -13,6 +13,7 @@ export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer
     constructor(r: SqlCommandWithParameters, nameProvider: EntityDbNamesBase);
     custom(key: string, customItem: any): void;
     or(orElements: Filter[]): void;
+    not(element: Filter): void;
     isNull(col: FieldMetadata): void;
     isNotNull(col: FieldMetadata): void;
     isIn(col: FieldMetadata, val: any[]): void;
@@ -24,6 +25,8 @@ export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer
     isLessThan(col: FieldMetadata, val: any): void;
     containsCaseInsensitive(col: FieldMetadata, val: any): void;
     notContainsCaseInsensitive(col: FieldMetadata, val: any): void;
+    startsWithCaseInsensitive(col: FieldMetadata, val: any): void;
+    endsWithCaseInsensitive(col: FieldMetadata, val: any): void;
     private add;
     private addToWhere;
     databaseCustom(databaseCustom: CustomSqlFilterObject): void;

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

@@ -114,6 +114,27 @@ var FilterConsumerBridgeToSqlRequest = /** @class */ (function () {
             });
         }); })());
     };
+    FilterConsumerBridgeToSqlRequest.prototype.not = function (element) {
+        var _this = this;
+        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var f, where;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        f = new FilterConsumerBridgeToSqlRequest(this.r, this.nameProvider);
+                        f._addWhere = false;
+                        element.__applyToConsumer(f);
+                        return [4 /*yield*/, f.resolveWhere()];
+                    case 1:
+                        where = _a.sent();
+                        if (!where)
+                            return [2 /*return*/]; //since if any member of or is empty, then the entire or is irrelevant
+                        this.addToWhere('not (' + where + ')');
+                        return [2 /*return*/];
+                }
+            });
+        }); })());
+    };
     FilterConsumerBridgeToSqlRequest.prototype.isNull = function (col) {
         var _this = this;
         this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
@@ -188,6 +209,32 @@ var FilterConsumerBridgeToSqlRequest = /** @class */ (function () {
             });
         }); })());
     };
+    FilterConsumerBridgeToSqlRequest.prototype.startsWithCaseInsensitive = function (col, val) {
+        var _this = this;
+        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                this.addToWhere('lower (' +
+                    this.nameProvider.$dbNameOf(col) +
+                    ") like lower ('" +
+                    val.replace(/'/g, "''") +
+                    "%')");
+                return [2 /*return*/];
+            });
+        }); })());
+    };
+    FilterConsumerBridgeToSqlRequest.prototype.endsWithCaseInsensitive = function (col, val) {
+        var _this = this;
+        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                this.addToWhere('lower (' +
+                    this.nameProvider.$dbNameOf(col) +
+                    ") like lower ('%" +
+                    val.replace(/'/g, "''") +
+                    "')");
+                return [2 /*return*/];
+            });
+        }); })());
+    };
     FilterConsumerBridgeToSqlRequest.prototype.add = function (col, val, operator) {
         var _this = this;
         this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {

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

@@ -184,7 +184,8 @@ export declare class Filter {
     toJson(): any;
 }
 export interface FilterConsumer {
-    or(orElements: Filter[]): any;
+    or(orElements: Filter[]): void;
+    not(filter: Filter): void;
     isEqualTo(col: FieldMetadata, val: any): void;
     isDifferentFrom(col: FieldMetadata, val: any): void;
     isNull(col: FieldMetadata): void;
@@ -195,6 +196,8 @@ export interface FilterConsumer {
     isLessThan(col: FieldMetadata, val: any): void;
     containsCaseInsensitive(col: FieldMetadata, val: any): void;
     notContainsCaseInsensitive(col: FieldMetadata, val: any): void;
+    startsWithCaseInsensitive(col: FieldMetadata, val: any): void;
+    endsWithCaseInsensitive(col: FieldMetadata, val: any): void;
     isIn(col: FieldMetadata, val: any[]): void;
     custom(key: string, customItem: any): void;
     databaseCustom(databaseCustom: any): void;
@@ -208,6 +211,10 @@ export declare class OrFilter extends Filter {
     readonly filters: Filter[];
     constructor(...filters: Filter[]);
 }
+export declare class NotFilter extends Filter {
+    readonly filter: Filter;
+    constructor(filter: Filter);
+}
 export declare const customUrlToken = "$custom$";
 export declare const customDatabaseFilterToken = "$db$";
 export declare class FilterSerializer implements FilterConsumer {
@@ -218,6 +225,7 @@ export declare class FilterSerializer implements FilterConsumer {
     hasUndefined: boolean;
     add(key: string, val: any): void;
     or(orElements: Filter[]): void;
+    not(filter: Filter): void;
     isNull(col: FieldMetadata): void;
     isNotNull(col: FieldMetadata): void;
     isIn(col: FieldMetadata, val: any[]): void;
@@ -229,6 +237,8 @@ export declare class FilterSerializer implements FilterConsumer {
     isLessThan(col: FieldMetadata, val: any): void;
     containsCaseInsensitive(col: FieldMetadata, val: any): void;
     notContainsCaseInsensitive(col: FieldMetadata, val: any): void;
+    startsWithCaseInsensitive(col: FieldMetadata, val: any): void;
+    endsWithCaseInsensitive(col: FieldMetadata, val: any): void;
 }
 export declare function entityFilterToJson<T>(entityDefs: EntityMetadata<T>, where: EntityFilter<T>): any;
 export declare function buildFilterFromRequestParameters(entity: EntityMetadata, filterInfo: {

package/src/filter/filter-interfaces.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__updateEntityBasedOnWhere = exports.buildFilterFromRequestParameters = exports.entityFilterToJson = exports.FilterSerializer = exports.customDatabaseFilterToken = exports.customUrlToken = exports.OrFilter = exports.AndFilter = exports.Filter = void 0;
+exports.__updateEntityBasedOnWhere = exports.buildFilterFromRequestParameters = exports.entityFilterToJson = exports.FilterSerializer = exports.customDatabaseFilterToken = exports.customUrlToken = exports.NotFilter = exports.OrFilter = exports.AndFilter = exports.Filter = void 0;
 var tslib_1 = require("tslib");
 var getEntityRef_js_1 = require("../remult3/getEntityRef.js");
 var relationInfoMember_js_1 = require("../remult3/relationInfoMember.js");
@@ -208,6 +208,9 @@ var Filter = /** @class */ (function () {
                     if (key == '$or') {
                         result.push(new (OrFilter.bind.apply(OrFilter, tslib_1.__spreadArray([void 0], tslib_1.__read(fieldToFilter_1.map(function (x) { return Filter.fromEntityFilter(entity, x); })), false)))());
                     }
+                    else if (key == '$not') {
+                        result.push(new NotFilter(Filter.fromEntityFilter(entity, fieldToFilter_1)));
+                    }
                     else if (key == '$and') {
                         result.push(new (AndFilter.bind.apply(AndFilter, tslib_1.__spreadArray([void 0], tslib_1.__read(fieldToFilter_1.map(function (x) { return Filter.fromEntityFilter(entity, x); })), false)))());
                     }
@@ -274,6 +277,14 @@ var Filter = /** @class */ (function () {
                                             found = true;
                                             result.push(fh.contains(element));
                                             break;
+                                        case '$startsWith':
+                                            found = true;
+                                            result.push(fh.startsWith(element));
+                                            break;
+                                        case '$endsWith':
+                                            found = true;
+                                            result.push(fh.endsWith(element));
+                                            break;
                                         case '$notContains':
                                             found = true;
                                             result.push(fh.notContains(element));
@@ -423,6 +434,16 @@ var filterHelper = /** @class */ (function () {
             return add.notContainsCaseInsensitive(_this.metadata, val);
         });
     };
+    filterHelper.prototype.startsWith = function (val) {
+        var _this = this;
+        return new Filter(function (add) {
+            return add.startsWithCaseInsensitive(_this.metadata, val);
+        });
+    };
+    filterHelper.prototype.endsWith = function (val) {
+        var _this = this;
+        return new Filter(function (add) { return add.endsWithCaseInsensitive(_this.metadata, val); });
+    };
     filterHelper.prototype.isLessThan = function (val) {
         var _this = this;
         val = this.processVal(val);
@@ -514,6 +535,12 @@ var manyToOneFilterHelper = /** @class */ (function () {
     manyToOneFilterHelper.prototype.notContains = function (val) {
         throw new Error('Invalid for Many To One Relation Field');
     };
+    manyToOneFilterHelper.prototype.endsWith = function (val) {
+        throw new Error('Invalid for Many To One Relation Field');
+    };
+    manyToOneFilterHelper.prototype.startsWith = function (val) {
+        throw new Error('Invalid for Many To One Relation Field');
+    };
     manyToOneFilterHelper.prototype.isLessThan = function (val) {
         throw new Error('Invalid for Many To One Relation Field');
     };
@@ -627,6 +654,18 @@ var OrFilter = /** @class */ (function (_super) {
     return OrFilter;
 }(Filter));
 exports.OrFilter = OrFilter;
+var NotFilter = /** @class */ (function (_super) {
+    tslib_1.__extends(NotFilter, _super);
+    function NotFilter(filter) {
+        var _this = _super.call(this, function (add) {
+            add.not(filter);
+        }) || this;
+        _this.filter = filter;
+        return _this;
+    }
+    return NotFilter;
+}(Filter));
+exports.NotFilter = NotFilter;
 exports.customUrlToken = '$custom$';
 exports.customDatabaseFilterToken = '$db$';
 var customArrayToken = '$an array';
@@ -667,6 +706,11 @@ var FilterSerializer = /** @class */ (function () {
             return f.result;
         }));
     };
+    FilterSerializer.prototype.not = function (filter) {
+        var f = new FilterSerializer();
+        filter.__applyToConsumer(f);
+        this.add('NOT', f.result);
+    };
     FilterSerializer.prototype.isNull = function (col) {
         this.add(col.key + '.null', true);
     };
@@ -700,6 +744,12 @@ var FilterSerializer = /** @class */ (function () {
     FilterSerializer.prototype.notContainsCaseInsensitive = function (col, val) {
         this.add(col.key + '.notContains', val);
     };
+    FilterSerializer.prototype.startsWithCaseInsensitive = function (col, val) {
+        this.add(col.key + '.startsWith', val);
+    };
+    FilterSerializer.prototype.endsWithCaseInsensitive = function (col, val) {
+        this.add(col.key + '.endsWith', val);
+    };
     return FilterSerializer;
 }());
 exports.FilterSerializer = FilterSerializer;
@@ -710,6 +760,7 @@ function entityFilterToJson(entityDefs, where) {
 }
 exports.entityFilterToJson = entityFilterToJson;
 function buildFilterFromRequestParameters(entity, filterInfo) {
+    var e_5, _a;
     var where = {};
     function addAnd(what) {
         if (!where.$and) {
@@ -728,7 +779,7 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
     ;
     tslib_1.__spreadArray([], tslib_1.__read(entity.fields), false).forEach(function (col) {
         function addFilter(operation, theFilter, jsonArray, asString) {
-            var e_5, _a;
+            var e_6, _a;
             if (jsonArray === void 0) { jsonArray = false; }
             if (asString === void 0) { asString = false; }
             var val = filterInfo.get(col.key + operation);
@@ -765,17 +816,17 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
                     }
                     var array = separateArrayFromInnerArray(val);
                     try {
-                        for (var array_1 = tslib_1.__values(array), array_1_1 = array_1.next(); !array_1_1.done; array_1_1 = array_1.next()) {
-                            var x = array_1_1.value;
+                        for (var array_2 = tslib_1.__values(array), array_2_1 = array_2.next(); !array_2_1.done; array_2_1 = array_2.next()) {
+                            var x = array_2_1.value;
                             addFilter_1(x);
                         }
                     }
-                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
                     finally {
                         try {
-                            if (array_1_1 && !array_1_1.done && (_a = array_1.return)) _a.call(array_1);
+                            if (array_2_1 && !array_2_1.done && (_a = array_2.return)) _a.call(array_2);
                         }
-                        finally { if (e_5) throw e_5.error; }
+                        finally { if (e_6) throw e_6.error; }
                     }
                 }
             }
@@ -803,6 +854,8 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
         }
         addFilter('.contains', function (val) { return ({ $contains: val }); }, false, true);
         addFilter('.notContains', function (val) { return ({ $notContains: val }); }, false, true);
+        addFilter('.startsWith', function (val) { return ({ $startsWith: val }); }, false, true);
+        addFilter('.endsWith', function (val) { return ({ $endsWith: val }); }, false, true);
     });
     var val = filterInfo.get('OR');
     if (val) {
@@ -828,7 +881,65 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
             });
         }
     }
-    var _loop_3 = function (key) {
+    val = filterInfo.get('NOT');
+    if (val) {
+        var array = separateArrayFromInnerArray(val);
+        var not = [];
+        var _loop_3 = function (e1) {
+            var e_7, _b;
+            var z = e1;
+            if (Array.isArray(e1)) {
+                var _loop_5 = function (e2) {
+                    not.push({
+                        $not: buildFilterFromRequestParameters(entity, {
+                            get: function (key) { return e2[key]; },
+                        }),
+                    });
+                };
+                try {
+                    for (var e1_1 = (e_7 = void 0, tslib_1.__values(e1)), e1_1_1 = e1_1.next(); !e1_1_1.done; e1_1_1 = e1_1.next()) {
+                        var e2 = e1_1_1.value;
+                        _loop_5(e2);
+                    }
+                }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (e1_1_1 && !e1_1_1.done && (_b = e1_1.return)) _b.call(e1_1);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
+            }
+            else
+                not.push({
+                    $not: buildFilterFromRequestParameters(entity, {
+                        get: function (key) { return e1[key]; },
+                    }),
+                });
+        };
+        try {
+            for (var array_1 = tslib_1.__values(array), array_1_1 = array_1.next(); !array_1_1.done; array_1_1 = array_1.next()) {
+                var e1 = array_1_1.value;
+                _loop_3(e1);
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (array_1_1 && !array_1_1.done && (_a = array_1.return)) _a.call(array_1);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        if (not.length == 1 && !where.$not) {
+            where = not[0];
+        }
+        else {
+            addAnd({
+                $and: not,
+            });
+        }
+    }
+    var _loop_4 = function (key) {
         var element = entity.entityType[key];
         if (element &&
             element.rawFilterInfo &&
@@ -849,11 +960,11 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
         }
     };
     for (var key in entity.entityType) {
-        _loop_3(key);
+        _loop_4(key);
     }
     return where;
     function separateArrayFromInnerArray(val) {
-        var e_6, _a;
+        var e_8, _a;
         if (!Array.isArray(val))
             return [val];
         var nonArray = [], array = [];
@@ -867,12 +978,12 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
                     nonArray.push(v);
             }
         }
-        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
         finally {
             try {
                 if (val_1_1 && !val_1_1.done && (_a = val_1.return)) _a.call(val_1);
             }
-            finally { if (e_6) throw e_6.error; }
+            finally { if (e_8) throw e_8.error; }
         }
         array.push(nonArray);
         return array;
@@ -909,6 +1020,26 @@ var customTranslator = /** @class */ (function () {
         }));
         this.commands.push(function (x) { return x.or(newOrElements); });
     };
+    customTranslator.prototype.not = function (filter) {
+        var _this = this;
+        var newNotElement;
+        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var c;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        c = new customTranslator(this.translateCustom);
+                        filter.__applyToConsumer(c);
+                        return [4 /*yield*/, c.resolve()];
+                    case 1:
+                        _a.sent();
+                        newNotElement = new Filter(function (x) { return c.applyTo(x); });
+                        return [2 /*return*/];
+                }
+            });
+        }); })());
+        this.commands.push(function (x) { return x.not(newNotElement); });
+    };
     customTranslator.prototype.isEqualTo = function (col, val) {
         this.commands.push(function (x) { return x.isEqualTo(col, val); });
     };
@@ -939,6 +1070,12 @@ var customTranslator = /** @class */ (function () {
     customTranslator.prototype.notContainsCaseInsensitive = function (col, val) {
         this.commands.push(function (x) { return x.notContainsCaseInsensitive(col, val); });
     };
+    customTranslator.prototype.startsWithCaseInsensitive = function (col, val) {
+        this.commands.push(function (x) { return x.startsWithCaseInsensitive(col, val); });
+    };
+    customTranslator.prototype.endsWithCaseInsensitive = function (col, val) {
+        this.commands.push(function (x) { return x.endsWithCaseInsensitive(col, val); });
+    };
     customTranslator.prototype.isIn = function (col, val) {
         this.commands.push(function (x) { return x.isIn(col, val); });
     };
@@ -994,6 +1131,8 @@ function __updateEntityBasedOnWhere(entityDefs, where, r) {
             databaseCustom: emptyFunction,
             containsCaseInsensitive: emptyFunction,
             notContainsCaseInsensitive: emptyFunction,
+            startsWithCaseInsensitive: emptyFunction,
+            endsWithCaseInsensitive: emptyFunction,
             isDifferentFrom: emptyFunction,
             isEqualTo: function (col, val) {
                 r[col.key] = val;
@@ -1005,6 +1144,7 @@ function __updateEntityBasedOnWhere(entityDefs, where, r) {
             isLessThan: emptyFunction,
             isNotNull: emptyFunction,
             isNull: emptyFunction,
+            not: emptyFunction,
             or: emptyFunction,
         });
     }
@@ -1068,8 +1208,9 @@ var preciseValuesCollector = /** @class */ (function () {
             x.bad = true;
         }
     };
+    preciseValuesCollector.prototype.not = function (filter) { };
     preciseValuesCollector.prototype.or = function (orElements) {
-        var e_7, _a, e_8, _b;
+        var e_9, _a, e_10, _b;
         var result = orElements.map(function (or) {
             var x = new preciseValuesCollector();
             or.__applyToConsumer(x);
@@ -1092,29 +1233,29 @@ var preciseValuesCollector = /** @class */ (function () {
                 }
             }
         }
-        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
         finally {
             try {
                 if (result_1_1 && !result_1_1.done && (_a = result_1.return)) _a.call(result_1);
             }
-            finally { if (e_7) throw e_7.error; }
+            finally { if (e_9) throw e_9.error; }
         }
         for (var key in this.rawValues) {
             if (Object.prototype.hasOwnProperty.call(this.rawValues, key)) {
                 try {
-                    for (var result_2 = (e_8 = void 0, tslib_1.__values(result)), result_2_1 = result_2.next(); !result_2_1.done; result_2_1 = result_2.next()) {
+                    for (var result_2 = (e_10 = void 0, tslib_1.__values(result)), result_2_1 = result_2.next(); !result_2_1.done; result_2_1 = result_2.next()) {
                         var r = result_2_1.value;
                         var element = r.rawValues[key];
                         if (!element)
                             this.notOk(this.rawValues[key].field);
                     }
                 }
-                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                catch (e_10_1) { e_10 = { error: e_10_1 }; }
                 finally {
                     try {
                         if (result_2_1 && !result_2_1.done && (_b = result_2.return)) _b.call(result_2);
                     }
-                    finally { if (e_8) throw e_8.error; }
+                    finally { if (e_10) throw e_10.error; }
                 }
             }
         }
@@ -1149,6 +1290,12 @@ var preciseValuesCollector = /** @class */ (function () {
     preciseValuesCollector.prototype.notContainsCaseInsensitive = function (col, val) {
         this.notOk(col);
     };
+    preciseValuesCollector.prototype.startsWithCaseInsensitive = function (col, val) {
+        this.notOk(col);
+    };
+    preciseValuesCollector.prototype.endsWithCaseInsensitive = function (col, val) {
+        this.notOk(col);
+    };
     preciseValuesCollector.prototype.isIn = function (col, val) {
         this.ok.apply(this, tslib_1.__spreadArray([col], tslib_1.__read(val), false));
     };

package/src/remult3/__updateEntityBasedOnWhere.js

@@ -11,6 +11,8 @@ function __updateEntityBasedOnWhere(entityDefs, where, r) {
             databaseCustom: emptyFunction,
             containsCaseInsensitive: emptyFunction,
             notContainsCaseInsensitive: emptyFunction,
+            startsWithCaseInsensitive: emptyFunction,
+            endsWithCaseInsensitive: emptyFunction,
             isDifferentFrom: emptyFunction,
             isEqualTo: function (col, val) {
                 r[col.key] = val;
@@ -22,6 +24,7 @@ function __updateEntityBasedOnWhere(entityDefs, where, r) {
             isLessThan: emptyFunction,
             isNotNull: emptyFunction,
             isNull: emptyFunction,
+            not: emptyFunction,
             or: emptyFunction,
         });
     }

package/src/remult3/remult3.d.ts

@@ -485,28 +485,220 @@ export declare type EntityFilter<entityType> = {
         id?: string | number;
     } | undefined ? IdFilter<Partial<entityType>[Properties]> : ValueFilter<Partial<entityType>[Properties]>) | ContainsStringValueFilter;
 } & {
+    /**
+     * Represents an 'OR' filter condition where any of the specified filters can be true.
+     *
+     * @example
+     * // Matches entities where the status is 1 or the archive is false
+     * const filter = {
+     *   $or: [
+     *     { status: 1 },
+     *     { archive: false }
+     *   ]
+     * };
+     */
     $or?: EntityFilter<entityType>[];
+    /**
+     * Represents an 'AND' filter condition where all of the specified filters must be true.
+     *
+     * @example
+     * // Matches entities where the status is 1 and the archive is false
+     * const filter = {
+     *   $and: [
+     *     { status: 1 },
+     *     { archive: false }
+     *   ]
+     * };
+     */
     $and?: EntityFilter<entityType>[];
+    /**
+     * Represents a 'NOT' filter condition where the specified filter must be false.
+     *
+     * @example
+     * // Matches entities where the status is not 1
+     * const filter = {
+     *   $not: { status: 1 }
+     * };
+     */
+    $not?: EntityFilter<entityType>;
 };
 export type ValueFilter<valueType> = valueType | valueType[] | {
+    /**
+     * Represents a 'NOT EQUAL' filter condition where the value must not match the specified value or values.
+     *
+     * @example
+     * // Matches entities where the status is not 1
+     * const filter = {
+     *   status: { $ne: 1 }
+     * };
+     *
+     * @example
+     * // Matches entities where the status is not 1, 2, or 3
+     * const filter = {
+     *   status: { $ne: [1, 2, 3] }
+     * };
+     */
     $ne?: valueType | valueType[];
+    /**
+     * Represents a 'NOT EQUAL' filter condition using the '!=' operator where the value must not match the specified value or values.
+     *
+     * @example
+     * // Matches entities where the status is not 1
+     * const filter = {
+     *   status: { '!=': 1 }
+     * };
+     *
+     * @example
+     * // Matches entities where the status is not 1, 2, or 3
+     * const filter = {
+     *   status: { '!=': [1, 2, 3] }
+     * };
+     */
     '!='?: valueType | valueType[];
+    /**
+     * Represents an 'IN' filter condition where the value must match one of the specified values.
+     *
+     * @example
+     * // Matches entities where the status is 1, 3, or 5
+     * const filter = {
+     *   status: { $in: [1, 3, 5] }
+     * };
+     */
     $in?: valueType[];
+    /**
+     * Represents a 'NOT IN' filter condition where the value must not match any of the specified values.
+     *
+     * @example
+     * // Matches entities where the status is not 1, 2, or 3
+     * const filter = {
+     *   status: { $nin: [1, 2, 3] }
+     * };
+     */
     $nin?: valueType[];
 };
 export type ComparisonValueFilter<valueType> = ValueFilter<valueType> & {
+    /**
+     * Represents a 'GREATER THAN' filter condition where the value must be greater than the specified value.
+     *
+     * @example
+     * // Matches entities where the status is greater than 1
+     * const filter = {
+     *   status: { $gt: 1 }
+     * };
+     */
     $gt?: valueType;
+    /**
+     * Represents a 'GREATER THAN' filter condition using the '>' operator where the value must be greater than the specified value.
+     *
+     * @example
+     * // Matches entities where the status is greater than 1
+     * const filter = {
+     *   status: { '>': 1 }
+     * };
+     */
     '>'?: valueType;
+    /**
+     * Represents a 'GREATER THAN OR EQUAL TO' filter condition where the value must be greater than or equal to the specified value.
+     *
+     * @example
+     * // Matches entities where the status is greater than or equal to 1
+     * const filter = {
+     *   status: { $gte: 1 }
+     * };
+     */
     $gte?: valueType;
+    /**
+     * Represents a 'GREATER THAN OR EQUAL TO' filter condition using the '>=' operator where the value must be greater than or equal to the specified value.
+     *
+     * @example
+     * // Matches entities where the status is greater than or equal to 1
+     * const filter = {
+     *   status: { '>=': 1 }
+     * };
+     */
     '>='?: valueType;
+    /**
+     * Represents a 'LESS THAN' filter condition where the value must be less than the specified value.
+     *
+     * @example
+     * // Matches entities where the status is less than 1
+     * const filter = {
+     *   status: { $lt: 1 }
+     * };
+     */
     $lt?: valueType;
+    /**
+     * Represents a 'LESS THAN' filter condition using the '<' operator where the value must be less than the specified value.
+     *
+     * @example
+     * // Matches entities where the status is less than 1
+     * const filter = {
+     *   status: { '<': 1 }
+     * };
+     */
     '<'?: valueType;
+    /**
+     * Represents a 'LESS THAN OR EQUAL TO' filter condition where the value must be less than or equal to the specified value.
+     *
+     * @example
+     * // Matches entities where the status is less than or equal to 1
+     * const filter = {
+     *   status: { $lte: 1 }
+     * };
+     */
     $lte?: valueType;
+    /**
+     * Represents a 'LESS THAN OR EQUAL TO' filter condition using the '<=' operator where the value must be less than or equal to the specified value.
+     *
+     * @example
+     * // Matches entities where the status is less than or equal to 1
+     * const filter = {
+     *   status: { '<=': 1 }
+     * };
+     */
     '<='?: valueType;
 };
 export interface ContainsStringValueFilter {
+    /**
+     * Represents a 'CONTAINS' filter condition where the value must contain the specified substring.
+     *
+     * @example
+     * // Matches entities where the name contains 'joe'
+     * const filter = {
+     *   name: { $contains: 'joe' }
+     * };
+     */
     $contains?: string;
+    /**
+     * Represents a 'NOT CONTAINS' filter condition where the value must not contain the specified substring.
+     *
+     * @example
+     * // Matches entities where the name does not contain 'joe'
+     * const filter = {
+     *   name: { $notContains: 'joe' }
+     * };
+     */
     $notContains?: string;
+    /**
+     * Represents a 'STARTS WITH' filter condition where the value must start with the specified substring.
+     *
+     * @example
+     * // Matches entities where the name starts with 'joe'
+     * const filter = {
+     *   name: { $startsWith: 'joe' }
+     * };
+     */
+    $startsWith?: string;
+    /**
+     * Represents an 'ENDS WITH' filter condition where the value must end with the specified substring.
+     *
+     * @example
+     * // Matches entities where the name ends with 'joe'
+     * const filter = {
+     *   name: { $endsWith: 'joe' }
+     * };
+     */
+    $endsWith?: string;
 }
 export type IdFilter<valueType> = ValueFilter<valueType> | {
     $id: ValueFilter<valueType extends {