@nattyjs/orm 0.0.1-beta.4 → 0.0.1-beta.40

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 const mssql = require('mssql');
+const pg = require('pg');
 const common = require('@nattyjs/common');
 const core = require('@nattyjs/core');
 
@@ -17,6 +18,7 @@ function _interopNamespaceCompat(e) {
 }
 
 const mssql__namespace = /*#__PURE__*/_interopNamespaceCompat(mssql);
+const pg__namespace = /*#__PURE__*/_interopNamespaceCompat(pg);
 
 var EntityState = /* @__PURE__ */ ((EntityState2) => {
   EntityState2[EntityState2["added"] = 0] = "added";
@@ -58,6 +60,12 @@ var QueryAction = /* @__PURE__ */ ((QueryAction2) => {
   return QueryAction2;
 })(QueryAction || {});
 
+var DatabaseServerTechnology = /* @__PURE__ */ ((DatabaseServerTechnology2) => {
+  DatabaseServerTechnology2[DatabaseServerTechnology2["MSSQL"] = 0] = "MSSQL";
+  DatabaseServerTechnology2[DatabaseServerTechnology2["PGSQL"] = 1] = "PGSQL";
+  return DatabaseServerTechnology2;
+})(DatabaseServerTechnology || {});
+
 function getComparisonOperator(operator) {
   let operatorText = "";
   switch (operator) {
@@ -87,23 +95,27 @@ function getLogicalOperator(operator) {
 function getDeleteQueryText(config) {
   const tableName = config.tableName;
   const params = new Array();
-  const whereClause = getWhereClause$1(config.whereClause, params);
+  const whereClause = getWhereClause$1(config.whereClause, params, config.databaseServerTechnology);
   return {
     query: `delete from ${tableName} where ${whereClause}`,
     parameters: params
   };
 }
-function getWhereClause$1(whereClause, params) {
+function getWhereClause$1(whereClause, params, dbTechnology) {
+  const isMsSql = dbTechnology == DatabaseServerTechnology.MSSQL;
+  let paramCharacter = isMsSql ? "@" : "$";
   let sqlQuery = "";
   const paramKeys = {};
   let increment = 1;
+  let index = 1;
   for (var i = 0; i < whereClause.length; i++) {
     const expression = whereClause[i];
     let paramKey = expression[0];
     if (paramKeys[paramKey])
       paramKey = `${paramKey}${increment}`;
     paramKeys[paramKey] = paramKey;
-    sqlQuery += `${expression[0]} ${getComparisonOperator(expression[1])} @${paramKey} `;
+    sqlQuery += `${expression[0]} ${getComparisonOperator(expression[1])} ${paramCharacter}${isMsSql ? paramKey : index} `;
+    index++;
     params.push({
       name: paramKey,
       value: expression[2]
@@ -126,16 +138,28 @@ class Utils {
 }
 
 function getInsertQueryText(config) {
+  const isMsSql = DatabaseServerTechnology.MSSQL == config.databaseServerTechnology;
+  const isPgSql = DatabaseServerTechnology.PGSQL == config.databaseServerTechnology;
   const tableName = config.tableName;
   const queryInfo = getColumnNameAndParams$1(config);
   const columnNames = queryInfo.columnNames.join(",");
-  const parameters = queryInfo.columnNames.map((name) => `@${name}`).join(",");
+  const parameters = queryInfo.columnNames.map((name, index) => {
+    if (isMsSql)
+      return `@${name}`;
+    else if (isPgSql)
+      return `$${index + 1}`;
+  }).join(",");
   const primaryKey = config.primaryKeys[0];
   let output = "";
-  if (primaryKey)
-    output = `OUTPUT INSERTED.${primaryKey}`;
+  let returningOutput = "";
+  if (primaryKey) {
+    if (DatabaseServerTechnology.MSSQL == config.databaseServerTechnology)
+      output = `OUTPUT INSERTED.${primaryKey}`;
+    else if (DatabaseServerTechnology.PGSQL == config.databaseServerTechnology)
+      returningOutput = `RETURNING ${primaryKey}`;
+  }
   return {
-    query: `insert into ${tableName} (${columnNames}) ${output} values (${parameters})`,
+    query: `insert into ${tableName} (${columnNames}) ${output} values (${parameters}) ${returningOutput}`,
     parameters: queryInfo.params,
     relationProps: queryInfo.relationProps
   };
@@ -167,23 +191,27 @@ function getSelectQueryText(config) {
   const tableName = config.tableName;
   const columnNames = config.columns.length == 0 ? "*" : config.columns.join(",");
   const params = new Array();
-  const whereClause = getWhereClause(config.whereClause, params);
+  const whereClause = getWhereClause(config.whereClause, params, config.databaseServerTechnology);
   return {
     query: `select ${columnNames} from ${tableName} ${whereClause ? `where ${whereClause}` : ""}`,
     parameters: params
   };
 }
-function getWhereClause(whereClause, params) {
+function getWhereClause(whereClause, params, dbTechnology) {
+  const isMsSql = dbTechnology == DatabaseServerTechnology.MSSQL;
+  let paramCharacter = isMsSql ? "@" : "$";
   let sqlQuery = "";
   const paramKeys = {};
   let increment = 1;
+  let index = 1;
   for (var i = 0; i < whereClause.length; i++) {
     const expression = whereClause[i];
     let paramKey = expression[0];
     if (paramKeys[paramKey])
       paramKey = `${paramKey}${increment}`;
     paramKeys[paramKey] = paramKey;
-    sqlQuery += `${expression[0]} ${getComparisonOperator(expression[1])} @${paramKey} `;
+    sqlQuery += `${expression[0]} ${getComparisonOperator(expression[1])} ${paramCharacter}${isMsSql ? paramKey : index} `;
+    index++;
     params.push({
       name: paramKey,
       value: expression[2]
@@ -206,16 +234,21 @@ function getUpdateQueryText(config) {
   };
 }
 function getColumnNameAndParams(config) {
+  const isMsSql = config.databaseServerTechnology == DatabaseServerTechnology.MSSQL;
   const sets = [];
   const whereClause = [];
   const params = new Array();
   if (config.entity) {
+    let index = 1;
+    let parameterCharacter = isMsSql ? "@" : "$";
     for (const [key, value] of Object.entries(config.entity)) {
+      const paramProp = isMsSql ? key : index;
       if (!(Utils.isObject(value) || Utils.isArray(value))) {
         if (config.primaryKeys.indexOf(key) === -1)
-          sets.push(`${key}=@${key}`);
+          sets.push(`${key}=${parameterCharacter}${paramProp}`);
         else
-          whereClause.push(`${key}=@${key}`);
+          whereClause.push(`${key}=${parameterCharacter}${paramProp}`);
+        index++;
         params.push({
           name: `${key}`,
           value
@@ -249,6 +282,281 @@ class DbConnection {
   constructor(config) {
     this.config = config;
     this.mssql = mssql__namespace;
+    this.pg = pg__namespace;
+  }
+}
+
+const connectionCacheContainer = new class {
+  constructor() {
+    this.connectionPoolState = {};
+  }
+  getCacheKey(config) {
+    return `${config.server}-${config.database}`;
+  }
+  async getConnectionPool(mssql, config) {
+    return await new Promise((resolve, error) => {
+      const cacheKey = this.getCacheKey(config);
+      if (this.connectionPoolState[cacheKey])
+        return resolve(this.connectionPoolState[cacheKey]);
+      const pool = new mssql.ConnectionPool(config);
+      const errorHandler = (error2) => {
+      };
+      pool.on("error", errorHandler);
+      const connection = pool.connect((err) => {
+        if (err)
+          return error(err);
+        this.connectionPoolState[cacheKey] = connection;
+        resolve(connection);
+      });
+    });
+  }
+  async getPgSqlConnectionPool(sql, config) {
+    return await new Promise((resolve, error) => {
+      const cacheKey = this.getCacheKey(config);
+      if (this.connectionPoolState[cacheKey])
+        return resolve(this.connectionPoolState[cacheKey]);
+      const pool = new sql.Pool(config);
+      this.connectionPoolState[cacheKey] = pool;
+      resolve(pool);
+    });
+  }
+}();
+
+class PgSqlDbTransaction {
+  constructor() {
+    this.transactionConnection = null;
+    this.isSelfTransaction = true;
+    this.dbContexts = null;
+  }
+  useTransaction(client) {
+    this.isSelfTransaction = false;
+    this.transactionConnection = client;
+  }
+  async begin(pool, isolationLevel, dbContexts) {
+    if (!this.transactionConnection) {
+      this.transactionConnection = await pool.connect();
+      this.isSelfTransaction = true;
+      const isoSql = this.convertToIsolationLevel(isolationLevel);
+      await this.transactionConnection.query(`BEGIN ${isoSql}`);
+    }
+    this.assignTransaction(dbContexts);
+  }
+  assignTransaction(dbContexts) {
+    if (dbContexts)
+      for (const dbContext of dbContexts) {
+        dbContext.connection.useTransaction(this.transactionConnection);
+      }
+    this.dbContexts = dbContexts;
+  }
+  async commit() {
+    if (this.transactionConnection && this.isSelfTransaction) {
+      try {
+        await this.transactionConnection.query("COMMIT");
+      } catch (err) {
+        throw err;
+      } finally {
+        this.transactionRelease();
+        this.transactionConnection.release();
+        this.transactionConnection = null;
+      }
+    }
+  }
+  async rollback() {
+    if (this.transactionConnection && this.isSelfTransaction) {
+      try {
+        await this.transactionConnection.query("ROLLBACK");
+      } catch (err) {
+        throw err;
+      } finally {
+        this.transactionRelease();
+        this.transactionConnection.release();
+        this.transactionConnection = null;
+      }
+    }
+  }
+  transactionRelease() {
+    if (this.dbContexts) {
+      for (const dbContext of this.dbContexts) {
+        dbContext.connection.releaseTransaction();
+      }
+      this.dbContexts = null;
+    }
+  }
+  releaseTransaction() {
+    this.transactionConnection = null;
+    this.isSelfTransaction = true;
+  }
+  convertToIsolationLevel(isolation) {
+    switch (isolation?.toUpperCase()) {
+      case "READ UNCOMMITTED":
+        return "ISOLATION LEVEL READ UNCOMMITTED";
+      case "REPEATABLE READ":
+        return "ISOLATION LEVEL REPEATABLE READ";
+      case "SERIALIZABLE":
+        return "ISOLATION LEVEL SERIALIZABLE";
+      case "READ COMMITTED":
+      default:
+        return "ISOLATION LEVEL READ COMMITTED";
+    }
+  }
+}
+
+class PgSqlConnection extends DbConnection {
+  constructor(config) {
+    super(config);
+    this.baseTransaction = new PgSqlDbTransaction();
+  }
+  get transaction() {
+    return this.baseTransaction;
+  }
+  useTransaction(connection) {
+    this.baseTransaction.useTransaction(connection);
+  }
+  useConnection(connection) {
+    this.connection = connection;
+  }
+  async executeQuery(query) {
+    try {
+      query.databaseServerTechnology = DatabaseServerTechnology.PGSQL;
+      const sqlQueryText = getSqlTextAndParams(query);
+      const result = await this.query(sqlQueryText);
+      let records = new Array();
+      const outputInfo = this.getOutput(result, query);
+      await this.runNestedObjectQueries(outputInfo, sqlQueryText.relationProps, query);
+      if (result["rows"]) {
+        records = result.rows;
+      }
+      return records;
+    } catch (ex) {
+      throw ex;
+    }
+  }
+  async runNestedObjectQueries(outputInfo, relationProps, config) {
+    if (outputInfo) {
+      switch (config.queryAction) {
+        case QueryAction.add:
+          for (const propName of relationProps.keys()) {
+            const entries = relationProps.get(propName);
+            const queryConfig = config.propsDbConfig.get(propName);
+            if (Array.isArray(entries) && queryConfig) {
+              for (const entity of entries) {
+                if (!entity[queryConfig.foreignKey])
+                  entity[queryConfig.foreignKey] = outputInfo.value;
+                await this.runQuery([{ ...queryConfig, entity }], config.queryAction);
+              }
+            }
+          }
+          break;
+      }
+    }
+  }
+  async executeFunc(funcName, params) {
+    let records = new Array();
+    if (common.isObject(params)) {
+      const queryInfo = { parameters: [] };
+      let query = `select * from ${funcName}(`;
+      let index = 1;
+      for (const [key, value] of Object.entries(params)) {
+        query += index == 1 ? `$${index}` : `,$${index}`;
+        index++;
+        queryInfo.parameters.push({ name: key, value });
+      }
+      query += ")";
+      queryInfo.query = query;
+      const result = await this.query(queryInfo);
+      if (result["rows"]) {
+        records = result.rows;
+      }
+      return records;
+    }
+    return records;
+  }
+  async executeSp(spName, params) {
+    let records = new Array();
+    if (common.isObject(params)) {
+      const queryInfo = { parameters: [] };
+      let query = `CALL ${spName}(`;
+      let index = 1;
+      for (const [key, value] of Object.entries(params)) {
+        query += index == 1 ? `$${index}` : `,$${index}`;
+        index++;
+        queryInfo.parameters.push({ name: key, value });
+      }
+      query += ")";
+      queryInfo.query = query;
+      const result = await this.query(queryInfo);
+      if (result["rows"]) {
+        records = result.rows;
+      }
+      return records;
+    }
+    return records;
+  }
+  getOutput(result, config) {
+    switch (config.queryAction) {
+      case QueryAction.add:
+        const primaryKey = config.primaryKeys[0];
+        const output = result.rows[0][primaryKey];
+        if (output)
+          config.entity[primaryKey] = output;
+        return { key: primaryKey, value: output };
+    }
+  }
+  async addEntries(dbEntities) {
+    await this.runQuery(dbEntities, QueryAction.add);
+  }
+  async updateEntries(dbEntities) {
+    await this.runQuery(dbEntities, QueryAction.update);
+  }
+  async deleteEntries(dbEntities) {
+    await this.runQuery(dbEntities, QueryAction.delete);
+  }
+  async runQuery(dbEntities, queryAction) {
+    for (const dbEntity of dbEntities) {
+      const executeQuery = {
+        ...dbEntity,
+        queryAction
+      };
+      await this.executeQuery(executeQuery);
+    }
+  }
+  async query(queryInfo) {
+    const pool = await this.getConnectionPool();
+    const request = pool;
+    const values = queryInfo.parameters.map((t) => t.value);
+    const resolveQuery = (resolve, errorResolver) => (error, raw) => {
+      if (error)
+        errorResolver(error);
+      resolve(raw);
+    };
+    const catchFn = (ex) => {
+      throw ex;
+    };
+    if (queryInfo.query) {
+      const raw = await new Promise((resolve, error) => {
+        request.query(queryInfo.query, values, resolveQuery(resolve, error));
+      }).catch(catchFn);
+      return raw;
+    }
+  }
+  async beginTransaction(isolationLevel, dbContexts) {
+    const connection = await this.getConnectionPool();
+    await this.baseTransaction.begin(connection, isolationLevel, dbContexts);
+  }
+  async commitTransaction() {
+    await this.baseTransaction.commit();
+  }
+  async rollbackTransaction() {
+    await this.baseTransaction.rollback();
+  }
+  releaseTransaction() {
+    this.baseTransaction.releaseTransaction();
+  }
+  async getConnectionPool() {
+    return this.createPool();
+  }
+  async createPool() {
+    return await connectionCacheContainer.getPgSqlConnectionPool(this.pg, this.config);
   }
 }
 
@@ -360,6 +668,7 @@ class SqlConnection extends DbConnection {
   }
   async executeQuery(query) {
     try {
+      query.databaseServerTechnology = DatabaseServerTechnology.MSSQL;
       const sqlQueryText = getSqlTextAndParams(query);
       const result = await this.query(sqlQueryText);
       let records = new Array();
@@ -370,6 +679,7 @@ class SqlConnection extends DbConnection {
       }
       return records;
     } catch (ex) {
+      throw ex;
     }
   }
   async runNestedObjectQueries(outputInfo, relationProps, config) {
@@ -391,6 +701,27 @@ class SqlConnection extends DbConnection {
       }
     }
   }
+  async executeFunc(funcName, params) {
+    let records = new Array();
+    if (common.isObject(params)) {
+      const queryInfo = { parameters: [] };
+      let query = `select * from ${funcName}(`;
+      let index = 1;
+      for (const [key, value] of Object.entries(params)) {
+        query += index == 1 ? `@${key}` : `,@${key}`;
+        index++;
+        queryInfo.parameters.push({ name: key, value });
+      }
+      query += ")";
+      queryInfo.query = query;
+      const result = await this.query(queryInfo);
+      if (result["recordset"]) {
+        records = result.recordset;
+      }
+      return records;
+    }
+    return records;
+  }
   async executeSp(spName, params) {
     let records = new Array();
     if (common.isObject(params)) {
@@ -443,20 +774,23 @@ class SqlConnection extends DbConnection {
       else
         request.input(param.name, param.value);
     }
-    const resolveQuery = (resolve) => (error, raw) => {
+    const resolveQuery = (resolve, errorResolver) => (error, raw) => {
       if (error)
-        throw error;
+        errorResolver(error);
       resolve(raw);
     };
+    const catchFn = (ex) => {
+      throw ex;
+    };
     if (queryInfo.query) {
       const raw = await new Promise((resolve, error) => {
-        request.query(queryInfo.query, resolveQuery(resolve));
-      });
+        request.query(queryInfo.query, resolveQuery(resolve, error));
+      }).catch(catchFn);
       return raw;
     } else if (queryInfo.sp) {
       const raw = await new Promise((resolve, error) => {
-        request.execute(queryInfo.sp, resolveQuery(resolve));
-      });
+        request.execute(queryInfo.sp, resolveQuery(resolve, error));
+      }).catch(catchFn);
       return raw;
     }
   }
@@ -477,19 +811,7 @@ class SqlConnection extends DbConnection {
     return this.createPool();
   }
   async createPool() {
-    return await new Promise((resolve, error) => {
-      if (this.baseTransaction.transactionConnection)
-        return resolve(this.baseTransaction.transactionConnection);
-      const pool = new this.mssql.ConnectionPool(this.config);
-      const errorHandler = (error2) => {
-      };
-      pool.on("error", errorHandler);
-      const connection = pool.connect((err) => {
-        if (err)
-          return error(err);
-        resolve(connection);
-      });
-    });
+    return await connectionCacheContainer.getConnectionPool(this.mssql, this.config);
   }
 }
 
@@ -497,6 +819,9 @@ class DbConnectionContext {
   useSqlServer(options) {
     this.connection = new SqlConnection(options);
   }
+  usePgSqlServer(options) {
+    this.connection = new PgSqlConnection(options);
+  }
 }
 
 class DbSet {
@@ -603,6 +928,25 @@ class StoreProc {
   }
 }
 
+class DbFunc {
+  constructor(funcName, type, queryConnection) {
+    this.funcName = funcName;
+    this.type = type;
+    this.queryConnection = queryConnection;
+  }
+  async execute(params) {
+    const items = await this.queryConnection.executeFunc(this.funcName, params);
+    return new common.List(items, this.type, this.properties);
+  }
+  get properties() {
+    const props = core.entityContainer.getProperties(this.type.name);
+    const jProps = {};
+    if (props)
+      props.forEach((property) => jProps[property.name.toLowerCase()] = property.name);
+    return jProps;
+  }
+}
+
 class DbContext {
   get connection() {
     return this.dbConnectionInfo.connection;
@@ -630,6 +974,11 @@ class DbContext {
       for (const [key, value] of Object.entries(sps))
         this[key] = new StoreProc(value.spName, value.model(), this.queryConnection);
   }
+  onDbFuncRegistering(funcs) {
+    if (funcs)
+      for (const [key, value] of Object.entries(funcs))
+        this[key] = new DbFunc(value.funcName, value.model(), this.queryConnection);
+  }
   async saveChanges() {
     return new Promise(async (resolve, error) => {
       try {
@@ -649,6 +998,8 @@ class DbContext {
   }
 }
 
+exports.DbConnectionContext = DbConnectionContext;
 exports.DbContext = DbContext;
+exports.DbFunc = DbFunc;
 exports.DbSet = DbSet;
 exports.StoreProc = StoreProc;

package/dist/index.d.ts

@@ -46,6 +46,7 @@ declare class ChangeTracker {
 declare class DbConnectionContext {
     connection: any;
     useSqlServer(options: any): void;
+    usePgSqlServer(options: any): void;
 }
 
 declare abstract class DbContext implements IDbContext {
@@ -64,12 +65,23 @@ declare abstract class DbContext implements IDbContext {
             spName: string;
         };
     }): void;
+    protected onDbFuncRegistering(funcs?: {
+        [key: string]: {
+            model: () => ClassType<any>;
+            funcName: string;
+        };
+    }): void;
     protected abstract onConfiguring(connectionContext: DbConnectionContext): void;
     saveChanges(): Promise<unknown>;
 }
 
 type FilterExpression<T> = (t: T) => boolean;
 
+declare enum DatabaseServerTechnology {
+    MSSQL = 0,
+    PGSQL = 1
+}
+
 declare enum QueryAction {
     select = 0,
     add = 1,
@@ -81,6 +93,7 @@ interface ExecuteQueryConfig extends DbEntityInfo {
     columns?: string[];
     whereClause?: any;
     queryAction?: QueryAction;
+    databaseServerTechnology?: DatabaseServerTechnology;
 }
 
 interface DataQueryConnection extends IDbConnection {
@@ -88,6 +101,9 @@ interface DataQueryConnection extends IDbConnection {
     executeSp(spName: string, params: {
         [key: string]: any;
     }): any;
+    executeFunc(funcName: string, params: {
+        [key: string]: any;
+    }): any;
 }
 
 declare class DbSet<T> {
@@ -119,4 +135,13 @@ declare class StoreProc<SpName, Entity, SpParamterModel> {
     private get properties();
 }
 
-export { DbContext, DbSet, StoreProc };
+declare class DbFunc<FuncName, Entity, FuncParamterModel> {
+    private funcName;
+    private type;
+    private queryConnection;
+    constructor(funcName: string, type: ClassType<Entity>, queryConnection: DataQueryConnection);
+    execute(params: FuncParamterModel): Promise<List<Entity>>;
+    private get properties();
+}
+
+export { DbConnectionContext, DbContext, DbFunc, DbSet, StoreProc };

package/dist/index.mjs

@@ -1,4 +1,5 @@
 import * as mssql from 'mssql';
+import * as pg from 'pg';
 import { isObject, List } from '@nattyjs/common';
 import { entityContainer } from '@nattyjs/core';
 
@@ -42,6 +43,12 @@ var QueryAction = /* @__PURE__ */ ((QueryAction2) => {
   return QueryAction2;
 })(QueryAction || {});
 
+var DatabaseServerTechnology = /* @__PURE__ */ ((DatabaseServerTechnology2) => {
+  DatabaseServerTechnology2[DatabaseServerTechnology2["MSSQL"] = 0] = "MSSQL";
+  DatabaseServerTechnology2[DatabaseServerTechnology2["PGSQL"] = 1] = "PGSQL";
+  return DatabaseServerTechnology2;
+})(DatabaseServerTechnology || {});
+
 function getComparisonOperator(operator) {
   let operatorText = "";
   switch (operator) {
@@ -71,23 +78,27 @@ function getLogicalOperator(operator) {
 function getDeleteQueryText(config) {
   const tableName = config.tableName;
   const params = new Array();
-  const whereClause = getWhereClause$1(config.whereClause, params);
+  const whereClause = getWhereClause$1(config.whereClause, params, config.databaseServerTechnology);
   return {
     query: `delete from ${tableName} where ${whereClause}`,
     parameters: params
   };
 }
-function getWhereClause$1(whereClause, params) {
+function getWhereClause$1(whereClause, params, dbTechnology) {
+  const isMsSql = dbTechnology == DatabaseServerTechnology.MSSQL;
+  let paramCharacter = isMsSql ? "@" : "$";
   let sqlQuery = "";
   const paramKeys = {};
   let increment = 1;
+  let index = 1;
   for (var i = 0; i < whereClause.length; i++) {
     const expression = whereClause[i];
     let paramKey = expression[0];
     if (paramKeys[paramKey])
       paramKey = `${paramKey}${increment}`;
     paramKeys[paramKey] = paramKey;
-    sqlQuery += `${expression[0]} ${getComparisonOperator(expression[1])} @${paramKey} `;
+    sqlQuery += `${expression[0]} ${getComparisonOperator(expression[1])} ${paramCharacter}${isMsSql ? paramKey : index} `;
+    index++;
     params.push({
       name: paramKey,
       value: expression[2]
@@ -110,16 +121,28 @@ class Utils {
 }
 
 function getInsertQueryText(config) {
+  const isMsSql = DatabaseServerTechnology.MSSQL == config.databaseServerTechnology;
+  const isPgSql = DatabaseServerTechnology.PGSQL == config.databaseServerTechnology;
   const tableName = config.tableName;
   const queryInfo = getColumnNameAndParams$1(config);
   const columnNames = queryInfo.columnNames.join(",");
-  const parameters = queryInfo.columnNames.map((name) => `@${name}`).join(",");
+  const parameters = queryInfo.columnNames.map((name, index) => {
+    if (isMsSql)
+      return `@${name}`;
+    else if (isPgSql)
+      return `$${index + 1}`;
+  }).join(",");
   const primaryKey = config.primaryKeys[0];
   let output = "";
-  if (primaryKey)
-    output = `OUTPUT INSERTED.${primaryKey}`;
+  let returningOutput = "";
+  if (primaryKey) {
+    if (DatabaseServerTechnology.MSSQL == config.databaseServerTechnology)
+      output = `OUTPUT INSERTED.${primaryKey}`;
+    else if (DatabaseServerTechnology.PGSQL == config.databaseServerTechnology)
+      returningOutput = `RETURNING ${primaryKey}`;
+  }
   return {
-    query: `insert into ${tableName} (${columnNames}) ${output} values (${parameters})`,
+    query: `insert into ${tableName} (${columnNames}) ${output} values (${parameters}) ${returningOutput}`,
     parameters: queryInfo.params,
     relationProps: queryInfo.relationProps
   };
@@ -151,23 +174,27 @@ function getSelectQueryText(config) {
   const tableName = config.tableName;
   const columnNames = config.columns.length == 0 ? "*" : config.columns.join(",");
   const params = new Array();
-  const whereClause = getWhereClause(config.whereClause, params);
+  const whereClause = getWhereClause(config.whereClause, params, config.databaseServerTechnology);
   return {
     query: `select ${columnNames} from ${tableName} ${whereClause ? `where ${whereClause}` : ""}`,
     parameters: params
   };
 }
-function getWhereClause(whereClause, params) {
+function getWhereClause(whereClause, params, dbTechnology) {
+  const isMsSql = dbTechnology == DatabaseServerTechnology.MSSQL;
+  let paramCharacter = isMsSql ? "@" : "$";
   let sqlQuery = "";
   const paramKeys = {};
   let increment = 1;
+  let index = 1;
   for (var i = 0; i < whereClause.length; i++) {
     const expression = whereClause[i];
     let paramKey = expression[0];
     if (paramKeys[paramKey])
       paramKey = `${paramKey}${increment}`;
     paramKeys[paramKey] = paramKey;
-    sqlQuery += `${expression[0]} ${getComparisonOperator(expression[1])} @${paramKey} `;
+    sqlQuery += `${expression[0]} ${getComparisonOperator(expression[1])} ${paramCharacter}${isMsSql ? paramKey : index} `;
+    index++;
     params.push({
       name: paramKey,
       value: expression[2]
@@ -190,16 +217,21 @@ function getUpdateQueryText(config) {
   };
 }
 function getColumnNameAndParams(config) {
+  const isMsSql = config.databaseServerTechnology == DatabaseServerTechnology.MSSQL;
   const sets = [];
   const whereClause = [];
   const params = new Array();
   if (config.entity) {
+    let index = 1;
+    let parameterCharacter = isMsSql ? "@" : "$";
     for (const [key, value] of Object.entries(config.entity)) {
+      const paramProp = isMsSql ? key : index;
       if (!(Utils.isObject(value) || Utils.isArray(value))) {
         if (config.primaryKeys.indexOf(key) === -1)
-          sets.push(`${key}=@${key}`);
+          sets.push(`${key}=${parameterCharacter}${paramProp}`);
         else
-          whereClause.push(`${key}=@${key}`);
+          whereClause.push(`${key}=${parameterCharacter}${paramProp}`);
+        index++;
         params.push({
           name: `${key}`,
           value
@@ -233,6 +265,281 @@ class DbConnection {
   constructor(config) {
     this.config = config;
     this.mssql = mssql;
+    this.pg = pg;
+  }
+}
+
+const connectionCacheContainer = new class {
+  constructor() {
+    this.connectionPoolState = {};
+  }
+  getCacheKey(config) {
+    return `${config.server}-${config.database}`;
+  }
+  async getConnectionPool(mssql, config) {
+    return await new Promise((resolve, error) => {
+      const cacheKey = this.getCacheKey(config);
+      if (this.connectionPoolState[cacheKey])
+        return resolve(this.connectionPoolState[cacheKey]);
+      const pool = new mssql.ConnectionPool(config);
+      const errorHandler = (error2) => {
+      };
+      pool.on("error", errorHandler);
+      const connection = pool.connect((err) => {
+        if (err)
+          return error(err);
+        this.connectionPoolState[cacheKey] = connection;
+        resolve(connection);
+      });
+    });
+  }
+  async getPgSqlConnectionPool(sql, config) {
+    return await new Promise((resolve, error) => {
+      const cacheKey = this.getCacheKey(config);
+      if (this.connectionPoolState[cacheKey])
+        return resolve(this.connectionPoolState[cacheKey]);
+      const pool = new sql.Pool(config);
+      this.connectionPoolState[cacheKey] = pool;
+      resolve(pool);
+    });
+  }
+}();
+
+class PgSqlDbTransaction {
+  constructor() {
+    this.transactionConnection = null;
+    this.isSelfTransaction = true;
+    this.dbContexts = null;
+  }
+  useTransaction(client) {
+    this.isSelfTransaction = false;
+    this.transactionConnection = client;
+  }
+  async begin(pool, isolationLevel, dbContexts) {
+    if (!this.transactionConnection) {
+      this.transactionConnection = await pool.connect();
+      this.isSelfTransaction = true;
+      const isoSql = this.convertToIsolationLevel(isolationLevel);
+      await this.transactionConnection.query(`BEGIN ${isoSql}`);
+    }
+    this.assignTransaction(dbContexts);
+  }
+  assignTransaction(dbContexts) {
+    if (dbContexts)
+      for (const dbContext of dbContexts) {
+        dbContext.connection.useTransaction(this.transactionConnection);
+      }
+    this.dbContexts = dbContexts;
+  }
+  async commit() {
+    if (this.transactionConnection && this.isSelfTransaction) {
+      try {
+        await this.transactionConnection.query("COMMIT");
+      } catch (err) {
+        throw err;
+      } finally {
+        this.transactionRelease();
+        this.transactionConnection.release();
+        this.transactionConnection = null;
+      }
+    }
+  }
+  async rollback() {
+    if (this.transactionConnection && this.isSelfTransaction) {
+      try {
+        await this.transactionConnection.query("ROLLBACK");
+      } catch (err) {
+        throw err;
+      } finally {
+        this.transactionRelease();
+        this.transactionConnection.release();
+        this.transactionConnection = null;
+      }
+    }
+  }
+  transactionRelease() {
+    if (this.dbContexts) {
+      for (const dbContext of this.dbContexts) {
+        dbContext.connection.releaseTransaction();
+      }
+      this.dbContexts = null;
+    }
+  }
+  releaseTransaction() {
+    this.transactionConnection = null;
+    this.isSelfTransaction = true;
+  }
+  convertToIsolationLevel(isolation) {
+    switch (isolation?.toUpperCase()) {
+      case "READ UNCOMMITTED":
+        return "ISOLATION LEVEL READ UNCOMMITTED";
+      case "REPEATABLE READ":
+        return "ISOLATION LEVEL REPEATABLE READ";
+      case "SERIALIZABLE":
+        return "ISOLATION LEVEL SERIALIZABLE";
+      case "READ COMMITTED":
+      default:
+        return "ISOLATION LEVEL READ COMMITTED";
+    }
+  }
+}
+
+class PgSqlConnection extends DbConnection {
+  constructor(config) {
+    super(config);
+    this.baseTransaction = new PgSqlDbTransaction();
+  }
+  get transaction() {
+    return this.baseTransaction;
+  }
+  useTransaction(connection) {
+    this.baseTransaction.useTransaction(connection);
+  }
+  useConnection(connection) {
+    this.connection = connection;
+  }
+  async executeQuery(query) {
+    try {
+      query.databaseServerTechnology = DatabaseServerTechnology.PGSQL;
+      const sqlQueryText = getSqlTextAndParams(query);
+      const result = await this.query(sqlQueryText);
+      let records = new Array();
+      const outputInfo = this.getOutput(result, query);
+      await this.runNestedObjectQueries(outputInfo, sqlQueryText.relationProps, query);
+      if (result["rows"]) {
+        records = result.rows;
+      }
+      return records;
+    } catch (ex) {
+      throw ex;
+    }
+  }
+  async runNestedObjectQueries(outputInfo, relationProps, config) {
+    if (outputInfo) {
+      switch (config.queryAction) {
+        case QueryAction.add:
+          for (const propName of relationProps.keys()) {
+            const entries = relationProps.get(propName);
+            const queryConfig = config.propsDbConfig.get(propName);
+            if (Array.isArray(entries) && queryConfig) {
+              for (const entity of entries) {
+                if (!entity[queryConfig.foreignKey])
+                  entity[queryConfig.foreignKey] = outputInfo.value;
+                await this.runQuery([{ ...queryConfig, entity }], config.queryAction);
+              }
+            }
+          }
+          break;
+      }
+    }
+  }
+  async executeFunc(funcName, params) {
+    let records = new Array();
+    if (isObject(params)) {
+      const queryInfo = { parameters: [] };
+      let query = `select * from ${funcName}(`;
+      let index = 1;
+      for (const [key, value] of Object.entries(params)) {
+        query += index == 1 ? `$${index}` : `,$${index}`;
+        index++;
+        queryInfo.parameters.push({ name: key, value });
+      }
+      query += ")";
+      queryInfo.query = query;
+      const result = await this.query(queryInfo);
+      if (result["rows"]) {
+        records = result.rows;
+      }
+      return records;
+    }
+    return records;
+  }
+  async executeSp(spName, params) {
+    let records = new Array();
+    if (isObject(params)) {
+      const queryInfo = { parameters: [] };
+      let query = `CALL ${spName}(`;
+      let index = 1;
+      for (const [key, value] of Object.entries(params)) {
+        query += index == 1 ? `$${index}` : `,$${index}`;
+        index++;
+        queryInfo.parameters.push({ name: key, value });
+      }
+      query += ")";
+      queryInfo.query = query;
+      const result = await this.query(queryInfo);
+      if (result["rows"]) {
+        records = result.rows;
+      }
+      return records;
+    }
+    return records;
+  }
+  getOutput(result, config) {
+    switch (config.queryAction) {
+      case QueryAction.add:
+        const primaryKey = config.primaryKeys[0];
+        const output = result.rows[0][primaryKey];
+        if (output)
+          config.entity[primaryKey] = output;
+        return { key: primaryKey, value: output };
+    }
+  }
+  async addEntries(dbEntities) {
+    await this.runQuery(dbEntities, QueryAction.add);
+  }
+  async updateEntries(dbEntities) {
+    await this.runQuery(dbEntities, QueryAction.update);
+  }
+  async deleteEntries(dbEntities) {
+    await this.runQuery(dbEntities, QueryAction.delete);
+  }
+  async runQuery(dbEntities, queryAction) {
+    for (const dbEntity of dbEntities) {
+      const executeQuery = {
+        ...dbEntity,
+        queryAction
+      };
+      await this.executeQuery(executeQuery);
+    }
+  }
+  async query(queryInfo) {
+    const pool = await this.getConnectionPool();
+    const request = pool;
+    const values = queryInfo.parameters.map((t) => t.value);
+    const resolveQuery = (resolve, errorResolver) => (error, raw) => {
+      if (error)
+        errorResolver(error);
+      resolve(raw);
+    };
+    const catchFn = (ex) => {
+      throw ex;
+    };
+    if (queryInfo.query) {
+      const raw = await new Promise((resolve, error) => {
+        request.query(queryInfo.query, values, resolveQuery(resolve, error));
+      }).catch(catchFn);
+      return raw;
+    }
+  }
+  async beginTransaction(isolationLevel, dbContexts) {
+    const connection = await this.getConnectionPool();
+    await this.baseTransaction.begin(connection, isolationLevel, dbContexts);
+  }
+  async commitTransaction() {
+    await this.baseTransaction.commit();
+  }
+  async rollbackTransaction() {
+    await this.baseTransaction.rollback();
+  }
+  releaseTransaction() {
+    this.baseTransaction.releaseTransaction();
+  }
+  async getConnectionPool() {
+    return this.createPool();
+  }
+  async createPool() {
+    return await connectionCacheContainer.getPgSqlConnectionPool(this.pg, this.config);
   }
 }
 
@@ -344,6 +651,7 @@ class SqlConnection extends DbConnection {
   }
   async executeQuery(query) {
     try {
+      query.databaseServerTechnology = DatabaseServerTechnology.MSSQL;
       const sqlQueryText = getSqlTextAndParams(query);
       const result = await this.query(sqlQueryText);
       let records = new Array();
@@ -354,6 +662,7 @@ class SqlConnection extends DbConnection {
       }
       return records;
     } catch (ex) {
+      throw ex;
     }
   }
   async runNestedObjectQueries(outputInfo, relationProps, config) {
@@ -375,6 +684,27 @@ class SqlConnection extends DbConnection {
       }
     }
   }
+  async executeFunc(funcName, params) {
+    let records = new Array();
+    if (isObject(params)) {
+      const queryInfo = { parameters: [] };
+      let query = `select * from ${funcName}(`;
+      let index = 1;
+      for (const [key, value] of Object.entries(params)) {
+        query += index == 1 ? `@${key}` : `,@${key}`;
+        index++;
+        queryInfo.parameters.push({ name: key, value });
+      }
+      query += ")";
+      queryInfo.query = query;
+      const result = await this.query(queryInfo);
+      if (result["recordset"]) {
+        records = result.recordset;
+      }
+      return records;
+    }
+    return records;
+  }
   async executeSp(spName, params) {
     let records = new Array();
     if (isObject(params)) {
@@ -427,20 +757,23 @@ class SqlConnection extends DbConnection {
       else
         request.input(param.name, param.value);
     }
-    const resolveQuery = (resolve) => (error, raw) => {
+    const resolveQuery = (resolve, errorResolver) => (error, raw) => {
       if (error)
-        throw error;
+        errorResolver(error);
       resolve(raw);
     };
+    const catchFn = (ex) => {
+      throw ex;
+    };
     if (queryInfo.query) {
       const raw = await new Promise((resolve, error) => {
-        request.query(queryInfo.query, resolveQuery(resolve));
-      });
+        request.query(queryInfo.query, resolveQuery(resolve, error));
+      }).catch(catchFn);
       return raw;
     } else if (queryInfo.sp) {
       const raw = await new Promise((resolve, error) => {
-        request.execute(queryInfo.sp, resolveQuery(resolve));
-      });
+        request.execute(queryInfo.sp, resolveQuery(resolve, error));
+      }).catch(catchFn);
       return raw;
     }
   }
@@ -461,19 +794,7 @@ class SqlConnection extends DbConnection {
     return this.createPool();
   }
   async createPool() {
-    return await new Promise((resolve, error) => {
-      if (this.baseTransaction.transactionConnection)
-        return resolve(this.baseTransaction.transactionConnection);
-      const pool = new this.mssql.ConnectionPool(this.config);
-      const errorHandler = (error2) => {
-      };
-      pool.on("error", errorHandler);
-      const connection = pool.connect((err) => {
-        if (err)
-          return error(err);
-        resolve(connection);
-      });
-    });
+    return await connectionCacheContainer.getConnectionPool(this.mssql, this.config);
   }
 }
 
@@ -481,6 +802,9 @@ class DbConnectionContext {
   useSqlServer(options) {
     this.connection = new SqlConnection(options);
   }
+  usePgSqlServer(options) {
+    this.connection = new PgSqlConnection(options);
+  }
 }
 
 class DbSet {
@@ -587,6 +911,25 @@ class StoreProc {
   }
 }
 
+class DbFunc {
+  constructor(funcName, type, queryConnection) {
+    this.funcName = funcName;
+    this.type = type;
+    this.queryConnection = queryConnection;
+  }
+  async execute(params) {
+    const items = await this.queryConnection.executeFunc(this.funcName, params);
+    return new List(items, this.type, this.properties);
+  }
+  get properties() {
+    const props = entityContainer.getProperties(this.type.name);
+    const jProps = {};
+    if (props)
+      props.forEach((property) => jProps[property.name.toLowerCase()] = property.name);
+    return jProps;
+  }
+}
+
 class DbContext {
   get connection() {
     return this.dbConnectionInfo.connection;
@@ -614,6 +957,11 @@ class DbContext {
       for (const [key, value] of Object.entries(sps))
         this[key] = new StoreProc(value.spName, value.model(), this.queryConnection);
   }
+  onDbFuncRegistering(funcs) {
+    if (funcs)
+      for (const [key, value] of Object.entries(funcs))
+        this[key] = new DbFunc(value.funcName, value.model(), this.queryConnection);
+  }
   async saveChanges() {
     return new Promise(async (resolve, error) => {
       try {
@@ -633,4 +981,4 @@ class DbContext {
   }
 }
 
-export { DbContext, DbSet, StoreProc };
+export { DbConnectionContext, DbContext, DbFunc, DbSet, StoreProc };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nattyjs/orm",
-  "version": "0.0.1-beta.4",
+  "version": "0.0.1-beta.40",
   "description": "",
   "module": "./dist/index.mjs",
   "main": "./dist/index.cjs",
@@ -17,10 +17,11 @@
     "unbuild": "1.2.1"
   },
   "dependencies": {
+    "pg": "8.16.0",
     "mssql": "^9.1.1",
-    "@nattyjs/core": "0.0.1-beta.4",
-    "@nattyjs/common": "0.0.1-beta.4",
-    "@nattyjs/entity": "0.0.1-beta.4",
-    "@nattyjs/types": "0.0.1-beta.4"
+    "@nattyjs/core": "0.0.1-beta.40",
+    "@nattyjs/common": "0.0.1-beta.40",
+    "@nattyjs/entity": "0.0.1-beta.40",
+    "@nattyjs/types": "0.0.1-beta.40"
   }
 }