@dwtechs/antity-pgsql 0.17.1 → 0.17.3

package/README.md

@@ -123,6 +123,24 @@ router.get("/:id/history", ..., entity.getHistory);
 
 ```
 
+### Expected table structure
+
+```sql
+CREATE TABLE IF NOT EXISTS "service" (
+  id SERIAL PRIMARY KEY,
+  name varchar(20) NOT NULL,
+  pattern TEXT,
+  archived BOOLEAN DEFAULT FALSE,
+  "archivedAt" TIMESTAMP,
+  "creatorId" INT,
+  "creatorName" TEXT,
+  "updaterId" INT,
+  "updaterName" TEXT,
+  "createdAt" TIMESTAMP DEFAULT NOW(),
+  "updatedAt" TIMESTAMP NULL
+);
+```
+
 ## API Reference
 
 
@@ -132,6 +150,10 @@ type Operation = "SELECT" | "INSERT" | "UPDATE";
 
 type Row = Record<string, string | number | boolean | Date | number[]>;
 
+type Comparator =
+  "=" | "<" | ">" | "<=" | ">=" | "<>" |
+  "IS" | "IS NOT" | "IN" | "NOT IN" | "LIKE" | "NOT LIKE";
+
 type MatchMode =  
   "startsWith" | 
   "endsWith" |
@@ -151,7 +173,8 @@ type MatchMode =
   "before" |
   "after" |
   "st_contains" |
-  "st_dwithin";
+  "st_dwithin" |
+  Comparator; // direct SQL comparators are also accepted
 
 
 type Filters = {
@@ -160,7 +183,7 @@ type Filters = {
 
 type Filter = {
   value: string | number | boolean | Date | number[];
-  matchMode?: MatchMode;
+  matchMode?: MatchMode; // semantic mode or direct SQL comparator
   operator?: string; // 'and' | 'or' - Used when multiple filters apply to the same property
 }
 
@@ -311,10 +334,10 @@ Using substacks simplifies your route definitions and ensures consistent data pr
 ### 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.
-- **query.insert()**: Generates an INSERT query. Accepts an array of `Row` objects with properties matching the entity definition. Consumer fields are appended directly to the query arguments — row objects are **not mutated**. Optionally appends `consumer.id` as `creatorId` and `consumer.nickname` as `name` for audit tracking. Supports `RETURNING` clause via the `rtn` parameter.
-- **query.update()**: Generates an UPDATE query using CASE statements. Accepts an array of `Row` objects with `id` property. Optionally appends `consumer.id` as `updaterId` and `consumer.nickname` as `name` for audit tracking.
-- **query.upsert()**: Generates an INSERT ... ON CONFLICT ... DO UPDATE query. (See [Upsert](#upsert-insert-or-update) section below.) Accepts an array of `Row` objects and a `conflictTarget` (single column name or array of column names) that defines uniqueness. If a conflict occurs on the specified column(s), the row is updated; otherwise, it is inserted. Properties are automatically included if they have both INSERT and UPDATE operations. Consumer fields are appended directly to the query arguments — row objects are **not mutated**. Optionally appends `consumer.id` as `creatorId` and `consumer.nickname` as `name` for audit tracking. Supports `RETURNING` clause via the `rtn` parameter.
-- **query.archive()**: Generates a simplified `UPDATE ... SET archived = true WHERE id IN (...)` query. Accepts an array of `Row` objects with `id` property. Optionally appends `consumer.id` as `updaterId` and `consumer.nickname` as `name` for audit tracking. Does not require an `archived` field in the rows — it is set directly in the SQL.
+- **query.insert()**: Generates an INSERT query. Accepts an array of `Row` objects with properties matching the entity definition. Consumer fields are appended directly to the query arguments — row objects are **not mutated**. Optionally appends `consumer.id` as `creatorId` and `consumer.nickname` as `creatorName` for audit tracking. Supports `RETURNING` clause via the `rtn` parameter.
+- **query.update()**: Generates an UPDATE query using CASE statements. Accepts an array of `Row` objects with `id` property. Optionally appends `consumer.id` as `updaterId` and `consumer.nickname` as `updaterName` for audit tracking.
+- **query.upsert()**: Generates an INSERT ... ON CONFLICT ... DO UPDATE query. (See [Upsert](#upsert-insert-or-update) section below.) Accepts an array of `Row` objects and a `conflictTarget` (single column name or array of column names) that defines uniqueness. If a conflict occurs on the specified column(s), the row is updated; otherwise, it is inserted. Properties are automatically included if they have both INSERT and UPDATE operations. Consumer fields are appended directly to the query arguments — row objects are **not mutated**. Optionally appends `consumer.id` as `creatorId` and `consumer.nickname` as `creatorName` for audit tracking. Supports `RETURNING` clause via the `rtn` parameter.
+- **query.archive()**: Generates a simplified `UPDATE ... SET archived = true WHERE id IN (...)` query. Accepts an array of `Row` objects with `id` property. Optionally appends `consumer.id` as `updaterId` and `consumer.nickname` as `updaterName` for audit tracking. Does not require an `archived` field in the rows — it is set directly in the SQL.
 - **sync()**: Atomically synchronises the table with the provided rows inside a single PostgreSQL transaction. Missing rows are inserted, existing rows are updated, and rows absent from the list are deleted. Accepts optional `idField` (default `'id'`) and `filters` to restrict the scope of managed rows. Stores the result in `res.locals.rows` and a summary `{ inserted, updated, deleted }` in `res.locals.sync`.
 - **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 using a PostgreSQL SECURITY DEFINER function. Expects `req.body.date` to be a Date object.
@@ -376,7 +399,7 @@ res.locals.sync  // { inserted: 1, updated: 1, deleted: 1 }
 - **Atomic**: All insert / update / delete operations are wrapped in a single transaction.
 - **Filter scope**: When `filters` are provided, only rows matching the filter are considered "managed". Rows outside the filter are never touched.
 - **Property selection**: Insert uses `INSERT` properties; update uses `UPDATE` properties — same as the standalone `add` and `update` middlewares.
-- **Consumer tracking**: `consumer.id` and `consumer.nickname` from `res.locals.consumer` are forwarded to inserts as `creatorId`/`name` and to updates as `updaterId`/`name` for audit tracking.
+- **Consumer tracking**: `consumer.id` and `consumer.nickname` from `res.locals.consumer` are forwarded to inserts as `creatorId`/`creatorName` and to updates as `updaterId`/`updaterName` for audit tracking.
 
 ### Upsert (Insert or Update)
 
@@ -492,6 +515,12 @@ const filters = {
   age: { value: 30, matchMode: 'equals' },
   archived: { value: false, matchMode: 'equals' }
 };
+
+// Direct SQL comparators are also accepted
+const filters = {
+  age: { value: 30, matchMode: '>=' },
+  status: { value: null, matchMode: 'IS NOT' }
+};
 ```
 
 #### Complex Format (Multiple Filters per Property)
