mythix-orm 1.5.5 → 1.6.1

package/lib/connection/literals/literal-base.d.ts

@@ -0,0 +1,22 @@
+import Field from '../../field';
+import { GenericObject } from '../../interfaces/common';
+import { FullyQualifiedFieldDefinition } from '../../utils/model-utils';
+import ConnectionBase from '../connection-base';
+
+declare class LiteralBase {
+  declare public static _isMythixLiteral: boolean;
+
+  public static isLiteralClass(value: any): boolean;
+  public static isLiteral(value: any): boolean;
+  public static isLiteralType(value: any): boolean;
+
+  public constructor(literal: any, options?: GenericObject);
+  public fullyQualifiedNameToDefinition(fullyQualifiedName: LiteralBase | string | Field): LiteralBase | FullyQualifiedFieldDefinition;
+  public definitionToField(connection, definition): LiteralBase | Field;
+  public toString(connection: ConnectionBase, options?: GenericObject): string;
+
+  declare public literal: any;
+  declare public options: GenericObject;
+}
+
+export default LiteralBase;

package/lib/connection/literals/literal-base.js

@@ -39,13 +39,13 @@ class LiteralBase {
     Object.defineProperties(this, {
       'literal': {
         writable:     true,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        literal,
       },
       'options': {
         writable:     true,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        options || {},
       },

package/lib/connection/literals/literal-field-base.d.ts

@@ -0,0 +1,17 @@
+import Field from '../../field';
+import { GenericObject } from '../../interfaces/common';
+import { FullyQualifiedFieldDefinition } from '../../utils/model-utils';
+import ConnectionBase from '../connection-base';
+import LiteralBase from './literal-base';
+
+declare class LiteralFieldBase extends LiteralBase {
+  public static isFieldRequired(): boolean;
+
+  public constructor(fullyQualifiedName: Field | string, options?: GenericObject);
+  getFullyQualifiedFieldName(): string | undefined;
+  getField(connection: ConnectionBase): Field | undefined;
+
+  declare public definition: FullyQualifiedFieldDefinition | undefined;
+}
+
+export default LiteralFieldBase;

package/lib/connection/literals/literal-field-base.js

@@ -8,8 +8,8 @@ class LiteralFieldBase extends LiteralBase {
     return true;
   }
 
-  constructor(fullyQualifiedName) {
-    super();
+  constructor(fullyQualifiedName, options) {
+    super(undefined, options);
 
     let isRequired = this.constructor.isFieldRequired();
     let definition;
@@ -26,7 +26,7 @@ class LiteralFieldBase extends LiteralBase {
     Object.defineProperties(this, {
       'definition': {
         writable:     true,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        definition,
       },
@@ -43,7 +43,7 @@ class LiteralFieldBase extends LiteralBase {
 
   getField(connection) {
     if (!this.definition)
-      return null;
+      return;
 
     return this.definitionToField(connection, this.definition);
   }

package/lib/connection/literals/literal.d.ts

@@ -0,0 +1,5 @@
+import LiteralBase from './literal-base';
+
+declare class Literal extends LiteralBase { }
+
+export default Literal;

package/lib/connection/literals/max-literal.d.ts

@@ -0,0 +1,5 @@
+import LiteralFieldBase from './literal-field-base';
+
+declare class MaxLiteral extends LiteralFieldBase { }
+
+export default MaxLiteral;

package/lib/connection/literals/min-literal.d.ts

@@ -0,0 +1,5 @@
+import LiteralFieldBase from './literal-field-base';
+
+declare class MinLiteral extends LiteralFieldBase { }
+
+export default MinLiteral;

package/lib/connection/literals/sum-literal.d.ts

@@ -0,0 +1,5 @@
+import LiteralFieldBase from './literal-field-base';
+
+declare class SumLiteral extends LiteralFieldBase { }
+
+export default SumLiteral;

package/lib/connection/query-generator-base.d.ts

@@ -0,0 +1,121 @@
+import Field from '../field';
+import { GenericObject } from '../interfaces/common';
+import { ModelClass } from '../model';
+import { QueryEngine } from '../query-engine';
+import ConnectionBase from './connection-base';
+import { AverageLiteral, CountLiteral, DistinctLiteral, FieldLiteral, MaxLiteral, MinLiteral, SumLiteral } from './literals';
+import LiteralBase from './literals/literal-base';
+
+export declare interface GetEscapedFieldNameOptions {
+  fieldNameOnly?: boolean;
+}
+
+export declare interface GetEscapedTableNameNameOptions {
+  tableNamePrefix?: string;
+}
+
+export declare interface GetEscapedColumnNameOptions extends GetEscapedTableNameNameOptions {
+  columnNamePrefix?: string
+  columnNameOnly?: boolean;
+}
+
+export declare interface GetEscapedProjectionNameOptions extends GetEscapedColumnNameOptions, GetEscapedFieldNameOptions {
+  noProjectionAliases?: boolean;
+}
+
+export declare interface GetEscapedModelFieldsOptions extends GetEscapedProjectionNameOptions {
+  asProjection?: boolean;
+  asColumn?: boolean;
+}
+
+export declare interface ProjectedFieldInfo {
+  projectedName: string;
+  Model: ModelClass;
+  modelName: string;
+  Field: Field;
+  fieldName: string;
+  direction: string;
+  fullFieldName: string;
+}
+
+export declare interface JoinTableInfo {
+  operator: string;
+  joinType: string | LiteralBase;
+  rootModelName: string;
+  joinModel: ModelClass;
+  joinModelName: string;
+  leftSideModel: ModelClass;
+  leftSideModelName: string;
+  leftQueryContext: GenericObject;
+  leftSideField: Field;
+  rightSideModel: ModelClass;
+  rightSideModelName: string;
+  rightQueryContext: GenericObject;
+  rightSideField: Field;
+}
+
+export declare interface FieldDirectionInfo {
+  hasDirection: boolean;
+  direction: string;
+  fieldName: string;
+}
+
+export declare interface FieldOrderInfo {
+  Model: ModelClass;
+  Field: Field;
+  direction: string;
+}
+
+declare class QueryGeneratorBase {
+  public constructor(connection);
+  public stackAssign(obj: GenericObject, ...args: Array<GenericObject>): GenericObject;
+  public getOptionsCache(options: GenericObject, keyPath: string, initialValue: any): any;
+  public setOptionsCache(options: GenericObject, keyPath: string, value: any): void;
+  public escape(field: Field, value: any, options?: GenericObject): string;
+  public escapeID(value: LiteralBase | string, options?: GenericObject): string;
+  public getEscapedFieldName(Model: ModelClass | null | undefined, field: Field, options?: GetEscapedFieldNameOptions): string;
+  public getEscapedColumnName(Model: ModelClass | null | undefined, field: Field, options?: GetEscapedColumnNameOptions): string;
+  public getEscapedTableName(modelOrField: ModelClass | Field, options?: GetEscapedTableNameNameOptions): string;
+  public getEscapedProjectionName(Model: ModelClass | null | undefined, field: Field, options?: GetEscapedProjectionNameOptions): string;
+  public getEscapedModelFields(Model: ModelClass, options?: GetEscapedModelFieldsOptions): { [ key: string ]: string };
+  public getAllModelsUsedInQuery(queryEngine: QueryEngine, options?: GenericObject): Array<ModelClass>;
+  public getProjectionRequiredFields(queryEngine: QueryEngine, options?: GenericObject): Map<string, ProjectedFieldInfo>;
+  public sortedProjectedFields(projectedFields: Array<LiteralBase | string>, options?: GenericObject): Array<LiteralBase | string>;
+  public getProjectionFromQueryEngine(queryEngine: QueryEngine, options?: GenericObject): Array<LiteralBase | string | ProjectedFieldInfo>;
+  public isFieldIdentifier(value: string): boolean;
+  public getProjectedFields(queryEngine: QueryEngine, options?: GenericObject, asMap?: false | undefined): Array<string>;
+  public getProjectedFields(queryEngine: QueryEngine, options?: GenericObject, asMap?: true): Map<string, string>;
+
+  public getJoinTableInfoFromQueryContexts(
+    leftQueryContext: GenericObject,
+    rightQueryContext: GenericObject,
+    joinType: string | LiteralBase,
+    options?: GenericObject
+  ): JoinTableInfo;
+
+  public getFieldDirectionSpecifier(order: LiteralBase): LiteralBase;
+  public getFieldDirectionSpecifier(order: string | Field): FieldDirectionInfo;
+
+  public getOrderLimitOffset(
+    queryEngine: QueryEngine,
+    options?: GenericObject,
+  ): {
+    limit: number | undefined,
+    offset: number | undefined,
+    order: Array<FieldOrderInfo>,
+  };
+
+  public getQuerySliceFromQueryPart(queryPart: GenericObject): Array<GenericObject>;
+  public _averageLiteralToString(literal: AverageLiteral, options?: GenericObject): string;
+  public _countLiteralToString(literal: CountLiteral, options?: GenericObject): string;
+  public _distinctLiteralToString(literal: DistinctLiteral, options?: GenericObject): string;
+  public _fieldLiteralToString(literal: FieldLiteral, options?: GenericObject): string;
+  public _maxLiteralToString(literal: MaxLiteral, options?: GenericObject): string;
+  public _minLiteralToString(literal: MinLiteral, options?: GenericObject): string;
+  public _sumLiteralToString(literal: SumLiteral, options?: GenericObject): string;
+  public toConnectionString(queryEngine: QueryEngine, options?: GenericObject): string;
+
+  declare public connection: ConnectionBase;
+}
+
+export default QueryGeneratorBase;

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

@@ -1,10 +1,9 @@
 'use strict';
 
-const Nife        = require('nife');
-const QueryEngine = require('../query-engine/query-engine');
-const Literals    = require('./literals');
-const ModelBase   = require('../model');
-
+const Nife                    = require('nife');
+const QueryEngine             = require('../query-engine/query-engine');
+const Literals                = require('./literals');
+const { Model: ModelBase }    = require('../model');
 const LiteralBase             = Literals.LiteralBase;
 const LITERAL_IS_DISTINCT_RE  = (/^DISTINCT[\s(]/i);
 
@@ -13,7 +12,7 @@ class QueryGeneratorBase {
     Object.defineProperties(this, {
       'connection': {
         writable:     true,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        connection,
       },
@@ -46,11 +45,6 @@ class QueryGeneratorBase {
     return this.connection.escapeID(...args);
   }
 
-  getTableNameFromQueryPart(queryPart) {
-    let Model = queryPart.Model;
-    return Model.getTableName(this.connection);
-  }
-
   getEscapedFieldName(_Model, field, options) {
     let isString  = Nife.instanceOf(field, 'string');
     let fieldName = (isString) ? field : field.fieldName;
@@ -73,10 +67,23 @@ class QueryGeneratorBase {
     if (!Model && field && !isString)
       Model = field.Model;
 
+    if (options && options.columnNamePrefix)
+      columnName = `${options.columnNamePrefix}${columnName}`;
+
     if (!Model || (options && options.columnNameOnly === true))
       return this.escapeID(columnName);
     else
-      return `${this.escapeID(Model.getTableName(this.connection))}.${this.escapeID(columnName)}`;
+      return `${this.getEscapedTableName(Model)}.${this.escapeID(columnName)}`;
+  }
+
+  getEscapedTableName(_modelOrField, options) {
+    let Model     = (_modelOrField.Model) ? _modelOrField.Model : _modelOrField;
+    let tableName = Model.getTableName(this.connection);
+
+    if (options && options.tableNamePrefix)
+      tableName = `${options.tableNamePrefix}${tableName}`;
+
+    return this.escapeID(tableName);
   }
 
   // eslint-disable-next-line no-unused-vars
@@ -361,7 +368,8 @@ class QueryGeneratorBase {
       let projectedFields = _projectedFields;
       let result;
 
-      if (options && options.isSubQuery) {
+      let subQueryOperator = (options && options.subQueryOperator);
+      if (options && options.isSubQuery && !(subQueryOperator === 'EXISTS' || subQueryOperator === 'NOT EXISTS')) {
         // If we are sub-selecting then only one
         // field in the projection is allowed
 
@@ -773,19 +781,6 @@ class QueryGeneratorBase {
     return orderLimitOffset;
   }
 
-  queryHasConditions(query) {
-    for (let i = 0, il = query.length; i < il; i++) {
-      let queryPart = query[i];
-      if (!Object.prototype.hasOwnProperty.call(queryPart, 'condition'))
-        continue;
-
-      if (queryPart.condition === true)
-        return true;
-    }
-
-    return false;
-  }
-
   getQuerySliceFromQueryPart(queryPart) {
     let queryRoot = queryPart.queryRoot;
     let index     = queryRoot.indexOf(queryPart);
@@ -838,6 +833,17 @@ class QueryGeneratorBase {
     return `DISTINCT ${this.getEscapedProjectionName(field.Model, field, this.stackAssign(options, literal.options))}`;
   }
 
+  _fieldLiteralToString(literal, options) {
+    if (!literal || !LiteralBase.isLiteral(literal))
+      return;
+
+    let field = literal.getField(this.connection);
+    if (LiteralBase.isLiteral(field))
+      return field.toString(this.connection, options);
+
+    return this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
+  }
+
   _maxLiteralToString(literal, options) {
     if (!literal || !LiteralBase.isLiteral(literal))
       return;

package/lib/field.d.ts

@@ -0,0 +1,61 @@
+import ConnectionBase from './connection/connection-base';
+import { GenericObject } from './interfaces/common';
+import { Model, ModelClass } from './model';
+import Type from './types/type';
+import { DefaultValueProvider } from './types/helpers/default-helpers';
+
+export declare interface GetSetContext {
+  field: Field;
+  fieldName: string;
+  get: () => any;
+  set: (value: any) => void;
+  self: Model;
+  value: any;
+}
+
+export declare interface ValidateContext {
+  connection: ConnectionBase;
+  Model: ModelClass;
+  options: GenericObject;
+  self: Model;
+}
+
+export declare interface FieldDefinition {
+  type: Type;
+  primaryKey: boolean;
+  fieldName: string;
+  columnName: string;
+  allowNull: boolean;
+  index: boolean | Array<boolean | string | Array<string>>;
+  unique: boolean;
+  defaultValue: any | DefaultValueProvider;
+  get: ((context: GetSetContext) => any) | undefined;
+  set: ((context: GetSetContext) => void) | undefined;
+  validate: (value: any, context: ValidateContext) => Promise<any> | any;
+}
+
+declare class Field {
+  declare public static _isMythixField: boolean;
+
+  public static isFieldClass(value: any): boolean;
+  public static isField(value: any): boolean;
+
+  public constructor(fieldDefinition?: Field | FieldDefinition);
+  public clone(): Field;
+  public setModel(Model: ModelClass): void;
+
+  declare public Model: ModelClass;
+  declare public type: Type;
+  declare public primaryKey: boolean;
+  declare public fieldName: string;
+  declare public columnName: string;
+  declare public allowNull: boolean;
+  declare public index: boolean | Array<boolean | string | Array<string>>;
+  declare public unique: boolean;
+  declare public defaultValue: any | DefaultValueProvider;
+  declare public get: ((context: GetSetContext) => any) | undefined;
+  declare public set: ((context: GetSetContext) => void) | undefined;
+  declare public validate: (value: any, context: ValidateContext) => Promise<any> | any;
+}
+
+export default Field;

package/lib/field.js

@@ -175,6 +175,7 @@ class Field {
   ///   `true` if the provided value is a <see>Field</see>
   ///    class, or inherits from <see>Field</see>. `false`
   ///    otherwise.
+  ///
   /// Arguments:
   ///   value: any
   ///     The value to check.
@@ -208,6 +209,7 @@ class Field {
   ///   `true` if the provided value is a <see>Field</see>
   ///    instance, or inherits from <see>Field</see>. `false`
   ///    otherwise.
+  ///
   /// Arguments:
   ///   value: any
   ///     The value to check.
@@ -232,10 +234,16 @@ class Field {
   /// the field attributes.
   ///
   /// Return: <see>Field</see>
+  ///
   /// Arguments:
   ///   fieldDescription: object | <see>Field</see>
   ///     The attributes to provide to this field.
   constructor(fieldDefinition) {
+    this.primaryKey = false;
+    this.allowNull = true;
+    this.index = false;
+    this.unique = false;
+
     Object.assign(this, fieldDefinition || {});
   }
 
@@ -252,6 +260,7 @@ class Field {
   /// for this field.
   ///
   /// Return: undefined
+  ///
   /// Arguments:
   ///   Model: class <see>Model</see>
   ///     The parent model class of this field.

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export * from './field';
+export { default as Field } from './field';
+export * from './model';
+export * as Types from './types';
+export * from './query-engine';
+export * as Utils from './utils';
+export * from './connection';

package/lib/index.js

@@ -2,7 +2,7 @@
 
 const Errors            = require('./errors');
 const Field             = require('./field');
-const Model             = require('./model');
+const _ModelScope       = require('./model');
 const ProxyClass        = require('./proxy-class');
 const QueryEngineScope  = require('./query-engine');
 const ConnectionScope   = require('./connection');
@@ -22,10 +22,16 @@ const {
   QueryGeneratorBase,
 } = ConnectionScope;
 
+const {
+  Model,
+  CacheKey,
+} = _ModelScope;
+
 module.exports = {
   Errors,
   Field,
   Model,
+  CacheKey,
   ProxyClass,
   Types,
   Utils,

package/lib/interfaces/common.ts

@@ -0,0 +1,3 @@
+export interface GenericObject {
+  [key: string]: any;
+};