@dwtechs/antity-pgsql 0.3.3 → 0.5.0

package/README.md

@@ -52,7 +52,9 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 120,
     typeCheck: true,
+    filter: true,
     methods: ["GET", "PUT", "DELETE"],
+    operations: ["SELECT", "UPDATE", "DELETE"],
     required: true,
     safe: true,
     sanitize: true,
@@ -68,7 +70,9 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
+    filter: false,
     methods: ["GET", "POST", "PUT", "DELETE"],
+    operations: ["SELECT", "UPDATE", "DELETE"],
     required: true,
     safe: true,
     sanitize: true,
@@ -84,7 +88,9 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
+    filter: false,
     methods: ["GET", "POST", "PUT", "DELETE"],
+    operations: ["SELECT", "UPDATE", "DELETE"],
     required: true,
     safe: true,
     sanitize: true,
@@ -100,7 +106,9 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
+    filter: true,
     methods: ["GET", "POST", "PUT", "DELETE"],
+    operations: ["SELECT", "UPDATE", "DELETE"],
     required: true,
     safe: true,
     sanitize: true,
@@ -124,7 +132,7 @@ router.put("/", ..., entity.archive);
 
 ```javascript
 
-type Operation = "select" | "insert" | "update" | "merge" | "delete";
+type Operation = "SELECT" | "INSERT" | "UPDATE" | "DELETE";
 
 type MatchMode =  
   "startsWith" | 
@@ -163,17 +171,33 @@ class SQLEntity {
   set table(table: string);
 
   query: {
-    select: (paginate: boolean) => string;
-    update: (rows: Record<string, unknown>[], consumerId: number | string, consumerName: string) => {
+    select: (
+      paginate: boolean,
+      first?: number,
+      rows?: number | null,
+      sortField?: string | null,
+      sortOrder?: "ASC" | "DESC" | null,
+      filters?: Filters | null) => {
         query: string;
-        args: unknown[];
-    };
-    insert: (rows: Record<string, unknown>[], consumerId: number | string, consumerName: string, rtn?: string) => {
-        query: string;
-        args: unknown[];
-    };
-    delete: () => string;
-    return: (prop: string) => string;
+        args: (Filter["value"])[];
+      };
+      update: (
+        rows: Record<string, unknown>[],
+        consumerId?: number | string,
+        consumerName?: string) => {
+          query: string;
+          args: unknown[];
+      };
+      insert: (
+        rows: Record<string, unknown>[],
+        consumerId?: number | string,
+        consumerName?: string,
+        rtn?: string) => {
+          query: string;
+            args: unknown[];
+        };
+        delete: () => string;
+        return: (prop: string) => string;
   };
   get: (req: Request, res: Response, next: NextFunction) => void;
   add: (req: Request, res: Response, next: NextFunction) => Promise<void>;
@@ -273,6 +297,35 @@ List of secondary types :
 | json               | object     |
 | object             | object     |
 
+
+## Available options for a property
+
+Any of these can be passed into the options object for each function.
+
+| Name            | Type                      |               Description                         |  Default value  |  
+| :-------------- | :------------------------ | :------------------------------------------------ | :-------------- |
+| key             |  string                   | Name of the property                              |
+| type            |  Type                     | Type of the property                              |
+| min             |  number \| Date           | Minimum value                                     | 0 \| 1900-01-01
+| max             |  number \| Date           | Maximum value                                     | 999999999 \| 2200-12-31
+| required        |  boolean                  | Property is required during validation            | false
+| safe            |  boolean                  | Property is sent in the response                  | true
+| typeCheck       |  boolean                  | Type is checked during validation                 | false
+| filter          |  boolean                  | property is filterable in a SELECT operation      | true
+| methods         |  Method[]                 | property is validated for the listed methods only | [ "GET", "POST", "PUT", "DELETE" ]
+| operations      |  Operation[]              | SQL DML operations for the property               | [ "SELECT", "INSERT", "UPDATE", "DELETE" ]
+| sanitize        |  boolean                  | Sanitize the property if true                     | true
+| normalize       |  boolean                  | Normalize the property if true                    | false
+| validate        |  boolean                  | validate the property if true                     | true
+| sanitizer       |  ((v:any) => any) \| null | Custom sanitizer function if sanitize is true     | null
+| normalizer      |  ((v:any) => any) \| null | Custop Normalizer function if normalize is true   | null
+| validator       |  ((v:any, min:number, max:number, typeCheck:boolean) => any) \| null  | validator function if validate is true            | null
+
+
+* *Min and max parameters are not used for boolean type*
+* *TypeCheck Parameter is not used for boolean, string and array types*
+
+
 ## Contributors
 
 Antity.js is still in development and we would be glad to get all the help you can provide.

package/dist/antity-pgsql.d.ts

@@ -24,8 +24,9 @@ SOFTWARE.
 https://github.com/DWTechs/Antity-pgsql.js
 */
 
-import { Entity, Property } from "@dwtechs/antity";
+import { Entity } from "@dwtechs/antity";
 import { Type } from "@dwtechs/antity";
+import { Property } from './property';
 import type { Request, Response, NextFunction } from 'express';
 
 export type Operation = "SELECT" | "INSERT" | "UPDATE" | "DELETE";
@@ -76,14 +77,24 @@ declare class SQLEntity extends Entity {
   get table(): string;
   set table(table: string);
   query: {
-    select: (paginate: boolean) => string;
-    update: (rows: Record<string, unknown>[], consumerId: number | string, consumerName: string) => {
-      query: string;
-      args: unknown[];
+    select: (
+      paginate: boolean,
+      first?: number,
+      rows?: number | null,
+      sortField?: string | null,
+      sortOrder?: "ASC" | "DESC" | null,
+      filters?: Filters | null) => {
+        query: string;
+        args: (Filter["value"])[];
     };
-    insert: (rows: Record<string, unknown>[], consumerId: number | string, consumerName: string, rtn?: string) => {
-      query: string;
-      args: unknown[];
+    update: (rows: Record<string,
+      unknown>[], consumerId?: number | string, consumerName?: string) => {
+        query: string;
+        args: unknown[];
+    };
+    insert: (rows: Record<string, unknown>[], consumerId?: number | string, consumerName?: string, rtn?: string) => {
+        query: string;
+        args: unknown[];
     };
     delete: () => string;
     return: (prop: string) => string;

package/dist/antity-pgsql.js

@@ -24,79 +24,12 @@ SOFTWARE.
 https://github.com/DWTechs/Antity-pgsql.js
 */
 
-import { isIn, isArray, isString } from '@dwtechs/checkard';
-import { deleteProps, add as add$1, chunk, flatten } from '@dwtechs/sparray';
+import { isArray, isIn, isString } from '@dwtechs/checkard';
+import { deleteProps, chunk, flatten } from '@dwtechs/sparray';
 import { log } from '@dwtechs/winstan';
 import { Entity } from '@dwtechs/antity';
 import Pool from 'pg-pool';
 
-function type(type) {
-    const s = "string";
-    const n = "number";
-    const d = "date";
-    switch (type) {
-        case "integer":
-            return n;
-        case "float":
-            return n;
-        case "even":
-            return n;
-        case "odd":
-            return n;
-        case "positive":
-            return n;
-        case "negative":
-            return n;
-        case "powerOfTwo":
-            return n;
-        case "ascii":
-            return n;
-        case "jwt":
-            return s;
-        case "symbol":
-            return s;
-        case "password":
-            return s;
-        case "email":
-            return s;
-        case "regex":
-            return s;
-        case "ipAddress":
-            return s;
-        case "slug":
-            return s;
-        case "hexadecimal":
-            return s;
-        case "date":
-            return d;
-        case "timestamp":
-            return d;
-        case "function":
-            return s;
-        case "htmlElement":
-            return s;
-        case "htmlEventAttribute":
-            return s;
-        case "node":
-            return s;
-        case "json":
-            return s;
-        case "object":
-            return s;
-        default:
-            return s;
-    }
-}
-
-const matchModes = {
-    string: ["startsWith", "contains", "endsWith", "notContains", "equals", "notEquals", "lt", "lte", "gt", "gte"],
-    number: ["equals", "notEquals", "lt", "lte", "gt", "gte"],
-    date: ["is", "isNot", "dateAfter"],
-};
-function matchMode(type, matchMode) {
-    return isIn(matchModes[type], matchMode);
-}
-
 const { DB_HOST, DB_USER, DB_PWD, DB_NAME, DB_PORT, DB_MAX } = process.env;
 var pool = new Pool({
     host: DB_HOST,
@@ -107,10 +40,12 @@ var pool = new Pool({
     max: DB_MAX ? +DB_MAX : 10,
 });
 
+const LOGS_PREFIX = '[Antity-PGSQL] ';
+
 function start(query, args) {
     const a = JSON.stringify(args);
     const q = query.replace(/[\n\r]+/g, "").replace(/\s{2,}/g, " ");
-    log.debug(`Pgsql: { Query : '${q}', Args : '${a}' }`);
+    log.debug(`${LOGS_PREFIX}Pgsql: { Query : '${q}', Args : '${a}' }`);
     return Date.now();
 }
 function end(res, time) {
@@ -169,6 +104,111 @@ function quoteIfUppercase(word) {
     return 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:
+            return `${i}`;
+    }
+}
+
+function comparator(matchMode) {
+    switch (matchMode) {
+        case "startsWith":
+            return "LIKE";
+        case "endsWith":
+            return "LIKE";
+        case "contains":
+            return "LIKE";
+        case "notContains":
+            return "NOT LIKE";
+        case "equals":
+            return "=";
+        case "notEquals":
+            return "<>";
+        case "in":
+            return "IN";
+        case "lt":
+            return "<";
+        case "lte":
+            return "<=";
+        case "gt":
+            return ">";
+        case "gte":
+            return ">=";
+        case "is":
+            return "IS";
+        case "isNot":
+            return "IS NOT";
+        case "before":
+            return "<";
+        case "after":
+            return ">";
+        default:
+            return null;
+    }
+}
+
+function add(filters) {
+    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);
+            }
+        }
+    }
+    return { conditions, args };
+}
+function addOne(key, indexes, matchMode) {
+    const sqlKey = `${quoteIfUppercase(key)}`;
+    const comparator$1 = comparator(matchMode);
+    const index$1 = index(indexes, matchMode);
+    return comparator$1 ? `${sqlKey} ${comparator$1} ${index$1}` : "";
+}
+
+function filter(first, rows, sortField, sortOrder, filters) {
+    const { conditions, args } = add(filters);
+    const filterClause = where(conditions)
+        + orderBy(sortField, sortOrder)
+        + limit(rows, first);
+    return { filterClause, args };
+}
+function where(conditions, operator = "AND") {
+    if (!conditions.length)
+        return "";
+    const c = conditions.join(` ${operator} `).trim();
+    return ` WHERE ${c}`;
+}
+function orderBy(sortField, sortOrder) {
+    if (!sortField)
+        return "";
+    const o = sortOrder || "ASC";
+    return ` ORDER BY ${quoteIfUppercase(sortField)} ${o}`;
+}
+function limit(rows, first) {
+    return rows ? ` LIMIT ${rows} OFFSET ${first}` : "";
+}
+
 class Select {
     constructor() {
         this._props = [];
@@ -182,10 +222,15 @@ class Select {
     get props() {
         return this._cols;
     }
-    query(table, paginate) {
+    query(table, paginate, first = 0, rows = null, sortField = null, sortOrder = null, filters = null) {
         const p = paginate ? this._count : '';
         const c = this._cols ? this._cols : '*';
-        return `SELECT ${c}${p} FROM ${quoteIfUppercase(table)}`;
+        const baseQuery = `SELECT ${c}${p} FROM ${quoteIfUppercase(table)}`;
+        const { filterClause, args } = filter(first, rows, sortField, sortOrder, filters);
+        return {
+            query: baseQuery + filterClause,
+            args
+        };
     }
     execute(query, args, client) {
         return execute$1(query, args, client)
@@ -208,27 +253,37 @@ function $i(qty, start) {
 
 class Insert {
     constructor() {
-        this._props = ["consumerId", "consumerName"];
-        this._cols = "*";
-        this._nbProps = 2;
+        this._props = [];
+        this._nbProps = 0;
+        this._cols = "";
     }
     addProp(prop) {
-        this._props = add$1(this._props, quoteIfUppercase(prop), this._props.length - 2);
-        this._cols = this._props.join(", ");
+        this._props.push(quoteIfUppercase(prop));
         this._nbProps++;
+        this._cols = this._props.join(", ");
     }
     query(table, rows, consumerId, consumerName, rtn = "") {
-        let query = `INSERT INTO ${quoteIfUppercase(table)} (${this._cols}) VALUES `;
+        const propsToUse = [...this._props];
+        let nbProps = this._nbProps;
+        let cols = this._cols;
+        if (consumerId !== undefined && consumerName !== undefined) {
+            propsToUse.push("consumerId", "consumerName");
+            nbProps += 2;
+            cols += ", consumerId, consumerName";
+        }
+        let query = `INSERT INTO ${quoteIfUppercase(table)} (${cols}) VALUES `;
         const args = [];
         let i = 0;
         for (const row of rows) {
-            row.consumerId = consumerId;
-            row.consumerName = consumerName;
-            query += `${$i(this._nbProps, i)}, `;
-            for (const prop of this._props) {
+            if (consumerId !== undefined && consumerName !== undefined) {
+                row.consumerId = consumerId;
+                row.consumerName = consumerName;
+            }
+            query += `${$i(nbProps, i)}, `;
+            for (const prop of propsToUse) {
                 args.push(row[prop]);
             }
-            i += this._nbProps;
+            i += nbProps;
         }
         query = query.slice(0, -2);
         if (rtn)
@@ -254,18 +309,24 @@ var __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _argu
 };
 class Update {
     constructor() {
-        this._props = ["consumerId", "consumerName"];
+        this._props = [];
     }
     addProp(prop) {
-        this._props = add$1(this._props, quoteIfUppercase(prop), this._props.length - 2);
+        this._props.push(quoteIfUppercase(prop));
     }
     query(table, rows, consumerId, consumerName) {
-        rows = this.addConsumer(rows, consumerId, consumerName);
+        if (consumerId !== undefined && consumerName !== undefined) {
+            rows = this.addConsumer(rows, consumerId, consumerName);
+        }
+        const propsToUse = [...this._props];
+        if (consumerId !== undefined && consumerName !== undefined) {
+            propsToUse.push("consumerId", "consumerName");
+        }
         const l = rows.length;
         const args = rows.map(row => row.id);
         let query = `UPDATE "${quoteIfUppercase(table)}" SET `;
         let i = args.length + 1;
-        for (const p of this._props) {
+        for (const p of propsToUse) {
             if (rows[0][p] === undefined)
                 continue;
             query += `${p} = CASE `;
@@ -315,109 +376,163 @@ function execute(date, query, client) {
     });
 }
 
-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})`;
+function type(type) {
+    const s = "string";
+    const n = "number";
+    const d = "date";
+    switch (type) {
+        case "integer":
+            return n;
+        case "float":
+            return n;
+        case "even":
+            return n;
+        case "odd":
+            return n;
+        case "positive":
+            return n;
+        case "negative":
+            return n;
+        case "powerOfTwo":
+            return n;
+        case "ascii":
+            return n;
+        case "jwt":
+            return s;
+        case "symbol":
+            return s;
+        case "password":
+            return s;
+        case "email":
+            return s;
+        case "regex":
+            return s;
+        case "ipAddress":
+            return s;
+        case "slug":
+            return s;
+        case "hexadecimal":
+            return s;
+        case "date":
+            return d;
+        case "timestamp":
+            return d;
+        case "function":
+            return s;
+        case "htmlElement":
+            return s;
+        case "htmlEventAttribute":
+            return s;
+        case "node":
+            return s;
+        case "json":
+            return s;
+        case "object":
+            return s;
         default:
-            return `${i}`;
+            return s;
     }
 }
 
