@dwtechs/antity-pgsql 0.8.0 → 0.9.0

package/README.md

@@ -45,7 +45,18 @@ $ npm i @dwtechs/antity-pgsql
 import { SQLEntity } from "@dwtechs/antity-pgsql";
 import { normalizeName, normalizeNickname } from "@dwtechs/checkard";
 
-const entity = new Entity("consumers", [
+// Create entity with default 'public' schema
+const entity = new SQLEntity("consumers", [
+  // properties...
+]);
+
+// Or specify a custom schema
+const customEntity = new SQLEntity("consumers", [
+  // properties...
+], "myschema");
+
+// Example with all properties
+const entity = new SQLEntity("consumers", [
   {
     key: "id",
     type: "integer",
@@ -53,13 +64,9 @@ const entity = new Entity("consumers", [
     max: 120,
     typeCheck: true,
     filter: true,
-    methods: ["GET", "PUT", "DELETE"],
-    operations: ["SELECT", "UPDATE", "DELETE"],
-    required: true,
-    safe: true,
-    sanitize: true,
-    normalize: true,
-    validate: true,
+    need: ["PUT"],
+    operations: ["SELECT", "UPDATE"],
+    send: true,
     sanitizer: null,
     normalizer: null,
     validator: null,
@@ -71,13 +78,9 @@ const entity = new Entity("consumers", [
     max: 255,
     typeCheck: true,
     filter: false,
-    methods: ["GET", "POST", "PUT", "DELETE"],
-    operations: ["SELECT", "UPDATE", "DELETE"],
-    required: true,
-    safe: true,
-    sanitize: true,
-    normalize: true,
-    validate: true,
+    need: ["POST", "PUT"],
+    operations: ["SELECT", "UPDATE"],
+    send: true,
     sanitizer: null,
     normalizer: normalizeName,
     validator: null,
@@ -89,13 +92,9 @@ const entity = new Entity("consumers", [
     max: 255,
     typeCheck: true,
     filter: false,
-    methods: ["GET", "POST", "PUT", "DELETE"],
-    operations: ["SELECT", "UPDATE", "DELETE"],
-    required: true,
-    safe: true,
-    sanitize: true,
-    normalize: true,
-    validate: true,
+    need: ["POST", "PUT"],
+    operations: ["SELECT", "UPDATE"],
+    send: true,
     sanitizer: null,
     normalizer: normalizeName,
     validator: null,
@@ -107,13 +106,9 @@ const entity = new Entity("consumers", [
     max: 255,
     typeCheck: true,
     filter: true,
-    methods: ["GET", "POST", "PUT", "DELETE"],
-    operations: ["SELECT", "UPDATE", "DELETE"],
-    required: true,
-    safe: true,
-    sanitize: true,
-    normalize: true,
-    validate: true,
+    need: ["POST", "PUT"],
+    operations: ["SELECT", "UPDATE"],
+    send: true,
     sanitizer: null,
     normalizer: normalizeNickname,
     validator: null,
@@ -121,11 +116,19 @@ const entity = new Entity("consumers", [
 ]);
 
 router.get("/", ..., entity.get);
-router.post("/", entity.normalizeArray, entity.validateArray, ..., entity.add);
-router.put("/", entity.normalizeArray, entity.validateArray, ..., entity.update);
+
+// Using substacks (recommended) - combines normalize, validate, and database operation
+router.post("/", ...entity.addArraySubstack);
+router.put("/", ...entity.updateArraySubstack);
+
+// Or manually chain middlewares
+router.post("/manual", entity.normalizeArray, entity.validateArray, ..., entity.add);
+router.put("/manual", entity.normalizeArray, entity.validateArray, ..., entity.update);
+
 router.put("/archive", ..., entity.archive);
 router.delete("/", ..., entity.delete);
 router.delete("/archived", ..., entity.deleteArchive);
+router.get("/history", ..., entity.getHistory);
 
 ```
 
@@ -134,7 +137,7 @@ router.delete("/archived", ..., entity.deleteArchive);
 
 ```javascript
 
-type Operation = "SELECT" | "INSERT" | "UPDATE" | "DELETE";
+type Operation = "SELECT" | "INSERT" | "UPDATE";
 
 type MatchMode =  
   "startsWith" | 
@@ -163,14 +166,26 @@ type Filter = {
   matchMode?: MatchMode;
 }
 
+type ExpressMiddleware = (req: Request, res: Response, next: NextFunction) => void;
+type ExpressMiddlewareAsync = (req: Request, res: Response, next: NextFunction) => Promise<void>;
+type SubstackTuple = [ExpressMiddleware, ExpressMiddleware, ExpressMiddlewareAsync];
+
 class SQLEntity {
-  constructor(name: string, properties: Property[]);
+  constructor(name: string, properties: Property[], schema?: string);
   get name(): string;
   get table(): string;
+  get schema(): string;
   get unsafeProps(): string[];
   get properties(): Property[];
   set name(name: string);
   set table(table: string);
+  set schema(schema: string);
+
+  // Middleware substacks (combine normalize, validate, and operation)
+  get addArraySubstack(): SubstackTuple;
+  get addOneSubstack(): SubstackTuple;
+  get updateArraySubstack(): SubstackTuple;
+  get updateOneSubstack(): SubstackTuple;
 
   query: {
     select: (
@@ -210,6 +225,7 @@ class SQLEntity {
   archive: (req: Request, res: Response, next: NextFunction) => Promise<void>;
   delete: (req: Request, res: Response, next: NextFunction) => Promise<void>;
   deleteArchive: (req: Request, res: Response, next: NextFunction) => void;
+  getHistory: (req: Request, res: Response, next: NextFunction) => Promise<void>;
 
 }
 
@@ -229,12 +245,38 @@ function execute(
 
 
 ```
-get(), add(), update(), archive(), delete() and deleteArchive() methods are made to be used as Express.js middlewares.
+
+### Middleware Methods for Express.js
+
+get(), add(), update(), archive(), delete(), deleteArchive() and getHistory() methods are made to be used as Express.js middlewares.
 Each method will look for data to work on in the **req.body.rows** parameter.
 
+### Schema Qualification
+
+All SQL queries generated by Antity-pgsql use schema-qualified table names (e.g., `schema.table`). This provides:
+- **Security**: Protection against search_path manipulation attacks, especially important when using SECURITY DEFINER functions
+- **Clarity**: Explicit schema references make queries more readable and maintainable
+- **Flexibility**: Easy multi-schema support within the same application
+
+The default schema is `'public'` but can be customized via the constructor's third parameter or the `schema` setter.
+
+### Middleware Substacks
+
+Substacks are pre-composed middleware chains that combine normalization, validation, and database operations:
+
+- **addArraySubstack**: Combines `normalizeArray`, `validateArray`, and `add`. Use this for POST routes with `req.body.rows` containing multiple objects.
+- **addOneSubstack**: Combines `normalizeOne`, `validateOne`, and `add`. Use this for POST routes with `req.body` containing a single object.
+- **updateArraySubstack**: Combines `normalizeArray`, `validateArray`, and `update`. Use this for PUT routes with `req.body.rows` containing multiple objects.
+- **updateOneSubstack**: Combines `normalizeOne`, `validateOne`, and `update`. Use this for PUT routes with `req.body` containing a single object.
+
+Using substacks simplifies your route definitions and ensures consistent data processing.
+
+### Query Methods
+
 - **query.select()**: Generates a SELECT query. When the `rows` parameter is provided (not null), pagination is automatically enabled and the query includes `COUNT(*) OVER () AS total` to return the total number of rows. The total count is extracted from results and returned separately from the row data.
 - **delete()**: Deletes rows by their IDs. Expects `req.body.rows` to be an array of objects with `id` property: `[{id: 1}, {id: 2}]`
-- **deleteArchive()**: Deletes archived rows that were archived before a specific date. Expects `req.body.date` to be a Date object.
+- **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.
 
 
 ## Match modes
@@ -318,18 +360,14 @@ Any of these can be passed into the options object for each function.
 | 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
+| need            |  Method[]                 | property is validated for the listed methods only | ["PATCH", "PUT", "POST"]
+| send            |  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
+| operations      |  Operation[]              | Property is used for the DML operations only      | ["SELECT", "INSERT", "UPDATE"]
 | 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
+| normalizer      |  ((v:any) => any) \| null | Custom 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*

package/dist/antity-pgsql.d.ts

@@ -68,46 +68,78 @@ export type PGResponse = {
   rowAsArray?: boolean;
 };
 
-declare class SQLEntity extends Entity {
-  private _table;
-  private sel;
-  private ins;
-  private upd;
-  constructor(name: string, properties: Property[]);
+type ExpressMiddleware = (req: Request, res: Response, next: NextFunction) => void;
+type ExpressMiddlewareAsync = (req: Request, res: Response, next: NextFunction) => Promise<void>;
+type SubstackTuple = [ExpressMiddleware, ExpressMiddleware, ExpressMiddlewareAsync];
+
+export class SQLEntity extends Entity {
+  private _table: string;
+  private _schema: string;
+  private sel: any;
+  private ins: any;
+  private upd: any;
+  
+  constructor(name: string, properties: Property[], schema?: string);
+  
   get table(): string;
   set table(table: string);
+  
+  get schema(): string;
+  set schema(schema: string);
+  
+  get addArraySubstack(): SubstackTuple;
+  get addOneSubstack(): SubstackTuple;
+  get updateArraySubstack(): SubstackTuple;
+  get updateOneSubstack(): SubstackTuple;
+  
   query: {
     select: (
       first?: number,
       rows?: number | null,
       sortField?: string | null,
       sortOrder?: "ASC" | "DESC" | null,
-      filters?: Filters | null) => {
-        query: string;
-        args: (Filter["value"])[];
+      filters?: Filters | null
+    ) => {
+      query: string;
+      args: (Filter["value"])[];
     };
-    update: (rows: Record<string,
-      unknown>[], consumerId?: number | string, consumerName?: 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[];
+    
+    insert: (
+      rows: Record<string, unknown>[],
+      consumerId?: number | string,
+      consumerName?: string,
+      rtn?: string
+    ) => {
+      query: string;
+      args: unknown[];
     };
+    
     delete: (ids: number[]) => {
       query: string;
       args: number[];
     };
+    
     deleteArchive: () => string;
+    
     return: (prop: string) => string;
   };
-  get: (req: Request, res: Response, next: NextFunction) => void;
-  add: (req: Request, res: Response, next: NextFunction) => Promise<void>;
-  update: (req: Request, res: Response, next: NextFunction) => Promise<void>;
-  archive: (req: Request, res: Response, next: NextFunction) => Promise<void>;
-  delete: (req: Request, res: Response, next: NextFunction) => Promise<void>;
-  deleteArchive: (req: Request, res: Response, next: NextFunction) => void;
+  
+  get(req: Request, res: Response, next: NextFunction): void;
+  add(req: Request, res: Response, next: NextFunction): Promise<void>;
+  update(req: Request, res: Response, next: NextFunction): Promise<void>;
+  archive(req: Request, res: Response, next: NextFunction): Promise<void>;
+  delete(req: Request, res: Response, next: NextFunction): Promise<void>;
+  deleteArchive(req: Request, res: Response, next: NextFunction): void;
+  getHistory(req: Request, res: Response, next: NextFunction): void;
 }
 
 declare function filter(

package/dist/antity-pgsql.js

@@ -222,10 +222,10 @@ class Select {
     get props() {
         return this._cols;
     }
-    query(table, first = 0, rows = null, sortField = null, sortOrder = null, filters = null) {
+    query(schema, table, first = 0, rows = null, sortField = null, sortOrder = null, filters = null) {
         const p = rows ? this._count : '';
         const c = this._cols ? this._cols : '*';
-        const baseQuery = `SELECT ${c}${p} FROM ${quoteIfUppercase(table)}`;
+        const baseQuery = `SELECT ${c}${p} FROM ${quoteIfUppercase(schema)}.${quoteIfUppercase(table)}`;
         const { filterClause, args } = filter(first, rows, sortField, sortOrder, filters);
         return {
             query: baseQuery + filterClause,
@@ -264,7 +264,7 @@ class Insert {
         this._nbProps++;
         this._cols = this._quotedProps.join(", ");
     }
-    query(table, rows, consumerId, consumerName, rtn = "") {
+    query(schema, table, rows, consumerId, consumerName, rtn = "") {
         const propsToUse = [...this._props];
         let nbProps = this._nbProps;
         let cols = this._cols;
@@ -273,7 +273,7 @@ class Insert {
             nbProps += 2;
             cols += `, "consumerId", "consumerName"`;
         }
-        let query = `INSERT INTO ${quoteIfUppercase(table)} (${cols}) VALUES `;
+        let query = `INSERT INTO ${quoteIfUppercase(schema)}.${quoteIfUppercase(table)} (${cols}) VALUES `;
         const args = [];
         let i = 0;
         for (const row of rows) {
@@ -316,7 +316,7 @@ class Update {
     addProp(prop) {
         this._props.push(prop);
     }
-    query(table, rows, consumerId, consumerName) {
+    query(schema, table, rows, consumerId, consumerName) {
         if (consumerId !== undefined && consumerName !== undefined)
             rows = this.addConsumer(rows, consumerId, consumerName);
         const propsToUse = [...this._props];
@@ -325,7 +325,7 @@ class Update {
         log.debug(`${LOGS_PREFIX}Update query input rows: ${JSON.stringify(rows, null, 2)}`);
         const l = rows.length;
         const args = rows.map(row => row.id);
-        let query = `UPDATE "${quoteIfUppercase(table)}" SET `;
+        let query = `UPDATE ${quoteIfUppercase(schema)}.${quoteIfUppercase(table)} SET `;
         let i = args.length + 1;
         for (const p of propsToUse) {
             if (rows[0][p] === undefined)
@@ -336,7 +336,7 @@ class Update {
                 query += `WHEN id = $${j + 1} THEN $${i++} `;
                 args.push(row[p]);
             }
-            query += `END, `;
+            query += `ELSE ${quoteIfUppercase(p)} END, `;
         }
         query = `${query.slice(0, -2)} WHERE id IN ${$i(l, 0)}`;
         return { query, args };
@@ -361,20 +361,20 @@ var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _argu
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-function queryById(table, ids) {
+function queryById(schema, table, ids) {
     return {
-        query: `DELETE FROM ${quoteIfUppercase(table)} WHERE id = ANY($1)`,
+        query: `DELETE FROM ${quoteIfUppercase(schema)}.${quoteIfUppercase(table)} WHERE id = ANY($1)`,
         args: [ids]
     };
 }
-function queryArchived(table) {
-    return `DELETE FROM ${quoteIfUppercase(table)} WHERE "archivedAt" < $1`;
+function queryByDate() {
+    return `SELECT hard_delete($1, $2, $3)`;
 }
-function executeArchived(date, query, client) {
+function executeArchived(schema, table, date, query, client) {
     return __awaiter$1(this, void 0, void 0, function* () {
         let db;
         try {
-            db = yield execute(query, [date], client);
+            db = yield execute(query, [schema, table, date], client);
         }
         catch (err) {
             throw err;
@@ -497,11 +497,10 @@ function generateSummary(name, table, properties) {
         lines.push(`│ │ ├─ Type: ${p.type}`);
         lines.push(`│ │ ├─ Min: ${p.min}`);
         lines.push(`│ │ ├─ Max: ${p.max}`);
-        lines.push(`│ │ ├─ Required: ${p.required}`);
+        lines.push(`│ │ ├─ need: ${p.need}`);
         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}`);
@@ -552,26 +551,26 @@ var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _argume
     });
 };
 class SQLEntity extends Entity {
-    constructor(name, properties) {
+    constructor(name, properties, schema = 'public') {
         super(name, properties);
         this.sel = new Select();
         this.ins = new Insert();
         this.upd = new Update();
         this.query = {
             select: (first = 0, rows = null, sortField = null, sortOrder = null, filters = null) => {
-                return this.sel.query(this.table, first, rows, sortField, sortOrder, filters);
+                return this.sel.query(this.schema, this.table, first, rows, sortField, sortOrder, filters);
             },
             update: (rows, consumerId, consumerName) => {
-                return this.upd.query(this.table, rows, consumerId, consumerName);
+                return this.upd.query(this.schema, this.table, rows, consumerId, consumerName);
             },
             insert: (rows, consumerId, consumerName, rtn = "") => {
-                return this.ins.query(this.table, rows, consumerId, consumerName, rtn);
+                return this.ins.query(this.schema, this.table, rows, consumerId, consumerName, rtn);
             },
             delete: (ids) => {
-                return queryById(this.table, ids);
+                return queryById(this.schema, this.table, ids);
             },
             deleteArchive: () => {
-                return queryArchived(this.table);
+                return queryByDate();
             },
             return: (prop) => {
                 return this.ins.rtn(prop);
@@ -591,7 +590,7 @@ class SQLEntity extends Entity {
             log.debug(`get(first='${first}', rows='${rows}', 
       sortOrder='${sortOrder}', sortField='${sortField}', 
       pagination=${pagination}, filters=${JSON.stringify(filters)}`);
-            const { query, args } = this.sel.query(this._table, first, rows, sortField, sortOrder, filters);
+            const { query, args } = this.sel.query(this._schema, this._table, first, rows, sortField, sortOrder, filters);
             this.sel.execute(query, args, dbClient)
                 .then((r) => {
                 l.rows = r.rows;
@@ -610,7 +609,7 @@ class SQLEntity extends Entity {
             const rtn = this.ins.rtn("id");
             const chunks = chunk(rows);
             for (const c of chunks) {
-                const { query, args } = this.ins.query(this._table, c, cId, cName, rtn);
+                const { query, args } = this.ins.query(this._schema, this._table, c, cId, cName, rtn);
                 let db;
                 try {
                     db = yield execute(query, args, dbClient);
@@ -635,7 +634,7 @@ class SQLEntity extends Entity {
             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);
+                const { query, args } = this.upd.query(this._schema, this._table, c, cId, cName);
                 try {
                     yield execute(query, args, dbClient);
                 }
@@ -655,7 +654,7 @@ class SQLEntity extends Entity {
             rows = rows.map((id) => (Object.assign(Object.assign({}, id), { archived: true })));
             const chunks = chunk(rows);
             for (const c of chunks) {
-                const { query, args } = this.upd.query(this._table, c, cId, cName);
+                const { query, args } = this.upd.query(this._schema, this._table, c, cId, cName);
                 try {
                     yield execute(query, args, dbClient);
                 }
@@ -670,7 +669,7 @@ class SQLEntity extends Entity {
             const dbClient = res.locals.dbClient || null;
             const ids = rows.map((row) => row.id);
             log.debug(`${LOGS_PREFIX}delete ${rows.length} rows : (${ids.join(", ")})`);
-            const { query, args } = queryById(this._table, ids);
+            const { query, args } = queryById(this._schema, this._table, ids);
             try {
                 yield execute(query, args, dbClient);
             }
@@ -682,13 +681,40 @@ class SQLEntity extends Entity {
         this.deleteArchive = (req, res, next) => {
             const date = req.body.date;
             const dbClient = res.locals.dbClient || null;
-            log.debug(`${LOGS_PREFIX}deleteArchive(date=${date})`);
-            const q = queryArchived(this._table);
-            executeArchived(date, q, dbClient)
+            log.debug(`${LOGS_PREFIX}deleteArchive(schema=${this._schema}, table=${this._table}, date=${date})`);
+            executeArchived(this._schema, this._table, date, queryByDate(), dbClient)
                 .then(() => next())
                 .catch((err) => next(err));
         };
+        this.getHistory = (req, res, next) => {
+            const id = req.params.id;
+            const dbClient = res.locals.dbClient || null;
+            if (!id) {
+                return next({ status: 400, msg: "Missing id" });
+            }
+            log.debug(`${LOGS_PREFIX}getHistory(schema=${this._schema}, table=${this._table}, id=${id})`);
+            const sql = `
+      SELECT id, tstamp, operation, "consumerId", "consumerName"
+      FROM log.history
+      WHERE "schemaName" = $1 
+        AND "tableName" = $2
+        AND CAST(record->>'id' AS INT) = $3
+      ORDER BY tstamp ASC
+    `;
+            execute(sql, [this._schema, this._table, id], dbClient)
+                .then((r) => {
+                const { rowCount, rows } = r;
+                if (!rowCount) {
+                    return next({ status: 404, msg: "History not found" });
+                }
+                res.locals.history = rows;
+                res.locals.total = rowCount;
+                next();
+            })
+                .catch((err) => next(err));
+        };
         this._table = name;
+        this._schema = schema;
         log.info(`${LOGS_PREFIX}Creating SQLEntity: "${name}"`);
         for (const p of properties) {
             this.mapProps(p.operations, p.key);
@@ -703,6 +729,26 @@ class SQLEntity extends Entity {
             throw new Error(`${LOGS_PREFIX}table must be a string of length > 0`);
         this._table = table;
     }
+    get schema() {
+        return this._schema;
+    }
+    set schema(schema) {
+        if (!isString(schema, "!0"))
+            throw new Error(`${LOGS_PREFIX}schema must be a string of length > 0`);
+        this._schema = schema;
+    }
+    get addArraySubstack() {
+        return [this.normalizeArray, this.validateArray, this.add];
+    }
+    get addOneSubstack() {
+        return [this.normalizeOne, this.validateOne, this.add];
+    }
+    get updateArraySubstack() {
+        return [this.normalizeArray, this.validateArray, this.update];
+    }
+    get updateOneSubstack() {
+        return [this.normalizeOne, this.validateOne, this.update];
+    }
     mapProps(operations, key) {
         for (const o of operations) {
             switch (o) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dwtechs/antity-pgsql",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Open source library to add PostgreSQL support to @dwtechs/Antity entities.",
   "keywords": [
     "entities"
@@ -38,7 +38,7 @@
   "dependencies": {
     "@dwtechs/checkard": "3.6.0",
     "@dwtechs/winstan": "0.5.0",
-    "@dwtechs/antity": "0.14.0",
+    "@dwtechs/antity": "0.15.0",
     "@dwtechs/sparray": "0.2.1",
     "pg": "8.13.1"
   },