@dwtechs/antity-pgsql 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 DWTechs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,289 @@
+
+[![License: MIT](https://img.shields.io/npm/l/@dwtechs/antity-pgsql.svg?color=brightgreen)](https://opensource.org/licenses/MIT)
+[![npm version](https://badge.fury.io/js/%40dwtechs%2Fantity.svg)](https://www.npmjs.com/package/@dwtechs/antity-pgsql)
+[![last version release date](https://img.shields.io/github/release-date/DWTechs/Antity-pgsql.js)](https://www.npmjs.com/package/@dwtechs/antity-pgsql)
+![Jest:coverage](https://img.shields.io/badge/Jest:coverage-100%25-brightgreen.svg)
+[![minified size](https://img.shields.io/bundlephobia/min/@dwtechs/antity-pgsql?color=brightgreen)](https://www.npmjs.com/package/@dwtechs/antity-pgsql)
+
+- [Synopsis](#synopsis)
+- [Support](#support)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [ES6](#es6)
+- [API Reference](#api-reference)
+- [Contributors](#contributors)
+- [Stack](#stack)
+
+
+## Synopsis
+
+**[Antity-pgsql.js](https://github.com/DWTechs/Antity-pgsql.js)** adds PostgreSQL features to **Antity.js** library.
+
+- Very lightweight
+- Thoroughly tested
+- Works in Javascript, Typescript
+- Can be used as EcmaScrypt module
+- Written in Typescript
+
+
+## Support
+
+- node: 22
+
+This is the oldest targeted versions. The library should work properly on older versions of Node.js but we do not support it officially.  
+
+
+## Installation
+
+```bash
+$ npm i @dwtechs/antity-pgsql
+```
+
+
+## Usage
+
+
+### ES6 / TypeScript
+
+```javascript
+
+import { SQLEntity } from "@dwtechs/antity-pgsql";
+import { normalizeName, normalizeNickname } from "@dwtechs/checkard";
+
+const entity = new Entity("consumers", [
+  {
+    key: "id",
+    type: "integer",
+    min: 0,
+    max: 120,
+    typeCheck: true,
+    methods: ["GET", "PUT", "DELETE"],
+    required: true,
+    safe: true,
+    sanitize: true,
+    normalize: true,
+    validate: true,
+    sanitizer: null,
+    normalizer: null,
+    validator: null,
+  },
+  {
+    key: "firstName",
+    type: "string",
+    min: 0,
+    max: 255,
+    typeCheck: true,
+    methods: ["GET", "POST", "PUT", "DELETE"],
+    required: true,
+    safe: true,
+    sanitize: true,
+    normalize: true,
+    validate: true,
+    sanitizer: null,
+    normalizer: normalizeName,
+    validator: null,
+  },
+  {
+    key: "lastName",
+    type: "string",
+    min: 0,
+    max: 255,
+    typeCheck: true,
+    methods: ["GET", "POST", "PUT", "DELETE"],
+    required: true,
+    safe: true,
+    sanitize: true,
+    normalize: true,
+    validate: true,
+    sanitizer: null,
+    normalizer: normalizeName,
+    validator: null,
+  },
+  {
+    key: "nickname",
+    type: "string",
+    min: 0,
+    max: 255,
+    typeCheck: true,
+    methods: ["GET", "POST", "PUT", "DELETE"],
+    required: true,
+    safe: true,
+    sanitize: true,
+    normalize: true,
+    validate: true,
+    sanitizer: null,
+    normalizer: normalizeNickname,
+    validator: null,
+  },
+]);
+
+// add a consumer. Used when loggin in from user service
+router.gett("/", ..., entity.get);
+router.post("/", entity.normalize, entity.validate, ..., entity.add);
+router.put("/", entity.normalize, entity.validate, ..., entity.update);
+router.put("/", ..., entity.archive);
+
+```
+
+## API Reference
+
+
+```javascript
+
+type Operation = "select" | "insert" | "update" | "merge" | "delete";
+
+type MatchMode =  
+  "startsWith" | 
+  "endsWith" |
+  "contains" |
+  "notContains" |
+  "equals" |
+  "notEquals" |
+  "between" |
+  "in" |
+  "lt" |
+  "lte" |
+  "gt" |
+  "gte" |
+  "is" |
+  "isNot" |
+  "before" |
+  "after" |
+  "st_contains" |
+  "st_dwithin";
+
+
+type Filter = {
+  value: string | number | boolean | Date | number[];
+  subProps?: string[];
+  matchMode?: MatchMode;
+}
+
+class SQLEntity {
+  constructor(name: string, properties: Property[]);
+  get name(): string;
+  get table(): string;
+  get unsafeProps(): string[];
+  get properties(): Property[];
+  set name(name: string);
+  set table(table: string);
+
+  query: {
+    select: (paginate: boolean) => string;
+    update: (chunk: Record<string, unknown>[], consumerId: number | string, consumerName: string) => {
+        query: string;
+        args: unknown[];
+    };
+    insert: (chunk: 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>;
+  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): void;
+
+}
+
+filter(
+  first: number,
+  rows: number | null,
+  sortField: string | null,
+  sortOrder: Sort,
+  filters: Filters | null,
+): { filterClause: string, args: (Filter["value"])[] } {
+
+
+```
+get(), add(), update(), archive() and delete() 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.
+
+
+## Match modes
+
+List of possible match modes :  
+
+| Name        | alias | types                   | Description |
+| :---------- | :---- | :---------------------- | :-------------------------------------------------------- |
+| startsWith  |       | string                  | Whether the value starts with the filter value |
+| contains	  |       | string                  | Whether the value contains the filter value |
+| endsWith    |       | string                  | Whether the value ends with the filter value |
+| notContains |       | string                  | Whether the value does not contain filter value |
+| equals	  |       | string \| number        | Whether the value equals the filter value |
+| notEquals	  |       | string \| number        | Whether the value does not equal the filter value |
+| in	      |       | string[] \| number[]    | Whether the value contains the filter value |
+| lt	      |       | string \| number        | Whether the value is less than the filter value |
+| lte	      |       | string \| number        | Whether the value is less than or equals to the filter value |
+| gt	      |       | string \| number        | Whether the value is greater than the filter value |
+| gte	      |       | string \| number        | Whether the value is greater than or equals to the filter value |
+| is	      |       | date \| boolean \| null | Whether the value equals the filter value, alias to equals |
+| isNot	      |       | date \| boolean \| null | Whether the value does not equal the filter value, alias to notEquals |
+| before      |       | date                    | Whether the date value is before the filter date |
+| after	      |       | date                    | Whether the date value is after the filter date |
+| between     |       | date[2] \| number[2]    | Whether the value is between the filter values | 
+| st_contains |       | geometry                | Whether the geometry completely contains other geometries |
+| st_dwithin  |       | geometry                | Whether geometries are within a specified distance from another geometry |
+
+## Types
+
+List of compatible match modes for each property types
+
+| Name        | Match modes             |
+| :---------- | :---------------------- | 
+| string      | startsWith,<br>contains,<br>endsWith,<br>notContains,<br>equals,<br>notEquals,<br>lt,<br>lte,<br>gt,<br>gte |
+| number      | equals,<br>notEquals,<br>lt,<br>lte,<br>gt,<br>gte |
+| date        | is,<br>isNot,<br>before,<br>after |
+| boolean     | is,<br>isNot            |
+| string[]    | in                      |
+| number[]    | in,<br>between          |
+| date[]      | between                 |
+| geometry    | st_contains,<br>st_dwithin |
+
+List of secondary types : 
+
+| Name               | equivalent |
+| :----------------- | :--------- | 
+| integer            | number     |
+| float              | number     |
+| even               | number     |
+| odd                | number     |
+| positive           | number     |
+| negative           | number     |
+| powerOfTwo         | number     |
+| ascii              | number     |
+| array              | any[]      |
+| jwt                | string     |
+| symbol             | string     |
+| email              | string     |
+| regex              | string     |
+| ipAddress          | string     |
+| slug               | string     |
+| hexadecimal        | string     |
+| date               | date       |
+| timestamp          | date       |
+| function           | string     |
+| htmlElement        | string     |
+| htmlEventAttribute | string     |
+| node               | string     |
+| json               | object     |
+| object             | object     |
+
+## Contributors
+
+Antity.js is still in development and we would be glad to get all the help you can provide.
+To contribute please read **[contributor.md](https://github.com/DWTechs/Antity.js/blob/main/contributor.md)** for detailed installation guide.
+
+
+## Stack
+
+| Purpose         |                    Choice                    |                                                     Motivation |
+| :-------------- | :------------------------------------------: | -------------------------------------------------------------: |
+| repository      |        [Github](https://github.com/)         |     hosting for software development version control using Git |
+| package manager |     [npm](https://www.npmjs.com/get-npm)     |                                default node.js package manager |
+| language        | [TypeScript](https://www.typescriptlang.org) | static type checking along with the latest ECMAScript features |
+| module bundler  |      [Rollup](https://rollupjs.org)          |                        advanced module bundler for ES6 modules |
+| unit testing    |          [Jest](https://jestjs.io/)          |                  delightful testing with a focus on simplicity |

package/dist/antity-pgsql.d.ts

@@ -0,0 +1,117 @@
+/*
+MIT License
+
+Copyright (c) 2025 DWTechs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+https://github.com/DWTechs/Antity-pgsql.js
+*/
+
+import { Entity, Property } from "@dwtechs/antity";
+import type { Request, NextFunction } from 'express';
+
+export type Operation = "SELECT" | "INSERT" | "UPDATE" | "DELETE";
+export type Sort = "ASC" | "DESC";
+export type Filters = {
+    [key: string]: Filter;
+};
+export type Filter = {
+    value: string | number | boolean | Date | number[];
+    subProps?: string[];
+    matchMode?: MatchMode;
+};
+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 MappedType = "string" | "number" | "date";
+export type Type = "boolean" | "string" | "number" | "integer" | "float" | "even" | "odd" | "positive" | "negative" | "powerOfTwo" | "ascii" | "array" | "jwt" | "symbol" | "email" | "regex" | "json" | "ipAddress" | "slug" | "hexadecimal" | "date" | "timestamp" | "function" | "htmlElement" | "htmlEventAttribute" | "node" | "object" | "geometry";
+export type Geometry = {
+    lng: number;
+    lat: number;
+    radius: number;
+    bounds: {
+        minLng: number;
+        minLat: number;
+        maxLng: number;
+        maxLat: number;
+    };
+};
+export type PGResponse = {
+    rows: Record<string, unknown>[];
+    rowCount: number;
+    total?: number;
+    command?: string;
+    oid?: number;
+    fields?: unknown[];
+    _parsers?: unknown[];
+    _types?: unknown;
+    RowCtor?: unknown;
+    rowAsArray?: boolean;
+};
+export type Response = {
+    rows: Record<string, unknown>[];
+    total?: number;
+};
+
+declare class SQLEntity extends Entity {
+    private _table;
+    private sel;
+    private ins;
+    private upd;
+    constructor(name: string, properties: Property[]);
+    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[];
+        };
+        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>;
+    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): void;
+    private cleanFilters;
+    private mapProps;
+}
+
+declare filter(
+    first: number,
+    rows: number | null,
+    sortField: string | null,
+    sortOrder: Sort,
+    filters: Filters | null,
+  ): { filterClause: string, args: (Filter["value"])[] } {]
+  
+
+export { 
+  SQLEntity,
+  Property,
+  filter,
+};
+

package/dist/antity-pgsql.js

@@ -0,0 +1,588 @@
+/*
+MIT License
+
+Copyright (c) 2025 DWTechs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+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 { 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 "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,
+    user: DB_USER,
+    password: DB_PWD,
+    database: DB_NAME,
+    port: +(DB_PORT || 5432),
+    max: DB_MAX ? +DB_MAX : 10,
+});
+
+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}' }`);
+    return Date.now();
+}
+function end(res, time) {
+    const r = JSON.stringify(res);
+    const t = Date.now() - time;
+    log.debug(`Pgsql response in ${t}ms : ${r}`);
+}
+var perf = {
+    start,
+    end,
+};
+
+function execute$1(query, args, clt) {
+    const time = perf.start(query, args);
+    const client = clt || pool;
+    return client
+        .query(query, args)
+        .then((res) => {
+        perf.end(res, time);
+        deleteIdleProperties(res);
+        return res;
+    })
+        .catch((err) => {
+        err.msg = `Postgre error: ${err.message}`;
+        throw err;
+    });
+}
+function deleteIdleProperties(res) {
+    res.command = undefined;
+    res.oid = undefined;
+    res.fields = undefined;
+    res._parsers = undefined;
+    res._types = undefined;
+    res.RowCtor = undefined;
+    res.rowAsArray = undefined;
+}
+
+class Select {
+    constructor() {
+        this._props = [];
+        this._cols = "";
+        this._count = ", COUNT(*) OVER () AS total";
+    }
+    addProp(prop) {
+        this._props.push(prop);
+        this._cols = this._props.join(", ");
+    }
+    get props() {
+        return this._cols;
+    }
+    query(table, paginate) {
+        const p = paginate ? this._count : '';
+        const c = this._cols ? this._cols : '*';
+        return `SELECT ${c}${p} FROM "${table}"`;
+    }
+    execute(query, args, client) {
+        return execute$1(query, args, client)
+            .then((r) => {
+            if (!r.rowCount)
+                throw { status: 404, msg: "Resource not found" };
+            const f = r.rows[0];
+            if (f.total) {
+                r.total = Number(f.total);
+                r.rows = deleteProps(r.rows, ["total"]);
+            }
+            return r;
+        });
+    }
+}
+
+function $i(qty, start) {
+    return `(${Array.from({ length: qty }, (_, i) => `$${start + i + 1}`).join(", ")})`;
+}
+
+class Insert {
+    constructor() {
+        this._props = ["consumerId", "consumerName"];
+        this._cols = "*";
+        this._nbProps = 2;
+    }
+    addProp(prop) {
+        this._props = add$1(this._props, prop, this._props.length - 2);
+        this._cols = this._props.join(", ");
+        this._nbProps++;
+    }
+    query(table, rows, consumerId, consumerName, rtn = "") {
+        let query = `INSERT INTO "${table}" (${this._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) {
+                args.push(row[prop]);
+            }
+            i += this._nbProps;
+        }
+        query = query.slice(0, -2);
+        if (rtn)
+            query += ` ${rtn}`;
+        return { query, args };
+    }
+    rtn(prop) {
+        return `RETURNING "${prop}"`;
+    }
+    execute(query, args, client) {
+        return execute$1(query, args, client);
+    }
+}
+
+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 Update {
+    constructor() {
+        this._props = ["consumerId", "consumerName"];
+    }
+    addProp(prop) {
+        this._props = add$1(this._props, prop, this._props.length - 2);
+    }
+    query(table, rows, consumerId, consumerName) {
+        rows = this.addConsumer(rows, consumerId, consumerName);
+        const l = rows.length;
+        const args = rows.map(row => row.id);
+        let query = `UPDATE "${table}" SET `;
+        let i = args.length + 1;
+        for (const p of this._props) {
+            if (rows[0][p] === undefined)
+                continue;
+            query += `${p} = CASE `;
+            for (let j = 0; j < l; j++) {
+                const row = rows[j];
+                query += `WHEN id = $${j + 1} THEN $${i++} `;
+                args.push(row[p]);
+            }
+            query += `END, `;
+        }
+        query = `${query.slice(0, -2)} WHERE id IN ${$i(l, 0)}`;
+        return { query, args };
+    }
+    execute(query, args, client) {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            return execute$1(query, args, client);
+        });
+    }
+    addConsumer(rows, consumerId, consumerName) {
+        return rows.map((row) => (Object.assign(Object.assign({}, row), { consumerId,
+            consumerName })));
+    }
+}
+
+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 query(table) {
+    return `DELETE FROM "${table}" WHERE "archivedAt" < $1`;
+}
+function execute(date, query, client) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        let db;
+        try {
+            db = yield execute$1(query, [date], client);
+        }
+        catch (err) {
+            throw err;
+        }
+        return db;
+    });
+}
+
+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 = `\"${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 "";
+    return ` ORDER BY "${sortField}" ${sortOrder}`;
+}
+function limit(rows, first) {
+    return rows ? ` LIMIT ${rows} OFFSET ${first}` : "";
+}
+
+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 {
+    constructor(name, properties) {
+        super(name, properties);
+        this.sel = new Select();
+        this.ins = new Insert();
+        this.upd = new Update();
+        this.query = {
+            select: (paginate) => {
+                return this.sel.query(this.table, paginate);
+            },
+            update: (rows, consumerId, consumerName) => {
+                return this.upd.query(this.table, rows, consumerId, consumerName);
+            },
+            insert: (rows, consumerId, consumerName, rtn = "") => {
+                return this.ins.query(this.table, rows, consumerId, consumerName, rtn);
+            },
+            delete: () => {
+                return query(this.table);
+            },
+            return: (prop) => {
+                return this.ins.rtn(prop);
+            }
+        };
+        this._table = name;
+        for (const p of properties) {
+            this.mapProps(p.methods, p.key);
+        }
+    }
+    get table() {
+        return this._table;
+    }
+    set table(table) {
+        if (!isString(table, "!0"))
+            throw new Error('table must be a string of length > 0');
+        this._table = table;
+    }
+    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 = this.cleanFilters(b.filters) || 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)
+            .then((r) => {
+            l.rows = r.rows;
+            l.total = r.total;
+            next();
+        })
+            .catch((err) => next(err));
+    }
+    add(req, res, next) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const l = res.locals;
+            const rows = req.body.rows;
+            const dbClient = l.dbClient || null;
+            const cId = l.consumerId;
+            const cName = l.consumerName;
+            log.debug(`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._table, c, cId, cName, rtn);
+                let db;
+                try {
+                    db = yield execute$1(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(req, res, next) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const l = res.locals;
+            const rows = req.body.rows;
+            const dbClient = l.dbClient || null;
+            const cId = l.consumerId;
+            const cName = l.consumerName;
+            log.debug(`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);
+                try {
+                    yield execute$1(query, args, dbClient);
+                }
+                catch (err) {
+                    return next(err);
+                }
+            }
+            next();
+        });
+    }
+    archive(req, res, next) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const l = res.locals;
+            let rows = req.body.rows;
+            const dbClient = l.dbClient || null;
+            const cId = l.consumerId;
+            const cName = l.consumerName;
+            log.debug(`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) {
+                const { query, args } = this.upd.query(this._table, c, cId, cName);
+                try {
+                    yield execute$1(query, args, dbClient);
+                }
+                catch (err) {
+                    return next(err);
+                }
+            }
+            next();
+        });
+    }
+    delete(req, res, next) {
+        const date = req.body.date;
+        const dbClient = res.locals.dbClient || null;
+        log.debug(`delete archived`);
+        const q = query(this._table);
+        execute(date, q, dbClient)
+            .then(() => next())
+            .catch((err) => next(err));
+    }
+    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":
+                    this.sel.addProp(key);
+                    break;
+                case "PATCH":
+                    this.upd.addProp(key);
+                    break;
+                case "PUT":
+                    this.upd.addProp(key);
+                    break;
+                case "POST":
+                    this.ins.addProp(key);
+                    break;
+            }
+        }
+    }
+}
+
+export { SQLEntity, filter };

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@dwtechs/antity-pgsql",
+  "version": "0.1.0",
+  "description": "Open source library for easy entity management",
+  "keywords": [
+    "entities"
+  ],
+  "homepage": "https://github.com/DWTechs/Antity.js",
+  "main": "dist/antity",
+  "types": "dist/antity",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DWTechs/Antity.js"
+  },
+  "bugs": {
+    "url": "https://github.com/DWTechs/Antity.js/issues",
+    "email": ""
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Ludovic Cluber",
+    "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",
+    "test": "jest --coverage"
+  },
+  "files": [
+    "dist/"
+  ],
+  "dependencies": {
+    "@dwtechs/checkard": "3.2.3",
+    "@dwtechs/winstan": "0.4.0",
+    "@dwtechs/antity": "0.9.0",
+    "@dwtechs/sparray": "0.2.0",
+    "pg": "8.13.1"
+  },
+  "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",
+    "babel-jest": "29.7.0",
+    "core-js": "3.33.0",
+    "jest": "29.7.0",
+    "rollup": "4.24.0",
+    "typescript": "5.6.3"
+  }
+}