-function comparator(matchMode) {
-    switch (matchMode) {
-        case "startsWith":
-            return "LIKE";
-        case "endsWith":
-            return "LIKE";
-        case "contains":
-            return "LIKE";
-        case "notContains":
-            return "NOT LIKE";
-        case "equals":
-            return "=";
-        case "notEquals":
-            return "<>";
-        case "in":
-            return "IN";
-        case "lt":
-            return "<";
-        case "lte":
-            return "<=";
-        case "gt":
-            return ">";
-        case "gte":
-            return ">=";
-        case "is":
-            return "IS";
-        case "isNot":
-            return "IS NOT";
-        case "before":
-            return "<";
-        case "after":
-            return ">";
-        default:
-            return null;
-    }
+const matchModes = {
+    string: ["startsWith", "contains", "endsWith", "notContains", "equals", "notEquals", "lt", "lte", "gt", "gte"],
+    number: ["equals", "notEquals", "lt", "lte", "gt", "gte"],
+    date: ["is", "isNot", "dateAfter"],
+};
+function matchMode(type, matchMode) {
+    return isIn(matchModes[type], matchMode);
 }
 
-function add(filters) {
-    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);
+function cleanFilters(filters, properties) {
+    for (const k in filters) {
+        if (filters.hasOwnProperty(k)) {
+            const prop = properties.find(p => p.key === k);
+            if (!prop) {
+                log.warn(`${LOGS_PREFIX}Filters: skipping unknown property: ${k}`);
+                delete filters[k];
+                continue;
+            }
+            if (!prop.filter) {
+                log.warn(`${LOGS_PREFIX}Filters: skipping unfilterable property: ${k}`);
+                delete filters[k];
+                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}"`);
+                delete filters[k];
+                continue;
             }
         }
     }
-    return { conditions, args };
-}
-function addOne(key, indexes, matchMode) {
-    const sqlKey = `${quoteIfUppercase(key)}`;
-    const comparator$1 = comparator(matchMode);
-    const index$1 = index(indexes, matchMode);
-    return comparator$1 ? `${sqlKey} ${comparator$1} ${index$1}` : "";
+    return filters;
 }
 
