mythix-orm 1.5.6 → 1.6.2

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,
       },

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;
+};

package/lib/model.d.ts

@@ -0,0 +1,205 @@
+import { GenericObject } from './interfaces/common';
+import ConnectionBase from './connection/connection-base';
+import Field, { FieldDefinition } from './field';
+import { QueryEngine, QueryEngineClass } from './query-engine/query-engine';
+
+export class CacheKey {
+  constructor(number: number);
+  valueOf(): number;
+}
+
+export declare interface ModelOptions extends GenericObject {
+  connection: ConnectionBase;
+}
+
+export declare type ModelClass = typeof Model;
+
+export declare interface Models {
+  [ key: string ]: ModelClass;
+}
+
+export declare interface HookContext {
+  connection: ConnectionBase;
+  Model: ModelClass;
+  options: GenericObject;
+}
+
+export declare interface DirtyChanges {
+  [ key: string ]: { previous: any; current: any };
+}
+
+export declare type LooseFields = Array<Field | FieldDefinition> | { [ key: string ]: Field | FieldDefinition } | Map<string, Field | FieldDefinition> | Set<Field | FieldDefinition>;
+export declare type Fields = Array<Field> | { [ key: string ]: Field } | Map<string, Field> | Set<Field>;
+
+export declare interface IterateFieldsContext {
+  field: Field;
+  fieldName: string;
+  fields: Fields;
+  index: number;
+  stop: () => void;
+  isStopped: () => boolean;
+}
+
+export declare type IterateFieldsCallback = (context: IterateFieldsContext) => any;
+
+export declare class Model {
+  declare public static fields: LooseFields | undefined;
+  declare public static _sortedFields: Array<Field> | null;
+  declare public static _isMythixModel: boolean;
+  declare public static _mythixBoundConnection: ConnectionBase | null;
+  declare public static where: QueryEngine;
+  declare public static $: QueryEngine;
+
+  public static isModelClass(value: any): boolean;
+  public static isModel(value: any): boolean;
+  public static toString(showFields: boolean): string;
+
+  public static _getConnection(connection?: ConnectionBase): ConnectionBase;
+  public _getConnection(connection?: ConnectionBase): ConnectionBase;
+
+  public static getConnection(connection?: ConnectionBase): ConnectionBase;
+  public getConnection(connection?: ConnectionBase): ConnectionBase;
+
+  public static bindConnection(connection: ConnectionBase): ModelClass;
+
+  public static getQueryEngineClass(connection?: ConnectionBase): QueryEngineClass;
+  public getQueryEngineClass(connection?: ConnectionBase): QueryEngineClass;
+
+  public static getUnscopedQueryEngine(connection?: ConnectionBase, options?: GenericObject): QueryEngine;
+  public getUnscopedQueryEngine(connection?: ConnectionBase, options?: GenericObject): QueryEngine;
+
+  public static defaultScope(query: QueryEngine): QueryEngine;
+  public defaultScope(query: QueryEngine): QueryEngine;
+
+  public static getQueryEngine(connection?: ConnectionBase, options?: GenericObject): QueryEngine;
+  public getQueryEngine(connection?: ConnectionBase, options?: GenericObject): QueryEngine;
+
+  public static getForeignKeyFieldsMap(connection?: ConnectionBase): Map<string, Array<{ targetFieldName: string, sourceFieldName: string }>>;
+  public getForeignKeyFieldsMap(connection?: ConnectionBase): Map<string, Array<{ targetFieldName: string, sourceFieldName: string }>>;
+
+  public static getForeignKeysTargetModels(connection?: ConnectionBase): Map<string, ModelClass>;
+  public getForeignKeysTargetModels(connection?: ConnectionBase): Map<string, ModelClass>;
+
+  public static getForeignKeysTargetModelNames(connection?: ConnectionBase): Array<string>;
+  public getForeignKeysTargetModelNames(connection?: ConnectionBase): Array<string>;
+
+  public static getForeignKeysTargetFieldNames(connection: ConnectionBase | null | undefined, modelName: string): Array<{ targetFieldName: string, sourceFieldName: string }>;
+  public getForeignKeysTargetFieldNames(connection: ConnectionBase | null | undefined, modelName: string): Array<{ targetFieldName: string, sourceFieldName: string }>;
+
+  public static getForeignKeysTargetField(connection: ConnectionBase | null | undefined, modelName: string, fieldName: string): { targetFieldName: string, sourceFieldName: string } | undefined;
+  public getForeignKeysTargetField(connection: ConnectionBase | null | undefined, modelName: string, fieldName: string): { targetFieldName: string, sourceFieldName: string } | undefined;
+
+  public static isForeignKeyTargetModel(connection: ConnectionBase | null | undefined, modelName: string): boolean;
+  public isForeignKeyTargetModel(connection: ConnectionBase | null | undefined, modelName: string): boolean;
+
+  public static getTableName(connection?: ConnectionBase): string;
+  public getTableName(connection?: ConnectionBase): string;
+
+  public static getModelName(): string;
+  public getModelName(): string;
+
+  public static getSingularName(): string;
+  public getSingularName(): string;
+
+  public static getPluralModelName(): string;
+  public getPluralModelName(): string;
+
+  public static getModel(modelName?: string): ModelClass | undefined;
+  public getModel(modelName?: string): ModelClass | undefined;
+
+  public static getFields(fieldNames?: Array<string>): Fields;
+  public getFields(fieldNames?: Array<string>): Fields;
+
+  public static getSortedFields(fieldNames?: Array<string>): Array<Field>;
+  public getSortedFields(fieldNames?: Array<string>): Array<Field>;
+
+  public static mergeFields(mergeFields?: Fields): Fields;
+
+  public static initializeFields(fields: Fields): Fields;
+
+  public static iterateFields(callback: IterateFieldsCallback, fields: LooseFields, sorted: boolean): Array<any>;
+  public iterateFields(callback: IterateFieldsCallback, fields: LooseFields, sorted: boolean): Array<any>;
+
+  public static hasRemoteFieldValues(): boolean;
+  public hasRemoteFieldValues(): boolean;
+
+  public static getPrimaryKeyField(): Field | undefined;
+  public getPrimaryKeyField(): Field | undefined;
+
+  public static getPrimaryKeyFieldName(): string | undefined;
+  public getPrimaryKeyFieldName(): string | undefined;
+
+  public static primaryKeyHasRemoteValue(): boolean;
+  public primaryKeyHasRemoteValue(): boolean;
+
+  public static getField(findFieldName: string): Field | undefined;
+  public getField(findFieldName: string): Field | undefined;
+
+  public static hasField(fieldName: string): boolean;
+  public hasField(fieldName: string): boolean;
+
+  public static getConcreteFieldCount(): number;
+  public getConcreteFieldCount(): number;
+
+  public static defaultOrder(options?: GenericObject): Array<string>;
+
+  public static getWhereWithConnection(options?: { connection: ConnectionBase }): QueryEngine;
+  public getWhereWithConnection(options?: { connection: ConnectionBase }): QueryEngine;
+
+  public static create(models: Array<Model | GenericObject>, options?: GenericObject): Promise<Array<Model>>;
+  public static create(models: Model | GenericObject, options?: GenericObject): Promise<Model>;
+  public static count(options?: GenericObject): Promise<number>;
+  public static all(options?: GenericObject): Promise<Array<Model>>;
+  public static fetchAll(options?: GenericObject): AsyncGenerator<Model>;
+  public static first(limit?: number, options?: GenericObject): Promise<Model | undefined>;
+  public static last(limit?: number, options?: GenericObject): Promise<Model | undefined>;
+  public static pluck(fields: string | Array<string>, options?: GenericObject): Promise<Array<any>>;
+
+  public constructor(data: GenericObject, _options?: ModelOptions);
+  public getOptions(): ModelOptions;
+  public _constructor(data?: GenericObject): void;
+  public _constructFields(): void;
+  public _constructField(fieldName: string, field: Field): void;
+  public _initializeModelData(data?: GenericObject): void;
+  public _castFieldValue(field: Field, value: any): any;
+  public _initializeFieldData(fieldName: string, field: Field, fieldValue: any, data?: GenericObject): void;
+  public _getDirtyFields(options?: GenericObject): DirtyChanges;
+  public _getFieldValue(fieldName: string, field: Field): any;
+  public _setFieldValue(fieldName: string, field: Field, value: any): void;
+  public isPersisted(): boolean;
+  public updateDirtyID(): void;
+  public isDirty(fieldName?: string): boolean;
+  public clearDirty(fieldName?: string): void;
+  public getDirtyFields(options?: GenericObject): Array<Field>;
+  public getDataValue(fieldName: string): any;
+  public setDataValue(fieldName: string, value: any): void;
+  public getAttributes(): GenericObject;
+  public setAttributes(attributes: GenericObject, noPrimaryKey?: boolean): void;
+  public hasValidPrimaryKey(): boolean;
+  public onValidate(context: HookContext): Promise<any>;
+  public onBeforeCreate(context: HookContext): Promise<any>;
+  public onBeforeUpdate(context: HookContext): Promise<any>;
+  public onBeforeSave(context: HookContext): Promise<any>;
+  public onAfterCreate(context: HookContext): Promise<any>;
+  public onAfterUpdate(context: HookContext): Promise<any>;
+  public onAfterSave(context: HookContext): Promise<any>;
+  public save(options?: GenericObject): Promise<Model | boolean>;
+  public reload(options?: GenericObject): Promise<void>;
+  public destroy(options?: GenericObject): Promise<number>;
+  public toString(): string;
+  public toJSON(): GenericObject;
+
+  declare public _options: ModelOptions;
+  declare public _mythixModelInstance: boolean;
+  declare public _connection: ConnectionBase | null;
+  declare public _fieldData: GenericObject;
+  declare public _dirtyFieldData: GenericObject;
+  declare public _typeData: GenericObject;
+  declare public _dirtyID: CacheKey;
+  declare public _persisted: boolean;
+  declare public __order: number;
+  declare public __assignedRelatedModels: Map<string, ModelClass>;
+  declare public changes: DirtyChanges;
+  declare public where: QueryEngine;
+  declare public $: QueryEngine;
+}