sedentary-pg 0.0.43 → 0.0.44

package/dist/cjs/adsrc.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adsrc = void 0;
+// cspell: disable-next-line
+function adsrc(version) {
+    // cspell: disable-next-line
+    return version >= 12 ? "pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" : "adsrc";
+}
+exports.adsrc = adsrc;

package/dist/cjs/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SedentaryPG = exports.TransactionPG = exports.Type = exports.EntryBase = void 0;
+const sedentary_1 = require("sedentary");
+const pgdb_1 = require("./pgdb");
+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; } });
+var pgdb_2 = require("./pgdb");
+Object.defineProperty(exports, "TransactionPG", { enumerable: true, get: function () { return pgdb_2.TransactionPG; } });
+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);
+    }
+    FKey(attribute, options) {
+        const { attributeName, modelName, unique } = attribute;
+        if (!unique)
+            throw new Error(`SedentaryPG.FKey: '${modelName}' model: '${attributeName}' attribute: is not unique: can't be used as FKey target`);
+        return super.FKey(attribute, options);
+    }
+    begin() {
+        return this.db.begin();
+    }
+    client() {
+        return this.db.client();
+    }
+}
+exports.SedentaryPG = SedentaryPG;

package/dist/cjs/pgdb.js

@@ -0,0 +1,521 @@
+"use strict";
+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 adsrc_1 = require("./adsrc");
+const needDrop = [
+    ["DATETIME", "int2"],
+    ["DATETIME", "int4"],
+    ["DATETIME", "int8"],
+    ["DATETIME", "numeric"],
+    ["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", 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;
+    }
+    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 (typeof value === "string")
+            return (0, pg_format_1.default)("%L", value);
+        //if(value instanceof Date)
+        return (0, pg_format_1.default)("%L", value).replace(/\.\d\d\d\+/, "+");
+        //return format("%L", JSON.stringify(value));
+    }
+    fill(attributes, row, entry) {
+        const loaded = {};
+        for (const attribute in attributes)
+            entry[attribute] = loaded[attribute] = row[attributes[attribute]];
+        Object.defineProperty(entry, "loaded", { configurable: true, value: loaded });
+    }
+    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 && order.length ? ` ORDER BY ${(typeof order === "string" ? [order] : order).map(_ => (_.startsWith("-") ? `${_.substring(1)} DESC` : _)).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.tx ? this.tx._client : await self.pool.connect();
+            let removed = false;
+            try {
+                const query = `DELETE FROM ${tableName} WHERE ${pkFldName} = ${self.escape(this[pkAttrName])}`;
+                self.log(query);
+                removed = (await client.query(query)).rowCount === 1;
+            }
+            finally {
+                if (!this.tx)
+                    client.release();
+            }
+            return removed;
+        };
+    }
+    save(tableName, attributes, 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.tx ? this.tx._client : await self.pool.connect();
+            let changed = false;
+            try {
+                const { loaded } = this;
+                if (loaded) {
+                    const actions = [];
+                    for (const attribute in attributes) {
+                        const value = this[attribute];
+                        if (value !== loaded[attribute])
+                            actions.push(`${attributes[attribute]} = ${self.escape(value)}`);
+                    }
+                    if (actions.length) {
+                        const query = `UPDATE ${tableName} SET ${actions.join(", ")} WHERE ${pkFldName} = ${self.escape(this[pkAttrName])}`;
+                        self.log(query);
+                        self.fill(attributes, (await client.query(query + " RETURNING *")).rows[0], this);
+                        changed = true;
+                    }
+                }
+                else {
+                    const fields = [];
+                    const values = [];
+                    for (const attribute in attributes) {
+                        const value = this[attribute];
+                        if (value !== null && value !== undefined) {
+                            fields.push(attributes[attribute]);
+                            values.push(self.escape(value));
+                        }
+                    }
+                    const query = fields.length ? `INSERT INTO ${tableName} (${fields.join(", ")}) VALUES (${values.join(", ")})` : `INSERT INTO ${tableName} DEFAULT VALUES`;
+                    self.log(query);
+                    self.fill(attributes, (await client.query(query + " RETURNING *")).rows[0], this);
+                    changed = true;
+                }
+            }
+            finally {
+                if (!this.tx)
+                    client.release();
+            }
+            return changed;
+        };
+    }
+    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 i in res.rows)
+            if (!table.findField(res.rows[i].attname))
+                await this.dropField(table.tableName, res.rows[i].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] });
+        }
+        catch (e) {
+            throw e;
+        }
+        finally {
+            this.released = true;
+            this._client.release();
+        }
+    }
+    fieldType(attribute) {
+        const { size, type } = attribute;
+        let ret;
+        switch (type) {
+            case "BOOLEAN":
+                return ["BOOL", "BOOL"];
+            case "DATETIME":
+                return ["DATETIME", "TIMESTAMP (3) WITH TIME ZONE"];
+            case "INT":
+                ret = size === 2 ? "SMALLINT" : "INTEGER";
+                return [ret, ret];
+            case "INT8":
+                return ["BIGINT", "BIGINT"];
+            case "JSON":
+                return ["JSON", "JSON"];
+            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 } = 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(`SELECT attnotnull, atttypmod, typname, ${(0, adsrc_1.adsrc)(this.version)} 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)
+                            this._client.query(statement);
+                    }
+                }
+                await setNotNull(isNotNull);
+            };
+            if (!res.rowCount) {
+                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)
+                            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)
+                        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 (e) {
+                    if (e instanceof pg_1.DatabaseError && e.code === "55000")
+                        return;
+                    if (e instanceof pg_1.DatabaseError && e.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 e;
+                }
+            })();
+        }
+        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;
+    }
+    async client() {
+        return this._client;
+    }
+    release() {
+        this.released = true;
+        this._client.release();
+    }
+    async commit() {
+        if (!this.released) {
+            this.log("COMMIT");
+            await this._client.query("COMMIT");
+            this.release();
+            super.commit();
+        }
+    }
+    async rollback() {
+        try {
+            if (!this.released) {
+                super.rollback();
+                this.log("ROLLBACK");
+                await this._client.query("ROLLBACK");
+            }
+        }
+        finally {
+            if (!this.released)
+                this.release();
+        }
+    }
+}
+exports.TransactionPG = TransactionPG;