-function filter(first, rows, sortField, sortOrder, filters) {
-    const { conditions, args } = add(filters);
-    const filterClause = where(conditions)
-        + orderBy(sortField, sortOrder)
-        + limit(rows, first);
-    return { filterClause, args };
+function logSummary(name, table, properties) {
+    const summary = generateSummary(name, table, properties);
+    log.info(`${LOGS_PREFIX}Entity "${name}" created successfully`);
+    log.info(`${LOGS_PREFIX}Entity Summary:\n${summary}`);
 }
-function where(conditions, operator = "AND") {
-    if (!conditions.length)
-        return "";
-    const c = conditions.join(` ${operator} `).trim();
-    return ` WHERE ${c}`;
+function generateSummary(name, table, properties) {
+    const lines = [];
+    const propLen = properties.length;
+    lines.push(`┌─ SQLEntity: "${name}" (Table: ${table})`);
+    lines.push(`├─ Total Properties: ${propLen}`);
+    const operationStats = getOperationStatistics(properties);
+    lines.push(`├─ Operation Distribution:`);
+    Object.entries(operationStats).forEach(([op, count]) => {
+        lines.push(`│  └─ ${op}: ${count} properties`);
+    });
+    lines.push(`├─ Property Details:`);
+    properties.forEach((p) => {
+        lines.push(`│ ├─ ${p.key}:`);
+        lines.push(`│ │ ├─ Type: ${p.type}`);
+        lines.push(`│ │ ├─ Min: ${p.min}`);
+        lines.push(`│ │ ├─ Max: ${p.max}`);
+        lines.push(`│ │ ├─ Required: ${p.required}`);
+        lines.push(`│ │ ├─ Safe: ${p.safe}`);
+        lines.push(`│ │ ├─ TypeCheck: ${p.typeCheck}`);
+        lines.push(`│ │ ├─ Filter: ${p.filter}`);
+        lines.push(`│ │ ├─ Methods: [${p.methods.join(', ')}]`);
+        lines.push(`│ │ ├─ Operations: [${p.operations.join(', ')}]`);
+        lines.push(`│ │ ├─ Sanitize: ${p.sanitize}`);
+        lines.push(`│ │ ├─ Normalize: ${p.normalize}`);
+        lines.push(`│ │ ├─ Validate: ${p.validate}`);
+    });
+    const crudMappings = getCrudMappings(properties);
+    lines.push(`├─ CRUD Mappings:`);
+    Object.entries(crudMappings).forEach(([operation, props]) => {
+        lines.push(`│  ├─ ${operation}: [${props.join(', ')}]`);
+    });
+    lines.push(`└─ Entity initialization completed`);
+    return lines.join('\n');
 }
-function orderBy(sortField, sortOrder) {
-    if (!sortField)
-        return "";
-    const o = sortOrder || "ASC";
-    return ` ORDER BY ${quoteIfUppercase(sortField)} ${o}`;
+function getOperationStatistics(properties) {
+    const stats = {};
+    properties.forEach(prop => {
+        prop.operations.forEach(op => {
+            stats[op] = (stats[op] || 0) + 1;
+        });
+    });
+    return stats;
 }
-function limit(rows, first) {
-    return rows ? ` LIMIT ${rows} OFFSET ${first}` : "";
+function getCrudMappings(properties) {
+    const mappings = {
+        'SELECT': [],
+        'INSERT': [],
+        'UPDATE': [],
+        'DELETE': []
+    };
+    properties.forEach(prop => {
+        const p = prop;
+        prop.operations.forEach(op => {
+            if (mappings[op]) {
+                mappings[op].push(p.key);
+            }
+        });
+    });
+    return mappings;
 }
 
 var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -436,8 +551,8 @@ class SQLEntity extends Entity {
         this.ins = new Insert();
         this.upd = new Update();
         this.query = {
-            select: (paginate) => {
-                return this.sel.query(this.table, paginate);
+            select: (paginate, first = 0, rows = null, sortField = null, sortOrder = null, filters = null) => {
+                return this.sel.query(this.table, paginate, first, rows, sortField, sortOrder, filters);
             },
             update: (rows, consumerId, consumerName) => {
                 return this.upd.query(this.table, rows, consumerId, consumerName);
@@ -460,15 +575,14 @@ class SQLEntity extends Entity {
             const rows = b.rows || null;
             const sortField = b.sortField || null;
             const sortOrder = b.sortOrder === -1 || b.sortOrder === "DESC" ? "DESC" : "ASC";
-            const filters = this.cleanFilters(b.filters) || null;
+            const filters = cleanFilters(b.filters, this.properties || []) || null;
             const pagination = b.pagination || false;
             const dbClient = l.dbClient || null;
             log.debug(`get(first='${first}', rows='${rows}', 
       sortOrder='${sortOrder}', sortField='${sortField}', 
       pagination=${pagination}, filters=${JSON.stringify(filters)}`);
-            const { filterClause, args } = filter(first, rows, sortField, sortOrder, filters);
-            const q = this.sel.query(this._table, pagination) + filterClause;
-            this.sel.execute(q, args, dbClient)
+            const { query, args } = this.sel.query(this._table, pagination, first, rows, sortField, sortOrder, filters);
+            this.sel.execute(query, args, dbClient)
                 .then((r) => {
                 l.rows = r.rows;
                 l.total = r.total;
@@ -482,7 +596,7 @@ class SQLEntity extends Entity {
             const dbClient = l.dbClient || null;
             const cId = l.consumerId;
             const cName = l.consumerName;
-            log.debug(`addMany(rows=${rows.length}, consumerId=${cId})`);
+            log.debug(`${LOGS_PREFIX}addMany(rows=${rows.length}, consumerId=${cId})`);
             const rtn = this.ins.rtn("id");
             const chunks = chunk(rows);
             for (const c of chunks) {
@@ -508,7 +622,7 @@ class SQLEntity extends Entity {
             const dbClient = l.dbClient || null;
             const cId = l.consumerId;
             const cName = l.consumerName;
-            log.debug(`update(rows=${rows.length}, consumerId=${cId})`);
+            log.debug(`${LOGS_PREFIX}update(rows=${rows.length}, consumerId=${cId})`);
             const chunks = chunk(rows);
             for (const c of chunks) {
                 const { query, args } = this.upd.query(this._table, c, cId, cName);
@@ -527,7 +641,7 @@ class SQLEntity extends Entity {
             const dbClient = l.dbClient || null;
             const cId = l.consumerId;
             const cName = l.consumerName;
-            log.debug(`archive(rows=${rows.length}, consumerId=${cId})`);
+            log.debug(`${LOGS_PREFIX}archive(rows=${rows.length}, consumerId=${cId})`);
             rows = rows.map((id) => (Object.assign(Object.assign({}, id), { archived: true })));
             const chunks = chunk(rows);
             for (const c of chunks) {
@@ -544,58 +658,37 @@ class SQLEntity extends Entity {
         this.delete = (req, res, next) => {
             const date = req.body.date;
             const dbClient = res.locals.dbClient || null;
-            log.debug(`delete archived`);
+            log.debug(`${LOGS_PREFIX}delete archived`);
             const q = query(this._table);
             execute(date, q, dbClient)
                 .then(() => next())
                 .catch((err) => next(err));
         };
         this._table = name;
+        log.info(`${LOGS_PREFIX}Creating SQLEntity: "${name}"`);
         for (const p of properties) {
-            this.mapProps(p.methods, p.key);
+            this.mapProps(p.operations, p.key);
         }
+        logSummary(name, this._table, properties);
     }
     get table() {
         return this._table;
     }
     set table(table) {
         if (!isString(table, "!0"))
-            throw new Error('table must be a string of length > 0');
+            throw new Error(`${LOGS_PREFIX}table must be a string of length > 0`);
         this._table = table;
     }
-    cleanFilters(filters) {
-        for (const k in filters) {
-            if (filters.hasOwnProperty(k)) {
-                const prop = this.getProp(k);
-                if (!prop) {
-                    log.warn(`Filters: skipping unknown property: ${k}`);
-                    delete filters[k];
-                    continue;
-                }
-                const type$1 = type(prop.type);
-                const { matchMode: matchMode$1 } = filters[k];
-                if (!matchMode$1 || !matchMode(type$1, matchMode$1)) {
-                    log.warn(`Filters: skipping invalid match mode: "${matchMode$1}" for type: "${type$1}" at property: "${k}"`);
-                    delete filters[k];
-                    continue;
-                }
-            }
-        }
-        return filters;
-    }
-    mapProps(methods, key) {
-        for (const m of methods) {
-            switch (m) {
-                case "GET":
+    mapProps(operations, key) {
+        for (const o of operations) {
+            switch (o) {
+                case "SELECT":
                     this.sel.addProp(key);
                     break;
-                case "PATCH":
-                    this.upd.addProp(key);
-                    break;
-                case "PUT":
+                case "UPDATE":
                     this.upd.addProp(key);
                     break;
-                case "POST":
+                case "INSERT":
                     this.ins.addProp(key);
                     break;
             }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dwtechs/antity-pgsql",
-  "version": "0.3.3",
-  "description": "Open source library for easy entity management",
+  "version": "0.5.0",
+  "description": "Open source library to add PostgreSQL support to @dwtechs/Antity entities.",
   "keywords": [
     "entities"
   ],
@@ -36,10 +36,10 @@
     "dist/"
   ],
   "dependencies": {
-    "@dwtechs/checkard": "3.2.3",
-    "@dwtechs/winstan": "0.4.0",
-    "@dwtechs/antity": "0.11.1",
-    "@dwtechs/sparray": "0.2.0",
+    "@dwtechs/checkard": "3.6.0",
+    "@dwtechs/winstan": "0.5.0",
+    "@dwtechs/antity": "0.13.0",
+    "@dwtechs/sparray": "0.2.1",
     "pg": "8.13.1"
   },
   "devDependencies": {