sedentary-pg 0.0.25 → 0.0.28

package/{pgdb.js → dist/cjs/pgdb.js}

@@ -6,7 +6,7 @@ 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 db_1 = require("sedentary/db");
+const sedentary_1 = require("sedentary");
 const adsrc_1 = require("./adsrc");
 const needDrop = [
     ["DATETIME", "int2"],
@@ -22,7 +22,7 @@ const needUsing = [
 ];
 const types = { int2: "SMALLINT", int4: "INTEGER", int8: "BIGINT", timestamptz: "DATETIME", varchar: "VARCHAR" };
 const actions = { cascade: "c", "no action": "a", restrict: "r", "set default": "d", "set null": "n" };
-class PGDB extends db_1.DB {
+class PGDB extends sedentary_1.DB {
     constructor(connection, log) {
         super(log);
         this.oidLoad = {};
@@ -419,7 +419,7 @@ class PGDB extends db_1.DB {
     }
 }
 exports.PGDB = PGDB;
-class TransactionPG extends db_1.Transaction {
+class TransactionPG extends sedentary_1.Transaction {
     constructor(client) {
         super();
         this.released = false;

package/dist/es/adsrc.js

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

package/dist/es/index.js

@@ -0,0 +1,22 @@
+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(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: is not unique: can't be used as FKEY target`);
+        return super.FKEY(attribute, options);
+    }
+    async begin() {
+        return this.db.begin();
+    }
+}
+export const Package = SedentaryPG;

package/dist/es/pgdb.js

@@ -0,0 +1,448 @@
+import { DatabaseError, Pool } from "pg";
+import format from "pg-format";
+import { DB, Transaction } from "sedentary";
+import { adsrc } from "./adsrc";
+const needDrop = [
+    ["DATETIME", "int2"],
+    ["DATETIME", "int4"],
+    ["DATETIME", "int8"],
+    ["INT", "timestamptz"],
+    ["INT8", "timestamptz"]
+];
+const needUsing = [
+    ["DATETIME", "varchar"],
+    ["INT", "varchar"],
+    ["INT8", "varchar"]
+];
+const types = { int2: "SMALLINT", int4: "INTEGER", int8: "BIGINT", timestamptz: "DATETIME", varchar: "VARCHAR" };
+const actions = { cascade: "c", "no action": "a", restrict: "r", "set default": "d", "set null": "n" };
+export class PGDB extends DB {
+    client;
+    indexes;
+    oidLoad = {};
+    pool;
+    version;
+    constructor(connection, log) {
+        super(log);
+        this.client = {};
+        this.indexes = [];
+        this.pool = new Pool(connection);
+        this.version = 0;
+    }
+    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.client.release)
+            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(await this.pool.connect());
+        await ret.client.query("BEGIN");
+        return ret;
+    }
+    escape(value) {
+        if (value === null || value === undefined)
+            throw new Error("SedentaryPG: Can't escape null nor undefined values; use the 'IS NULL' operator instead");
+        const type = typeof value;
+        if (type === "number" || type === "boolean")
+            return value.toString();
+        if (type === "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, tx) => {
+            const { oid } = table;
+            const ret = [];
+            const client = tx ? tx.client : await this.pool.connect();
+            const oidPK = {};
+            try {
+                const query = `SELECT *, tableoid FROM ${tableName}${where ? ` WHERE ${where}` : ""}${order && order.length ? ` ORDER BY ${order.map(_ => (_.startsWith("-") ? `${_.substring(1)} DESC` : _)).join(",")}` : ""}`;
+                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);
+                        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] of oidPK[oid])
+                            ret[id] = entry;
+                }
+            }
+            finally {
+                if (!tx)
+                    client.release();
+            }
+            return ret;
+        };
+    }
+    save(tableName, attributes, pk) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const pkAttrnName = pk.attributeName;
+        const pkFldName = pk.fieldName;
+        return async function () {
+            let changed = false;
+            const client = this.tx ? this.tx.client : await self.pool.connect();
+            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[pkAttrnName])}`;
+                        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() {
+        await super.syncDataBase();
+        for (const table of this.tables)
+            this.oidLoad[table.oid || 0] = (ids) => table.model.load({ [table.pk.attributeName]: ["IN", ids] });
+    }
+    fieldType(attribute) {
+        const { size, type } = attribute;
+        let ret;
+        switch (type) {
+            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 "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, create) => {
+                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 (!isNotNull && !create) {
+                        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, true);
+            }
+            else {
+                const { adsrc, attnotnull, atttypmod, typname } = res.rows[0];
+                if (types[typname] !== base || (base === "VARCHAR" && (size ? size + 4 !== atttypmod : atttypmod !== -1))) {
+                    if (needDrop.filter(([type, name]) => attribute.type === type && typname === name).length) {
+                        await this.dropField(tableName, fieldName);
+                        await addField();
+                        await setDefault(false, true);
+                    }
+                    else {
+                        if (adsrc)
+                            dropDefault();
+                        const using = needUsing.filter(([type, name]) => attribute.type === type && typname === name).length ? " 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, false);
+                    }
+                }
+                else if (defaultValue === undefined) {
+                    if (adsrc)
+                        dropDefault();
+                    await setNotNull(attnotnull);
+                }
+                else if (!adsrc || this.defaultNeq(adsrc, defaultValue))
+                    await setDefault(attnotnull, false);
+            }
+        }
+    }
+    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(client) {
+        super();
+        this.client = client;
+    }
+    release() {
+        this.released = true;
+        this.client.release();
+    }
+    async commit() {
+        if (!this.released) {
+            await this.client.query("COMMIT");
+            this.release();
+            super.commit();
+        }
+    }
+    async rollback() {
+        try {
+            if (!this.released) {
+                super.rollback();
+                await this.client.query("ROLLBACK");
+            }
+        }
+        finally {
+            if (!this.released)
+                this.release();
+        }
+    }
+}

package/{index.d.ts → dist/types/index.d.ts}

@@ -1,5 +1,4 @@
-import { EntryBase, ForeignKeyOptions, Natural, Sedentary, SedentaryOptions, Type } from "sedentary";
-import { Attribute } from "sedentary/db";
+import { Attribute, EntryBase, ForeignKeyOptions, Natural, Sedentary, SedentaryOptions, Type } from "sedentary";
 import { PoolConfig } from "pg";
 import { PGDB, TransactionPG } from "./pgdb";
 export { EntryBase, SedentaryOptions, Type } from "sedentary";

package/{pgdb.d.ts → dist/types/pgdb.d.ts}

@@ -1,5 +1,5 @@
 import { PoolClient, PoolConfig } from "pg";
-import { Attribute, DB, EntryBase, Natural, Table, Transaction } from "sedentary/db";
+import { Attribute, DB, EntryBase, Natural, Table, Transaction } from "sedentary";
 export declare class PGDB extends DB<TransactionPG> {
     private client;
     private indexes;

package/package.json

@@ -9,7 +9,7 @@
     "@types/pg": "8.6.4",
     "pg": "8.7.3",
     "pg-format": "1.0.4",
-    "sedentary": "0.0.25"
+    "sedentary": "0.0.28"
   },
   "description": "The ORM which never needs to migrate - PostgreSQL",
   "devDependencies": {
@@ -44,6 +44,8 @@
     "sqlite"
   ],
   "license": "MIT",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es/index.js",
   "name": "sedentary-pg",
   "prettier": {
     "arrowParens": "avoid",
@@ -62,15 +64,14 @@
     "packagejson": "node -r ts-node/register utils.ts packagejson",
     "test": "mocha -r ts-node/register test/*ts",
     "travis": "node -r ts-node/register utils.ts travis",
-    "tsc": "tsc --declaration",
+    "tsc": "tsc -p tsconfig.cjs.json && tsc -p tsconfig.es.json && tsc -p tsconfig.types.json",
     "version": "node -r ts-node/register utils.ts version"
   },
   "tsd": {
     "compilerOptions": {
       "alwaysStrict": true,
-      "declaration": true,
       "esModuleInterop": true,
-      "module": "commonjs",
+      "moduleResolution": "node",
       "noImplicitAny": true,
       "noImplicitReturns": true,
       "noImplicitThis": true,
@@ -78,10 +79,9 @@
       "strictBindCallApply": true,
       "strictFunctionTypes": true,
       "strictNullChecks": true,
-      "strictPropertyInitialization": true,
-      "target": "es2017"
+      "strictPropertyInitialization": true
     }
   },
-  "types": "index.d.ts",
-  "version": "0.0.25"
-}
+  "types": "./dist/types/index.d.ts",
+  "version": "0.0.28"
+}