package/dist/es/adsrc.js

@@ -0,0 +1,5 @@
+// cspell: disable-next-line
+export function adsrc(version) {
+    // cspell: disable-next-line
+    return version >= 12 ? "pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" : "adsrc";
+}

package/dist/es/index.js

@@ -0,0 +1,24 @@
+import { Sedentary } from "sedentary";
+import { PGDB } from "./pgdb";
+export { EntryBase, Type } from "sedentary";
+export { TransactionPG } from "./pgdb";
+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);
+    }
+    FKey(attribute, options) {
+        const { attributeName, modelName, unique } = attribute;
+        if (!unique)
+            throw new Error(`SedentaryPG.FKey: '${modelName}' model: '${attributeName}' attribute: is not unique: can't be used as FKey target`);
+        return super.FKey(attribute, options);
+    }
+    begin() {
+        return this.db.begin();
+    }
+    client() {
+        return this.db.client();
+    }
+}

package/dist/es/pgdb.js

@@ -0,0 +1,515 @@
+import { DatabaseError, Pool, types as PGtypes } from "pg";
+import format from "pg-format";
+import { DB, Transaction } from "sedentary";
+import { adsrc } from "./adsrc";
+const needDrop = [
+    ["DATETIME", "int2"],
+    ["DATETIME", "int4"],
+    ["DATETIME", "int8"],
+    ["DATETIME", "numeric"],
+    ["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", 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;
+    }
+    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 (typeof value === "string")
+            return format("%L", value);
+        //if(value instanceof Date)
+        return format("%L", value).replace(/\.\d\d\d\+/, "+");
+        //return format("%L", JSON.stringify(value));
+    }
+    fill(attributes, row, entry) {
+        const loaded = {};
+        for (const attribute in attributes)
+            entry[attribute] = loaded[attribute] = row[attributes[attribute]];
+        Object.defineProperty(entry, "loaded", { configurable: true, value: loaded });
+    }
+    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 && order.length ? ` ORDER BY ${(typeof order === "string" ? [order] : order).map(_ => (_.startsWith("-") ? `${_.substring(1)} DESC` : _)).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.tx ? this.tx._client : await self.pool.connect();
+            let removed = false;
+            try {
+                const query = `DELETE FROM ${tableName} WHERE ${pkFldName} = ${self.escape(this[pkAttrName])}`;
+                self.log(query);
+                removed = (await client.query(query)).rowCount === 1;
+            }
+            finally {
+                if (!this.tx)
+                    client.release();
+            }
+            return removed;
+        };
+    }
+    save(tableName, attributes, 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.tx ? this.tx._client : await self.pool.connect();
+            let changed = false;
+            try {
+                const { loaded } = this;
+                if (loaded) {
+                    const actions = [];
+                    for (const attribute in attributes) {
+                        const value = this[attribute];
+                        if (value !== loaded[attribute])
+                            actions.push(`${attributes[attribute]} = ${self.escape(value)}`);
+                    }
+                    if (actions.length) {
+                        const query = `UPDATE ${tableName} SET ${actions.join(", ")} WHERE ${pkFldName} = ${self.escape(this[pkAttrName])}`;
+                        self.log(query);
+                        self.fill(attributes, (await client.query(query + " RETURNING *")).rows[0], this);
+                        changed = true;
+                    }
+                }
+                else {
+                    const fields = [];
+                    const values = [];
+                    for (const attribute in attributes) {
+                        const value = this[attribute];
+                        if (value !== null && value !== undefined) {
+                            fields.push(attributes[attribute]);
+                            values.push(self.escape(value));
+                        }
+                    }
+                    const query = fields.length ? `INSERT INTO ${tableName} (${fields.join(", ")}) VALUES (${values.join(", ")})` : `INSERT INTO ${tableName} DEFAULT VALUES`;
+                    self.log(query);
+                    self.fill(attributes, (await client.query(query + " RETURNING *")).rows[0], this);
+                    changed = true;
+                }
+            }
+            finally {
+                if (!this.tx)
+                    client.release();
+            }
+            return changed;
+        };
+    }
+    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 i in res.rows)
+            if (!table.findField(res.rows[i].attname))
+                await this.dropField(table.tableName, res.rows[i].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] });
+        }
+        catch (e) {
+            throw e;
+        }
+        finally {
+            this.released = true;
+            this._client.release();
+        }
+    }
+    fieldType(attribute) {
+        const { size, type } = attribute;
+        let ret;
+        switch (type) {
+            case "BOOLEAN":
+                return ["BOOL", "BOOL"];
+            case "DATETIME":
+                return ["DATETIME", "TIMESTAMP (3) WITH TIME ZONE"];
+            case "INT":
+                ret = size === 2 ? "SMALLINT" : "INTEGER";
+                return [ret, ret];
+            case "INT8":
+                return ["BIGINT", "BIGINT"];
+            case "JSON":
+                return ["JSON", "JSON"];
+            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 } = 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(`SELECT attnotnull, atttypmod, typname, ${adsrc(this.version)} 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)
+                            this._client.query(statement);
+                    }
+                }
+                await setNotNull(isNotNull);
+            };
+            if (!res.rowCount) {
+                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)
+                            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)
+                        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 (e) {
+                    if (e instanceof DatabaseError && e.code === "55000")
+                        return;
+                    if (e instanceof DatabaseError && e.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 e;
+                }
+            })();
+        }
+        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;
+    }
+    async client() {
+        return this._client;
+    }
+    release() {
+        this.released = true;
+        this._client.release();
+    }
+    async commit() {
+        if (!this.released) {
+            this.log("COMMIT");
+            await this._client.query("COMMIT");
+            this.release();
+            super.commit();
+        }
+    }
+    async rollback() {
+        try {
+            if (!this.released) {
+                super.rollback();
+                this.log("ROLLBACK");
+                await this._client.query("ROLLBACK");
+            }
+        }
+        finally {
+            if (!this.released)
+                this.release();
+        }
+    }
+}

