mythix-orm 1.8.3 → 1.11.0

package/lib/query-engine/query-engine.d.ts

@@ -6,22 +6,22 @@ import Field from '../field';
 
 export declare interface QueryEngineOptions {
   connection: ConnectionBase;
-  [ key: string ]: any;
+  [key: string]: any;
 }
 
 export declare type QueryEngineClass = typeof QueryEngine;
 
 export declare interface CallableInterface {
   (...args: Array<any>): QueryEngine;
-  [ key: string ]: QueryEngine;
+  [key: string]: QueryEngine;
 }
 
 export declare class QueryEngine<T = ConnectionBase> {
   // QueryEngineBase
   static generateID(): number;
-  static isQueryContext(value: any): boolean;
+  static isQueryOperationContext(value: any): boolean;
   static isQuery(value: any): boolean;
-  static queryContextType(queryContext: GenericObject): { hasCondition: boolean; hasField: boolean; hasModel: boolean; };
+  static queryOperationInfo(queryContext: GenericObject): { hasCondition: boolean; hasField: boolean; hasModel: boolean; };
 
   public getModelScopeClass(): QueryEngine;
   public getFieldScopeClass(): QueryEngine;
@@ -31,33 +31,38 @@ export declare class QueryEngine<T = ConnectionBase> {
   public _newModelScope(Model: ModelClass): QueryEngine;
   public _newFieldScope(Field: Field): QueryEngine;
   public constructor(context: QueryEngineOptions);
-  public _getTopContextID(): number;
-  public _getRawQueryContext(): GenericObject;
-  public _getRawQuery(): Array<GenericObject>;
-  public _isLastPartControl(): boolean;
-  public _isLastPartCondition(): boolean;
-  public _queryHasConditions(): boolean;
-  public _queryHasJoins(): boolean;
-  public _debugQuery(): void;
-  public _addToQuery(queryPart: GenericObject, context: GenericObject): void;
+  public getQueryID(): number;
+  public getOperationContext(): GenericObject;
+  public getOperationStack(): Array<GenericObject>;
+  public isLastOperationControl(): boolean;
+  public isLastOperationCondition(): boolean;
+  public queryHasConditions(): boolean;
+  public queryHasJoins(): boolean;
+  public logQueryOperations(): void;
+  public _pushOperationOntoStack(queryPart: GenericObject, context: GenericObject): void;
   public getConnection(): ConnectionBase;
   public getModel(modelName: string): ModelClass | undefined;
   public getQueryEngineScope(): QueryEngine;
   public getQueryEngineClass(): QueryEngineClass;
   public clone(): QueryEngine;
+  public filter(callback: (operation: GenericObject, index: number, operations: Array<GenericObject>, query: QueryEngine) => GenericObject): QueryEngine;
+  public map(callback: (operation: GenericObject, index: number, operations: Array<GenericObject>, query: QueryEngine) => GenericObject): QueryEngine;
+  public walk(callback: (query: QueryEngine, parent: GenericObject | null, contextKey: string, depth: number) => GenericObject, checkContextKeys?: Array<string>): void;
+  public getAllModelsUsedInQuery(): Array<ModelClass>;
 
   // QueryEngine
   public getModelScopeClass(): QueryEngineClass;
   public getFieldScopeClass(): QueryEngineClass;
+  public getQueryEngineScopeClass(): QueryEngineClass;
   public Model(modelName: string): QueryEngine;
   public unscoped(context?: GenericObject): QueryEngine;
   public toString(options?: GenericObject): string;
   public MERGE(queryEngine: QueryEngine): QueryEngine;
   public all<T extends Model = Model>(options?: GenericObject): Promise<Array<T>>;
-  public fetchAll<T extends Model = Model>(options?: GenericObject): AsyncGenerator<T>;
+  public cursor<T extends Model = Model>(options?: GenericObject): AsyncGenerator<T>;
   public first<T extends Model = Model>(limit?: number | null | undefined, options?: GenericObject): Promise<T | undefined>;
   public last<T extends Model = Model>(limit?: number | null | undefined, options?: GenericObject): Promise<T | undefined>;
-  public update<T extends Model = Model>(attributes: T | GenericObject, options?: GenericObject): Promise<number>;
+  public updateAll<T extends Model = Model>(attributes: T | GenericObject, options?: GenericObject): Promise<number>;
   public destroy(options?: GenericObject): Promise<number>;
   public average(field: Field | string, options?: GenericObject): Promise<number>;
   public count(field: Field | string, options?: GenericObject): Promise<number>;
@@ -66,6 +71,7 @@ export declare class QueryEngine<T = ConnectionBase> {
   public sum(field: Field | string, options?: GenericObject): Promise<number>;
   public pluck(fields: string | Array<string>, options?: GenericObject): Promise<Array<any>>;
   public exists(options?: GenericObject): Promise<boolean>;
+  public finalizeQuery(operation: string, options: GenericObject): Promise<QueryEngine>;
 
   // ModelScope
   public _getField(fieldName: string): Field | undefined;
@@ -73,77 +79,80 @@ export declare class QueryEngine<T = ConnectionBase> {
   public Field(fieldName: string): QueryEngine;
   public LIMIT(value: number): QueryEngine;
   public OFFSET(value: number): QueryEngine;
-  public ORDER(...args: Array<string | Array<string>>): QueryEngine;
-  public PROJECT(...args: Array<string | ModelClass | LiteralBase | Field>): QueryEngine;
+  public ORDER(...args: Array<LiteralBase | Field | string | Array<LiteralBase | Field | string>>): QueryEngine;
+  public GROUP_BY(...args: Array<LiteralBase | Field | string | Array<LiteralBase | Field | string>>): QueryEngine;
+  public HAVING(query: QueryEngine): QueryEngine;
+  public EXISTS(query: QueryEngine): QueryEngine;
+  public PROJECT(...args: Array<string | ModelClass | LiteralBase | Field | Array<string | ModelClass | LiteralBase | Field>>): QueryEngine;
 
   declare public NOT: {
     (): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public AND: {
     (query: QueryEngine): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public OR: {
     (query: QueryEngine): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public DISTINCT: {
     (fullyQualifiedName: string | Field): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public INNER_JOIN: {
     (): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public LEFT_JOIN: {
     (): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public RIGHT_JOIN: {
     (): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public FULL_JOIN: {
     (): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public CROSS_JOIN: {
     (): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public JOIN: {
     (type: string | LiteralBase): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   // FieldScope
@@ -158,7 +167,7 @@ export declare class QueryEngine<T = ConnectionBase> {
   public NOT_LIKE(value: string, options?: { caseSensitive: boolean }): QueryEngine;
 
   name: QueryEngine;
-  [ key: string ]: any;
+  [key: string]: any;
 }
 
 export class ModelScope extends QueryEngine { }

package/lib/query-engine/query-engine.js

@@ -20,9 +20,9 @@ class QueryEngine extends QueryEngineBase {
     let context = Object.assign(
       Object.create(_context || {}),
       {
-        currentScopeName: 'queryEngine',
-        isQueryContext:   true,
-        contextID:        QueryEngineBase.generateID(),
+        currentScopeName:        'queryEngine',
+        isQueryOperationContext: true,
+        contextID:               QueryEngineBase.generateID(),
       },
     );
 
@@ -39,15 +39,15 @@ class QueryEngine extends QueryEngineBase {
     return this._newModelScope(model);
   }
 
-  unscoped(context) {
+  unscoped() {
+    let context           = this.getOperationContext();
     let QueryEngineClass  = this.constructor;
-    let currentContext    = context || this.currentContext;
     let queryEngine       = new QueryEngineClass({
-      connection: currentContext.connection,
+      connection: this.getConnection(),
     });
 
-    if (currentContext.rootModelName)
-      queryEngine = queryEngine[currentContext.rootModelName];
+    if (context.rootModelName)
+      queryEngine = queryEngine[context.rootModelName];
 
     return queryEngine;
   }
@@ -59,35 +59,23 @@ class QueryEngine extends QueryEngineBase {
     return queryGenerator.toConnectionString(this, ...args);
   }
 
-  MERGE(_queryEngine) {
-    let queryEngine = _queryEngine;
-    if (!queryEngine)
+  MERGE(_incomingQueryEngine, _options) {
+    let incomingQueryEngine = _incomingQueryEngine;
+    if (!incomingQueryEngine)
       return this;
 
-    let thisQueryContext = this._getRawQueryContext();
-    if (!QueryEngine.isQuery(queryEngine) && Nife.instanceOf(queryEngine, 'array', 'object', 'map', 'set'))
-      queryEngine = Utils.generateQueryFromFilter(this.getConnection(), thisQueryContext.rootModel, queryEngine);
-
-    let sourceQuery           = queryEngine._getRawQuery();
-    let currentModel          = thisQueryContext.Model;
-    let skipLogicalOperators  = true;
-
-    for (let i = 0, il = sourceQuery.length; i < il; i++) {
-      let queryPart     = sourceQuery[i];
-      let mergeContext  = Utils.objectAssignSpecial(queryPart, null, [
-        // Skip the following keys
-        // as they are provided by the
-        // parent queryEngine
-        'connection',
-        'fieldContext',
-        'isQueryContext',
-        'modelContext',
-        'queryEngineScope',
-        'queryRoot',
-        'rootContext',
-        'rootModel',
-        'rootModelName',
-      ]);
+    let options           = _options || {};
+    let thisQueryContext  = this.getOperationContext();
+    if (!QueryEngine.isQuery(incomingQueryEngine) && Nife.instanceOf(incomingQueryEngine, 'array', 'object', 'map', 'set'))
+      incomingQueryEngine = Utils.generateQueryFromFilter(this.getConnection(options.connection), thisQueryContext.rootModel, incomingQueryEngine);
+
+    let incomingOperationStack      = incomingQueryEngine.getOperationStack();
+    let skippingLogical             = true;
+    let logicalOperatorEncountered  = false;
+    let queryEngine                 = this.clone();
+
+    for (let i = 0, il = incomingOperationStack.length; i < il; i++) {
+      let queryPart = incomingOperationStack[i];
 
       // For merges, we want to skip the first logical operators
       // found before any other operation.
@@ -97,51 +85,59 @@ class QueryEngine extends QueryEngineBase {
       // Since the result we want here is OR merge, not AND merge
       // we skip the first "AND" we encounter, leaving the "OR" as
       // the current logical operator.
-      if (skipLogicalOperators && Object.prototype.hasOwnProperty.call(mergeContext, 'logical') && mergeContext.logical) {
-        if (mergeContext.value == null && (mergeContext.operator === 'AND' || mergeContext.operator === 'OR'))
+      // Logical operators do not always come first in the query,
+      // so we need to rely on "logicalOperatorEncountered" to
+      // ensure we skip only the first one (or first few in a sequence).
+      if (skippingLogical && Object.prototype.hasOwnProperty.call(queryPart, 'logical') && queryPart.logical) {
+        if (queryPart.value == null && (queryPart.operator === 'AND' || queryPart.operator === 'OR')) {
+          logicalOperatorEncountered = true;
           continue;
+        }
       }
 
-      if (Object.prototype.hasOwnProperty.call(mergeContext, 'operator')) {
-        // Skip unneeded duplicate model entries
-        if (mergeContext.operator === 'MODEL') {
-          if (mergeContext.Model === currentModel)
-            continue;
+      if (logicalOperatorEncountered)
+        skippingLogical = false;
 
-          currentModel = mergeContext.Model;
-        } else if (mergeContext.operator !== 'FIELD') {
-          skipLogicalOperators = false;
-        }
+      let value = queryPart.value;
+      if (Object.prototype.hasOwnProperty.call(queryPart, 'control') && queryPart.control === true) {
+        if (queryPart.operator === 'PROJECT' && options.projections !== true)
+          continue;
+
+        if (queryPart.operator === 'ORDER' && options.orders === false)
+          continue;
+
+        if (queryPart.operator === 'GROUP_BY' && options.groupBys === false)
+          continue;
+
+        if (queryPart.operator === 'PROJECT' || queryPart.operator === 'ORDER' || queryPart.operator === 'GROUP_BY')
+          value = [ '+' ].concat(value);
       }
 
-      this._addToQuery(Object.assign({
-        Model:      queryPart.Model,
-        modelName:  queryPart.modelName,
-        Field:      queryPart.Field,
-        fieldName:  queryPart.fieldName,
-      }, mergeContext));
+      queryEngine = queryEngine[queryPart.queryProp](value, ...(queryPart.queryExtraArgs || []));
     }
 
-    return this;
+    return queryEngine;
   }
 
-  all(options) {
+  async all(options) {
     let connection = this.getConnection(options && options.connection);
 
     if (options && options.stream)
-      return connection.select(this, options);
-    else
-      return Utils.collect(connection.select(this, options));
+      throw new TypeError('QueryEngine::all: "stream" option set to true. For streaming, please use the "cursor" method instead.');
+
+    return await Utils.collect(connection.select(await this.finalizeQuery('read', options), options));
   }
 
-  fetchAll(options) {
-    return this.all({ ...(options || {}), stream: true });
+  async *cursor(_options) {
+    let options     = _options || {};
+    let connection  = this.getConnection(options && options.connection);
+    return yield *connection.select(await this.finalizeQuery('read', options), { ...options, stream: true });
   }
 
   async first(_limit, options) {
     let limit       = (_limit == null) ? 1 : _limit;
     let connection  = this.getConnection(options && options.connection);
-    let query       = this.clone().LIMIT(limit);
+    let query       = (await this.finalizeQuery('read', options)).clone().LIMIT(limit);
 
     let result = await Utils.collect(connection.select(query, options));
     return (_limit == null) ? result[0] : result;
@@ -150,55 +146,63 @@ class QueryEngine extends QueryEngineBase {
   async last(_limit, options) {
     let limit       = (_limit == null) ? 1 : _limit;
     let connection  = this.getConnection(options && options.connection);
-    let query       = this.clone().LIMIT(limit);
+    let query       = (await this.finalizeQuery('read', options)).clone().LIMIT(limit);
 
     let result = await Utils.collect(connection.select(query, Object.assign({}, options || {}, { reverseOrder: true })));
     return (_limit == null) ? result[0] : result.reverse();
   }
 
-  async update(attributes, options) {
+  async updateAll(attributes, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.updateAll(this, attributes, options);
+    return await connection.updateAll(await this.finalizeQuery('update', options), attributes, options);
   }
 
   async destroy(options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.destroy(this, options);
+    return await connection.destroy(await this.finalizeQuery('delete', options), options);
   }
 
   async average(field, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.average(this, field, options);
+    return await connection.average(await this.finalizeQuery('read', options), field, options);
   }
 
   async count(field, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.count(this, field, options);
+    return await connection.count(await this.finalizeQuery('read', options), field, options);
   }
 
   async min(field, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.min(this, field, options);
+    return await connection.min(await this.finalizeQuery('read', options), field, options);
   }
 
   async max(field, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.max(this, field, options);
+    return await connection.max(await this.finalizeQuery('read', options), field, options);
   }
 
   async sum(field, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.sum(this, field, options);
+    return await connection.sum(await this.finalizeQuery('read', options), field, options);
   }
 
   async pluck(fields, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.pluck(this, fields, options);
+    return await connection.pluck(await this.finalizeQuery('read', options), fields, options);
   }
 
   async exists(options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.exists(this, options);
+    return await connection.exists(await this.finalizeQuery('read', options), options);
+  }
+
+  async finalizeQuery(crudOperation, options) {
+    let connection = this.getConnection();
+    if (connection && typeof connection.finalizeQuery === 'function')
+      return await connection.finalizeQuery(crudOperation, this, options);
+
+    return this;
   }
 
   [ProxyClass.MISSING](target, prop) {

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

@@ -269,6 +269,6 @@ class DateTimeType extends Type {
 }
 
 module.exports = {
-  DATETIME:   Type.wrapConstructor(DateTimeType),
+  DATETIME: Type.wrapConstructor(DateTimeType),
   DateTimeType,
 };

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

@@ -110,13 +110,13 @@ class SerializedType extends Type {
       options = { type: options };
 
     options = {
-      serialize:    ({ value }) => {
+      serialize: ({ value }) => {
         if (value == null)
           return value;
 
         return JSON.stringify(value);
       },
-      deserialize:  ({ value }) => {
+      deserialize: ({ value }) => {
         if (value == null)
           return value;
 

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

@@ -72,12 +72,12 @@ const TYPE_OPERATIONS = {
       if (!model.isDirty())
         return model;
 
-      let [ storedModel ] = await connection.update(model.getModel(), [ model ], options);
+      await connection.update(model.getModel(), [ model ], options);
 
       // Update this model to reflect the update
-      ModelUtils.setRelationalValues(connection, this.getModel(), this, storedModel.getModel(), storedModel);
+      ModelUtils.setRelationalValues(connection, this.getModel(), this, model.getModel(), model);
 
-      return storedModel;
+      return model;
     }, options);
 
     // Save needs to go outside of the transaction

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

@@ -125,7 +125,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, options }, [ userQuery ].concat(args));
-      let results                     = query.all(Object.assign({}, options, { stream: true }));
+      let results                     = query.cursor(options);
       let primaryModelRelationalArray = [];
 
       this[field.fieldName] = primaryModelRelationalArray;

package/lib/types/virtual/relational-type-base.js

@@ -140,17 +140,17 @@ class RelationalTypeBase extends Type {
       };
 
       let target = {
-        Model:      leftContext.Model,
-        modelName:  leftContext.modelName,
-        field:      leftContext.Field,
-        fieldName:  leftContext.fieldName,
+        Model:     leftContext.Model,
+        modelName: leftContext.modelName,
+        field:     leftContext.Field,
+        fieldName: leftContext.fieldName,
       };
 
       let source = {
-        Model:      rightContext.Model,
-        modelName:  rightContext.modelName,
-        field:      rightContext.Field,
-        fieldName:  rightContext.fieldName,
+        Model:     rightContext.Model,
+        modelName: rightContext.modelName,
+        field:     rightContext.Field,
+        fieldName: rightContext.fieldName,
       };
 
       // The primary model is always the target
@@ -170,7 +170,7 @@ class RelationalTypeBase extends Type {
     let PrimaryModel      = (context.self && context.self.getModel());
     let primaryModelName  = PrimaryModel.getModelName();
     let query             = await this.prepareQuery(Object.assign({ connection }, context), args);
-    let queryParts        = query._getRawQuery();
+    let queryParts        = query.getOperationStack();
     let queryContext      = (queryParts[queryParts.length - 1] || {});
     let TargetModel       = queryContext.rootModel;
     let TargetField       = queryContext.rootField;
@@ -186,7 +186,7 @@ class RelationalTypeBase extends Type {
       let rightQueryContext = null;
 
       if (QueryEngine.isQuery(conditionValue)) {
-        rightQueryContext = conditionValue._getRawQueryContext();
+        rightQueryContext = conditionValue.getOperationContext();
         if (rightQueryContext.condition)
           continue;
       } else {
@@ -205,10 +205,10 @@ class RelationalTypeBase extends Type {
         let targetField     = fkField.getTargetField(connection);
         let targetFieldName = fkField.getTargetFieldName(connection);
         let fkContext       = {
-          Model:      targetModel,
-          modelName:  targetModelName,
-          field:      targetField,
-          fieldName:  targetFieldName,
+          Model:     targetModel,
+          modelName: targetModelName,
+          field:     targetField,
+          fieldName: targetFieldName,
         };
 
         if (!isAlreadyVisited(fkContext, rightQueryContext))
@@ -222,10 +222,10 @@ class RelationalTypeBase extends Type {
         let targetField     = fkField.getTargetField(connection);
         let targetFieldName = fkField.getTargetFieldName(connection);
         let fkContext       = {
-          Model:      targetModel,
-          modelName:  targetModelName,
-          field:      targetField,
-          fieldName:  targetFieldName,
+          Model:     targetModel,
+          modelName: targetModelName,
+          field:     targetField,
+          fieldName: targetFieldName,
         };
 
         if (!isAlreadyVisited(leftQueryContext, fkContext))
@@ -245,16 +245,16 @@ class RelationalTypeBase extends Type {
     // be copying field values from
     let targetModelName = TargetModel.getModelName();
     let source      = {
-      Model:      TargetModel,
-      modelName:  targetModelName,
-      Field:      TargetField,
-      fieldName:  TargetField.fieldName,
+      Model:     TargetModel,
+      modelName: targetModelName,
+      Field:     TargetField,
+      fieldName: TargetField.fieldName,
     };
     let target    = {
-      Model:      PrimaryModel,
-      modelName:  PrimaryModel.getModelName(),
-      Field:      context.field,
-      fieldName:  context.field.fieldName,
+      Model:     PrimaryModel,
+      modelName: PrimaryModel.getModelName(),
+      Field:     context.field,
+      fieldName: context.field.fieldName,
     };
 
     if (!isAlreadyVisited(source, target))

package/lib/utils/index.js

@@ -7,7 +7,6 @@ const AsyncStore  = require('./async-store');
 
 const {
   collect,
-  objectAssignSpecial,
   valueToDateTime,
 } = MiscUtils;
 
@@ -31,6 +30,7 @@ const {
 const {
   parseFilterFieldAndOperator,
   generateQueryFromFilter,
+  margeFields,
 } = QueryUtils;
 
 const {
@@ -48,7 +48,6 @@ module.exports = {
 
   // MiscUtils
   collect,
-  objectAssignSpecial,
   valueToDateTime,
 
   // ModelUtils
@@ -70,6 +69,7 @@ module.exports = {
   // QueryUtils
   parseFilterFieldAndOperator,
   generateQueryFromFilter,
+  margeFields,
 
   // AsyncStore
   getContextStore,

package/lib/utils/misc-utils.d.ts

@@ -2,5 +2,4 @@ import { DateTime } from 'luxon';
 import { GenericObject } from '../interfaces/common';
 
 declare function collect(iterator: AsyncIterator<any>): Promise<Array<any>>;
-declare function objectAssignSpecial(obj: GenericObject, proto?: GenericObject | null, skipKeys?: Array<string> | GenericObject): GenericObject;
 declare function valueToDateTime(value: DateTime | Date | number | BigInt | string, format?: string): DateTime;

package/lib/utils/misc-utils.js

@@ -12,29 +12,6 @@ async function collect(iterator) {
   return items;
 }
 
-function objectAssignSpecial(obj, proto, skipKeys) {
-  const isKeySkipped = (key) => {
-    if (Array.isArray(skipKeys))
-      return (skipKeys.indexOf(key) >= 0);
-
-    return Object.prototype.hasOwnProperty.call(skipKeys, key);
-  };
-
-  let newObj  = Object.create(proto || {});
-  let keys    = Object.keys(obj);
-
-  // eslint-disable-next-line guard-for-in
-  for (let i = 0, il = keys.length; i < il; i++) {
-    let key = keys[i];
-    if (skipKeys && isKeySkipped(key))
-      continue;
-
-    newObj[key] = obj[key];
-  }
-
-  return newObj;
-}
-
 function valueToDateTime(value, format) {
   if (DateTime.isDateTime(value)) {
     return value;
@@ -59,6 +36,5 @@ function valueToDateTime(value, format) {
 
 module.exports = {
   collect,
-  objectAssignSpecial,
   valueToDateTime,
 };