mythix-orm 1.5.6 → 1.6.1

package/lib/types/concrete/uuid-v3-type.d.ts

@@ -0,0 +1,27 @@
+import { DefaultValueProvider } from '../helpers/default-helpers';
+import { TypeWrapper } from '../type';
+import UUIDBaseType from './uuid-base';
+
+export declare interface UUIDV3TypeWrapper extends TypeWrapper<UUIDV3Type> {
+  (options?: UUIDV3TypeOptions): UUIDV3Type;
+}
+
+export declare interface UUIDV3TypeOptions {
+  prefix?: string;
+  name?: string | Array<number>;
+  namespace?: string | Array<number>;
+  buffer?: Buffer;
+  offset?: number;
+}
+
+export declare class UUIDV3Type extends UUIDBaseType {
+  declare public static Default: {
+    UUIDV3: DefaultValueProvider;
+  }
+
+  constructor(options?: UUIDV3TypeOptions);
+  getOptions(): UUIDV3TypeOptions;
+  getArgsForUUID(options: UUIDV3TypeOptions): Array<any>;
+}
+
+export const UUIDV3: UUIDV3TypeWrapper;

package/lib/types/concrete/uuid-v3-type.js

@@ -27,10 +27,6 @@ class UUIDV3Type extends UUIDBaseType {
     return 'UUIDV3';
   }
 
