@nattyjs/orm 0.0.1-beta.5 → 0.0.1-beta.50

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
   };
@@ -145,9 +169,10 @@ function getColumnNameAndParams$1(config) {
   const params = new Array();
   const relationProps = /* @__PURE__ */ new Map();
   if (config.entity) {
-    for (const key of Object.keys(config.entity)) {
-      if (config.properties[key.toLowerCase()]) {
-        const paramValue = config.entity[key];
+    for (const key of Object.keys(config.properties)) {
+      const propName = config.properties[key];
+      if (config.entity[propName] !== void 0) {
+        const paramValue = config.entity[propName];
         if (!(Utils.isObject(paramValue) || Utils.isArray(paramValue))) {
           columnNames.push(key);
           params.push({
@@ -167,23 +192,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,20 +235,29 @@ function getUpdateQueryText(config) {
   };
 }
 function getColumnNameAndParams(config) {
+  const isMsSql = config.databaseServerTechnology == DatabaseServerTechnology.MSSQL;
   const sets = [];
   const whereClause = [];
   const params = new Array();
   if (config.entity) {
-    for (const [key, value] of Object.entries(config.entity)) {
-      if (!(Utils.isObject(value) || Utils.isArray(value))) {
-        if (config.primaryKeys.indexOf(key) === -1)
-          sets.push(`${key}=@${key}`);
-        else
-          whereClause.push(`${key}=@${key}`);
-        params.push({
-          name: `${key}`,
-          value
-        });
+    let index = 1;
+    let parameterCharacter = isMsSql ? "@" : "$";
+    for (const prop of Object.keys(config.properties)) {
+      const key = config.properties[prop];
+      const value = config.entity[key];
+      if (value !== void 0) {
+        const paramProp = isMsSql ? key : index;
+        if (!(Utils.isObject(value) || Utils.isArray(value))) {
+          if (config.primaryKeys.indexOf(key) === -1)
+            sets.push(`${key}=${parameterCharacter}${paramProp}`);
+          else
+            whereClause.push(`${key}=${parameterCharacter}${paramProp}`);
+          index++;
+          params.push({
+            name: `${key}`,
+            value
+          });
+        }
       }
     }
   }
@@ -249,6 +287,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 +673,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 +684,7 @@ class SqlConnection extends DbConnection {
       }
       return records;
     } catch (ex) {
+      throw ex;
     }
   }
   async runNestedObjectQueries(outputInfo, relationProps, config) {
@@ -391,6 +706,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 +779,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 +816,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 +824,9 @@ class DbConnectionContext {
   useSqlServer(options) {
     this.connection = new SqlConnection(options);
   }
+  usePgSqlServer(options) {
+    this.connection = new PgSqlConnection(options);
+  }
 }
 
 class DbSet {
@@ -517,27 +847,36 @@ class DbSet {
   }
   async add(entity) {
     const properties = this.getProperties();
-    this.changeTracker.addItem({
-      tableName: this.getTableName(this.type.name),
-      entity,
-      primaryKeys: this.getPrimaryKeys(this.type.name),
-      propsDbConfig: this.getPropsDbConfig(entity),
-      properties
-    }, EntityState.added);
+    this.changeTracker.addItem(
+      {
+        tableName: this.getTableName(this.type.name),
+        entity,
+        primaryKeys: this.getPrimaryKeys(this.type.name),
+        propsDbConfig: this.getPropsDbConfig(entity),
+        properties
+      },
+      EntityState.added
+    );
   }
   async update(entity) {
-    this.changeTracker.addItem({
-      tableName: this.getTableName(this.type.name),
-      entity,
-      primaryKeys: this.getPrimaryKeys(this.type.name),
-      propsDbConfig: this.getPropsDbConfig(entity)
-    }, EntityState.updated);
+    this.changeTracker.addItem(
+      {
+        tableName: this.getTableName(this.type.name),
+        entity,
+        primaryKeys: this.getPrimaryKeys(this.type.name),
+        propsDbConfig: this.getPropsDbConfig(entity)
+      },
+      EntityState.updated
+    );
   }
   async delete(expression) {
-    this.changeTracker.addItem({
-      tableName: this.getTableName(this.type.name),
-      whereClause: expression
-    }, EntityState.deleted);
+    this.changeTracker.addItem(
+      {
+        tableName: this.getTableName(this.type.name),
+        whereClause: expression
+      },
+      EntityState.deleted
+    );
   }
   async toList() {
     return await this.execute();
@@ -559,22 +898,30 @@ class DbSet {
     const props = core.entityContainer.getProperties(name || this.type.name);
     const jProps = {};
     if (props)
-      props.forEach((property) => jProps[property.name.toLowerCase()] = property.name);
+      props.forEach(
+        (property) => jProps[property.name.toLowerCase()] = property.name
+      );
     return jProps;
   }
   getPropsDbConfig(entity) {
     const propsDbConfig = core.entityContainer.getPropsDbConfig(this.type.name);
+    const properties = core.entityContainer.getProperties(this.type.name);
     const props = /* @__PURE__ */ new Map();
-    for (const propName of Object.keys(entity)) {
-      const dbFieldConfig = propsDbConfig.get(propName);
-      if (dbFieldConfig && (dbFieldConfig.oneToMany || dbFieldConfig.oneToOne)) {
-        const fieldRelationConfig = dbFieldConfig.oneToMany || dbFieldConfig.oneToOne;
-        props.set(propName, {
-          tableName: this.getTableName(fieldRelationConfig.model.name),
-          primaryKeys: this.getPrimaryKeys(fieldRelationConfig.model.name),
-          foreignKey: fieldRelationConfig.foreignKey,
-          properties: this.getProperties(fieldRelationConfig.model.name)
-        });
+    if (properties && Array.isArray(properties)) {
+      for (const property of properties) {
+        if (entity[property.name]) {
+          const propName = property.name;
+          const dbFieldConfig = propsDbConfig.get(propName);
+          if (dbFieldConfig && (dbFieldConfig.oneToMany || dbFieldConfig.oneToOne)) {
+            const fieldRelationConfig = dbFieldConfig.oneToMany || dbFieldConfig.oneToOne;
+            props.set(propName, {
+              tableName: this.getTableName(fieldRelationConfig.model.name),
+              primaryKeys: this.getPrimaryKeys(fieldRelationConfig.model.name),
+              foreignKey: fieldRelationConfig.foreignKey,
+              properties: this.getProperties(fieldRelationConfig.model.name)
+            });
+          }
+        }
       }
     }
     return props;
@@ -603,6 +950,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 +996,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 +1020,8 @@ class DbContext {
   }
 }
 
+exports.DbConnectionContext = DbConnectionContext;
 exports.DbContext = DbContext;
+exports.DbFunc = DbFunc;
 exports.DbSet = DbSet;
 exports.StoreProc = StoreProc;