sedentary-pg 0.0.23 → 0.0.24

package/index.d.ts

@@ -1,9 +1,12 @@
 import { EntryBase, ForeignKeyOptions, Natural, Sedentary, SedentaryOptions, Type } from "sedentary";
 import { Attribute } from "sedentary/db";
 import { PoolConfig } from "pg";
+import { TransactionPG } from "./pgdb";
 export { EntryBase, SedentaryOptions, Type } from "sedentary";
+export { TransactionPG } from "./pgdb";
 export declare class SedentaryPG extends Sedentary {
     constructor(connection: PoolConfig, options?: SedentaryOptions);
     FKEY<N extends Natural, E extends EntryBase>(attribute: Attribute<N, E>, options?: ForeignKeyOptions): Type<N, E>;
+    begin(): Promise<TransactionPG>;
 }
 export declare const Package: typeof SedentaryPG;

package/index.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Package = exports.SedentaryPG = exports.Type = exports.EntryBase = void 0;
+exports.Package = 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);
@@ -19,6 +21,9 @@ class SedentaryPG extends sedentary_1.Sedentary {
             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();
+    }
 }
 exports.SedentaryPG = SedentaryPG;
 exports.Package = SedentaryPG;

package/package.json

@@ -6,25 +6,24 @@
     "yossarian <sergiybiluk@gmail.com> (https://github.com/captain-yossarian)"
   ],
   "dependencies": {
+    "@types/pg": "8.6.3",
     "pg": "8.7.1",
     "pg-format": "1.0.4",
-    "sedentary": "0.0.23"
+    "sedentary": "0.0.24"
   },
   "description": "The ORM which never needs to migrate - PostgreSQL",
   "devDependencies": {
     "@types/mocha": "9.0.0",
-    "@types/node": "17.0.5",
-    "@types/pg": "8.6.3",
+    "@types/node": "17.0.8",
     "@types/pg-format": "1.0.2",
     "@types/yamljs": "0.2.31",
-    "@typescript-eslint/eslint-plugin": "5.8.1",
-    "@typescript-eslint/parser": "5.8.1",
-    "eslint": "8.5.0",
+    "@typescript-eslint/eslint-plugin": "5.9.0",
+    "@typescript-eslint/parser": "5.9.0",
+    "eslint": "8.6.0",
     "mocha": "9.1.3",
     "nyc": "15.1.0",
     "prettier": "2.5.1",
     "ts-node": "10.4.0",
-    "tsd": "0.19.0",
     "typescript": "4.5.4",
     "yamljs": "0.3.0"
   },
@@ -84,5 +83,5 @@
     }
   },
   "types": "index.d.ts",
-  "version": "0.0.23"
+  "version": "0.0.24"
 }

package/pgdb.d.ts

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

package/pgdb.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PGDB = void 0;
+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");
@@ -25,6 +25,7 @@ const actions = { cascade: "c", "no action": "a", restrict: "r", "set default":
 class PGDB extends db_1.DB {
     constructor(connection, log) {
         super(log);
+        this.oidLoad = {};
         this.client = {};
         this.indexes = [];
         this.pool = new pg_1.Pool(connection);
@@ -36,7 +37,8 @@ class PGDB extends db_1.DB {
         this.version = parseInt(res.rows[0].version.split(" ")[1].split(".")[0], 10);
     }
     async end() {
-        this.client.release();
+        if (this.client.release)
+            this.client.release();
         await this.pool.end();
     }
     defaultNeq(src, value) {
@@ -44,6 +46,11 @@ class PGDB extends db_1.DB {
             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");
@@ -56,47 +63,96 @@ class PGDB extends db_1.DB {
             return (0, pg_format_1.default)("%L", value).replace(/\.\d\d\d\+/, "+");
         return (0, pg_format_1.default)("%L", JSON.stringify(value));
     }
-    fill(attributes, row, entity) {
-        for (const attribute of attributes)
-            entity[attribute.attributeName] = row[attribute.fieldName];
+    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) {
+    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();
-            if (!this.loaded) {
-                const fields = [];
-                const values = [];
-                for (const attribute of attributes) {
-                    const value = this[attribute.attributeName];
-                    if (value !== null && value !== undefined) {
-                        fields.push(attribute.fieldName);
-                        values.push(self.escape(this[attribute.attributeName]));
+            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;
                     }
                 }
-                const query = fields.length ? `INSERT INTO ${tableName} (${fields.join(",")}) VALUES (${values.join(",")})` : `INSERT INTO ${tableName} DEFAULT VALUES`;
-                try {
+                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 true;
             }
-            let changed = false;
-            const { loaded } = this;
-            for (const key in this) {
-                if (typeof this[key] === "object") {
-                    if (JSON.stringify(this[key]) !== JSON.stringify(loaded[key]))
-                        changed = true;
-                }
-                else if (this[key] !== loaded[key])
-                    changed = true;
+            finally {
+                if (!this.tx)
+                    client.release();
             }
-            return Promise.resolve(changed);
+            return changed;
         };
     }
     async dropConstraints(table) {
@@ -187,6 +243,11 @@ class PGDB extends db_1.DB {
             }
         }
     }
+    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;
@@ -359,8 +420,33 @@ class PGDB extends db_1.DB {
 }
 exports.PGDB = PGDB;
 class TransactionPG extends db_1.Transaction {
-    constructor() {
-        super(...arguments);
-        this.client = {};
+    constructor(client) {
+        super();
+        this.released = false;
+        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();
+        }
     }
 }
+exports.TransactionPG = TransactionPG;