sedentary-pg 0.1.0 → 0.1.2

package/dist/cjs/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SedentaryPG = exports.Type = exports.EntryBase = exports.TransactionPG = void 0;
+const sedentary_1 = require("sedentary");
+const pgdb_1 = require("./pgdb");
+var pgdb_2 = require("./pgdb");
+Object.defineProperty(exports, "TransactionPG", { enumerable: true, get: function () { return pgdb_2.TransactionPG; } });
+var sedentary_2 = require("sedentary");
+Object.defineProperty(exports, "EntryBase", { enumerable: true, get: function () { return sedentary_2.EntryBase; } });
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return sedentary_2.Type; } });
+class SedentaryPG extends sedentary_1.Sedentary {
+    constructor(connection, options) {
+        super(options);
+        if (!(connection instanceof Object))
+            throw new Error("SedentaryPG.constructor: 'connection' argument: Wrong type, expected 'Object'");
+        this.db = new pgdb_1.PGDB(connection, this.log);
+    }
+    begin() {
+        return this.db.begin();
+    }
+    client() {
+        return this.db.client();
+    }
+}
+exports.SedentaryPG = SedentaryPG;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/pgdb.js

@@ -0,0 +1,553 @@
+"use strict";
+// cSpell:ignore adbin adnum adrelid adsrc amname attinhcount attisdropped attislocal attname attnotnull attnum attrdef attrelid atttypid atttypmod confdeltype confdeltype
+// cSpell:ignore confupdtype conindid conkey conname conrelid contype currval indexrelid indisunique indrelid inhparent inhrelid relam relname timestamptz typname
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionPG = exports.PGDB = void 0;
+const pg_1 = require("pg");
+const pg_format_1 = __importDefault(require("pg-format"));
+const sedentary_1 = require("sedentary");
+const needDrop = [
+    ["DATETIME", "float4"],
+    ["DATETIME", "float8"],
+    ["DATETIME", "int2"],
+    ["DATETIME", "int4"],
+    ["DATETIME", "int8"],
+    ["DATETIME", "numeric"],
+    ["FLOAT", "json"],
+    ["FLOAT", "timestamptz"],
+    ["INT", "json"],
+    ["INT", "timestamptz"],
+    ["INT8", "json"],
+    ["INT8", "timestamptz"],
+    ["JSON", "int2"],
+    ["JSON", "int4"],
+    ["JSON", "int8"],
+    ["JSON", "numeric"],
+    ["NUMBER", "json"],
+    ["NUMBER", "timestamptz"]
+];
+const needUsing = [
+    ["BOOLEAN", "varchar"],
+    ["DATETIME", "varchar"],
+    ["INT", "varchar"],
+    ["INT8", "varchar"],
+    ["JSON", "varchar"],
+    ["NUMBER", "varchar"]
+];
+const types = { bool: "BOOL", float4: "FLOAT4", float8: "FLOAT8", int2: "SMALLINT", int4: "INTEGER", int8: "BIGINT", json: "JSON", numeric: "NUMERIC", timestamptz: "DATETIME", varchar: "VARCHAR" };
+const actions = { cascade: "c", "no action": "a", restrict: "r", "set default": "d", "set null": "n" };
+function parseInt8(value) {
+    return BigInt(value);
+}
+function parseNumber(value) {
+    return parseFloat(value);
+}
+pg_1.types.setTypeParser(20, parseInt8);
+pg_1.types.setTypeParser(1700, parseNumber);
+class PGDB extends sedentary_1.DB {
+    constructor(connection, log) {
+        super(log);
+        this._client = {};
+        this.indexes = [];
+        this.oidLoad = {};
+        this.released = false;
+        this.version = 0;
+        this.pool = new pg_1.Pool(connection);
+    }
+    async connect() {
+        this._client = await this.pool.connect();
+        const res = await this._client.query("SELECT version()");
+        this.version = parseInt(res.rows[0].version.split(" ")[1].split(".")[0], 10);
+    }
+    async end() {
+        if (!this.released)
+            this._client.release();
+        await this.pool.end();
+    }
+    defaultNeq(src, value) {
+        if (src === value)
+            return false;
+        return src.split("::")[0] !== value;
+    }
+    async begin() {
+        const ret = new TransactionPG(this.log, await this.pool.connect());
+        this.log("BEGIN");
+        await ret._client.query("BEGIN");
+        return ret;
+    }
+    cancel(tableName) {
+        return async (where, tx) => {
+            const client = tx ? tx._client : await this.pool.connect();
+            let rowCount = 0;
+            try {
+                const query = `DELETE FROM ${tableName}${where ? ` WHERE ${where}` : ""}`;
+                this.log(query);
+                ({ rowCount } = (await client.query(query)));
+            }
+            finally {
+                if (!tx)
+                    client.release();
+            }
+            return rowCount;
+        };
+    }
+    async client() {
+        return await this.pool.connect();
+    }
+    escape(value) {
+        if (value === null || value === undefined)
+            throw new Error("SedentaryPG: Can't escape null nor undefined values; use the 'IS NULL' operator instead");
+        if (typeof value === "boolean" || typeof value === "number")
+            return value.toString();
+        if (value instanceof Date)
+            return (0, pg_format_1.default)("%L", value).replace(/\.\d\d\d\+/, "+");
+        return (0, pg_format_1.default)("%L", value);
+    }
+    fill(attr2field, row, entry) {
+        const value = {};
+        for (const attribute in attr2field)
+            value[attribute] = (0, sedentary_1.deepCopy)((entry[attribute] = row[attr2field[attribute]]));
+        Object.defineProperty(entry, sedentary_1.loaded, { configurable: true, value });
+    }
+    load(tableName, attributes, pk, model, table) {
+        const pkFldName = pk.fieldName;
+        return async (where, order, limit, tx, lock) => {
+            const { oid } = table;
+            const ret = [];
+            const client = tx ? tx._client : await this.pool.connect();
+            const oidPK = {};
+            try {
+                const forUpdate = lock ? " FOR UPDATE" : "";
+                const orderBy = order?.length
+                    ? ` ORDER BY ${(typeof order === "string" ? [order] : order)
+                        .map(_ => (_.startsWith("-") ? `${table.findAttribute(_.substring(1)).fieldName} DESC` : table.findAttribute(_).fieldName))
+                        .join(",")}`
+                    : "";
+                const limitTo = typeof limit === "number" ? ` LIMIT ${limit}` : "";
+                const query = `SELECT *, tableoid FROM ${tableName}${where ? ` WHERE ${where}` : ""}${orderBy}${limitTo}${forUpdate}`;
+                this.log(query);
+                const res = await client.query(query);
+                for (const row of res.rows) {
+                    if (row.tableoid === oid) {
+                        const entry = new model("load");
+                        this.fill(attributes, row, entry);
+                        if (tx)
+                            tx.addEntry(entry);
+                        ret.push(entry);
+                        entry.postLoad();
+                    }
+                    else {
+                        if (!oidPK[row.tableoid])
+                            oidPK[row.tableoid] = [];
+                        oidPK[row.tableoid].push([ret.length, row[pkFldName]]);
+                        ret.push(null);
+                    }
+                }
+                for (const oid in oidPK) {
+                    const res = await this.oidLoad[oid](oidPK[oid].map(_ => _[1]));
+                    for (const entry of res)
+                        for (const [id, pk] of oidPK[oid])
+                            if (pk === entry[pkFldName])
+                                ret[id] = entry;
+                }
+            }
+            finally {
+                if (!tx)
+                    client.release();
+            }
+            return ret;
+        };
+    }
+    remove(tableName, pk) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const pkAttrName = pk.attributeName;
+        const pkFldName = pk.fieldName;
+        return async function () {
+            const client = this[sedentary_1.transaction] ? this[sedentary_1.transaction]._client : await self.pool.connect();
+            let removed;
+            try {
+                const query = `DELETE FROM ${tableName} WHERE ${pkFldName} = ${self.escape(this[pkAttrName])}`;
+                self.log(query);
+                removed = (await client.query(query)).rowCount;
+            }
+            finally {
+                if (!this[sedentary_1.transaction])
+                    client.release();
+            }
+            return removed;
+        };
+    }
+    save(tableName, attr2field, pk) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const pkAttrName = pk.attributeName;
+        const pkFldName = pk.fieldName;
+        return async function () {
+            const client = this[sedentary_1.transaction] ? this[sedentary_1.transaction]._client : await self.pool.connect();
+            let changed = false;
+            let result = null;
+            const save = async (query) => {
+                self.log(query);
+                changed = true;
+                result = await client.query(`${query} RETURNING *`);
+                self.fill(attr2field, result.rows[0], this);
+            };
+            try {
+                const loadedRecord = this[sedentary_1.loaded];
+                if (loadedRecord) {
+                    const actions = [];
+                    for (const attribute in attr2field) {
+                        const value = this[attribute];
+                        if ((0, sedentary_1.deepDiff)(value, loadedRecord[attribute]))
+                            actions.push(`${attr2field[attribute]} = ${self.escape(value)}`);
+                    }
+                    if (actions.length)
+                        await save(`UPDATE ${tableName} SET ${actions.join(", ")} WHERE ${pkFldName} = ${self.escape(this[pkAttrName])}`);
+                }
+                else {
+                    const fields = [];
+                    const values = [];
+                    for (const attribute in attr2field) {
+                        const value = this[attribute];
+                        if (value !== null && value !== undefined) {
+                            fields.push(attr2field[attribute]);
+                            values.push(self.escape(value));
+                        }
+                    }
+                    await save(fields.length ? `INSERT INTO ${tableName} (${fields.join(", ")}) VALUES (${values.join(", ")})` : `INSERT INTO ${tableName} DEFAULT VALUES`);
+                }
+            }
+            finally {
+                if (!this[sedentary_1.transaction])
+                    client.release();
+            }
+            return changed && result.rowCount;
+        };
+    }
+    async dropConstraints(table) {
+        const indexes = [];
+        const res = await this._client.query("SELECT confdeltype, confupdtype, conindid, conname, contype FROM pg_constraint WHERE conrelid = $1 ORDER BY conname", [table.oid]);
+        for (const row of res.rows) {
+            const arr = table.constraints.filter(_ => _.constraintName === row.conname && _.type === row.contype);
+            let drop = false;
+            if (arr.length === 0)
+                drop = true;
+            else if (row.contype === "u")
+                indexes.push(row.conindid);
+            else {
+                const { options } = arr[0].attribute.foreignKey;
+                if (actions[options.onDelete] !== row.confdeltype || actions[options.onUpdate] !== row.confupdtype)
+                    drop = true;
+            }
+            if (drop) {
+                const statement = `ALTER TABLE ${table.tableName} DROP CONSTRAINT ${row.conname} CASCADE`;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            }
+        }
+        return indexes;
+    }
+    async dropField(tableName, fieldName) {
+        const statement = `ALTER TABLE ${tableName} DROP COLUMN ${fieldName}`;
+        this.syncLog(statement);
+        if (this.sync)
+            await this._client.query(statement);
+    }
+    async dropFields(table) {
+        const res = await this._client.query("SELECT attname FROM pg_attribute WHERE attrelid = $1 AND attnum > 0 AND attisdropped = false AND attinhcount = 0", [table.oid]);
+        for (const row of res.rows) {
+            const field = table.findField(row.attname);
+            if (!field?.[sedentary_1.base])
+                await this.dropField(table.tableName, row.attname);
+        }
+    }
+    async dropIndexes(table, constraintIndexes) {
+        const { indexes, oid } = table;
+        const iObject = {};
+        const res = await this._client.query("SELECT amname, attname, indexrelid, indisunique, relname FROM pg_class, pg_index, pg_attribute, pg_am WHERE indrelid = $1 AND indexrelid = pg_class.oid AND attrelid = pg_class.oid AND relam = pg_am.oid ORDER BY attnum", [oid]);
+        for (const row of res.rows) {
+            const { amname, attname, indexrelid, indisunique, relname } = row;
+            if (!constraintIndexes.includes(indexrelid)) {
+                if (iObject[relname])
+                    iObject[relname].fields.push(attname);
+                else
+                    iObject[relname] = { fields: [attname], indexName: relname, type: amname, unique: indisunique };
+            }
+        }
+        this.indexes = [];
+        for (const index of indexes) {
+            const { indexName } = index;
+            if (iObject[indexName] && this.indexesEq(index, iObject[indexName])) {
+                this.indexes.push(indexName);
+                delete iObject[indexName];
+            }
+        }
+        for (const index of Object.keys(iObject).sort()) {
+            const statement = `DROP INDEX ${index}`;
+            this.syncLog(statement);
+            if (this.sync)
+                await this._client.query(statement);
+        }
+    }
+    async syncConstraints(table) {
+        for (const constraint of table.constraints) {
+            const { attribute, constraintName, type } = constraint;
+            const res = await this._client.query("SELECT attname FROM pg_attribute, pg_constraint WHERE attrelid = $1 AND conrelid = $1 AND attnum = conkey[1] AND attname = $2", [
+                table.oid,
+                attribute.fieldName
+            ]);
+            if (!res.rowCount) {
+                let query;
+                if (type === "f") {
+                    const { fieldName, options, tableName } = attribute.foreignKey;
+                    const onDelete = options.onDelete !== "no action" ? ` ON DELETE ${options.onDelete.toUpperCase()}` : "";
+                    const onUpdate = options.onUpdate !== "no action" ? ` ON UPDATE ${options.onUpdate.toUpperCase()}` : "";
+                    query = `FOREIGN KEY (${attribute.fieldName}) REFERENCES ${tableName}(${fieldName})${onDelete}${onUpdate}`;
+                }
+                else
+                    query = `UNIQUE(${attribute.fieldName})`;
+                const statement = `ALTER TABLE ${table.tableName} ADD CONSTRAINT ${constraintName} ${query}`;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            }
+        }
+    }
+    async syncDataBase() {
+        try {
+            await super.syncDataBase();
+            for (const table of this.tables)
+                this.oidLoad[table.oid || 0] = (ids) => table.model.load({ [table.pk.attributeName]: ["IN", ids] });
+        }
+        finally {
+            this.released = true;
+            this._client.release();
+        }
+    }
+    fieldType(attribute) {
+        const { [sedentary_1.size]: _size, type } = attribute;
+        let ret;
+        switch (type) {
+            case "BOOLEAN":
+                return ["BOOL", "BOOL"];
+            case "DATETIME":
+                return ["DATETIME", "TIMESTAMP (3) WITH TIME ZONE"];
+            case "FLOAT":
+                ret = _size === 4 ? "FLOAT4" : "FLOAT8";
+                return [ret, ret];
+            case "INT":
+                ret = _size === 2 ? "SMALLINT" : "INTEGER";
+                return [ret, ret];
+            case "INT8":
+                return ["BIGINT", "BIGINT"];
+            case "JSON":
+                return ["JSON", "JSON"];
+            case "NONE":
+                return ["NONE", "NONE"];
+            case "NUMBER":
+                return ["NUMERIC", "NUMERIC"];
+            case "VARCHAR":
+                return ["VARCHAR", `VARCHAR${_size ? `(${_size})` : ""}`];
+        }
+        throw new Error(`Unknown type: '${type}', '${_size}'`);
+    }
+    async syncFields(table) {
+        const { attributes, autoIncrement, oid, tableName } = table;
+        for (const attribute of attributes) {
+            const { fieldName, notNull, [sedentary_1.size]: _size } = attribute;
+            const defaultValue = attribute.defaultValue === undefined ? (autoIncrement && fieldName === "id" ? `nextval('${tableName}_id_seq'::regclass)` : undefined) : this.escape(attribute.defaultValue);
+            const [base, type] = this.fieldType(attribute);
+            const where = "attrelid = $1 AND attnum > 0 AND atttypid = pg_type.oid AND attislocal = 't' AND attname = $2";
+            const res = await this._client.query(
+            // eslint-disable-next-line max-len
+            `SELECT attnotnull, atttypmod, typname, pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc FROM pg_type, pg_attribute LEFT JOIN pg_attrdef ON adrelid = attrelid AND adnum = attnum WHERE ${where}`, [oid, fieldName]);
+            const addField = async () => {
+                const statement = `ALTER TABLE ${tableName} ADD COLUMN ${fieldName} ${type}`;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            };
+            const dropDefault = async () => {
+                const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} DROP DEFAULT`;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            };
+            const setNotNull = async (isNotNull) => {
+                if (isNotNull === notNull)
+                    return;
+                const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} ${notNull ? "SET" : "DROP"} NOT NULL`;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            };
+            const setDefault = async (isNotNull) => {
+                if (defaultValue !== undefined) {
+                    let statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} SET DEFAULT ${defaultValue}`;
+                    this.syncLog(statement);
+                    if (this.sync)
+                        await this._client.query(statement);
+                    if (notNull && !isNotNull) {
+                        statement = `UPDATE ${tableName} SET ${fieldName} = ${defaultValue} WHERE ${fieldName} IS NULL`;
+                        this.syncLog(statement);
+                        if (this.sync)
+                            await this._client.query(statement);
+                    }
+                }
+                await setNotNull(isNotNull);
+            };
+            if (!res.rowCount) {
+                if (type !== "NONE") {
+                    await addField();
+                    await setDefault(false);
+                }
+            }
+            else {
+                const { adsrc, attnotnull, atttypmod, typname } = res.rows[0];
+                if (types[typname] !== base || (base === "VARCHAR" && (_size ? _size + 4 !== atttypmod : atttypmod !== -1))) {
+                    if (needDrop.some(([type, name]) => attribute.type === type && typname === name)) {
+                        await this.dropField(tableName, fieldName);
+                        await addField();
+                        await setDefault(false);
+                    }
+                    else {
+                        if (adsrc)
+                            await dropDefault();
+                        const using = needUsing.some(([type, name]) => attribute.type === type && typname === name) ? ` USING ${fieldName}::${type}` : "";
+                        const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} TYPE ${type}${using}`;
+                        this.syncLog(statement);
+                        if (this.sync)
+                            await this._client.query(statement);
+                        await setDefault(attnotnull);
+                    }
+                }
+                else if (defaultValue === undefined) {
+                    if (adsrc)
+                        await dropDefault();
+                    await setNotNull(attnotnull);
+                }
+                else if (!adsrc || this.defaultNeq(adsrc, defaultValue))
+                    await setDefault(attnotnull);
+            }
+        }
+    }
+    async syncIndexes(table) {
+        const { indexes, tableName } = table;
+        for (const index of indexes) {
+            const { fields, indexName, type, unique } = index;
+            if (!this.indexes.includes(indexName)) {
+                const statement = `CREATE${unique ? " UNIQUE" : ""} INDEX ${indexName} ON ${tableName} USING ${type} (${fields.join(", ")})`;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            }
+        }
+    }
+    async syncSequence(table) {
+        if (!table.autoIncrementOwn)
+            return;
+        const statement = `ALTER SEQUENCE ${table.tableName}_id_seq OWNED BY ${table.tableName}.id`;
+        this.syncLog(statement);
+        if (this.sync)
+            await this._client.query(statement);
+    }
+    async syncTable(table) {
+        if (table.autoIncrement) {
+            await (async () => {
+                try {
+                    await this._client.query(`SELECT currval('${table.tableName}_id_seq')`);
+                }
+                catch (error) {
+                    if (error instanceof pg_1.DatabaseError && error.code === "55000")
+                        return;
+                    if (error instanceof pg_1.DatabaseError && error.code === "42P01") {
+                        const statement = `CREATE SEQUENCE ${table.tableName}_id_seq`;
+                        this.syncLog(statement);
+                        if (this.sync)
+                            await this._client.query(statement);
+                        table.autoIncrementOwn = true;
+                        return;
+                    }
+                    throw error;
+                }
+            })();
+        }
+        let create = false;
+        const resTable = await this._client.query("SELECT oid FROM pg_class WHERE relname = $1", [table.tableName]);
+        if (resTable.rowCount) {
+            table.oid = resTable.rows[0].oid;
+            let drop = false;
+            const resParent = await this._client.query("SELECT inhparent FROM pg_inherits WHERE inhrelid = $1", [table.oid]);
+            if (resParent.rowCount) {
+                if (!table.parent)
+                    drop = true;
+                else if (this.findTable(table.parent.tableName).oid === resParent.rows[0].inhparent)
+                    return;
+                drop = true;
+            }
+            else if (table.parent)
+                drop = true;
+            if (drop) {
+                const statement = `DROP TABLE ${table.tableName} CASCADE`;
+                create = true;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            }
+        }
+        else
+            create = true;
+        if (create) {
+            const parent = table.parent ? ` INHERITS (${table.parent.tableName})` : "";
+            const statement = `CREATE TABLE ${table.tableName} ()${parent}`;
+            this.syncLog(statement);
+            if (this.sync)
+                await this._client.query(statement);
+            const resTable = await this._client.query("SELECT oid FROM pg_class WHERE relname = $1", [table.tableName]);
+            table.oid = resTable.rows[0]?.oid;
+        }
+    }
+}
+exports.PGDB = PGDB;
+class TransactionPG extends sedentary_1.Transaction {
+    constructor(log, client) {
+        super(log);
+        this.released = false;
+        this._client = client;
+    }
+    client() {
+        return Promise.resolve(this._client);
+    }
+    release() {
+        this.released = true;
+        this._client.release();
+    }
+    async commit() {
+        if (!this.released) {
+            this.preCommit();
+            this.log("COMMIT");
+            await this._client.query("COMMIT");
+            this.release();
+            await super.commit();
+        }
+    }
+    async rollback() {
+        try {
+            if (!this.released) {
+                await super.rollback();
+                this.log("ROLLBACK");
+                await this._client.query("ROLLBACK");
+            }
+        }
+        finally {
+            if (!this.released)
+                this.release();
+        }
+    }
+}
+exports.TransactionPG = TransactionPG;

