@dwtechs/antity-pgsql 0.10.0 → 0.11.1

package/README.md

@@ -160,10 +160,14 @@ type MatchMode =
   "st_dwithin";
 
 
+type Filters = {
+  [key: string]: Filter | Filter[]; // Supports both simple (object) and complex (array) formats
+}
+
 type Filter = {
   value: string | number | boolean | Date | number[];
-  subProps?: string[];
   matchMode?: MatchMode;
+  operator?: string; // 'and' | 'or' - Used when multiple filters apply to the same property
 }
 
 type ExpressMiddleware = (req: Request, res: Response, next: NextFunction) => void;
@@ -278,6 +282,56 @@ Using substacks simplifies your route definitions and ensures consistent data pr
 - **deleteArchive()**: Deletes archived rows that were archived before a specific date using a PostgreSQL SECURITY DEFINER function. Expects `req.body.date` to be a Date object.
 - **getHistory()**: Retrieves modification history for rows from the `log.history` table. Expects `req.body.rows` to be an array of objects with `id` property. Returns all historical records for the specified entity IDs.
 
+### Filters
+
+Filters support two formats for maximum flexibility:
+
+#### Simple Format (Single Filter per Property)
+
+Backward-compatible format using a single filter object:
+
+```javascript
+const filters = {
+  name: { value: 'John', matchMode: 'contains' },
+  age: { value: 30, matchMode: 'equals' },
+  archived: { value: false, matchMode: 'equals' }
+};
+```
+
+#### Complex Format (Multiple Filters per Property)
+
+Array-based format supporting multiple filters with logical operators:
+
+```javascript
+const filters = {
+  // Multiple filters on the same property with OR operator
+  name: [
+    { value: 'John', matchMode: 'contains', operator: 'or' },
+    { value: 'Jane', matchMode: 'contains', operator: 'or' }
+  ],
+  // Age range with AND operator
+  age: [
+    { value: 18, matchMode: 'gte', operator: 'and' },
+    { value: 65, matchMode: 'lte', operator: 'and' }
+  ],
+  // Single filter in array format
+  archived: [{ value: false, matchMode: 'equals' }]
+};
+```
+
+This generates SQL like:
+```sql
+WHERE (name LIKE '%John%' OR name LIKE '%Jane%') 
+  AND (age >= 18 AND age <= 65) 
+  AND archived = false
+```
+
+**Notes:**
+- Both formats can be mixed in the same filters object
+- When using arrays with a single filter, the operator is optional
+- Default operator is 'AND' if not specified
+- The operator field is case-insensitive
+
 
 ## Match modes
 

package/dist/antity-pgsql.d.ts

@@ -36,13 +36,13 @@ export type Filters = {
 };
 export type Filter = {
   value: string | number | boolean | Date | number[];
-  subProps?: string[];
   matchMode?: MatchMode;
+  operator?: string;
 };
 export type { Type };
 
 export declare class Property extends BaseProperty {
-  filter: boolean;
+  isFilterable: boolean;
   operations: Operation[];
   constructor(
     key: string,

package/dist/antity-pgsql.js

@@ -24,7 +24,7 @@ SOFTWARE.
 https://github.com/DWTechs/Antity-pgsql.js
 */
 
-import { isArray, isIn, isString } from '@dwtechs/checkard';
+import { isArray, isString, isIn } from '@dwtechs/checkard';
 import { deleteProps, chunk, flatten } from '@dwtechs/sparray';
 import { log } from '@dwtechs/winstan';
 import { Entity } from '@dwtechs/antity';
@@ -107,14 +107,6 @@ function quoteIfUppercase(word) {
 function index(index, matchMode) {
     const i = index.map((i) => `$${i}`);
     switch (matchMode) {
-        case "startsWith":
-            return `${i}%`;
-        case "endsWith":
-            return `%${i}`;
-        case "contains":
-            return `%${i}%`;
-        case "notContains":
-            return `%${i}%`;
         case "in":
             return `(${i})`;
         default:
@@ -159,21 +151,49 @@ function comparator(matchMode) {
     }
 }
 
+function formatValue(value, matchMode) {
+    if (!isString(value))
+        return value;
+    switch (matchMode) {
+        case "startsWith":
+            return `${value}%`;
+        case "endsWith":
+            return `%${value}`;
+        case "contains":
+        case "notContains":
+            return `%${value}%`;
+        default:
+            return value;
+    }
+}
 function add(filters) {
+    var _a, _b;
     const conditions = [];
     const args = [];
     if (filters) {
         let i = 1;
         for (const k in filters) {
-            const { value, matchMode } = filters[k];
-            const indexes = isArray(value) ? value.map(() => i++) : [i++];
-            const cond = addOne(k, indexes, matchMode);
-            if (cond) {
-                conditions.push(cond);
-                if (isArray(value))
-                    args.push(...value);
-                else
-                    args.push(value);
+            const filterValue = filters[k];
+            const filterArray = isArray(filterValue) ? filterValue : [filterValue];
+            const groupConditions = [];
+            for (const filter of filterArray) {
+                const { value, matchMode } = filter;
+                const indexes = isArray(value) ? value.map(() => i++) : [i++];
+                const cond = addOne(k, indexes, matchMode);
+                if (cond) {
+                    groupConditions.push(cond);
+                    if (isArray(value))
+                        args.push(...value.map((v) => formatValue(v, matchMode)));
+                    else
+                        args.push(formatValue(value, matchMode));
+                }
+            }
+            if (groupConditions.length > 0) {
+                const operator = ((_b = (_a = filterArray[0]) === null || _a === void 0 ? void 0 : _a.operator) === null || _b === void 0 ? void 0 : _b.toUpperCase()) || 'AND';
+                const combined = groupConditions.length > 1
+                    ? `(${groupConditions.join(` ${operator} `)})`
+                    : groupConditions[0];
+                conditions.push(combined);
             }
         }
     }
@@ -465,12 +485,20 @@ function cleanFilters(filters, properties) {
                 continue;
             }
             const type$1 = type(prop.type);
-            const { matchMode: matchMode$1 } = filters[k];
-            if (!matchMode$1 || !matchMode(type$1, matchMode$1)) {
-                log.warn(`${LOGS_PREFIX}Filters: skipping invalid match mode: "${matchMode$1}" for type: "${type$1}" at property: "${k}"`);
+            const filterValue = filters[k];
+            const filterArray = isArray(filterValue) ? filterValue : [filterValue];
+            const validFilters = filterArray.filter((f) => {
+                const { matchMode: matchMode$1 } = f;
+                if (!matchMode$1 || !matchMode(type$1, matchMode$1)) {
+                    log.warn(`${LOGS_PREFIX}Filters: skipping invalid match mode: "${matchMode$1}" for type: "${type$1}" at property: "${k}"`);
+                    return false;
+                }
+                return true;
+            });
+            if (!validFilters.length)
                 delete filters[k];
-                continue;
-            }
+            else
+                filters[k] = validFilters;
         }
     }
     return filters;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dwtechs/antity-pgsql",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Open source library to add PostgreSQL support to @dwtechs/Antity entities.",
   "keywords": [
     "entities"