mythix-orm-sql-base 1.4.8 → 1.5.1

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './sql-connection-base';
+export { default as SQLConnectionBase } from './sql-connection-base';
+export * from './sql-query-generator-base';
+export { default as SQLQueryGeneratorBase } from './sql-query-generator-base';

package/lib/sql-connection-base.d.ts

@@ -0,0 +1,36 @@
+import { ConnectionBase, Field, ModelClass, QueryEngine, QueryResults, Model } from 'mythix-orm';
+import { GenericObject } from 'mythix-orm/lib/interfaces/common';
+
+export declare interface ModelDataFromQueryResults {
+  [ key: string ]: Array<GenericObject>;
+}
+
+declare class SQLConnectionBase extends ConnectionBase {
+  public prepareArrayValuesForSQL(array: Array<any>): Array<any>;
+  public generateSavePointName(): string;
+
+  public findAllFieldsFromFieldProjectionMap(
+    projectionFieldMap: Map<string, string> | Array<string>
+  ): Array<Field>;
+
+  public buildModelDataMapFromSelectResults(
+    queryEngine: QueryEngine,
+    result: QueryResults
+  ): ModelDataFromQueryResults;
+
+  public enableForeignKeyConstraints(enable: boolean): Promise<void>;
+
+  buildModelsFromModelDataMap(
+    queryEngine: QueryEngine,
+    modelDataMap: ModelDataFromQueryResults,
+    callback: (Model: ModelClass, model: Model) => Model,
+  ): Array<Model>;
+
+  updateModelsFromResults(
+    Model: ModelClass,
+    storedModels: Array<Model>,
+    results: QueryResults
+  ): Array<Model>;
+}
+
+export default SQLConnectionBase;

package/lib/sql-connection-base.js

