mythix-orm-sql-base 1.1.1 → 1.3.0

package/lib/sql-connection-base.js

@@ -39,6 +39,32 @@ class SQLConnectionBase extends ConnectionBase {
     return literal;
   }
 
+  getLockMode(options) {
+    if (!options)
+      return { lock: false, read: false, write: false };
+
+    const throwError = () => {
+      throw new Error(`${this.constructor.name}::getLockMode: "lock" must be the name of a model (lock: "ModelName"), or an object specifying the model and the lock mode (lock: { modelName: "ModelName", read: true, write: true, dependents: true, noWait: false }).`);
+    };
+
+    if (Nife.instanceOf(options, 'string')) {
+      let Model = this.getModel(options);
+      if (!Model)
+        throwError();
+
+      return { lock: true, modelName: options, read: true, write: true };
+    } else if (Nife.instanceOf(options, 'object')) {
+      let modelName = options.modelName;
+      let Model = this.getModel(modelName);
+      if (!Model)
+        throwError();
+
+      return Object.assign({ lock: true, read: true, write: true }, options);
+    } else {
+      throwError();
+    }
+  }
+
   prepareArrayValuesForSQL(_array) {
     let array = Nife.arrayFlatten(_array);
 
@@ -426,7 +452,7 @@ class SQLConnectionBase extends ConnectionBase {
       // Operation handler
       async (Model, preparedModels, options, queryGenerator) => {
         let sqlStr  = queryGenerator.generateInsertStatement(Model, preparedModels, options);
-        let results = await this.query(sqlStr, { logger: options.logger });
+        let results = await this.query(sqlStr, options);
 
         this.updateModelsFromResults(Model, preparedModels.models, results);
       },
@@ -439,7 +465,7 @@ class SQLConnectionBase extends ConnectionBase {
         for (let dirtyModel of dirtyModels) {
           let Model   = dirtyModel.getModel();
           let sqlStr  = queryGenerator.generateUpdateStatement(Model, dirtyModel, null, options);
-          let results = await this.query(sqlStr, { logger: options.logger });
+          let results = await this.query(sqlStr, options);
 
           this.updateModelsFromResults(Model, [ dirtyModel ], results);
         }
@@ -449,7 +475,7 @@ class SQLConnectionBase extends ConnectionBase {
 
   // eslint-disable-next-line no-unused-vars
   async upsert(Model, models, _options) {
-    throw new Error(`${this.constructor.name}::upsert: This connection type does not support "upsert" operations.`);
+    throw new Error(`${this.constructor.name}::upsert: This operation is not supported for this connection type.`);
   }
 
   async update(Model, models, _options) {
@@ -484,7 +510,7 @@ class SQLConnectionBase extends ConnectionBase {
           if (!sqlStr)
             continue;
 
-          let results = await this.query(sqlStr, { logger: options.logger });
+          let results = await this.query(sqlStr, options);
           this.updateModelsFromResults(Model, [ model ], results);
         }
       },
@@ -510,7 +536,7 @@ class SQLConnectionBase extends ConnectionBase {
 
     // TODO: Use "RETURNING" to return pks of of updated rows
 
-    return await this.query(sqlStr, { logger: options.logger });
+    return await this.query(sqlStr, options);
   }
 
   async destroyModels(Model, _models, _options) {
@@ -522,7 +548,7 @@ class SQLConnectionBase extends ConnectionBase {
       let queryGenerator  = this.getQueryGenerator();
       let sqlStr          = queryGenerator.generateDeleteStatement(Model, Model.where.unscoped(), options);
 
-      return await this.query(sqlStr, { logger: options.logger });
+      return await this.query(sqlStr, options);
     }
 
     let models = Nife.toArray(_models).filter(Boolean);
@@ -560,7 +586,7 @@ class SQLConnectionBase extends ConnectionBase {
         if (!sqlStr)
           return;
 
-        await this.query(sqlStr, { logger: options.logger });
+        await this.query(sqlStr, options);
       },
     );
   }
@@ -588,7 +614,7 @@ class SQLConnectionBase extends ConnectionBase {
     let options         = modelsOrOptions || {};
     let queryGenerator  = this.getQueryGenerator();
     let sqlStr          = queryGenerator.generateDeleteStatement(rootModel, queryEngine, options);
-    return await this.query(sqlStr, { logger: options.logger });
+    return await this.query(sqlStr, options);
   }
 
   async *select(_queryEngine, _options) {
@@ -612,7 +638,7 @@ class SQLConnectionBase extends ConnectionBase {
     while (true) {
       let query         = queryEngine.clone().LIMIT(batchSize).OFFSET(startIndex);
       let sqlStatement  = queryGenerator.generateSelectStatement(query, options);
-      let result        = await this.query(sqlStatement, { logger: options.logger });
+      let result        = await this.query(sqlStatement, options);
 
       if (!result.rows || result.rows.length === 0)
         break;
@@ -830,6 +856,50 @@ class SQLConnectionBase extends ConnectionBase {
   async enableForeignKeyConstraints(enable) {
     throw new Error(`${this.constructor.name}::enableForeignKeyConstraints: This operation is not supported for this connection type.`);
   }
+
+  // Define operations
+
+  async defineTable() {
+    throw new Error(`${this.constructor.name}::defineTable: This operation is not supported for this connection type.`);
+  }
+
+  async defineConstraints() {
+    throw new Error(`${this.constructor.name}::defineConstraints: This operation is not supported for this connection type.`);
+  }
+
+  async defineIndexes() {
+    throw new Error(`${this.constructor.name}::defineIndexes: This operation is not supported for this connection type.`);
+  }
+
+  // Alter operations
+
+  async renameTable() {
+    throw new Error(`${this.constructor.name}::renameTable: This operation is not supported for this connection type.`);
+  }
+
+  async renameColumn() {
+    throw new Error(`${this.constructor.name}::renameColumn: This operation is not supported for this connection type.`);
+  }
+
+  async dropColumn() {
+    throw new Error(`${this.constructor.name}::dropColumn: This operation is not supported for this connection type.`);
+  }
+
+  async alterColumn() {
+    throw new Error(`${this.constructor.name}::alterColumn: This operation is not supported for this connection type.`);
+  }
+
+  async addColumn() {
+    throw new Error(`${this.constructor.name}::addColumn: This operation is not supported for this connection type.`);
+  }
+
+  async addConstraint() {
+    throw new Error(`${this.constructor.name}::addConstraint: This operation is not supported for this connection type.`);
+  }
+
+  async addIndex() {
+    throw new Error(`${this.constructor.name}::addIndex: This operation is not supported for this connection type.`);
+  }
 }
 
 module.exports = SQLConnectionBase;

package/lib/sql-query-generator-base.js

@@ -117,7 +117,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
   }
 
   // eslint-disable-next-line no-unused-vars
-  generateSelectQueryOperatorFromQueryEngineOperator(operator, value, valueIsReference, options) {
+  generateSelectQueryOperatorFromQueryEngineOperator(queryPart, operator, value, valueIsReference, options) {
     if (LiteralBase.isLiteral(operator))
       return operator.toString(this.connection);
 
@@ -148,11 +148,36 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
         return '<';
       case 'LTE':
         return '<=';
+      case 'LIKE':
+        if (valueIsReference)
+          throw new TypeError(`${this.constructor.name}::generateSelectQueryOperatorFromQueryEngineOperator: The "LIKE" operator can not be used for table joins.`);
+
+        if (!Nife.instanceOf(value, 'string'))
+          throw new TypeError(`${this.constructor.name}::generateSelectQueryOperatorFromQueryEngineOperator: The "LIKE" operator requires a string for a value.`);
+
+        return 'LIKE';
+      case 'NOT_LIKE':
+        if (valueIsReference)
+          throw new TypeError(`${this.constructor.name}::generateSelectQueryOperatorFromQueryEngineOperator: The "NOT LIKE" operator can not be used for table joins.`);
+
+        if (!Nife.instanceOf(value, 'string'))
+          throw new TypeError(`${this.constructor.name}::generateSelectQueryOperatorFromQueryEngineOperator: The "NOT LIKE" operator requires a string for a value.`);
+
+        return 'NOT LIKE';
       default:
         throw new Error(`${this.constructor.name}::generateSelectQueryOperatorFromQueryEngineOperator: Unknown operator "${operator}".`);
     }
   }
 
+  formatLikeValue({ value }) {
+    return value;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  generateConditionPostfix(context) {
+    return '';
+  }
+
   generateSelectQueryCondition(queryPart, _value, options) {
     let value     = _value;
     let field     = queryPart.Field;
@@ -162,6 +187,9 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     // If the value is an array, then handle the
     // special "IN" case for an array
     if (Array.isArray(value)) {
+      if (operator !== 'EQ' && operator !== 'NEQ')
+        throw new Error(`${this.constructor.name}::generateSelectQueryCondition: Invalid value provided to operator "${operator}": `, value);
+
       // Flatten array, filter down to
       // only unique items, and remove
       // anything that we can't match on
@@ -200,7 +228,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
     let escapedTableName  = this.escapeID(this.getTableNameFromQueryPart(queryPart));
     let escapedColumnName = this.escapeID(field.columnName);
-    let sqlOperator       = this.generateSelectQueryOperatorFromQueryEngineOperator(operator, value, false, options);
+    let sqlOperator       = this.generateSelectQueryOperatorFromQueryEngineOperator(queryPart, operator, value, false, options);
 
     if (QueryEngine.isQuery(value)) {
       if (!this.queryHasConditions(value._getRawQuery()))
@@ -214,7 +242,13 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       return `${escapedTableName}.${escapedColumnName} ${sqlOperator} (${this.generateSelectStatement(value, this.stackAssign(options, { isSubQuery: true }))})`;
     }
 
-    return `${escapedTableName}.${escapedColumnName} ${sqlOperator} ${this.escape(field, value)}`;
+    let context = { queryPart, field, sqlOperator, operator, value };
+    if (sqlOperator === 'LIKE' || sqlOperator === 'NOT LIKE')
+      value = this.formatLikeValue(context);
+
+    let conditionPostfix = this.generateConditionPostfix(context);
+
+    return `${escapedTableName}.${escapedColumnName} ${sqlOperator} ${this.escape(field, value)}${(conditionPostfix) ? ` ${conditionPostfix}` : ''}`;
   }
 
   // eslint-disable-next-line no-unused-vars
@@ -231,7 +265,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     let leftSideEscapedColumnName   = this.escapeID(leftField.columnName);
     let rightSideEscapedTableName   = this.escapeID(this.getTableNameFromQueryPart(rightQueryPart));
     let rightSideEscapedColumnName  = this.escapeID(rightField.columnName);
-    let sqlOperator                 = this.generateSelectQueryOperatorFromQueryEngineOperator(operator, undefined, true, options);
+    let sqlOperator                 = this.generateSelectQueryOperatorFromQueryEngineOperator(leftQueryPart, operator, undefined, true, options);
 
     return `${leftSideEscapedTableName}.${leftSideEscapedColumnName} ${sqlOperator} ${rightSideEscapedTableName}.${rightSideEscapedColumnName}`;
   }
@@ -1112,6 +1146,10 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
     return `RETURNING ${returnFields.join(',')}`;
   }
+
+  toConnectionString(queryEngine, options) {
+    return this.generateSelectStatement(queryEngine, options);
+  }
 }
 
 module.exports = SQLQueryGeneratorBase;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix-orm-sql-base",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "SQL base support for Mythix ORM",
   "main": "lib/index.js",
   "type": "commonjs",
@@ -33,7 +33,7 @@
   },
   "homepage": "https://github.com/th317erd/mythix-orm-sql-base#readme",
   "peerDependencies": {
-    "mythix-orm": "^1.3.0"
+    "mythix-orm": "^1.4.4"
   },
   "dependencies": {
     "nife": "^1.11.3",