@abedmurrar/objection 4.0.0-alpha.0 → 4.0.0-beta.1

package/lib/queryBuilder/operations/FindOperation.js

@@ -1,164 +1,147 @@
 'use strict';
-
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { StaticHookArguments } = require('../StaticHookArguments');
+const { StaticHookArguments, hasStaticHook } = require('../StaticHookArguments');
 const { isPromise, after, afterReturn } = require('../../utils/promiseUtils');
 const { isObject } = require('../../utils/objectUtils');
-
 class FindOperation extends QueryBuilderOperation {
-  onBefore2(builder, result) {
-    return afterReturn(callStaticBeforeFind(builder), result);
-  }
-
-  onAfter3(builder, results) {
-    const opt = builder.findOptions();
-
-    if (opt.dontCallFindHooks) {
-      return results;
-    } else {
-      return callAfterFind(builder, results);
+    onBefore2(builder, result) {
+        return afterReturn(callStaticBeforeFind(builder), result);
+    }
+    onAfter3(builder, results) {
+        const opt = builder.findOptions();
+        if (opt.dontCallFindHooks) {
+            return results;
+        }
+        else {
+            return callAfterFind(builder, results);
+        }
     }
-  }
 }
-
 function callStaticBeforeFind(builder) {
-  const args = StaticHookArguments.create({ builder });
-  return builder.modelClass().beforeFind(args);
+    if (!hasStaticHook(builder.modelClass(), 'beforeFind')) {
+        return undefined;
+    }
+    const args = StaticHookArguments.create({ builder });
+    return builder.modelClass().beforeFind(args);
 }
-
 function callAfterFind(builder, result) {
-  const opt = builder.findOptions();
-  const maybePromise = callInstanceAfterFind(builder.context(), result, opt.callAfterFindDeeply);
-
-  return after(maybePromise, () => callStaticAfterFind(builder, result));
+    const opt = builder.findOptions();
+    const maybePromise = callInstanceAfterFind(builder.context(), result, opt.callAfterFindDeeply);
+    return after(maybePromise, () => callStaticAfterFind(builder, result));
 }
-
 function callStaticAfterFind(builder, result) {
-  const args = StaticHookArguments.create({ builder, result });
-  const maybePromise = builder.modelClass().afterFind(args);
-
-  return after(maybePromise, (maybeResult) => {
-    if (maybeResult === undefined) {
-      return result;
-    } else {
-      return maybeResult;
-    }
-  });
+    if (!hasStaticHook(builder.modelClass(), 'afterFind')) {
+        return result;
+    }
+    const args = StaticHookArguments.create({ builder, result });
+    const maybePromise = builder.modelClass().afterFind(args);
+    return after(maybePromise, (maybeResult) => {
+        if (maybeResult === undefined) {
+            return result;
+        }
+        else {
+            return maybeResult;
+        }
+    });
 }
-
 function callInstanceAfterFind(ctx, results, deep) {
-  if (Array.isArray(results)) {
-    if (results.length === 1) {
-      return callAfterFindForOne(ctx, results[0], results, deep);
-    } else {
-      return callAfterFindArray(ctx, results, deep);
-    }
-  } else {
-    return callAfterFindForOne(ctx, results, results, deep);
-  }
+    if (Array.isArray(results)) {
+        if (results.length === 1) {
+            return callAfterFindForOne(ctx, results[0], results, deep);
+        }
+        else {
+            return callAfterFindArray(ctx, results, deep);
+        }
+    }
+    else {
+        return callAfterFindForOne(ctx, results, results, deep);
+    }
 }
-
 function callAfterFindArray(ctx, results, deep) {
-  if (results.length === 0 || !isObject(results[0])) {
-    return results;
-  }
-
-  const mapped = new Array(results.length);
-  let containsPromise = false;
-
-  for (let i = 0, l = results.length; i < l; ++i) {
-    mapped[i] = callAfterFindForOne(ctx, results[i], results[i], deep);
-
-    if (isPromise(mapped[i])) {
-      containsPromise = true;
-    }
-  }
-
-  if (containsPromise) {
-    return Promise.all(mapped);
-  } else {
-    return mapped;
-  }
+    if (results.length === 0 || !isObject(results[0])) {
+        return results;
+    }
+    const mapped = new Array(results.length);
+    let containsPromise = false;
+    for (let i = 0, l = results.length; i < l; ++i) {
+        mapped[i] = callAfterFindForOne(ctx, results[i], results[i], deep);
+        if (isPromise(mapped[i])) {
+            containsPromise = true;
+        }
+    }
+    if (containsPromise) {
+        return Promise.all(mapped);
+    }
+    else {
+        return mapped;
+    }
 }
-
 function callAfterFindForOne(ctx, model, result, deep) {
-  if (!isObject(model) || !model.$isObjectionModel) {
-    return result;
-  }
-
-  if (deep) {
-    const results = [];
-    const containsPromise = callAfterFindForRelations(ctx, model, results);
-
-    if (containsPromise) {
-      return Promise.all(results).then(() => {
+    if (!isObject(model) || !model.$isObjectionModel) {
+        return result;
+    }
+    if (deep) {
+        const results = [];
+        const containsPromise = callAfterFindForRelations(ctx, model, results);
+        if (containsPromise) {
+            return Promise.all(results).then(() => {
+                return doCallAfterFind(ctx, model, result);
+            });
+        }
+        else {
+            return doCallAfterFind(ctx, model, result);
+        }
+    }
+    else {
         return doCallAfterFind(ctx, model, result);
-      });
-    } else {
-      return doCallAfterFind(ctx, model, result);
     }
-  } else {
-    return doCallAfterFind(ctx, model, result);
-  }
 }
-
 function callAfterFindForRelations(ctx, model, results) {
-  const keys = Object.keys(model);
-  let containsPromise = false;
-
-  for (let i = 0, l = keys.length; i < l; ++i) {
-    const key = keys[i];
-    const value = model[key];
-
-    if (isRelation(value)) {
-      const maybePromise = callInstanceAfterFind(ctx, value, true);
-
-      if (isPromise(maybePromise)) {
-        containsPromise = true;
-      }
-
-      results.push(maybePromise);
-    }
-  }
-
-  return containsPromise;
+    const keys = Object.keys(model);
+    let containsPromise = false;
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        const value = model[key];
+        if (isRelation(value)) {
+            const maybePromise = callInstanceAfterFind(ctx, value, true);
+            if (isPromise(maybePromise)) {
+                containsPromise = true;
+            }
+            results.push(maybePromise);
+        }
+    }
+    return containsPromise;
 }
-
 function isRelation(value) {
-  return (
-    (isObject(value) && value.$isObjectionModel) ||
-    (isNonEmptyObjectArray(value) && value[0].$isObjectionModel)
-  );
+    return ((isObject(value) && value.$isObjectionModel) ||
+        (isNonEmptyObjectArray(value) && value[0].$isObjectionModel));
 }
-
 function isNonEmptyObjectArray(value) {
-  return Array.isArray(value) && value.length > 0 && isObject(value[0]);
+    return Array.isArray(value) && value.length > 0 && isObject(value[0]);
 }
-
 function doCallAfterFind(ctx, model, result) {
-  const afterFind = getAfterFindHook(model);
-
-  if (afterFind !== null) {
-    const maybePromise = afterFind.call(model, ctx);
-
-    if (isPromise(maybePromise)) {
-      return maybePromise.then(() => result);
-    } else {
-      return result;
-    }
-  } else {
-    return result;
-  }
+    const afterFind = getAfterFindHook(model);
+    if (afterFind !== null) {
+        const maybePromise = afterFind.call(model, ctx);
+        if (isPromise(maybePromise)) {
+            return maybePromise.then(() => result);
+        }
+        else {
+            return result;
+        }
+    }
+    else {
+        return result;
+    }
 }
-
 function getAfterFindHook(model) {
-  if (model.$afterFind !== model.$objectionModelClass.prototype.$afterFind) {
-    return model.$afterFind;
-  } else {
-    return null;
-  }
+    if (model.$afterFind !== model.$objectionModelClass.prototype.$afterFind) {
+        return model.$afterFind;
+    }
+    else {
+        return null;
+    }
 }
-
 module.exports = {
-  FindOperation,
+    FindOperation,
 };

package/lib/queryBuilder/operations/FirstOperation.js

@@ -1,27 +1,22 @@
 'use strict';
-
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-
 class FirstOperation extends QueryBuilderOperation {
-  onBuildKnex(knexBuilder, builder) {
-    const modelClass = builder.modelClass();
-
-    if (builder.isFind() && modelClass.useLimitInFirst) {
-      knexBuilder = knexBuilder.limit(1);
+    onBuildKnex(knexBuilder, builder) {
+        const modelClass = builder.modelClass();
+        if (builder.isFind() && modelClass.useLimitInFirst) {
+            knexBuilder = knexBuilder.limit(1);
+        }
+        return knexBuilder;
     }
-
-    return knexBuilder;
-  }
-
-  onAfter3(_, result) {
-    if (Array.isArray(result)) {
-      return result[0];
-    } else {
-      return result;
+    onAfter3(_, result) {
+        if (Array.isArray(result)) {
+            return result[0];
+        }
+        else {
+            return result;
+        }
     }
-  }
 }
-
 module.exports = {
-  FirstOperation,
+    FirstOperation,
 };

package/lib/queryBuilder/operations/FromOperation.js

@@ -1,110 +1,91 @@
 'use strict';
-
 const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
 const { isPlainObject, isString } = require('../../utils/objectUtils');
 const { isModelClass } = require('../../utils/resolveModel');
-
 const ALIAS_REGEX = /\s+as\s+/i;
-
 // FromOperation corresponds to a `.from(args)` call. The call is delegated to
 // knex, but we first try to parse the arguments so that we can determine which
 // tables have been mentioned in a query's from clause. We only parse string
 // references and not `raw` or `ref` etc. references at this point thouhg.
 class FromOperation extends ObjectionToKnexConvertingOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    this.table = null;
-    this.alias = null;
-  }
-
-  onAdd(builder, args) {
-    const ret = super.onAdd(builder, args);
-    const parsed = parseTableAndAlias(this.args[0], builder);
-
-    if (parsed.table) {
-      builder.tableName(parsed.table);
-      this.table = parsed.table;
+    constructor(name, opt) {
+        super(name, opt);
+        this.table = null;
+        this.alias = null;
     }
-
-    if (parsed.alias) {
-      builder.aliasFor(builder.modelClass().getTableName(), parsed.alias);
-      this.alias = parsed.alias;
+    onAdd(builder, args) {
+        const ret = super.onAdd(builder, args);
+        const parsed = parseTableAndAlias(this.args[0], builder);
+        if (parsed.table) {
+            builder.tableName(parsed.table);
+            this.table = parsed.table;
+        }
+        if (parsed.alias) {
+            builder.aliasFor(builder.modelClass().getTableName(), parsed.alias);
+            this.alias = parsed.alias;
+        }
+        return ret;
+    }
+    onBuildKnex(knexBuilder, builder) {
+        // Simply call knex's from method with the converted arguments.
+        return knexBuilder.from.apply(knexBuilder, this.getKnexArgs(builder));
+    }
+    clone() {
+        const clone = super.clone();
+        clone.table = this.table;
+        clone.alias = this.alias;
+        return clone;
     }
-
-    return ret;
-  }
-
-  onBuildKnex(knexBuilder, builder) {
-    // Simply call knex's from method with the converted arguments.
-    return knexBuilder.from.apply(knexBuilder, this.getKnexArgs(builder));
-  }
-
-  clone() {
-    const clone = super.clone();
-
-    clone.table = this.table;
-    clone.alias = this.alias;
-
-    return clone;
-  }
 }
-
 function parseTableAndAlias(arg, builder) {
-  if (isModelClass(arg)) {
-    return parseTableAndAliasFromString(arg.getTableName());
-  } else if (isString(arg)) {
-    return parseTableAndAliasFromString(arg);
-  } else if (isPlainObject(arg)) {
-    return parseTableAndAliasFromObject(arg, builder);
-  } else {
-    // Could not parse table and alias from the arguments.
-    return {
-      table: null,
-      alias: null,
-    };
-  }
+    if (isModelClass(arg)) {
+        return parseTableAndAliasFromString(arg.getTableName());
+    }
+    else if (isString(arg)) {
+        return parseTableAndAliasFromString(arg);
+    }
+    else if (isPlainObject(arg)) {
+        return parseTableAndAliasFromObject(arg, builder);
+    }
+    else {
+        // Could not parse table and alias from the arguments.
+        return {
+            table: null,
+            alias: null,
+        };
+    }
 }
-
 function parseTableAndAliasFromString(arg) {
-  if (ALIAS_REGEX.test(arg)) {
-    const parts = arg.split(ALIAS_REGEX);
-
-    return {
-      table: parts[0].trim(),
-      alias: parts[1].trim(),
-    };
-  } else {
-    return {
-      table: arg.trim(),
-      alias: null,
-    };
-  }
+    if (ALIAS_REGEX.test(arg)) {
+        const parts = arg.split(ALIAS_REGEX);
+        return {
+            table: parts[0].trim(),
+            alias: parts[1].trim(),
+        };
+    }
+    else {
+        return {
+            table: arg.trim(),
+            alias: null,
+        };
+    }
 }
-
 function parseTableAndAliasFromObject(arg, builder) {
-  for (const alias of Object.keys(arg)) {
-    const value = isModelClass(arg[alias]) ? arg[alias].getTableName() : arg[alias];
-
-    if (!isString(value)) {
-      continue;
-    }
-
-    const table = value.trim();
-
-    if (table === builder.modelClass().getTableName()) {
-      return {
-        alias,
-        table,
-      };
+    for (const alias of Object.keys(arg)) {
+        const value = isModelClass(arg[alias]) ? arg[alias].getTableName() : arg[alias];
+        if (!isString(value)) {
+            continue;
+        }
+        const table = value.trim();
+        if (table === builder.modelClass().getTableName()) {
+            return {
+                alias,
+                table,
+            };
+        }
     }
-  }
-
-  throw new Error(
-    `one of the tables in ${JSON.stringify(arg)} must be the query's model class's table.`,
-  );
+    throw new Error(`one of the tables in ${JSON.stringify(arg)} must be the query's model class's table.`);
 }
-
 module.exports = {
-  FromOperation,
+    FromOperation,
 };

package/lib/queryBuilder/operations/InsertAndFetchOperation.js

@@ -1,49 +1,38 @@
 'use strict';
-
 const { InsertOperation } = require('./InsertOperation');
 const { DelegateOperation } = require('./DelegateOperation');
 const { keyByProps } = require('../../model/modelUtils');
 const { asArray } = require('../../utils/objectUtils');
-
 class InsertAndFetchOperation extends DelegateOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    if (!this.delegate.is(InsertOperation)) {
-      throw new Error('Invalid delegate');
+    constructor(name, opt) {
+        super(name, opt);
+        if (!this.delegate.is(InsertOperation)) {
+            throw new Error('Invalid delegate');
+        }
+    }
+    get models() {
+        return this.delegate.models;
+    }
+    async onAfter2(builder, inserted) {
+        const modelClass = builder.modelClass();
+        const insertedModels = await super.onAfter2(builder, inserted);
+        const insertedModelArray = asArray(insertedModels);
+        const idProps = modelClass.getIdPropertyArray();
+        const ids = insertedModelArray.map((model) => model.$id());
+        const fetchedModels = await modelClass
+            .query()
+            .childQueryOf(builder)
+            .findByIds(ids)
+            .castTo(builder.resultModelClass());
+        const modelsById = keyByProps(fetchedModels, idProps);
+        // Instead of returning the freshly fetched models, update the input
+        // models with the fresh values.
+        insertedModelArray.forEach((insertedModel) => {
+            insertedModel.$set(modelsById.get(insertedModel.$propKey(idProps)));
+        });
+        return insertedModels;
     }
-  }
-
-  get models() {
-    return this.delegate.models;
-  }
-
-  async onAfter2(builder, inserted) {
-    const modelClass = builder.modelClass();
-    const insertedModels = await super.onAfter2(builder, inserted);
-
-    const insertedModelArray = asArray(insertedModels);
-    const idProps = modelClass.getIdPropertyArray();
-    const ids = insertedModelArray.map((model) => model.$id());
-
-    const fetchedModels = await modelClass
-      .query()
-      .childQueryOf(builder)
-      .findByIds(ids)
-      .castTo(builder.resultModelClass());
-
-    const modelsById = keyByProps(fetchedModels, idProps);
-
-    // Instead of returning the freshly fetched models, update the input
-    // models with the fresh values.
-    insertedModelArray.forEach((insertedModel) => {
-      insertedModel.$set(modelsById.get(insertedModel.$propKey(idProps)));
-    });
-
-    return insertedModels;
-  }
 }
-
 module.exports = {
-  InsertAndFetchOperation,
+    InsertAndFetchOperation,
 };

package/lib/queryBuilder/operations/InsertGraphAndFetchOperation.js

@@ -1,45 +1,35 @@
 'use strict';
-
 const { DelegateOperation } = require('./DelegateOperation');
 const { InsertGraphOperation } = require('./InsertGraphOperation');
 const { RelationExpression } = require('../RelationExpression');
-
 class InsertGraphAndFetchOperation extends DelegateOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    if (!this.delegate.is(InsertGraphOperation)) {
-      throw new Error('Invalid delegate');
+    constructor(name, opt) {
+        super(name, opt);
+        if (!this.delegate.is(InsertGraphOperation)) {
+            throw new Error('Invalid delegate');
+        }
     }
-  }
-
-  get models() {
-    return this.delegate.models;
-  }
-
-  get isArray() {
-    return this.delegate.isArray;
-  }
-
-  async onAfter2(builder) {
-    if (this.models.length === 0) {
-      return this.isArray ? [] : null;
+    get models() {
+        return this.delegate.models;
+    }
+    get isArray() {
+        return this.delegate.isArray;
+    }
+    async onAfter2(builder) {
+        if (this.models.length === 0) {
+            return this.isArray ? [] : null;
+        }
+        const eager = RelationExpression.fromModelGraph(this.models);
+        const modelClass = this.models[0].constructor;
+        const ids = this.models.map((model) => model.$id());
+        const models = await modelClass
+            .query()
+            .childQueryOf(builder)
+            .findByIds(ids)
+            .withGraphFetched(eager);
+        return this.isArray ? models : models[0] || null;
     }
-
-    const eager = RelationExpression.fromModelGraph(this.models);
-    const modelClass = this.models[0].constructor;
-    const ids = this.models.map((model) => model.$id());
-
-    const models = await modelClass
-      .query()
-      .childQueryOf(builder)
-      .findByIds(ids)
-      .withGraphFetched(eager);
-
-    return this.isArray ? models : models[0] || null;
-  }
 }
-
 module.exports = {
-  InsertGraphAndFetchOperation,
+    InsertGraphAndFetchOperation,
 };