@nattyjs/orm 0.0.1-beta.0

package/README.md

@@ -0,0 +1,11 @@
+# `orm`
+
+> TODO: description
+
+## Usage
+
+```
+const orm = require('orm');
+
+// TODO: DEMONSTRATE API
+```

package/dist/index.cjs

@@ -0,0 +1,654 @@
+'use strict';
+
+const mssql = require('mssql');
+const common = require('@nattyjs/common');
+const core = require('@nattyjs/core');
+
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    const n = Object.create(null);
+    if (e) {
+        for (const k in e) {
+            n[k] = e[k];
+        }
+    }
+    n.default = e;
+    return n;
+}
+
+const mssql__namespace = /*#__PURE__*/_interopNamespaceCompat(mssql);
+
+var EntityState = /* @__PURE__ */ ((EntityState2) => {
+  EntityState2[EntityState2["added"] = 0] = "added";
+  EntityState2[EntityState2["updated"] = 1] = "updated";
+  EntityState2[EntityState2["deleted"] = 2] = "deleted";
+  return EntityState2;
+})(EntityState || {});
+
+class ChangeTracker {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  get addedEntries() {
+    return this.entries.get(EntityState.added) || [];
+  }
+  get updatedEntries() {
+    return this.entries.get(EntityState.updated) || [];
+  }
+  get deletedEntries() {
+    return this.entries.get(EntityState.deleted) || [];
+  }
+  clear() {
+    this.entries.clear();
+  }
+  addItem(entity, entityState) {
+    let arraySet = this.entries.get(entityState);
+    if (!arraySet)
+      arraySet = new Array();
+    arraySet.push(entity);
+    this.entries.set(entityState, arraySet);
+  }
+}
+
+var QueryAction = /* @__PURE__ */ ((QueryAction2) => {
+  QueryAction2[QueryAction2["select"] = 0] = "select";
+  QueryAction2[QueryAction2["add"] = 1] = "add";
+  QueryAction2[QueryAction2["update"] = 2] = "update";
+  QueryAction2[QueryAction2["delete"] = 3] = "delete";
+  return QueryAction2;
+})(QueryAction || {});
+
+function getComparisonOperator(operator) {
+  let operatorText = "";
+  switch (operator) {
+    case "==":
+      operatorText = "=";
+      break;
+    default:
+      operatorText = operator;
+      break;
+  }
+  return operatorText;
+}
+
+function getLogicalOperator(operator) {
+  let operatorText = "";
+  switch (operator) {
+    case "&&":
+      operatorText = "AND";
+      break;
+    case "||":
+      operatorText = "OR";
+      break;
+  }
+  return operatorText;
+}
+
+function getDeleteQueryText(config) {
+  const tableName = config.tableName;
+  const params = new Array();
+  const whereClause = getWhereClause$1(config.whereClause, params);
+  return {
+    query: `delete from ${tableName} where ${whereClause}`,
+    parameters: params
+  };
+}
+function getWhereClause$1(whereClause, params) {
+  let sqlQuery = "";
+  const paramKeys = {};
+  let increment = 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} `;
+    params.push({
+      name: paramKey,
+      value: expression[2]
+    });
+    i = i + 1;
+    if (whereClause[i]) {
+      sqlQuery += ` ${getLogicalOperator(whereClause[i])} `;
+    }
+  }
+  return sqlQuery;
+}
+
+class Utils {
+  static isObject(value) {
+    return Object.prototype.toString.call(value) === "[object Object]";
+  }
+  static isArray(value) {
+    return Array.isArray(value);
+  }
+}
+
+function getInsertQueryText(config) {
+  const tableName = config.tableName;
+  const queryInfo = getColumnNameAndParams$1(config);
+  const columnNames = queryInfo.columnNames.join(",");
+  const parameters = queryInfo.columnNames.map((name) => `@${name}`).join(",");
+  const primaryKey = config.primaryKeys[0];
+  let output = "";
+  if (primaryKey)
+    output = `OUTPUT INSERTED.${primaryKey}`;
+  return {
+    query: `insert into ${tableName} (${columnNames}) ${output} values (${parameters})`,
+    parameters: queryInfo.params,
+    relationProps: queryInfo.relationProps
+  };
+}
+function getColumnNameAndParams$1(config) {
+  const columnNames = [];
+  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];
+        if (!(Utils.isObject(paramValue) || Utils.isArray(paramValue))) {
+          columnNames.push(key);
+          params.push({
+            name: `${key}`,
+            value: paramValue
+          });
+        } else {
+          relationProps.set(key, paramValue);
+        }
+      }
+    }
+  }
+  return { columnNames, params, relationProps };
+}
+
+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);
+  return {
+    query: `select ${columnNames} from ${tableName} ${whereClause ? `where ${whereClause}` : ""}`,
+    parameters: params
+  };
+}
+function getWhereClause(whereClause, params) {
+  let sqlQuery = "";
+  const paramKeys = {};
+  let increment = 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} `;
+    params.push({
+      name: paramKey,
+      value: expression[2]
+    });
+    i = i + 1;
+    if (whereClause[i]) {
+      sqlQuery += ` ${getLogicalOperator(whereClause[i])} `;
+    }
+  }
+  return sqlQuery;
+}
+
+function getUpdateQueryText(config) {
+  const tableName = config.tableName;
+  const queryInfo = getColumnNameAndParams(config);
+  const sets = queryInfo.sets.join(",");
+  return {
+    query: `update ${tableName} set ${sets} where ${queryInfo.whereClause.join(` AND `)}`,
+    parameters: queryInfo.params
+  };
+}
+function getColumnNameAndParams(config) {
+  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
+        });
+      }
+    }
+  }
+  return { sets, params, whereClause };
+}
+
+function getSqlTextAndParams(config) {
+  let queryInfo = void 0;
+  switch (config.queryAction) {
+    case QueryAction.select:
+      queryInfo = getSelectQueryText(config);
+      break;
+    case QueryAction.add:
+      queryInfo = getInsertQueryText(config);
+      break;
+    case QueryAction.update:
+      queryInfo = getUpdateQueryText(config);
+      break;
+    case QueryAction.delete:
+      queryInfo = getDeleteQueryText(config);
+      break;
+  }
+  return queryInfo;
+}
+
+class DbConnection {
+  constructor(config) {
+    this.config = config;
+    this.mssql = mssql__namespace;
+  }
+}
+
+class SqlDbTransaction {
+  constructor() {
+    this.isSelfTransaction = true;
+  }
+  useTransaction(connection) {
+    this.isSelfTransaction = false;
+    this.transactionConnection = connection;
+  }
+  async begin(pool, isolationLevel, dbContexts) {
+    return await new Promise(async (resolve, error) => {
+      const transactionCallback = (err) => {
+        if (err) {
+          return error(err);
+        }
+        resolve();
+      };
+      if (!this.transactionConnection) {
+        this.transactionConnection = pool.transaction();
+        if (isolationLevel) {
+          this.transactionConnection.begin(
+            this.convertToIsolationLevel(isolationLevel),
+            transactionCallback
+          );
+        } else {
+          this.transactionConnection.begin(transactionCallback);
+        }
+      } else {
+        resolve();
+      }
+      this.assignTransaction(dbContexts);
+    });
+  }
+  assignTransaction(dbContexts) {
+    if (dbContexts)
+      for (const dbContext of dbContexts)
+        dbContext.connection.useTransaction(this.transactionConnection);
+    this.dbContexts = dbContexts;
+  }
+  async commit() {
+    return new Promise((resolve, error) => {
+      if (this.transactionConnection && this.isSelfTransaction) {
+        this.transactionConnection.commit(async (err) => {
+          if (err)
+            return error(err);
+          this.transactionConnection = null;
+          this.transactionRelease();
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+  transactionRelease() {
+    if (this.dbContexts)
+      for (const dbContext of this.dbContexts)
+        dbContext.connection.releaseTransaction();
+    this.dbContexts = null;
+  }
+  releaseTransaction() {
+    this.transactionConnection = null;
+    this.isSelfTransaction = true;
+  }
+  rollback() {
+    if (this.transactionConnection && this.isSelfTransaction) {
+      return new Promise((resolve, error) => {
+        this.transactionConnection.rollback(async (err) => {
+          if (err)
+            return error(err);
+          this.transactionConnection = null;
+          this.transactionRelease();
+          resolve();
+        });
+      });
+    }
+  }
+  convertToIsolationLevel(isolation) {
+    const ISOLATION_LEVEL = mssql__namespace.ISOLATION_LEVEL;
+    switch (isolation) {
+      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 SqlConnection extends DbConnection {
+  constructor(config) {
+    super(config);
+    this.baseTransaction = new SqlDbTransaction();
+  }
+  get transaction() {
+    return this.baseTransaction;
+  }
+  useTransaction(connection) {
+    this.baseTransaction.useTransaction(connection);
+  }
+  useConnection(connection) {
+    this.connection = connection;
+  }
+  async executeQuery(query) {
+    try {
+      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["recordset"]) {
+        records = result.recordset;
+      }
+      return records;
+    } catch (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 executeSp(spName, params) {
+    let records = new Array();
+    if (common.isObject(params)) {
+      const queryInfo = { parameters: [] };
+      for (const [key, value] of Object.entries(params))
+        queryInfo.parameters.push({ name: key, value });
+      queryInfo.sp = spName;
+      const result = await this.query(queryInfo);
+      if (result["recordset"]) {
+        records = result.recordset;
+      }
+      return records;
+    }
+    return records;
+  }
+  getOutput(result, config) {
+    switch (config.queryAction) {
+      case QueryAction.add:
+        const primaryKey = config.primaryKeys[0];
+        const output = result.recordset[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 = new this.mssql.Request(pool);
+    for (const param of queryInfo.parameters) {
+      if (param.type !== void 0)
+        request.input(param.name, param.type, param.value);
+      else
+        request.input(param.name, param.value);
+    }
+    const resolveQuery = (resolve) => (error, raw) => {
+      if (error)
+        throw error;
+      resolve(raw);
+    };
+    if (queryInfo.query) {
+      const raw = await new Promise((resolve, error) => {
+        request.query(queryInfo.query, resolveQuery(resolve));
+      });
+      return raw;
+    } else if (queryInfo.sp) {
+      const raw = await new Promise((resolve, error) => {
+        request.execute(queryInfo.sp, resolveQuery(resolve));
+      });
+      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 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);
+      });
+    });
+  }
+}
+
+class DbConnectionContext {
+  useSqlServer(options) {
+    this.connection = new SqlConnection(options);
+  }
+}
+
+class DbSet {
+  constructor(type, queryConnection, changeTracker) {
+    this.type = type;
+    this.queryConnection = queryConnection;
+    this.changeTracker = changeTracker;
+    this.columns = new Array();
+    this.whereClause = [];
+  }
+  filter(expression) {
+    this.whereClause = expression;
+    return this;
+  }
+  async firstOrDefault(expression) {
+    this.whereClause = expression;
+    return (await this.execute()).firstOrDefault();
+  }
+  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);
+  }
+  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);
+  }
+  async delete(expression) {
+    this.changeTracker.addItem({
+      tableName: this.getTableName(this.type.name),
+      whereClause: expression
+    }, EntityState.deleted);
+  }
+  async toList() {
+    return await this.execute();
+  }
+  async execute() {
+    const items = await this.queryConnection.executeQuery({
+      queryAction: QueryAction.select,
+      tableName: this.getTableName(this.type.name),
+      columns: this.columns,
+      whereClause: this.whereClause
+    });
+    return new common.List(items, this.type, this.getProperties());
+  }
+  getTableName(name) {
+    const modelConfig = core.entityContainer.getModelConfig(name);
+    return modelConfig ? modelConfig.tableName || this.type.name : this.type.name;
+  }
+  getProperties(name) {
+    const props = core.entityContainer.getProperties(name || this.type.name);
+    const jProps = {};
+    if (props)
+      props.forEach((property) => jProps[property.name.toLowerCase()] = property.name);
+    return jProps;
+  }
+  getPropsDbConfig(entity) {
+    const propsDbConfig = core.entityContainer.getPropsDbConfig(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)
+        });
+      }
+    }
+    return props;
+  }
+  getPrimaryKeys(name) {
+    return core.entityContainer.getPrimaryKeys(name);
+  }
+}
+
+class StoreProc {
+  constructor(spName, type, queryConnection) {
+    this.spName = spName;
+    this.type = type;
+    this.queryConnection = queryConnection;
+  }
+  async execute(params) {
+    const items = await this.queryConnection.executeSp(this.spName, 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;
+  }
+  get internalConnection() {
+    return this.dbConnectionInfo.connection;
+  }
+  get queryConnection() {
+    return this.dbConnectionInfo.connection;
+  }
+  constructor() {
+    this.dbConnectionInfo = new DbConnectionContext();
+    this.changeTracker = new ChangeTracker();
+    this.onConfiguring(this.dbConnectionInfo);
+    this.onDbSetRegistering();
+    this.onSpRegistering();
+  }
+  onDbSetRegistering(dbSets) {
+    if (dbSets)
+      for (const [key, value] of Object.entries(dbSets))
+        this[key] = new DbSet(value(), this.queryConnection, this.changeTracker);
+  }
+  onSpRegistering(sps) {
+    if (sps)
+      for (const [key, value] of Object.entries(sps))
+        this[key] = new StoreProc(value.spName, value.model(), this.queryConnection);
+  }
+  async saveChanges() {
+    return new Promise(async (resolve, error) => {
+      try {
+        await this.internalConnection.beginTransaction();
+        await this.internalConnection.addEntries(this.changeTracker.addedEntries);
+        await this.internalConnection.updateEntries(this.changeTracker.updatedEntries);
+        await this.internalConnection.deleteEntries(this.changeTracker.deletedEntries);
+        await this.internalConnection.commitTransaction();
+        this.changeTracker.clear();
+        resolve(void 0);
+      } catch (ex) {
+        this.changeTracker.clear();
+        await this.internalConnection.rollbackTransaction();
+        error(ex);
+      }
+    });
+  }
+}
+
+exports.DbContext = DbContext;
+exports.DbSet = DbSet;
+exports.StoreProc = StoreProc;