@@ -531,7 +560,11 @@ WHERE (name LIKE '%John%' OR name LIKE '%Jane%')
 
 ## Match modes
 
-List of possible match modes :  
+`matchMode` accepts either a **semantic match mode** (listed below) or a **direct SQL comparator** (`=`, `<`, `>`, `<=`, `>=`, `<>`, `IS`, `IS NOT`, `IN`, `NOT IN`, `LIKE`, `NOT LIKE`).
+
+Using a direct comparator bypasses the semantic layer. Note that when using `LIKE` or `NOT LIKE` directly, wildcard characters (`%`) must be included manually in the value.
+
+List of possible semantic match modes :  
 
 | Name        | alias | types                   | Description |
 | :---------- | :---- | :---------------------- | :-------------------------------------------------------- |

package/dist/antity-pgsql.d.ts

@@ -31,7 +31,7 @@ import type { Request, Response, NextFunction } from 'express';
 export type Operation = "SELECT" | "INSERT" | "UPDATE";
 export type Sort = "ASC" | "DESC";
 export type Filters = {
-  [key: string]: Filter;
+  [key: string]: Filter | Filter[];
 };
 export type Filter = {
   value: string | number | boolean | Date | number[];
@@ -60,8 +60,8 @@ export declare class Property extends BaseProperty {
 }
 
 export type LogicalOperator = "AND" | "OR";
-export type Comparator = "=" | "<" | ">" | "<=" | ">=" | "<>" | "IS" | "IS NOT" | "IN" | "LIKE" | "NOT LIKE";
-export type MatchMode = "startsWith" | "endsWith" | "contains" | "notContains" | "equals" | "notEquals" | "between" | "in" | "lt" | "lte" | "gt" | "gte" | "is" | "isNot" | "before" | "after" | "st_contains" | "st_dwithin";
+export type Comparator = "=" | "<" | ">" | "<=" | ">=" | "<>" | "IS" | "IS NOT" | "IN" | "NOT IN" | "LIKE" | "NOT LIKE";
+export type MatchMode = "startsWith" | "endsWith" | "contains" | "notContains" | "equals" | "notEquals" | "between" | "in" | "notIn" | "lt" | "lte" | "gt" | "gte" | "is" | "isNot" | "before" | "after" | "st_contains" | "st_dwithin" | Comparator;
 export type MappedType = "string" | "number" | "date";
 export type Geometry = {
   lng: number;
@@ -96,6 +96,7 @@ export type PGResponse = {
   _types?: unknown;
   RowCtor?: unknown;
   rowAsArray?: boolean;
+  _prebuiltEmptyResultObject?: Record<string, unknown>;
 };
 
 type ExpressMiddleware = (req: Request, res: Response, next: NextFunction) => void;

package/dist/antity-pgsql.js

@@ -24,7 +24,7 @@ SOFTWARE.
 https://github.com/DWTechs/Antity-pgsql.js
 */
 
-import { isArray, isString, isIn } from '@dwtechs/checkard';
+import { isArray, isString } from '@dwtechs/checkard';
 import { deleteProps, chunk, flatten } from '@dwtechs/sparray';
 import { log } from '@dwtechs/winstan';
 import { Entity } from '@dwtechs/antity';
@@ -84,7 +84,7 @@ function deleteIdleProperties(res) {
     res._prebuiltEmptyResultObject = undefined;
 }
 
-const reserved = [
+const reserved = new Set([
     'all', 'analyse', 'analyze', 'and', 'any', 'array', 'as', 'asc', 'asymmetric',
     'authorization', 'between', 'binary', 'both', 'case', 'cast', 'check', 'collate',
     'column', 'constraint', 'create', 'cross', 'current_catalog', 'current_date',
@@ -97,9 +97,9 @@ const reserved = [
     'references', 'returning', 'right', 'select', 'session_user', 'similar', 'some', 'symmetric',
     'table', 'tablesample', 'then', 'to', 'trailing', 'true', 'union', 'unique', 'user', 'using',
     'variadic', 'verbose', 'when', 'where', 'window', 'with'
-];
+]);
 function quoteIfUppercase(word) {
-    if (/[A-Z]/.test(word) || reserved.includes(word.toLowerCase()))
+    if (/[A-Z]/.test(word) || reserved.has(word.toLowerCase()))
         return `"${word}"`;
     return word;
 }
@@ -109,13 +109,18 @@ function index(index, matchMode) {
     switch (matchMode) {
         case "in":
         case "notIn":
+        case "IN":
+        case "NOT IN":
             return `(${i})`;
         default:
             return `${i}`;
     }
 }
 
+const COMPARATORS = new Set(["=", "<", ">", "<=", ">=", "<>", "IS", "IS NOT", "IN", "NOT IN", "LIKE", "NOT LIKE"]);
 function comparator(matchMode) {
+    if (matchMode && COMPARATORS.has(matchMode))
+        return matchMode;
     switch (matchMode) {
         case "startsWith":
             return "LIKE";
@@ -174,12 +179,11 @@ function shouldSkipValue(value, matchMode) {
         return true;
     if (isArray(value, "0"))
         return true;
-    if (value === null && matchMode !== 'is' && matchMode !== 'isNot')
+    if (value === null && matchMode !== 'is' && matchMode !== 'isNot' && matchMode !== 'IS' && matchMode !== 'IS NOT')
         return true;
     return false;
 }
 function add(filters) {
-    var _a, _b;
     const conditions = [];
     const args = [];
     if (filters) {
@@ -203,7 +207,7 @@ function add(filters) {
                 }
             }
             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 operator = filterArray[0]?.operator?.toUpperCase() || 'AND';
                 const combined = groupConditions.length > 1
                     ? `(${groupConditions.join(` ${operator} `)})`
                     : groupConditions[0];
@@ -244,11 +248,9 @@ function limit(rows, first) {
 }
 
 class Select {
-    constructor() {
-        this._props = [];
-        this._cols = "";
-        this._count = ", COUNT(*) OVER () AS total";
-    }
+    _props = [];
+    _cols = "";
+    _count = ", COUNT(*) OVER () AS total";
     addProp(prop) {
         this._props.push(quoteIfUppercase(prop));
         this._cols = this._props.join(", ");
@@ -286,12 +288,10 @@ function $i(qty, start) {
 }
 
 class Insert {
-    constructor() {
-        this._props = [];
-        this._quotedProps = [];
-        this._nbProps = 0;
-        this._cols = "";
-    }
+    _props = [];
+    _quotedProps = [];
+    _nbProps = 0;
+    _cols = "";
     addProp(prop) {
         this._props.push(prop);
         this._quotedProps.push(quoteIfUppercase(prop));
@@ -305,7 +305,7 @@ class Insert {
         if (consumerId !== undefined && consumerName !== undefined) {
             propsToUse.push("consumerId", "consumerName");
             nbProps += 2;
-            cols += `, creatorId, name`;
+            cols += `, "creatorId", "creatorName"`;
         }
         let query = `INSERT INTO ${quoteIfUppercase(schema)}.${quoteIfUppercase(table)} (${cols}) VALUES `;
         const args = [];
@@ -335,27 +335,15 @@ class Insert {
     }
 }
 
-var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 class Update {
-    constructor() {
-        this._props = [];
-    }
+    _props = [];
     addProp(prop) {
         this._props.push(prop);
     }
     query(schema, table, rows, consumerId, consumerName) {
-        if (consumerId !== undefined && consumerName !== undefined)
-            rows = this.addConsumer(rows, consumerId, consumerName);
+        const hasConsumer = consumerId !== undefined && consumerName !== undefined;
         const propsToUse = [...this._props];
-        if (consumerId !== undefined && consumerName !== undefined)
+        if (hasConsumer)
             propsToUse.push("consumerId", "consumerName");
         log.debug(() => `${LOGS_PREFIX}Update query input rows: ${JSON.stringify(rows, null, 2)}`);
         const l = rows.length;
@@ -363,38 +351,37 @@ class Update {
         let query = `UPDATE ${quoteIfUppercase(schema)}.${quoteIfUppercase(table)} SET `;
         let i = args.length + 1;
         for (const p of propsToUse) {
-            if (rows[0][p] === undefined)
+            const isConsumerId = p === "consumerId";
+            const isConsumerName = p === "consumerName";
+            const isConsumerProp = isConsumerId || isConsumerName;
+            if (!isConsumerProp && rows[0][p] === undefined)
                 continue;
-            const colName = p === "consumerId" ? "updaterId" : p === "consumerName" ? "name" : quoteIfUppercase(p);
+            const colName = isConsumerId ? '"updaterId"' : isConsumerName ? '"updaterName"' : quoteIfUppercase(p);
             query += `${colName} = CASE `;
             for (let j = 0; j < l; j++) {
-                const row = rows[j];
                 query += `WHEN id = $${j + 1} THEN $${i++} `;
-                args.push(row[p]);
+                if (isConsumerId)
+                    args.push(consumerId);
+                else if (isConsumerName)
+                    args.push(consumerName);
+                else
+                    args.push(rows[j][p]);
             }
             query += `ELSE ${colName} END, `;
         }
         query = `${query.slice(0, -2)} WHERE id IN ${$i(l, 0)}`;
         return { query, args };
     }
-    execute(query, args, client) {
-        return __awaiter$3(this, void 0, void 0, function* () {
-            return execute(query, args, client);
-        });
-    }
-    addConsumer(rows, consumerId, consumerName) {
-        return rows.map((row) => (Object.assign(Object.assign({}, row), { consumerId,
-            consumerName })));
+    async execute(query, args, client) {
+        return execute(query, args, client);
     }
 }
 
 class Upsert {
-    constructor() {
-        this._props = [];
-        this._quotedProps = [];
-        this._nbProps = 0;
-        this._cols = "";
-    }
+    _props = [];
+    _quotedProps = [];
+    _nbProps = 0;
+    _cols = "";
     addProp(prop) {
         this._props.push(prop);
         this._quotedProps.push(quoteIfUppercase(prop));
@@ -413,9 +400,9 @@ class Upsert {
         let cols = this._cols;
         if (consumerId !== undefined && consumerName !== undefined) {
             propsToUse.push("consumerId", "consumerName");
-            quotedPropsToUse.push(`creatorId`, `name`);
+            quotedPropsToUse.push(`"creatorId"`, `"creatorName"`);
             nbProps += 2;
-            cols += `, creatorId, name`;
+            cols += `, "creatorId", "creatorName"`;
         }
         const conflictColumns = Array.isArray(conflictTarget)
             ? conflictTarget.map(col => quoteIfUppercase(col)).join(", ")
@@ -456,15 +443,6 @@ class Upsert {
     }
 }
 
-var __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 class Archive {
     query(schema, table, rows, consumerId, consumerName) {
         log.debug(() => `${LOGS_PREFIX}Archive query input rows: ${JSON.stringify(rows, null, 2)}`);
@@ -472,28 +450,17 @@ class Archive {
         const args = rows.map(row => row.id);
         let query = `UPDATE ${quoteIfUppercase(schema)}.${quoteIfUppercase(table)} SET archived = true`;
         if (consumerId !== undefined && consumerName !== undefined) {
-            query += `, updaterId = $${l + 1}, name = $${l + 2}`;
+            query += `, "updaterId" = $${l + 1}, "updaterName" = $${l + 2}`;
             args.push(consumerId, consumerName);
         }
         query += ` WHERE id IN ${$i(l, 0)}`;
         return { query, args };
     }
-    execute(query, args, client) {
-        return __awaiter$2(this, void 0, void 0, function* () {
-            return execute(query, args, client);
-        });
+    async execute(query, args, client) {
+        return execute(query, args, client);
     }
 }
 
-var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 function queryById(schema, table, ids) {
     return {
         query: `DELETE FROM ${quoteIfUppercase(schema)}.${quoteIfUppercase(table)} WHERE id = ANY($1)`,
@@ -503,17 +470,15 @@ function queryById(schema, table, ids) {
 function queryByDate() {
     return `SELECT hard_delete($1, $2, $3)`;
 }
-function executeArchived(schema, table, date, query, client) {
-    return __awaiter$1(this, void 0, void 0, function* () {
-        let db;
-        try {
-            db = yield execute(query, [schema, table, date], client);
-        }
-        catch (err) {
-            throw err;
-        }
-        return db;
-    });
+async function executeArchived(schema, table, date, query, client) {
+    let db;
+    try {
+        db = await execute(query, [schema, table, date], client);
+    }
+    catch (err) {
+        throw err;
+    }
+    return db;
 }
 
 function type(type) {
@@ -575,12 +540,12 @@ function type(type) {
 }
 
 const matchModes = {
-    string: ["startsWith", "contains", "endsWith", "notContains", "equals", "notEquals", "lt", "lte", "gt", "gte", "in", "notIn"],
-    number: ["equals", "notEquals", "lt", "lte", "gt", "gte", "in", "notIn"],
-    date: ["is", "isNot", "dateAfter"],
+    string: new Set(["startsWith", "contains", "endsWith", "notContains", "equals", "notEquals", "lt", "lte", "gt", "gte", "in", "notIn"]),
+    number: new Set(["equals", "notEquals", "lt", "lte", "gt", "gte", "in", "notIn"]),
+    date: new Set(["is", "isNot", "dateAfter"]),
 };
 function matchMode(type, matchMode) {
-    return isIn(matchModes[type], matchMode);
+    return COMPARATORS.has(matchMode) || matchModes[type].has(matchMode);
 }
 
 function cleanFilters(filters, properties) {
@@ -681,290 +646,16 @@ function getCrudMappings(properties) {
     return mappings;
 }
 
-var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 class SQLEntity extends Entity {
+    _table;
+    _schema;
+    sel = new Select();
+    ins = new Insert();
+    upd = new Update();
+    ups = new Upsert();
+    arc = new Archive();
     constructor(name, properties, schema = 'public') {
         super(name, properties);
-        this.sel = new Select();
-        this.ins = new Insert();
-        this.upd = new Update();
-        this.ups = new Upsert();
-        this.arc = new Archive();
-        this.query = {
-            select: (first = 0, rows = null, sortField = null, sortOrder = null, filters = null) => {
-                return this.sel.query(this.schema, this.table, first, rows, sortField, sortOrder, filters);
-            },
-            update: (rows, consumer) => {
-                return this.upd.query(this.schema, this.table, rows, consumer === null || consumer === void 0 ? void 0 : consumer.id, consumer === null || consumer === void 0 ? void 0 : consumer.nickname);
-            },
-            insert: (rows, consumer, rtn = "") => {
-                return this.ins.query(this.schema, this.table, rows, consumer === null || consumer === void 0 ? void 0 : consumer.id, consumer === null || consumer === void 0 ? void 0 : consumer.nickname, rtn);
-            },
-            upsert: (rows, conflictTarget, consumer, rtn = "") => {
-                return this.ups.query(this.schema, this.table, rows, conflictTarget, consumer === null || consumer === void 0 ? void 0 : consumer.id, consumer === null || consumer === void 0 ? void 0 : consumer.nickname, rtn);
-            },
-            delete: (ids) => {
-                return queryById(this.schema, this.table, ids);
-            },
-            archive: (rows, consumer) => {
-                return this.arc.query(this.schema, this.table, rows, consumer === null || consumer === void 0 ? void 0 : consumer.id, consumer === null || consumer === void 0 ? void 0 : consumer.nickname);
-            },
-            deleteArchive: () => {
-                return queryByDate();
-            },
-            return: (prop) => {
-                return this.ins.rtn(prop);
-            }
-        };
-        this.get = (req, res, next) => {
-            var _a;
-            const l = res.locals;
-            const b = req.body;
-            const first = (_a = b === null || b === void 0 ? void 0 : b.first) !== null && _a !== void 0 ? _a : 0;
-            const rows = b.rows || null;
-            const sortField = b.sortField || null;
-            const sortOrder = b.sortOrder === -1 || b.sortOrder === "DESC" ? "DESC" : "ASC";
-            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 { 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;
-                l.total = r.total;
-                next();
-            })
-                .catch((err) => next(err));
-        };
-        this.add = (req, res, next) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const l = res.locals;
-            const rows = req.body.rows;
-            const dbClient = l.dbClient || null;
-            const cId = (_a = l.consumer) === null || _a === void 0 ? void 0 : _a.id;
-            const cName = (_b = l.consumer) === null || _b === void 0 ? void 0 : _b.nickname;
-            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) {
-                const { query, args } = this.ins.query(this._schema, this._table, c, cId, cName, rtn);
-                let db;
-                try {
-                    db = yield execute(query, args, dbClient);
-                }
-                catch (err) {
-                    return next(err);
-                }
-                const r = db.rows;
-                for (let i = 0; i < c.length; i++) {
-                    c[i].id = r[i].id;
-                }
-            }
-            l.rows = flatten(chunks);
-            next();
-        });
-        this.update = (req, res, next) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const l = res.locals;
-            const r = req.body.rows;
-            const dbClient = l.dbClient || null;
-            const cId = (_a = l.consumer) === null || _a === void 0 ? void 0 : _a.id;
-            const cName = (_b = l.consumer) === null || _b === void 0 ? void 0 : _b.nickname;
-            log.debug(() => `${LOGS_PREFIX}update(rows=${r.length}, consumerId=${cId})`);
-            const chunks = chunk(r);
-            for (const c of chunks) {
-                const { query, args } = this.upd.query(this._schema, this._table, c, cId, cName);
-                try {
-                    yield execute(query, args, dbClient);
-                }
-                catch (err) {
-                    return next(err);
-                }
-            }
-            l.rows = r;
-            next();
-        });
-        this.upsert = (req, res, next) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const l = res.locals;
-            const rows = req.body.rows;
-            const conflictTarget = req.body.conflictTarget;
-            const dbClient = l.dbClient || null;
-            const cId = (_a = l.consumer) === null || _a === void 0 ? void 0 : _a.id;
-            const cName = (_b = l.consumer) === null || _b === void 0 ? void 0 : _b.nickname;
-            if (!conflictTarget) {
-                return next({ status: 400, msg: "Missing conflictTarget for upsert operation" });
-            }
-            if (!rows || !Array.isArray(rows) || rows.length === 0) {
-                return next({ status: 400, msg: "Missing or empty rows array for upsert operation" });
-            }
-            log.debug(() => `${LOGS_PREFIX}upsert(rows=${rows.length}, conflictTarget=${conflictTarget}, consumerId=${cId})`);
-            const rtn = this.ups.rtn("id");
-            const chunks = chunk(rows);
-            for (const c of chunks) {
-                const { query, args } = this.ups.query(this._schema, this._table, c, conflictTarget, cId, cName, rtn);
-                let db;
-                try {
-                    db = yield execute(query, args, dbClient);
-                }
-                catch (err) {
-                    return next(err);
-                }
-                const r = db.rows;
-                for (let i = 0; i < c.length; i++) {
-                    c[i].id = r[i].id;
-                }
-            }
-            l.rows = flatten(chunks);
-            next();
-        });
-        this.archive = (req, res, next) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const l = res.locals;
-            const r = req.body.rows;
-            const dbClient = l.dbClient || null;
-            const cId = (_a = l.consumer) === null || _a === void 0 ? void 0 : _a.id;
-            const cName = (_b = l.consumer) === null || _b === void 0 ? void 0 : _b.nickname;
-            log.debug(() => `${LOGS_PREFIX}archive(rows=${r.length}, consumerId=${cId})`);
-            const chunks = chunk(r);
-            for (const c of chunks) {
-                const { query, args } = this.arc.query(this._schema, this._table, c, cId, cName);
-                try {
-                    yield execute(query, args, dbClient);
-                }
-                catch (err) {
-                    return next(err);
-                }
-            }
-            next();
-        });
-        this.delete = (req, res, next) => __awaiter(this, void 0, void 0, function* () {
-            const rows = req.body.rows;
-            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._schema, this._table, ids);
-            try {
-                yield execute(query, args, dbClient);
-            }
-            catch (err) {
-                return next(err);
-            }
-            next();
-        });
-        this.deleteArchive = (req, res, next) => {
-            const date = req.body.date;
-            const dbClient = res.locals.dbClient || null;
-            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) {
-                next({ status: 400, msg: "Missing id" });
-                return;
-            }
-            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.sync = (req, res, next) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            const l = res.locals;
-            const rows = req.body.rows;
-            const idField = (_a = req.body.idField) !== null && _a !== void 0 ? _a : 'id';
-            const cId = (_b = l.consumer) === null || _b === void 0 ? void 0 : _b.id;
-            const cName = (_c = l.consumer) === null || _c === void 0 ? void 0 : _c.nickname;
-            if (!rows || !Array.isArray(rows)) {
-                return next({ status: 400, msg: "Missing or invalid rows array for sync operation" });
-            }
-            log.debug(() => `${LOGS_PREFIX}sync(rows=${rows.length}, idField=${idField}, consumerId=${cId})`);
-            const cleanedFilters = cleanFilters(req.body.filters, this.properties) || null;
-            const { conditions, args: filterArgs } = add(cleanedFilters);
-            const whereClause = conditions.length ? ` WHERE ${conditions.join(' AND ')}` : '';
-            const txClient = l.dbClient || (yield pool.connect());
-            let toInsert = [];
-            let toUpdate = [];
-            let idsToDelete = [];
-            try {
-                yield txClient.query('BEGIN');
-                const selectIdQuery = `SELECT ${quoteIfUppercase(idField)} FROM ${quoteIfUppercase(this._schema)}.${quoteIfUppercase(this._table)}${whereClause}`;
-                const existingDb = yield execute(selectIdQuery, filterArgs, txClient);
-                const existingIds = new Set(existingDb.rows.map(r => r[idField]));
-                const incomingIds = new Set(rows.filter(r => r[idField] != null).map(r => r[idField]));
-                toInsert = rows.filter(r => r[idField] == null || !existingIds.has(r[idField]));
-                toUpdate = rows.filter(r => r[idField] != null && existingIds.has(r[idField]));
-                idsToDelete = [...existingIds].filter(id => !incomingIds.has(id));
-                if (toInsert.length > 0) {
-                    const rtn = this.ins.rtn(idField);
-                    const chunks = chunk(toInsert);
-                    for (const c of chunks) {
-                        const { query, args } = this.ins.query(this._schema, this._table, c, cId, cName, rtn);
-                        const db = yield execute(query, args, txClient);
-                        const r = db.rows;
-                        for (let i = 0; i < c.length; i++) {
-                            c[i][idField] = r[i][idField];
-                        }
-                    }
-                }
-                if (toUpdate.length > 0) {
-                    const chunks = chunk(toUpdate);
-                    for (const c of chunks) {
-                        const { query, args } = this.upd.query(this._schema, this._table, c, cId, cName);
-                        yield execute(query, args, txClient);
-                    }
-                }
-                if (idsToDelete.length > 0) {
-                    const deleteArgs = [idsToDelete, ...filterArgs];
-                    const scopedWhere = conditions.length
-                        ? ` AND ${conditions.map(c => c.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + 1}`)).join(' AND ')}`
-                        : '';
-                    const deleteQuery = `DELETE FROM ${quoteIfUppercase(this._schema)}.${quoteIfUppercase(this._table)} WHERE ${quoteIfUppercase(idField)} = ANY($1)${scopedWhere}`;
-                    yield execute(deleteQuery, deleteArgs, txClient);
-                }
-                yield txClient.query('COMMIT');
-            }
-            catch (err) {
-                yield txClient.query('ROLLBACK');
-                return next(err);
-            }
-            finally {
-                if (!l.dbClient)
-                    txClient.release();
-            }
-            l.rows = rows;
-            l.sync = { inserted: toInsert.length, updated: toUpdate.length, deleted: idsToDelete.length };
-            next();
-        });
         this._table = name;
         this._schema = schema;
         log.info(() => `${LOGS_PREFIX}Creating SQLEntity: "${name}"`);
@@ -1013,6 +704,267 @@ class SQLEntity extends Entity {
     get syncArraySubstack() {
         return [this.normalizeArray, this.validateArray, this.sync];
     }
+    query = {
+        select: (first = 0, rows = null, sortField = null, sortOrder = null, filters = null) => {
+            return this.sel.query(this.schema, this.table, first, rows, sortField, sortOrder, filters);
+        },
+        update: (rows, consumer) => {
+            return this.upd.query(this.schema, this.table, rows, consumer?.id, consumer?.nickname);
+        },
+        insert: (rows, consumer, rtn = "") => {
+            return this.ins.query(this.schema, this.table, rows, consumer?.id, consumer?.nickname, rtn);
+        },
+        upsert: (rows, conflictTarget, consumer, rtn = "") => {
+            return this.ups.query(this.schema, this.table, rows, conflictTarget, consumer?.id, consumer?.nickname, rtn);
+        },
+        delete: (ids) => {
+            return queryById(this.schema, this.table, ids);
+        },
+        archive: (rows, consumer) => {
+            return this.arc.query(this.schema, this.table, rows, consumer?.id, consumer?.nickname);
+        },
+        deleteArchive: () => {
+            return queryByDate();
+        },
+        return: (prop) => {
+            return this.ins.rtn(prop);
+        }
+    };
+    get = (req, res, next) => {
+        const l = res.locals;
+        const b = req.body;
+        const first = b?.first ?? 0;
+        const rows = b.rows || null;
+        const sortField = b.sortField || null;
+        const sortOrder = b.sortOrder === -1 || b.sortOrder === "DESC" ? "DESC" : "ASC";
+        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 { 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;
+            l.total = r.total;
+            next();
+        })
+            .catch((err) => next(err));
+    };
+    add = async (req, res, next) => {
+        const l = res.locals;
+        const rows = req.body.rows;
+        const dbClient = l.dbClient || null;
+        const cId = l.consumer?.id;
+        const cName = l.consumer?.nickname;
+        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) {
+            const { query, args } = this.ins.query(this._schema, this._table, c, cId, cName, rtn);
+            let db;
+            try {
+                db = await execute(query, args, dbClient);
+            }
+            catch (err) {
+                return next(err);
+            }
+            const r = db.rows;
+            for (let i = 0; i < c.length; i++) {
+                c[i].id = r[i].id;
+            }
+        }
+        l.rows = flatten(chunks);
+        next();
+    };
+    update = async (req, res, next) => {
+        const l = res.locals;
+        const r = req.body.rows;
+        const dbClient = l.dbClient || null;
+        const cId = l.consumer?.id;
+        const cName = l.consumer?.nickname;
+        log.debug(() => `${LOGS_PREFIX}update(rows=${r.length}, consumerId=${cId})`);
+        const chunks = chunk(r);
+        for (const c of chunks) {
+            const { query, args } = this.upd.query(this._schema, this._table, c, cId, cName);
+            try {
+                await execute(query, args, dbClient);
+            }
+            catch (err) {
+                return next(err);
+            }
+        }
+        l.rows = r;
+        next();
+    };
+    upsert = async (req, res, next) => {
+        const l = res.locals;
+        const rows = req.body.rows;
+        const conflictTarget = req.body.conflictTarget;
+        const dbClient = l.dbClient || null;
+        const cId = l.consumer?.id;
+        const cName = l.consumer?.nickname;
+        if (!conflictTarget) {
+            return next({ status: 400, msg: "Missing conflictTarget for upsert operation" });
+        }
+        if (!rows || !Array.isArray(rows) || rows.length === 0) {
+            return next({ status: 400, msg: "Missing or empty rows array for upsert operation" });
+        }
+        log.debug(() => `${LOGS_PREFIX}upsert(rows=${rows.length}, conflictTarget=${conflictTarget}, consumerId=${cId})`);
+        const rtn = this.ups.rtn("id");
+        const chunks = chunk(rows);
+        for (const c of chunks) {
+            const { query, args } = this.ups.query(this._schema, this._table, c, conflictTarget, cId, cName, rtn);
+            let db;
+            try {
+                db = await execute(query, args, dbClient);
+            }
+            catch (err) {
+                return next(err);
+            }
+            const r = db.rows;
+            for (let i = 0; i < c.length; i++) {
+                c[i].id = r[i].id;
+            }
+        }
+        l.rows = flatten(chunks);
+        next();
+    };
+    archive = async (req, res, next) => {
+        const l = res.locals;
+        const r = req.body.rows;
+        const dbClient = l.dbClient || null;
+        const cId = l.consumer?.id;
+        const cName = l.consumer?.nickname;
+        log.debug(() => `${LOGS_PREFIX}archive(rows=${r.length}, consumerId=${cId})`);
+        const chunks = chunk(r);
+        for (const c of chunks) {
+            const { query, args } = this.arc.query(this._schema, this._table, c, cId, cName);
+            try {
+                await execute(query, args, dbClient);
+            }
+            catch (err) {
+                return next(err);
+            }
+        }
+        next();
+    };
+    delete = async (req, res, next) => {
+        const rows = req.body.rows;
+        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._schema, this._table, ids);
+        try {
+            await execute(query, args, dbClient);
+        }
+        catch (err) {
+            return next(err);
+        }
+        next();
+    };
+    deleteArchive = (req, res, next) => {
+        const date = req.body.date;
+        const dbClient = res.locals.dbClient || null;
+        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));
+    };
+    getHistory = (req, res, next) => {
+        const id = req.params.id;
+        const dbClient = res.locals.dbClient || null;
+        if (!id) {
+            next({ status: 400, msg: "Missing id" });
+            return;
+        }
+        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));
+    };
+    sync = async (req, res, next) => {
+        const l = res.locals;
+        const rows = req.body.rows;
+        const idField = req.body.idField ?? 'id';
+        const cId = l.consumer?.id;
+        const cName = l.consumer?.nickname;
+        if (!rows || !Array.isArray(rows)) {
+            return next({ status: 400, msg: "Missing or invalid rows array for sync operation" });
+        }
+        log.debug(() => `${LOGS_PREFIX}sync(rows=${rows.length}, idField=${idField}, consumerId=${cId})`);
+        const cleanedFilters = cleanFilters(req.body.filters, this.properties) || null;
+        const { conditions, args: filterArgs } = add(cleanedFilters);
+        const whereClause = conditions.length ? ` WHERE ${conditions.join(' AND ')}` : '';
+        const txClient = l.dbClient || await pool.connect();
+        let toInsert = [];
+        let toUpdate = [];
+        let idsToDelete = [];
+        try {
+            await txClient.query('BEGIN');
+            const selectIdQuery = `SELECT ${quoteIfUppercase(idField)} FROM ${quoteIfUppercase(this._schema)}.${quoteIfUppercase(this._table)}${whereClause}`;
+            const existingDb = await execute(selectIdQuery, filterArgs, txClient);
+            const existingIds = new Set(existingDb.rows.map(r => r[idField]));
+            const incomingIds = new Set(rows.filter(r => r[idField] != null).map(r => r[idField]));
+            toInsert = rows.filter(r => r[idField] == null || !existingIds.has(r[idField]));
+            toUpdate = rows.filter(r => r[idField] != null && existingIds.has(r[idField]));
+            idsToDelete = [...existingIds].filter(id => !incomingIds.has(id));
+            if (toInsert.length > 0) {
+                const rtn = this.ins.rtn(idField);
+                const chunks = chunk(toInsert);
+                for (const c of chunks) {
+                    const { query, args } = this.ins.query(this._schema, this._table, c, cId, cName, rtn);
+                    const db = await execute(query, args, txClient);
+                    const r = db.rows;
+                    for (let i = 0; i < c.length; i++) {
+                        c[i][idField] = r[i][idField];
+                    }
+                }
+            }
+            if (toUpdate.length > 0) {
+                const chunks = chunk(toUpdate);
+                for (const c of chunks) {
+                    const { query, args } = this.upd.query(this._schema, this._table, c, cId, cName);
+                    await execute(query, args, txClient);
+                }
+            }
+            if (idsToDelete.length > 0) {
+                const deleteArgs = [idsToDelete, ...filterArgs];
+                const scopedWhere = conditions.length
+                    ? ` AND ${conditions.map(c => c.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + 1}`)).join(' AND ')}`
+                    : '';
+                const deleteQuery = `DELETE FROM ${quoteIfUppercase(this._schema)}.${quoteIfUppercase(this._table)} WHERE ${quoteIfUppercase(idField)} = ANY($1)${scopedWhere}`;
+                await execute(deleteQuery, deleteArgs, txClient);
+            }
+            await txClient.query('COMMIT');
+        }
+        catch (err) {
+            await txClient.query('ROLLBACK');
+            return next(err);
+        }
+        finally {
+            if (!l.dbClient)
+                txClient.release();
+        }
+        l.rows = rows;
+        l.sync = { inserted: toInsert.length, updated: toUpdate.length, deleted: idsToDelete.length };
+        next();
+    };
     mapProps(operations, key) {
         let hasInsert = false;
         let hasUpdate = false;

package/package.json

@@ -1,20 +1,19 @@
 {
   "name": "@dwtechs/antity-pgsql",
-  "version": "0.17.1",
+  "version": "0.17.3",
   "description": "Open source library to add PostgreSQL support to @dwtechs/Antity entities.",
   "keywords": [
     "entities"
   ],
   "homepage": "https://github.com/DWTechs/Antity-pgsql.js",
-  "main": "dist/antity-pgsql",
-  "types": "dist/antity-pgsql",
+  "main": "dist/antity-pgsql.js",
+  "types": "dist/antity-pgsql.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/DWTechs/Antity-pgsql.js" 
   },
   "bugs": {
-    "url": "https://github.com/DWTechs/Antity-pgsql.js/issues",
-    "email": ""
+    "url": "https://github.com/DWTechs/Antity-pgsql.js/issues"
   },
   "license": "MIT",
   "author": {
@@ -22,19 +21,18 @@
     "email": "http://www.lcluber.com/contact",
     "url": "http://www.lcluber.com"
   },
-  "contributors": [],
   "scripts": {
-    "start": "",
     "prebuild": "npm install",
     "build": "node ./scripts/clear && tsc && npm run rollup && node ./scripts/copy && npm run test",
-    "rollup:mjs": "rollup --config rollup.config.mjs",
-    "rollup:cjs": "rollup --config rollup.config.cjs.mjs",
-    "rollup": "npm run rollup:mjs",
+    "rollup": "rollup --config rollup.config.mjs",
     "test": "jest --coverage"
   },
   "files": [
     "dist/"
   ],
+  "engines": {
+    "node": ">= 22"
+  },
   "dependencies": {
     "@dwtechs/checkard": "3.6.0",
     "@dwtechs/winstan": "0.7.0",
@@ -45,16 +43,14 @@
   "devDependencies": {
     "@babel/core": "7.26.0",
     "@babel/preset-env": "7.26.0",
-    "@rollup/plugin-commonjs": "28.0.1",
-    "@rollup/plugin-node-resolve": "15.3.0",
     "@types/jest": "29.5.14",
-    "@types/node": "22.10.1",
-    "@types/pg-pool": "2.0.6",
-    "@types/express": "5.0.0",
+    "@types/node": "25.6.0",
+    "@types/pg-pool": "2.0.7",
+    "@types/express": "5.0.6",
     "babel-jest": "29.7.0",
     "core-js": "3.33.0",
     "jest": "29.7.0",
     "rollup": "4.24.0",
-    "typescript": "5.6.3"
+    "typescript": "6.0.3"
   }
 }