package/dist/es/index.js

@@ -0,0 +1,18 @@
+import { Sedentary } from "sedentary";
+import { PGDB } from "./pgdb";
+export { TransactionPG } from "./pgdb";
+export { EntryBase, Type } from "sedentary";
+export class SedentaryPG extends Sedentary {
+    constructor(connection, options) {
+        super(options);
+        if (!(connection instanceof Object))
+            throw new Error("SedentaryPG.constructor: 'connection' argument: Wrong type, expected 'Object'");
+        this.db = new PGDB(connection, this.log);
+    }
+    begin() {
+        return this.db.begin();
+    }
+    client() {
+        return this.db.client();
+    }
+}

package/dist/es/pgdb.js

@@ -0,0 +1,547 @@
+// cSpell:ignore adbin adnum adrelid adsrc amname attinhcount attisdropped attislocal attname attnotnull attnum attrdef attrelid atttypid atttypmod confdeltype confdeltype
+// cSpell:ignore confupdtype conindid conkey conname conrelid contype currval indexrelid indisunique indrelid inhparent inhrelid relam relname timestamptz typname
+import { DatabaseError, Pool, types as PGtypes } from "pg";
+import format from "pg-format";
+import { base, DB, deepCopy, deepDiff, loaded, size, Transaction, transaction } from "sedentary";
+const needDrop = [
+    ["DATETIME", "float4"],
+    ["DATETIME", "float8"],
+    ["DATETIME", "int2"],
+    ["DATETIME", "int4"],
+    ["DATETIME", "int8"],
+    ["DATETIME", "numeric"],
+    ["FLOAT", "json"],
+    ["FLOAT", "timestamptz"],
+    ["INT", "json"],
+    ["INT", "timestamptz"],
+    ["INT8", "json"],
+    ["INT8", "timestamptz"],
+    ["JSON", "int2"],
+    ["JSON", "int4"],
+    ["JSON", "int8"],
+    ["JSON", "numeric"],
+    ["NUMBER", "json"],
+    ["NUMBER", "timestamptz"]
+];
+const needUsing = [
+    ["BOOLEAN", "varchar"],
+    ["DATETIME", "varchar"],
+    ["INT", "varchar"],
+    ["INT8", "varchar"],
+    ["JSON", "varchar"],
+    ["NUMBER", "varchar"]
+];
+const types = { bool: "BOOL", float4: "FLOAT4", float8: "FLOAT8", int2: "SMALLINT", int4: "INTEGER", int8: "BIGINT", json: "JSON", numeric: "NUMERIC", timestamptz: "DATETIME", varchar: "VARCHAR" };
+const actions = { cascade: "c", "no action": "a", restrict: "r", "set default": "d", "set null": "n" };
+function parseInt8(value) {
+    return BigInt(value);
+}
+function parseNumber(value) {
+    return parseFloat(value);
+}
+PGtypes.setTypeParser(20, parseInt8);
+PGtypes.setTypeParser(1700, parseNumber);
+export class PGDB extends DB {
+    _client = {};
+    indexes = [];
+    oidLoad = {};
+    pool;
+    released = false;
+    version = 0;
+    constructor(connection, log) {
+        super(log);
+        this.pool = new Pool(connection);
+    }
+    async connect() {
+        this._client = await this.pool.connect();
+        const res = await this._client.query("SELECT version()");
+        this.version = parseInt(res.rows[0].version.split(" ")[1].split(".")[0], 10);
+    }
+    async end() {
+        if (!this.released)
+            this._client.release();
+        await this.pool.end();
+    }
+    defaultNeq(src, value) {
+        if (src === value)
+            return false;
+        return src.split("::")[0] !== value;
+    }
+    async begin() {
+        const ret = new TransactionPG(this.log, await this.pool.connect());
+        this.log("BEGIN");
+        await ret._client.query("BEGIN");
+        return ret;
+    }
+    cancel(tableName) {
+        return async (where, tx) => {
+            const client = tx ? tx._client : await this.pool.connect();
+            let rowCount = 0;
+            try {
+                const query = `DELETE FROM ${tableName}${where ? ` WHERE ${where}` : ""}`;
+                this.log(query);
+                ({ rowCount } = (await client.query(query)));
+            }
+            finally {
+                if (!tx)
+                    client.release();
+            }
+            return rowCount;
+        };
+    }
+    async client() {
+        return await this.pool.connect();
+    }
+    escape(value) {
+        if (value === null || value === undefined)
+            throw new Error("SedentaryPG: Can't escape null nor undefined values; use the 'IS NULL' operator instead");
+        if (typeof value === "boolean" || typeof value === "number")
+            return value.toString();
+        if (value instanceof Date)
+            return format("%L", value).replace(/\.\d\d\d\+/, "+");
+        return format("%L", value);
+    }
+    fill(attr2field, row, entry) {
+        const value = {};
+        for (const attribute in attr2field)
+            value[attribute] = deepCopy((entry[attribute] = row[attr2field[attribute]]));
+        Object.defineProperty(entry, loaded, { configurable: true, value });
+    }
+    load(tableName, attributes, pk, model, table) {
+        const pkFldName = pk.fieldName;
+        return async (where, order, limit, tx, lock) => {
+            const { oid } = table;
+            const ret = [];
+            const client = tx ? tx._client : await this.pool.connect();
+            const oidPK = {};
+            try {
+                const forUpdate = lock ? " FOR UPDATE" : "";
+                const orderBy = order?.length
+                    ? ` ORDER BY ${(typeof order === "string" ? [order] : order)
+                        .map(_ => (_.startsWith("-") ? `${table.findAttribute(_.substring(1)).fieldName} DESC` : table.findAttribute(_).fieldName))
+                        .join(",")}`
+                    : "";
+                const limitTo = typeof limit === "number" ? ` LIMIT ${limit}` : "";
+                const query = `SELECT *, tableoid FROM ${tableName}${where ? ` WHERE ${where}` : ""}${orderBy}${limitTo}${forUpdate}`;
+                this.log(query);
+                const res = await client.query(query);
+                for (const row of res.rows) {
+                    if (row.tableoid === oid) {
+                        const entry = new model("load");
+                        this.fill(attributes, row, entry);
+                        if (tx)
+                            tx.addEntry(entry);
+                        ret.push(entry);
+                        entry.postLoad();
+                    }
+                    else {
+                        if (!oidPK[row.tableoid])
+                            oidPK[row.tableoid] = [];
+                        oidPK[row.tableoid].push([ret.length, row[pkFldName]]);
+                        ret.push(null);
+                    }
+                }
+                for (const oid in oidPK) {
+                    const res = await this.oidLoad[oid](oidPK[oid].map(_ => _[1]));
+                    for (const entry of res)
+                        for (const [id, pk] of oidPK[oid])
+                            if (pk === entry[pkFldName])
+                                ret[id] = entry;
+                }
+            }
+            finally {
+                if (!tx)
+                    client.release();
+            }
+            return ret;
+        };
+    }
+    remove(tableName, pk) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const pkAttrName = pk.attributeName;
+        const pkFldName = pk.fieldName;
+        return async function () {
+            const client = this[transaction] ? this[transaction]._client : await self.pool.connect();
+            let removed;
+            try {
+                const query = `DELETE FROM ${tableName} WHERE ${pkFldName} = ${self.escape(this[pkAttrName])}`;
+                self.log(query);
+                removed = (await client.query(query)).rowCount;
+            }
+            finally {
+                if (!this[transaction])
+                    client.release();
+            }
+            return removed;
+        };
+    }
+    save(tableName, attr2field, pk) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const pkAttrName = pk.attributeName;
+        const pkFldName = pk.fieldName;
+        return async function () {
+            const client = this[transaction] ? this[transaction]._client : await self.pool.connect();
+            let changed = false;
+            let result = null;
+            const save = async (query) => {
+                self.log(query);
+                changed = true;
+                result = await client.query(`${query} RETURNING *`);
+                self.fill(attr2field, result.rows[0], this);
+            };
+            try {
+                const loadedRecord = this[loaded];
+                if (loadedRecord) {
+                    const actions = [];
+                    for (const attribute in attr2field) {
+                        const value = this[attribute];
+                        if (deepDiff(value, loadedRecord[attribute]))
+                            actions.push(`${attr2field[attribute]} = ${self.escape(value)}`);
+                    }
+                    if (actions.length)
+                        await save(`UPDATE ${tableName} SET ${actions.join(", ")} WHERE ${pkFldName} = ${self.escape(this[pkAttrName])}`);
+                }
+                else {
+                    const fields = [];
+                    const values = [];
+                    for (const attribute in attr2field) {
+                        const value = this[attribute];
+                        if (value !== null && value !== undefined) {
+                            fields.push(attr2field[attribute]);
+                            values.push(self.escape(value));
+                        }
+                    }
+                    await save(fields.length ? `INSERT INTO ${tableName} (${fields.join(", ")}) VALUES (${values.join(", ")})` : `INSERT INTO ${tableName} DEFAULT VALUES`);
+                }
+            }
+            finally {
+                if (!this[transaction])
+                    client.release();
+            }
+            return changed && result.rowCount;
+        };
+    }
+    async dropConstraints(table) {
+        const indexes = [];
+        const res = await this._client.query("SELECT confdeltype, confupdtype, conindid, conname, contype FROM pg_constraint WHERE conrelid = $1 ORDER BY conname", [table.oid]);
+        for (const row of res.rows) {
+            const arr = table.constraints.filter(_ => _.constraintName === row.conname && _.type === row.contype);
+            let drop = false;
+            if (arr.length === 0)
+                drop = true;
+            else if (row.contype === "u")
+                indexes.push(row.conindid);
+            else {
+                const { options } = arr[0].attribute.foreignKey;
+                if (actions[options.onDelete] !== row.confdeltype || actions[options.onUpdate] !== row.confupdtype)
+                    drop = true;
+            }
+            if (drop) {
+                const statement = `ALTER TABLE ${table.tableName} DROP CONSTRAINT ${row.conname} CASCADE`;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            }
+        }
+        return indexes;
+    }
+    async dropField(tableName, fieldName) {
+        const statement = `ALTER TABLE ${tableName} DROP COLUMN ${fieldName}`;
+        this.syncLog(statement);
+        if (this.sync)
+            await this._client.query(statement);
+    }
+    async dropFields(table) {
+        const res = await this._client.query("SELECT attname FROM pg_attribute WHERE attrelid = $1 AND attnum > 0 AND attisdropped = false AND attinhcount = 0", [table.oid]);
+        for (const row of res.rows) {
+            const field = table.findField(row.attname);
+            if (!field?.[base])
+                await this.dropField(table.tableName, row.attname);
+        }
+    }
+    async dropIndexes(table, constraintIndexes) {
+        const { indexes, oid } = table;
+        const iObject = {};
+        const res = await this._client.query("SELECT amname, attname, indexrelid, indisunique, relname FROM pg_class, pg_index, pg_attribute, pg_am WHERE indrelid = $1 AND indexrelid = pg_class.oid AND attrelid = pg_class.oid AND relam = pg_am.oid ORDER BY attnum", [oid]);
+        for (const row of res.rows) {
+            const { amname, attname, indexrelid, indisunique, relname } = row;
+            if (!constraintIndexes.includes(indexrelid)) {
+                if (iObject[relname])
+                    iObject[relname].fields.push(attname);
+                else
+                    iObject[relname] = { fields: [attname], indexName: relname, type: amname, unique: indisunique };
+            }
+        }
+        this.indexes = [];
+        for (const index of indexes) {
+            const { indexName } = index;
+            if (iObject[indexName] && this.indexesEq(index, iObject[indexName])) {
+                this.indexes.push(indexName);
+                delete iObject[indexName];
+            }
+        }
+        for (const index of Object.keys(iObject).sort()) {
+            const statement = `DROP INDEX ${index}`;
+            this.syncLog(statement);
+            if (this.sync)
+                await this._client.query(statement);
+        }
+    }
+    async syncConstraints(table) {
+        for (const constraint of table.constraints) {
+            const { attribute, constraintName, type } = constraint;
+            const res = await this._client.query("SELECT attname FROM pg_attribute, pg_constraint WHERE attrelid = $1 AND conrelid = $1 AND attnum = conkey[1] AND attname = $2", [
+                table.oid,
+                attribute.fieldName
+            ]);
+            if (!res.rowCount) {
+                let query;
+                if (type === "f") {
+                    const { fieldName, options, tableName } = attribute.foreignKey;
+                    const onDelete = options.onDelete !== "no action" ? ` ON DELETE ${options.onDelete.toUpperCase()}` : "";
+                    const onUpdate = options.onUpdate !== "no action" ? ` ON UPDATE ${options.onUpdate.toUpperCase()}` : "";
+                    query = `FOREIGN KEY (${attribute.fieldName}) REFERENCES ${tableName}(${fieldName})${onDelete}${onUpdate}`;
+                }
+                else
+                    query = `UNIQUE(${attribute.fieldName})`;
+                const statement = `ALTER TABLE ${table.tableName} ADD CONSTRAINT ${constraintName} ${query}`;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            }
+        }
+    }
+    async syncDataBase() {
+        try {
+            await super.syncDataBase();
+            for (const table of this.tables)
+                this.oidLoad[table.oid || 0] = (ids) => table.model.load({ [table.pk.attributeName]: ["IN", ids] });
+        }
+        finally {
+            this.released = true;
+            this._client.release();
+        }
+    }
+    fieldType(attribute) {
+        const { [size]: _size, type } = attribute;
+        let ret;
+        switch (type) {
+            case "BOOLEAN":
+                return ["BOOL", "BOOL"];
+            case "DATETIME":
+                return ["DATETIME", "TIMESTAMP (3) WITH TIME ZONE"];
+            case "FLOAT":
+                ret = _size === 4 ? "FLOAT4" : "FLOAT8";
+                return [ret, ret];
+            case "INT":
+                ret = _size === 2 ? "SMALLINT" : "INTEGER";
+                return [ret, ret];
+            case "INT8":
+                return ["BIGINT", "BIGINT"];
+            case "JSON":
+                return ["JSON", "JSON"];
+            case "NONE":
+                return ["NONE", "NONE"];
+            case "NUMBER":
+                return ["NUMERIC", "NUMERIC"];
+            case "VARCHAR":
+                return ["VARCHAR", `VARCHAR${_size ? `(${_size})` : ""}`];
+        }
+        throw new Error(`Unknown type: '${type}', '${_size}'`);
+    }
+    async syncFields(table) {
+        const { attributes, autoIncrement, oid, tableName } = table;
+        for (const attribute of attributes) {
+            const { fieldName, notNull, [size]: _size } = attribute;
+            const defaultValue = attribute.defaultValue === undefined ? (autoIncrement && fieldName === "id" ? `nextval('${tableName}_id_seq'::regclass)` : undefined) : this.escape(attribute.defaultValue);
+            const [base, type] = this.fieldType(attribute);
+            const where = "attrelid = $1 AND attnum > 0 AND atttypid = pg_type.oid AND attislocal = 't' AND attname = $2";
+            const res = await this._client.query(
+            // eslint-disable-next-line max-len
+            `SELECT attnotnull, atttypmod, typname, pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc FROM pg_type, pg_attribute LEFT JOIN pg_attrdef ON adrelid = attrelid AND adnum = attnum WHERE ${where}`, [oid, fieldName]);
+            const addField = async () => {
+                const statement = `ALTER TABLE ${tableName} ADD COLUMN ${fieldName} ${type}`;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            };
+            const dropDefault = async () => {
+                const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} DROP DEFAULT`;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            };
+            const setNotNull = async (isNotNull) => {
+                if (isNotNull === notNull)
+                    return;
+                const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} ${notNull ? "SET" : "DROP"} NOT NULL`;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            };
+            const setDefault = async (isNotNull) => {
+                if (defaultValue !== undefined) {
+                    let statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} SET DEFAULT ${defaultValue}`;
+                    this.syncLog(statement);
+                    if (this.sync)
+                        await this._client.query(statement);
+                    if (notNull && !isNotNull) {
+                        statement = `UPDATE ${tableName} SET ${fieldName} = ${defaultValue} WHERE ${fieldName} IS NULL`;
+                        this.syncLog(statement);
+                        if (this.sync)
+                            await this._client.query(statement);
+                    }
+                }
+                await setNotNull(isNotNull);
+            };
+            if (!res.rowCount) {
+                if (type !== "NONE") {
+                    await addField();
+                    await setDefault(false);
+                }
+            }
+            else {
+                const { adsrc, attnotnull, atttypmod, typname } = res.rows[0];
+                if (types[typname] !== base || (base === "VARCHAR" && (_size ? _size + 4 !== atttypmod : atttypmod !== -1))) {
+                    if (needDrop.some(([type, name]) => attribute.type === type && typname === name)) {
+                        await this.dropField(tableName, fieldName);
+                        await addField();
+                        await setDefault(false);
+                    }
+                    else {
+                        if (adsrc)
+                            await dropDefault();
+                        const using = needUsing.some(([type, name]) => attribute.type === type && typname === name) ? ` USING ${fieldName}::${type}` : "";
+                        const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} TYPE ${type}${using}`;
+                        this.syncLog(statement);
+                        if (this.sync)
+                            await this._client.query(statement);
+                        await setDefault(attnotnull);
+                    }
+                }
+                else if (defaultValue === undefined) {
+                    if (adsrc)
+                        await dropDefault();
+                    await setNotNull(attnotnull);
+                }
+                else if (!adsrc || this.defaultNeq(adsrc, defaultValue))
+                    await setDefault(attnotnull);
+            }
+        }
+    }
+    async syncIndexes(table) {
+        const { indexes, tableName } = table;
+        for (const index of indexes) {
+            const { fields, indexName, type, unique } = index;
+            if (!this.indexes.includes(indexName)) {
+                const statement = `CREATE${unique ? " UNIQUE" : ""} INDEX ${indexName} ON ${tableName} USING ${type} (${fields.join(", ")})`;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            }
+        }
+    }
+    async syncSequence(table) {
+        if (!table.autoIncrementOwn)
+            return;
+        const statement = `ALTER SEQUENCE ${table.tableName}_id_seq OWNED BY ${table.tableName}.id`;
+        this.syncLog(statement);
+        if (this.sync)
+            await this._client.query(statement);
+    }
+    async syncTable(table) {
+        if (table.autoIncrement) {
+            await (async () => {
+                try {
+                    await this._client.query(`SELECT currval('${table.tableName}_id_seq')`);
+                }
+                catch (error) {
+                    if (error instanceof DatabaseError && error.code === "55000")
+                        return;
+                    if (error instanceof DatabaseError && error.code === "42P01") {
+                        const statement = `CREATE SEQUENCE ${table.tableName}_id_seq`;
+                        this.syncLog(statement);
+                        if (this.sync)
+                            await this._client.query(statement);
+                        table.autoIncrementOwn = true;
+                        return;
+                    }
+                    throw error;
+                }
+            })();
+        }
+        let create = false;
+        const resTable = await this._client.query("SELECT oid FROM pg_class WHERE relname = $1", [table.tableName]);
+        if (resTable.rowCount) {
+            table.oid = resTable.rows[0].oid;
+            let drop = false;
+            const resParent = await this._client.query("SELECT inhparent FROM pg_inherits WHERE inhrelid = $1", [table.oid]);
+            if (resParent.rowCount) {
+                if (!table.parent)
+                    drop = true;
+                else if (this.findTable(table.parent.tableName).oid === resParent.rows[0].inhparent)
+                    return;
+                drop = true;
+            }
+            else if (table.parent)
+                drop = true;
+            if (drop) {
+                const statement = `DROP TABLE ${table.tableName} CASCADE`;
+                create = true;
+                this.syncLog(statement);
+                if (this.sync)
+                    await this._client.query(statement);
+            }
+        }
+        else
+            create = true;
+        if (create) {
+            const parent = table.parent ? ` INHERITS (${table.parent.tableName})` : "";
+            const statement = `CREATE TABLE ${table.tableName} ()${parent}`;
+            this.syncLog(statement);
+            if (this.sync)
+                await this._client.query(statement);
+            const resTable = await this._client.query("SELECT oid FROM pg_class WHERE relname = $1", [table.tableName]);
+            table.oid = resTable.rows[0]?.oid;
+        }
+    }
+}
+export class TransactionPG extends Transaction {
+    _client;
+    released = false;
+    constructor(log, client) {
+        super(log);
+        this._client = client;
+    }
+    client() {
+        return Promise.resolve(this._client);
+    }
+    release() {
+        this.released = true;
+        this._client.release();
+    }
+    async commit() {
+        if (!this.released) {
+            this.preCommit();
+            this.log("COMMIT");
+            await this._client.query("COMMIT");
+            this.release();
+            await super.commit();
+        }
+    }
+    async rollback() {
+        try {
+            if (!this.released) {
+                await super.rollback();
+                this.log("ROLLBACK");
+                await this._client.query("ROLLBACK");
+            }
+        }
+        finally {
+            if (!this.released)
+                this.release();
+        }
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+import { PoolConfig } from "pg";
+import { Sedentary, SedentaryOptions } from "sedentary";
+import { PGDB, TransactionPG } from "./pgdb";
+export { TransactionPG } from "./pgdb";
+export { Entry, EntryBase, SedentaryOptions, TxAction, Type } from "sedentary";
+export declare class SedentaryPG extends Sedentary<PGDB, TransactionPG> {
+    constructor(connection: PoolConfig, options?: SedentaryOptions);
+    begin(): Promise<TransactionPG>;
+    client(): Promise<import("pg").PoolClient>;
+}

package/dist/types/pgdb.d.ts

@@ -0,0 +1,47 @@
+import { PoolClient, PoolConfig } from "pg";
+import { Attribute, DB, EntryBase, loaded, Table, Transaction, transaction } from "sedentary";
+export declare class PGDB extends DB<TransactionPG> {
+    private _client;
+    private indexes;
+    private oidLoad;
+    private pool;
+    private released;
+    private version;
+    constructor(connection: PoolConfig, log: (message: string) => void);
+    connect(): Promise<void>;
+    end(): Promise<void>;
+    defaultNeq(src: string, value: unknown): boolean;
+    begin(): Promise<TransactionPG>;
+    cancel(tableName: string): (where: string, tx?: Transaction) => Promise<number>;
+    client(): Promise<PoolClient>;
+    escape(value: unknown): string;
+    fill(attr2field: Record<string, string>, row: Record<string, unknown>, entry: Record<string, unknown>): void;
+    load(tableName: string, attributes: Record<string, string>, pk: Attribute<unknown, boolean, unknown>, model: new (from: "load") => EntryBase, table: Table): (where: string, order?: string | string[], limit?: number, tx?: Transaction) => Promise<EntryBase[]>;
+    remove(tableName: string, pk: Attribute<unknown, boolean, unknown>): (this: Record<string, unknown> & {
+        [transaction]?: TransactionPG;
+    }) => Promise<number>;
+    save(tableName: string, attr2field: Record<string, string>, pk: Attribute<unknown, boolean, unknown>): (this: Record<string, unknown> & {
+        [loaded]?: Record<string, unknown>;
+        [transaction]?: TransactionPG;
+    }) => Promise<number | false>;
+    dropConstraints(table: Table): Promise<number[]>;
+    dropField(tableName: string, fieldName: string): Promise<void>;
+    dropFields(table: Table): Promise<void>;
+    dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
+    syncConstraints(table: Table): Promise<void>;
+    syncDataBase(): Promise<void>;
+    fieldType(attribute: Attribute<unknown, boolean, unknown>): string[];
+    syncFields(table: Table): Promise<void>;
+    syncIndexes(table: Table): Promise<void>;
+    syncSequence(table: Table): Promise<void>;
+    syncTable(table: Table): Promise<void>;
+}
+export declare class TransactionPG extends Transaction {
+    private _client;
+    private released;
+    constructor(log: (message: string) => void, client: PoolClient);
+    client(): Promise<PoolClient>;
+    private release;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}

package/package.json

@@ -9,12 +9,15 @@
     "@types/pg": "^8.16.0",
     "pg": "^8.18.0",
     "pg-format": "^1.0.4",
-    "sedentary": "0.1.0"
+    "sedentary": "0.1.2"
   },
   "description": "The ORM which never needs to migrate - PostgreSQL",
   "engines": {
     "node": ">=20.19"
   },
+  "files": [
+    "dist"
+  ],
   "funding": {
     "url": "https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB"
   },
@@ -41,5 +44,5 @@
     "preinstall": "if [ -f Makefile ] ; then make ; fi"
   },
   "types": "./dist/types/index.d.ts",
-  "version": "0.1.0"
+  "version": "0.1.2"
 }