-  getDisplayName() {
-    return this.constructor.getDisplayName();
-  }
-
   getArgsForUUID(options) {
     let uuidOptions = {};
 

package/lib/types/concrete/uuid-v4-type.d.ts

@@ -0,0 +1,27 @@
+import { DefaultValueProvider } from '../helpers/default-helpers';
+import { TypeWrapper } from '../type';
+import UUIDBaseType from './uuid-base';
+
+export declare interface UUIDV4TypeWrapper extends TypeWrapper<UUIDV4Type> {
+  (options?: UUIDV4TypeOptions): UUIDV4Type;
+}
+
+export declare interface UUIDV4TypeOptions {
+  prefix?: string;
+  random?: Array<number>;
+  rng?: () => Array<number>;
+  buffer?: Buffer;
+  offset?: number;
+}
+
+export declare class UUIDV4Type extends UUIDBaseType {
+  declare public static Default: {
+    UUIDV4: DefaultValueProvider;
+  }
+
+  constructor(options?: UUIDV4TypeOptions);
+  getOptions(): UUIDV4TypeOptions;
+  getArgsForUUID(options: UUIDV4TypeOptions): Array<any>;
+}
+
+export const UUIDV4: UUIDV4TypeWrapper;

package/lib/types/concrete/uuid-v4-type.js

@@ -27,10 +27,6 @@ class UUIDV4Type extends UUIDBaseType {
     return 'UUIDV4';
   }
 
-  getDisplayName() {
-    return this.constructor.getDisplayName();
-  }
-
   getArgsForUUID(options) {
     let uuidOptions = {};
 

package/lib/types/concrete/uuid-v5-type.d.ts

@@ -0,0 +1,27 @@
+import { DefaultValueProvider } from '../helpers/default-helpers';
+import { TypeWrapper } from '../type';
+import UUIDBaseType from './uuid-base';
+
+export declare interface UUIDV5TypeWrapper extends TypeWrapper<UUIDV5Type> {
+  (options?: UUIDV5TypeOptions): UUIDV5Type;
+}
+
+export declare interface UUIDV5TypeOptions {
+  prefix?: string;
+  name?: string | Array<number>;
+  namespace?: string | Array<number>;
+  buffer?: Buffer;
+  offset?: number;
+}
+
+export declare class UUIDV5Type extends UUIDBaseType {
+  declare public static Default: {
+    UUIDV5: DefaultValueProvider;
+  }
+
+  constructor(options?: UUIDV5TypeOptions);
+  getOptions(): UUIDV5TypeOptions;
+  getArgsForUUID(options: UUIDV5TypeOptions): Array<any>;
+}
+
+export const UUIDV5: UUIDV5TypeWrapper;

package/lib/types/concrete/uuid-v5-type.js

@@ -27,10 +27,6 @@ class UUIDV5Type extends UUIDBaseType {
     return 'UUIDV5';
   }
 
-  getDisplayName() {
-    return this.constructor.getDisplayName();
-  }
-
   getArgsForUUID(options) {
     let uuidOptions = {};
 

package/lib/types/concrete/xid-type.d.ts

@@ -0,0 +1,17 @@
+import { DefaultValueProvider } from '../helpers/default-helpers';
+import { TypeWrapper } from '../type';
+import UUIDBaseType from './uuid-base';
+
+export declare interface XIDTypeWrapper extends TypeWrapper<XIDType> {
+  (): XIDType;
+}
+
+export declare class XIDType extends UUIDBaseType {
+  declare public static Default: {
+    XID: DefaultValueProvider;
+  }
+
+  constructor();
+}
+
+export const XID: XIDTypeWrapper;

package/lib/types/concrete/xid-type.js

@@ -20,10 +20,6 @@ class XIDType extends UUIDBaseType {
     return 'XID';
   }
 
-  getDisplayName() {
-    return this.constructor.getDisplayName();
-  }
-
   castToType(args) {
     let { value } = args;
     if (value == null)

package/lib/types/helpers/default-helpers.d.ts

@@ -0,0 +1,61 @@
+import ConnectionBase from '../../connection/connection-base';
+import Field from '../../field';
+import { GenericObject } from '../../interfaces/common';
+import { Model } from '../../model';
+
+export const FLAG_ON_INITIALIZE: number;
+export const FLAG_ON_INSERT: number;
+export const FLAG_ON_UPDATE: number;
+export const FLAG_ON_STORE: number;
+export const FLAG_LITERAL: number;
+export const FLAG_REMOTE: number;
+
+export declare interface DefaultValueContext {
+  _initial: boolean;
+  connection: ConnectionBase;
+  data: GenericObject | undefined;
+  field: Field;
+  fieldName: string;
+  fieldValue: any;
+  self: Model;
+}
+
+export declare interface DefaultValueProvider {
+  (context: DefaultValueContext): any;
+  mythixFlags: number | undefined;
+}
+
+export declare interface DefaultValueFlagsOptions {
+  onInitialize: boolean;
+  onInsert: boolean;
+  onUpdate: boolean;
+  onStore: boolean;
+  literal: boolean;
+  remote: boolean;
+}
+
+export declare type DefaultValueFlags = number | 'onInitialize' | 'onInsert' | 'onUpdate' | 'onStore' | 'literal' | 'remote';
+
+export declare function defaultValueFlags(func: Function, flagsObj: DefaultValueFlagsOptions): DefaultValueProvider;
+export declare function getDefaultValueFlags(func: Function): number;
+export declare function checkDefaultValueFlags(func: Function, checkFlags: Array<DefaultValueFlags>): boolean;
+
+// For AUTOINCREMENT
+export declare interface AutoIncrementDefaultValueProvider extends DefaultValueProvider {
+  _mythixIsAutoIncrement: boolean;
+}
+
+// For DATETIME_NOW.LOCAL and DATE_NOW.LOCAL
+export declare interface UpdateLocalDefaultValueProvider extends DefaultValueProvider {
+  UPDATE: DefaultValueProvider;
+}
+
+// For DATETIME_NOW and DATE_NOW
+export declare interface UpdateDefaultValueProvider extends DefaultValueProvider {
+  UPDATE: DefaultValueProvider;
+  LOCAL: UpdateLocalDefaultValueProvider;
+}
+
+export const AUTO_INCREMENT: AutoIncrementDefaultValueProvider;
+export const DATETIME_NOW: UpdateDefaultValueProvider;
+export const DATE_NOW: UpdateDefaultValueProvider;

package/lib/types/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './default-helpers';

package/lib/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './type';
+export { default as Type } from './type';
+export * from './concrete';
+export * from './virtual';
+export * as DefaultHelpers from './helpers';
+export * as Helpers from './helpers';

package/lib/types/index.js

@@ -24,6 +24,7 @@ const {
   UUIDV4Type,
   UUIDV5Type,
   XIDType,
+  UUIDBaseType,
   BIGINT,
   BLOB,
   BOOLEAN,
@@ -75,6 +76,7 @@ module.exports = {
   UUIDV4Type,
   UUIDV5Type,
   XIDType,
+  UUIDBaseType,
   BIGINT,
   BLOB,
   BOOLEAN,

package/lib/types/type.d.ts

@@ -0,0 +1,89 @@
+import ConnectionBase from '../connection/connection-base';
+import Field from '../field';
+import { GenericObject } from '../interfaces/common';
+import { Model, ModelClass } from '../model';
+import { DefaultValueProvider } from './helpers/default-helpers';
+
+export declare type TypeClass = typeof Type;
+
+export declare interface TypeWrapper<T = Type, P = DefaultValueProvider> {
+  (...any: Array<any>): T;
+  Default?: { [ key: string ]: P };
+  _isMythixFieldType: boolean;
+  clone: () => TypeClass;
+  isTypeClass: (value: any) => boolean;
+  isType: (value: any) => boolean;
+  instantiateType: (type: Type | TypeClass) => Type;
+  isVirtual: () => boolean;
+  isRelational: () => boolean;
+  isForeignKey: () => boolean;
+  exposeToModel: () => boolean;
+  getDisplayName: () => string;
+}
+
+export declare interface CastToTypeContext {
+  connection: ConnectionBase;
+  field: Field;
+  Model: ModelClass;
+  self: Model;
+  value: any;
+}
+
+export declare interface CheckDirtyContext {
+  value: any;
+  field: Field;
+  fieldName: string;
+  self: Model;
+  connection: ConnectionBase;
+}
+
+export declare interface SetFieldValueContext {
+  value: any;
+  field: Field;
+  fieldName: string;
+  self: Model;
+}
+
+declare class Type {
+  declare public static _isMythixFieldType: boolean;
+  public static clone(): TypeClass;
+
+  public static getDisplayName(): string;
+  public static isTypeClass(value: any): boolean;
+  public static isType(value): boolean;
+  public static isSameType(value: any): boolean;
+  public static instantiateType(type: Type | TypeClass): Type;
+  public static isVirtual(): boolean;
+  public static isRelational(): boolean;
+  public static isForeignKey(): boolean;
+  public static exposeToModel(): boolean;
+  public static wrapConstructor(TypeKlass: TypeClass): TypeWrapper;
+
+  declare public _args: Array<any>;
+  declare public _Model: ModelClass | undefined;
+  declare public _field: Field | undefined;
+
+  public constructor(...args: Array<any>);
+  public clone(): Type;
+  public isVirtual(): boolean;
+  public isRelational(): boolean;
+  public isForeignKey(): boolean;
+  public exposeToModel(): boolean;
+  public isRemote(): boolean;
+  public isValidValue(value: any): boolean;
+  public getField(): Field | undefined;
+  public setField(field: Field): void;
+  public getModel(): ModelClass | undefined;
+  public setModel(Model: ModelClass): void;
+  public castToType(context: CastToTypeContext): any;
+  public initialize(connection: ConnectionBase, self: Model): void;
+  public isDirty(context: CheckDirtyContext): any;
+  public onSetFieldValue(context: SetFieldValueContext): void;
+  public serialize(value: any, connection?: ConnectionBase): any;
+  public deserialize(value: any, connection?: ConnectionBase): any;
+  public toConnectionType(connection?: ConnectionBase, options?: GenericObject): string;
+  public toString(connection?: ConnectionBase): string;
+  public getDisplayName(): string;
+}
+
+export default Type;

package/lib/types/type.js

@@ -4,6 +4,14 @@ const { checkDefaultValueFlags }  = require('./helpers/default-helpers');
 
 /// Base type class for all other field types.
 class Type {
+  static getDisplayName() {
+    return '<UNKNOWN>';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
   static _isMythixFieldType = true;
 
   static clone = function() {
@@ -85,6 +93,7 @@ class Type {
       'isRelational',
       'isForeignKey',
       'exposeToModel',
+      'getDisplayName',
     ];
 
     for (let i = 0, il = staticPropertiesToCopy.length; i < il; i++) {
@@ -98,7 +107,7 @@ class Type {
     Object.defineProperties(TypeWrapper, {
       'name': {
         writable:     false,
-        enumberable:  false,
+        enumerable:   false,
         configurable: false,
         value:        `${TypeKlass.name}Wrapper`,
       },
@@ -111,42 +120,22 @@ class Type {
     Object.defineProperties(this, {
       '_args': {
         writable:     true,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        args,
       },
       '_Model': {
         writable:     true,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        null,
       },
       '_field': {
         writable:     true,
-        enumberable:  false,
-        configurable: true,
-        value:        null,
-      },
-      '_modelInstance': {
-        writable:     true,
-        enumberable:  false,
-        configurable: true,
-        value:        null,
-      },
-      '_connection': {
-        writable:     true,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        null,
       },
-      '_initialized': {
-        enumberable:  false,
-        configurable: true,
-        get:          () => {
-          return !!(this._Model && this._field);
-        },
-        set:          () => {},
-      },
     });
   }
 
@@ -156,7 +145,6 @@ class Type {
 
     newInstance._Model = this._Model;
     newInstance._field = this._field;
-    newInstance._modelInstance = this._modelInstance;
 
     return newInstance;
   }
@@ -240,6 +228,7 @@ class Type {
   ///   };
   ///
   /// Return: any
+  ///
   /// Arguments:
   ///   context: CastToTypeContext
   ///     The "context" passed to `castToType`. This contains
@@ -248,6 +237,23 @@ class Type {
     return value;
   }
 
+  /// Initialize a model instance against this type.
+  ///
+  /// Initialize is called whenever a model instance is
+  /// created. Note that the type instance is shared
+  /// across all model instances. `initialize` is still
+  /// called for every model instance that is created however,
+  /// because the type class can modify the model it
+  /// exists on. For example, the `Model` and `Models` type
+  /// inject custom relational methods onto each model instance.
+  ///
+  /// Return: undefined
+  ///
+  /// Arguments:
+  ///   connection: <see>Connection</see>
+  ///     The database connection of the calling model instance.
+  ///   self: Model
+  ///     The actual model instance that is calling this method.
   // eslint-disable-next-line no-unused-vars
   initialize(connection, self) {
   }
@@ -266,6 +272,32 @@ class Type {
     return value;
   }
 
+  /// Convert this type to the underlying type
+  /// of the database driver.
+  ///
+  /// This is generally called by a `QueryGenerator`
+  /// instance to convert the field's type to the
+  /// underlying type of the database. If a `connection`
+  /// argument is provided, then it will proxy the
+  /// call to <see>Connection.typeToString</see>.
+  /// If no `connection` argument is provided, then
+  /// it will simply return the "common" SQL string
+  /// representation for this type.
+  ///
+  /// Return: string
+  ///   A string type representing the underlying
+  ///   database driver type, or the "common" SQL
+  ///   type if not `connection` is provided.
+  ///
+  /// Arguments:
+  ///   connection: <see>Connection</see>
+  ///     The database driver connection this type
+  ///     is being converted to.
+  ///   options?: object
+  ///     Any options to pass through with the type
+  ///     conversion. This options object will be
+  ///     passed to the <see>Connection.typeToString</see>
+  ///     call.
   toConnectionType(connection, options) {
     if (!connection)
       return this.toString();

package/lib/types/virtual/index.d.ts

@@ -0,0 +1,4 @@
+export * from './model-type';
+export * from './models-type';
+export * from './relational-type-base';
+export { default as RelationalTypeBase } from './relational-type-base';

package/lib/types/virtual/model-type.d.ts

@@ -0,0 +1,15 @@
+import Field from '../../field';
+import { GenericObject } from '../../interfaces/common';
+import { TypeWrapper } from '../type';
+import RelationalTypeBase, { QueryFactory } from './relational-type-base';
+import { Model as _Model, Models } from '../../model';
+
+export declare interface Model<T extends _Model, M = Models> extends TypeWrapper<ModelType<T, M>> {
+  (targetModelName: string, queryFactory: QueryFactory<T, M>, options?: GenericObject): ModelType<T, M>;
+}
+
+export declare class ModelType<T extends _Model, M = Models> extends RelationalTypeBase<T, M> {
+  public fieldNameToOperationName(field: Field, operation: string, rootMethod: boolean): string;
+}
+
+export function Model<T extends _Model, M = Models>(targetModelName: string, queryFactory: QueryFactory<T, M>, options?: GenericObject): ModelType<T, M>;

package/lib/types/virtual/model-type.js

@@ -8,7 +8,7 @@ const ModelUtils          = require('../../utils/model-utils');
 // create{fieldName}, get{fieldName}, etc...
 const TYPE_OPERATIONS = {
   'queryFor': async function({ field, type }, userQuery, options, ...args) {
-    return await type.prepareQuery({ connection: null, self: this, field, userQuery, options }, args);
+    return await type.prepareQuery({ connection: null, self: this, field, options }, [ userQuery ].concat(args));
   },
   'create': async function({ field, type, get }, model, options) {
     if (!model)
@@ -51,7 +51,7 @@ const TYPE_OPERATIONS = {
     return result;
   },
   'get': async function({ field, type }, userQuery, options, ...args) {
-    let query = await type.prepareQuery({ connection: null, self: this, field, userQuery, options }, args);
+    let query = await type.prepareQuery({ connection: null, self: this, field, options }, [ userQuery ].concat(args));
     return await query.first(null, options);
   },
   'update': async function({ fullMethodName, field, type, create }, attributes, _options, ...args) {

package/lib/types/virtual/models-type.d.ts

@@ -0,0 +1,15 @@
+import Field from '../../field';
+import { GenericObject } from '../../interfaces/common';
+import { Model, Models as _Models } from '../../model';
+import { TypeWrapper } from '../type';
+import RelationalTypeBase, { QueryFactory } from './relational-type-base';
+
+export declare interface Models<T extends Model, M = _Models> extends TypeWrapper<ModelsType<T, M>> {
+  (targetModelName: string, queryFactory: QueryFactory<T, M>, options?: GenericObject): ModelsType<T, M>;
+}
+
+export declare class ModelsType<T extends Model, M = _Models> extends RelationalTypeBase<T, M> {
+  public fieldNameToOperationName(field: Field, operation: string, rootMethod: boolean): string;
+}
+
+export function Models<T extends Model, M = _Models>(targetModelName: string, queryFactory: QueryFactory<T, M>, options?: GenericObject): ModelsType<T, M>;

package/lib/types/virtual/models-type.js

@@ -94,7 +94,7 @@ async function destroyRelatedModels(connection, field, type, TargetModel, stored
 // addTo{fieldName}, get{fieldName}, etc...
 const TYPE_OPERATIONS = {
   'queryFor': async function({ field, type }, userQuery, options, ...args) {
-    return await type.prepareQuery({ connection: null, self: this, field, userQuery, options }, args);
+    return await type.prepareQuery({ connection: null, self: this, field, options }, [ userQuery ].concat(args));
   },
   'addTo': async function({ field }, _models, options) {
     let models = Nife.toArray(_models).filter(Boolean);
@@ -124,7 +124,7 @@ const TYPE_OPERATIONS = {
   },
   'get': function({ field, type }, userQuery, options, ...args) {
     const doGet = async function*() {
-      let query                       = await type.prepareQuery({ connection: null, self: this, field, userQuery, options }, args);
+      let query                       = await type.prepareQuery({ connection: null, self: this, field, options }, [ userQuery ].concat(args));
       let results                     = query.all(Object.assign({}, options, { stream: true }));
       let primaryModelRelationalArray = [];
 
@@ -222,15 +222,15 @@ const TYPE_OPERATIONS = {
     }, _options);
   },
   'destroy': async function({ field, type }, userQuery, options, ...args) {
-    let query = await type.prepareQuery({ connection: null, self: this, field, userQuery, options }, args);
+    let query = await type.prepareQuery({ connection: null, self: this, field, options }, [ userQuery ].concat(args));
     return await query.destroy(options);
   },
   'count': async function({ field, type }, userQuery, options, ...args) {
-    let query = await type.prepareQuery({ connection: null, self: this, field, userQuery, options }, args);
+    let query = await type.prepareQuery({ connection: null, self: this, field, options }, [ userQuery ].concat(args));
     return await query.count(null, options);
   },
   'pluck': async function({ field, type }, userQuery, fields, options, ...args) {
-    let query = await type.prepareQuery({ connection: null, self: this, field, fields, userQuery, options }, args);
+    let query = await type.prepareQuery({ connection: null, self: this, field, fields, options }, [ userQuery ].concat(args));
     return await query.pluck(fields, options);
   },
   'has': async function({ count }, userQuery, options, ...args) {

package/lib/types/virtual/relational-type-base.d.ts

@@ -0,0 +1,46 @@
+import ConnectionBase from '../../connection/connection-base';
+import Field from '../../field';
+import { GenericObject } from '../../interfaces/common';
+import { Model, ModelClass, Models } from '../../model';
+import { QueryEngine } from '../../query-engine';
+import Type from '../type';
+
+export declare interface QueryFactoryContext<T extends Model> {
+  type: Type;
+  self: T;
+  connection: ConnectionBase;
+  field: Field;
+}
+
+export declare interface QueryFactory<T extends Model, M = Models> {
+  (context: QueryFactoryContext<T>, models: M, ...args: Array<any>): QueryEngine | Promise<QueryEngine>;
+}
+
+export declare interface RelationalInfo {
+  Model: ModelClass;
+  modelName: string;
+  field: Field | null;
+  fieldName: string | null;
+}
+
+export declare interface RelationalContext {
+  PrimaryModel: ModelClass;
+  TargetModel: ModelClass;
+  TargetField: Field;
+  target: RelationalInfo;
+  source: RelationalInfo;
+}
+
+declare class RelationalTypeBase<T extends Model, M = Models> extends Type {
+  declare public targetModelName: string;
+  declare public queryFactory: QueryFactory<T, M>;
+  declare public options: string;
+
+  constructor(targetModelName: string, queryFactory: QueryFactory<T, M>, options?: GenericObject);
+  getOptions(): GenericObject;
+  walkQueryRelations(connection: ConnectionBase, callback: (context: RelationalContext) => void, context: QueryFactoryContext<T>, ...args: Array<any>): Promise<QueryEngine>;
+  getTargetModel(connection?: ConnectionBase): ModelClass;
+  prepareQuery(context: QueryFactoryContext<T>, args: Array<any>): Promise<QueryEngine>;
+}
+
+export default RelationalTypeBase;