@@ -14,57 +14,6 @@ const SAVE_POINT_NAME_CHARS = [ 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P'
 const MODEL_RELATIONS       = Symbol.for('_mythixModelRelations');
 
 class SQLConnectionBase extends ConnectionBase {
-  static Literals = Literals;
-
-  static getLiteralClassByName(_name) {
-    if (!_name)
-      return;
-
-    let name = Nife.capitalize(_name.toLowerCase());
-
-    if (name === 'Literal')
-      return Literals.Literal;
-    else if (name === 'Base')
-      return Literals.LiteralBase;
-
-    return Literals[`${name}Literal`];
-  }
-
-  static Literal(name, ...args) {
-    const LiteralClass = this.getLiteralClassByName(name);
-    if (!LiteralClass)
-      throw new Error(`${this.constructor.name}::Literal: Unable to locate literal class for literal name "${name}".`);
-
-    let literal = new LiteralClass(...args);
-    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);
 
@@ -233,7 +182,7 @@ class SQLConnectionBase extends ConnectionBase {
             Object.defineProperties(rootModel, {
               [MODEL_RELATIONS]: {
                 writable:     true,
-                enumberable:  false,
+                enumerable:   false,
                 configurable: true,
                 value:        {},
               },
@@ -251,6 +200,11 @@ class SQLConnectionBase extends ConnectionBase {
     return modelData;
   }
 
+  // eslint-disable-next-line no-unused-vars
+  async enableForeignKeyConstraints(enable) {
+    throw new Error(`${this.constructor.name}::enableForeignKeyConstraints: This operation is not supported for this connection type.`);
+  }
+
   buildModelsFromModelDataMap(queryEngine, modelDataMap, callback) {
     if (Nife.isEmpty(modelDataMap))
       return [];
@@ -325,30 +279,7 @@ class SQLConnectionBase extends ConnectionBase {
     return storedModels;
   }
 
-  async runSaveHooks(Model, models, operationHookName, saveHookName, options) {
-    const throwError = (error) => {
-      throw error;
-    };
-
-    let promises  = [];
-    let context   = { connection: this, Model, options };
-
-    for (let i = 0, il = models.length; i < il; i++) {
-      let model   = models[i];
-      let promise = model[operationHookName](context);
-
-      if (!Nife.instanceOf(promise, 'promise'))
-        promise = Promise.resolve(promise);
-
-      promise = promise.then(async () => await model[saveHookName](context), throwError);
-      if (!Nife.instanceOf(promise, 'promise'))
-        promise = Promise.resolve(promise);
-
-      promises.push(promise);
-    }
-
-    await Promise.all(promises);
-  }
+  // --------------------------------------------- //
 
   async dropTable(Model, options) {
     let queryGenerator  = this.getQueryGenerator();
@@ -358,42 +289,6 @@ class SQLConnectionBase extends ConnectionBase {
     return await this.query(createTableSQL, options);
   }
 
-  async dropTables(_Models, options) {
-    if (!_Models)
-      return;
-
-    // First we collect all models and put them into a map
-    let modelMap = _Models;
-
-    if (Nife.instanceOf(_Models, 'array', 'function')) {
-      modelMap = {};
-
-      let Models = Nife.toArray(_Models).filter(Boolean);
-      for (let i = 0, il = Models.length; i < il; i++) {
-        let Model     = Models[i];
-        let modelName = Model.getModelName();
-
-        modelMap[modelName] = Model;
-      }
-    }
-
-    // Second we sort the model names in creation order,
-    // and going in reverse of that order we destroy
-    // each table.
-    let modelNames        = Object.keys(modelMap);
-    let sortedModelNames  = Utils.sortModelNamesByCreationOrder(this, modelNames);
-    let results           = [];
-
-    for (let i = sortedModelNames.length - 1; i >= 0; i--) {
-      let modelName = sortedModelNames[i];
-      let Model     = modelMap[modelName];
-
-      results.push(await this.dropTable(Model, options));
-    }
-
-    return results;
-  }
-
   async createTable(Model, options) {
     let queryGenerator  = this.getQueryGenerator();
     let createTableSQL  = queryGenerator.generateCreateTableStatement(Model, options);
@@ -413,41 +308,6 @@ class SQLConnectionBase extends ConnectionBase {
     return result;
   }
 
-  async createTables(_Models, options) {
-    if (!_Models)
-      return;
-
-    // First we collect all models and put them into a map
-    let modelMap = _Models;
-
-    if (Nife.instanceOf(_Models, 'array', 'function')) {
-      modelMap = {};
-
-      let Models = Nife.toArray(_Models).filter(Boolean);
-      for (let i = 0, il = Models.length; i < il; i++) {
-        let Model     = Models[i];
-        let modelName = Model.getModelName();
-
-        modelMap[modelName] = Model;
-      }
-    }
-
-    // Second we sort the model names in creation order,
-    // and then create the tables in that order
-    let modelNames        = Object.keys(modelMap);
-    let sortedModelNames  = Utils.sortModelNamesByCreationOrder(this, modelNames);
-    let results           = [];
-
-    for (let i = 0, il = sortedModelNames.length; i < il; i++) {
-      let modelName = sortedModelNames[i];
-      let Model     = modelMap[modelName];
-
-      results.push(await this.createTable(Model, options));
-    }
-
-    return results;
-  }
-
   async insert(Model, models, _options) {
     return await this.bulkModelOperation(
       Model,
@@ -860,55 +720,6 @@ class SQLConnectionBase extends ConnectionBase {
     let count = await this.count(queryEngine, null, options);
     return (count > 0);
   }
-
-  // eslint-disable-next-line no-unused-vars
-  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.d.ts

@@ -0,0 +1,181 @@
+import { Field, FieldOrderInfo, JoinTableInfo, Model, ModelClass, PreparedModels, QueryEngine, QueryGeneratorBase } from 'mythix-orm';
+import { LiteralBase } from 'mythix-orm/lib/connection/literals';
+import { GenericObject } from 'mythix-orm/lib/interfaces/common';
+import { Type } from 'mythix-orm/lib/types';
+
+export declare interface QueryConditionContext {
+  queryPart: GenericObject;
+  field: Field;
+  sqlOperator: string;
+  operator: string | LiteralBase;
+  value: any;
+}
+
+declare class SQLQueryGeneratorBase extends QueryGeneratorBase {
+  public prepareArrayValuesForSQL(array: Array<any>): Array<any>;
+  public parseFieldProjection(value: string, getRawField: boolean): string | Field | undefined;
+  public parseFieldProjectionToFieldMap(selectStatement: string): Map<string, Field | string>;
+
+  public generateSelectQueryFieldProjection(
+    queryEngine: QueryEngine,
+    options?: GenericObject,
+    asMap?: false | undefined,
+  ): Array<string>;
+
+  public generateSelectQueryFieldProjection(
+    queryEngine: QueryEngine,
+    options?: GenericObject,
+    asMap?: true,
+  ): Map<string, string>;
+
+  public generateSelectQueryOperatorFromQueryEngineOperator(
+    queryPart: GenericObject,
+    operator: string | LiteralBase,
+    value: any,
+    valueIsReference: boolean,
+    options?: GenericObject,
+  ): string;
+
+  public formatLikeValue(context: QueryConditionContext): any;
+  public generateConditionPostfix(context: QueryConditionContext): string;
+
+  public generateSelectQueryCondition(
+    queryPart: GenericObject,
+    value: any,
+    options?: GenericObject,
+  ): string;
+
+  public generateFromTableOrTableJoin(
+    Model: ModelClass,
+    joinType: string | LiteralBase,
+    options?: GenericObject
+  ): string;
+
+  public generateSelectJoinOnTableQueryCondition(
+    leftQueryPart: GenericObject,
+    rightQueryPart: GenericObject,
+    leftField: Field,
+    rightField: Field,
+    operator: string | LiteralBase,
+    options?: GenericObject,
+  ): string;
+
+  public generateJoinOnTableQueryConditions(
+    joinInfos: Array<JoinTableInfo>,
+    options?: GenericObject
+  ): string;
+
+  public generateSQLJoinTypeFromQueryEngineJoinType(joinType: LiteralBase, outer: boolean, options?: GenericObject): LiteralBase;
+  public generateSQLJoinTypeFromQueryEngineJoinType(joinType: string, outer: boolean, options?: GenericObject): string;
+  public sortJoinRelationOrder(joins: Map<string, Array<JoinTableInfo>>): Array<string>;
+  public generateSelectQueryJoinTables(queryEngine: QueryEngine, options?: GenericObject): string;
+  public generateSelectWhereConditions(queryEngine: QueryEngine, options?: GenericObject): string;
+  public generateOrderClause(
+    orders: LiteralBase | FieldOrderInfo | Array<LiteralBase | FieldOrderInfo>,
+    options?: GenericObject
+  ): string;
+
+  public generateLimitClause(limit: LiteralBase | number | string, options?: GenericObject): string;
+  public generateOffsetClause(offset: LiteralBase | number | string, options?: GenericObject): string;
+  public generateSelectOrderLimitOffset(queryEngine: QueryEngine, options?: GenericObject): string;
+  public generateWhereAndOrderLimitOffset(queryEngine: QueryEngine, options?: GenericObject): string;
+
+  public generateSelectStatement(
+    queryEngine: QueryEngine,
+    options?: GenericObject
+  ): string | { sql: string, projectionFields: Map<string, string> };
+
+  public getFieldDefaultValue(
+    field: Field,
+    fieldName: string,
+    options?: GenericObject,
+  ): string | LiteralBase | undefined;
+
+  public generateIndexName(
+    Model: ModelClass,
+    field: Field,
+    index: string | true,
+    options?: GenericObject
+  ): string;
+
+  public generateColumnIndexes(
+    Model: ModelClass,
+    field: Field,
+    indexes: string | boolean | Array<string | boolean | Array<string>>,
+    options?: GenericObject,
+  ): Array<string>;
+
+  public generateDropTableStatement(Model: ModelClass, options?: GenericObject): string;
+  public generateForeignKeyConstraint(field: Field, type: Type, options?: GenericObject): string;
+  public generateCreateTableStatementInnerTail(Model: ModelClass, options?: GenericObject): Array<string>;
+  public generateCreateTableStatementOuterTail(Model: ModelClass, options?: GenericObject): Array<string>;
+  public generateCreateTableStatement(Model: ModelClass, options?: GenericObject): string;
+
+  public generateInsertFieldValuesFromModel(
+    model: Model,
+    options?: GenericObject
+  ): { modelChanges: GenericObject, rowValues: string } | undefined;
+
+  public generateInsertValuesFromModels(
+    Model: ModelClass,
+    models: Model | Array<Model> | PreparedModels,
+    options?: GenericObject,
+  ): { modelChanges: Array<GenericObject>, values: string } | undefined;
+
+  public generateInsertStatementTail(
+    Model: ModelClass,
+    model: Model,
+    options: GenericObject,
+    context: {
+      escapedTableName: string,
+      modelChanges: Array<GenericObject>,
+      dirtyFields: Array<Field>,
+    },
+  ): string | undefined;
+
+  public generateInsertStatement(
+    Model: ModelClass,
+    models: Model | Array<Model> | PreparedModels,
+    options?: GenericObject,
+  ): string;
+
+  public generateUpdateStatementTail(
+    Model: ModelClass,
+    model: Model | GenericObject,
+    queryEngine: QueryEngine,
+    options: GenericObject,
+    context: {
+      queryEngine: QueryEngine,
+      escapedTableName: string,
+      modelChanges: Array<GenericObject>,
+      dirtyFields: Array<Field>,
+      where: string,
+    },
+  ): string | undefined;
+
+  public generateUpdateStatement(
+    Model: ModelClass,
+    model: Model | GenericObject,
+    queryEngine: QueryEngine,
+    options?: GenericObject,
+  ): string;
+
+  public generateDeleteStatement(Model: ModelClass, queryEngine: QueryEngine, options?: GenericObject): string;
+  public generateTruncateTableStatement(Model: ModelClass, options?: GenericObject): string;
+
+  public _collectRemoteReturningFields(Model: ModelClass): Array<string>;
+  public _collectReturningFields(
+    Model: ModelClass,
+    model: Model,
+    options: GenericObject,
+    context: {
+      escapedTableName: string,
+      modelChanges: Array<GenericObject>,
+      dirtyFields: Array<Field>,
+    },
+  ): string | undefined;
+
+  toConnectionString(queryEngine: QueryEngine, options?: GenericObject): string;
+}
+
+export default SQLQueryGeneratorBase;

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

@@ -14,8 +14,8 @@ const DefaultHelpers  = Types.DefaultHelpers;
 const LiteralBase     = Literals.LiteralBase;
 
 class SQLQueryGeneratorBase extends QueryGeneratorBase {
-  prepareArrayValuesForSQL(...args) {
-    return this.connection.prepareArrayValuesForSQL(...args);
+  prepareArrayValuesForSQL(array) {
+    return this.connection.prepareArrayValuesForSQL(array);
   }
 
   parseFieldProjection = (str, getRawField) => {
@@ -247,11 +247,15 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
   }
 
   // eslint-disable-next-line no-unused-vars
-  generateFromTableOrTableJoin(Model, joinType, options) {
+  generateFromTableOrTableJoin(Model, _joinType, options) {
     if (!Model)
       throw new Error(`${this.constructor.name}::generateFromTableOrTableJoin: No valid model provided.`);
 
     let escapedTableName = this.getEscapedTableName(Model, options);
+    let joinType = _joinType;
+    if (joinType && LiteralBase.isLiteral(joinType))
+      joinType = joinType.toString(this.connection);
+
     return (joinType) ? `${joinType} ${escapedTableName}` : `FROM ${escapedTableName}`;
   }
 
@@ -863,7 +867,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
   generateInsertFieldValuesFromModel(model, _options) {
     if (!model)
-      return '';
+      return;
 
     let options       = _options || {};
     let sqlParts      = [];
@@ -871,7 +875,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     let dirtyFields   = model._getDirtyFields({ insert: true });
 
     if (dirtyFields && Object.keys(dirtyFields).length === 0)
-      return '';
+      return;
 
     model.iterateFields(
       ({ field, fieldName }) => {
@@ -912,7 +916,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     let allModelChanges         = [];
 
     if (Nife.isEmpty(models))
-      return '';
+      return;
 
     let sqlParts    = [];
     let subOptions  = this.stackAssign(options, { dirtyFields });
@@ -1182,6 +1186,12 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     return `RETURNING ${returnFields.join(',')}`;
   }
 
+  // eslint-disable-next-line no-unused-vars
+  generateTruncateTableStatement(Model, _options) {
+    let escapedTableName = this.escapeID(Model.getTableName(this.connection));
+    return `TRUNCATE TABLE ${escapedTableName}`;
+  }
+
   toConnectionString(queryEngine, options) {
     return this.generateSelectStatement(queryEngine, options);
   }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "mythix-orm-sql-base",
-  "version": "1.4.8",
+  "version": "1.5.1",
   "description": "SQL base support for Mythix ORM",
-  "main": "lib/index.js",
+  "main": "lib/index",
   "type": "commonjs",
   "scripts": {
     "coverage": "clear ; node ./node_modules/.bin/nyc ./node_modules/.bin/jasmine",
@@ -33,17 +33,17 @@
   },
   "homepage": "https://github.com/th317erd/mythix-orm-sql-base#readme",
   "peerDependencies": {
-    "mythix-orm": "^1.5.6"
+    "mythix-orm": "^1.6.2"
   },
   "dependencies": {
-    "nife": "^1.11.3",
-    "uuid": "^8.3.2"
+    "nife": "^1.12.1",
+    "uuid": "^9.0.0"
   },
   "devDependencies": {
     "@spothero/eslint-plugin-spothero": "github:spothero/eslint-plugin-spothero",
     "better-sqlite3": "^7.6.2",
-    "eslint": "^8.13.0",
-    "jasmine": "^4.3.0",
+    "eslint": "^8.23.1",
+    "jasmine": "^4.4.0",
     "moment": "^2.29.4",
     "nyc": "^15.1.0"
   },