package/dist/types/adsrc.d.ts

@@ -0,0 +1 @@
+export declare function adsrc(version: number): "pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" | "adsrc";

package/dist/types/index.d.ts

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

package/dist/types/pgdb.d.ts

@@ -0,0 +1,46 @@
+import { PoolClient, PoolConfig } from "pg";
+import { Attribute, DB, EntryBase, Table, 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>;
+    client(): Promise<PoolClient>;
+    escape(value: unknown): string;
+    fill(attributes: Record<string, string>, row: Record<string, unknown>, entry: Record<string, unknown>): void;
+    load(tableName: string, attributes: Record<string, string>, pk: Attribute<unknown, 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, unknown>): (this: Record<string, unknown> & {
+        tx?: TransactionPG;
+    }) => Promise<boolean>;
+    save(tableName: string, attributes: Record<string, string>, pk: Attribute<unknown, unknown>): (this: Record<string, unknown> & {
+        loaded?: Record<string, unknown>;
+        tx?: TransactionPG;
+    }) => Promise<boolean>;
+    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, 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,7 +9,7 @@
     "@types/pg": "8.6.5",
     "pg": "8.7.3",
     "pg-format": "1.0.4",
-    "sedentary": "0.0.43"
+    "sedentary": "0.0.44"
   },
   "description": "The ORM which never needs to migrate - PostgreSQL",
   "engines": {
@@ -40,12 +40,12 @@
   "scripts": {
     "build": "make build",
     "coverage": "jest --coverage --no-cache --runInBand",
-    "deploy": "npm_config_registry=\"registry.npmjs.org\" npm publish",
+    "deploy": "make deploy",
     "precoverage": "make pretest",
     "preinstall": "if [ -f Makefile ] ; then make ; fi",
     "pretest": "make pretest",
     "test": "jest --no-cache --runInBand"
   },
   "types": "./dist/types/index.d.ts",
-  "version": "0.0.43"
+  "version": "0.0.44"
 }